【动态规划】零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

你可以认为每种硬币的数量是无限的。

 

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1

示例 2：

输入：coins = [2], amount = 3
输出：-1

示例 3：

输入：coins = [1], amount = 0
输出：0

示例 4：

输入：coins = [1], amount = 1
输出：1

示例 5：

输入：coins = [1], amount = 2
输出：2
 

提示：

1 <= coins.length <= 12
1 <= coins[i] <= 2^31 - 1
0 <= amount <= 10^4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/coin-change
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

法一，自下而上动态规划（自己想出来了不容易）

class Solution {
    public int coinChange(int[] coins, int amount) {
        if(amount==0)return 0;
        if(coins.length==1)return amount%coins[0]==0?amount/coins[0]:-1;
 
        int dp[]=new int[amount+1];
        Arrays.fill(dp,amount+1);
        dp[0]=0;
        
        for(int i=1;i<=amount;i++){
            for(int j=0;j<coins.length;j++){
                if (coins[j] <= i) {
                    dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }
        //注意return的时候判断一下是否有更新过
        return dp[amount] > amount ? -1 : dp[amount];
    }
}

法二，dfs+剪枝

居然比动态规划快。多考虑剪枝条件

class Solution {
    int ans=Integer.MAX_VALUE;
    public int coinChange(int[] coins, int amount) {
        Arrays.sort(coins);//以后降序排序直接用倒叙索引更省事
        dfs(coins,coins.length-1,amount,0);
        return ans==Integer.MAX_VALUE?-1:ans;
    }
    public void dfs(int[] coins,int index,int amount,int cnt){
        if(index<0){
            return;
        }
        for(int c=amount/coins[index];c>=0;c--){//从最大的硬币开始，c是这个最大硬币使用的次数
            int rest=amount-c*coins[index];//使用c枚当前硬币后剩下的余额
            int next_cnt=cnt+c;//使用这c枚硬币后的总数
            if(rest==0){//直接return
                ans=Math.min(ans,next_cnt);
                return;//剪枝1
            }
            if(next_cnt+1>=ans){
                return; //剪枝2,rest 不为 0，至少还要使用 1 枚硬币，则继续搜索得到的答案不会更优。
            }
            dfs(coins,index-1,rest,next_cnt);
        }
    }
}