build

chapter_array_and_linkedlist/array.md

@@ -1078,7 +1078,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     // 在数组中查找指定元素
     fn find(nums: []i32, target: i32) i32 {
         for (nums, 0..) |num, i| {
-            if (num == target) return @intCast(i32, i);
+            if (num == target) return @intCast(i);
         }
         return -1;
     }

chapter_computational_complexity/time_complexity.md

@@ -1703,7 +1703,7 @@ $$
     fn bubbleSort(nums: []i32) i32 {
         var count: i32 = 0;  // 计数器 
         // 外循环：未排序区间为 [0, i]
-        var i: i32 = @intCast(i32, nums.len ) - 1;
+        var i: i32 = @as(i32, @intCast(nums.len)) - 1;
         while (i > 0) : (i -= 1) {
             var j: usize = 0;
             // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 

chapter_dynamic_programming/dp_solution_pipeline.md

@@ -11,11 +11,11 @@ comments: true
 
 ## 13.3.1.   问题判断
 
-总的来说，如果一个问题包含重叠子问题、最优子结构，并满足无后效性，那么它通常就适合用动态规划求解。然而，我们很难从问题描述上直接提取出这些特性。因此我们通常会放宽条件，**先观察问题是否适合使用回溯（穷举）解决**。
+总的来说，如果一个问题包含重叠子问题、最优子结构，并满足无后效性，那么它通常就适合用动态规划求解，但我们很难从问题描述上直接提取出这些特性。因此我们通常会放宽条件，**先观察问题是否适合使用回溯（穷举）解决**。
 
-**适合用回溯解决的问题通常满足「决策树模型」**，这种问题可以使用树形结构来描述，其中每一个节点代表一个决策，每一条路径代表一个决策序列。
+**适合用回溯解决的问题通常满足“决策树模型”**，这种问题可以使用树形结构来描述，其中每一个节点代表一个决策，每一条路径代表一个决策序列。
 
-换句话说，**如果问题包含明确的决策概念，并且解是通过一系列决策产生的，那么它就满足决策树模型**，可以使用回溯来解决。
+换句话说，如果问题包含明确的决策概念，并且解是通过一系列决策产生的，那么它就满足决策树模型，通常可以使用回溯来解决。
 
 在此基础上，还有一些判断问题是动态规划问题的“加分项”，包括：
 
@@ -110,19 +110,49 @@ $$
 === "Java"
 
     ```java title="min_path_sum.java"
-    [class]{min_path_sum}-[func]{minPathSumDFS}
+    /* 最小路径和：暴力搜索 */
+    int minPathSumDFS(int[][] grid, int i, int j) {
+        // 若为左上角单元格，则终止搜索
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if (i < 0 || j < 0) {
+            return Integer.MAX_VALUE;
+        }
+        // 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价
+        int left = minPathSumDFS(grid, i - 1, j);
+        int up = minPathSumDFS(grid, i, j - 1);
+        // 返回从左上角到 (i, j) 的最小路径代价
+        return Math.min(left, up) + grid[i][j];
+    }
     ```
 
 === "C++"
 
     ```cpp title="min_path_sum.cpp"
-    [class]{}-[func]{minPathSumDFS}
+    /* 最小路径和：暴力搜索 */
+    int minPathSumDFS(vector<vector<int>> &grid, int i, int j) {
+        // 若为左上角单元格，则终止搜索
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if (i < 0 || j < 0) {
+            return INT_MAX;
+        }
+        // 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价
+        int left = minPathSumDFS(grid, i - 1, j);
+        int up = minPathSumDFS(grid, i, j - 1);
+        // 返回从左上角到 (i, j) 的最小路径代价
+        return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
+    }
     ```
 
 === "Python"
 
     ```python title="min_path_sum.py"
-    def min_path_sum_dfs(grid, i, j):
+    def min_path_sum_dfs(grid: list[list[int]], i: int, j: int) -> int:
         """最小路径和：暴力搜索"""
         # 若为左上角单元格，则终止搜索
         if i == 0 and j == 0:
@@ -164,7 +194,22 @@ $$
 === "C#"
 
     ```csharp title="min_path_sum.cs"
-    [class]{min_path_sum}-[func]{minPathSumDFS}
+    /* 最小路径和：暴力搜索 */
+    int minPathSumDFS(int[][] grid, int i, int j) {
+        // 若为左上角单元格，则终止搜索
+        if (i == 0 && j == 0){
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if (i < 0 || j < 0) {
+            return int.MaxValue;
+        }
+        // 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价
+        int left = minPathSumDFS(grid, i - 1, j);
+        int up = minPathSumDFS(grid, i, j - 1);
+        // 返回从左上角到 (i, j) 的最小路径代价
+        return Math.Min(left, up) + grid[i][j];
+    }
     ```
 
 === "Swift"
@@ -202,19 +247,61 @@ $$
 === "Java"
 
     ```java title="min_path_sum.java"
-    [class]{min}-[func]{minPathSumDFSMem}
+    /* 最小路径和：记忆化搜索 */
+    int minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
+        // 若为左上角单元格，则终止搜索
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if (i < 0 || j < 0) {
+            return Integer.MAX_VALUE;
+        }
+        // 若已有记录，则直接返回
+        if (mem[i][j] != -1) {
+            return mem[i][j];
+        }
+        // 左边和上边单元格的最小路径代价
+        int left = minPathSumDFSMem(grid, mem, i - 1, j);
+        int up = minPathSumDFSMem(grid, mem, i, j - 1);
+        // 记录并返回左上角到 (i, j) 的最小路径代价
+        mem[i][j] = Math.min(left, up) + grid[i][j];
+        return mem[i][j];
+    }
     ```
 
 === "C++"
 
     ```cpp title="min_path_sum.cpp"
-    [class]{}-[func]{minPathSumDFSMem}
+    /* 最小路径和：记忆化搜索 */
+    int minPathSumDFSMem(vector<vector<int>> &grid, vector<vector<int>> &mem, int i, int j) {
+        // 若为左上角单元格，则终止搜索
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if (i < 0 || j < 0) {
+            return INT_MAX;
+        }
+        // 若已有记录，则直接返回
+        if (mem[i][j] != -1) {
+            return mem[i][j];
+        }
+        // 左边和上边单元格的最小路径代价
+        int left = minPathSumDFSMem(grid, mem, i - 1, j);
+        int up = minPathSumDFSMem(grid, mem, i, j - 1);
+        // 记录并返回左上角到 (i, j) 的最小路径代价
+        mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
+        return mem[i][j];
+    }
     ```
 
 === "Python"
 
     ```python title="min_path_sum.py"
-    def min_path_sum_dfs_mem(grid, mem, i, j):
+    def min_path_sum_dfs_mem(
+        grid: list[list[int]], mem: list[list[int]], i: int, j: int
+    ) -> int:
         """最小路径和：记忆化搜索"""
         # 若为左上角单元格，则终止搜索
         if i == 0 and j == 0:
@@ -260,7 +347,27 @@ $$
 === "C#"
 
     ```csharp title="min_path_sum.cs"
-    [class]{min_path_sum}-[func]{minPathSumDFSMem}
+    /* 最小路径和：记忆化搜索 */
+    int minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
+        // 若为左上角单元格，则终止搜索
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if (i < 0 || j < 0) {
+            return int.MaxValue;
+        }
+        // 若已有记录，则直接返回
+        if (mem[i][j] != -1) {
+            return mem[i][j];
+        }
+        // 左边和上边单元格的最小路径代价
+        int left = minPathSumDFSMem(grid, mem, i - 1, j);
+        int up = minPathSumDFSMem(grid, mem, i, j - 1);
+        // 记录并返回左上角到 (i, j) 的最小路径代价
+        mem[i][j] = Math.Min(left, up) + grid[i][j];
+        return mem[i][j];
+    }
     ```
 
 === "Swift"
@@ -300,13 +407,34 @@ $$
 === "C++"
 
     ```cpp title="min_path_sum.cpp"
-    [class]{}-[func]{minPathSumDP}
+    /* 最小路径和：动态规划 */
+    int minPathSumDP(vector<vector<int>> &grid) {
+        int n = grid.size(), m = grid[0].size();
+        // 初始化 dp 表
+        vector<vector<int>> dp(n, vector<int>(m));
+        dp[0][0] = grid[0][0];
+        // 状态转移：首行
+        for (int j = 1; j < m; j++) {
+            dp[0][j] = dp[0][j - 1] + grid[0][j];
+        }
+        // 状态转移：首列
+        for (int i = 1; i < n; i++) {
+            dp[i][0] = dp[i - 1][0] + grid[i][0];
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i < n; i++) {
+            for (int j = 1; j < m; j++) {
+                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
+            }
+        }
+        return dp[n - 1][m - 1];
+    }
     ```
 
 === "Python"
 
     ```python title="min_path_sum.py"
-    def min_path_sum_dp(grid):
+    def min_path_sum_dp(grid: list[list[int]]) -> int:
         """最小路径和：动态规划"""
         n, m = len(grid), len(grid[0])
         # 初始化 dp 表
@@ -352,7 +480,28 @@ $$
 === "C#"
 
     ```csharp title="min_path_sum.cs"
-    [class]{min_path_sum}-[func]{minPathSumDP}
+    /* 最小路径和：动态规划 */
+    int minPathSumDP(int[][] grid) {
+        int n = grid.Length, m = grid[0].Length;
+        // 初始化 dp 表
+        int[,] dp = new int[n, m];
+        dp[0, 0] = grid[0][0];
+        // 状态转移：首行
+        for (int j = 1; j < m; j++) {
+            dp[0, j] = dp[0, j - 1] + grid[0][j];
+        }
+        // 状态转移：首列
+        for (int i = 1; i < n; i++) {
+            dp[i, 0] = dp[i - 1, 0] + grid[i][0];
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i < n; i++) {
+            for (int j = 1; j < m; j++) {
+                dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];
+            }
+        }
+        return dp[n - 1, m - 1];
+    }
     ```
 
 === "Swift"
@@ -424,13 +573,33 @@ $$
 === "C++"
 
     ```cpp title="min_path_sum.cpp"
-    [class]{}-[func]{minPathSumDPComp}
+    /* 最小路径和：状态压缩后的动态规划 */
+    int minPathSumDPComp(vector<vector<int>> &grid) {
+        int n = grid.size(), m = grid[0].size();
+        // 初始化 dp 表
+        vector<int> dp(m);
+        // 状态转移：首行
+        dp[0] = grid[0][0];
+        for (int j = 1; j < m; j++) {
+            dp[j] = dp[j - 1] + grid[0][j];
+        }
+        // 状态转移：其余行
+        for (int i = 1; i < n; i++) {
+            // 状态转移：首列
+            dp[0] = dp[0] + grid[i][0];
+            // 状态转移：其余列
+            for (int j = 1; j < m; j++) {
+                dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];
+            }
+        }
+        return dp[m - 1];
+    }
     ```
 
 === "Python"
 
     ```python title="min_path_sum.py"
