Add subtitles to docs

docs/chapter_dynamic_programming/dp_problem_features.md

@@ -2,7 +2,13 @@
 
 在上节中，我们学习了动态规划问题的暴力解法，从递归树中观察到海量的重叠子问题，以及了解到动态规划是如何通过记录解来优化时间复杂度的。
 
-实际上，动态规划最常用来求解最优方案问题，例如寻找最短路径、最大利润、最少时间等。**这类问题不仅包含重叠子问题，往往还具有另外两大特性：最优子结构、无后效性**。
+总的看来，**子问题分解是一种通用的算法思路，在分治、动态规划、回溯中各有特点**：
+
+- 分治算法将原问题划分为几个独立的子问题，然后递归解决子问题，最后合并子问题的解得到原问题的解。
+- 动态规划也是将原问题分解为多个子问题，但与分治算法的主要区别是，**动态规划中的子问题往往不是相互独立的**，原问题的解依赖于子问题的解，而子问题的解又依赖于更小的子问题的解。
+- 回溯算法在尝试和回退中穷举所有可能的解，并通过剪枝避免不必要的搜索分支。原问题的解由一系列决策步骤构成，我们可以将每个决策步骤之前的子序列看作为一个子问题。
+
+实际上，动态规划最常用来求解最优化问题。**这类问题不仅包含重叠子问题，还具有另外两大特性：最优子结构、无后效性**。
 
 ## 最优子结构
 

docs/chapter_dynamic_programming/dp_solution_pipeline.md

@@ -25,7 +25,7 @@
 
 如果一个问题满足决策树模型，并具有较为明显的“加分项“，我们就可以假设它是一个动态规划问题，并尝试求解它。
 
-## 问题求解
+## 问题求解步骤
 
 动态规划的解题流程可能会因问题的性质和难度而有所不同，但通常遵循以下步骤：描述决策，定义状态，建立 $dp$ 表，推导状态转移方程，确定边界条件等。
 
@@ -87,7 +87,7 @@ $$
 
 接下来，我们就可以实现动态规划代码了。然而，由于子问题分解是一种从顶至底的思想，因此按照“暴力搜索 $\rightarrow$ 记忆化搜索 $\rightarrow$ 动态规划”的顺序实现更加符合思维习惯。
 
-## 方法一：暴力搜索
+### 方法一：暴力搜索
 
 从状态 $[i, j]$ 开始搜索，不断分解为更小的状态 $[i-1, j]$ 和 $[i, j-1]$ ，包括以下递归要素：
 
@@ -169,7 +169,7 @@ $$
 
 每个状态都有向下和向右两种选择，从左上角走到右下角总共需要 $m + n - 2$ 步，所以最差时间复杂度为 $O(2^{m + n})$ 。请注意，这种计算方式未考虑临近网格边界的情况，当到达网络边界时只剩下一种选择。因此实际的路径数量会少一些。
 
-## 方法二：记忆化搜索
+### 方法二：记忆化搜索
 
 为了避免重复计算重叠子问题，我们引入一个和网格 `grid` 相同尺寸的记忆列表 `mem` ，用于记录各个子问题的解，提升搜索效率。
 
@@ -243,7 +243,7 @@ $$
 
 ![记忆化搜索递归树](dp_solution_pipeline.assets/min_path_sum_dfs_mem.png)
 
-## 方法三：动态规划
+### 方法三：动态规划
 
 动态规划代码是从底至顶的，仅需循环即可实现。
 
@@ -351,6 +351,8 @@ $$
 === "<12>"
     ![min_path_sum_dp_step12](dp_solution_pipeline.assets/min_path_sum_dp_step12.png)
 
+### 状态压缩
+
 如果希望进一步节省空间使用，可以考虑进行状态压缩。每个格子只与左边和上边的格子有关，因此我们可以只用一个单行数组来实现 $dp$ 表。
 
 由于数组 `dp` 只能表示一行的状态，因此我们无法提前初始化首列状态，而是在遍历每行中更新它。

docs/chapter_dynamic_programming/edit_distance_problem.md

