diff --git a/chapter_backtracking/backtracking_algorithm.md b/chapter_backtracking/backtracking_algorithm.md index d1b315b22..ac9a3db43 100644 --- a/chapter_backtracking/backtracking_algorithm.md +++ b/chapter_backtracking/backtracking_algorithm.md @@ -6,7 +6,7 @@ comments: true 「回溯算法 Backtracking Algorithm」是一种通过穷举来解决问题的方法，它的核心思想是从一个初始状态出发，暴力搜索所有可能的解决方案，当遇到正确的解则将其记录，直到找到解或者尝试了所有可能的选择都无法找到解为止。 -回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中，我们提到前序、中序和后序遍历都属于深度优先搜索。下面，我们将从前序遍历入手，逐步了解回溯算法的工作原理。 +回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中，我们提到前序、中序和后序遍历都属于深度优先搜索。接下来我们先用前序遍历构造一个回溯问题，逐步了解回溯算法的工作原理。 !!! question "例题一" @@ -1350,7 +1350,21 @@ comments: true 相较于基于前序遍历的实现代码，基于回溯算法框架的实现代码虽然显得啰嗦，但通用性更好。实际上，**所有回溯问题都可以在该框架下解决**。我们需要根据具体问题来定义 `state` 和 `choices` ，并实现框架中的各个方法。 -## 12.1.5.   典型例题 +## 12.1.5.   优势与局限性 + +回溯算法本质上是一种深度优先搜索算法，它尝试所有可能的解决方案直到找到满足条件的解。这种方法的优势在于它能够找到所有可能的解决方案，而且在合理的剪枝操作下，具有很高的效率。 + +然而，在处理大规模或者复杂问题时，**回溯算法的运行效率可能难以接受**。 + +- 在最坏的情况下，回溯算法需要遍历解空间的所有可能解，所需时间很长。例如，求解 $n$ 皇后问题的时间复杂度可以达到 $O(n!)$ 。 +- 在每一次递归调用时，都需要保存当前的状态（例如选择路径、用于剪枝的辅助变量等），对于深度很大的递归，空间需求可能会变得非常大。 + +即便如此，**回溯算法仍然是某些搜索问题和约束满足问题的最佳解决方案**。对于这些问题，由于无法预测哪些选择可生成有效的解，因此我们必须对所有可能的选择进行遍历。在这种情况下，**关键是如何进行效率优化**： + +- 上文介绍过的剪枝是一种常用的优化方法。它可以避免搜索那些肯定不会产生有效解的路径，从而节省时间和空间。 +- 另一个常用的优化方法是加入「启发式搜索 Heuristic Search」策略，它在搜索过程中引入一些策略或者估计值，从而优先搜索最有可能产生有效解的路径。 + +## 12.1.6.   典型例题 **搜索问题**：这类问题的目标是找到满足特定条件的解决方案。 @@ -1371,14 +1385,3 @@ comments: true - 最大团问题：给定一个无向图，找到最大的完全子图，即子图中的任意两个顶点之间都有边相连。 请注意，回溯算法通常不是解决组合优化问题的最优方法。0-1 背包问题通常使用动态规划解决；旅行商是一个 NP-Hard 问题，常用解决方法有遗传算法和蚁群算法等；最大团问题是图轮中的一个经典 NP-Hard 问题，通常用贪心算法等启发式算法来解决。 - -## 12.1.6.   优势与局限性 - -回溯算法本质上是一种深度优先搜索算法，它尝试所有可能的解决方案直到找到满足条件的解。这种方法的优势在于它能够找到所有可能的解决方案，而且在合理的剪枝操作下，具有很高的效率。 - -然而，在处理大规模或者复杂问题时，**回溯算法的运行效率可能难以接受**。这是因为在最坏的情况下，回溯算法需要遍历解空间的所有可能解。例如，求解 $n$ 皇后问题的时间复杂度可以达到 $O(n!)$ 。回溯算法的空间复杂度也可能较高。因为在每一次递归调用时，都需要保存当前的状态（例如选择路径、用于剪枝的辅助变量等），对于深度很大的递归，空间需求可能会变得非常大。 - -即便如此，**回溯算法仍然是某些搜索问题和约束满足问题的最佳解决方案**。对于这些问题，由于我们无法预测哪些选择可生成有效的解，因此我们必须对所有可能的选择进行遍历。在这种情况下，**关键是如何进行效率优化**： - -- 上文介绍过的剪枝是一种常用的优化方法。它可以避免搜索那些肯定不会产生有效解的路径，从而节省时间和空间。 -- 另一个常用的优化方法是加入「启发式搜索 Heuristic Search」策略，它在搜索过程中引入一些策略或者估计值，从而优先搜索最有可能产生有效解的路径。 diff --git a/chapter_backtracking/permutations_problem.md b/chapter_backtracking/permutations_problem.md index 5d9f8339e..0e8602c32 100644 --- a/chapter_backtracking/permutations_problem.md +++ b/chapter_backtracking/permutations_problem.md @@ -6,7 +6,7 @@ comments: true 全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找出这个集合中元素的所有可能的排列。 -如下表所示，列举了几个示例数组和其对应的所有排列。 +下表列举了几个示例数据，包括输入数组和对应的所有排列。
@@ -346,7 +346,7 @@ comments: true 需要重点关注的是，我们引入了一个布尔型数组 `selected` ，它的长度与输入数组长度相等，其中 `selected[i]` 表示 `choices[i]` 是否已被选择。我们利用 `selected` 避免某个元素被重复选择，从而实现剪枝。 -如下图所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。**从本质上理解，此剪枝操作可将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$** 。 +如下图所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。**此剪枝操作可将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$** 。 ![全排列剪枝示例](permutations_problem.assets/permutations_i_pruning.png) @@ -364,7 +364,7 @@ comments: true