-    def min_path_sum_dp_comp(grid):
+    def min_path_sum_dp_comp(grid: list[list[int]]) -> int:
         """最小路径和：状态压缩后的动态规划"""
         n, m = len(grid), len(grid[0])
         # 初始化 dp 表
@@ -476,7 +645,27 @@ $$
 === "C#"
 
     ```csharp title="min_path_sum.cs"
-    [class]{min_path_sum}-[func]{minPathSumDPComp}
+    /* 最小路径和：状态压缩后的动态规划 */
+    int minPathSumDPComp(int[][] grid) {
+        int n = grid.Length, m = grid[0].Length;
+        // 初始化 dp 表
+        int[] dp = new int[m];
+        dp[0] = grid[0][0];
+        // 状态转移：首行
+        for (int j = 1; j < m; j++) {
+            dp[j] = dp[j - 1] + grid[0][j];
+        }
+        // 状态转移：其余行
+        for (int i = 1; i < n; i++) {
+            // 状态转移：首列
+            dp[0] = dp[0] + grid[i][0];
+            // 状态转移：其余列
+            for (int j = 1; j < m; j++) {
+                dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];
+            }
+        }
+        return dp[m - 1];
+    }
     ```
 
 === "Swift"

chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -4,9 +4,9 @@ comments: true
 
 # 13.1.   初探动态规划
 