@@ -61,6 +61,8 @@ $$
 
 观察状态转移方程，解 $dp[i, j]$ 依赖左方、上方、左上方的解，因此通过两层循环正序遍历整个 $dp$ 表即可。
 
+### 代码实现
+
 === "Java"
 
     ```java title="edit_distance.java"
@@ -174,6 +176,8 @@ $$
 === "<15>"
     ![edit_distance_dp_step15](edit_distance_problem.assets/edit_distance_dp_step15.png)
 
+### 状态压缩
+
 下面考虑状态压缩，将 $dp$ 表的第一维删除。由于 $dp[i,j]$ 是由上方 $dp[i-1, j]$ 、左方 $dp[i, j-1]$ 、左上方状态 $dp[i-1, j-1]$ 转移而来，而正序遍历会丢失左上方 $dp[i-1, j-1]$ ，倒序遍历无法提前构建 $dp[i, j-1]$ ，因此两种遍历顺序都不可取。
 
 为解决此问题，我们可以使用一个变量 `leftup` 来暂存左上方的解 $dp[i-1, j-1]$ ，这样便只用考虑左方和上方的解，与完全背包问题的情况相同，可使用正序遍历。

docs/chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -403,6 +403,8 @@ $$
 
 ![爬楼梯的动态规划过程](intro_to_dynamic_programming.assets/climbing_stairs_dp.png)
 
+## 状态压缩
+
 细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。如以下代码所示，由于省去了数组 `dp` 占用的空间，因此空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
 
 === "Java"
@@ -472,9 +474,3 @@ $$
     ```
 
 **我们将这种空间优化技巧称为「状态压缩」**。在许多动态规划问题中，当前状态仅与前面有限个状态有关，不必保存所有的历史状态，这时我们可以应用状态压缩，只保留必要的状态，通过“降维”来节省内存空间。
-
-总的看来，**子问题分解是一种通用的算法思路，在分治、动态规划、回溯中各有特点**：
-
-- 分治算法将原问题划分为几个独立的子问题，然后递归解决子问题，最后合并子问题的解得到原问题的解。例如，归并排序将长数组不断划分为两个短子数组，再将排序好的子数组合并为排序好的长数组。
-- 动态规划也是将原问题分解为多个子问题，但与分治算法的主要区别是，**动态规划中的子问题往往不是相互独立的**，原问题的解依赖于子问题的解，而子问题的解又依赖于更小的子问题的解。
-- 回溯算法在尝试和回退中穷举所有可能的解，并通过剪枝避免不必要的搜索分支。原问题的解由一系列决策步骤构成，我们可以将每个决策步骤之前的子序列看作为一个子问题。

docs/chapter_dynamic_programming/knapsack_problem.md

@@ -49,7 +49,7 @@ $$
 
     完成以上三步后，我们可以直接实现从底至顶的动态规划解法。而为了展示本题包含的重叠子问题，本文也同时给出从顶至底的暴力搜索和记忆化搜索解法。
 
-## 方法一：暴力搜索
+### 方法一：暴力搜索
 
 搜索代码包含以下要素：
 
@@ -129,7 +129,7 @@ $$
 
 ![0-1 背包的暴力搜索递归树](knapsack_problem.assets/knapsack_dfs.png)
 
-## 方法二：记忆化搜索
+### 方法二：记忆化搜索
 
 为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 对应解 $dp[i, c]$ 。
 
@@ -203,7 +203,7 @@ $$
 
 ![0-1 背包的记忆化搜索递归树](knapsack_problem.assets/knapsack_dfs_mem.png)
 
-## 方法三：动态规划
+### 方法三：动态规划
 
 动态规划解法本质上就是在状态转移中填充 $dp$ 表的过程，代码如下所示。
 
@@ -317,7 +317,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$ 行的状态，**为了避免左方区域的格子在状态转移中被覆盖，应该采取倒序遍历**。
 

docs/chapter_dynamic_programming/summary.md