Fig. 重复排列

-那么，如何去除重复的排列呢？最直接地，我们可以借助一个哈希表，直接对排列结果进行去重。然而，这样做不够优雅，因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝，这样可以提升算法效率。 +那么，如何去除重复的排列呢？最直接地，我们可以借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，**因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝**，这样可以进一步提升算法效率。 观察发现，在第一轮中，选择 $1$ 或选择 $\hat{1}$ 是等价的，因为在这两个选择之下生成的所有排列都是重复的。因此，我们应该把 $\hat{1}$ 剪枝掉。同理，在第一轮选择 $2$ 后，第二轮选择中的 $1$ 和 $\hat{1}$ 也会产生重复分支，因此也需要将第二轮的 $\hat{1}$ 剪枝。 diff --git a/chapter_data_structure/basic_data_types.md b/chapter_data_structure/basic_data_types.md index 06e36288f..94ade2643 100644 --- a/chapter_data_structure/basic_data_types.md +++ b/chapter_data_structure/basic_data_types.md @@ -48,7 +48,7 @@ comments: true === "Java" ```java title="" - /* 使用多种「基本数据类型」来初始化「数组」 */ + // 使用多种基本数据类型来初始化数组 int[] numbers = new int[5]; float[] decimals = new float[5]; char[] characters = new char[5]; @@ -58,7 +58,7 @@ comments: true === "C++" ```cpp title="" - /* 使用多种「基本数据类型」来初始化「数组」 */ + // 使用多种基本数据类型来初始化数组 int numbers[5]; float decimals[5]; char characters[5]; @@ -85,14 +85,14 @@ comments: true === "JavaScript" ```javascript title="" - /* JavaScript 的数组可以自由存储各种基本数据类型和对象 */ + // JavaScript 的数组可以自由存储各种基本数据类型和对象 const array = [0, 0.0, 'a', false]; ``` === "TypeScript" ```typescript title="" - /* 使用多种「基本数据类型」来初始化「数组」 */ + // 使用多种基本数据类型来初始化数组 const numbers: number[] = []; const characters: string[] = []; const booleans: boolean[] = []; @@ -101,7 +101,7 @@ comments: true === "C" ```c title="" - /* 使用多种「基本数据类型」来初始化「数组」 */ + // 使用多种基本数据类型来初始化数组 int numbers[10]; float decimals[10]; char characters[10]; @@ -111,7 +111,7 @@ comments: true === "C#" ```csharp title="" - /* 使用多种「基本数据类型」来初始化「数组」 */ + // 使用多种基本数据类型来初始化数组 int[] numbers = new int[5]; float[] decimals = new float[5]; char[] characters = new char[5]; @@ -121,7 +121,7 @@ comments: true === "Swift" ```swift title="" - /* 使用多种「基本数据类型」来初始化「数组」 */ + // 使用多种基本数据类型来初始化数组 let numbers = Array(repeating: Int(), count: 5) let decimals = Array(repeating: Double(), count: 5) let characters = Array(repeating: Character("a"), count: 5) @@ -137,7 +137,7 @@ comments: true === "Dart" ```dart title="" - /* 使用多种「基本数据类型」来初始化「数组」 */ + // 使用多种基本数据类型来初始化数组 List numbers = List.filled(5, 0); List decimals = List.filled(5, 0.0); List characters = List.filled(5, 'a'); diff --git a/chapter_data_structure/classification_of_data_structure.md b/chapter_data_structure/classification_of_data_structure.md index 33b17b92c..e8cc93bf6 100644 --- a/chapter_data_structure/classification_of_data_structure.md +++ b/chapter_data_structure/classification_of_data_structure.md @@ -10,18 +10,24 @@ comments: true **「逻辑结构」揭示了数据元素之间的逻辑关系**。在数组和链表中，数据按照顺序依次排列，体现了数据之间的线性关系；而在树中，数据从顶部向下按层次排列，表现出祖先与后代之间的派生关系；图则由节点和边构成，反映了复杂的网络关系。 -逻辑结构通常分为「线性」和「非线性」两类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列，例如网状或树状结构。 +逻辑结构通常分为“线性”和“非线性”两类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。 - **线性数据结构**：数组、链表、栈、队列、哈希表； -- **非线性数据结构**：树、图、堆、哈希表； +- **非线性数据结构**：树、堆、图、哈希表； ![线性与非线性数据结构](classification_of_data_structure.assets/classification_logic_structure.png)