-「动态规划 Dynamic Programming」是一种用于解决复杂问题的优化算法，它把一个问题分解为一系列更小的子问题，并把子问题的解存储起来以供后续使用，从而避免了重复计算，提升了解题效率。
+「动态规划 Dynamic Programming」是一种通过将复杂问题分解为更简单的子问题的方式来求解问题的方法。它将一个问题分解为一系列更小的子问题，并通过存储子问题的解来避免重复计算，从而大幅提升时间效率。
 
-在本节中，我们先从一个动态规划的经典例题入手，先给出它的暴力回溯解法，观察其中包含的重叠子问题，再一步步导出更高效的动态规划解法。
+在本节中，我们从一个经典例题入手，先给出它的暴力回溯解法，观察其中包含的重叠子问题，再逐步导出更高效的动态规划解法。
 
 !!! question "爬楼梯"
 

chapter_dynamic_programming/knapsack_problem.md

@@ -10,7 +10,7 @@ comments: true
 
 !!! question
 
-    给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$ 、价值为 $val[i-1]$ ，现在有个容量为 $cap$ 的背包，请求解在不超过背包容量下背包中物品的最大价值。
+    给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$ 、价值为 $val[i-1]$ ，现在有个容量为 $cap$ 的背包，每个物品只能选择一次，问在不超过背包容量下背包中物品的最大价值。
     
     请注意，物品编号 $i$ 从 $1$ 开始计数，数组索引从 $0$ 开始计数，因此物品 $i$ 对应重量 $wgt[i-1]$ 和价值 $val[i-1]$ 。
 
