build

docs/chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -323,6 +323,35 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="unbounded_knapsack.kt"
+    /* 完全背包：动态规划 */
+    fun unboundedKnapsackDP(
+        wgt: IntArray,
+        value: IntArray,
+        cap: Int
+    ): Int {
+        val n = wgt.size
+        // 初始化 dp 表
+        val dp = Array(n + 1) { IntArray(cap + 1) }
+        // 状态转移
+        for (i in 1..n) {
+            for (c in 1..cap) {
+                if (wgt[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[i][c] = dp[i - 1][c]
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[i][c] = max(dp[i - 1][c].toDouble(), (dp[i][c - wgt[i - 1]] + value[i - 1]).toDouble())
+                        .toInt()
+                }
+            }
+        }
+        return dp[n][cap]
+    }
+    ```
+
 === "Zig"
 
     ```zig title="unbounded_knapsack.zig"
@@ -648,6 +677,35 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="unbounded_knapsack.kt"
+    /* 完全背包：空间优化后的动态规划 */
+    fun unboundedKnapsackDPComp(
+        wgt: IntArray,
+        value: IntArray,
+        cap: Int
+    ): Int {
+        val n = wgt.size
+        // 初始化 dp 表
+        val dp = IntArray(cap + 1)
+        // 状态转移
+        for (i in 1..n) {
+            for (c in 1..cap) {
+                if (wgt[i - 1] > c) {
+                    // 若超过背包容量，则不选物品 i
+                    dp[c] = dp[c]
+                } else {
+                    // 不选和选物品 i 这两种方案的较大值
+                    dp[c] =
+                        max(dp[c].toDouble(), (dp[c - wgt[i - 1]] + value[i - 1]).toDouble()).toInt()
+                }
+            }
+        }
+        return dp[cap]
+    }
+    ```
+
 === "Zig"
 
     ```zig title="unbounded_knapsack.zig"
@@ -1063,6 +1121,36 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="coin_change.kt"
+    /* 零钱兑换：动态规划 */
+    fun coinChangeDP(coins: IntArray, amt: Int): Int {
+        val n = coins.size
+        val MAX = amt + 1
+        // 初始化 dp 表
+        val dp = Array(n + 1) { IntArray(amt + 1) }
+        // 状态转移：首行首列
+        for (a in 1..amt) {
+            dp[0][a] = MAX
+        }
+        // 状态转移：其余行和列
+        for (i in 1..n) {
+            for (a in 1..amt) {
+                if (coins[i - 1] > a) {
+                    // 若超过目标金额，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a]
+                } else {
+                    // 不选和选硬币 i 这两种方案的较小值
+                    dp[i][a] = min(dp[i - 1][a].toDouble(), (dp[i][a - coins[i - 1]] + 1).toDouble())
+                        .toInt()
+                }
+            }
+        }
+        return if (dp[n][amt] != MAX) dp[n][amt] else -1
+    }
+    ```
+
 === "Zig"
 
     ```zig title="coin_change.zig"
@@ -1453,6 +1541,33 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="coin_change.kt"
+    /* 零钱兑换：空间优化后的动态规划 */
+    fun coinChangeDPComp(coins: IntArray, amt: Int): Int {
+        val n = coins.size
+        val MAX = amt + 1
+        // 初始化 dp 表
+        val dp = IntArray(amt + 1)
+        Arrays.fill(dp, MAX)
+        dp[0] = 0
+        // 状态转移
+        for (i in 1..n) {
+            for (a in 1..amt) {
+                if (coins[i - 1] > a) {
+                    // 若超过目标金额，则不选硬币 i
+                    dp[a] = dp[a]
+                } else {
+                    // 不选和选硬币 i 这两种方案的较小值
+                    dp[a] = min(dp[a].toDouble(), (dp[a - coins[i - 1]] + 1).toDouble()).toInt()
+                }
+            }
+        }
+        return if (dp[amt] != MAX) dp[amt] else -1
+    }
+    ```
+
 === "Zig"
 
     ```zig title="coin_change.zig"
@@ -1832,6 +1947,34 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="coin_change_ii.kt"
+    /* 零钱兑换 II：动态规划 */
+    fun coinChangeIIDP(coins: IntArray, amt: Int): Int {
+        val n = coins.size
+        // 初始化 dp 表
+        val dp = Array(n + 1) { IntArray(amt + 1) }
+        // 初始化首列
+        for (i in 0..n) {
+            dp[i][0] = 1
+        }
+        // 状态转移
+        for (i in 1..n) {
+            for (a in 1..amt) {
+                if (coins[i - 1] > a) {
+                    // 若超过目标金额，则不选硬币 i
+                    dp[i][a] = dp[i - 1][a]
+                } else {
+                    // 不选和选硬币 i 这两种方案之和
+                    dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]
+                }
+            }
+        }
+        return dp[n][amt]
+    }
+    ```
+
 === "Zig"
 
     ```zig title="coin_change_ii.zig"
@@ -2145,6 +2288,31 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="coin_change_ii.kt"
+    /* 零钱兑换 II：空间优化后的动态规划 */
+    fun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {
+        val n = coins.size
+        // 初始化 dp 表
+        val dp = IntArray(amt + 1)
+        dp[0] = 1
+        // 状态转移
+        for (i in 1..n) {
+            for (a in 1..amt) {
+                if (coins[i - 1] > a) {
+                    // 若超过目标金额，则不选硬币 i
+                    dp[a] = dp[a]
+                } else {
+                    // 不选和选硬币 i 这两种方案之和
+                    dp[a] = dp[a] + dp[a - coins[i - 1]]
+                }
+            }
+        }
+        return dp[amt]
+    }
+    ```
+
 === "Zig"
 
     ```zig title="coin_change_ii.zig"