build

chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -212,9 +212,9 @@ $$
 
 也就是说，在爬楼梯问题中，**各个子问题之间不是相互独立的，原问题的解可以由子问题的解构成**。
 
-我们可以基于此递推公式写出暴力搜索代码：以 $dp[n]$ 为起始点，**从顶至底地将一个较大问题拆解为两个较小问题的和**，直至到达最小子问题 $dp[1]$ 和 $dp[2]$ 时返回。其中，最小子问题的解是已知的，即爬到第 $1$ , $2$ 阶分别有 $1$ , $2$ 种方案。
+我们可以基于此递推公式写出暴力搜索代码：以 $dp[n]$ 为起始点，**从顶至底地将一个较大问题拆解为两个较小问题的和**，直至到达最小子问题 $dp[1]$ 和 $dp[2]$ 时返回。其中，最小子问题的解 $dp[1] = 1$ , $dp[2] = 2$ 是已知的，代表爬到第 $1$ , $2$ 阶分别有 $1$ , $2$ 种方案。
 
-观察以下代码，它与回溯解法都属于深度优先搜索，但比回溯算法更加简洁。
+观察以下代码，它和标准回溯代码都属于深度优先搜索，但更加简洁。
 
 === "Java"
 
@@ -346,7 +346,7 @@ $$
     [class]{}-[func]{climbingStairsDFS}
     ```
 
-下图展示了该方法形成的递归树。对于问题 $dp[n]$ ，递归树的深度为 $n$ ，时间复杂度为 $O(2^n)$ 。指数阶的运行时间增长地非常快，如果我们输入一个比较大的 $n$ ，则会陷入漫长的等待之中。
+下图展示了暴力搜索形成的递归树。对于问题 $dp[n]$ ，其递归树的深度为 $n$ ，时间复杂度为 $O(2^n)$ 。指数阶的运行时间增长地非常快，如果我们输入一个比较大的 $n$ ，则会陷入漫长的等待之中。
 
 ![爬楼梯对应递归树](intro_to_dynamic_programming.assets/climbing_stairs_dfs_tree.png)
 
@@ -654,10 +654,10 @@ $$
     [class]{}-[func]{climbingStairsDP}
     ```
 
-与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如对于爬楼梯问题，状态定义为当前所在楼梯阶数。**动态规划的常用术语包括**：
+与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如对于爬楼梯问题，状态定义为当前所在楼梯阶数 $i$ 。**动态规划的常用术语包括**：
 
 - 将 $dp$ 数组称为「状态列表」，$dp[i]$ 代表第 $i$ 个状态的解；
-- 将最简单子问题对应的状态（即第 $1$ , $2$ 阶楼梯）称为「初始状态」；
+- 将最小子问题对应的状态（即第 $1$ , $2$ 阶楼梯）称为「初始状态」；
 - 将递推公式 $dp[i] = dp[i-1] + dp[i-2]$ 称为「状态转移方程」；
 
 ![爬楼梯的动态规划过程](intro_to_dynamic_programming.assets/climbing_stairs_dp.png)

chapter_dynamic_programming/knapsack_problem.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 13.3.   0-1 背包问题
+# 13.4.   0-1 背包问题
 
 背包问题是一个非常好的动态规划入门题目，是动态规划中最常见的问题形式。其具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。
 
@@ -20,17 +20,26 @@ comments: true
 
 <p align="center"> Fig. 0-1 背包的示例数据 </p>
 
-在 0-1 背包问题中，每个物体都有不放入和放入两种决策。不放入背包，背包容量不变；放入背包，背包容量减小。由此可得：
+我们可以将 0-1 背包问题看作是一个由 $n$ 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。此外，该问题的目标是求解“在限定背包容量下的最大价值”，因此较大概率是个动态规划问题。我们接下来尝试求解它。
 
-- **状态包括物品编号 $i$ 和背包容量 $c$**，记为 $[i, c]$ 。
-- 状态 $[i, c]$ 对应子问题的解为：**前 $i$ 个物品在容量为 $c$ 背包中的最大价值**，记为 $dp[i, c]$ 。
+**第一步：思考每一轮的决策是什么，从而得到状态定义**
 
-我们可以将 0-1 背包求解过程看作是一个由 $n$ 轮决策组成的过程。从物品 $n$ 开始，当我们做出物品 $i$ 的决策后，剩余的是前 $i-1$ 个物品的决策。因此，状态转移分为两种情况：
+在 0-1 背包问题中，不放入背包，背包容量不变；放入背包，背包容量减小。由此可得状态定义：物品编号 $i$ 和背包容量 $c$ ，记为 $[i, c]$ 。
+
+**第二步：明确子问题是什么，从而得到 $dp$ 列表**
+
+状态 $[i, c]$ 对应的子问题为：**前 $i$ 个物品在容量为 $c$ 背包中的最大价值**，记为 $dp[i, c]$ 。
+
+至此，我们得到一个尺寸为 $n \times cap$ 的二维 $dp$ 矩阵。
+
+**第三步：找出最优子结构，进而推导出状态转移方程**
+
+当我们做出物品 $i$ 的决策后，剩余的是前 $i-1$ 个物品的决策。因此，状态转移分为两种情况：
 
 - **不放入物品 $i$** ：背包容量不变，状态转移至 $[i-1, c]$ ；
 - **放入物品 $i$** ：背包容量减小 $wgt[i-1]$ ，价值增加 $val[i-1]$ ，状态转移至 $[i-1, c-wgt[i-1]]$ ；
 