@@ -62,19 +62,49 @@ $$
 === "Java"
 
     ```java title="knapsack.java"
-    [class]{knapsack}-[func]{knapsackDFS}
+    /* 0-1 背包：暴力搜索 */
+    int knapsackDFS(int[] wgt, int[] val, int i, int c) {
+        // 若已选完所有物品或背包无容量，则返回价值 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // 若超过背包容量，则只能不放入背包
+        if (wgt[i - 1] > c) {
+            return knapsackDFS(wgt, val, i - 1, c);
+        }
+        // 计算不放入和放入物品 i 的最大价值
+        int no = knapsackDFS(wgt, val, i - 1, c);
+        int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
+        // 返回两种方案中价值更大的那一个
+        return Math.max(no, yes);
+    }
     ```
 
 === "C++"
 
     ```cpp title="knapsack.cpp"
-    [class]{}-[func]{knapsackDFS}
+    /* 0-1 背包：暴力搜索 */
+    int knapsackDFS(vector<int> &wgt, vector<int> &val, int i, int c) {
+        // 若已选完所有物品或背包无容量，则返回价值 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // 若超过背包容量，则只能不放入背包
+        if (wgt[i - 1] > c) {
+            return knapsackDFS(wgt, val, i - 1, c);
+        }
+        // 计算不放入和放入物品 i 的最大价值
+        int no = knapsackDFS(wgt, val, i - 1, c);
+        int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
+        // 返回两种方案中价值更大的那一个
+        return max(no, yes);
+    }
     ```
 
 === "Python"
 
     ```python title="knapsack.py"
-    def knapsack_dfs(wgt, val, i, c):
+    def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -> int:
         """0-1 背包：暴力搜索"""
         # 若已选完所有物品或背包无容量，则返回价值 0
         if i == 0 or c == 0:
@@ -116,7 +146,22 @@ $$
 === "C#"
 
     ```csharp title="knapsack.cs"
-    [class]{knapsack}-[func]{knapsackDFS}
+    /* 0-1 背包：暴力搜索 */
+    int knapsackDFS(int[] weight, int[] val, int i, int c) {
+        // 若已选完所有物品或背包无容量，则返回价值 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // 若超过背包容量，则只能不放入背包
+        if (weight[i - 1] > c) {
+            return knapsackDFS(weight, val, i - 1, c);
+        }
+        // 计算不放入和放入物品 i 的最大价值
+        int no = knapsackDFS(weight, val, i - 1, c);
+        int yes = knapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];
+        // 返回两种方案中价值更大的那一个
+        return Math.Max(no, yes);
+    }
     ```
 
 === "Swift"
@@ -152,19 +197,61 @@ $$
 === "Java"
 
     ```java title="knapsack.java"
-    [class]{knapsack}-[func]{knapsackDFSMem}
+    /* 0-1 背包：记忆化搜索 */
+    int knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {
+        // 若已选完所有物品或背包无容量，则返回价值 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // 若已有记录，则直接返回
+        if (mem[i][c] != -1) {
+            return mem[i][c];
+        }
+        // 若超过背包容量，则只能不放入背包
+        if (wgt[i - 1] > c) {
+            return knapsackDFSMem(wgt, val, mem, i - 1, c);
+        }
+        // 计算不放入和放入物品 i 的最大价值
+        int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
+        int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
+        // 记录并返回两种方案中价值更大的那一个
+        mem[i][c] = Math.max(no, yes);
+        return mem[i][c];
+    }
     ```
 
 === "C++"
 
     ```cpp title="knapsack.cpp"
