LeetCode322. 零钱兑换

322. 零钱兑换

---

一、题目

给你一个整数数组 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

提示：

• 1 <= coins.length <= 12
• 1 <= coins[i] <= 231 - 1
• 0 <= amount <= 104

二、题解

方法一：完全背包二维数组

这个问题可以看作是一个完全背包问题的变形，即每种硬币的数量是无限的，而不是有限的。

• 算法思路：

  • 首先，我们要定义一个二维数组 dp ，其中 dp[i][j] 表示用前 i+1 种硬币（即 coins[0] 到 coins[i]）凑成金额 j 所需的最少硬币个数。

  • 然后，我们要初始化 dp 数组，对于第一种硬币 coins[0] ，我们只需要看金额 j 是否能被它整除，如果能，那么 dp[0][j] = j / coins[0] ，否则 dp[0][j] = INT_MAX （表示无法凑成）。

  • 接下来，我们要逐行更新 dp 数组，对于第 i+1 种硬币 coins[i] ，我们有两种选择：使用它或者不使用它。如果不使用它，那么 dp[i][j] = dp[i-1][j] ，即和前 i 种硬币的结果一样；如果使用它，那么我们要保证金额 j 大于等于硬币面额 coins[i] ，并且减去这个面额后的金额能够被前 i+1 种硬币凑成，即 dp[i][j-coins[i]] != INT_MAX ，那么 dp[i][j] = dp[i][j-coins[i]] + 1 ，即在减去这个面额后的结果上加一。我们要在这两种选择中取最小值，即 dp[i][j] = min(dp[i-1][j], dp[i][j-coins[i]] + 1) 。

  • 最后，我们要返回 dp[coins.size() - 1][amount] ，即用所有种类的硬币凑成总金额所需的最少硬币个数。如果这个值等于 INT_MAX ，说明无法凑成，返回 -1 ；否则返回这个值。

• 具体实现：

  • 可以用一个嵌套的循环来实现上述算法思路，外层循环遍历硬币种类，内层循环遍历金额。每次更新 dp[i][j] 时，先赋值为不使用当前硬币的结果，然后判断是否可以使用当前硬币，并更新为最小值。

  • 我们还需要注意一些边界情况，比如当金额为零时，返回零；当硬币数组为空时，返回 -1 。

  class Solution {
  public:
      int coinChange(vector<int>& coins, int amount) {
          if (amount == 0) return 0;
          vector<vector<int>> dp(coins.size(), vector<int>(amount + 1, INT_MAX));
  
          // 初始化
          for (int i = 0; i <= amount; i++) {
              if (i % coins[0] == 0) {
                  dp[0][i] = i / coins[0];
              }
          }
  
          for (int i = 1; i < coins.size(); i++) {
              for (int j = 0; j <= amount; j++) {
                  dp[i][j] = dp[i - 1][j];
                  if (j >= coins[i] && dp[i][j - coins[i]]!=INT_MAX) {
                      dp[i][j] = min(dp[i][j], dp[i][j - coins[i]] + 1);
                  }
              }
          }
  
          return dp[coins.size() - 1][amount] == INT_MAX? -1 : 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

• 算法分析：

  • 时间复杂度：O(N*M)，其中 N 是硬币种类数，M 是总金额。我们需要遍历所有的硬币和金额组合，每次更新一个状态值。

  • 空间复杂度：O(N*M)，其中 N 是硬币种类数，M 是总金额。需要一个二维数组来存储所有的状态值。

方法二：一维数组

算法思路和具体实现和上面的二维数组差不多，不过我也copy了一下~

• 算法思路：

  • 首先，我们定义一个一维数组 dp ，其中 dp[j] 表示凑成金额 j 所需的最少硬币个数。
  • 然后，我们初始化 dp 数组，对于金额为零的情况，我们不需要任何硬币，所以 dp[0] = 0 。对于其他金额，我们先设为一个很大的数，比如 INT_MAX ，表示无法凑成。
  • 接下来，我们遍历每种硬币 coins[i] ，对于每种硬币，我们从小到大遍历金额 j ，如果 j >= coins[i] ，说明我们可以用这种硬币来凑成金额 j ，那么我们就比较使用这种硬币和不使用这种硬币的结果，取最小值，即 dp[j] = min(dp[j], dp[j - coins[i]] + 1) 。注意这里和 01 背包问题的区别，01 背包问题中只能用一次每种物品，所以要从大到小遍历金额，避免重复使用；而完全背包问题中可以用无限次每种物品，所以要从小到大遍历金额，允许重复使用。
  • 最后，我们返回 dp[amount] ，即凑成总金额所需的最少硬币个数。如果这个值等于 INT_MAX ，说明无法凑成，返回 -1 ；否则返回这个值。

• 具体实现：

  • 这个代码和上一个代码的区别在于，它只用了一个一维数组来存储状态值，而不是一个二维数组。这样做的原因是，对于每种硬币，我们只需要知道上一行的状态值就可以更新当前行的状态值，所以我们可以用一个一维数组来代替二维数组，节省空间。
  • 我们可以用一个嵌套的循环来实现上述算法思路，外层循环遍历硬币种类，内层循环遍历金额。每次更新 dp[j] 时，先判断是否可以使用当前硬币，并更新为最小值。
  • 我们还需要注意一些边界情况，比如当金额为零时，返回零；当硬币数组为空时，返回 -1 。

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

• 算法分析：

  • 时间复杂度：O(N*M)，其中 N 是硬币种类数，M 是总金额。我们需要遍历所有的硬币和金额组合，每次更新一个状态值。
  • 空间复杂度：O(M)，其中 M 是总金额。我们只需要一个一维数组来存储状态值。

三、注意

这道题不在乎硬币是排列还是组合，是因为我们只关心最少的硬币个数，而不关心硬币的顺序。换句话说，我们只要找到一种硬币组合，使得它的总金额等于目标金额，并且硬币个数最少，那么这种组合就是最优解，无论它的硬币顺序如何。例如，如果目标金额是 11 ，硬币面额是 [1, 2, 5] ，那么无论是 [5, 5, 1] 还是 [1, 5, 5] ，都是最优解，因为它们都只用了 3 个硬币。所以，不需要考虑排列和组合的区别，只需要考虑状态转移的逻辑。