-上述的状态转移向我们展示了本题的「最优子结构」：**最大价值 $dp[i, c]$ 等于不放入物品 $i$ 和放入物品 $i$ 两种方案中的价值更大的那一个**。由此可推出状态转移方程：
+上述的状态转移向我们揭示了本题的最优子结构：**最大价值 $dp[i, c]$ 等于不放入物品 $i$ 和放入物品 $i$ 两种方案中的价值更大的那一个**。由此可推出状态转移方程：
 
 $$
 dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
@@ -38,13 +47,13 @@ $$
 
 需要注意的是，若当前物品重量 $wgt[i - 1]$ 超出剩余背包容量 $c$ ，则只能选择不放入背包。
 
-## 13.3.1. &nbsp; 方法一：暴力搜索
+## 13.4.1. &nbsp; 方法一：暴力搜索
 
 搜索代码包含以下要素：
 
 - **递归参数**：状态 $[i, c]$ ；**返回值**：子问题的解 $dp[i, c]$ 。
 - **终止条件**：当物品编号越界 $i = 0$ 或背包剩余容量为 $0$ 时，终止递归并返回价值 $0$ 。
-- **剪枝**：若当前物品重量 $wgt[i - 1]$ 超出剩余背包容量 $c$ ，则不能放入背包。
+- **剪枝**：若当前物品重量超出背包剩余容量，则只能不放入背包。
 
 === "Java"
 
@@ -126,15 +135,15 @@ $$
 
 如下图所示，由于每个物品都会产生不选和选两条搜索分支，因此最差时间复杂度为 $O(2^n)$ 。
 
-观察递归树，容易发现其中存在一些「重叠子问题」。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。
+观察递归树，容易发现其中存在一些「重叠子问题」，例如 $dp[1, 10]$ 等。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。
 
 ![0-1 背包的暴力搜索递归树](knapsack_problem.assets/knapsack_dfs.png)
 
 <p align="center"> Fig. 0-1 背包的暴力搜索递归树 </p>
 
-## 13.3.2. &nbsp; 方法二：记忆化搜索
+## 13.4.2. &nbsp; 方法二：记忆化搜索
 
-为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 记录解 $dp[i, c]$ 。
+为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 对应解 $dp[i, c]$ 。
 
 === "Java"
 
@@ -224,9 +233,9 @@ $$
 
 <p align="center"> Fig. 0-1 背包的记忆化搜索递归树 </p>
 
-## 13.3.3. &nbsp; 方法三：动态规划
+## 13.4.3. &nbsp; 方法三：动态规划
 
-接下来，我们将“从顶至底”的记忆化搜索代码译写为“从底至顶”的动态规划代码。
+动态规划解法本质上就是在状态转移中填充 `dp` 矩阵的过程，代码如下所示。
 
 === "Java"
 
@@ -308,7 +317,7 @@ $$
     [class]{}-[func]{knapsackDP}
     ```
 
-如下图所示，**动态规划本质上就是填充 $dp$ 矩阵的过程**，时间复杂度也为 $O(n \times cap)$ 。
+如下图所示，时间复杂度由 `dp` 矩阵大小决定，为 $O(n \times cap)$ 。
 
 === "<1>"
     ![0-1 背包的动态规划过程](knapsack_problem.assets/knapsack_dp_step1.png)
@@ -352,7 +361,7 @@ $$
 === "<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$ 行的状态，为了避免左边区域的格子在状态转移中被覆盖，我们应采取倒序遍历。
 
@@ -376,7 +385,7 @@ $$
 === "<6>"
     ![knapsack_dp_comp_step6](knapsack_problem.assets/knapsack_dp_comp_step6.png)
 
-如以下代码所示，我们仅需将 $dp$ 列表的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。
+如以下代码所示，我们仅需将 `dp` 矩阵的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。
 
 === "Java"
 

chapter_tree/avl_tree.md

@@ -1006,10 +1006,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
 
 | 失衡节点的平衡因子 | 子节点的平衡因子 | 应采用的旋转方法 |
 | ---------------- | ---------------- | ---------------- |
-| $>0$ （即左偏树）  | $\geq 0$         | 右旋             |
-| $>0$ （即左偏树）  | $<0$             | 先左旋后右旋     |
-| $<0$ （即右偏树）  | $\leq 0$         | 左旋             |
-| $<0$ （即右偏树）  | $>0$             | 先右旋后左旋     |
+| $>1$ （即左偏树）  | $\geq 0$         | 右旋             |
+| $>1$ （即左偏树）  | $<0$             | 先左旋后右旋     |
+| $<-1$ （即右偏树）  | $\leq 0$         | 左旋             |
+| $<-1$ （即右偏树）  | $>0$             | 先右旋后左旋     |
 
 </div>