-    [class]{}-[func]{knapsackDFSMem}
+    /* 0-1 背包：记忆化搜索 */
+    int knapsackDFSMem(vector<int> &wgt, vector<int> &val, vector<vector<int>> &mem, int i, int c) {
+        // 若已选完所有物品或背包无容量，则返回价值 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // 若已有记录，则直接返回
+        if (mem[i][c] != -1) {
+            return mem[i][c];
+        }
+        // 若超过背包容量，则只能不放入背包
+        if (wgt[i - 1] > c) {
+            return knapsackDFSMem(wgt, val, mem, i - 1, c);
+        }
+        // 计算不放入和放入物品 i 的最大价值
+        int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
+        int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
+        // 记录并返回两种方案中价值更大的那一个
+        mem[i][c] = max(no, yes);
+        return mem[i][c];
+    }
     ```
 
 === "Python"
 
     ```python title="knapsack.py"
-    def knapsack_dfs_mem(wgt, val, mem, i, c):
+    def knapsack_dfs_mem(
+        wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int
+    ) -> int:
         """0-1 背包：记忆化搜索"""
         # 若已选完所有物品或背包无容量，则返回价值 0
         if i == 0 or c == 0:
@@ -210,7 +297,27 @@ $$
 === "C#"
 
     ```csharp title="knapsack.cs"
-    [class]{knapsack}-[func]{knapsackDFSMem}
+    /* 0-1 背包：记忆化搜索 */
+    int knapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {
+        // 若已选完所有物品或背包无容量，则返回价值 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // 若已有记录，则直接返回
+        if (mem[i][c] != -1) {
+            return mem[i][c];
+        }
+        // 若超过背包容量，则只能不放入背包
+        if (weight[i - 1] > c) {
+            return knapsackDFSMem(weight, val, mem, i - 1, c);
+        }
+        // 计算不放入和放入物品 i 的最大价值
+        int no = knapsackDFSMem(weight, val, mem, i - 1, c);
+        int yes = knapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];
+        // 记录并返回两种方案中价值更大的那一个
+        mem[i][c] = Math.Max(no, yes);
+        return mem[i][c];
+    }
     ```
 
 === "Swift"
@@ -244,19 +351,55 @@ $$
 === "Java"
 
     ```java title="knapsack.java"
-    [class]{knapsack}-[func]{knapsackDP}
+    /* 0-1 背包：动态规划 */
+    int knapsackDP(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 - 1][c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[n][cap];
+    }
     ```
 
 === "C++"
 
     ```cpp title="knapsack.cpp"
-    [class]{}-[func]{knapsackDP}
+    /* 0-1 背包：动态规划 */
+    int knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
+        int n = wgt.size();
+        // 初始化 dp 表
+        vector<vector<int>> dp(n + 1, vector<int>(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 - 1][c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[n][cap];
+    }
     ```
 
 === "Python"
 
     ```python title="knapsack.py"
-    def knapsack_dp(wgt, val, cap):
+    def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
         """0-1 背包：动态规划"""
         n = len(wgt)
         # 初始化 dp 表
@@ -269,7 +412,7 @@ $$
                     dp[i][c] = dp[i - 1][c]
                 else:
                     # 不选和选物品 i 这两种方案的较大值
-                    dp[i][c] = max(dp[i - 1][c - wgt[i - 1]] + val[i - 1], dp[i - 1][c])
+                    dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])
         return dp[n][cap]
     ```
 
@@ -300,7 +443,25 @@ $$
 === "C#"
 
     ```csharp title="knapsack.cs"
-    [class]{knapsack}-[func]{knapsackDP}
+    /* 0-1 背包：动态规划 */
+    int knapsackDP(int[] weight, int[] val, int cap) {
+        int n = weight.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 (weight[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[i, c] = dp[i - 1, c];
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);
+                }
+            }
+        }
+        return dp[n, cap];
+    }
     ```
 
 === "Swift"
