build

chapter_dynamic_programming/dp_problem_features.md

@@ -28,11 +28,9 @@ $$
 dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
 $$
 
-这便可以引出「最优子结构」的含义：**原问题的最优解是从子问题的最优解构建得来的**。对于本题，我们从两个子问题最优解 $dp[i-1]$ , $dp[i-2]$ 中挑选出较优的那一个，并用它构建出原问题 $dp[i]$ 的最优解。
+这便可以引出「最优子结构」的含义：**原问题的最优解是从子问题的最优解构建得来的**。本题显然具有最优子结构：我们从两个子问题最优解 $dp[i-1]$ , $dp[i-2]$ 中挑选出较优的那一个，并用它构建出原问题 $dp[i]$ 的最优解。
 
-相较于分治问题，动态规划问题的解也是由其子问题的解构成的。不同的是，**动态规划中子问题的解不仅揭示了问题的局部最优解，而且还通过特定的递推关系链接起来，共同构建出原问题的全局最优解**。
-
-那么，上节的爬楼梯题目有没有最优子结构呢？它要求解的是方案数量，看似是一个计数问题，但如果换一种问法：求解最大方案数量。我们意外地发现，**虽然题目修改前后是等价的，但最优子结构浮现出来了**：第 $n$ 阶最大方案数量等于第 $n-1$ 阶和第 $n-2$ 阶最大方案数量之和。所以说，最优子结构的是一个比较宽泛的概念，在不同问题中会有不同的含义。
+那么，上节的爬楼梯题目有没有最优子结构呢？它要求解的是方案数量，看似是一个计数问题，但如果换一种问法：求解最大方案数量。我们意外地发现，**虽然题目修改前后是等价的，但最优子结构浮现出来了**：第 $n$ 阶最大方案数量等于第 $n-1$ 阶和第 $n-2$ 阶最大方案数量之和。所以说，最优子结构的解释方式比较灵活，在不同问题中会有不同的含义。
 
 根据以上状态转移方程，以及初始状态 $dp[1] = cost[1]$ , $dp[2] = cost[2]$ ，我们可以得出动态规划解题代码。
 
@@ -458,4 +456,4 @@ $$
 
 在这个问题中，下次跳跃依赖于过去所有的状态，因为每一次跳跃都会在更高的阶梯上设置障碍，并影响未来的跳跃。对于这类问题，动态规划往往难以解决，或是因为计算复杂度过高而难以应用。
 
-实际上，许多组合优化问题（例如著名的旅行商问题）都不满足无后效性。对于这类问题，我们通常会选择使用其他方法，例如启发式搜索、遗传算法、强化学习等，从而降低时间复杂度，在有限时间内得到能够接受的局部最优解。
+实际上，许多复杂的组合优化问题（例如著名的旅行商问题）都不满足无后效性。对于这类问题，我们通常会选择使用其他方法，例如启发式搜索、遗传算法、强化学习等，从而降低时间复杂度，在有限时间内得到能够接受的局部最优解。

chapter_dynamic_programming/edit_distance_problem.md

@@ -35,7 +35,7 @@ comments: true
 - 若 $s[n-1]$ 和 $t[m-1]$ 相同，我们可以直接跳过它们，接下来考虑 $s[n-2]$ 和 $t[m-2]$ ;
 - 若 $s[n-1]$ 和 $t[m-1]$ 不同，我们需要对 $s$ 进行一次编辑（插入、删除、替换），使得两字符串尾部的字符相同，从而可以跳过它们，考虑规模更小的问题；
 
-也就是说，我们在字符串 $s$ 中进行的每一轮决策（编辑操作），都会使得 $s$ 和 $t$ 中剩余的待匹配字符发生变化。因此，状态定义为当前在 $s$ , $t$ 中考虑的第 $i$ , $j$ 个字符，记为 $[i, j]$ 。
+也就是说，我们在字符串 $s$ 中进行的每一轮决策（编辑操作），都会使得 $s$ 和 $t$ 中剩余的待匹配字符发生变化。因此，状态为当前在 $s$ , $t$ 中考虑的第 $i$ , $j$ 个字符，记为 $[i, j]$ 。
 
 状态 $[i, j]$ 对应的子问题：**将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数**。
 
@@ -45,7 +45,7 @@ comments: true
 
 考虑子问题 $dp[i, j]$ ，其对应的两个字符串的尾部字符为 $s[i-1]$ 和 $t[j-1]$ ，可根据不同编辑操作分为三种情况：
 
