build

chapter_dynamic_programming/dp_solution_pipeline.md

@@ -279,6 +279,27 @@ $$
     [class]{}-[func]{minPathSumDFS}
     ```
 
+=== "Rust"
+
+    ```rust title="min_path_sum.rs"
+    /* 最小路径和：暴力搜索 */
+    fn min_path_sum_dfs(grid: &Vec<Vec<i32>>, i: i32, j: i32) -> i32 {
+        // 若为左上角单元格，则终止搜索
+        if i == 0 && j == 0 {
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if i < 0 || j < 0 {
+            return i32::MAX;
+        }
+        // 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价
+        let left = min_path_sum_dfs(grid, i - 1, j);
+        let up = min_path_sum_dfs(grid, i, j - 1);
+        // 返回从左上角到 (i, j) 的最小路径代价
+        std::cmp::min(left, up) + grid[i as usize][j as usize]
+    }
+    ```
+
 下图给出了以 $dp[2, 1]$ 为根节点的递归树，其中包含一些重叠子问题，其数量会随着网格 `grid` 的尺寸变大而急剧增多。
 
 本质上看，造成重叠子问题的原因为：**存在多条路径可以从左上角到达某一单元格**。
@@ -498,6 +519,32 @@ $$
     [class]{}-[func]{minPathSumDFSMem}
     ```
 
+=== "Rust"
+
+    ```rust title="min_path_sum.rs"
+    /* 最小路径和：记忆化搜索 */
+    fn min_path_sum_dfs_mem(grid: &Vec<Vec<i32>>, mem: &mut Vec<Vec<i32>>, i: i32, j: i32) -> i32 {
+        // 若为左上角单元格，则终止搜索
+        if i == 0 && j == 0 {
+            return grid[0][0];
+        }
+        // 若行列索引越界，则返回 +∞ 代价
+        if i < 0 || j < 0 {
+            return i32::MAX;
+        }
+        // 若已有记录，则直接返回
+        if mem[i as usize][j as usize] != -1 {
+            return mem[i as usize][j as usize];
+        }
+        // 左边和上边单元格的最小路径代价
+        let left = min_path_sum_dfs_mem(grid, mem, i - 1, j);
+        let up = min_path_sum_dfs_mem(grid, mem, i, j - 1);
+        // 记录并返回左上角到 (i, j) 的最小路径代价
+        mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];
+        mem[i as usize][j as usize]
+    }
+    ```
+
 引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 $O(nm)$ 。
 
 ![记忆化搜索递归树](dp_solution_pipeline.assets/min_path_sum_dfs_mem.png)
@@ -721,6 +768,33 @@ $$
     [class]{}-[func]{minPathSumDP}
     ```
 
+=== "Rust"
+
+    ```rust title="min_path_sum.rs"
+    /* 最小路径和：动态规划 */
+    fn min_path_sum_dp(grid: &Vec<Vec<i32>>) -> i32 {
+        let (n, m) = (grid.len(), grid[0].len());
+        // 初始化 dp 表
+        let mut dp = vec![vec![0; m]; n];
+        dp[0][0] = grid[0][0];
+        // 状态转移：首行
+        for j in 1..m {
+            dp[0][j] = dp[0][j - 1] + grid[0][j];
+        }
+        // 状态转移：首列
+        for i in 1..n {
+            dp[i][0] = dp[i - 1][0] + grid[i][0];
+        }
+        // 状态转移：其余行列
+        for i in 1..n {
+            for j in 1..m {
+                dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
+            }
+        }
+        dp[n - 1][m - 1]
+    }
+    ```
+
 下图展示了最小路径和的状态转移过程，其遍历了整个网格，**因此时间复杂度为 $O(nm)$** 。
 
 数组 `dp` 大小为 $n \times m$ ，**因此空间复杂度为 $O(nm)$** 。
@@ -969,3 +1043,29 @@ $$
     ```dart title="min_path_sum.dart"
     [class]{}-[func]{minPathSumDPComp}
     ```
+
+=== "Rust"
+
+    ```rust title="min_path_sum.rs"
+    /* 最小路径和：状态压缩后的动态规划 */
+    fn min_path_sum_dp_comp(grid: &Vec<Vec<i32>>) -> i32 {
+        let (n, m) = (grid.len(), grid[0].len());
+        // 初始化 dp 表
+        let mut dp = vec![0; m];
+        // 状态转移：首行
+        dp[0] = grid[0][0];
+        for j in 1..m {
+            dp[j] = dp[j - 1] + grid[0][j];
+        }
+        // 状态转移：其余行
+        for i in 1..n {
+            // 状态转移：首列
+            dp[0] = dp[0] + grid[i][0];
+            // 状态转移：其余列
+            for j in 1..m {
+                dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];
+            }
+        }
+        dp[m - 1]
+    }
+    ```