build

2026-08-30 20:07:14 +00:00 · 2024-04-06 03:02:20 +08:00
parent 0a9daa8b9f
commit 8d37c215c8
148 changed files with 70398 additions and 408 deletions
@@ -0,0 +1,568 @@
+---
+comments: true
+---
+
+# 15.2 &nbsp; 分數背包問題
+
+!!! question
+
+    給定 $n$ 個物品，第 $i$ 個物品的重量為 $wgt[i-1]$、價值為 $val[i-1]$ ，和一個容量為 $cap$ 的背包。每個物品只能選擇一次，**但可以選擇物品的一部分，價值根據選擇的重量比例計算**，問在限定背包容量下背包中物品的最大價值。示例如圖 15-3 所示。
+
+![分數背包問題的示例資料](fractional_knapsack_problem.assets/fractional_knapsack_example.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-3 &nbsp; 分數背包問題的示例資料 </p>
+
+分數背包問題和 0-1 背包問題整體上非常相似，狀態包含當前物品 $i$ 和容量 $c$ ，目標是求限定背包容量下的最大價值。
+
+不同點在於，本題允許只選擇物品的一部分。如圖 15-4 所示，**我們可以對物品任意地進行切分，並按照重量比例來計算相應價值**。
+
+1. 對於物品 $i$ ，它在單位重量下的價值為 $val[i-1] / wgt[i-1]$ ，簡稱單位價值。
+2. 假設放入一部分物品 $i$ ，重量為 $w$ ，則背包增加的價值為 $w \times val[i-1] / wgt[i-1]$ 。
+
+![物品在單位重量下的價值](fractional_knapsack_problem.assets/fractional_knapsack_unit_value.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-4 &nbsp; 物品在單位重量下的價值 </p>
+
+### 1. &nbsp; 貪婪策略確定
+
+最大化背包內物品總價值，**本質上是最大化單位重量下的物品價值**。由此便可推理出圖 15-5 所示的貪婪策略。
+
+1. 將物品按照單位價值從高到低進行排序。
+2. 走訪所有物品，**每輪貪婪地選擇單位價值最高的物品**。
+3. 若剩餘背包容量不足，則使用當前物品的一部分填滿背包。
+
+![分數背包問題的貪婪策略](fractional_knapsack_problem.assets/fractional_knapsack_greedy_strategy.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-5 &nbsp; 分數背包問題的貪婪策略 </p>
+
+### 2. &nbsp; 程式碼實現
+
+我們建立了一個物品類別 `Item` ，以便將物品按照單位價值進行排序。迴圈進行貪婪選擇，當背包已滿時跳出並返回解：
+
+=== "Python"
+
+    ```python title="fractional_knapsack.py"
+    class Item:
+        """物品"""
+
+        def __init__(self, w: int, v: int):
+            self.w = w  # 物品重量
+            self.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
+    ```
+
+=== "C++"
+
+    ```cpp title="fractional_knapsack.cpp"
+    /* 物品 */
+    class Item {
+      public:
+        int w; // 物品重量
+        int v; // 物品價值
+
+        Item(int w, int v) : w(w), v(v) {
+        }
+    };
+
+    /* 分數背包：貪婪 */
+    double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
+        // 建立物品串列，包含兩個屬性：重量、價值
+        vector<Item> items;
+        for (int i = 0; i < wgt.size(); i++) {
+            items.push_back(Item(wgt[i], val[i]));
+        }
+        // 按照單位價值 item.v / item.w 從高到低進行排序
+        sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });
+        // 迴圈貪婪選擇
+        double res = 0;
+        for (auto &item : items) {
+            if (item.w <= cap) {
+                // 若剩餘容量充足，則將當前物品整個裝進背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩餘容量不足，則將當前物品的一部分裝進背包
+                res += (double)item.v / item.w * cap;
+                // 已無剩餘容量，因此跳出迴圈
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="fractional_knapsack.java"
+    /* 物品 */
+    class Item {
+        int w; // 物品重量
+        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 從高到低進行排序
+        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(int w, int v) {
+        public int w = w; // 物品重量
+        public int 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"
+
+    ```go title="fractional_knapsack.go"
+    /* 物品 */
+    type Item struct {
+        w int // 物品重量
+        v int // 物品價值
+    }
+
+    /* 分數背包：貪婪 */
+    func fractionalKnapsack(wgt []int, val []int, cap int) float64 {
+        // 建立物品串列，包含兩個屬性：重量、價值
+        items := make([]Item, len(wgt))
+        for i := 0; i < len(wgt); i++ {
+            items[i] = Item{wgt[i], val[i]}
+        }
+        // 按照單位價值 item.v / item.w 從高到低進行排序
+        sort.Slice(items, func(i, j int) bool {
+            return float64(items[i].v)/float64(items[i].w) > float64(items[j].v)/float64(items[j].w)
+        })
+        // 迴圈貪婪選擇
+        res := 0.0
+        for _, item := range items {
+            if item.w <= cap {
+                // 若剩餘容量充足，則將當前物品整個裝進背包
+                res += float64(item.v)
+                cap -= item.w
+            } else {
+                // 若剩餘容量不足，則將當前物品的一部分裝進背包
+                res += float64(item.v) / float64(item.w) * float64(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 { -(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"
+    /* 物品 */
+    class Item {
+        constructor(w, v) {
+            this.w = w; // 物品重量
+            this.v = v; // 物品價值
+        }
+    }
+
+    /* 分數背包：貪婪 */
+    function fractionalKnapsack(wgt, val, cap) {
+        // 建立物品串列，包含兩個屬性：重量、價值
+        const items = wgt.map((w, i) => new Item(w, val[i]));
+        // 按照單位價值 item.v / item.w 從高到低進行排序
+        items.sort((a, b) => b.v / b.w - a.v / a.w);
+        // 迴圈貪婪選擇
+        let res = 0;
+        for (const item of items) {
+            if (item.w <= cap) {
+                // 若剩餘容量充足，則將當前物品整個裝進背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩餘容量不足，則將當前物品的一部分裝進背包
+                res += (item.v / item.w) * cap;
+                // 已無剩餘容量，因此跳出迴圈
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="fractional_knapsack.ts"
+    /* 物品 */
+    class Item {
+        w: number; // 物品重量
+        v: number; // 物品價值
+
+        constructor(w: number, v: number) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分數背包：貪婪 */
+    function fractionalKnapsack(wgt: number[], val: number[], cap: number): number {
+        // 建立物品串列，包含兩個屬性：重量、價值
+        const items: Item[] = wgt.map((w, i) => new Item(w, val[i]));
+        // 按照單位價值 item.v / item.w 從高到低進行排序
+        items.sort((a, b) => b.v / b.w - a.v / a.w);
+        // 迴圈貪婪選擇
+        let res = 0;
+        for (const item of items) {
+            if (item.w <= cap) {
+                // 若剩餘容量充足，則將當前物品整個裝進背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩餘容量不足，則將當前物品的一部分裝進背包
+                res += (item.v / item.w) * cap;
+                // 已無剩餘容量，因此跳出迴圈
+                break;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="fractional_knapsack.dart"
+    /* 物品 */
+    class Item {
+      int w; // 物品重量
+      int v; // 物品價值
+
+      Item(this.w, this.v);
+    }
+
+    /* 分數背包：貪婪 */
+    double fractionalKnapsack(List<int> wgt, List<int> val, int cap) {
+      // 建立物品串列，包含兩個屬性：重量、價值
+      List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));
+      // 按照單位價值 item.v / item.w 從高到低進行排序
+      items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));
+      // 迴圈貪婪選擇
+      double res = 0;
+      for (Item item in items) {
+        if (item.w <= cap) {
+          // 若剩餘容量充足，則將當前物品整個裝進背包
+          res += item.v;
+          cap -= item.w;
+        } else {
+          // 若剩餘容量不足，則將當前物品的一部分裝進背包
+          res += item.v / item.w * cap;
+          // 已無剩餘容量，因此跳出迴圈
+          break;
+        }
+      }
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="fractional_knapsack.rs"
+    /* 物品 */
+    struct Item {
+        w: i32, // 物品重量
+        v: i32, // 物品價值
+    }
+
+    impl Item {
+        fn new(w: i32, v: i32) -> Self {
+            Self { w, v }
+        }
+    }
+
+    /* 分數背包：貪婪 */
+    fn fractional_knapsack(wgt: &[i32], val: &[i32], mut cap: i32) -> f64 {
+        // 建立物品串列，包含兩個屬性：重量、價值
+        let mut items = wgt
+            .iter()
+            .zip(val.iter())
+            .map(|(&w, &v)| Item::new(w, v))
+            .collect::<Vec<Item>>();
+        // 按照單位價值 item.v / item.w 從高到低進行排序
+        items.sort_by(|a, b| {
+            (b.v as f64 / b.w as f64)
+                .partial_cmp(&(a.v as f64 / a.w as f64))
+                .unwrap()
+        });
+        // 迴圈貪婪選擇
+        let mut res = 0.0;
+        for item in &items {
+            if item.w <= cap {
+                // 若剩餘容量充足，則將當前物品整個裝進背包
+                res += item.v as f64;
+                cap -= item.w;
+            } else {
+                // 若剩餘容量不足，則將當前物品的一部分裝進背包
+                res += item.v as f64 / item.w as f64 * cap as f64;
+                // 已無剩餘容量，因此跳出迴圈
+                break;
+            }
+        }
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="fractional_knapsack.c"
+    /* 物品 */
+    typedef struct {
+        int w; // 物品重量
+        int v; // 物品價值
+    } Item;
+
+    /* 分數背包：貪婪 */
+    float fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {
+        // 建立物品串列，包含兩個屬性：重量、價值
+        Item *items = malloc(sizeof(Item) * itemCount);
+        for (int i = 0; i < itemCount; i++) {
+            items[i] = (Item){.w = wgt[i], .v = val[i]};
+        }
+        // 按照單位價值 item.v / item.w 從高到低進行排序
+        qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);
+        // 迴圈貪婪選擇
+        float res = 0.0;
+        for (int i = 0; i < itemCount; i++) {
+            if (items[i].w <= cap) {
+                // 若剩餘容量充足，則將當前物品整個裝進背包
+                res += items[i].v;
+                cap -= items[i].w;
+            } else {
+                // 若剩餘容量不足，則將當前物品的一部分裝進背包
+                res += (float)cap / items[i].w * items[i].v;
+                cap = 0;
+                break;
+            }
+        }
+        free(items);
+        return res;
+    }
+    ```
+
+=== "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
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="fractional_knapsack.rb"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractional_knapsack}
+    ```
+
+=== "Zig"
+
+    ```zig title="fractional_knapsack.zig"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractionalKnapsack}
+    ```
+
+??? pythontutor "視覺化執行"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=class%20Item%3A%0A%20%20%20%20%22%22%22%E7%89%A9%E5%93%81%22%22%22%0A%20%20%20%20def%20__init__%28self,%20w%3A%20int,%20v%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.w%20%3D%20w%20%20%23%20%E7%89%A9%E5%93%81%E9%87%8D%E9%87%8F%0A%20%20%20%20%20%20%20%20self.v%20%3D%20v%20%20%23%20%E7%89%A9%E5%93%81%E4%BB%B7%E5%80%BC%0A%0Adef%20fractional_knapsack%28wgt%3A%20list%5Bint%5D,%20val%3A%20list%5Bint%5D,%20cap%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E5%88%86%E6%95%B0%E8%83%8C%E5%8C%85%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%88%9B%E5%BB%BA%E7%89%A9%E5%93%81%E5%88%97%E8%A1%A8%EF%BC%8C%E5%8C%85%E5%90%AB%E4%B8%A4%E4%B8%AA%E5%B1%9E%E6%80%A7%EF%BC%9A%E9%87%8D%E9%87%8F%E3%80%81%E4%BB%B7%E5%80%BC%0A%20%20%20%20items%20%3D%20%5BItem%28w,%20v%29%20for%20w,%20v%20in%20zip%28wgt,%20val%29%5D%0A%20%20%20%20%23%20%E6%8C%89%E7%85%A7%E5%8D%95%E4%BD%8D%E4%BB%B7%E5%80%BC%20item.v%20/%20item.w%20%E4%BB%8E%E9%AB%98%E5%88%B0%E4%BD%8E%E8%BF%9B%E8%A1%8C%E6%8E%92%E5%BA%8F%0A%20%20%20%20items.sort%28key%3Dlambda%20item%3A%20item.v%20/%20item.w,%20reverse%3DTrue%29%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E8%B4%AA%E5%BF%83%E9%80%89%E6%8B%A9%0A%20%20%20%20res%20%3D%200%0A%20%20%20%20for%20item%20in%20items%3A%0A%20%20%20%20%20%20%20%20if%20item.w%20%3C%3D%20cap%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E5%89%A9%E4%BD%99%E5%AE%B9%E9%87%8F%E5%85%85%E8%B6%B3%EF%BC%8C%E5%88%99%E5%B0%86%E5%BD%93%E5%89%8D%E7%89%A9%E5%93%81%E6%95%B4%E4%B8%AA%E8%A3%85%E8%BF%9B%E8%83%8C%E5%8C%85%0A%20%20%20%20%20%20%20%20%20%20%20%20res%20%2B%3D%20item.v%0A%20%20%20%20%20%20%20%20%20%20%20%20cap%20-%3D%20item.w%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E5%89%A9%E4%BD%99%E5%AE%B9%E9%87%8F%E4%B8%8D%E8%B6%B3%EF%BC%8C%E5%88%99%E5%B0%86%E5%BD%93%E5%89%8D%E7%89%A9%E5%93%81%E7%9A%84%E4%B8%80%E9%83%A8%E5%88%86%E8%A3%85%E8%BF%9B%E8%83%8C%E5%8C%85%0A%20%20%20%20%20%20%20%20%20%20%20%20res%20%2B%3D%20%28item.v%20/%20item.w%29%20*%20cap%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E5%B7%B2%E6%97%A0%E5%89%A9%E4%BD%99%E5%AE%B9%E9%87%8F%EF%BC%8C%E5%9B%A0%E6%AD%A4%E8%B7%B3%E5%87%BA%E5%BE%AA%E7%8E%AF%0A%20%20%20%20%20%20%20%20%20%20%20%20break%0A%20%20%20%20return%20res%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20wgt%20%3D%20%5B10,%2020,%2030,%2040,%2050%5D%0A%20%20%20%20val%20%3D%20%5B50,%20120,%20150,%20210,%20240%5D%0A%20%20%20%20cap%20%3D%2050%0A%20%20%20%20n%20%3D%20len%28wgt%29%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%0A%20%20%20%20res%20%3D%20fractional_knapsack%28wgt,%20val,%20cap%29%0A%20%20%20%20print%28f%22%E4%B8%8D%E8%B6%85%E8%BF%87%E8%83%8C%E5%8C%85%E5%AE%B9%E9%87%8F%E7%9A%84%E6%9C%80%E5%A4%A7%E7%89%A9%E5%93%81%E4%BB%B7%E5%80%BC%E4%B8%BA%20%7Bres%7D%22%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=8&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=class%20Item%3A%0A%20%20%20%20%22%22%22%E7%89%A9%E5%93%81%22%22%22%0A%20%20%20%20def%20__init__%28self,%20w%3A%20int,%20v%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.w%20%3D%20w%20%20%23%20%E7%89%A9%E5%93%81%E9%87%8D%E9%87%8F%0A%20%20%20%20%20%20%20%20self.v%20%3D%20v%20%20%23%20%E7%89%A9%E5%93%81%E4%BB%B7%E5%80%BC%0A%0Adef%20fractional_knapsack%28wgt%3A%20list%5Bint%5D,%20val%3A%20list%5Bint%5D,%20cap%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E5%88%86%E6%95%B0%E8%83%8C%E5%8C%85%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%88%9B%E5%BB%BA%E7%89%A9%E5%93%81%E5%88%97%E8%A1%A8%EF%BC%8C%E5%8C%85%E5%90%AB%E4%B8%A4%E4%B8%AA%E5%B1%9E%E6%80%A7%EF%BC%9A%E9%87%8D%E9%87%8F%E3%80%81%E4%BB%B7%E5%80%BC%0A%20%20%20%20items%20%3D%20%5BItem%28w,%20v%29%20for%20w,%20v%20in%20zip%28wgt,%20val%29%5D%0A%20%20%20%20%23%20%E6%8C%89%E7%85%A7%E5%8D%95%E4%BD%8D%E4%BB%B7%E5%80%BC%20item.v%20/%20item.w%20%E4%BB%8E%E9%AB%98%E5%88%B0%E4%BD%8E%E8%BF%9B%E8%A1%8C%E6%8E%92%E5%BA%8F%0A%20%20%20%20items.sort%28key%3Dlambda%20item%3A%20item.v%20/%20item.w,%20reverse%3DTrue%29%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E8%B4%AA%E5%BF%83%E9%80%89%E6%8B%A9%0A%20%20%20%20res%20%3D%200%0A%20%20%20%20for%20item%20in%20items%3A%0A%20%20%20%20%20%20%20%20if%20item.w%20%3C%3D%20cap%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E5%89%A9%E4%BD%99%E5%AE%B9%E9%87%8F%E5%85%85%E8%B6%B3%EF%BC%8C%E5%88%99%E5%B0%86%E5%BD%93%E5%89%8D%E7%89%A9%E5%93%81%E6%95%B4%E4%B8%AA%E8%A3%85%E8%BF%9B%E8%83%8C%E5%8C%85%0A%20%20%20%20%20%20%20%20%20%20%20%20res%20%2B%3D%20item.v%0A%20%20%20%20%20%20%20%20%20%20%20%20cap%20-%3D%20item.w%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E5%89%A9%E4%BD%99%E5%AE%B9%E9%87%8F%E4%B8%8D%E8%B6%B3%EF%BC%8C%E5%88%99%E5%B0%86%E5%BD%93%E5%89%8D%E7%89%A9%E5%93%81%E7%9A%84%E4%B8%80%E9%83%A8%E5%88%86%E8%A3%85%E8%BF%9B%E8%83%8C%E5%8C%85%0A%20%20%20%20%20%20%20%20%20%20%20%20res%20%2B%3D%20%28item.v%20/%20item.w%29%20*%20cap%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E5%B7%B2%E6%97%A0%E5%89%A9%E4%BD%99%E5%AE%B9%E9%87%8F%EF%BC%8C%E5%9B%A0%E6%AD%A4%E8%B7%B3%E5%87%BA%E5%BE%AA%E7%8E%AF%0A%20%20%20%20%20%20%20%20%20%20%20%20break%0A%20%20%20%20return%20res%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20wgt%20%3D%20%5B10,%2020,%2030,%2040,%2050%5D%0A%20%20%20%20val%20%3D%20%5B50,%20120,%20150,%20210,%20240%5D%0A%20%20%20%20cap%20%3D%2050%0A%20%20%20%20n%20%3D%20len%28wgt%29%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%0A%20%20%20%20res%20%3D%20fractional_knapsack%28wgt,%20val,%20cap%29%0A%20%20%20%20print%28f%22%E4%B8%8D%E8%B6%85%E8%BF%87%E8%83%8C%E5%8C%85%E5%AE%B9%E9%87%8F%E7%9A%84%E6%9C%80%E5%A4%A7%E7%89%A9%E5%93%81%E4%BB%B7%E5%80%BC%E4%B8%BA%20%7Bres%7D%22%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=8&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">全螢幕觀看 ></a></div>
+
+除排序之外，在最差情況下，需要走訪整個物品串列，**因此時間複雜度為 $O(n)$** ，其中 $n$ 為物品數量。
+
+由於初始化了一個 `Item` 物件串列，**因此空間複雜度為 $O(n)$** 。
+
+### 3. &nbsp; 正確性證明
+
+採用反證法。假設物品 $x$ 是單位價值最高的物品，使用某演算法求得最大價值為 `res` ，但該解中不包含物品 $x$ 。
+
+現在從背包中拿出單位重量的任意物品，並替換為單位重量的物品 $x$ 。由於物品 $x$ 的單位價值最高，因此替換後的總價值一定大於 `res` 。**這與 `res` 是最優解矛盾，說明最優解中必須包含物品 $x$** 。
+
+對於該解中的其他物品，我們也可以構建出上述矛盾。總而言之，**單位價值更大的物品總是更優選擇**，這說明貪婪策略是有效的。
+
+如圖 15-6 所示，如果將物品重量和物品單位價值分別看作一張二維圖表的橫軸和縱軸，則分數背包問題可轉化為“求在有限橫軸區間下圍成的最大面積”。這個類比可以幫助我們從幾何角度理解貪婪策略的有效性。
+
+![分數背包問題的幾何表示](fractional_knapsack_problem.assets/fractional_knapsack_area_chart.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-6 &nbsp; 分數背包問題的幾何表示 </p>
@@ -0,0 +1,397 @@
+---
+comments: true
+---
+
+# 15.1 &nbsp; 貪婪演算法
+
+<u>貪婪演算法（greedy algorithm）</u>是一種常見的解決最佳化問題的演算法，其基本思想是在問題的每個決策階段，都選擇當前看起來最優的選擇，即貪婪地做出區域性最優的決策，以期獲得全域性最優解。貪婪演算法簡潔且高效，在許多實際問題中有著廣泛的應用。
+
+貪婪演算法和動態規劃都常用於解決最佳化問題。它們之間存在一些相似之處，比如都依賴最優子結構性質，但工作原理不同。
+
+- 動態規劃會根據之前階段的所有決策來考慮當前決策，並使用過去子問題的解來構建當前子問題的解。
+- 貪婪演算法不會考慮過去的決策，而是一路向前地進行貪婪選擇，不斷縮小問題範圍，直至問題被解決。
+
+我們先透過例題“零錢兌換”瞭解貪婪演算法的工作原理。這道題已經在“完全背包問題”章節中介紹過，相信你對它並不陌生。
+
+!!! question
+
+    給定 $n$ 種硬幣，第 $i$ 種硬幣的面值為 $coins[i - 1]$ ，目標金額為 $amt$ ，每種硬幣可以重複選取，問能夠湊出目標金額的最少硬幣數量。如果無法湊出目標金額，則返回 $-1$ 。
+
+本題採取的貪婪策略如圖 15-1 所示。給定目標金額，**我們貪婪地選擇不大於且最接近它的硬幣**，不斷迴圈該步驟，直至湊出目標金額為止。
+
+![零錢兌換的貪婪策略](greedy_algorithm.assets/coin_change_greedy_strategy.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-1 &nbsp; 零錢兌換的貪婪策略 </p>
+
+實現程式碼如下所示：
+
+=== "Python"
+
+    ```python title="coin_change_greedy.py"
+    def coin_change_greedy(coins: list[int], amt: int) -> int:
+        """零錢兌換：貪婪"""
+        # 假設 coins 串列有序
+        i = len(coins) - 1
+        count = 0
+        # 迴圈進行貪婪選擇，直到無剩餘金額
+        while amt > 0:
+            # 找到小於且最接近剩餘金額的硬幣
+            while i > 0 and coins[i] > amt:
+                i -= 1
+            # 選擇 coins[i]
+            amt -= coins[i]
+            count += 1
+        # 若未找到可行方案，則返回 -1
+        return count if amt == 0 else -1
+    ```
+
+=== "C++"
+
+    ```cpp title="coin_change_greedy.cpp"
+    /* 零錢兌換：貪婪 */
+    int coinChangeGreedy(vector<int> &coins, int amt) {
+        // 假設 coins 串列有序
+        int i = coins.size() - 1;
+        int count = 0;
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while (amt > 0) {
+            // 找到小於且最接近剩餘金額的硬幣
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 選擇 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，則返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="coin_change_greedy.java"
+    /* 零錢兌換：貪婪 */
+    int coinChangeGreedy(int[] coins, int amt) {
+        // 假設 coins 串列有序
+        int i = coins.length - 1;
+        int count = 0;
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while (amt > 0) {
+            // 找到小於且最接近剩餘金額的硬幣
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 選擇 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，則返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="coin_change_greedy.cs"
+    /* 零錢兌換：貪婪 */
+    int CoinChangeGreedy(int[] coins, int amt) {
+        // 假設 coins 串列有序
+        int i = coins.Length - 1;
+        int count = 0;
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while (amt > 0) {
+            // 找到小於且最接近剩餘金額的硬幣
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 選擇 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，則返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="coin_change_greedy.go"
+    /* 零錢兌換：貪婪 */
+    func coinChangeGreedy(coins []int, amt int) int {
+        // 假設 coins 串列有序
+        i := len(coins) - 1
+        count := 0
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        for amt > 0 {
+            // 找到小於且最接近剩餘金額的硬幣
+            for i > 0 && coins[i] > amt {
+                i--
+            }
+            // 選擇 coins[i]
+            amt -= coins[i]
+            count++
+        }
+        // 若未找到可行方案，則返回 -1
+        if amt != 0 {
+            return -1
+        }
+        return count
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="coin_change_greedy.swift"
+    /* 零錢兌換：貪婪 */
+    func coinChangeGreedy(coins: [Int], amt: Int) -> Int {
+        // 假設 coins 串列有序
+        var i = coins.count - 1
+        var count = 0
+        var amt = amt
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while amt > 0 {
+            // 找到小於且最接近剩餘金額的硬幣
+            while i > 0 && coins[i] > amt {
+                i -= 1
+            }
+            // 選擇 coins[i]
+            amt -= coins[i]
+            count += 1
+        }
+        // 若未找到可行方案，則返回 -1
+        return amt == 0 ? count : -1
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="coin_change_greedy.js"
+    /* 零錢兌換：貪婪 */
+    function coinChangeGreedy(coins, amt) {
+        // 假設 coins 陣列有序
+        let i = coins.length - 1;
+        let count = 0;
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while (amt > 0) {
+            // 找到小於且最接近剩餘金額的硬幣
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 選擇 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，則返回 -1
+        return amt === 0 ? count : -1;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="coin_change_greedy.ts"
+    /* 零錢兌換：貪婪 */
+    function coinChangeGreedy(coins: number[], amt: number): number {
+        // 假設 coins 陣列有序
+        let i = coins.length - 1;
+        let count = 0;
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while (amt > 0) {
+            // 找到小於且最接近剩餘金額的硬幣
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 選擇 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，則返回 -1
+        return amt === 0 ? count : -1;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="coin_change_greedy.dart"
+    /* 零錢兌換：貪婪 */
+    int coinChangeGreedy(List<int> coins, int amt) {
+      // 假設 coins 串列有序
+      int i = coins.length - 1;
+      int count = 0;
+      // 迴圈進行貪婪選擇，直到無剩餘金額
+      while (amt > 0) {
+        // 找到小於且最接近剩餘金額的硬幣
+        while (i > 0 && coins[i] > amt) {
+          i--;
+        }
+        // 選擇 coins[i]
+        amt -= coins[i];
+        count++;
+      }
+      // 若未找到可行方案，則返回 -1
+      return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="coin_change_greedy.rs"
+    /* 零錢兌換：貪婪 */
+    fn coin_change_greedy(coins: &[i32], mut amt: i32) -> i32 {
+        // 假設 coins 串列有序
+        let mut i = coins.len() - 1;
+        let mut count = 0;
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while amt > 0 {
+            // 找到小於且最接近剩餘金額的硬幣
+            while i > 0 && coins[i] > amt {
+                i -= 1;
+            }
+            // 選擇 coins[i]
+            amt -= coins[i];
+            count += 1;
+        }
+        // 若未找到可行方案，則返回 -1
+        if amt == 0 {
+            count
+        } else {
+            -1
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="coin_change_greedy.c"
+    /* 零錢兌換：貪婪 */
+    int coinChangeGreedy(int *coins, int size, int amt) {
+        // 假設 coins 串列有序
+        int i = size - 1;
+        int count = 0;
+        // 迴圈進行貪婪選擇，直到無剩餘金額
+        while (amt > 0) {
+            // 找到小於且最接近剩餘金額的硬幣
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 選擇 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，則返回 -1
+        return amt == 0 ? count : -1;
+    }
+    ```
+
+=== "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
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="coin_change_greedy.rb"
+    [class]{}-[func]{coin_change_greedy}
+    ```
+
+=== "Zig"
+
+    ```zig title="coin_change_greedy.zig"
+    [class]{}-[func]{coinChangeGreedy}
+    ```
+
+??? pythontutor "視覺化執行"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20coin_change_greedy%28coins%3A%20list%5Bint%5D,%20amt%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E9%9B%B6%E9%92%B1%E5%85%91%E6%8D%A2%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%81%87%E8%AE%BE%20coins%20%E5%88%97%E8%A1%A8%E6%9C%89%E5%BA%8F%0A%20%20%20%20i%20%3D%20len%28coins%29%20-%201%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E8%BF%9B%E8%A1%8C%E8%B4%AA%E5%BF%83%E9%80%89%E6%8B%A9%EF%BC%8C%E7%9B%B4%E5%88%B0%E6%97%A0%E5%89%A9%E4%BD%99%E9%87%91%E9%A2%9D%0A%20%20%20%20while%20amt%20%3E%200%3A%0A%20%20%20%20%20%20%20%20%23%20%E6%89%BE%E5%88%B0%E5%B0%8F%E4%BA%8E%E4%B8%94%E6%9C%80%E6%8E%A5%E8%BF%91%E5%89%A9%E4%BD%99%E9%87%91%E9%A2%9D%E7%9A%84%E7%A1%AC%E5%B8%81%0A%20%20%20%20%20%20%20%20while%20i%20%3E%200%20and%20coins%5Bi%5D%20%3E%20amt%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20-%3D%201%0A%20%20%20%20%20%20%20%20%23%20%E9%80%89%E6%8B%A9%20coins%5Bi%5D%0A%20%20%20%20%20%20%20%20amt%20-%3D%20coins%5Bi%5D%0A%20%20%20%20%20%20%20%20count%20%2B%3D%201%0A%20%20%20%20%23%20%E8%8B%A5%E6%9C%AA%E6%89%BE%E5%88%B0%E5%8F%AF%E8%A1%8C%E6%96%B9%E6%A1%88%EF%BC%8C%E5%88%99%E8%BF%94%E5%9B%9E%20-1%0A%20%20%20%20return%20count%20if%20amt%20%3D%3D%200%20else%20-1%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%EF%BC%9A%E8%83%BD%E5%A4%9F%E4%BF%9D%E8%AF%81%E6%89%BE%E5%88%B0%E5%85%A8%E5%B1%80%E6%9C%80%E4%BC%98%E8%A7%A3%0A%20%20%20%20coins%20%3D%20%5B1,%205,%2010,%2020,%2050,%20100%5D%0A%20%20%20%20amt%20%3D%20186%0A%20%20%20%20res%20%3D%20coin_change_greedy%28coins,%20amt%29%0A%20%20%20%20print%28f%22%5Cncoins%20%3D%20%7Bcoins%7D,%20amt%20%3D%20%7Bamt%7D%22%29%0A%20%20%20%20print%28f%22%E5%87%91%E5%88%B0%20%7Bamt%7D%20%E6%89%80%E9%9C%80%E7%9A%84%E6%9C%80%E5%B0%91%E7%A1%AC%E5%B8%81%E6%95%B0%E9%87%8F%E4%B8%BA%20%7Bres%7D%22%29%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%EF%BC%9A%E6%97%A0%E6%B3%95%E4%BF%9D%E8%AF%81%E6%89%BE%E5%88%B0%E5%85%A8%E5%B1%80%E6%9C%80%E4%BC%98%E8%A7%A3%0A%20%20%20%20coins%20%3D%20%5B1,%2020,%2050%5D%0A%20%20%20%20amt%20%3D%2060%0A%20%20%20%20res%20%3D%20coin_change_greedy%28coins,%20amt%29%0A%20%20%20%20print%28f%22%5Cncoins%20%3D%20%7Bcoins%7D,%20amt%20%3D%20%7Bamt%7D%22%29%0A%20%20%20%20print%28f%22%E5%87%91%E5%88%B0%20%7Bamt%7D%20%E6%89%80%E9%9C%80%E7%9A%84%E6%9C%80%E5%B0%91%E7%A1%AC%E5%B8%81%E6%95%B0%E9%87%8F%E4%B8%BA%20%7Bres%7D%22%29%0A%20%20%20%20print%28f%22%E5%AE%9E%E9%99%85%E4%B8%8A%E9%9C%80%E8%A6%81%E7%9A%84%E6%9C%80%E5%B0%91%E6%95%B0%E9%87%8F%E4%B8%BA%203%20%EF%BC%8C%E5%8D%B3%2020%20%2B%2020%20%2B%2020%22%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20coin_change_greedy%28coins%3A%20list%5Bint%5D,%20amt%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E9%9B%B6%E9%92%B1%E5%85%91%E6%8D%A2%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%81%87%E8%AE%BE%20coins%20%E5%88%97%E8%A1%A8%E6%9C%89%E5%BA%8F%0A%20%20%20%20i%20%3D%20len%28coins%29%20-%201%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E8%BF%9B%E8%A1%8C%E8%B4%AA%E5%BF%83%E9%80%89%E6%8B%A9%EF%BC%8C%E7%9B%B4%E5%88%B0%E6%97%A0%E5%89%A9%E4%BD%99%E9%87%91%E9%A2%9D%0A%20%20%20%20while%20amt%20%3E%200%3A%0A%20%20%20%20%20%20%20%20%23%20%E6%89%BE%E5%88%B0%E5%B0%8F%E4%BA%8E%E4%B8%94%E6%9C%80%E6%8E%A5%E8%BF%91%E5%89%A9%E4%BD%99%E9%87%91%E9%A2%9D%E7%9A%84%E7%A1%AC%E5%B8%81%0A%20%20%20%20%20%20%20%20while%20i%20%3E%200%20and%20coins%5Bi%5D%20%3E%20amt%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20-%3D%201%0A%20%20%20%20%20%20%20%20%23%20%E9%80%89%E6%8B%A9%20coins%5Bi%5D%0A%20%20%20%20%20%20%20%20amt%20-%3D%20coins%5Bi%5D%0A%20%20%20%20%20%20%20%20count%20%2B%3D%201%0A%20%20%20%20%23%20%E8%8B%A5%E6%9C%AA%E6%89%BE%E5%88%B0%E5%8F%AF%E8%A1%8C%E6%96%B9%E6%A1%88%EF%BC%8C%E5%88%99%E8%BF%94%E5%9B%9E%20-1%0A%20%20%20%20return%20count%20if%20amt%20%3D%3D%200%20else%20-1%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%EF%BC%9A%E8%83%BD%E5%A4%9F%E4%BF%9D%E8%AF%81%E6%89%BE%E5%88%B0%E5%85%A8%E5%B1%80%E6%9C%80%E4%BC%98%E8%A7%A3%0A%20%20%20%20coins%20%3D%20%5B1,%205,%2010,%2020,%2050,%20100%5D%0A%20%20%20%20amt%20%3D%20186%0A%20%20%20%20res%20%3D%20coin_change_greedy%28coins,%20amt%29%0A%20%20%20%20print%28f%22%5Cncoins%20%3D%20%7Bcoins%7D,%20amt%20%3D%20%7Bamt%7D%22%29%0A%20%20%20%20print%28f%22%E5%87%91%E5%88%B0%20%7Bamt%7D%20%E6%89%80%E9%9C%80%E7%9A%84%E6%9C%80%E5%B0%91%E7%A1%AC%E5%B8%81%E6%95%B0%E9%87%8F%E4%B8%BA%20%7Bres%7D%22%29%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%EF%BC%9A%E6%97%A0%E6%B3%95%E4%BF%9D%E8%AF%81%E6%89%BE%E5%88%B0%E5%85%A8%E5%B1%80%E6%9C%80%E4%BC%98%E8%A7%A3%0A%20%20%20%20coins%20%3D%20%5B1,%2020,%2050%5D%0A%20%20%20%20amt%20%3D%2060%0A%20%20%20%20res%20%3D%20coin_change_greedy%28coins,%20amt%29%0A%20%20%20%20print%28f%22%5Cncoins%20%3D%20%7Bcoins%7D,%20amt%20%3D%20%7Bamt%7D%22%29%0A%20%20%20%20print%28f%22%E5%87%91%E5%88%B0%20%7Bamt%7D%20%E6%89%80%E9%9C%80%E7%9A%84%E6%9C%80%E5%B0%91%E7%A1%AC%E5%B8%81%E6%95%B0%E9%87%8F%E4%B8%BA%20%7Bres%7D%22%29%0A%20%20%20%20print%28f%22%E5%AE%9E%E9%99%85%E4%B8%8A%E9%9C%80%E8%A6%81%E7%9A%84%E6%9C%80%E5%B0%91%E6%95%B0%E9%87%8F%E4%B8%BA%203%20%EF%BC%8C%E5%8D%B3%2020%20%2B%2020%20%2B%2020%22%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">全螢幕觀看 ></a></div>
+
+你可能會不由地發出感嘆：So clean ！貪婪演算法僅用約十行程式碼就解決了零錢兌換問題。
+
+## 15.1.1 &nbsp; 貪婪演算法的優點與侷限性
+
+**貪婪演算法不僅操作直接、實現簡單，而且通常效率也很高**。在以上程式碼中，記硬幣最小面值為 $\min(coins)$ ，則貪婪選擇最多迴圈 $amt / \min(coins)$ 次，時間複雜度為 $O(amt / \min(coins))$ 。這比動態規劃解法的時間複雜度 $O(n \times amt)$ 小了一個數量級。
+
+然而，**對於某些硬幣面值組合，貪婪演算法並不能找到最優解**。圖 15-2 給出了兩個示例。
+
+- **正例 $coins = [1, 5, 10, 20, 50, 100]$**：在該硬幣組合下，給定任意 $amt$ ，貪婪演算法都可以找到最優解。
+- **反例 $coins = [1, 20, 50]$**：假設 $amt = 60$ ，貪婪演算法只能找到 $50 + 1 \times 10$ 的兌換組合，共計 $11$ 枚硬幣，但動態規劃可以找到最優解 $20 + 20 + 20$ ，僅需 $3$ 枚硬幣。
+- **反例 $coins = [1, 49, 50]$**：假設 $amt = 98$ ，貪婪演算法只能找到 $50 + 1 \times 48$ 的兌換組合，共計 $49$ 枚硬幣，但動態規劃可以找到最優解 $49 + 49$ ，僅需 $2$ 枚硬幣。
+
+![貪婪演算法無法找出最優解的示例](greedy_algorithm.assets/coin_change_greedy_vs_dp.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-2 &nbsp; 貪婪演算法無法找出最優解的示例 </p>
+
+也就是說，對於零錢兌換問題，貪婪演算法無法保證找到全域性最優解，並且有可能找到非常差的解。它更適合用動態規劃解決。
+
+一般情況下，貪婪演算法的適用情況分以下兩種。
+
+1. **可以保證找到最優解**：貪婪演算法在這種情況下往往是最優選擇，因為它往往比回溯、動態規劃更高效。
+2. **可以找到近似最優解**：貪婪演算法在這種情況下也是可用的。對於很多複雜問題來說，尋找全域性最優解非常困難，能以較高效率找到次優解也是非常不錯的。
+
+## 15.1.2 &nbsp; 貪婪演算法特性
+
+那麼問題來了，什麼樣的問題適合用貪婪演算法求解呢？或者說，貪婪演算法在什麼情況下可以保證找到最優解？
+
+相較於動態規劃，貪婪演算法的使用條件更加苛刻，其主要關注問題的兩個性質。
+
+- **貪婪選擇性質**：只有當局部最優選擇始終可以導致全域性最優解時，貪婪演算法才能保證得到最優解。
+- **最優子結構**：原問題的最優解包含子問題的最優解。
+
+最優子結構已經在“動態規劃”章節中介紹過，這裡不再贅述。值得注意的是，一些問題的最優子結構並不明顯，但仍然可使用貪婪演算法解決。
+
+我們主要探究貪婪選擇性質的判斷方法。雖然它的描述看上去比較簡單，**但實際上對於許多問題，證明貪婪選擇性質並非易事**。
+
+例如零錢兌換問題，我們雖然能夠容易地舉出反例，對貪婪選擇性質進行證偽，但證實的難度較大。如果問：**滿足什麼條件的硬幣組合可以使用貪婪演算法求解**？我們往往只能憑藉直覺或舉例子來給出一個模稜兩可的答案，而難以給出嚴謹的數學證明。
+
+!!! quote
+
+    有一篇論文給出了一個 $O(n^3)$ 時間複雜度的演算法，用於判斷一個硬幣組合能否使用貪婪演算法找出任意金額的最優解。
+
+    Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.
+
+## 15.1.3 &nbsp; 貪婪演算法解題步驟
+
+貪婪問題的解決流程大體可分為以下三步。
+
+1. **問題分析**：梳理與理解問題特性，包括狀態定義、最佳化目標和約束條件等。這一步在回溯和動態規劃中都有涉及。
+2. **確定貪婪策略**：確定如何在每一步中做出貪婪選擇。這個策略能夠在每一步減小問題的規模，並最終解決整個問題。
+3. **正確性證明**：通常需要證明問題具有貪婪選擇性質和最優子結構。這個步驟可能需要用到數學證明，例如歸納法或反證法等。
+
+確定貪婪策略是求解問題的核心步驟，但實施起來可能並不容易，主要有以下原因。
+
+- **不同問題的貪婪策略的差異較大**。對於許多問題來說，貪婪策略比較淺顯，我們透過一些大概的思考與嘗試就能得出。而對於一些複雜問題，貪婪策略可能非常隱蔽，這種情況就非常考驗個人的解題經驗與演算法能力了。
+- **某些貪婪策略具有較強的迷惑性**。當我們滿懷信心設計好貪婪策略，寫出解題程式碼並提交執行，很可能發現部分測試樣例無法透過。這是因為設計的貪婪策略只是“部分正確”的，上文介紹的零錢兌換就是一個典型案例。
+
+為了保證正確性，我們應該對貪婪策略進行嚴謹的數學證明，**通常需要用到反證法或數學歸納法**。
+
+然而，正確性證明也很可能不是一件易事。如若沒有頭緒，我們通常會選擇面向測試用例進行程式碼除錯，一步步修改與驗證貪婪策略。
+
+## 15.1.4 &nbsp; 貪婪演算法典型例題
+
+貪婪演算法常常應用在滿足貪婪選擇性質和最優子結構的最佳化問題中，以下列舉了一些典型的貪婪演算法問題。
+
+- **硬幣找零問題**：在某些硬幣組合下，貪婪演算法總是可以得到最優解。
+- **區間排程問題**：假設你有一些任務，每個任務在一段時間內進行，你的目標是完成儘可能多的任務。如果每次都選擇結束時間最早的任務，那麼貪婪演算法就可以得到最優解。
+- **分數背包問題**：給定一組物品和一個載重量，你的目標是選擇一組物品，使得總重量不超過載重量，且總價值最大。如果每次都選擇價效比最高（價值 / 重量）的物品，那麼貪婪演算法在一些情況下可以得到最優解。
+- **股票買賣問題**：給定一組股票的歷史價格，你可以進行多次買賣，但如果你已經持有股票，那麼在賣出之前不能再買，目標是獲取最大利潤。
+- **霍夫曼編碼**：霍夫曼編碼是一種用於無損資料壓縮的貪婪演算法。透過構建霍夫曼樹，每次選擇出現頻率最低的兩個節點合併，最後得到的霍夫曼樹的帶權路徑長度（編碼長度）最小。
+- **Dijkstra 演算法**：它是一種解決給定源頂點到其餘各頂點的最短路徑問題的貪婪演算法。
@@ -0,0 +1,22 @@
+---
+comments: true
+icon: material/head-heart-outline
+---
+
+# 第 15 章 &nbsp; 貪婪
+
+![貪婪](../assets/covers/chapter_greedy.jpg){ class="cover-image" }
+
+!!! abstract
+
+    向日葵朝著太陽轉動，時刻追求自身成長的最大可能。
+
+    貪婪策略在一輪輪的簡單選擇中，逐步導向最佳答案。
+
+## Chapter Contents
+
+- [15.1 &nbsp; 貪婪演算法](https://www.hello-algo.com/en/chapter_greedy/greedy_algorithm/)
+- [15.2 &nbsp; 分數背包問題](https://www.hello-algo.com/en/chapter_greedy/fractional_knapsack_problem/)
+- [15.3 &nbsp; 最大容量問題](https://www.hello-algo.com/en/chapter_greedy/max_capacity_problem/)
+- [15.4 &nbsp; 最大切分乘積問題](https://www.hello-algo.com/en/chapter_greedy/max_product_cutting_problem/)
+- [15.5 &nbsp; 小結](https://www.hello-algo.com/en/chapter_greedy/summary/)
@@ -0,0 +1,430 @@
+---
+comments: true
+---
+
+# 15.3 &nbsp; 最大容量問題
+
+!!! question
+
+    輸入一個陣列 $ht$ ，其中的每個元素代表一個垂直隔板的高度。陣列中的任意兩個隔板，以及它們之間的空間可以組成一個容器。
+    
+    容器的容量等於高度和寬度的乘積（面積），其中高度由較短的隔板決定，寬度是兩個隔板的陣列索引之差。
+    
+    請在陣列中選擇兩個隔板，使得組成的容器的容量最大，返回最大容量。示例如圖 15-7 所示。
+
+![最大容量問題的示例資料](max_capacity_problem.assets/max_capacity_example.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-7 &nbsp; 最大容量問題的示例資料 </p>
+
+容器由任意兩個隔板圍成，**因此本題的狀態為兩個隔板的索引，記為 $[i, j]$** 。
+
+根據題意，容量等於高度乘以寬度，其中高度由短板決定，寬度是兩隔板的陣列索引之差。設容量為 $cap[i, j]$ ，則可得計算公式：
+
+$$
+cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
+$$
+
+設陣列長度為 $n$ ，兩個隔板的組合數量（狀態總數）為 $C_n^2 = \frac{n(n - 1)}{2}$ 個。最直接地，**我們可以窮舉所有狀態**，從而求得最大容量，時間複雜度為 $O(n^2)$ 。
+
+### 1. &nbsp; 貪婪策略確定
+
+這道題還有更高效率的解法。如圖 15-8 所示，現選取一個狀態 $[i, j]$ ，其滿足索引 $i < j$ 且高度 $ht[i] < ht[j]$ ，即 $i$ 為短板、$j$ 為長板。
+
+![初始狀態](max_capacity_problem.assets/max_capacity_initial_state.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-8 &nbsp; 初始狀態 </p>
+
+如圖 15-9 所示，**若此時將長板 $j$ 向短板 $i$ 靠近，則容量一定變小**。
+
+這是因為在移動長板 $j$ 後，寬度 $j-i$ 肯定變小；而高度由短板決定，因此高度只可能不變（ $i$ 仍為短板）或變小（移動後的 $j$ 成為短板）。
+
+![向內移動長板後的狀態](max_capacity_problem.assets/max_capacity_moving_long_board.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-9 &nbsp; 向內移動長板後的狀態 </p>
+
+反向思考，**我們只有向內收縮短板 $i$ ，才有可能使容量變大**。因為雖然寬度一定變小，**但高度可能會變大**（移動後的短板 $i$ 可能會變長）。例如在圖 15-10 中，移動短板後面積變大。
+
+![向內移動短板後的狀態](max_capacity_problem.assets/max_capacity_moving_short_board.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-10 &nbsp; 向內移動短板後的狀態 </p>
+
+由此便可推出本題的貪婪策略：初始化兩指標，使其分列容器兩端，每輪向內收縮短板對應的指標，直至兩指標相遇。
+
+圖 15-11 展示了貪婪策略的執行過程。
+
+1. 初始狀態下，指標 $i$ 和 $j$ 分列陣列兩端。
+2. 計算當前狀態的容量 $cap[i, j]$ ，並更新最大容量。
+3. 比較板 $i$ 和 板 $j$ 的高度，並將短板向內移動一格。
+4. 迴圈執行第 `2.` 步和第 `3.` 步，直至 $i$ 和 $j$ 相遇時結束。
+
+=== "<1>"
+    ![最大容量問題的貪婪過程](max_capacity_problem.assets/max_capacity_greedy_step1.png){ class="animation-figure" }
+
+=== "<2>"
+    ![max_capacity_greedy_step2](max_capacity_problem.assets/max_capacity_greedy_step2.png){ class="animation-figure" }
+
+=== "<3>"
+    ![max_capacity_greedy_step3](max_capacity_problem.assets/max_capacity_greedy_step3.png){ class="animation-figure" }
+
+=== "<4>"
+    ![max_capacity_greedy_step4](max_capacity_problem.assets/max_capacity_greedy_step4.png){ class="animation-figure" }
+
+=== "<5>"
+    ![max_capacity_greedy_step5](max_capacity_problem.assets/max_capacity_greedy_step5.png){ class="animation-figure" }
+
+=== "<6>"
+    ![max_capacity_greedy_step6](max_capacity_problem.assets/max_capacity_greedy_step6.png){ class="animation-figure" }
+
+=== "<7>"
+    ![max_capacity_greedy_step7](max_capacity_problem.assets/max_capacity_greedy_step7.png){ class="animation-figure" }
+
+=== "<8>"
+    ![max_capacity_greedy_step8](max_capacity_problem.assets/max_capacity_greedy_step8.png){ class="animation-figure" }
+
+=== "<9>"
+    ![max_capacity_greedy_step9](max_capacity_problem.assets/max_capacity_greedy_step9.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-11 &nbsp; 最大容量問題的貪婪過程 </p>
+
+### 2. &nbsp; 程式碼實現
+
+程式碼迴圈最多 $n$ 輪，**因此時間複雜度為 $O(n)$** 。
+
+變數 $i$、$j$、$res$ 使用常數大小的額外空間，**因此空間複雜度為 $O(1)$** 。
+
+=== "Python"
+
+    ```python title="max_capacity.py"
+    def max_capacity(ht: list[int]) -> int:
+        """最大容量：貪婪"""
+        # 初始化 i, j，使其分列陣列兩端
+        i, j = 0, len(ht) - 1
+        # 初始最大容量為 0
+        res = 0
+        # 迴圈貪婪選擇，直至兩板相遇
+        while i < j:
+            # 更新最大容量
+            cap = min(ht[i], ht[j]) * (j - i)
+            res = max(res, cap)
+            # 向內移動短板
+            if ht[i] < ht[j]:
+                i += 1
+            else:
+                j -= 1
+        return res
+    ```
+
+=== "C++"
+
+    ```cpp title="max_capacity.cpp"
+    /* 最大容量：貪婪 */
+    int maxCapacity(vector<int> &ht) {
+        // 初始化 i, j，使其分列陣列兩端
+        int i = 0, j = ht.size() - 1;
+        // 初始最大容量為 0
+        int res = 0;
+        // 迴圈貪婪選擇，直至兩板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = min(ht[i], ht[j]) * (j - i);
+            res = max(res, cap);
+            // 向內移動短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="max_capacity.java"
+    /* 最大容量：貪婪 */
+    int maxCapacity(int[] ht) {
+        // 初始化 i, j，使其分列陣列兩端
+        int i = 0, j = ht.length - 1;
+        // 初始最大容量為 0
+        int res = 0;
+        // 迴圈貪婪選擇，直至兩板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向內移動短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="max_capacity.cs"
+    /* 最大容量：貪婪 */
+    int MaxCapacity(int[] ht) {
+        // 初始化 i, j，使其分列陣列兩端
+        int i = 0, j = ht.Length - 1;
+        // 初始最大容量為 0
+        int res = 0;
+        // 迴圈貪婪選擇，直至兩板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = Math.Min(ht[i], ht[j]) * (j - i);
+            res = Math.Max(res, cap);
+            // 向內移動短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="max_capacity.go"
+    /* 最大容量：貪婪 */
+    func maxCapacity(ht []int) int {
+        // 初始化 i, j，使其分列陣列兩端
+        i, j := 0, len(ht)-1
+        // 初始最大容量為 0
+        res := 0
+        // 迴圈貪婪選擇，直至兩板相遇
+        for i < j {
+            // 更新最大容量
+            capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)
+            res = int(math.Max(float64(res), float64(capacity)))
+            // 向內移動短板
+            if ht[i] < ht[j] {
+                i++
+            } else {
+                j--
+            }
+        }
+        return res
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="max_capacity.swift"
+    /* 最大容量：貪婪 */
+    func maxCapacity(ht: [Int]) -> Int {
+        // 初始化 i, j，使其分列陣列兩端
+        var i = ht.startIndex, j = ht.endIndex - 1
+        // 初始最大容量為 0
+        var res = 0
+        // 迴圈貪婪選擇，直至兩板相遇
+        while i < j {
+            // 更新最大容量
+            let cap = min(ht[i], ht[j]) * (j - i)
+            res = max(res, cap)
+            // 向內移動短板
+            if ht[i] < ht[j] {
+                i += 1
+            } else {
+                j -= 1
+            }
+        }
+        return res
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="max_capacity.js"
+    /* 最大容量：貪婪 */
+    function maxCapacity(ht) {
+        // 初始化 i, j，使其分列陣列兩端
+        let i = 0,
+            j = ht.length - 1;
+        // 初始最大容量為 0
+        let res = 0;
+        // 迴圈貪婪選擇，直至兩板相遇
+        while (i < j) {
+            // 更新最大容量
+            const cap = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向內移動短板
+            if (ht[i] < ht[j]) {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="max_capacity.ts"
+    /* 最大容量：貪婪 */
+    function maxCapacity(ht: number[]): number {
+        // 初始化 i, j，使其分列陣列兩端
+        let i = 0,
+            j = ht.length - 1;
+        // 初始最大容量為 0
+        let res = 0;
+        // 迴圈貪婪選擇，直至兩板相遇
+        while (i < j) {
+            // 更新最大容量
+            const cap: number = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向內移動短板
+            if (ht[i] < ht[j]) {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="max_capacity.dart"
+    /* 最大容量：貪婪 */
+    int maxCapacity(List<int> ht) {
+      // 初始化 i, j，使其分列陣列兩端
+      int i = 0, j = ht.length - 1;
+      // 初始最大容量為 0
+      int res = 0;
+      // 迴圈貪婪選擇，直至兩板相遇
+      while (i < j) {
+        // 更新最大容量
+        int cap = min(ht[i], ht[j]) * (j - i);
+        res = max(res, cap);
+        // 向內移動短板
+        if (ht[i] < ht[j]) {
+          i++;
+        } else {
+          j--;
+        }
+      }
+      return res;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="max_capacity.rs"
+    /* 最大容量：貪婪 */
+    fn max_capacity(ht: &[i32]) -> i32 {
+        // 初始化 i, j，使其分列陣列兩端
+        let mut i = 0;
+        let mut j = ht.len() - 1;
+        // 初始最大容量為 0
+        let mut res = 0;
+        // 迴圈貪婪選擇，直至兩板相遇
+        while i < j {
+            // 更新最大容量
+            let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;
+            res = std::cmp::max(res, cap);
+            // 向內移動短板
+            if ht[i] < ht[j] {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        res
+    }
+    ```
+
+=== "C"
+
+    ```c title="max_capacity.c"
+    /* 最大容量：貪婪 */
+    int maxCapacity(int ht[], int htLength) {
+        // 初始化 i, j，使其分列陣列兩端
+        int i = 0;
+        int j = htLength - 1;
+        // 初始最大容量為 0
+        int res = 0;
+        // 迴圈貪婪選擇，直至兩板相遇
+        while (i < j) {
+            // 更新最大容量
+            int capacity = myMin(ht[i], ht[j]) * (j - i);
+            res = myMax(res, capacity);
+            // 向內移動短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+    ```
+
+=== "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
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="max_capacity.rb"
+    [class]{}-[func]{max_capacity}
+    ```
+
+=== "Zig"
+
+    ```zig title="max_capacity.zig"
+    [class]{}-[func]{maxCapacity}
+    ```
+
+??? pythontutor "視覺化執行"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20max_capacity%28ht%3A%20list%5Bint%5D%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%20i,%20j%EF%BC%8C%E4%BD%BF%E5%85%B6%E5%88%86%E5%88%97%E6%95%B0%E7%BB%84%E4%B8%A4%E7%AB%AF%0A%20%20%20%20i,%20j%20%3D%200,%20len%28ht%29%20-%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%E4%B8%BA%200%0A%20%20%20%20res%20%3D%200%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E8%B4%AA%E5%BF%83%E9%80%89%E6%8B%A9%EF%BC%8C%E7%9B%B4%E8%87%B3%E4%B8%A4%E6%9D%BF%E7%9B%B8%E9%81%87%0A%20%20%20%20while%20i%20%3C%20j%3A%0A%20%20%20%20%20%20%20%20%23%20%E6%9B%B4%E6%96%B0%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%0A%20%20%20%20%20%20%20%20cap%20%3D%20min%28ht%5Bi%5D,%20ht%5Bj%5D%29%20*%20%28j%20-%20i%29%0A%20%20%20%20%20%20%20%20res%20%3D%20max%28res,%20cap%29%0A%20%20%20%20%20%20%20%20%23%20%E5%90%91%E5%86%85%E7%A7%BB%E5%8A%A8%E7%9F%AD%E6%9D%BF%0A%20%20%20%20%20%20%20%20if%20ht%5Bi%5D%20%3C%20ht%5Bj%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20-%3D%201%0A%20%20%20%20return%20res%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20ht%20%3D%20%5B3,%208,%205,%202,%207,%207,%203,%204%5D%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%0A%20%20%20%20res%20%3D%20max_capacity%28ht%29%0A%20%20%20%20print%28f%22%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%E4%B8%BA%20%7Bres%7D%22%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20max_capacity%28ht%3A%20list%5Bint%5D%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%20i,%20j%EF%BC%8C%E4%BD%BF%E5%85%B6%E5%88%86%E5%88%97%E6%95%B0%E7%BB%84%E4%B8%A4%E7%AB%AF%0A%20%20%20%20i,%20j%20%3D%200,%20len%28ht%29%20-%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%E4%B8%BA%200%0A%20%20%20%20res%20%3D%200%0A%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E8%B4%AA%E5%BF%83%E9%80%89%E6%8B%A9%EF%BC%8C%E7%9B%B4%E8%87%B3%E4%B8%A4%E6%9D%BF%E7%9B%B8%E9%81%87%0A%20%20%20%20while%20i%20%3C%20j%3A%0A%20%20%20%20%20%20%20%20%23%20%E6%9B%B4%E6%96%B0%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%0A%20%20%20%20%20%20%20%20cap%20%3D%20min%28ht%5Bi%5D,%20ht%5Bj%5D%29%20*%20%28j%20-%20i%29%0A%20%20%20%20%20%20%20%20res%20%3D%20max%28res,%20cap%29%0A%20%20%20%20%20%20%20%20%23%20%E5%90%91%E5%86%85%E7%A7%BB%E5%8A%A8%E7%9F%AD%E6%9D%BF%0A%20%20%20%20%20%20%20%20if%20ht%5Bi%5D%20%3C%20ht%5Bj%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20-%3D%201%0A%20%20%20%20return%20res%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20ht%20%3D%20%5B3,%208,%205,%202,%207,%207,%203,%204%5D%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%0A%20%20%20%20res%20%3D%20max_capacity%28ht%29%0A%20%20%20%20print%28f%22%E6%9C%80%E5%A4%A7%E5%AE%B9%E9%87%8F%E4%B8%BA%20%7Bres%7D%22%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">全螢幕觀看 ></a></div>
+
+### 3. &nbsp; 正確性證明
+
+之所以貪婪比窮舉更快，是因為每輪的貪婪選擇都會“跳過”一些狀態。
+
+比如在狀態 $cap[i, j]$ 下，$i$ 為短板、$j$ 為長板。若貪婪地將短板 $i$ 向內移動一格，會導致圖 15-12 所示的狀態被“跳過”。**這意味著之後無法驗證這些狀態的容量大小**。
+
+$$
+cap[i, i+1], cap[i, i+2], \dots, cap[i, j-2], cap[i, j-1]
+$$
+
+![移動短板導致被跳過的狀態](max_capacity_problem.assets/max_capacity_skipped_states.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-12 &nbsp; 移動短板導致被跳過的狀態 </p>
+
+觀察發現，**這些被跳過的狀態實際上就是將長板 $j$ 向內移動的所有狀態**。前面我們已經證明內移長板一定會導致容量變小。也就是說，被跳過的狀態都不可能是最優解，**跳過它們不會導致錯過最優解**。
+
+以上分析說明，移動短板的操作是“安全”的，貪婪策略是有效的。
@@ -0,0 +1,405 @@
+---
+comments: true
+---
+
+# 15.4 &nbsp; 最大切分乘積問題
+
+!!! question
+
+    給定一個正整數 $n$ ，將其切分為至少兩個正整數的和，求切分後所有整數的乘積最大是多少，如圖 15-13 所示。
+
+![最大切分乘積的問題定義](max_product_cutting_problem.assets/max_product_cutting_definition.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-13 &nbsp; 最大切分乘積的問題定義 </p>
+
+假設我們將 $n$ 切分為 $m$ 個整數因子，其中第 $i$ 個因子記為 $n_i$ ，即
+
+$$
+n = \sum_{i=1}^{m}n_i
+$$
+
+本題的目標是求得所有整數因子的最大乘積，即
+
+$$
+\max(\prod_{i=1}^{m}n_i)
+$$
+
+我們需要思考的是：切分數量 $m$ 應該多大，每個 $n_i$ 應該是多少？
+
+### 1. &nbsp; 貪婪策略確定
+
+根據經驗，兩個整數的乘積往往比它們的加和更大。假設從 $n$ 中分出一個因子 $2$ ，則它們的乘積為 $2(n-2)$ 。我們將該乘積與 $n$ 作比較：
+
+$$
+\begin{aligned}
+2(n-2) & \geq n \newline
+2n - n - 4 & \geq 0 \newline
+n & \geq 4
+\end{aligned}
+$$
+
+如圖 15-14 所示，當 $n \geq 4$ 時，切分出一個 $2$ 後乘積會變大，**這說明大於等於 $4$ 的整數都應該被切分**。
+
+**貪婪策略一**：如果切分方案中包含 $\geq 4$ 的因子，那麼它就應該被繼續切分。最終的切分方案只應出現 $1$、$2$、$3$ 這三種因子。
+
+![切分導致乘積變大](max_product_cutting_problem.assets/max_product_cutting_greedy_infer1.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-14 &nbsp; 切分導致乘積變大 </p>
+
+接下來思考哪個因子是最優的。在 $1$、$2$、$3$ 這三個因子中，顯然 $1$ 是最差的，因為 $1 \times (n-1) < n$ 恆成立，即切分出 $1$ 反而會導致乘積減小。
+
+如圖 15-15 所示，當 $n = 6$ 時，有 $3 \times 3 > 2 \times 2 \times 2$ 。**這意味著切分出 $3$ 比切分出 $2$ 更優**。
+
+**貪婪策略二**：在切分方案中，最多隻應存在兩個 $2$ 。因為三個 $2$ 總是可以替換為兩個 $3$ ，從而獲得更大的乘積。
+
+![最優切分因子](max_product_cutting_problem.assets/max_product_cutting_greedy_infer2.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-15 &nbsp; 最優切分因子 </p>
+
+綜上所述，可推理出以下貪婪策略。
+
+1. 輸入整數 $n$ ，從其不斷地切分出因子 $3$ ，直至餘數為 $0$、$1$、$2$ 。
+2. 當餘數為 $0$ 時，代表 $n$ 是 $3$ 的倍數，因此不做任何處理。
+3. 當餘數為 $2$ 時，不繼續劃分，保留。
+4. 當餘數為 $1$ 時，由於 $2 \times 2 > 1 \times 3$ ，因此應將最後一個 $3$ 替換為 $2$ 。
+
+### 2. &nbsp; 程式碼實現
+
+如圖 15-16 所示，我們無須透過迴圈來切分整數，而可以利用向下整除運算得到 $3$ 的個數 $a$ ，用取模運算得到餘數 $b$ ，此時有：
+
+$$
+n = 3 a + b
+$$
+
+請注意，對於 $n \leq 3$ 的邊界情況，必須拆分出一個 $1$ ，乘積為 $1 \times (n - 1)$ 。
+
+=== "Python"
+
+    ```python title="max_product_cutting.py"
+    def max_product_cutting(n: int) -> int:
+        """最大切分乘積：貪婪"""
+        # 當 n <= 3 時，必須切分出一個 1
+        if n <= 3:
+            return 1 * (n - 1)
+        # 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        a, b = n // 3, n % 3
+        if b == 1:
+            # 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return int(math.pow(3, a - 1)) * 2 * 2
+        if b == 2:
+            # 當餘數為 2 時，不做處理
+            return int(math.pow(3, a)) * 2
+        # 當餘數為 0 時，不做處理
+        return int(math.pow(3, a))
+    ```
+
+=== "C++"
+
+    ```cpp title="max_product_cutting.cpp"
+    /* 最大切分乘積：貪婪 */
+    int maxProductCutting(int n) {
+        // 當 n <= 3 時，必須切分出一個 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return (int)pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 當餘數為 2 時，不做處理
+            return (int)pow(3, a) * 2;
+        }
+        // 當餘數為 0 時，不做處理
+        return (int)pow(3, a);
+    }
+    ```
+
+=== "Java"
+
+    ```java title="max_product_cutting.java"
+    /* 最大切分乘積：貪婪 */
+    int maxProductCutting(int n) {
+        // 當 n <= 3 時，必須切分出一個 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return (int) Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 當餘數為 2 時，不做處理
+            return (int) Math.pow(3, a) * 2;
+        }
+        // 當餘數為 0 時，不做處理
+        return (int) Math.pow(3, a);
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="max_product_cutting.cs"
+    /* 最大切分乘積：貪婪 */
+    int MaxProductCutting(int n) {
+        // 當 n <= 3 時，必須切分出一個 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return (int)Math.Pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 當餘數為 2 時，不做處理
+            return (int)Math.Pow(3, a) * 2;
+        }
+        // 當餘數為 0 時，不做處理
+        return (int)Math.Pow(3, a);
+    }
+    ```
+
+=== "Go"
+
+    ```go title="max_product_cutting.go"
+    /* 最大切分乘積：貪婪 */
+    func maxProductCutting(n int) int {
+        // 當 n <= 3 時，必須切分出一個 1
+        if n <= 3 {
+            return 1 * (n - 1)
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        a := n / 3
+        b := n % 3
+        if b == 1 {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return int(math.Pow(3, float64(a-1))) * 2 * 2
+        }
+        if b == 2 {
+            // 當餘數為 2 時，不做處理
+            return int(math.Pow(3, float64(a))) * 2
+        }
+        // 當餘數為 0 時，不做處理
+        return int(math.Pow(3, float64(a)))
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="max_product_cutting.swift"
+    /* 最大切分乘積：貪婪 */
+    func maxProductCutting(n: Int) -> Int {
+        // 當 n <= 3 時，必須切分出一個 1
+        if n <= 3 {
+            return 1 * (n - 1)
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        let a = n / 3
+        let b = n % 3
+        if b == 1 {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return pow(3, a - 1) * 2 * 2
+        }
+        if b == 2 {
+            // 當餘數為 2 時，不做處理
+            return pow(3, a) * 2
+        }
+        // 當餘數為 0 時，不做處理
+        return pow(3, a)
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="max_product_cutting.js"
+    /* 最大切分乘積：貪婪 */
+    function maxProductCutting(n) {
+        // 當 n <= 3 時，必須切分出一個 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        let a = Math.floor(n / 3);
+        let b = n % 3;
+        if (b === 1) {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b === 2) {
+            // 當餘數為 2 時，不做處理
+            return Math.pow(3, a) * 2;
+        }
+        // 當餘數為 0 時，不做處理
+        return Math.pow(3, a);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="max_product_cutting.ts"
+    /* 最大切分乘積：貪婪 */
+    function maxProductCutting(n: number): number {
+        // 當 n <= 3 時，必須切分出一個 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        let a: number = Math.floor(n / 3);
+        let b: number = n % 3;
+        if (b === 1) {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b === 2) {
+            // 當餘數為 2 時，不做處理
+            return Math.pow(3, a) * 2;
+        }
+        // 當餘數為 0 時，不做處理
+        return Math.pow(3, a);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="max_product_cutting.dart"
+    /* 最大切分乘積：貪婪 */
+    int maxProductCutting(int n) {
+      // 當 n <= 3 時，必須切分出一個 1
+      if (n <= 3) {
+        return 1 * (n - 1);
+      }
+      // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+      int a = n ~/ 3;
+      int b = n % 3;
+      if (b == 1) {
+        // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+        return (pow(3, a - 1) * 2 * 2).toInt();
+      }
+      if (b == 2) {
+        // 當餘數為 2 時，不做處理
+        return (pow(3, a) * 2).toInt();
+      }
+      // 當餘數為 0 時，不做處理
+      return pow(3, a).toInt();
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="max_product_cutting.rs"
+    /* 最大切分乘積：貪婪 */
+    fn max_product_cutting(n: i32) -> i32 {
+        // 當 n <= 3 時，必須切分出一個 1
+        if n <= 3 {
+            return 1 * (n - 1);
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        let a = n / 3;
+        let b = n % 3;
+        if b == 1 {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            3_i32.pow(a as u32 - 1) * 2 * 2
+        } else if b == 2 {
+            // 當餘數為 2 時，不做處理
+            3_i32.pow(a as u32) * 2
+        } else {
+            // 當餘數為 0 時，不做處理
+            3_i32.pow(a as u32)
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title="max_product_cutting.c"
+    /* 最大切分乘積：貪婪 */
+    int maxProductCutting(int n) {
+        // 當 n <= 3 時，必須切分出一個 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+            return pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 當餘數為 2 時，不做處理
+            return pow(3, a) * 2;
+        }
+        // 當餘數為 0 時，不做處理
+        return pow(3, a);
+    }
+    ```
+
+=== "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()
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="max_product_cutting.rb"
+    [class]{}-[func]{max_product_cutting}
+    ```
+
+=== "Zig"
+
+    ```zig title="max_product_cutting.zig"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+??? pythontutor "視覺化執行"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=import%20math%0A%0Adef%20max_product_cutting%28n%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E6%9C%80%E5%A4%A7%E5%88%87%E5%88%86%E4%B9%98%E7%A7%AF%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%BD%93%20n%20%3C%3D%203%20%E6%97%B6%EF%BC%8C%E5%BF%85%E9%A1%BB%E5%88%87%E5%88%86%E5%87%BA%E4%B8%80%E4%B8%AA%201%0A%20%20%20%20if%20n%20%3C%3D%203%3A%0A%20%20%20%20%20%20%20%20return%201%20*%20%28n%20-%201%29%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E5%9C%B0%E5%88%87%E5%88%86%E5%87%BA%203%20%EF%BC%8Ca%20%E4%B8%BA%203%20%E7%9A%84%E4%B8%AA%E6%95%B0%EF%BC%8Cb%20%E4%B8%BA%E4%BD%99%E6%95%B0%0A%20%20%20%20a,%20b%20%3D%20n%20//%203,%20n%20%25%203%0A%20%20%20%20if%20b%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20%23%20%E5%BD%93%E4%BD%99%E6%95%B0%E4%B8%BA%201%20%E6%97%B6%EF%BC%8C%E5%B0%86%E4%B8%80%E5%AF%B9%201%20*%203%20%E8%BD%AC%E5%8C%96%E4%B8%BA%202%20*%202%0A%20%20%20%20%20%20%20%20return%20int%28math.pow%283,%20a%20-%201%29%29%20*%202%20*%202%0A%20%20%20%20if%20b%20%3D%3D%202%3A%0A%20%20%20%20%20%20%20%20%23%20%E5%BD%93%E4%BD%99%E6%95%B0%E4%B8%BA%202%20%E6%97%B6%EF%BC%8C%E4%B8%8D%E5%81%9A%E5%A4%84%E7%90%86%0A%20%20%20%20%20%20%20%20return%20int%28math.pow%283,%20a%29%29%20*%202%0A%20%20%20%20%23%20%E5%BD%93%E4%BD%99%E6%95%B0%E4%B8%BA%200%20%E6%97%B6%EF%BC%8C%E4%B8%8D%E5%81%9A%E5%A4%84%E7%90%86%0A%20%20%20%20return%20int%28math.pow%283,%20a%29%29%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%2058%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%0A%20%20%20%20res%20%3D%20max_product_cutting%28n%29%0A%20%20%20%20print%28f%22%E6%9C%80%E5%A4%A7%E5%88%87%E5%88%86%E4%B9%98%E7%A7%AF%E4%B8%BA%20%7Bres%7D%22%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=import%20math%0A%0Adef%20max_product_cutting%28n%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%E6%9C%80%E5%A4%A7%E5%88%87%E5%88%86%E4%B9%98%E7%A7%AF%EF%BC%9A%E8%B4%AA%E5%BF%83%22%22%22%0A%20%20%20%20%23%20%E5%BD%93%20n%20%3C%3D%203%20%E6%97%B6%EF%BC%8C%E5%BF%85%E9%A1%BB%E5%88%87%E5%88%86%E5%87%BA%E4%B8%80%E4%B8%AA%201%0A%20%20%20%20if%20n%20%3C%3D%203%3A%0A%20%20%20%20%20%20%20%20return%201%20*%20%28n%20-%201%29%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E5%9C%B0%E5%88%87%E5%88%86%E5%87%BA%203%20%EF%BC%8Ca%20%E4%B8%BA%203%20%E7%9A%84%E4%B8%AA%E6%95%B0%EF%BC%8Cb%20%E4%B8%BA%E4%BD%99%E6%95%B0%0A%20%20%20%20a,%20b%20%3D%20n%20//%203,%20n%20%25%203%0A%20%20%20%20if%20b%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20%23%20%E5%BD%93%E4%BD%99%E6%95%B0%E4%B8%BA%201%20%E6%97%B6%EF%BC%8C%E5%B0%86%E4%B8%80%E5%AF%B9%201%20*%203%20%E8%BD%AC%E5%8C%96%E4%B8%BA%202%20*%202%0A%20%20%20%20%20%20%20%20return%20int%28math.pow%283,%20a%20-%201%29%29%20*%202%20*%202%0A%20%20%20%20if%20b%20%3D%3D%202%3A%0A%20%20%20%20%20%20%20%20%23%20%E5%BD%93%E4%BD%99%E6%95%B0%E4%B8%BA%202%20%E6%97%B6%EF%BC%8C%E4%B8%8D%E5%81%9A%E5%A4%84%E7%90%86%0A%20%20%20%20%20%20%20%20return%20int%28math.pow%283,%20a%29%29%20*%202%0A%20%20%20%20%23%20%E5%BD%93%E4%BD%99%E6%95%B0%E4%B8%BA%200%20%E6%97%B6%EF%BC%8C%E4%B8%8D%E5%81%9A%E5%A4%84%E7%90%86%0A%20%20%20%20return%20int%28math.pow%283,%20a%29%29%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%2058%0A%0A%20%20%20%20%23%20%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%0A%20%20%20%20res%20%3D%20max_product_cutting%28n%29%0A%20%20%20%20print%28f%22%E6%9C%80%E5%A4%A7%E5%88%87%E5%88%86%E4%B9%98%E7%A7%AF%E4%B8%BA%20%7Bres%7D%22%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">全螢幕觀看 ></a></div>
+
+![最大切分乘積的計算方法](max_product_cutting_problem.assets/max_product_cutting_greedy_calculation.png){ class="animation-figure" }
+
+<p align="center"> 圖 15-16 &nbsp; 最大切分乘積的計算方法 </p>
+
+**時間複雜度取決於程式語言的冪運算的實現方法**。以 Python 為例，常用的冪計算函式有三種。
+
+- 運算子 `**` 和函式 `pow()` 的時間複雜度均為 $O(\log⁡ a)$ 。
+- 函式 `math.pow()` 內部呼叫 C 語言庫的 `pow()` 函式，其執行浮點取冪，時間複雜度為 $O(1)$ 。
+
+變數 $a$ 和 $b$ 使用常數大小的額外空間，**因此空間複雜度為 $O(1)$** 。
+
+### 3. &nbsp; 正確性證明
+
+使用反證法，只分析 $n \geq 3$ 的情況。
+
+1. **所有因子 $\leq 3$** ：假設最優切分方案中存在 $\geq 4$ 的因子 $x$ ，那麼一定可以將其繼續劃分為 $2(x-2)$ ，從而獲得更大的乘積。這與假設矛盾。
+2. **切分方案不包含 $1$** ：假設最優切分方案中存在一個因子 $1$ ，那麼它一定可以合併入另外一個因子中，以獲得更大的乘積。這與假設矛盾。
+3. **切分方案最多包含兩個 $2$** ：假設最優切分方案中包含三個 $2$ ，那麼一定可以替換為兩個 $3$ ，乘積更大。這與假設矛盾。
@@ -0,0 +1,16 @@
+---
+comments: true
+---
+
+# 15.5 &nbsp; 小結
+
+- 貪婪演算法通常用於解決最最佳化問題，其原理是在每個決策階段都做出區域性最優的決策，以期獲得全域性最優解。
+- 貪婪演算法會迭代地做出一個又一個的貪婪選擇，每輪都將問題轉化成一個規模更小的子問題，直到問題被解決。
+- 貪婪演算法不僅實現簡單，還具有很高的解題效率。相比於動態規劃，貪婪演算法的時間複雜度通常更低。
+- 在零錢兌換問題中，對於某些硬幣組合，貪婪演算法可以保證找到最優解；對於另外一些硬幣組合則不然，貪婪演算法可能找到很差的解。
+- 適合用貪婪演算法求解的問題具有兩大性質：貪婪選擇性質和最優子結構。貪婪選擇性質代表貪婪策略的有效性。
+- 對於某些複雜問題，貪婪選擇性質的證明並不簡單。相對來說，證偽更加容易，例如零錢兌換問題。
+- 求解貪婪問題主要分為三步：問題分析、確定貪婪策略、正確性證明。其中，確定貪婪策略是核心步驟，正確性證明往往是難點。
+- 分數背包問題在 0-1 背包的基礎上，允許選擇物品的一部分，因此可使用貪婪演算法求解。貪婪策略的正確性可以使用反證法來證明。
+- 最大容量問題可使用窮舉法求解，時間複雜度為 $O(n^2)$ 。透過設計貪婪策略，每輪向內移動短板，可將時間複雜度最佳化至 $O(n)$ 。
+- 在最大切分乘積問題中，我們先後推理出兩個貪婪策略：$\geq 4$ 的整數都應該繼續切分，最優切分因子為 $3$ 。程式碼中包含冪運算，時間複雜度取決於冪運算實現方法，通常為 $O(1)$ 或 $O(\log n)$ 。