-1. 在 $s$ 尾部添加 $t[j-1]$ ，则剩余子问题 $dp[i, j-1]$ ；
+1. 在 $s[i-1]$ 之后添加 $t[j-1]$ ，则剩余子问题 $dp[i, j-1]$ ；
 2. 删除 $s[i-1]$ ，则剩余子问题 $dp[i-1, j]$ ；
 3. 将 $s[i-1]$ 替换为 $t[j-1]$ ，则剩余子问题 $dp[i-1, j-1]$ ；
 

chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -212,7 +212,9 @@ $$
 
 也就是说，在爬楼梯问题中，**各个子问题之间不是相互独立的，原问题的解可以由子问题的解构成**。
 
-我们可以基于此递推公式写出暴力搜索代码：以 $dp[n]$ 为起始点，**从顶至底地将一个较大问题拆解为两个较小问题的和**，直至到达最小子问题 $dp[1]$ 和 $dp[2]$ 时返回。其中，最小子问题的解 $dp[1] = 1$ , $dp[2] = 2$ 是已知的，代表爬到第 $1$ , $2$ 阶分别有 $1$ , $2$ 种方案。
+我们可以基于此递推公式写出暴力搜索代码：以 $dp[n]$ 为起始点，**从顶至底地将一个较大问题拆解为两个较小问题的和**，直至到达最小子问题 $dp[1]$ 和 $dp[2]$ 时返回。
+
+请注意，最小子问题的解 $dp[1] = 1$ , $dp[2] = 2$ 是已知的，代表爬到第 $1$ , $2$ 阶分别有 $1$ , $2$ 种方案。
 
 观察以下代码，它和标准回溯代码都属于深度优先搜索，但更加简洁。
 
@@ -774,7 +776,7 @@ $$
 
 **我们将这种空间优化技巧称为「状态压缩」**。在许多动态规划问题中，当前状态仅与前面有限个状态有关，不必保存所有的历史状态，这时我们可以应用状态压缩，只保留必要的状态，通过“降维”来节省内存空间。
 
-总的看来，子问题分解是一种通用的算法思路，在分治算法、动态规划、回溯算法中各有特点：
+总的看来，**子问题分解是一种通用的算法思路，在分治、动态规划、回溯中各有特点**：
 
 - 分治算法将原问题划分为几个独立的子问题，然后递归解决子问题，最后合并子问题的解得到原问题的解。例如，归并排序将长数组不断划分为两个短子数组，再将排序好的子数组合并为排序好的长数组。
 - 动态规划也是将原问题分解为多个子问题，但与分治算法的主要区别是，**动态规划中的子问题往往不是相互独立的**，原问题的解依赖于子问题的解，而子问题的解又依赖于更小的子问题的解。因此，动态规划通常会引入记忆化，保存已经解决的子问题的解，避免重复计算。

chapter_dynamic_programming/knapsack_problem.md

@@ -532,7 +532,7 @@ $$
 
 **最后考虑状态压缩**。以上代码中的数组 `dp` 占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略，有兴趣的同学可以自行实现。
 
-那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 $i$ 行时，该数组存储的仍然是第 $i-1$ 行的状态，**为了避免左方区域的格子在状态转移中被覆盖，应该采取倒序遍历**。
+那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由正上方或左上方的格子转移过来的。假设只有一个数组，当遍历到第 $i$ 行时，该数组存储的仍然是第 $i-1$ 行的状态，**为了避免左方区域的格子在状态转移中被覆盖，应该采取倒序遍历**。
 
 以下动画展示了在单个数组下从第 $i=1$ 行转换至第 $i=2$ 行的过程。建议你思考一下正序遍历和倒序遍历的区别。
 

chapter_dynamic_programming/summary.md