Fig. 线性与非线性数据结构

+非线性数据结构可以进一步被划分为树形结构和网状结构。 + +- **线性结构**：数组、链表、队列、栈、哈希表，元素存在一对一的顺序关系； +- **树形结构**：树、堆、哈希表，元素存在一对多的关系； +- **网状结构**：图，元素存在多对多的关系； + ## 3.1.2.   物理结构：连续与离散 -在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。 +在计算机中，内存和硬盘是两种主要的存储硬件设备。硬盘主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。内存用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。 **在算法运行过程中，相关数据都存储在内存中**。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。 @@ -44,7 +50,7 @@ comments: true - **基于数组可实现**：栈、队列、哈希表、树、堆、图、矩阵、张量（维度 $\geq 3$ 的数组）等； - **基于链表可实现**：栈、队列、哈希表、树、堆、图等； -基于数组实现的数据结构也被称为「静态数据结构」，这意味着此类数据结构在初始化后长度不可变。相对应地，基于链表实现的数据结构被称为「动态数据结构」，这类数据结构在初始化后，仍可以在程序运行过程中对其长度进行调整。 +基于数组实现的数据结构也被称为“静态数据结构”，这意味着此类数据结构在初始化后长度不可变。相对应地，基于链表实现的数据结构被称为“动态数据结构”，这类数据结构在初始化后，仍可以在程序运行过程中对其长度进行调整。 !!! tip diff --git a/chapter_dynamic_programming/dp_problem_features.md b/chapter_dynamic_programming/dp_problem_features.md index d8fcb522a..ed19db5a0 100644 --- a/chapter_dynamic_programming/dp_problem_features.md +++ b/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)

Fig. 爬到第 3 阶的最小代价

@@ -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)

Fig. 爬楼梯最小代价的动态规划过程

@@ -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)

Fig. 带约束爬到第 3 阶的方案数量

@@ -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)

Fig. 考虑约束下的递推关系

diff --git a/chapter_dynamic_programming/dp_solution_pipeline.md b/chapter_dynamic_programming/dp_solution_pipeline.md index 91d41970e..1e83b344c 100644 --- a/chapter_dynamic_programming/dp_solution_pipeline.md +++ b/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" diff --git a/chapter_dynamic_programming/knapsack_problem.md b/chapter_dynamic_programming/knapsack_problem.md index 1bf4b5dc4..0c7bbc22e 100644 --- a/chapter_dynamic_programming/knapsack_problem.md +++ b/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" diff --git a/chapter_dynamic_programming/unbounded_knapsack_problem.md b/chapter_dynamic_programming/unbounded_knapsack_problem.md new file mode 100644 index 000000000..e9bd08450 --- /dev/null +++ b/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) + +

Fig. 完全背包问题的示例数据

+ +完全背包和 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 &wgt, vector &val, int cap) { + int n = wgt.size(); + // 初始化 dp 表 + vector> dp(n + 1, vector(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 &wgt, vector &val, int cap) { + int n = wgt.size(); + // 初始化 dp 表 + vector 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.   零钱兑换问题 + +背包问题是一大类动态规划问题的代表，其拥有很多的变种，例如零钱兑换问题。 + +!!! question + + 给定 $n$ 种硬币，第 $i$ 个硬币的面值为 $coins[i - 1]$ ，为目标金额 $amt$ ，**每种硬币可以重复选取**，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 $-1$ 。 + +如下图所示，凑出 $11$ 元最少需要 $3$ 枚硬币，方案为 $1 + 2 + 5 = 11$ 。 + +![零钱兑换问题的示例数据](unbounded_knapsack_problem.assets/coin_change_example.png) + +

Fig. 零钱兑换问题的示例数据

+ +**零钱兑换问题可以看作是完全背包问题的一种特殊情况**，两者具有以下联系与不同点： + +- 两道题可以相互转换，“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”； +- 目标不同，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量； +- 背包问题是求“不超过”背包容量下的解，零钱兑换是求“恰好”凑到目标金额的解； + +**第一步：思考每轮的决策，定义状态，从而得到 $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 &coins, int amt) { + int n = coins.size(); + int MAX = amt + 1; + // 初始化 dp 表 + vector> dp(n + 1, vector(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 &coins, int amt) { + int n = coins.size(); + int MAX = amt + 1; + // 初始化 dp 表 + vector 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.   零钱兑换问题 II + +!!! question + + 给定 $n$ 种硬币，第 $i$ 个硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，每种硬币可以重复选取，**问在凑出目标金额的硬币组合数量**。 + +![零钱兑换问题 II 的示例数据](unbounded_knapsack_problem.assets/coin_change_ii_example.png) + +

Fig. 零钱兑换问题 II 的示例数据

+ +相比于上一题，本题目标是组合数量，因此子问题变为：**前 $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 &coins, int amt) { + int n = coins.size(); + // 初始化 dp 表 + vector> dp(n + 1, vector(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 &coins, int amt) { + int n = coins.size(); + // 初始化 dp 表 + vector 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} + ```