Fix a definition.

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

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}")

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}")

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} 步")

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}")

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]

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}")

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}")