LeetCode518. 零钱兑换 II 以及 动态规划相关的排列组合问题

---

一、题目

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

示例 1：

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1
1
2
3
4
5
6
7

示例 2：

输入：amount = 3, coins = [2]
输出：0
解释：只用面额 2 的硬币不能凑成总金额 3 。
1
2
3

示例 3：

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

提示：

• 1 <= coins.length <= 300
• 1 <= coins[i] <= 5000
• coins 中的所有值 互不相同
• 0 <= amount <= 5000

二、题解

方法一：完全背包问题的变体（版本1）

题目理解

这道题目是一个动态规划问题，需要计算凑成总金额的硬币组合数。给定一组硬币的面额数组 coins 和一个总金额 amount，要求计算有多少种不同的组合方式来凑成总金额。每个硬币的面额都可以被使用无限次。

动态规划思路

我们可以将硬币问题与完全背包问题联系起来：

• 将硬币的面额视为物品的重量。
• 将总金额视为背包的容量。
• 将计算硬币组合数的问题视为在完全背包问题中计算组合数量的变种。

1. 定义状态

我们需要定义一个状态来表示问题的子问题和最优解。在这个问题中，我们可以使用二维数组 dp[i][j] 来表示前 i 种硬币组成总金额 j 的组合数。其中，i 表示考虑的硬币种类数量，j 表示总金额。

2. 初始化状态

我们需要初始化状态数组 dp，确保其初始值是正确的。在这里，可以看到 dp[i][0] 应该初始化为0，因为没有硬币可供选择。当 i % coins[0] == 0时dp[0][i] 应该初始化为1，因为i可以由整数个第一个硬币组成。

3. 状态转移方程

接下来，我们需要找到状态之间的转移关系，即如何从子问题的最优解推导出原问题的最优解。在这个问题中，状态转移方程如下：

• 如果当前总金额 j 小于硬币面额 coins[i]，则无法将硬币 i 加入组合，所以 dp[i][j] = dp[i-1][j]，表示不使用硬币 i。
• 如果 j 大于等于硬币面额 coins[i]，我们可以选择使用硬币 i 或者不使用。因此，dp[i][j] 等于两者之和：
  • 不使用硬币 i，即 dp[i-1][j]。
  • 使用硬币 i，即 dp[i][j - coins[i]]，这里的 dp[i][j - coins[i]] 表示在考虑硬币 i 时，总金额减去硬币 i 的面额后的组合数。

4. 填充状态表格

通过上述状态转移方程，我们可以通过双重循环遍历所有的子问题，从而填充状态表格 dp。外层循环遍历硬币种类 i，内层循环遍历总金额 j，根据状态转移方程更新 dp[i][j]。

5. 获取最终答案

最后，我们可以通过 dp[coins.size() - 1][amount] 来获取问题的最终答案，即考虑了所有硬币种类并且总金额为 amount 时的组合数。

代码解析

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<vector<int>> dp(coins.size(), vector<int>(amount + 1, 0));
        for (int i = 0; i <= amount; i++) {
            if (i % coins[0] == 0) {
                dp[0][i] = 1;
            }
        }
        for (int i = 1; i < coins.size(); i++) {
            for (int j = 0; j <= amount; j++) {
                if (j < coins[i]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]];
                }
            }
        }
        return dp[coins.size() - 1][amount];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1. 创建一个二维数组 dp，其中 dp[i][j] 表示前 i 种硬币组成总金额 j 的组合数。

2. 初始化 dp[0][j]，即考虑只有一种硬币时，对应总金额 j 的组合数。如果 j 可以被第一种硬币整除，那么 dp[0][j] 初始化为1，表示有一种组合方式，即只使用第一种硬币。

3. 通过嵌套的循环遍历硬币种类 i 和总金额 j，根据状态转移方程更新 dp[i][j]。如果 j 小于硬币面额 coins[i]，则 dp[i][j] 等于 dp[i-1][j]，否则 dp[i][j] 等于 dp[i-1][j] + dp[i][j - coins[i]]。

4. 最后返回 dp[coins.size() - 1][amount]，即考虑了所有硬币种类并且总金额为 amount 时的组合数。

