Fix a definition.

2026-07-16 11:02:09 +08:00 · 2023-08-27 00:50:18 +08:00
parent debf42b189
commit 9731a46d67
85 changed files with 167 additions and 159 deletions
--- a/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp
+++ b/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp
@@ -22,7 +22,7 @@ int climbingStairsDP(int n) {
    return dp[n];
 }

-/* 爬楼梯：状态压缩后的动态规划 */
+/* 爬楼梯：空间优化后的动态规划 */
 int climbingStairsDPComp(int n) {
    if (n == 1 || n == 2)
        return n;
--- a/codes/cpp/chapter_dynamic_programming/coin_change.cpp
+++ b/codes/cpp/chapter_dynamic_programming/coin_change.cpp
@@ -31,7 +31,7 @@ int coinChangeDP(vector<int> &coins, int amt) {
    return dp[n][amt] != MAX ? dp[n][amt] : -1;
 }

-/* 零钱兑换：状态压缩后的动态规划 */
+/* 零钱兑换：空间优化后的动态规划 */
 int coinChangeDPComp(vector<int> &coins, int amt) {
    int n = coins.size();
    int MAX = amt + 1;
@@ -62,7 +62,7 @@ int main() {
    int res = coinChangeDP(coins, amt);
    cout << "凑到目标金额所需的最少硬币数量为 " << res << endl;

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = coinChangeDPComp(coins, amt);
    cout << "凑到目标金额所需的最少硬币数量为 " << res << endl;

--- a/codes/cpp/chapter_dynamic_programming/coin_change_ii.cpp
+++ b/codes/cpp/chapter_dynamic_programming/coin_change_ii.cpp
@@ -30,7 +30,7 @@ int coinChangeIIDP(vector<int> &coins, int amt) {
    return dp[n][amt];
 }

-/* 零钱兑换 II：状态压缩后的动态规划 */
+/* 零钱兑换 II：空间优化后的动态规划 */
 int coinChangeIIDPComp(vector<int> &coins, int amt) {
    int n = coins.size();
    // 初始化 dp 表
@@ -60,7 +60,7 @@ int main() {
    int res = coinChangeIIDP(coins, amt);
    cout << "凑出目标金额的硬币组合数量为 " << res << endl;

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = coinChangeIIDPComp(coins, amt);
    cout << "凑出目标金额的硬币组合数量为 " << res << endl;

--- a/codes/cpp/chapter_dynamic_programming/edit_distance.cpp
+++ b/codes/cpp/chapter_dynamic_programming/edit_distance.cpp
@@ -80,7 +80,7 @@ int editDistanceDP(string s, string t) {
    return dp[n][m];
 }

-/* 编辑距离：状态压缩后的动态规划 */
+/* 编辑距离：空间优化后的动态规划 */
 int editDistanceDPComp(string s, string t) {
    int n = s.length(), m = t.length();
    vector<int> dp(m + 1, 0);
@@ -128,7 +128,7 @@ int main() {
    res = editDistanceDP(s, t);
    cout << "将 " << s << " 更改为 " << t << " 最少需要编辑 " << res << " 步\n";

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = editDistanceDPComp(s, t);
    cout << "将 " << s << " 更改为 " << t << " 最少需要编辑 " << res << " 步\n";

--- a/codes/cpp/chapter_dynamic_programming/knapsack.cpp
+++ b/codes/cpp/chapter_dynamic_programming/knapsack.cpp
@@ -63,7 +63,7 @@ int knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
    return dp[n][cap];
 }

-/* 0-1 背包：状态压缩后的动态规划 */
+/* 0-1 背包：空间优化后的动态规划 */
 int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
    int n = wgt.size();
    // 初始化 dp 表
@@ -101,7 +101,7 @@ int main() {
    res = knapsackDP(wgt, val, cap);
    cout << "不超过背包容量的最大物品价值为 " << res << endl;

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = knapsackDPComp(wgt, val, cap);
    cout << "不超过背包容量的最大物品价值为 " << res << endl;

--- a/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp
+++ b/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp
@@ -23,7 +23,7 @@ int minCostClimbingStairsDP(vector<int> &cost) {
    return dp[n];
 }

-/* 爬楼梯最小代价：状态压缩后的动态规划 */
+/* 爬楼梯最小代价：空间优化后的动态规划 */
 int minCostClimbingStairsDPComp(vector<int> &cost) {
    int n = cost.size() - 1;
    if (n == 1 || n == 2)
--- a/codes/cpp/chapter_dynamic_programming/min_path_sum.cpp
+++ b/codes/cpp/chapter_dynamic_programming/min_path_sum.cpp
@@ -68,7 +68,7 @@ int minPathSumDP(vector<vector<int>> &grid) {
    return dp[n - 1][m - 1];
 }

-/* 最小路径和：状态压缩后的动态规划 */
+/* 最小路径和：空间优化后的动态规划 */
 int minPathSumDPComp(vector<vector<int>> &grid) {
    int n = grid.size(), m = grid[0].size();
    // 初始化 dp 表
@@ -108,7 +108,7 @@ int main() {
    res = minPathSumDP(grid);
    cout << "从左上角到右下角的最小路径和为 " << res << endl;

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = minPathSumDPComp(grid);
    cout << "从左上角到右下角的最小路径和为 " << res << endl;

--- a/codes/cpp/chapter_dynamic_programming/unbounded_knapsack.cpp
+++ b/codes/cpp/chapter_dynamic_programming/unbounded_knapsack.cpp
@@ -26,7 +26,7 @@ int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
    return dp[n][cap];
 }

-/* 完全背包：状态压缩后的动态规划 */
+/* 完全背包：空间优化后的动态规划 */
 int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
    int n = wgt.size();
    // 初始化 dp 表
@@ -56,7 +56,7 @@ int main() {
    int res = unboundedKnapsackDP(wgt, val, cap);
    cout << "不超过背包容量的最大物品价值为 " << res << endl;

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = unboundedKnapsackDPComp(wgt, val, cap);
    cout << "不超过背包容量的最大物品价值为 " << res << endl;

--- a/codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs
+++ b/codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs
@@ -23,7 +23,7 @@ public class climbing_stairs_dp {
        return dp[n];
    }

-    /* 爬楼梯：状态压缩后的动态规划 */
+    /* 爬楼梯：空间优化后的动态规划 */
    public int climbingStairsDPComp(int n) {
        if (n == 1 || n == 2)
            return n;
--- a/codes/csharp/chapter_dynamic_programming/coin_change.cs
+++ b/codes/csharp/chapter_dynamic_programming/coin_change.cs
@@ -32,7 +32,7 @@ public class coin_change {
        return dp[n, amt] != MAX ? dp[n, amt] : -1;
    }

-    /* 零钱兑换：状态压缩后的动态规划 */
+    /* 零钱兑换：空间优化后的动态规划 */
    public int coinChangeDPComp(int[] coins, int amt) {
        int n = coins.Length;
        int MAX = amt + 1;
@@ -64,7 +64,7 @@ public class coin_change {
        int res = coinChangeDP(coins, amt);
        Console.WriteLine("凑到目标金额所需的最少硬币数量为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = coinChangeDPComp(coins, amt);
        Console.WriteLine("凑到目标金额所需的最少硬币数量为 " + res);
    }
--- a/codes/csharp/chapter_dynamic_programming/coin_change_ii.cs
+++ b/codes/csharp/chapter_dynamic_programming/coin_change_ii.cs
@@ -31,7 +31,7 @@ public class coin_change_ii {
        return dp[n, amt];
    }

-    /* 零钱兑换 II：状态压缩后的动态规划 */
+    /* 零钱兑换 II：空间优化后的动态规划 */
    public int coinChangeIIDPComp(int[] coins, int amt) {
        int n = coins.Length;
        // 初始化 dp 表
@@ -61,7 +61,7 @@ public class coin_change_ii {
        int res = coinChangeIIDP(coins, amt);
        Console.WriteLine("凑出目标金额的硬币组合数量为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = coinChangeIIDPComp(coins, amt);
        Console.WriteLine("凑出目标金额的硬币组合数量为 " + res);
    }
--- a/codes/csharp/chapter_dynamic_programming/edit_distance.cs
+++ b/codes/csharp/chapter_dynamic_programming/edit_distance.cs
@@ -81,7 +81,7 @@ public class edit_distance {
        return dp[n, m];
    }

-    /* 编辑距离：状态压缩后的动态规划 */
+    /* 编辑距离：空间优化后的动态规划 */
    public int editDistanceDPComp(string s, string t) {
        int n = s.Length, m = t.Length;
        int[] dp = new int[m + 1];
@@ -134,7 +134,7 @@ public class edit_distance {
        res = editDistanceDP(s, t);
        Console.WriteLine("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = editDistanceDPComp(s, t);
        Console.WriteLine("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");
    }
--- a/codes/csharp/chapter_dynamic_programming/knapsack.cs
+++ b/codes/csharp/chapter_dynamic_programming/knapsack.cs
@@ -66,7 +66,7 @@ public class knapsack {
        return dp[n, cap];
    }

-    /* 0-1 背包：状态压缩后的动态规划 */
+    /* 0-1 背包：空间优化后的动态规划 */
    public int knapsackDPComp(int[] weight, int[] val, int cap) {
        int n = weight.Length;
        // 初始化 dp 表
@@ -111,7 +111,7 @@ public class knapsack {
        res = knapsackDP(weight, val, cap);
        Console.WriteLine("不超过背包容量的最大物品价值为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = knapsackDPComp(weight, val, cap);
        Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
    }
--- a/codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs
+++ b/codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs
@@ -24,7 +24,7 @@ public class min_cost_climbing_stairs_dp {
        return dp[n];
    }

-    /* 爬楼梯最小代价：状态压缩后的动态规划 */
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
    public int minCostClimbingStairsDPComp(int[] cost) {
        int n = cost.Length - 1;
        if (n == 1 || n == 2)
--- a/codes/csharp/chapter_dynamic_programming/min_path_sum.cs
+++ b/codes/csharp/chapter_dynamic_programming/min_path_sum.cs
@@ -69,7 +69,7 @@ public class min_path_sum {
        return dp[n - 1, m - 1];
    }

-    /* 最小路径和：状态压缩后的动态规划 */
+    /* 最小路径和：空间优化后的动态规划 */
    public int minPathSumDPComp(int[][] grid) {
        int n = grid.Length, m = grid[0].Length;
        // 初始化 dp 表
@@ -120,7 +120,7 @@ public class min_path_sum {
        res = minPathSumDP(grid);
        Console.WriteLine("从左上角到右下角的做小路径和为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = minPathSumDPComp(grid);
        Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
    }
--- a/codes/csharp/chapter_dynamic_programming/unbounded_knapsack.cs
+++ b/codes/csharp/chapter_dynamic_programming/unbounded_knapsack.cs
@@ -27,7 +27,7 @@ public class unbounded_knapsack {
        return dp[n, cap];
    }

-    /* 完全背包：状态压缩后的动态规划 */
+    /* 完全背包：空间优化后的动态规划 */
    public int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
        int n = wgt.Length;
        // 初始化 dp 表
@@ -57,7 +57,7 @@ public class unbounded_knapsack {
        int res = unboundedKnapsackDP(wgt, val, cap);
        Console.WriteLine("不超过背包容量的最大物品价值为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = unboundedKnapsackDPComp(wgt, val, cap);
        Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
    }
--- a/codes/dart/chapter_dynamic_programming/climbing_stairs_dp.dart
+++ b/codes/dart/chapter_dynamic_programming/climbing_stairs_dp.dart
@@ -19,7 +19,7 @@ int climbingStairsDP(int n) {
  return dp[n];
 }

-/* 爬楼梯：状态压缩后的动态规划 */
+/* 爬楼梯：空间优化后的动态规划 */
 int climbingStairsDPComp(int n) {
  if (n == 1 || n == 2) return n;
  int a = 1, b = 2;
--- a/codes/dart/chapter_dynamic_programming/coin_change.dart
+++ b/codes/dart/chapter_dynamic_programming/coin_change.dart
@@ -31,7 +31,7 @@ int coinChangeDP(List<int> coins, int amt) {
  return dp[n][amt] != MAX ? dp[n][amt] : -1;
 }

-/* 零钱兑换：状态压缩后的动态规划 */
+/* 零钱兑换：空间优化后的动态规划 */
 int coinChangeDPComp(List<int> coins, int amt) {
  int n = coins.length;
  int MAX = amt + 1;
@@ -62,7 +62,7 @@ void main() {
  int res = coinChangeDP(coins, amt);
  print("凑到目标金额所需的最少硬币数量为 $res");

-  // 状态压缩后的动态规划
+  // 空间优化后的动态规划
  res = coinChangeDPComp(coins, amt);
  print("凑到目标金额所需的最少硬币数量为 $res");
 }
--- a/codes/dart/chapter_dynamic_programming/coin_change_ii.dart
+++ b/codes/dart/chapter_dynamic_programming/coin_change_ii.dart
@@ -28,7 +28,7 @@ int coinChangeIIDP(List<int> coins, int amt) {
  return dp[n][amt];
 }

-/* 零钱兑换 II：状态压缩后的动态规划 */
+/* 零钱兑换 II：空间优化后的动态规划 */
 int coinChangeIIDPComp(List<int> coins, int amt) {
  int n = coins.length;
  // 初始化 dp 表
@@ -58,7 +58,7 @@ void main() {
  int res = coinChangeIIDP(coins, amt);
  print("凑出目标金额的硬币组合数量为 $res");

-  // 状态压缩后的动态规划
+  // 空间优化后的动态规划
  res = coinChangeIIDPComp(coins, amt);
  print("凑出目标金额的硬币组合数量为 $res");
 }
--- a/codes/dart/chapter_dynamic_programming/edit_distance.dart
+++ b/codes/dart/chapter_dynamic_programming/edit_distance.dart
@@ -71,7 +71,7 @@ int editDistanceDP(String s, String t) {
  return dp[n][m];
 }

-/* 编辑距离：状态压缩后的动态规划 */
+/* 编辑距离：空间优化后的动态规划 */
 int editDistanceDPComp(String s, String t) {
  int n = s.length, m = t.length;
  List<int> dp = List.filled(m + 1, 0);
@@ -119,7 +119,7 @@ void main() {
  res = editDistanceDP(s, t);
  print("将 " + s + " 更改为 " + t + " 最少需要编辑 $res 步");

-  // 状态压缩后的动态规划
+  // 空间优化后的动态规划
  res = editDistanceDPComp(s, t);
  print("将 " + s + " 更改为 " + t + " 最少需要编辑 $res 步");
 }
--- a/codes/dart/chapter_dynamic_programming/knapsack.dart
+++ b/codes/dart/chapter_dynamic_programming/knapsack.dart
@@ -71,7 +71,7 @@ int knapsackDP(List<int> wgt, List<int> val, int cap) {
  return dp[n][cap];
 }

-/* 0-1 背包：状态压缩后的动态规划 */
+/* 0-1 背包：空间优化后的动态规划 */
 int knapsackDPComp(List<int> wgt, List<int> val, int cap) {
  int n = wgt.length;
  // 初始化 dp 表
@@ -110,7 +110,7 @@ void main() {
  res = knapsackDP(wgt, val, cap);
  print("不超过背包容量的最大物品价值为 $res");

-  // 状态压缩后的动态规划
+  // 空间优化后的动态规划
  res = knapsackDPComp(wgt, val, cap);
  print("不超过背包容量的最大物品价值为 $res");
 }
--- a/codes/dart/chapter_dynamic_programming/min_cost_climbing_stairs_dp.dart
+++ b/codes/dart/chapter_dynamic_programming/min_cost_climbing_stairs_dp.dart
@@ -22,7 +22,7 @@ int minCostClimbingStairsDP(List<int> cost) {
  return dp[n];
 }

-/* 爬楼梯最小代价：状态压缩后的动态规划 */
+/* 爬楼梯最小代价：空间优化后的动态规划 */
 int minCostClimbingStairsDPComp(List<int> cost) {
  int n = cost.length - 1;
  if (n == 1 || n == 2) return cost[n];
--- a/codes/dart/chapter_dynamic_programming/min_path_sum.dart
+++ b/codes/dart/chapter_dynamic_programming/min_path_sum.dart
@@ -70,7 +70,7 @@ int minPathSumDP(List<List<int>> grid) {
  return dp[n - 1][m - 1];
 }

-/* 最小路径和：状态压缩后的动态规划 */
+/* 最小路径和：空间优化后的动态规划 */
 int minPathSumDPComp(List<List<int>> grid) {
  int n = grid.length, m = grid[0].length;
  // 初始化 dp 表
@@ -114,7 +114,7 @@ void main() {
  res = minPathSumDP(grid);
  print("从左上角到右下角的做小路径和为 $res");

-// 状态压缩后的动态规划
+// 空间优化后的动态规划
  res = minPathSumDPComp(grid);
  print("从左上角到右下角的做小路径和为 $res");
 }
--- a/codes/dart/chapter_dynamic_programming/unbounded_knapsack.dart
+++ b/codes/dart/chapter_dynamic_programming/unbounded_knapsack.dart
@@ -26,7 +26,7 @@ int unboundedKnapsackDP(List<int> wgt, List<int> val, int cap) {
  return dp[n][cap];
 }

-/* 完全背包：状态压缩后的动态规划 */
+/* 完全背包：空间优化后的动态规划 */
 int unboundedKnapsackDPComp(List<int> wgt, List<int> val, int cap) {
  int n = wgt.length;
  // 初始化 dp 表
@@ -56,7 +56,7 @@ void main() {
  int res = unboundedKnapsackDP(wgt, val, cap);
  print("不超过背包容量的最大物品价值为 $res");

-  // 状态压缩后的动态规划
+  // 空间优化后的动态规划
  int resComp = unboundedKnapsackDPComp(wgt, val, cap);
  print("不超过背包容量的最大物品价值为 $resComp");
 }
--- a/codes/go/chapter_dynamic_programming/climbing_stairs_dp.go
+++ b/codes/go/chapter_dynamic_programming/climbing_stairs_dp.go
@@ -21,7 +21,7 @@ func climbingStairsDP(n int) int {
 	return dp[n]
 }

-/* 爬楼梯：状态压缩后的动态规划 */
+/* 爬楼梯：空间优化后的动态规划 */
 func climbingStairsDPComp(n int) int {
 	if n == 1 || n == 2 {
 		return n
--- a/codes/go/chapter_dynamic_programming/coin_change_ii.go
+++ b/codes/go/chapter_dynamic_programming/coin_change_ii.go
@@ -31,7 +31,7 @@ func coinChangeIIDP(coins []int, amt int) int {
 	return dp[n][amt]
 }

-/* 零钱兑换 II：状态压缩后的动态规划 */
+/* 零钱兑换 II：空间优化后的动态规划 */
 func coinChangeIIDPComp(coins []int, amt int) int {
 	n := len(coins)
 	// 初始化 dp 表
--- a/codes/go/chapter_dynamic_programming/coin_change_test.go
+++ b/codes/go/chapter_dynamic_programming/coin_change_test.go
@@ -17,7 +17,7 @@ func TestCoinChange(t *testing.T) {
 	res := coinChangeDP(coins, amt)
 	fmt.Printf("凑到目标金额所需的最少硬币数量为 %d\n", res)

-	// 状态压缩后的动态规划
+	// 空间优化后的动态规划
 	res = coinChangeDPComp(coins, amt)
 	fmt.Printf("凑到目标金额所需的最少硬币数量为 %d\n", res)
 }
--- a/codes/go/chapter_dynamic_programming/edit_distance.go
+++ b/codes/go/chapter_dynamic_programming/edit_distance.go
@@ -91,7 +91,7 @@ func editDistanceDP(s string, t string) int {
 	return dp[n][m]
 }

-/* 编辑距离：状态压缩后的动态规划 */
+/* 编辑距离：空间优化后的动态规划 */
 func editDistanceDPComp(s string, t string) int {
 	n := len(s)
 	m := len(t)
--- a/codes/go/chapter_dynamic_programming/edit_distance_test.go
+++ b/codes/go/chapter_dynamic_programming/edit_distance_test.go
@@ -34,7 +34,7 @@ func TestEditDistanceDFS(test *testing.T) {
 	res = editDistanceDP(s, t)
 	fmt.Printf("将 %s 更改为 %s 最少需要编辑 %d 步\n", s, t, res)

-	// 状态压缩后的动态规划
+	// 空间优化后的动态规划
 	res = editDistanceDPComp(s, t)
 	fmt.Printf("将 %s 更改为 %s 最少需要编辑 %d 步\n", s, t, res)
 }
--- a/codes/go/chapter_dynamic_programming/knapsack.go
+++ b/codes/go/chapter_dynamic_programming/knapsack.go
@@ -68,7 +68,7 @@ func knapsackDP(wgt, val []int, cap int) int {
 	return dp[n][cap]
 }

-/* 0-1 背包：状态压缩后的动态规划 */
+/* 0-1 背包：空间优化后的动态规划 */
 func knapsackDPComp(wgt, val []int, cap int) int {
 	n := len(wgt)
 	// 初始化 dp 表
--- a/codes/go/chapter_dynamic_programming/knapsack_test.go
+++ b/codes/go/chapter_dynamic_programming/knapsack_test.go
@@ -34,7 +34,7 @@ func TestKnapsack(t *testing.T) {
 	res = knapsackDP(wgt, val, c)
 	fmt.Printf("不超过背包容量的最大物品价值为 %d\n", res)

-	// 状态压缩后的动态规划
+	// 空间优化后的动态规划
 	res = knapsackDPComp(wgt, val, c)
 	fmt.Printf("不超过背包容量的最大物品价值为 %d\n", res)
 }
@@ -48,7 +48,7 @@ func TestUnboundedKnapsack(t *testing.T) {
 	res := unboundedKnapsackDP(wgt, val, c)
 	fmt.Printf("不超过背包容量的最大物品价值为 %d\n", res)

-	// 状态压缩后的动态规划
+	// 空间优化后的动态规划
 	res = unboundedKnapsackDPComp(wgt, val, c)
 	fmt.Printf("不超过背包容量的最大物品价值为 %d\n", res)
 }
--- a/codes/go/chapter_dynamic_programming/min_cost_climbing_stairs_dp.go
+++ b/codes/go/chapter_dynamic_programming/min_cost_climbing_stairs_dp.go
@@ -24,7 +24,7 @@ func minCostClimbingStairsDP(cost []int) int {
 	return dp[n]
 }

-/* 爬楼梯最小代价：状态压缩后的动态规划 */
+/* 爬楼梯最小代价：空间优化后的动态规划 */
 func minCostClimbingStairsDPComp(cost []int) int {
 	n := len(cost) - 1
 	if n == 1 || n == 2 {
--- a/codes/go/chapter_dynamic_programming/min_path_sum.go
+++ b/codes/go/chapter_dynamic_programming/min_path_sum.go
@@ -71,7 +71,7 @@ func minPathSumDP(grid [][]int) int {
 	return dp[n-1][m-1]
 }

-/* 最小路径和：状态压缩后的动态规划 */
+/* 最小路径和：空间优化后的动态规划 */
 func minPathSumDPComp(grid [][]int) int {
 	n, m := len(grid), len(grid[0])
 	// 初始化 dp 表
--- a/codes/go/chapter_dynamic_programming/min_path_sum_test.go
+++ b/codes/go/chapter_dynamic_programming/min_path_sum_test.go
@@ -37,7 +37,7 @@ func TestMinPathSum(t *testing.T) {
 	res = minPathSumDP(grid)
 	fmt.Printf("从左上角到右下角的做小路径和为  %d\n", res)

-	// 状态压缩后的动态规划
+	// 空间优化后的动态规划
 	res = minPathSumDPComp(grid)
 	fmt.Printf("从左上角到右下角的做小路径和为  %d\n", res)
 }
--- a/codes/go/chapter_dynamic_programming/unbounded_knapsack.go
+++ b/codes/go/chapter_dynamic_programming/unbounded_knapsack.go
@@ -29,7 +29,7 @@ func unboundedKnapsackDP(wgt, val []int, cap int) int {
 	return dp[n][cap]
 }

-/* 完全背包：状态压缩后的动态规划 */
+/* 完全背包：空间优化后的动态规划 */
 func unboundedKnapsackDPComp(wgt, val []int, cap int) int {
 	n := len(wgt)
 	// 初始化 dp 表
--- a/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java
+++ b/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java
@@ -23,7 +23,7 @@ public class climbing_stairs_dp {
        return dp[n];
    }

-    /* 爬楼梯：状态压缩后的动态规划 */
+    /* 爬楼梯：空间优化后的动态规划 */
    public static int climbingStairsDPComp(int n) {
        if (n == 1 || n == 2)
            return n;
--- a/codes/java/chapter_dynamic_programming/coin_change.java
+++ b/codes/java/chapter_dynamic_programming/coin_change.java
@@ -34,7 +34,7 @@ public class coin_change {
        return dp[n][amt] != MAX ? dp[n][amt] : -1;
    }

-    /* 零钱兑换：状态压缩后的动态规划 */
+    /* 零钱兑换：空间优化后的动态规划 */
    static int coinChangeDPComp(int[] coins, int amt) {
        int n = coins.length;
        int MAX = amt + 1;
@@ -65,7 +65,7 @@ public class coin_change {
        int res = coinChangeDP(coins, amt);
        System.out.println("凑到目标金额所需的最少硬币数量为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = coinChangeDPComp(coins, amt);
        System.out.println("凑到目标金额所需的最少硬币数量为 " + res);
    }
--- a/codes/java/chapter_dynamic_programming/coin_change_ii.java
+++ b/codes/java/chapter_dynamic_programming/coin_change_ii.java
@@ -31,7 +31,7 @@ public class coin_change_ii {
        return dp[n][amt];
    }

-    /* 零钱兑换 II：状态压缩后的动态规划 */
+    /* 零钱兑换 II：空间优化后的动态规划 */
    static int coinChangeIIDPComp(int[] coins, int amt) {
        int n = coins.length;
        // 初始化 dp 表
@@ -60,7 +60,7 @@ public class coin_change_ii {
        int res = coinChangeIIDP(coins, amt);
        System.out.println("凑出目标金额的硬币组合数量为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = coinChangeIIDPComp(coins, amt);
        System.out.println("凑出目标金额的硬币组合数量为 " + res);
    }
--- a/codes/java/chapter_dynamic_programming/edit_distance.java
+++ b/codes/java/chapter_dynamic_programming/edit_distance.java
@@ -83,7 +83,7 @@ public class edit_distance {
        return dp[n][m];
    }

-    /* 编辑距离：状态压缩后的动态规划 */
+    /* 编辑距离：空间优化后的动态规划 */
    static int editDistanceDPComp(String s, String t) {
        int n = s.length(), m = t.length();
        int[] dp = new int[m + 1];
@@ -132,7 +132,7 @@ public class edit_distance {
        res = editDistanceDP(s, t);
        System.out.println("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = editDistanceDPComp(s, t);
        System.out.println("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");
    }
--- a/codes/java/chapter_dynamic_programming/knapsack.java
+++ b/codes/java/chapter_dynamic_programming/knapsack.java
@@ -69,7 +69,7 @@ public class knapsack {
        return dp[n][cap];
    }

-    /* 0-1 背包：状态压缩后的动态规划 */
+    /* 0-1 背包：空间优化后的动态规划 */
    static int knapsackDPComp(int[] wgt, int[] val, int cap) {
        int n = wgt.length;
        // 初始化 dp 表
@@ -109,7 +109,7 @@ public class knapsack {
        res = knapsackDP(wgt, val, cap);
        System.out.println("不超过背包容量的最大物品价值为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = knapsackDPComp(wgt, val, cap);
        System.out.println("不超过背包容量的最大物品价值为 " + res);
    }
--- a/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java
+++ b/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java
@@ -26,7 +26,7 @@ public class min_cost_climbing_stairs_dp {
        return dp[n];
    }

-    /* 爬楼梯最小代价：状态压缩后的动态规划 */
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
    public static int minCostClimbingStairsDPComp(int[] cost) {
        int n = cost.length - 1;
        if (n == 1 || n == 2)
--- a/codes/java/chapter_dynamic_programming/min_path_sum.java
+++ b/codes/java/chapter_dynamic_programming/min_path_sum.java
@@ -71,7 +71,7 @@ public class min_path_sum {
        return dp[n - 1][m - 1];
    }

-    /* 最小路径和：状态压缩后的动态规划 */
+    /* 最小路径和：空间优化后的动态规划 */
    static int minPathSumDPComp(int[][] grid) {
        int n = grid.length, m = grid[0].length;
        // 初始化 dp 表
@@ -118,7 +118,7 @@ public class min_path_sum {
        res = minPathSumDP(grid);
        System.out.println("从左上角到右下角的做小路径和为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = minPathSumDPComp(grid);
        System.out.println("从左上角到右下角的做小路径和为 " + res);
    }
--- a/codes/java/chapter_dynamic_programming/unbounded_knapsack.java
+++ b/codes/java/chapter_dynamic_programming/unbounded_knapsack.java
@@ -27,7 +27,7 @@ public class unbounded_knapsack {
        return dp[n][cap];
    }

-    /* 完全背包：状态压缩后的动态规划 */
+    /* 完全背包：空间优化后的动态规划 */
    static int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
        int n = wgt.length;
        // 初始化 dp 表
@@ -56,7 +56,7 @@ public class unbounded_knapsack {
        int res = unboundedKnapsackDP(wgt, val, cap);
        System.out.println("不超过背包容量的最大物品价值为 " + res);

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = unboundedKnapsackDPComp(wgt, val, cap);
        System.out.println("不超过背包容量的最大物品价值为 " + res);
    }
--- a/codes/javascript/chapter_dynamic_programming/climbing_stairs_dp.js
+++ b/codes/javascript/chapter_dynamic_programming/climbing_stairs_dp.js
@@ -19,7 +19,7 @@ function climbingStairsDP(n) {
    return dp[n];
 }

-/* 爬楼梯：状态压缩后的动态规划 */
+/* 爬楼梯：空间优化后的动态规划 */
 function climbingStairsDPComp(n) {
    if (n === 1 || n === 2) return n;
    let a = 1,
--- a/codes/python/chapter_dynamic_programming/climbing_stairs_dp.py
+++ b/codes/python/chapter_dynamic_programming/climbing_stairs_dp.py
@@ -20,7 +20,7 @@ def climbing_stairs_dp(n: int) -> int:


 def climbing_stairs_dp_comp(n: int) -> int:
-    """爬楼梯：状态压缩后的动态规划"""
+    """爬楼梯：空间优化后的动态规划"""
    if n == 1 or n == 2:
        return n
    a, b = 1, 2
--- a/codes/python/chapter_dynamic_programming/coin_change.py
+++ b/codes/python/chapter_dynamic_programming/coin_change.py
@@ -27,7 +27,7 @@ def coin_change_dp(coins: list[int], amt: int) -> int:


 def coin_change_dp_comp(coins: list[int], amt: int) -> int:
-    """零钱兑换：状态压缩后的动态规划"""
+    """零钱兑换：空间优化后的动态规划"""
    n = len(coins)
    MAX = amt + 1
    # 初始化 dp 表
@@ -55,6 +55,6 @@ if __name__ == "__main__":
    res = coin_change_dp(coins, amt)
    print(f"凑到目标金额所需的最少硬币数量为 {res}")

-    # 状态压缩后的动态规划
+    # 空间优化后的动态规划
    res = coin_change_dp_comp(coins, amt)
    print(f"凑到目标金额所需的最少硬币数量为 {res}")
--- a/codes/python/chapter_dynamic_programming/coin_change_ii.py
+++ b/codes/python/chapter_dynamic_programming/coin_change_ii.py
@@ -26,7 +26,7 @@ def coin_change_ii_dp(coins: list[int], amt: int) -> int:


 def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:
-    """零钱兑换 II：状态压缩后的动态规划"""
+    """零钱兑换 II：空间优化后的动态规划"""
    n = len(coins)
    # 初始化 dp 表
    dp = [0] * (amt + 1)
@@ -54,6 +54,6 @@ if __name__ == "__main__":
    res = coin_change_ii_dp(coins, amt)
    print(f"凑出目标金额的硬币组合数量为 {res}")

-    # 状态压缩后的动态规划
+    # 空间优化后的动态规划
    res = coin_change_ii_dp_comp(coins, amt)
    print(f"凑出目标金额的硬币组合数量为 {res}")
--- a/codes/python/chapter_dynamic_programming/edit_distance.py
+++ b/codes/python/chapter_dynamic_programming/edit_distance.py
@@ -75,7 +75,7 @@ def edit_distance_dp(s: str, t: str) -> int:


 def edit_distance_dp_comp(s: str, t: str) -> int:
-    """编辑距离：状态压缩后的动态规划"""
+    """编辑距离：空间优化后的动态规划"""
    n, m = len(s), len(t)
    dp = [0] * (m + 1)
    # 状态转移：首行
@@ -118,6 +118,6 @@ if __name__ == "__main__":
    res = edit_distance_dp(s, t)
    print(f"将 {s} 更改为 {t} 最少需要编辑 {res} 步")

-    # 状态压缩后的动态规划
+    # 空间优化后的动态规划
    res = edit_distance_dp_comp(s, t)
    print(f"将 {s} 更改为 {t} 最少需要编辑 {res} 步")
--- a/codes/python/chapter_dynamic_programming/knapsack.py
+++ b/codes/python/chapter_dynamic_programming/knapsack.py
@@ -59,7 +59,7 @@ def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:


 def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
-    """0-1 背包：状态压缩后的动态规划"""
+    """0-1 背包：空间优化后的动态规划"""
    n = len(wgt)
    # 初始化 dp 表
    dp = [0] * (cap + 1)
@@ -96,6 +96,6 @@ if __name__ == "__main__":
    res = knapsack_dp(wgt, val, cap)
    print(f"不超过背包容量的最大物品价值为 {res}")

-    # 状态压缩后的动态规划
+    # 空间优化后的动态规划
    res = knapsack_dp_comp(wgt, val, cap)
    print(f"不超过背包容量的最大物品价值为 {res}")
--- a/codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py
+++ b/codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py
@@ -21,7 +21,7 @@ def min_cost_climbing_stairs_dp(cost: list[int]) -> int:


 def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:
-    """爬楼梯最小代价：状态压缩后的动态规划"""
+    """爬楼梯最小代价：空间优化后的动态规划"""
    n = len(cost) - 1
    if n == 1 or n == 2:
        return cost[n]
--- a/codes/python/chapter_dynamic_programming/min_path_sum.py
+++ b/codes/python/chapter_dynamic_programming/min_path_sum.py
@@ -63,7 +63,7 @@ def min_path_sum_dp(grid: list[list[int]]) -> int:


 def min_path_sum_dp_comp(grid: list[list[int]]) -> int:
-    """最小路径和：状态压缩后的动态规划"""
+    """最小路径和：空间优化后的动态规划"""
    n, m = len(grid), len(grid[0])
    # 初始化 dp 表
    dp = [0] * m
@@ -99,6 +99,6 @@ if __name__ == "__main__":
    res = min_path_sum_dp(grid)
    print(f"从左上角到右下角的做小路径和为 {res}")

-    # 状态压缩后的动态规划
+    # 空间优化后的动态规划
    res = min_path_sum_dp_comp(grid)
    print(f"从左上角到右下角的做小路径和为 {res}")
--- a/codes/python/chapter_dynamic_programming/unbounded_knapsack.py
+++ b/codes/python/chapter_dynamic_programming/unbounded_knapsack.py
@@ -23,7 +23,7 @@ def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:


 def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
-    """完全背包：状态压缩后的动态规划"""
+    """完全背包：空间优化后的动态规划"""
    n = len(wgt)
    # 初始化 dp 表
    dp = [0] * (cap + 1)
@@ -50,6 +50,6 @@ if __name__ == "__main__":
    res = unbounded_knapsack_dp(wgt, val, cap)
    print(f"不超过背包容量的最大物品价值为 {res}")

-    # 状态压缩后的动态规划
+    # 空间优化后的动态规划
    res = unbounded_knapsack_dp_comp(wgt, val, cap)
    print(f"不超过背包容量的最大物品价值为 {res}")
--- a/codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs
+++ b/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);
--- a/codes/rust/chapter_dynamic_programming/coin_change.rs
+++ b/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}");
 }
--- a/codes/rust/chapter_dynamic_programming/coin_change_ii.rs
+++ b/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}");
 }
--- a/codes/rust/chapter_dynamic_programming/edit_distance.rs
+++ b/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} 步");
 }
--- a/codes/rust/chapter_dynamic_programming/knapsack.rs
+++ b/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}");
 }
--- a/codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs
+++ b/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] };
--- a/codes/rust/chapter_dynamic_programming/min_path_sum.rs
+++ b/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}");
 }
--- a/codes/rust/chapter_dynamic_programming/unbounded_knapsack.rs
+++ b/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}");
 }
--- a/codes/swift/chapter_dynamic_programming/climbing_stairs_dp.swift
+++ b/codes/swift/chapter_dynamic_programming/climbing_stairs_dp.swift
@@ -21,7 +21,7 @@ func climbingStairsDP(n: Int) -> Int {
    return dp[n]
 }

-/* 爬楼梯：状态压缩后的动态规划 */
+/* 爬楼梯：空间优化后的动态规划 */
 func climbingStairsDPComp(n: Int) -> Int {
    if n == 1 || n == 2 {
        return n
--- a/codes/swift/chapter_dynamic_programming/coin_change.swift
+++ b/codes/swift/chapter_dynamic_programming/coin_change.swift
@@ -29,7 +29,7 @@ func coinChangeDP(coins: [Int], amt: Int) -> Int {
    return dp[n][amt] != MAX ? dp[n][amt] : -1
 }

-/* 零钱兑换：状态压缩后的动态规划 */
+/* 零钱兑换：空间优化后的动态规划 */
 func coinChangeDPComp(coins: [Int], amt: Int) -> Int {
    let n = coins.count
    let MAX = amt + 1
@@ -62,7 +62,7 @@ enum CoinChange {
        var res = coinChangeDP(coins: coins, amt: amt)
        print("凑到目标金额所需的最少硬币数量为 \(res)")

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = coinChangeDPComp(coins: coins, amt: amt)
        print("凑到目标金额所需的最少硬币数量为 \(res)")
    }
--- a/codes/swift/chapter_dynamic_programming/coin_change_ii.swift
+++ b/codes/swift/chapter_dynamic_programming/coin_change_ii.swift
@@ -28,7 +28,7 @@ func coinChangeIIDP(coins: [Int], amt: Int) -> Int {
    return dp[n][amt]
 }

-/* 零钱兑换 II：状态压缩后的动态规划 */
+/* 零钱兑换 II：空间优化后的动态规划 */
 func coinChangeIIDPComp(coins: [Int], amt: Int) -> Int {
    let n = coins.count
    // 初始化 dp 表
@@ -60,7 +60,7 @@ enum CoinChangeII {
        var res = coinChangeIIDP(coins: coins, amt: amt)
        print("凑出目标金额的硬币组合数量为 \(res)")

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = coinChangeIIDPComp(coins: coins, amt: amt)
        print("凑出目标金额的硬币组合数量为 \(res)")
    }
--- a/codes/swift/chapter_dynamic_programming/edit_distance.swift
+++ b/codes/swift/chapter_dynamic_programming/edit_distance.swift
@@ -88,7 +88,7 @@ func editDistanceDP(s: String, t: String) -> Int {
    return dp[n][m]
 }

-/* 编辑距离：状态压缩后的动态规划 */
+/* 编辑距离：空间优化后的动态规划 */
 func editDistanceDPComp(s: String, t: String) -> Int {
    let n = s.utf8CString.count
    let m = t.utf8CString.count
@@ -140,7 +140,7 @@ enum EditDistance {
        res = editDistanceDP(s: s, t: t)
        print("将 \(s) 更改为 \(t) 最少需要编辑 \(res) 步")

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = editDistanceDPComp(s: s, t: t)
        print("将 \(s) 更改为 \(t) 最少需要编辑 \(res) 步")
    }
--- a/codes/swift/chapter_dynamic_programming/knapsack.swift
+++ b/codes/swift/chapter_dynamic_programming/knapsack.swift
@@ -63,7 +63,7 @@ func knapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int {
    return dp[n][cap]
 }

-/* 0-1 背包：状态压缩后的动态规划 */
+/* 0-1 背包：空间优化后的动态规划 */
 func knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int {
    let n = wgt.count
    // 初始化 dp 表
@@ -103,7 +103,7 @@ enum Knapsack {
        res = knapsackDP(wgt: wgt, val: val, cap: cap)
        print("不超过背包容量的最大物品价值为 \(res)")

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = knapsackDPComp(wgt: wgt, val: val, cap: cap)
        print("不超过背包容量的最大物品价值为 \(res)")
    }
--- a/codes/swift/chapter_dynamic_programming/min_cost_climbing_stairs_dp.swift
+++ b/codes/swift/chapter_dynamic_programming/min_cost_climbing_stairs_dp.swift
@@ -22,7 +22,7 @@ func minCostClimbingStairsDP(cost: [Int]) -> Int {
    return dp[n]
 }

-/* 爬楼梯最小代价：状态压缩后的动态规划 */
+/* 爬楼梯最小代价：空间优化后的动态规划 */
 func minCostClimbingStairsDPComp(cost: [Int]) -> Int {
    let n = cost.count - 1
    if n == 1 || n == 2 {
--- a/codes/swift/chapter_dynamic_programming/min_path_sum.swift
+++ b/codes/swift/chapter_dynamic_programming/min_path_sum.swift
@@ -67,7 +67,7 @@ func minPathSumDP(grid: [[Int]]) -> Int {
    return dp[n - 1][m - 1]
 }

-/* 最小路径和：状态压缩后的动态规划 */
+/* 最小路径和：空间优化后的动态规划 */
 func minPathSumDPComp(grid: [[Int]]) -> Int {
    let n = grid.count
    let m = grid[0].count
@@ -116,7 +116,7 @@ enum MinPathSum {
        res = minPathSumDP(grid: grid)
        print("从左上角到右下角的做小路径和为 \(res)")

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = minPathSumDPComp(grid: grid)
        print("从左上角到右下角的做小路径和为 \(res)")
    }
--- a/codes/swift/chapter_dynamic_programming/unbounded_knapsack.swift
+++ b/codes/swift/chapter_dynamic_programming/unbounded_knapsack.swift
@@ -24,7 +24,7 @@ func unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int {
    return dp[n][cap]
 }

-/* 完全背包：状态压缩后的动态规划 */
+/* 完全背包：空间优化后的动态规划 */
 func unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int {
    let n = wgt.count
    // 初始化 dp 表
@@ -56,7 +56,7 @@ enum UnboundedKnapsack {
        var res = unboundedKnapsackDP(wgt: wgt, val: val, cap: cap)
        print("不超过背包容量的最大物品价值为 \(res)")

-        // 状态压缩后的动态规划
+        // 空间优化后的动态规划
        res = unboundedKnapsackDPComp(wgt: wgt, val: val, cap: cap)
        print("不超过背包容量的最大物品价值为 \(res)")
    }
--- a/codes/typescript/chapter_dynamic_programming/climbing_stairs_dp.ts
+++ b/codes/typescript/chapter_dynamic_programming/climbing_stairs_dp.ts
@@ -19,7 +19,7 @@ function climbingStairsDP(n: number): number {
    return dp[n];
 }

-/* 爬楼梯：状态压缩后的动态规划 */
+/* 爬楼梯：空间优化后的动态规划 */
 function climbingStairsDPComp(n: number): number {
    if (n === 1 || n === 2) return n;
    let a = 1,
--- a/codes/zig/chapter_dynamic_programming/climbing_stairs_dp.zig
+++ b/codes/zig/chapter_dynamic_programming/climbing_stairs_dp.zig
@@ -22,7 +22,7 @@ fn climbingStairsDP(comptime n: usize) i32 {
    return dp[n];
 }

-// 爬楼梯：状态压缩后的动态规划
+// 爬楼梯：空间优化后的动态规划
 fn climbingStairsDPComp(comptime n: usize) i32 {
    if (n == 1 or n == 2) {
        return @intCast(n);
--- a/codes/zig/chapter_dynamic_programming/coin_change.zig
+++ b/codes/zig/chapter_dynamic_programming/coin_change.zig
@@ -33,7 +33,7 @@ fn coinChangeDP(comptime coins: []i32, comptime amt: usize) i32 {
    }
 }

-// 零钱兑换：状态压缩后的动态规划
+// 零钱兑换：空间优化后的动态规划
 fn coinChangeDPComp(comptime coins: []i32, comptime amt: usize) i32 {
    comptime var n = coins.len;
    comptime var max = amt + 1;
@@ -69,7 +69,7 @@ pub fn main() !void {
    var res = coinChangeDP(&coins, amt);
    std.debug.print("凑到目标金额所需的最少硬币数量为 {}\n", .{res});

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = coinChangeDPComp(&coins, amt);
    std.debug.print("凑到目标金额所需的最少硬币数量为 {}\n", .{res});

--- a/codes/zig/chapter_dynamic_programming/coin_change_ii.zig
+++ b/codes/zig/chapter_dynamic_programming/coin_change_ii.zig
@@ -28,7 +28,7 @@ fn coinChangeIIDP(comptime coins: []i32, comptime amt: usize) i32 {
    return dp[n][amt];
 }

-// 零钱兑换 II：状态压缩后的动态规划
+// 零钱兑换 II：空间优化后的动态规划
 fn coinChangeIIDPComp(comptime coins: []i32, comptime amt: usize) i32 {
    comptime var n = coins.len;
    // 初始化 dp 表
@@ -58,7 +58,7 @@ pub fn main() !void {
    var res = coinChangeIIDP(&coins, amt);
    std.debug.print("凑出目标金额的硬币组合数量为 {}\n", .{res});

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = coinChangeIIDPComp(&coins, amt);
    std.debug.print("凑出目标金额的硬币组合数量为 {}\n", .{res});

--- a/codes/zig/chapter_dynamic_programming/edit_distance.zig
+++ b/codes/zig/chapter_dynamic_programming/edit_distance.zig
@@ -88,7 +88,7 @@ fn editDistanceDP(comptime s: []const u8, comptime t: []const u8) i32 {
    return dp[n][m];
 }

-// 编辑距离：状态压缩后的动态规划
+// 编辑距离：空间优化后的动态规划
 fn editDistanceDPComp(comptime s: []const u8, comptime t: []const u8) i32 {
    comptime var n = s.len;
    comptime var m = t.len;
@@ -138,7 +138,7 @@ pub fn main() !void {
    res = editDistanceDP(s, t);
    std.debug.print("将 {s} 更改为 {s} 最少需要编辑 {} 步\n", .{ s, t, res });

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = editDistanceDPComp(s, t);
    std.debug.print("将 {s} 更改为 {s} 最少需要编辑 {} 步\n", .{ s, t, res });

--- a/codes/zig/chapter_dynamic_programming/knapsack.zig
+++ b/codes/zig/chapter_dynamic_programming/knapsack.zig
@@ -63,7 +63,7 @@ fn knapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {
    return dp[n][cap];
 }

-// 0-1 背包：状态压缩后的动态规划
+// 0-1 背包：空间优化后的动态规划
 fn knapsackDPComp(wgt: []i32, val: []i32, comptime cap: usize) i32 {
    var n = wgt.len;
    // 初始化 dp 表
@@ -102,7 +102,7 @@ pub fn main() !void {
    res = knapsackDP(&wgt, &val, cap);
    std.debug.print("不超过背包容量的最大物品价值为 {}\n", .{res});

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = knapsackDPComp(&wgt, &val, cap);
    std.debug.print("不超过背包容量的最大物品价值为 {}\n", .{res});

--- a/codes/zig/chapter_dynamic_programming/min_cost_climbing_stairs_dp.zig
+++ b/codes/zig/chapter_dynamic_programming/min_cost_climbing_stairs_dp.zig
@@ -22,7 +22,7 @@ fn minCostClimbingStairsDP(comptime cost: []i32) i32 {
    return dp[n];
 }

-// 爬楼梯最小代价：状态压缩后的动态规划
+// 爬楼梯最小代价：空间优化后的动态规划
 fn minCostClimbingStairsDPComp(cost: []i32) i32 {
    var n = cost.len - 1;
    if (n == 1 or n == 2) {
--- a/codes/zig/chapter_dynamic_programming/min_path_sum.zig
+++ b/codes/zig/chapter_dynamic_programming/min_path_sum.zig
@@ -68,7 +68,7 @@ fn minPathSumDP(comptime grid: anytype) i32 {
    return dp[n - 1][m - 1];
 }

-// 最小路径和：状态压缩后的动态规划
+// 最小路径和：空间优化后的动态规划
 fn minPathSumDPComp(comptime grid: anytype) i32 {
    comptime var n = grid.len;
    comptime var m = grid[0].len;
@@ -114,7 +114,7 @@ pub fn main() !void {
    res = minPathSumDP(&grid);
    std.debug.print("从左上角到右下角的最小路径和为 {}\n", .{res});

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = minPathSumDPComp(&grid);
    std.debug.print("从左上角到右下角的最小路径和为 {}\n", .{res});

--- a/codes/zig/chapter_dynamic_programming/unbounded_knapsack.zig
+++ b/codes/zig/chapter_dynamic_programming/unbounded_knapsack.zig
@@ -24,7 +24,7 @@ fn unboundedKnapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32
    return dp[n][cap];
 }

-// 完全背包：状态压缩后的动态规划
+// 完全背包：空间优化后的动态规划
 fn unboundedKnapsackDPComp(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {
    comptime var n = wgt.len;
    // 初始化 dp 表
@@ -54,7 +54,7 @@ pub fn main() !void {
    var res = unboundedKnapsackDP(&wgt, &val, cap);
    std.debug.print("不超过背包容量的最大物品价值为 {}\n", .{res});

-    // 状态压缩后的动态规划
+    // 空间优化后的动态规划
    res = unboundedKnapsackDPComp(&wgt, &val, cap);
    std.debug.print("不超过背包容量的最大物品价值为 {}\n", .{res});