[leetcode]Coin Change

最新推荐文章于 2020-05-18 23:50:55 发布

jliang981

最新推荐文章于 2020-05-18 23:50:55 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏： acm 文章标签： acm

本文链接：https://blog.youkuaiyun.com/liang0000zai/article/details/51254584

acm 专栏收录该内容

63 篇文章

订阅专栏

本文介绍了两种解决硬币找零问题的方法：递归法和动态规划法。递归法直观但效率较低，容易超时；动态规划法则从底层开始逐步构建解决方案，确保了较高的效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.只提供一种递归的思路，从上到下解决问题，没有完全优化，会超时。

public class Solution {
    public int coinChange(int[] coins, int amount) {
        Arrays.sort(coins);//jdk降序排列
        int len=coins.length;
        int total=0,pos=len-1;
        total=count(coins,pos,amount);
        return total;
    }
    
    private int count(int[] coins,int pos,int  amount){
        if( amount<0 ){
            return -1;            
        }
        if(amount %  coins[pos] == 0 ){
            return amount/coins[pos];
        }
        int tmp=-2,min=0x10000000;
        for(int i=pos;i>=0;i-- ){
            int ct=count(coins,i,amount-coins[i]);
            if(ct>=0 && ct<min){
                min=ct;
            }
        }
        if(min != 0x10000000 ){
            tmp+=min+2;
        }
        return tmp+1;
    }
}

下面是采用动态规划，从底到上的思想。

public class Solution {
    public int coinChange(int[] coins, int amount) {
        if(amount==0)
            return 0;
        int[] min=new int[amount+1];
        Arrays.sort(coins);
        int len=coins.length;
        // for(int i=0;i<len;i++){
        //     min[coins[i]]=1;
        // }
        for(int i=coins[0];i<=amount;i++ ){
            int t = 0x10000000;
            for(int j=len-1;j>=0;j--){
                if(i-coins[j] == 0){
                    min[i]=1;
                    break;
                }
                else if( i-coins[j] >0  && min[i-coins[j]]>0 &&  min[i-coins[j]] <t){
                       t=min[i-coins[j]];
                }
            }
            if(t!=0x10000000)
                min[i]=t+1;
        }
        if(min[amount] == 0)
            return -1;
        return min[amount];
    }
}