322. Coin Change

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:
coins = [1, 2, 5], amount = 11
return 3 (11 = 5 + 5 + 1)

Example 2:
coins = [2], amount = 3

return -1.

题意：给定一个数组和一个amount，数组中每个元素可以取若干个，请问使得取出元素之和为amount，至少需要取多少个元素（同一个元素取多次需要重复计算个数）。

这道题第一想法是使用动态规划去做，我们定义一个dp数组，dp[i][j]表示从数组前i+1个元素中取，和为j+1至少需要取多少个。

那么递推规律为：

数组第i+1个元素取0次，dp[i-1][j]

数组第i+1个元素取1次，dp[i-1][j-数组中第i+1个元素的值]+1

数组第i+1个元素取2次，dp[i-1][j-数组中第i+1个元素的值*2]+2

……

数组第i+1个元素取m次，dp[i-1][j-数组中第i+1个元素的值*m]+m（其中m等于j+1除以数组中第i+1个元素的值取整）

dp[i][j]= 上面这些值的最小值

最后得到的dp[coins.length-1][amount-1]即为我们所求

下面贴代码：

public class Solution {
    public int coinChange(int[] coins, int amount) {
        Arrays.sort(coins);
        if(amount==0) return 0;
        if(amount<coins[0]) return -1;
        int[][] dp = new int[coins.length][amount];
        for(int i=0;i<amount;i++){    //初始化dp数组
            if(i+1 < coins[0]) dp[0][i] = -1;
            else{
                if((i+1)%coins[0] == 0)
                    dp[0][i] = (i+1)/coins[0];
                else
                    dp[0][i] = -1;
            }
        }
        for(int i=1;i<coins.length;i++){    //计算dp数组
            for(int j=0;j<amount;j++){
                if((j+1)%coins[i] == 0)
                    dp[i][j] = (j+1)/coins[i];
                else{
                    int num = (j+1)/coins[i];
                    dp[i][j] = amount+1;
                    for(int k=0;k<=num;k++){
                        if(dp[i-1][j-k*coins[i]] != -1){
                            dp[i][j] = Math.min(dp[i][j],dp[i-1][j-k*coins[i]]+k);
                        }
                    }
                    if(dp[i][j]==amount+1) dp[i][j] = -1;
                }
            }
        }
        return dp[coins.length-1][amount-1];
    }
}

此种解法在LeetCode上是能够AC的，但是运行时间仅仅超过了5%左右，在上面的解法中我们使用了3层循环，显然效率比较低下。下面我们看一下第二种解法。

换一种思路来想一下，其实我们没有必要去定义一个二维的dp数组来存储之前的状态，用一维数组就能达到我们的目的：

我们定义一个一维数组dp[amount+1]，dp[i]表示元素和为i时，至少需要取多少个元素。那么递推规律为：

如果i大于等于数组第1个元素，dp[i] = Min（dp[i],dp[i-数组第1个元素]+1）

如果i大于等于数组第2个元素，dp[i] = Min（dp[i],dp[i-数组第2个元素]+1）

……

如果i大于等于数组最后1个元素，dp[i] = Min（dp[i],dp[i-数组最后1个元素]+1）

下面贴代码：

public class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount+1];
        Arrays.fill(dp,amount+1);  //初始化dp数组
        dp[0] = 0;
        for(int i=1;i<=amount;i++){
            for(int j=0;j<coins.length;j++){
                if(i>=coins[j]){
                    dp[i] = Math.min(dp[i],dp[i-coins[j]]+1);
                }
            }
        }
        if(dp[amount] == amount+1) dp[amount]=-1;    //考虑特殊情况
        return dp[amount];
    }
}