Leetcode 322: Coin Change - 动态规划

Description:

You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

Example 1:

Input: coins = [1, 2, 5], amount = 11
Output: 3
Explanation: 11 = 5 + 5 + 1

Example 2:

Input: coins = [2], amount = 3
Output: -1

Note:
You may assume that you have an infinite number of each kind of coin.

 

Solution（递推）

如果先for amount，则不可以用滚动数组的思想。

class Solution {
    public int coinChange(int[] coins, int amount) {
        int n = coins.length;
        if(n == 0){
            return 0;
        }
        int dp[] = new int[amount + 1];
        for(int i = 1; i <= amount; ++i){
            dp[i] = Integer.MAX_VALUE;
            for(int j = 0; j < n; ++j){
                if(coins[j] <= i && dp[i - coins[j]] != Integer.MAX_VALUE){
                    dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
                }
            }
        }
        if(dp[amount] == Integer.MAX_VALUE)
            return -1;
        else
            return dp[amount];
    }
}

Solution（递推 + 滚动数组）

class Solution {
    public int coinChange(int[] coins, int amount) {
        int n = coins.length;
        if(n == 0) //没有coins的时候，返回0
            return 0;
        if(amount == 0) //不需要change coin的时候，返回0
            return 0;
        
        Arrays.sort(coins);
        if(coins[0] > amount)  //最小分值的coin还比amount大的时候，返回-1
            return -1;
        int index = n - 1;
        //找到比amount小的最大coin分值
        while(coins[index] > amount && index > 0){
            index--;
        }
        int dp[] = new int[coins[index] + 1];  //滚动数组思想
        for(int i = 1; i <= amount; ++i){
            dp[i % (coins[index] + 1)] = Integer.MAX_VALUE;
            for(int j = 0; j <= index; ++j){
                if(coins[j] <= i && dp[(i - coins[j]) % (coins[index] + 1)] != Integer.MAX_VALUE){
                    dp[i % (coins[index] + 1)] = Math.min(dp[i % (coins[index] + 1)], dp[(i - coins[j]) % (coins[index] + 1)] + 1);
                }
            }
        }
        if(dp[amount % (coins[index] + 1)] == Integer.MAX_VALUE)
            return -1;
        else
            return dp[amount % (coins[index] + 1)];
    }
}

Solution（递归）

class Solution {
    public int coinChange(int[] coins, int amount) {
        Arrays.sort(coins);

        int rval = smallestAmount(coins, amount, coins.length - 1, 0, Integer.MAX_VALUE);
        if (rval == Integer.MAX_VALUE) {
            return -1;
        }
        return rval;
    }

    private int smallestAmount(final int[] coins, final int amount, final int coinIndex, 
                               final int nCoins, int best)
    {
        final int denomination = coins[coinIndex];
        final int maxOfThis = amount / denomination;
        if (amount % denomination == 0) {
            int newWay = nCoins + maxOfThis;
            if (newWay < best) {
                return newWay;
            }
            return best;
        }

        if ((nCoins + maxOfThis + 1) >= best) {
            return best;
        }
        if (coinIndex > 0) {
            for (int i = maxOfThis; i >= 0 ; i--) {
                best = smallestAmount(coins,
                                      amount - (i * denomination),
                                      coinIndex - 1,
                                      nCoins + i,
                                      best);
            }
        }
        return best;
     }    
}