LeetCode 322. 零钱兑换【c++/java详细题解】_leetcode,求最少硬笔数java

1、题目

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

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

示例 1：

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

示例 2：

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

示例 3：

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

示例 4：

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

示例 5：

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

提示：

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

2、思路

(动态规划，完全背包问题) $O(nm)$

完全背包问题。

相当于有n 种物品，每种物品的体积是硬币面值，价值是1，每种物品可用无限次。问装满背包最少需要多少价值的物品？

先考虑二维状态

状态表示： f[i][j] 表示从前i种硬币中选，且总金额恰好为j的所需要的最少硬币数。

那么f[n][amount]就表示表示 从前n种硬币中选，且总金额恰好为amount的所需要的最少硬币数，即为答案。

集合划分：

按照第i种硬币可以选 0个,1个，2个，3个，，，，k个划分集合 f[i][j]。其中k*w[i] <= j,也就是说在背包能装下的情况下，枚举第i种硬币可以选择几个。

不使用第i种硬币，状态表示: f[i-1][j]

使用第i种硬币，假设我们使用k个(容量允许的情况下)，状态表示：min(f[i-1][j - k*coin]) + k

状态计算方程：

f[i][j] = min(f[i-1][j],f[i-1][j-coins[i]] + 1,f[i-1][j-2*coins[i]] + 2,......,f[i-1][j-k*coins[i]] + k) .

初始化条件:

f[0][0]=0，其余f[0][j] = INF，表示当没有任何硬币的时候，存在凑成总和为 0 的方案，方案所使用的硬币为 0；凑成其他总和的方案不存在。

3、c++代码

class Solution {
public:
    int INF = 1000000000;
    int coinChange(vector<int>& coins, int amount) {
         int n = coins.size();
         vector<vector<int>> f (n + 1, vector<int>(amount + 1, INF));

         f[0][0] = 0;   
         for(int i = 1; i <= n; i++)
         {
         	int val = coins[i-1];
            for(int j = 0; j <= amount; j++)
                for(int k = 0; k*val <= j; k++)
                {
                    f[i][j] = min(f[i][j] , f[i-1][j-k*val] + k);
                }
         }	 
        if (f[n][amount] == INF) f[n][amount] = -1;
        return f[n][amount];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4、java代码

class Solution {
    int INF = 1000000000;
    public int coinChange(int[] coins, int amount) {
        int n = coins.length;
        int[][] f = new int[n + 1][amount + 1];

        for (int i = 0; i <= n; i++) 
            for(int j = 0; j <= amount; j++)
               f[i][j] = INF;
        f[0][0] = 0;
        for (int i = 1; i <= n; i++) {
            int val = coins[i - 1];
            for (int j = 0; j <= amount; j++) {
                for (int k = 0; k * val <= j; k++) {
                      f[i][j] = Math.min(f[i][j], f[i-1][j-k*val] + k);
                    }
                }
        }
        if (f[n][amount] == INF) f[n][amount] = -1;
        return f[n][amount];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

时间复杂度分析： 共有 $n\ast amount$ 个状态需要转移，每个状态转移最多遍历$amount$次。整体复杂度为$O(n\ast amoun{t}^2)$

超出时间限制，考虑一维优化。

5、一维优化

v代表第i件物品的体积(面值)

f[i][j] = min( f[i-1][j],f[i-1][j-v] + 1,f[i-1][j-2v] + 2......f[i-1][j-kv] + k)

f[i][j-v] + 1 = min(f[i-1,[j-v] + 1,f[i-1][j-2v] + 2......,f[i-1][j-kv] + k)

因此：

f[i][j] = min(f[i-1][j],f[i][j-v] + 1)

图示：

去掉一维：

状态计算方程为: f[j] = min([j],[j-v] + 1)

物品的体积即硬币面值: f[j] = min([j],[j-coins[i]] + 1)

时间复杂度分析：令 n 表示硬币种数，m 表示总价钱，则总共两层循环，所以时间复杂度是 $O(nm)$。

6、c++代码2

class Solution {
public:

    int INF = 1000000000;

    int coinChange(vector<int>& coins, int amount) {
        vector<int> f(amount + 1, INF);
        f[0] = 0;
        for (int i = 0; i < coins.size(); i ++ )
            for (int j = coins[i]; j <= amount; j ++ )
                f[j] = min(f[j], f[j - coins[i]] + 1);
        if (f[amount] == INF) f[amount] = -1;
        return f[amount] ;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7、java代码2

public class Solution {
    int INF = 1000000000;
    public int coinChange(int[] coins, int amount) {
        int[] f = new int[amount + 1];
        Arrays.fill(f, max);
        f[0] = 0;
        for (int i = 0; i < coins.size(); i ++ )
            for (int j = coins[i]; j <= amount; j ++ )
                    f[i] = Math.min(f[i], f[i - coins[j]] + 1);
                }
            }
        }
        if (f[amount] == INF) f[amount] = -1;
        return f[amount] ;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

原题链接：322. 零钱兑换