@@ -4,11 +4,17 @@
 - 不考虑时间的前提下，所有动态规划问题都可以用回溯（暴力搜索）进行求解，但递归树中存在大量的重叠子问题，效率极低。通过引入记忆化列表，可以存储所有计算过的子问题的解，从而保证重叠子问题只被计算一次。
 - 记忆化递归是一种从顶至底的递归式解法，而与之对应的动态规划是一种从底至顶的递推式解法，就像是在“填写表格”一样。由于当前状态仅依赖于某些局部状态，因此我们可以消除 $dp$ 表的一个维度，从而降低空间复杂度。
 - 动态规划问题的三大特性：重叠子问题、最优子结构、无后效性。如果原问题的最优解可以从子问题的最优解构建得来，则此问题就具有最优子结构。无后效性指对于一个状态，其未来发展只与该状态有关，与其所经历的过去的所有状态无关。许多组合优化问题都不具有无后效性，无法使用动态规划快速求解。
+
+**背包问题**
+
 - 背包问题是最典型的动态规划题目，具有 0-1 背包、完全背包、多重背包等变种问题。
 - 0-1 背包的状态定义为前 $i$ 个物品在剩余容量为 $c$ 的背包中的最大价值。这是一种常见的定义方式。不放入物品 $i$ ，状态转移至 $[i-1, c]$ ，放入则转移至 $[i-1, c-wgt[i-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]$ 时，无需编辑当前字符，直接跳过即可。
 - 在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。利用一个变量暂存左上方状态，即转化至完全背包地情况，可以在状态压缩后使用正序遍历。

docs/chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -26,6 +26,8 @@ $$
 dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
 $$
 
+### 代码实现
+
 对比两道题目的动态规划代码，状态转移中有一处从 $i-1$ 变为 $i$ ，其余完全一致。
 
 === "Java"
@@ -94,6 +96,8 @@ $$
     [class]{}-[func]{unboundedKnapsackDP}
     ```
 
+### 状态压缩
+
 由于当前状态是从左边和上边的状态转移而来，**因此状态压缩后应该对 $dp$ 表中的每一行采取正序遍历**，这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解为什么要改为正序遍历。
 
 === "<1>"
@@ -221,7 +225,9 @@ $$
 
 当目标金额为 $0$ 时，凑出它的最少硬币个数为 $0$ ，即所有 $dp[i, 0]$ 都等于 $0$ 。当无硬币时，**无法凑出任意 $> 0$ 的目标金额**，即是无效解。为使状态转移方程中的 $\min()$ 函数能够识别并过滤无效解，我们考虑使用 $+ \infty$ 来表示它们，即令所有 $dp[0, a]$ 都等于 $+ \infty$ 。
 
-以上做法仅适用于 Python 语言，因为大多数编程语言并未提供 $+ \infty$ 变量，所以只能使用整型 `int` 的最大值，而这又会导致大数越界：**当 $dp[i, a - coins[i-1]]$ 是无效解时，再执行 $+ 1$ 操作会发生溢出**。
+### 代码实现
+
+然而，大多数编程语言并未提供 $+ \infty$ 变量，因此只能使用整型 `int` 的最大值来代替，而这又会导致大数越界：**当 $dp[i, a - coins[i-1]]$ 是无效解时，再执行 $+ 1$ 操作会发生溢出**。
 
 为解决该问题，我们采用一个不可能达到的大数字 $amt + 1$ 来表示无效解，因为凑出 $amt$ 的硬币个数最多为 $amt$ 个。
 
@@ -340,6 +346,8 @@ $$
 === "<15>"
     ![coin_change_dp_step15](unbounded_knapsack_problem.assets/coin_change_dp_step15.png)
 
+### 状态压缩
+
 由于零钱兑换和完全背包的状态转移方程如出一辙，因此状态压缩方式也相同。
 
 === "Java"
@@ -426,6 +434,8 @@ $$
 
 当目标金额为 $0$ 时，无需选择任何硬币即可凑出目标金额，因此应将所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此所有 $dp[0, a]$ 都等于 $0$ 。
 
+### 代码实现
+
 === "Java"
 
     ```java title="coin_change_ii.java"
@@ -492,6 +502,8 @@ $$
     [class]{}-[func]{coinChangeIIDP}
     ```
 
+### 状态压缩
+
 状态压缩处理方式相同，删除硬币维度即可。
 
 === "Java"