build

chapter_dynamic_programming/dp_problem_features.md

@@ -18,7 +18,7 @@ comments: true
 
 如下图所示，若第 $1$ , $2$ , $3$ 阶的代价分别为 $1$ , $10$ , $1$ ，则从地面爬到第 $3$ 阶的最小代价为 $2$ 。
 
-![爬到第 3 阶的最小代价](intro_to_dynamic_programming.assets/min_cost_cs_example.png)
+![爬到第 3 阶的最小代价](dp_problem_features.assets/min_cost_cs_example.png)
 
 <p align="center"> Fig. 爬到第 3 阶的最小代价 </p>
 
@@ -159,7 +159,7 @@ $$
     [class]{}-[func]{minCostClimbingStairsDP}
     ```
 
-![爬楼梯最小代价的动态规划过程](intro_to_dynamic_programming.assets/min_cost_cs_dp.png)
+![爬楼梯最小代价的动态规划过程](dp_problem_features.assets/min_cost_cs_dp.png)
 
 <p align="center"> Fig. 爬楼梯最小代价的动态规划过程 </p>
 
@@ -289,7 +289,7 @@ $$
 
 例如，爬上第 $3$ 阶仅剩 $2$ 种可行方案，其中连续三次跳 $1$ 阶的方案不满足约束条件，因此被舍弃。
 
-![带约束爬到第 3 阶的方案数量](intro_to_dynamic_programming.assets/climbing_stairs_constraint_example.png)
+![带约束爬到第 3 阶的方案数量](dp_problem_features.assets/climbing_stairs_constraint_example.png)
 
 <p align="center"> Fig. 带约束爬到第 3 阶的方案数量 </p>
 
@@ -311,7 +311,7 @@ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2]
 \end{cases}
 $$
 
-![考虑约束下的递推关系](intro_to_dynamic_programming.assets/climbing_stairs_constraint_state_transfer.png)
+![考虑约束下的递推关系](dp_problem_features.assets/climbing_stairs_constraint_state_transfer.png)
 
 <p align="center"> Fig. 考虑约束下的递推关系 </p>
 

chapter_dynamic_programming/dp_solution_pipeline.md

@@ -97,14 +97,14 @@ $$
 
     边界条件即初始状态，在搜索中用于剪枝，在动态规划中用于初始化 $dp$ 表。状态转移顺序的核心是要保证在计算当前问题时，所有它依赖的更小子问题都已经被正确地计算出来。
 
-最后，我们基于以上结果实现解法即可。熟练度较高同学可以直接写出动态规划解法，初学者可以按照“暴力搜索 $\rightarrow$ 记忆化搜索 $\rightarrow$ 动态规划” 的顺序实现。
+接下来，我们就可以实现动态规划代码了。然而，由于子问题分解是一种从顶至底的思想，因此按照“暴力搜索 $\rightarrow$ 记忆化搜索 $\rightarrow$ 动态规划”的顺序实现更加符合思维习惯。
 
 ## 13.3.3.   方法一：暴力搜索
 
 从状态 $[i, j]$ 开始搜索，不断分解为更小的状态 $[i-1, j]$ 和 $[i, j-1]$ ，包括以下递归要素：
 
 - **递归参数**：状态 $[i, j]$ ；**返回值**：从 $[0, 0]$ 到 $[i, j]$ 的最小路径和 $dp[i, j]$ ；
-- **终止条件**：当 $i = 0$ 且 $j = 0$ 时，返回代价 $grid[0][0]$ ；
+- **终止条件**：当 $i = 0$ 且 $j = 0$ 时，返回代价 $grid[0, 0]$ ；
 - **剪枝**：当 $i < 0$ 时或 $j < 0$ 时索引越界，此时返回代价 $+\infty$ ，代表不可行；
 
 === "Java"

chapter_dynamic_programming/knapsack_problem.md

@@ -28,7 +28,7 @@ comments: true
 
 状态 $[i, c]$ 对应的子问题为：**前 $i$ 个物品在剩余容量为 $c$ 的背包中的最大价值**，记为 $dp[i, c]$ 。
 
-至此，我们得到一个尺寸为 $n \times cap$ 的二维 $dp$ 矩阵。
+需要求解的是 $dp[n, cap]$ ，因此需要一个尺寸为 $(n+1) \times (cap+1)$ 的二维 $dp$ 表。
 
 **第二步：找出最优子结构，进而推导出状态转移方程**
 
@@ -51,6 +51,10 @@ $$
 
 当前状态 $[i, c]$ 从上方的状态 $[i-1, c]$ 和左上方的状态 $[i-1, c-wgt[i-1]]$ 转移而来，因此通过两层循环正序遍历整个 $dp$ 表即可。
 
+!!! tip
+
+    完成以上三步后，我们可以直接实现从底至顶的动态规划解法。而为了展示本题包含的重叠子问题，本文也同时给出从顶至底的暴力搜索和记忆化搜索解法。
+
 ## 13.4.1.   方法一：暴力搜索
 
 搜索代码包含以下要素：
@@ -346,7 +350,7 @@ $$
 
 ## 13.4.3.   方法三：动态规划
 
-动态规划解法本质上就是在状态转移中填充 `dp` 矩阵的过程，代码如下所示。
+动态规划解法本质上就是在状态转移中填充 $dp$ 表的过程，代码如下所示。
 
 === "Java"
 
@@ -482,7 +486,7 @@ $$
     [class]{}-[func]{knapsackDP}
     ```
 
