build

chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -305,9 +305,31 @@ status: new
 === "Dart"
 
     ```dart title="climbing_stairs_backtrack.dart"
-    [class]{}-[func]{backtrack}
+    /* 回溯 */
+    void backtrack(List<int> choices, int state, int n, List<int> res) {
+      // 当爬到第 n 阶时，方案数量加 1
+      if (state == n) {
+        res[0]++;
+      }
+      // 遍历所有选择
+      for (int choice in choices) {
+        // 剪枝：不允许越过第 n 阶
+        if (state + choice > n) break;
+        // 尝试：做出选择，更新状态
+        backtrack(choices, state + choice, n, res);
+        // 回退
+      }
+    }
 
-    [class]{}-[func]{climbingStairsBacktrack}
+    /* 爬楼梯：回溯 */
+    int climbingStairsBacktrack(int n) {
+      List<int> choices = [1, 2]; // 可选择向上爬 1 或 2 阶
+      int state = 0; // 从第 0 阶开始爬
+      List<int> res = [];
+      res.add(0); // 使用 res[0] 记录方案数量
+      backtrack(choices, state, n, res);
+      return res[0];
+    }
     ```
 
 === "Rust"
@@ -550,9 +572,19 @@ $$
 === "Dart"
 
     ```dart title="climbing_stairs_dfs.dart"
-    [class]{}-[func]{dfs}
+    /* 搜索 */
+    int dfs(int i) {
+      // 已知 dp[1] 和 dp[2] ，返回之
+      if (i == 1 || i == 2) return i;
+      // dp[i] = dp[i-1] + dp[i-2]
+      int count = dfs(i - 1) + dfs(i - 2);
+      return count;
+    }
 
-    [class]{}-[func]{climbingStairsDFS}
+    /* 爬楼梯：搜索 */
+    int climbingStairsDFS(int n) {
+      return dfs(n);
+    }
     ```
 
 === "Rust"
@@ -840,9 +872,25 @@ $$
 === "Dart"
 
     ```dart title="climbing_stairs_dfs_mem.dart"
-    [class]{}-[func]{dfs}
+    /* 记忆化搜索 */
+    int dfs(int i, List<int> mem) {
+      // 已知 dp[1] 和 dp[2] ，返回之
+      if (i == 1 || i == 2) return i;
+      // 若存在记录 dp[i] ，则直接返回之
+      if (mem[i] != -1) return mem[i];
+      // dp[i] = dp[i-1] + dp[i-2]
+      int count = dfs(i - 1, mem) + dfs(i - 2, mem);
+      // 记录 dp[i]
+      mem[i] = count;
+      return count;
+    }
 
-    [class]{}-[func]{climbingStairsDFSMem}
+    /* 爬楼梯：记忆化搜索 */
+    int climbingStairsDFSMem(int n) {
+      // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
+      List<int> mem = List.filled(n + 1, -1);
+      return dfs(n, mem);
+    }
     ```
 
 === "Rust"
@@ -1071,7 +1119,20 @@ $$
 === "Dart"
 
     ```dart title="climbing_stairs_dp.dart"
-    [class]{}-[func]{climbingStairsDP}
+    /* 爬楼梯：动态规划 */
+    int climbingStairsDP(int n) {
+      if (n == 1 || n == 2) return n;
+      // 初始化 dp 表，用于存储子问题的解
+      List<int> dp = List.filled(n + 1, 0);
+      // 初始状态：预设最小子问题的解
+      dp[1] = 1;
+      dp[2] = 2;
+      // 状态转移：从较小子问题逐步求解较大子问题
+      for (int i = 3; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+      }
+      return dp[n];
+    }
     ```
 
 === "Rust"
@@ -1270,7 +1331,17 @@ $$
 === "Dart"
 
     ```dart title="climbing_stairs_dp.dart"
-    [class]{}-[func]{climbingStairsDPComp}
+    /* 爬楼梯：状态压缩后的动态规划 */
+    int climbingStairsDPComp(int n) {
+      if (n == 1 || n == 2) return n;
+      int a = 1, b = 2;
+      for (int i = 3; i <= n; i++) {
+        int tmp = b;
+        b = a + b;
+        a = tmp;
+      }
+      return b;
+    }
     ```
 
 === "Rust"