build

chapter_greedy/fractional_knapsack_problem.md

@@ -40,45 +40,35 @@ status: new
 
 我们建立了一个物品类 `Item` ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解。
 
-=== "Java"
+=== "Python"
 
-    ```java title="fractional_knapsack.java"
-    /* 物品 */
-    class Item {
-        int w; // 物品重量
-        int v; // 物品价值
+    ```python title="fractional_knapsack.py"
+    class Item:
+        """物品"""
 
-        public Item(int w, int v) {
-            this.w = w;
-            this.v = v;
-        }
-    }
+        def __init__(self, w: int, v: int):
+            self.w = w  # 物品重量
+            self.v = v  # 物品价值
 
-    /* 分数背包：贪心 */
-    double fractionalKnapsack(int[] wgt, int[] val, int cap) {
-        // 创建物品列表，包含两个属性：重量、价值
-        Item[] items = new Item[wgt.length];
-        for (int i = 0; i < wgt.length; i++) {
-            items[i] = new Item(wgt[i], val[i]);
-        }
-        // 按照单位价值 item.v / item.w 从高到低进行排序
-        Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));
-        // 循环贪心选择
-        double res = 0;
-        for (Item item : items) {
-            if (item.w <= cap) {
-                // 若剩余容量充足，则将当前物品整个装进背包
-                res += item.v;
-                cap -= item.w;
-            } else {
-                // 若剩余容量不足，则将当前物品的一部分装进背包
-                res += (double) item.v / item.w * cap;
-                // 已无剩余容量，因此跳出循环
-                break;
-            }
-        }
-        return res;
-    }
+    def fractional_knapsack(wgt: list[int], val: list[int], cap: int) -> int:
+        """分数背包：贪心"""
+        # 创建物品列表，包含两个属性：重量、价值
+        items = [Item(w, v) for w, v in zip(wgt, val)]
+        # 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort(key=lambda item: item.v / item.w, reverse=True)
+        # 循环贪心选择
+        res = 0
+        for item in items:
+            if item.w <= cap:
+                # 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v
+                cap -= item.w
+            else:
+                # 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (item.v / item.w) * cap
+                # 已无剩余容量，因此跳出循环
+                break
+        return res
     ```
 
 === "C++"
@@ -121,35 +111,86 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="fractional_knapsack.py"
-    class Item:
-        """物品"""
+    ```java title="fractional_knapsack.java"
+    /* 物品 */
+    class Item {
+        int w; // 物品重量
+        int v; // 物品价值
 
-        def __init__(self, w: int, v: int):
-            self.w = w  # 物品重量
-            self.v = v  # 物品价值
+        public Item(int w, int v) {
+            this.w = w;
+            this.v = v;
+        }
+    }
 
