build

chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 13.1.   初探动态规划
+# 14.1.   初探动态规划
 
 「动态规划 Dynamic Programming」是一种通过将复杂问题分解为更简单的子问题的方式来求解问题的方法。它将一个问题分解为一系列更小的子问题，并通过存储子问题的解来避免重复计算，从而大幅提升时间效率。
 
@@ -177,7 +177,23 @@ comments: true
 === "Zig"
 
     ```zig title="climbing_stairs_backtrack.zig"
-    [class]{}-[func]{backtrack}
+    // 回溯
+    fn backtrack(choices: []i32, state: i32, n: i32, res: std.ArrayList(i32)) void {
+        // 当爬到第 n 阶时，方案数量加 1
+        if (state == n) {
+            res.items[0] = res.items[0] + 1;
+        }
+        // 遍历所有选择
+        for (choices) |choice| {
+            // 剪枝：不允许越过第 n 阶
+            if (state + choice > n) {
+                break;
+            }
+            // 尝试：做出选择，更新状态
+            backtrack(choices, state + choice, n, res);
+            // 回退
+        }
+    }
 
     [class]{}-[func]{climbingStairsBacktrack}
     ```
@@ -190,7 +206,7 @@ comments: true
     [class]{}-[func]{climbingStairsBacktrack}
     ```
 
-## 13.1.1.   方法一：暴力搜索
+## 14.1.1.   方法一：暴力搜索
 
 回溯算法通常并不显式地对问题进行拆解，而是将问题看作一系列决策步骤，通过试探和剪枝，搜索所有可能的解。
 
@@ -335,7 +351,16 @@ $$
 === "Zig"
 
     ```zig title="climbing_stairs_dfs.zig"
-    [class]{}-[func]{dfs}
+    // 搜索
+    fn dfs(i: usize) i32 {
+        // 已知 dp[1] 和 dp[2] ，返回之
+        if (i == 1 or i == 2) {
+            return @intCast(i);
+        }
+        // dp[i] = dp[i-1] + dp[i-2]
+        var count = dfs(i - 1) + dfs(i - 2);
+        return count;
+    }
 
     [class]{}-[func]{climbingStairsDFS}
     ```
@@ -356,7 +381,7 @@ $$
 
 实际上，**指数阶的时间复杂度是由于「重叠子问题」导致的**。例如，问题 $dp[9]$ 被分解为子问题 $dp[8]$ 和 $dp[7]$ ，问题 $dp[8]$ 被分解为子问题 $dp[7]$ 和 $dp[6]$ ，两者都包含子问题 $dp[7]$ ，而子问题中又包含更小的重叠子问题，子子孙孙无穷尽也，绝大部分计算资源都浪费在这些重叠的问题上。
 
-## 13.1.2.   方法二：记忆化搜索
+## 14.1.2.   方法二：记忆化搜索
 
 为了提升算法效率，**我们希望所有的重叠子问题都只被计算一次**。具体来说，考虑借助一个数组 `mem` 来记录每个子问题的解，并在搜索过程中这样做：
 
@@ -510,7 +535,22 @@ $$
 === "Zig"
 
     ```zig title="climbing_stairs_dfs_mem.zig"
-    [class]{}-[func]{dfs}
+    // 记忆化搜索
+    fn dfs(i: usize, mem: []i32) i32 {
+        // 已知 dp[1] 和 dp[2] ，返回之
+        if (i == 1 or i == 2) {
+            return @intCast(i);
+        }
+        // 若存在记录 dp[i] ，则直接返回之
+        if (mem[i] != -1) {
+            return mem[i];
+        }
+        // dp[i] = dp[i-1] + dp[i-2]
+        var count = dfs(i - 1, mem) + dfs(i - 2, mem);
+        // 记录 dp[i]
+        mem[i] = count;
+        return count;
+    }
 
     [class]{}-[func]{climbingStairsDFSMem}
     ```
@@ -529,7 +569,7 @@ $$
 
 <p align="center"> Fig. 记忆化搜索对应递归树 </p>
 
-## 13.1.3. &nbsp; 方法三：动态规划
+## 14.1.3. &nbsp; 方法三：动态规划
 
 **记忆化搜索是一种“从顶至底”的方法**：我们从原问题（根节点）开始，递归地将较大子问题分解为较小子问题，直至解已知的最小子问题（叶节点）；最终通过回溯将子问题的解逐层收集，得到原问题的解。
 
@@ -779,5 +819,5 @@ $$
 总的看来，**子问题分解是一种通用的算法思路，在分治、动态规划、回溯中各有特点**：
 
 - 分治算法将原问题划分为几个独立的子问题，然后递归解决子问题，最后合并子问题的解得到原问题的解。例如，归并排序将长数组不断划分为两个短子数组，再将排序好的子数组合并为排序好的长数组。
-- 动态规划也是将原问题分解为多个子问题，但与分治算法的主要区别是，**动态规划中的子问题往往不是相互独立的**，原问题的解依赖于子问题的解，而子问题的解又依赖于更小的子问题的解。因此，动态规划通常会引入记忆化，保存已经解决的子问题的解，避免重复计算。
-- 回溯算法在尝试和回退中穷举所有可能的解，并通过剪枝避免不必要的搜索分支。原问题的解由一系列决策步骤构成，我们可以将每个决策步骤之后的剩余问题看作为一个子问题。
+- 动态规划也是将原问题分解为多个子问题，但与分治算法的主要区别是，**动态规划中的子问题往往不是相互独立的**，原问题的解依赖于子问题的解，而子问题的解又依赖于更小的子问题的解。
+- 回溯算法在尝试和回退中穷举所有可能的解，并通过剪枝避免不必要的搜索分支。原问题的解由一系列决策步骤构成，我们可以将每个决策步骤之前的子序列看作为一个子问题。