@@ -0,0 +1,26 @@
+---
+comments: true
+---
+
+# 13.7.   小结
+
+- 动态规划通过将原问题分解为子问题来求解问题，并通过存储子问题的解来规避重复计算，实现高效的计算效率。
+- 不考虑时间的前提下，所有动态规划问题都可以用回溯（暴力搜索）进行求解，但递归树中存在大量的重叠子问题，效率极低。
+- 通过引入记忆化列表，可以存储所有计算过的子问题的解，从而保证重叠子问题只被计算一次。
+- 记忆化递归是一种从顶至底的递归式解法，与之对应的动态规划是一种从底至顶的递推式解法。
+- 由于当前状态仅依赖于某些局部状态，因此我们可以对 $dp$ 表的维度进行压缩，从而降低空间复杂度。
+- 子问题分解是一种通用的算法思路，在分治、动态规划、回溯中具有不同的性质。
+- 动态规划问题的三大特性：重叠子问题、最优子结构、无后效性。
+- 如果原问题的最优解可以从子问题的最优解构建得来，则此问题就具有最优子结构。
+- 无后效性指对于一个状态，其未来发展只与该状态有关，与其所经历的过去的所有状态无关。许多组合优化问题都不具有无后效性，无法使用动态规划快速求解。
+- 背包问题是最典型的动态规划题目，具有 0-1 背包、完全背包、多重背包等变种问题。
+- 0-1 背包的状态定义为前 $i$ 个物品在剩余容量为 $c$ 的背包中的最大价值。这是一种常见的定义方式。
+- 在 0-1 背包中，不放入物品 $i$ ，状态转移至 $[i-1, c]$ ，放入则转移至 $[i-1, c-wgt[i-1]]$ 。由此便得到最优子结构，并构建出状态转移方程。
+- 在 0-1 背包中，由于每个状态依赖正上方和左上方的状态，因此状态压缩后需要倒序遍历列表，避免左上方状态被覆盖。
+- 完全背包的每种物品有无数个，因此在放置物品 $i$ 后，状态转移至 $[i, c-wgt[i-1]]$ 。由于状态依赖于正上方和正左方的状态，因此状态压缩后应该正序遍历。
+- 零钱兑换问题是完全背包的一个变种。为从求“最大“价值变为求“最小”硬币数量，我们将状态转移方程中的 $\max()$ 改为 $\min$ ，为从求“不超过”背包容量到求“恰好”凑出目标金额，我们使用 $amt + 1$ 来表示“无法凑出目标金额”的无效解。
+- 零钱兑换 II 问题从求“最少硬币数量”改为求“硬币组合数量”，状态转移方程相应地从 $\min()$ 改为求和运算符。
+- 编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。
+- 编辑距离的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。
+- 对于字符 $s[i]$ 和 $t[j]$ ，可以在 $s[i-1]$ 之后添加 $t[j-1]$ 、删除 $s[i-1]$ 、将 $s[i-1]$ 替换为 $t[j-1]$ ，三种操作都有相应的剩余子问题。据此，我们就可以找出最优子结构与构建状态转移方程。值得注意的是，当 $s[i] = t[j]$ 时，无需编辑当前字符，直接跳过即可。
+- 在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。利用一个变量暂存左上方状态，即转化至完全背包地情况，可以在状态压缩后使用正序遍历。

chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -129,7 +129,25 @@ $$
 === "C#"
 
     ```csharp title="unbounded_knapsack.cs"
-    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDP}
+    /* 完全背包：动态规划 */
+    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];
+    }
     ```
 
 === "Swift"
@@ -268,7 +286,25 @@ $$
 === "C#"
 
     ```csharp title="unbounded_knapsack.cs"
-    [class]{unbounded_knapsack}-[func]{unboundedKnapsackDPComp}
+    /* 完全背包：状态压缩后的动态规划 */
+    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];
+    }
     ```
 
 === "Swift"
@@ -445,7 +481,30 @@ $$
 === "C#"
 
     ```csharp title="coin_change.cs"
-    [class]{coin_change}-[func]{coinChangeDP}
+    /* 零钱兑换：动态规划 */
+    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;
+    }
     ```
 
 === "Swift"
@@ -618,7 +677,28 @@ $$
 === "C#"
 
     ```csharp title="coin_change.cs"
-    [class]{coin_change}-[func]{coinChangeDPComp}
+    /* 零钱兑换：状态压缩后的动态规划 */
+    int coinChangeDPComp(int[] coins, int amt) {
+        int n = coins.Length;
+        int MAX = amt + 1;
+        // 初始化 dp 表
+        int[] dp = new int[amt + 1];
+        Array.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;
+    }
     ```
 
 === "Swift"
@@ -765,7 +845,29 @@ $$
 === "C#"
 
     ```csharp title="coin_change_ii.cs"
-    [class]{coin_change_ii}-[func]{coinChangeIIDP}
+    /* 零钱兑换 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];
+    }
     ```
 
 === "Swift"
@@ -887,7 +989,26 @@ $$
 === "C#"
 
     ```csharp title="coin_change_ii.cs"
-    [class]{coin_change_ii}-[func]{coinChangeIIDPComp}
+    /* 零钱兑换 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];
+    }
     ```
 
 === "Swift"