@@ -394,19 +555,51 @@ $$
 === "Java"
 
     ```java title="knapsack.java"
-    [class]{knapsack}-[func]{knapsackDPComp}
+    /* 0-1 背包：状态压缩后的动态规划 */
+    int knapsackDPComp(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 = cap; c >= 1; c--) {
+                if (wgt[i - 1] <= c) {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
     ```
 
 === "C++"
 
     ```cpp title="knapsack.cpp"
-    [class]{}-[func]{knapsackDPComp}
+    /* 0-1 背包：状态压缩后的动态规划 */
+    int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
+        int n = wgt.size();
+        // 初始化 dp 表
+        vector<int> dp(cap + 1, 0);
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            // 倒序遍历
+            for (int c = cap; c >= 1; c--) {
+                if (wgt[i - 1] <= c) {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
     ```
 
 === "Python"
 
     ```python title="knapsack.py"
-    def knapsack_dp_comp(wgt, val, cap):
+    def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
         """0-1 背包：状态压缩后的动态规划"""
         n = len(wgt)
         # 初始化 dp 表
@@ -420,7 +613,7 @@ $$
                     dp[c] = dp[c]
                 else:
                     # 不选和选物品 i 这两种方案的较大值
-                    dp[c] = max(dp[c - wgt[i - 1]] + val[i - 1], dp[c])
+                    dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])
         return dp[cap]
     ```
 
@@ -451,7 +644,26 @@ $$
 === "C#"
 
     ```csharp title="knapsack.cs"
-    [class]{knapsack}-[func]{knapsackDPComp}
+    /* 0-1 背包：状态压缩后的动态规划 */
+    int knapsackDPComp(int[] weight, int[] val, int cap) {
+        int n = weight.Length;
+        // 初始化 dp 表
+        int[] dp = new int[cap + 1];
+        // 状态转移
+        for (int i = 1; i <= n; i++) {
+            // 倒序遍历
+            for (int c = cap; c > 0; c--) {
+                if (weight[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[c] = dp[c];
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
     ```
 
 === "Swift"

chapter_searching/binary_search.md

@@ -271,7 +271,7 @@ comments: true
             } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m-1] 中
                 j = m - 1;
             } else {                                // 找到目标元素，返回其索引
-                return @intCast(T, m);
+                return @intCast(m);
             }
         }
         // 未找到目标元素，返回 -1
@@ -538,7 +538,7 @@ comments: true
             } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m) 中
                 j = m;
             } else {                                // 找到目标元素，返回其索引
-                return @intCast(T, m);
+                return @intCast(m);
             }
         }
         // 未找到目标元素，返回 -1

chapter_searching/replace_linear_by_hashing.md

@@ -185,7 +185,7 @@ comments: true
             var j = i + 1;
             while (j < size) : (j += 1) {
                 if (nums[i] + nums[j] == target) {
-                    return [_]i32{@intCast(i32, i), @intCast(i32, j)};
+                    return [_]i32{@intCast(i), @intCast(j)};
                 }
             }
         }
@@ -437,9 +437,9 @@ comments: true
         // 单层循环，时间复杂度 O(n)
         while (i < size) : (i += 1) {
             if (dic.contains(target - nums[i])) {
-                return [_]i32{dic.get(target - nums[i]).?, @intCast(i32, i)};
+                return [_]i32{dic.get(target - nums[i]).?, @intCast(i)};
             }
-            try dic.put(nums[i], @intCast(i32, i));
+            try dic.put(nums[i], @intCast(i));
         }
         return null;
     }

chapter_sorting/radix_sort.md

@@ -539,7 +539,7 @@ $$
         var n = nums.len;
         // 统计 0~9 各数字的出现次数
         for (nums) |num| {
-            var d = @bitCast(u32, digit(num, exp)); // 获取 nums[i] 第 k 位，记为 d
+            var d: u32 = @bitCast(digit(num, exp)); // 获取 nums[i] 第 k 位，记为 d
             counter[d] += 1; // 统计数字 d 的出现次数
         }
         // 求前缀和，将“出现个数”转换为“数组索引”
@@ -551,7 +551,7 @@ $$
         var res = try mem_allocator.alloc(i32, n);
         i = n - 1;
         while (i >= 0) : (i -= 1) {
-            var d = @bitCast(u32, digit(nums[i], exp));
+            var d: u32 = @bitCast(digit(nums[i], exp));
             var j = counter[d] - 1; // 获取 d 在数组中的索引 j
             res[j] = nums[i];       // 将当前元素填入索引 j
             counter[d] -= 1;        // 将 d 的数量减 1

chapter_tree/avl_tree.md

@@ -369,7 +369,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
     // 更新节点高度
     fn updateHeight(self: *Self, node: ?*inc.TreeNode(T)) void {
         // 节点高度等于最高子树高度 + 1
-        node.?.height = std.math.max(self.height(node.?.left), self.height(node.?.right)) + 1;
+        node.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1;
     }
     ```