【数据结构与算法】动态规划 零钱兑换

• 第一种暴力 dfs 但是超时

class Solution {
    int ans = -1;
    public int coinChange(int[] coins, int amount) {
        // dfs(coins,amount,0,0);
        return ans;
    }
    
    public void dfs(int[] coins, int amount, int index,int count) {
        if(index==coins.length || amount<0){
            return;
        }
        if(amount==0){
            if(ans==-1){
                ans = count;
            }else{
                ans = Math.min(ans,count);
            }
        }
        //不选,下一个
        dfs(coins,amount,index+1,count);
        //选
        dfs(coins,amount-coins[index],index,count+1);
    }
}

动态规划可以解决

```java
class Solution {
    public int coinChange(int[] coins, int amount) {
        //dp[i]表示 兑换零钱i需要的最小次数
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, 100000);
        dp[0] = 0;
        for (int i = 1; i <= amount; i++) {
            //零钱i 是从前面的i-coins[j]来的，所以dp[i]取 满足条件的dp[j]+1中的最小值就可以了
            for (int j = 0; j < coins.length; j++) {
                if (i - coins[j] >= 0) {
                    dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }
        return dp[amount]==100000?-1:dp[amount];
    }
}