Fix a definition.

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

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

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

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

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

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 {

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

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