-如下图所示，时间复杂度由 `dp` 矩阵大小决定，为 $O(n \times cap)$ 。
+如下图所示，时间复杂度由数组 `dp` 大小决定，为 $O(n \times cap)$ 。
 
 === "<1>"
     ![0-1 背包的动态规划过程](knapsack_problem.assets/knapsack_dp_step1.png)
@@ -526,9 +530,9 @@ $$
 === "<14>"
     ![knapsack_dp_step14](knapsack_problem.assets/knapsack_dp_step14.png)
 
-**最后考虑状态压缩**。以上代码中的 `dp` 矩阵占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略，有兴趣的同学可以自行实现。
+**最后考虑状态压缩**。以上代码中的数组 `dp` 占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略，有兴趣的同学可以自行实现。
 
-那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 $i$ 行时，该数组存储的仍然是第 $i-1$ 行的状态，为了避免左边区域的格子在状态转移中被覆盖，我们应采取倒序遍历。
+那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 $i$ 行时，该数组存储的仍然是第 $i-1$ 行的状态，**为了避免左方区域的格子在状态转移中被覆盖，应该采取倒序遍历**。
 
 以下动画展示了在单个数组下从第 $i=1$ 行转换至第 $i=2$ 行的过程。建议你思考一下正序遍历和倒序遍历的区别。
 
@@ -550,7 +554,7 @@ $$
 === "<6>"
     ![knapsack_dp_comp_step6](knapsack_problem.assets/knapsack_dp_comp_step6.png)
 
-如以下代码所示，我们仅需将 `dp` 矩阵的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。
+如以下代码所示，我们仅需将数组 `dp` 的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。
 
 === "Java"
 

chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -0,0 +1,909 @@
+---
+comments: true
+---
+
+# 13.5.   完全背包问题
+
+在本节，我们先求解 0-1 背包的一个变种问题：完全背包问题；再了解完全背包的一种特例问题：零钱兑换。
+
+## 13.5.1.   完全背包问题
+
+!!! question
+
+    给定 $n$ 种物品，第 $i$ 个物品的重量为 $wgt[i-1]$ 、价值为 $val[i-1]$ ，现在有个容量为 $cap$ 的背包，**每种物品可以重复选取**，问在不超过背包容量下背包中物品的最大价值。
+
+![完全背包问题的示例数据](unbounded_knapsack_problem.assets/unbounded_knapsack_example.png)
+
+<p align="center"> Fig. 完全背包问题的示例数据 </p>
+
+完全背包和 0-1 背包问题非常相似，**区别仅在于不限制物品的选择次数**。
+
+- 在 0-1 背包中，每个物品只有一个，因此将物品 $i$ 放入背包后，只能从前 $i-1$ 个物品中选择；
+- 在完全背包中，每个物品有无数个，因此将物品 $i$ 放入背包后，**仍可以从前 $i$ 个物品中选择**；
+
+这就导致了状态转移的变化，对于状态 $[i, c]$ 有：
+
+- **不放入物品 $i$** ：与 0-1 背包相同，转移至 $[i-1, c]$ ；
+- **放入物品 $i$** ：状态转移至 $[i, c-wgt[i-1]]$ 而非 0-1 背包的 $[i-1, c-wgt[i-1]]$ ；
+
+因此状态转移方程变为：
+
+$$
+dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
+$$
+
+对比两道题目的动态规划代码，状态转移中有一处从 $i-1$ 变为 $i$ ，其余完全一致。
+
+=== "Java"
+
+    ```java title="unbounded_knapsack.java"
+    /* 完全背包：动态规划 */
+    int unboundedKnapsackDP(int[] wgt, int[] val, int cap) {
+        int n = wgt.length;
+        // 初始化 dp 表
+        int[][] dp = new int[n + 1][cap + 1];
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[i][c] = dp[i - 1][c];
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[n][cap];
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="unbounded_knapsack.cpp"
+    /* 完全背包：动态规划 */
+    int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
+        int n = wgt.size();
+        // 初始化 dp 表
+        vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[i][c] = dp[i - 1][c];
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[n][cap];
+    }
+    ```
+
+=== "Python"
+
+    ```python title="unbounded_knapsack.py"
+    def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
+        """完全背包：动态规划"""
+        n = len(wgt)
+        # 初始化 dp 表
+        dp = [[0] * (cap + 1) for _ in range(n + 1)]
+        # 状态转移
+        for i in range(1, n + 1):
+            for c in range(1, cap + 1):
+                if wgt[i - 1] > c:
+                    # 若超过背包容量，则不选物品 i
+                    dp[i][c] = dp[i - 1][c]
+                else:
+                    # 不选和选物品 i 这两种方案的较大值
+                    dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])
+        return dp[n][cap]
+    ```
+
+=== "Go"
+
+    ```go title="unbounded_knapsack.go"
+    [class]{}-[func]{unboundedKnapsackDP}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="unbounded_knapsack.js"
+    [class]{}-[func]{unboundedKnapsackDP}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="unbounded_knapsack.ts"
+    [class]{}-[func]{unboundedKnapsackDP}
+    ```
+
+=== "C"
+
+    ```c title="unbounded_knapsack.c"
+    [class]{}-[func]{unboundedKnapsackDP}
+    ```
+
+=== "C#"
+
+    ```csharp title="unbounded_knapsack.cs"
+    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDP}
+    ```
+
+=== "Swift"
+
+    ```swift title="unbounded_knapsack.swift"
+    [class]{}-[func]{unboundedKnapsackDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="unbounded_knapsack.zig"
+    [class]{}-[func]{unboundedKnapsackDP}
+    ```
+
+=== "Dart"
+
+    ```dart title="unbounded_knapsack.dart"
+    [class]{}-[func]{unboundedKnapsackDP}
+    ```
+
+由于当前状态是从左边和上边的状态转移而来，**因此状态压缩后应该对 $dp$ 表中的每一行采取正序遍历**，这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解为什么要改为正序遍历。
+
+=== "<1>"
+    ![unbounded_knapsack_dp_comp_step1](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step1.png)
+
+=== "<2>"
+    ![unbounded_knapsack_dp_comp_step2](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step2.png)
+
+=== "<3>"
+    ![unbounded_knapsack_dp_comp_step3](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step3.png)
+
+=== "<4>"
+    ![unbounded_knapsack_dp_comp_step4](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step4.png)
+
+=== "<5>"
+    ![unbounded_knapsack_dp_comp_step5](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step5.png)
+
+=== "<6>"
+    ![unbounded_knapsack_dp_comp_step6](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step6.png)
+
+代码实现比较简单，仅需将数组 `dp` 的第一维删除。
+
+=== "Java"
+
+    ```java title="unbounded_knapsack.java"
+    /* 完全背包：状态压缩后的动态规划 */
+    int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
+        int n = wgt.length;
+        // 初始化 dp 表
+        int[] dp = new int[cap + 1];
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[c] = dp[c];
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="unbounded_knapsack.cpp"
+    /* 完全背包：状态压缩后的动态规划 */
+    int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
+        int n = wgt.size();
+        // 初始化 dp 表
+        vector<int> dp(cap + 1, 0);
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[c] = dp[c];
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
+    ```
+
+=== "Python"
+
+    ```python title="unbounded_knapsack.py"
+    def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
+        """完全背包：状态压缩后的动态规划"""
+        n = len(wgt)
+        # 初始化 dp 表
+        dp = [0] * (cap + 1)
+        # 状态转移
+        for i in range(1, n + 1):
+            # 正序遍历
+            for c in range(1, cap + 1):
+                if wgt[i - 1] > c:
+                    # 若超过背包容量，则不选物品 i
+                    dp[c] = dp[c]
+                else:
+                    # 不选和选物品 i 这两种方案的较大值
+                    dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])
+        return dp[cap]
+    ```
+
+=== "Go"
+
+    ```go title="unbounded_knapsack.go"
+    [class]{}-[func]{unboundedKnapsackDPComp}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="unbounded_knapsack.js"
+    [class]{}-[func]{unboundedKnapsackDPComp}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="unbounded_knapsack.ts"
+    [class]{}-[func]{unboundedKnapsackDPComp}
+    ```
+
+=== "C"
+
+    ```c title="unbounded_knapsack.c"
+    [class]{}-[func]{unboundedKnapsackDPComp}
+    ```
+
+=== "C#"
+
+    ```csharp title="unbounded_knapsack.cs"
+    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDPComp}
+    ```
+
+=== "Swift"
+
+    ```swift title="unbounded_knapsack.swift"
+    [class]{}-[func]{unboundedKnapsackDPComp}
+    ```
+
+=== "Zig"
+
+    ```zig title="unbounded_knapsack.zig"
+    [class]{}-[func]{unboundedKnapsackDPComp}
+    ```
+
+=== "Dart"
+
+    ```dart title="unbounded_knapsack.dart"
+    [class]{}-[func]{unboundedKnapsackDPComp}
+    ```
+
+## 13.5.2. &nbsp; 零钱兑换问题
+
+背包问题是一大类动态规划问题的代表，其拥有很多的变种，例如零钱兑换问题。
+
+!!! question
+
+    给定 $n$ 种硬币，第 $i$ 个硬币的面值为 $coins[i - 1]$ ，为目标金额 $amt$ ，**每种硬币可以重复选取**，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 $-1$ 。
+
+如下图所示，凑出 $11$ 元最少需要 $3$ 枚硬币，方案为 $1 + 2 + 5 = 11$ 。
+
+![零钱兑换问题的示例数据](unbounded_knapsack_problem.assets/coin_change_example.png)
+
+<p align="center"> Fig. 零钱兑换问题的示例数据 </p>
+
+**零钱兑换问题可以看作是完全背包问题的一种特殊情况**，两者具有以下联系与不同点：
+
+- 两道题可以相互转换，“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”；
+- 目标不同，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量；
+- 背包问题是求“不超过”背包容量下的解，零钱兑换是求“恰好”凑到目标金额的解；
+
+**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表**
+
+状态 $[i, a]$ 对应的子问题为：**前 $i$ 个硬币能够凑出金额 $a$ 的最少硬币个数**，记为 $dp[i, a]$ 。
+
+二维 $dp$ 表的尺寸为 $(n+1) \times (amt+1)$ 。
+
+**第二步：找出最优子结构，进而推导出状态转移方程**
+
+与完全背包的状态转移方程基本相同，不同点在于：
+
+- 本题要求最小值，因此需将运算符 $\max()$ 更改为 $\min()$ ；
+- 优化主体是“硬币数量”而非”商品价值“，因此在选中硬币时执行 $+1$ 即可；
+
+$$
+dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
+$$
+
+**第三步：确定边界条件和状态转移顺序**
+
+当目标金额为 $0$ 时，凑出它的最少硬币个数为 $0$ ，即所有 $dp[i, 0]$ 都等于 $0$ 。当无硬币时，**无法凑出任意 $> 0$ 的目标金额**，即是无效解。为使状态转移方程中的 $\min()$ 函数能够识别并过滤无效解，我们考虑使用 $+ \infty$ 来表示它们，即令所有 $dp[0, a]$ 都等于 $+ \infty$ 。
+
+以上做法仅适用于 Python 语言，因为大多数编程语言并未提供 $+ \infty$ 变量，所以只能使用整型 `int` 的最大值，而这又会导致大数越界：**当 $dp[i, a - coins[i-1]]$ 是无效解时，再执行 $+ 1$ 操作会发生溢出**。
+
+为解决该问题，我们采用一个不可能达到的大数字 $amt + 1$ 来表示无效解，因为凑出 $amt$ 的硬币个数最多为 $amt$ 个。
+
+在最后返回前，判断 $dp[n, amt]$ 是否等于 $amt + 1$ ，若是则返回 $-1$ ，代表无法凑出目标金额。
+
+=== "Java"
+
+    ```java title="coin_change.java"
+    /* 零钱兑换：动态规划 */
+    int coinChangeDP(int[] coins, int amt) {
+        int n = coins.length;
+        int MAX = amt + 1;
+        // 初始化 dp 表
+        int[][] dp = new int[n + 1][amt + 1];
+        // 状态转移：首行首列
+        for (int a = 1; a <= amt; a++) {
+            dp[0][a] = MAX;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a];
+                } else {
+                    // 不选和选硬币 i 这两种方案的较小值
+                    dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[n][amt] != MAX ? dp[n][amt] : -1;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="coin_change.cpp"
+    /* 零钱兑换：动态规划 */
+    int coinChangeDP(vector<int> &coins, int amt) {
+        int n = coins.size();
+        int MAX = amt + 1;
+        // 初始化 dp 表
+        vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
+        // 状态转移：首行首列
+        for (int a = 1; a <= amt; a++) {
+            dp[0][a] = MAX;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a];
+                } else {
+                    // 不选和选硬币 i 这两种方案的较小值
+                    dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[n][amt] != MAX ? dp[n][amt] : -1;
+    }
+    ```
+
+=== "Python"
+
+    ```python title="coin_change.py"
+    def coin_change_dp(coins: list[int], amt: int) -> int:
+        """零钱兑换：动态规划"""
+        n = len(coins)
+        MAX = amt + 1
+        # 初始化 dp 表
+        dp = [[0] * (amt + 1) for _ in range(n + 1)]
+        # 状态转移：首行首列
+        for a in range(1, amt + 1):
+            dp[0][a] = MAX
+        # 状态转移：其余行列
+        for i in range(1, n + 1):
+            for a in range(1, amt + 1):
+                if coins[i - 1] > a:
+                    # 若超过背包容量，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a]
+                else:
+                    # 不选和选硬币 i 这两种方案的较小值
+                    dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)
+        return dp[n][amt] if dp[n][amt] != MAX else -1
+    ```
+
+=== "Go"
+
+    ```go title="coin_change.go"
+    [class]{}-[func]{coinChangeDP}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="coin_change.js"
+    [class]{}-[func]{coinChangeDP}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="coin_change.ts"
+    [class]{}-[func]{coinChangeDP}
+    ```
+
+=== "C"
+
+    ```c title="coin_change.c"
+    [class]{}-[func]{coinChangeDP}
+    ```
+
+=== "C#"
+
+    ```csharp title="coin_change.cs"
+    [class]{coin_change}-[func]{coinChangeDP}
+    ```
+
+=== "Swift"
+
+    ```swift title="coin_change.swift"
+    [class]{}-[func]{coinChangeDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="coin_change.zig"
+    [class]{}-[func]{coinChangeDP}
+    ```
+
+=== "Dart"
+
+    ```dart title="coin_change.dart"
+    [class]{}-[func]{coinChangeDP}
+    ```
+
+下图展示了零钱兑换的动态规划过程。
+
+=== "<1>"
+    ![coin_change_dp_step1](unbounded_knapsack_problem.assets/coin_change_dp_step1.png)
+
+=== "<2>"
+    ![coin_change_dp_step2](unbounded_knapsack_problem.assets/coin_change_dp_step2.png)
+
+=== "<3>"
+    ![coin_change_dp_step3](unbounded_knapsack_problem.assets/coin_change_dp_step3.png)
+
+=== "<4>"
+    ![coin_change_dp_step4](unbounded_knapsack_problem.assets/coin_change_dp_step4.png)
+
+=== "<5>"
+    ![coin_change_dp_step5](unbounded_knapsack_problem.assets/coin_change_dp_step5.png)
+
+=== "<6>"
+    ![coin_change_dp_step6](unbounded_knapsack_problem.assets/coin_change_dp_step6.png)
+
+=== "<7>"
+    ![coin_change_dp_step7](unbounded_knapsack_problem.assets/coin_change_dp_step7.png)
+
+=== "<8>"
+    ![coin_change_dp_step8](unbounded_knapsack_problem.assets/coin_change_dp_step8.png)
+
+=== "<9>"
+    ![coin_change_dp_step9](unbounded_knapsack_problem.assets/coin_change_dp_step9.png)
+
+=== "<10>"
+    ![coin_change_dp_step10](unbounded_knapsack_problem.assets/coin_change_dp_step10.png)
+
+=== "<11>"
+    ![coin_change_dp_step11](unbounded_knapsack_problem.assets/coin_change_dp_step11.png)
+
+=== "<12>"
+    ![coin_change_dp_step12](unbounded_knapsack_problem.assets/coin_change_dp_step12.png)
+
+=== "<13>"
+    ![coin_change_dp_step13](unbounded_knapsack_problem.assets/coin_change_dp_step13.png)
+
+=== "<14>"
+    ![coin_change_dp_step14](unbounded_knapsack_problem.assets/coin_change_dp_step14.png)
+
+=== "<15>"
+    ![coin_change_dp_step15](unbounded_knapsack_problem.assets/coin_change_dp_step15.png)
+
+由于零钱兑换和完全背包的状态转移方程如出一辙，因此状态压缩方式也相同。
+
+=== "Java"
+
+    ```java title="coin_change.java"
+    /* 零钱兑换：状态压缩后的动态规划 */
+    int coinChangeDPComp(int[] coins, int amt) {
+        int n = coins.length;
+        int MAX = amt + 1;
+        // 初始化 dp 表
+        int[] dp = new int[amt + 1];
+        Arrays.fill(dp, MAX);
+        dp[0] = 0;
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[a] = dp[a];
+                } else {
+                    // 不选和选硬币 i 这两种方案的较小值
+                    dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[amt] != MAX ? dp[amt] : -1;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="coin_change.cpp"
+    /* 零钱兑换：状态压缩后的动态规划 */
+    int coinChangeDPComp(vector<int> &coins, int amt) {
+        int n = coins.size();
+        int MAX = amt + 1;
+        // 初始化 dp 表
+        vector<int> dp(amt + 1, MAX);
+        dp[0] = 0;
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[a] = dp[a];
+                } else {
+                    // 不选和选硬币 i 这两种方案的较小值
+                    dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[amt] != MAX ? dp[amt] : -1;
+    }
+    ```
+
+=== "Python"
+
+    ```python title="coin_change.py"
+    def coin_change_dp_comp(coins: list[int], amt: int) -> int:
+        """零钱兑换：状态压缩后的动态规划"""
+        n = len(coins)
+        MAX = amt + 1
+        # 初始化 dp 表
+        dp = [MAX] * (amt + 1)
+        dp[0] = 0
+        # 状态转移
+        for i in range(1, n + 1):
+            # 正序遍历
+            for a in range(1, amt + 1):
+                if coins[i - 1] > a:
+                    # 若超过背包容量，则不选硬币 i
+                    dp[a] = dp[a]
+                else:
+                    # 不选和选硬币 i 这两种方案的较小值
+                    dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)
+        return dp[amt] if dp[amt] != MAX else -1
+    ```
+
+=== "Go"
+
+    ```go title="coin_change.go"
+    [class]{}-[func]{coinChangeDPComp}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="coin_change.js"
+    [class]{}-[func]{coinChangeDPComp}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="coin_change.ts"
+    [class]{}-[func]{coinChangeDPComp}
+    ```
+
+=== "C"
+
+    ```c title="coin_change.c"
+    [class]{}-[func]{coinChangeDPComp}
+    ```
+
+=== "C#"
+
+    ```csharp title="coin_change.cs"
+    [class]{coin_change}-[func]{coinChangeDPComp}
+    ```
+
+=== "Swift"
+
+    ```swift title="coin_change.swift"
+    [class]{}-[func]{coinChangeDPComp}
+    ```
+
+=== "Zig"
+
+    ```zig title="coin_change.zig"
+    [class]{}-[func]{coinChangeDPComp}
+    ```
+
+=== "Dart"
+
+    ```dart title="coin_change.dart"
+    [class]{}-[func]{coinChangeDPComp}
+    ```
+
+## 13.5.3. &nbsp; 零钱兑换问题 II
+
+!!! question
+
+    给定 $n$ 种硬币，第 $i$ 个硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，每种硬币可以重复选取，**问在凑出目标金额的硬币组合数量**。
+
+![零钱兑换问题 II 的示例数据](unbounded_knapsack_problem.assets/coin_change_ii_example.png)
+
+<p align="center"> Fig. 零钱兑换问题 II 的示例数据 </p>
+
+相比于上一题，本题目标是组合数量，因此子问题变为：**前 $i$ 个硬币能够凑出金额 $a$ 的组合数量**。而 $dp$ 表仍然是尺寸为 $(n+1) \times (amt + 1)$ 的二维矩阵。
+
+当前状态的组合数量等于不选当前硬币与选当前硬币这两种决策的组合数量之和。状态转移方程为：
+
+$$
+dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]]
+$$
+
+当目标金额为 $0$ 时，无需选择任何硬币即可凑出目标金额，因此应将所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此所有 $dp[0, a]$ 都等于 $0$ 。
+
+=== "Java"
+
+    ```java title="coin_change_ii.java"
+    /* 零钱兑换 II：动态规划 */
+    int coinChangeIIDP(int[] coins, int amt) {
+        int n = coins.length;
+        // 初始化 dp 表
+        int[][] dp = new int[n + 1][amt + 1];
+        // 初始化首列
+        for (int i = 0; i <= n; i++) {
+            dp[i][0] = 1;
+        }
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a];
+                } else {
+                    // 不选和选硬币 i 这两种方案之和
+                    dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[n][amt];
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="coin_change_ii.cpp"
+    /* 零钱兑换 II：动态规划 */
+    int coinChangeIIDP(vector<int> &coins, int amt) {
+        int n = coins.size();
+        // 初始化 dp 表
+        vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
+        // 初始化首列
+        for (int i = 0; i <= n; i++) {
+            dp[i][0] = 1;
+        }
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a];
+                } else {
+                    // 不选和选硬币 i 这两种方案之和
+                    dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[n][amt];
+    }
+    ```
+
+=== "Python"
+
+    ```python title="coin_change_ii.py"
+    def coin_change_ii_dp(coins: list[int], amt: int) -> int:
+        """零钱兑换 II：动态规划"""
+        n = len(coins)
+        # 初始化 dp 表
+        dp = [[0] * (amt + 1) for _ in range(n + 1)]
+        # 初始化首列
+        for i in range(n + 1):
+            dp[i][0] = 1
+        # 状态转移
+        for i in range(1, n + 1):
+            for a in range(1, amt + 1):
+                if coins[i - 1] > a:
+                    # 若超过背包容量，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a]
+                else:
+                    # 不选和选硬币 i 这两种方案之和
+                    dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]
+        return dp[n][amt]
+    ```
+
+=== "Go"
+
+    ```go title="coin_change_ii.go"
+    [class]{}-[func]{coinChangeIIDP}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="coin_change_ii.js"
+    [class]{}-[func]{coinChangeIIDP}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="coin_change_ii.ts"
+    [class]{}-[func]{coinChangeIIDP}
+    ```
+
+=== "C"
+
+    ```c title="coin_change_ii.c"
+    [class]{}-[func]{coinChangeIIDP}
+    ```
+
+=== "C#"
+
+    ```csharp title="coin_change_ii.cs"
+    [class]{coin_change_ii}-[func]{coinChangeIIDP}
+    ```
+
+=== "Swift"
+
+    ```swift title="coin_change_ii.swift"
+    [class]{}-[func]{coinChangeIIDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="coin_change_ii.zig"
+    [class]{}-[func]{coinChangeIIDP}
+    ```
+
+=== "Dart"
+
+    ```dart title="coin_change_ii.dart"
+    [class]{}-[func]{coinChangeIIDP}
+    ```
+
+状态压缩处理方式相同，删除硬币维度即可。
+
+=== "Java"
+
+    ```java title="coin_change_ii.java"
+    /* 零钱兑换 II：状态压缩后的动态规划 */
+    int coinChangeIIDPComp(int[] coins, int amt) {
+        int n = coins.length;
+        // 初始化 dp 表
+        int[] dp = new int[amt + 1];
+        dp[0] = 1;
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[a] = dp[a];
+                } else {
+                    // 不选和选硬币 i 这两种方案之和
+                    dp[a] = dp[a] + dp[a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[amt];
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="coin_change_ii.cpp"
+    /* 零钱兑换 II：状态压缩后的动态规划 */
+    int coinChangeIIDPComp(vector<int> &coins, int amt) {
+        int n = coins.size();
+        // 初始化 dp 表
+        vector<int> dp(amt + 1, 0);
+        dp[0] = 1;
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // 若超过背包容量，则不选硬币 i
+                    dp[a] = dp[a];
+                } else {
+                    // 不选和选硬币 i 这两种方案之和
+                    dp[a] = dp[a] + dp[a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[amt];
+    }
+    ```
+
+=== "Python"
+
+    ```python title="coin_change_ii.py"
+    def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:
+        """零钱兑换 II：状态压缩后的动态规划"""
+        n = len(coins)
+        # 初始化 dp 表
+        dp = [0] * (amt + 1)
+        dp[0] = 1
+        # 状态转移
+        for i in range(1, n + 1):
+            # 正序遍历
+            for a in range(1, amt + 1):
+                if coins[i - 1] > a:
+                    # 若超过背包容量，则不选硬币 i
+                    dp[a] = dp[a]
+                else:
+                    # 不选和选硬币 i 这两种方案之和
+                    dp[a] = dp[a] + dp[a - coins[i - 1]]
+        return dp[amt]
+    ```
+
+=== "Go"
+
+    ```go title="coin_change_ii.go"
+    [class]{}-[func]{coinChangeIIDPComp}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="coin_change_ii.js"
+    [class]{}-[func]{coinChangeIIDPComp}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="coin_change_ii.ts"
+    [class]{}-[func]{coinChangeIIDPComp}
+    ```
+
+=== "C"
+
+    ```c title="coin_change_ii.c"
+    [class]{}-[func]{coinChangeIIDPComp}
+    ```
+
+=== "C#"
+
+    ```csharp title="coin_change_ii.cs"
+    [class]{coin_change_ii}-[func]{coinChangeIIDPComp}
+    ```
+
+=== "Swift"
+
+    ```swift title="coin_change_ii.swift"
+    [class]{}-[func]{coinChangeIIDPComp}
+    ```
+
+=== "Zig"
+
+    ```zig title="coin_change_ii.zig"
+    [class]{}-[func]{coinChangeIIDPComp}
+    ```
+
+=== "Dart"
+
+    ```dart title="coin_change_ii.dart"
+    [class]{}-[func]{coinChangeIIDPComp}
+    ```