Update knapsack_problem and intro_to_dp

Fix avl_tree

codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp

@@ -11,7 +11,7 @@ int climbingStairsConstraintDP(int n) {
     if (n == 1 || n == 2) {
         return n;
     }
-    // 初始化 dp 列表，用于存储子问题的解
+    // 初始化 dp 表，用于存储子问题的解
     vector<vector<int>> dp(n + 1, vector<int>(3, 0));
     // 初始状态：预设最小子问题的解
     dp[1][1] = 1;

codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp

@@ -10,7 +10,7 @@
 int climbingStairsDP(int n) {
     if (n == 1 || n == 2)
         return n;
-    // 初始化 dp 列表，用于存储子问题的解
+    // 初始化 dp 表，用于存储子问题的解
     vector<int> dp(n + 1);
     // 初始状态：预设最小子问题的解
     dp[1] = 1;

codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp

@@ -11,7 +11,7 @@ int minCostClimbingStairsDP(vector<int> &cost) {
     int n = cost.size() - 1;
     if (n == 1 || n == 2)
         return cost[n];
-    // 初始化 dp 列表，用于存储子问题的解
+    // 初始化 dp 表，用于存储子问题的解
     vector<int> dp(n + 1);
     // 初始状态：预设最小子问题的解
     dp[1] = cost[1];

codes/csharp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cs

@@ -12,7 +12,7 @@ public class climbing_stairs_constraint_dp {
         if (n == 1 || n == 2) {
             return n;
         }
-        // 初始化 dp 列表，用于存储子问题的解
+        // 初始化 dp 表，用于存储子问题的解
         int[,] dp = new int[n + 1, 3];
         // 初始状态：预设最小子问题的解
         dp[1, 1] = 1;

codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs

@@ -11,7 +11,7 @@ public class climbing_stairs_dp {
     public int climbingStairsDP(int n) {
         if (n == 1 || n == 2)
             return n;
-        // 初始化 dp 列表，用于存储子问题的解
+        // 初始化 dp 表，用于存储子问题的解
         int[] dp = new int[n + 1];
         // 初始状态：预设最小子问题的解
         dp[1] = 1;

codes/csharp/chapter_dynamic_programming/knapsack.cs

@@ -49,7 +49,7 @@ public class knapsack {
     /* 0-1 背包：动态规划 */
     public int knapsack_dp(int[] weight, int[] val, int cap) {
         int n = weight.Length;
-        // 初始化 dp 列表
+        // 初始化 dp 表
         int[,] dp = new int[n + 1, cap + 1];
         // 状态转移
         for (int i = 1; i <= n; i++) {
@@ -69,7 +69,7 @@ public class knapsack {
     /* 0-1 背包：状态压缩后的动态规划 */
     public int knapsack_dp_comp(int[] weight, int[] val, int cap) {
         int n = weight.Length;
-        // 初始化 dp 列表
+        // 初始化 dp 表
         int[] dp = new int[cap + 1];
         // 状态转移
         for (int i = 1; i <= n; i++) {

codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs

@@ -12,7 +12,7 @@ public class min_cost_climbing_stairs_dp {
         int n = cost.Length - 1;
         if (n == 1 || n == 2)
             return cost[n];
-        // 初始化 dp 列表，用于存储子问题的解
+        // 初始化 dp 表，用于存储子问题的解
         int[] dp = new int[n + 1];
         // 初始状态：预设最小子问题的解
         dp[1] = cost[1];

codes/java/chapter_dynamic_programming/climbing_stairs_constraint_dp.java

@@ -12,7 +12,7 @@ public class climbing_stairs_constraint_dp {
         if (n == 1 || n == 2) {
             return n;
         }
-        // 初始化 dp 列表，用于存储子问题的解
+        // 初始化 dp 表，用于存储子问题的解
         int[][] dp = new int[n + 1][3];
         // 初始状态：预设最小子问题的解
         dp[1][1] = 1;

codes/java/chapter_dynamic_programming/climbing_stairs_dp.java

@@ -11,7 +11,7 @@ public class climbing_stairs_dp {
     public static int climbingStairsDP(int n) {
         if (n == 1 || n == 2)
             return n;
-        // 初始化 dp 列表，用于存储子问题的解
+        // 初始化 dp 表，用于存储子问题的解
         int[] dp = new int[n + 1];
         // 初始状态：预设最小子问题的解
         dp[1] = 1;

codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java

@@ -14,7 +14,7 @@ public class min_cost_climbing_stairs_dp {
         int n = cost.length - 1;
         if (n == 1 || n == 2)
             return cost[n];
-        // 初始化 dp 列表，用于存储子问题的解
+        // 初始化 dp 表，用于存储子问题的解
         int[] dp = new int[n + 1];
         // 初始状态：预设最小子问题的解
         dp[1] = cost[1];

codes/python/chapter_dynamic_programming/climbing_stairs_constraint_dp.py

@@ -9,7 +9,7 @@ def climbing_stairs_constraint_dp(n: int) -> int:
     """带约束爬楼梯：动态规划"""
     if n == 1 or n == 2:
         return n
-    # 初始化 dp 列表，用于存储子问题的解
+    # 初始化 dp 表，用于存储子问题的解
     dp = [[0] * 3 for _ in range(n + 1)]
     # 初始状态：预设最小子问题的解
     dp[1][1], dp[1][2] = 1, 0

codes/python/chapter_dynamic_programming/climbing_stairs_dp.py

@@ -9,7 +9,7 @@ def climbing_stairs_dp(n: int) -> int:
     """爬楼梯：动态规划"""
     if n == 1 or n == 2:
         return n
-    # 初始化 dp 列表，用于存储子问题的解
+    # 初始化 dp 表，用于存储子问题的解
     dp = [0] * (n + 1)
     # 初始状态：预设最小子问题的解
     dp[1], dp[2] = 1, 2

codes/python/chapter_dynamic_programming/knapsack.py

@@ -42,7 +42,7 @@ def knapsack_dfs_mem(wgt, val, mem, i, c):
 def knapsack_dp(wgt, val, cap):
     """0-1 背包：动态规划"""
     n = len(wgt)
-    # 初始化 dp 列表
+    # 初始化 dp 表
     dp = [[0] * (cap + 1) for _ in range(n + 1)]
     # 状态转移
     for i in range(1, n + 1):
@@ -59,7 +59,7 @@ def knapsack_dp(wgt, val, cap):
 def knapsack_dp_comp(wgt, val, cap):
     """0-1 背包：状态压缩后的动态规划"""
     n = len(wgt)
-    # 初始化 dp 列表
+    # 初始化 dp 表
     dp = [0] * (cap + 1)
     # 状态转移
     for i in range(1, n + 1):

codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py

@@ -10,7 +10,7 @@ def min_cost_climbing_stairs_dp(cost: list[int]) -> int:
     n = len(cost) - 1
     if n == 1 or n == 2:
         return cost[n]
-    # 初始化 dp 列表，用于存储子问题的解
+    # 初始化 dp 表，用于存储子问题的解
     dp = [0] * (n + 1)
     # 初始状态：预设最小子问题的解
     dp[1], dp[2] = cost[1], cost[2]

docs/chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -122,9 +122,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"
 
@@ -214,7 +214,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)
 
@@ -393,15 +393,15 @@ $$
     [class]{}-[func]{climbingStairsDP}
     ```
 
-与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如对于爬楼梯问题，状态定义为当前所在楼梯阶数。**动态规划的常用术语包括**：
+与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如对于爬楼梯问题，状态定义为当前所在楼梯阶数 $i$ 。**动态规划的常用术语包括**：
 
-- 将 $dp$ 数组称为「状态列表」，$dp[i]$ 代表第 $i$ 个状态的解；
-- 将最简单子问题对应的状态（即第 $1$ , $2$ 阶楼梯）称为「初始状态」；
+- 将数组 `dp` 称为「$dp$ 表」，$dp[i]$ 表示状态 $i$ 对应子问题的解；
+- 将最小子问题对应的状态（即第 $1$ , $2$ 阶楼梯）称为「初始状态」；
 - 将递推公式 $dp[i] = dp[i-1] + dp[i-2]$ 称为「状态转移方程」；
 
 ![爬楼梯的动态规划过程](intro_to_dynamic_programming.assets/climbing_stairs_dp.png)
 
-细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有状态**，而只需两个变量滚动前进即可。如以下代码所示，由于省去了数组 `dp` 占用的空间，因此空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
+细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。如以下代码所示，由于省去了数组 `dp` 占用的空间，因此空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
 
 === "Java"
 

docs/chapter_dynamic_programming/knapsack_problem.md

@@ -1,44 +1,57 @@
 # 0-1 背包问题
 
-背包问题是学习动态规划的一个非常好的入门题目，其涉及到“选择与不选择”和“限制条件下的最优化”等问题，是动态规划中最常见的问题形式。
+背包问题是一个非常好的动态规划入门题目，是动态规划中最常见的问题形式。其具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。
 
-背包问题具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。在本节中，我们先来学习最简单的 0-1 背包问题。
+在本节中，我们先来学习基础的的 0-1 背包问题。
 
 !!! question
 
     给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$ 、价值为 $val[i-1]$ ，现在有个容量为 $cap$ 的背包，请求解在不超过背包容量下背包中物品的最大价值。
     
-    请注意，物品编号 $i$ 从 $1$ 开始计数，但数组索引从 $0$ 开始计数，因此物品 $i$ 对应重量 $wgt[i-1]$ 和价值 $val[i-1]$ 。
+    请注意，物品编号 $i$ 从 $1$ 开始计数，数组索引从 $0$ 开始计数，因此物品 $i$ 对应重量 $wgt[i-1]$ 和价值 $val[i-1]$ 。
 
 下图给出了一个 0-1 背包的示例数据，背包内的最大价值为 $220$ 。
 
 ![0-1 背包的示例数据](knapsack_problem.assets/knapsack_example.png)
 
-接下来，我们仍然先从回溯角度入手，先给出暴力搜索解法；再引入记忆化处理，得到记忆化搜索和动态规划解法。
+我们可以将 0-1 背包问题看作是一个由 $n$ 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。此外，该问题的目标是求解“在限定背包容量下的最大价值”，因此较大概率是个动态规划问题。我们接下来尝试求解它。
 
-## 方法一：暴力搜索
+**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表**
+
+在 0-1 背包问题中，不放入背包，背包容量不变；放入背包，背包容量减小。由此可得状态定义：当前物品编号 $i$ 和剩余背包容量 $c$ ，记为 $[i, c]$ 。
+
+状态 $[i, c]$ 对应的子问题为：**前 $i$ 个物品在剩余容量为 $c$ 的背包中的最大价值**，记为 $dp[i, c]$ 。
 
-0-1 背包问题是一道典型的“选或不选”的问题，0 代表不选、1 代表选。我们可以将 0-1 背包看作是一个由 $n$ 轮决策组成的搜索过程，对于每个物体都有不放入和放入两种决策。不放入背包，背包容量不变；放入背包，背包容量减小。由此可得：
+至此，我们得到一个尺寸为 $n \times cap$ 的二维 $dp$ 矩阵。
 
-- **状态包括物品编号 $i$ 和背包容量 $c$**，记为 $[i, c]$ 。
-- 状态 $[i, c]$ 对应子问题“**前 $i$ 个物品在容量为 $c$ 背包中的最大价值**”，解记为 $dp[i, c]$ 。
+**第二步：找出最优子结构，进而推导出状态转移方程**
 
-当我们做出物品 $i$ 的决策后，剩余的是前 $i-1$ 个物品的子问题，因此状态转移分为两种：
+当我们做出物品 $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])
 $$
 
-以下是暴力搜索的实现代码，其中包含以下要素：
+需要注意的是，若当前物品重量 $wgt[i - 1]$ 超出剩余背包容量 $c$ ，则只能选择不放入背包。
+
+**第三步：确定边界条件和状态转移顺序**
+
+当无物品或无剩余背包容量时最大价值为 $0$ ，即所有 $dp[i, 0]$ 和 $dp[0, c]$ 都等于 $0$ 。
+
+当前状态 $[i, c]$ 从上方的状态 $[i-1, c]$ 和左上方的状态 $[i-1, c-wgt[i-1]]$ 转移而来，因此通过两层循环正序遍历整个 $dp$ 表即可。
+
+## 方法一：暴力搜索
+
+搜索代码包含以下要素：
 
 - **递归参数**：状态 $[i, c]$ ；**返回值**：子问题的解 $dp[i, c]$ 。
-- **终止条件**：当已完成 $n$ 轮决策或背包无剩余容量为时，终止递归并返回价值 $0$ 。
-- **剪枝**：若当前物品重量 $wgt[i - 1]$ 超出剩余背包容量 $c$ ，则只能选择不放入背包。
+- **终止条件**：当物品编号越界 $i = 0$ 或背包剩余容量为 $0$ 时，终止递归并返回价值 $0$ 。
+- **剪枝**：若当前物品重量超出背包剩余容量，则只能不放入背包。
 
 === "Java"
 
@@ -108,13 +121,13 @@ $$
 
 如下图所示，由于每个物品都会产生不选和选两条搜索分支，因此最差时间复杂度为 $O(2^n)$ 。
 
-观察递归树，容易发现其中存在一些「重叠子问题」。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。
+观察递归树，容易发现其中存在一些「重叠子问题」，例如 $dp[1, 10]$ 等。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。
 
 ![0-1 背包的暴力搜索递归树](knapsack_problem.assets/knapsack_dfs.png)
 
 ## 方法二：记忆化搜索
 
-为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 表示前 $i$ 个物品在容量为 $c$ 背包中的最大价值。当再次遇到相同子问题时，直接从 `mem` 中获取记录。
+为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 对应解 $dp[i, c]$ 。
 
 === "Java"
 
@@ -182,13 +195,13 @@ $$
     [class]{}-[func]{knapsackDFSMem}
     ```
 
-引入记忆化之后，所有子问题最多只被计算一次，**因此时间复杂度取决于子问题数量**，也就是 $O(n \times cap)$ 。
+引入记忆化之后，所有子问题都只被计算一次，**因此时间复杂度取决于子问题数量**，也就是 $O(n \times cap)$ 。
 
 ![0-1 背包的记忆化搜索递归树](knapsack_problem.assets/knapsack_dfs_mem.png)
 
 ## 方法三：动态规划
 
-接下来就是体力活了，我们将“从顶至底”的记忆化搜索代码译写为“从底至顶”的动态规划代码。
+动态规划解法本质上就是在状态转移中填充 `dp` 矩阵的过程，代码如下所示。
 
 === "Java"
 
@@ -256,7 +269,7 @@ $$
     [class]{}-[func]{knapsackDP}
     ```
 
-观察下图，动态规划的过程本质上就是填充 $dp$ 列表（矩阵）的过程，时间复杂度也为 $O(n \times cap)$ 。
+如下图所示，时间复杂度由 `dp` 矩阵大小决定，为 $O(n \times cap)$ 。
 
 === "<1>"
     ![0-1 背包的动态规划过程](knapsack_problem.assets/knapsack_dp_step1.png)
@@ -300,9 +313,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$ 行的过程。建议你思考一下正序遍历和倒序遍历的区别。
 
@@ -324,7 +337,7 @@ $$
 === "<6>"
     ![knapsack_dp_comp_step6](knapsack_problem.assets/knapsack_dp_comp_step6.png)
 
-如以下代码所示，我们仅需将 $dp$ 列表的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。
+如以下代码所示，我们仅需将 `dp` 矩阵的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。
 
 === "Java"
 

docs/chapter_tree/avl_tree.md

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