build

docs/chapter_greedy/fractional_knapsack_problem.md

@@ -456,6 +456,78 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="fractional_knapsack.kt"
+    /* 物品 */
+    class Item(
+        val w: Int, // 物品
+        val v: Int // 物品价值
+    )
+
+    /* 分数背包：贪心 */
+    fun fractionalKnapsack(
+        wgt: IntArray,
+        value: IntArray,
+        c: Int
+    ): Double {
+        // 创建物品列表，包含两个属性：重量、价值
+        var cap = c
+        val items = arrayOfNulls<Item>(wgt.size)
+        for (i in wgt.indices) {
+            items[i] = Item(wgt[i], value[i])
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Arrays.sort(items, Comparator.comparingDouble { item: Item -> -(item.v.toDouble() / item.w) })
+        // 循环贪心选择
+        var res = 0.0
+        for (item in items) {
+            if (item!!.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v.toDouble()
+                cap -= item.w
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += item.v.toDouble() / item.w * cap
+                // 已无剩余容量，因此跳出循环
+                break
+            }
+        }
+        return res
+    }
+
+    /* 分数背包：贪心 */
+    fun fractionalKnapsack(
+        wgt: IntArray,
+        value: IntArray,
+        c: Int
+    ): Double {
+        // 创建物品列表，包含两个属性：重量、价值
+        var cap = c
+        val items = arrayOfNulls<Item>(wgt.size)
+        for (i in wgt.indices) {
+            items[i] = Item(wgt[i], value[i])
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Arrays.sort(items, Comparator.comparingDouble { item: Item -> -(item.v.toDouble() / item.w) })
+        // 循环贪心选择
+        var res = 0.0
+        for (item in items) {
+            if (item!!.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v.toDouble()
+                cap -= item.w
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += item.v.toDouble() / item.w * cap
+                // 已无剩余容量，因此跳出循环
+                break
+            }
+        }
+        return res
+    }
+    ```
+
 === "Zig"
 
     ```zig title="fractional_knapsack.zig"

docs/chapter_greedy/greedy_algorithm.md

@@ -283,6 +283,30 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="coin_change_greedy.kt"
+    /* 零钱兑换：贪心 */
+    fun coinChangeGreedy(coins: IntArray, amt: Int): Int {
+        // 假设 coins 列表有序
+        var am = amt
+        var i = coins.size - 1
+        var count = 0
+        // 循环进行贪心选择，直到无剩余金额
+        while (am > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > am) {
+                i--
+            }
+            // 选择 coins[i]
+            am -= coins[i]
+            count++
+        }
+        // 若未找到可行方案，则返回 -1
+        return if (am == 0) count else -1
+    }
+    ```
+
 === "Zig"
 
     ```zig title="coin_change_greedy.zig"

docs/chapter_greedy/max_capacity_problem.md

@@ -368,6 +368,32 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="max_capacity.kt"
+    /* 最大容量：贪心 */
+    fun maxCapacity(ht: IntArray): Int {
+        // 初始化 i, j，使其分列数组两端
+        var i = 0
+        var j = ht.size - 1
+        // 初始最大容量为 0
+        var res = 0
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            val cap = (min(ht[i].toDouble(), ht[j].toDouble()) * (j - i)).toInt()
+            res = max(res.toDouble(), cap.toDouble()).toInt()
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++
+            } else {
+                j--
+            }
+        }
+        return res
+    }
+    ```
+
 === "Zig"
 
     ```zig title="max_capacity.zig"

docs/chapter_greedy/max_product_cutting_problem.md

@@ -343,6 +343,31 @@ $$
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="max_product_cutting.kt"
+    /* 最大切分乘积：贪心 */
+    fun maxProductCutting(n: Int): Int {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1)
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        val a = n / 3
+        val b = n % 3
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return 3.0.pow((a - 1).toDouble()).toInt() * 2 * 2
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return 3.0.pow(a.toDouble()).toInt() * 2 * 2
+        }
+        // 当余数为 0 时，不做处理
+        return 3.0.pow(a.toDouble()).toInt()
+    }
+    ```
+
 === "Zig"
 
     ```zig title="max_product_cutting.zig"