方法二：完全背包问题变体（版本2）

1. 定义状态

首先，我们需要定义一个状态，来表示问题的子问题和最优解。在这个问题中，我们可以使用一维数组 dp，其中 dp[i] 表示总金额 i 的组合方式数量。

2. 初始化状态

接下来，我们需要初始化状态数组 dp，确保其初始值是正确的。在这里，可以看到 dp[0] 应该初始化为1，因为总金额为0时，只有一种组合方式，那就是什么硬币都不选。

3. 状态转移方程

然后，我们需要找到状态之间的转移关系，即如何从子问题的最优解推导出原问题的最优解。状态转移方程如下：

• 对于每个硬币面额 coins[i]，我们可以选择使用该硬币或不使用。
• 如果我们选择使用硬币 coins[i]，那么 dp[j] 应该等于 dp[j] + dp[j - coins[i]]，表示在考虑硬币 coins[i] 时，总金额 j 的组合方式数量应该加上总金额 j - coins[i] 的组合方式数量。
• 如果我们选择不使用硬币 coins[i]，那么 dp[j] 保持不变。

4. 填充状态数组

通过上述状态转移方程，我们可以通过循环遍历所有的子问题，从而填充状态数组 dp。外层循环遍历硬币的面额 i，内层循环遍历总金额 j，根据状态转移方程更新 dp[j]。

5. 获取最终答案

最后，我们可以通过 dp[amount] 来获取问题的最终答案，即总金额为 amount 时的组合方式数量。

代码解析

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount+1,0);
        dp[0] = 1;
        for(int i = 0; i < coins.size(); i++){
            for(int j = coins[i]; j <= amount; j++){
                dp[j] += dp[j-coins[i]];
            }
        }
        return dp[amount];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

1. 创建一个一维数组 dp，其中 dp[i] 表示总金额 i 的组合方式数量。

2. 初始化 dp[0] 为1，因为总金额为0时，只有一种组合方式，即不选硬币。

3. 通过嵌套的循环遍历硬币面额 coins[i] 和总金额 amount，根据状态转移方程 dp[j] += dp[j - coins[i]] 来更新 dp[j]。这表示在考虑硬币 coins[i] 时，总金额 j 的组合方式数量应该加上总金额 j - coins[i] 的组合方式数量。

4. 最后返回 dp[amount]，即总金额为 amount 时的组合方式数量。

二维数组版本

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<vector<int>> dp(coins.size(), vector<int>(amount + 1, 0));
        
        // 初始化第一行，当金额为0时，有1种方式，即不选择任何硬币
        for (int i = 0; i < coins.size(); i++) {
            dp[i][0] = 1;
        }
        
        for (int i = 0; i < coins.size(); i++) {
            for (int j = 1; j <= amount; j++) {
                // 如果当前硬币面值大于金额j，则不能选择当前硬币，直接继承上一种方式的数量
                if (coins[i] > j) {
                    if (i > 0) {
                        dp[i][j] = dp[i - 1][j];
                    }
                } else {
                    // 否则，可以选择当前硬币或不选择当前硬币
                    if (i > 0) {
                        dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]];
                    } else {
                        dp[i][j] = dp[i][j - coins[i]];
                    }
                }
            }
        }
        
        return dp[coins.size() - 1][amount];
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

三、拓展：先遍历物品后遍历背包vs先遍历背包后遍历物品

先遍历物品后遍历背包（组合问题）

如果我们选择先遍历物品后遍历背包，那么我们的状态 dp[j] 表示的是总金额为 j 时的硬币组合数量。在这种情况下，我们考虑了每个硬币，并决定是否将其放入组合。这导致了我们计算的是硬币的组合数量，而不考虑硬币的排列顺序。

