Fix a definition.

codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs

@@ -20,7 +20,7 @@ fn climbing_stairs_dp(n: usize) -> i32 {
     dp[n]
 }
 
-/* 爬楼梯：状态压缩后的动态规划 */
+/* 爬楼梯：空间优化后的动态规划 */
 fn climbing_stairs_dp_comp(n: usize) -> i32 {
     if n == 1 || n == 2 { return n as i32; }
     let (mut a, mut b) = (1, 2);

codes/rust/chapter_dynamic_programming/coin_change.rs

@@ -29,7 +29,7 @@ fn coin_change_dp(coins: &[i32], amt: usize) -> i32 {
     if dp[n][amt] != max { return dp[n][amt] as i32; } else { -1 }
 }
 
-/* 零钱兑换：状态压缩后的动态规划 */
+/* 零钱兑换：空间优化后的动态规划 */
 fn coin_change_dp_comp(coins: &[i32], amt: usize) -> i32 {
     let n = coins.len();
     let max = amt + 1;
@@ -61,7 +61,7 @@ pub fn main() {
     let res = coin_change_dp(&coins, amt);
     println!("凑到目标金额所需的最少硬币数量为 {res}");
 
-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
     let res = coin_change_dp_comp(&coins, amt);
     println!("凑到目标金额所需的最少硬币数量为 {res}");
 }

codes/rust/chapter_dynamic_programming/coin_change_ii.rs

@@ -28,7 +28,7 @@ fn coin_change_ii_dp(coins: &[i32], amt: usize) -> i32 {
     dp[n][amt]
 }
 
-/* 零钱兑换 II：状态压缩后的动态规划 */
+/* 零钱兑换 II：空间优化后的动态规划 */
 fn coin_change_ii_dp_comp(coins: &[i32], amt: usize) -> i32 {
     let n = coins.len();
     // 初始化 dp 表
@@ -58,7 +58,7 @@ pub fn main() {
     let res = coin_change_ii_dp(&coins, amt);
     println!("凑出目标金额的硬币组合数量为 {res}");
 
-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
     let res = coin_change_dp_ii_comp(&coins, amt);
     println!("凑出目标金额的硬币组合数量为 {res}");
 }

codes/rust/chapter_dynamic_programming/edit_distance.rs

@@ -73,7 +73,7 @@ fn edit_distance_dp(s: &str, t: &str) -> i32 {
     dp[n][m]
 }
 
-/* 编辑距离：状态压缩后的动态规划 */
+/* 编辑距离：空间优化后的动态规划 */
 fn edit_distance_dp_comp(s: &str, t: &str) -> i32 {
     let (n, m) = (s.len(), t.len());
     let mut dp = vec![0; m + 1];
@@ -124,7 +124,7 @@ pub fn main() {
     let res = edit_distance_dp(s, t);
     println!("将 {s} 更改为 {t} 最少需要编辑 {res} 步");
 
-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
     let res = edit_distance_dp_comp(s, t);
     println!("将 {s} 更改为 {t} 最少需要编辑 {res} 步");
 }

codes/rust/chapter_dynamic_programming/knapsack.rs

@@ -63,7 +63,7 @@ fn knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
     dp[n][cap]
 }
 
-/* 0-1 背包：状态压缩后的动态规划 */
+/* 0-1 背包：空间优化后的动态规划 */
 fn knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
     let n = wgt.len();
     // 初始化 dp 表
@@ -104,7 +104,7 @@ pub fn main() {
     let res = knapsack_dp(&wgt, &val, cap);
     println!("不超过背包容量的最大物品价值为 {res}");
 
-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
     let res = knapsack_dp_comp(&wgt, &val, cap);
     println!("不超过背包容量的最大物品价值为 {res}");
 }

codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs

@@ -22,7 +22,7 @@ fn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {
     dp[n]
 }
 
-/* 爬楼梯最小代价：状态压缩后的动态规划 */
+/* 爬楼梯最小代价：空间优化后的动态规划 */
 fn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {
     let n = cost.len() - 1;
     if n == 1 || n == 2 { return cost[n] };

codes/rust/chapter_dynamic_programming/min_path_sum.rs

@@ -66,7 +66,7 @@ fn min_path_sum_dp(grid: &Vec<Vec<i32>>) -> i32 {
     dp[n - 1][m - 1]
 }
 
-/* 最小路径和：状态压缩后的动态规划 */
+/* 最小路径和：空间优化后的动态规划 */
 fn min_path_sum_dp_comp(grid: &Vec<Vec<i32>>) -> i32 {
     let (n, m) = (grid.len(), grid[0].len());
     // 初始化 dp 表
@@ -113,7 +113,7 @@ pub fn main() {
     let res = min_path_sum_dp(&grid);
     println!("从左上角到右下角的最小路径和为 {res}");
 
-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
     let res = min_path_sum_dp_comp(&grid);
     println!("从左上角到右下角的最小路径和为 {res}");
 }

codes/rust/chapter_dynamic_programming/unbounded_knapsack.rs

@@ -24,7 +24,7 @@ fn unbounded_knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
     return dp[n][cap];
 }
 
-/* 完全背包：状态压缩后的动态规划 */
+/* 完全背包：空间优化后的动态规划 */
 fn unbounded_knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
     let n = wgt.len();
     // 初始化 dp 表
@@ -54,7 +54,7 @@ pub fn main() {
     let res = unbounded_knapsack_dp(&wgt, &val, cap);
     println!("不超过背包容量的最大物品价值为 {res}");
 
-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
     let res = unbounded_knapsack_dp_comp(&wgt, &val, cap);
     println!("不超过背包容量的最大物品价值为 {res}");
 }