Fix a definition.

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;

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

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

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

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

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];

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

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