#include 
#include 
using namespace std;

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount + 1, 0); // 初始化动态规划数组，dp[i] 表示凑成金额 i 的方法数
        dp[0] = 1; // 凑成金额为 0 的方法数为 1，因为什么都不选也是一种方法

        for (int i = 0; i < coins.size(); i++) {
            int coin = coins[i];
            for (int j = coin; j <= amount; j++) {
                // 如果当前硬币面额小于等于当前金额 j，可以考虑将该硬币加入方案
                // 当前 dp[j] 的值应该加上 dp[j-coin]，表示不使用这个硬币时的方法数
                dp[j] += dp[j - coin];
            }

            // 输出当前填写后的 dp 数组
            cout << "Coins: " << coin << " | DP Array: ";
            for (int k = 0; k <= amount; k++) {
                cout << dp[k] << " ";
            }
            cout << endl;
        }

        return dp[amount]; // 返回凑成目标金额的方法数
    }
};

int main() {
    Solution s;
    vector<int> coins = { 1, 2, 5 };
    int amount = 5;
    int result = s.change(amount, coins);
    cout << "Result: " << result << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

[注意]大多数格子由三行组成，第一行是推导出结果的公式，第三行是推导出的结果，第二行是组合方式。

先遍历背包后遍历物品（排列问题）

如果我们选择先遍历背包后遍历物品，那么我们的状态 dp[j] 表示的是总金额为 j 时的硬币排列数量。在这种情况下，我们考虑了每个背包容量，然后决定放入哪些硬币。这导致了我们计算的是硬币的排列数量，考虑了硬币的顺序。

注意：我写了两个版本，一个是一维数组，一个是二维数组，最直观的就是展现成二维数组。

一维数组

#include 
using namespace std;
#include 

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount + 1, 0);
        dp[0] = 1;
        
        for (int j = 0 ; j <= amount; j++) {
            for (int i = 0; i < coins.size(); i++) {
               if(j >= coins[i]) dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
};

int main()
{
    Solution s;
    vector<int> coins;
    coins.push_back(1); coins.push_back(2); coins.push_back(5);
    int result;
    result = s.change(5, coins);
    cout << "result:" << result << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

二维数组
下面这段代码中dp[j][i]的意义是背包为j大小时，最后一个放入价值为coins[i]硬币加上不放入该硬币（最后一个投入的硬币是从coins[0]到coins[i]之间的硬币）的方法种类总数。

#include 
#include 
using namespace std;

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<vector<int>> dp(amount+1,vector<int>(coins.size(),0)); 
        dp[0][0] = 1; 
        int j = 0;
        for (j = 0; j <=amount ; j++) {
            for (int i = 0; i <coins.size(); i++) {
                if( i > 0 ) dp[j][i] = dp[j][i - 1];
                if (j >= coins[i]) {
                    dp[j][i]+=dp[j - coins[i]][coins.size() - 1];
                }    
            }

            // 输出当前填写后的 dp 数组
            cout << "j（容量） " << j << " | DP Array: ";
            for (int k = 0; k < coins.size(); k++) {
                cout << dp[j][k] << " ";
            }
            cout << endl;
        }

        return dp[amount][coins.size()-1]; // 返回凑成目标金额的方法数
    }
};

int main() {
    Solution s;
    vector<int> coins = { 1, 2, 5 };
    int amount = 5;
    int result = s.change(amount, coins);
    cout << "Result: " << result << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

[注意]大多数格子由三行组成，第一行是推导出结果的公式，第三行是推导出的结果，第二行是排列方式。

转置这个矩阵（如果看上面矩阵不顺眼）

#include 
#include 
using namespace std;

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<vector<int>> dp(coins.size(), vector<int>(amount + 1, 0));
        dp[0][0] = 1;
        int i = 0;
        for (i = 0; i <= amount; i++) {
            for (int j = 0; j < coins.size(); j++) {
                if (j > 0) dp[j][i] = dp[j-1][i];
                if (i >= coins[j]) {
                    dp[j][i] += dp[coins.size()-1][i-coins[j]];
                }
            }
        }
        for (int i = 0; i < coins.size(); i++) {
            for (int j = 0; j <= amount; j++) {
                cout << dp[i][j] << " ";
            }
            cout << endl;
        }
        return dp[coins.size() - 1][amount]; // 返回凑成目标金额的方法数
    }
};

int main() {
    Solution s;
    vector<int> coins = { 1, 2, 5 };
    int amount = 5;
    int result = s.change(amount, coins);
    cout << "Result: " << result << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37