-    def fractional_knapsack(wgt: list[int], val: list[int], cap: int) -> int:
-        """分数背包：贪心"""
-        # 创建物品列表，包含两个属性：重量、价值
-        items = [Item(w, v) for w, v in zip(wgt, val)]
-        # 按照单位价值 item.v / item.w 从高到低进行排序
-        items.sort(key=lambda item: item.v / item.w, reverse=True)
-        # 循环贪心选择
-        res = 0
-        for item in items:
-            if item.w <= cap:
-                # 若剩余容量充足，则将当前物品整个装进背包
-                res += item.v
-                cap -= item.w
-            else:
-                # 若剩余容量不足，则将当前物品的一部分装进背包
-                res += (item.v / item.w) * cap
-                # 已无剩余容量，因此跳出循环
-                break
-        return res
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item[] items = new Item[wgt.length];
+        for (int i = 0; i < wgt.length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));
+        // 循环贪心选择
+        double res = 0;
+        for (Item item : items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double) item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="fractional_knapsack.cs"
+    /* 物品 */
+    class Item {
+        public int w; // 物品重量
+        public int v; // 物品价值
+
+        public Item(int w, int v) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item[] items = new Item[wgt.Length];
+        for (int i = 0; i < wgt.Length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Array.Sort(items, (x, y) => (y.v / y.w).CompareTo(x.v / x.w));
+        // 循环贪心选择
+        double res = 0;
+        foreach (Item item in items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double)item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Go"
@@ -190,6 +231,45 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="fractional_knapsack.swift"
+    /* 物品 */
+    class Item {
+        var w: Int // 物品重量
+        var v: Int // 物品价值
+
+        init(w: Int, v: Int) {
+            self.w = w
+            self.v = v
+        }
+    }
+
+    /* 分数背包：贪心 */
+    func fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -> Double {
+        // 创建物品列表，包含两个属性：重量、价值
+        var items = zip(wgt, val).map { Item(w: $0, v: $1) }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort(by: { -(Double($0.v) / Double($0.w)) < -(Double($1.v) / Double($1.w)) })
+        // 循环贪心选择
+        var res = 0.0
+        var cap = cap
+        for item in items {
+            if item.w <= cap {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += Double(item.v)
+                cap -= item.w
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += Double(item.v) / Double(item.w) * Double(cap)
+                // 已无剩余容量，因此跳出循环
+                break
+            }
+        }
+        return res
+    }
+    ```
+
 === "JS"
 
     ```javascript title="fractional_knapsack.js"
@@ -263,102 +343,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="fractional_knapsack.c"
-    [class]{Item}-[func]{}
-
-    [class]{}-[func]{fractionalKnapsack}
-    ```
-
-=== "C#"
-
-    ```csharp title="fractional_knapsack.cs"
-    /* 物品 */
-    class Item {
-        public int w; // 物品重量
-        public int v; // 物品价值
-
-        public Item(int w, int v) {
-            this.w = w;
-            this.v = v;
-        }
-    }
-
-    /* 分数背包：贪心 */
-    double fractionalKnapsack(int[] wgt, int[] val, int cap) {
-        // 创建物品列表，包含两个属性：重量、价值
-        Item[] items = new Item[wgt.Length];
-        for (int i = 0; i < wgt.Length; i++) {
-            items[i] = new Item(wgt[i], val[i]);
-        }
-        // 按照单位价值 item.v / item.w 从高到低进行排序
-        Array.Sort(items, (x, y) => (y.v / y.w).CompareTo(x.v / x.w));
-        // 循环贪心选择
-        double res = 0;
-        foreach (Item item in items) {
-            if (item.w <= cap) {
-                // 若剩余容量充足，则将当前物品整个装进背包
-                res += item.v;
-                cap -= item.w;
-            } else {
-                // 若剩余容量不足，则将当前物品的一部分装进背包
-                res += (double)item.v / item.w * cap;
-                // 已无剩余容量，因此跳出循环
-                break;
-            }
-        }
-        return res;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="fractional_knapsack.swift"
-    /* 物品 */
-    class Item {
-        var w: Int // 物品重量
-        var v: Int // 物品价值
-
-        init(w: Int, v: Int) {
-            self.w = w
-            self.v = v
-        }
-    }
-
-    /* 分数背包：贪心 */
-    func fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -> Double {
-        // 创建物品列表，包含两个属性：重量、价值
-        var items = zip(wgt, val).map { Item(w: $0, v: $1) }
-        // 按照单位价值 item.v / item.w 从高到低进行排序
-        items.sort(by: { -(Double($0.v) / Double($0.w)) < -(Double($1.v) / Double($1.w)) })
-        // 循环贪心选择
-        var res = 0.0
-        var cap = cap
-        for item in items {
-            if item.w <= cap {
-                // 若剩余容量充足，则将当前物品整个装进背包
-                res += Double(item.v)
-                cap -= item.w
-            } else {
-                // 若剩余容量不足，则将当前物品的一部分装进背包
-                res += Double(item.v) / Double(item.w) * Double(cap)
-                // 已无剩余容量，因此跳出循环
-                break
-            }
-        }
-        return res
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="fractional_knapsack.zig"
-    [class]{Item}-[func]{}
-
-    [class]{}-[func]{fractionalKnapsack}
-    ```
-
 === "Dart"
 
     ```dart title="fractional_knapsack.dart"
@@ -441,6 +425,22 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="fractional_knapsack.c"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractionalKnapsack}
+    ```
+
+=== "Zig"
+
+    ```zig title="fractional_knapsack.zig"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractionalKnapsack}
+    ```
+
 最差情况下，需要遍历整个物品列表，**因此时间复杂度为 $O(n)$** ，其中 $n$ 为物品数量。
 
 由于初始化了一个 `Item` 对象列表，**因此空间复杂度为 $O(n)$** 。