build

chapter_greedy/fractional_knapsack_problem.md

@@ -15,7 +15,7 @@ status: new
 
 <p align="center"> Fig. 分数背包问题的示例数据 </p>
 
-**第一步：问题分析**
+### 第一步：问题分析
 
 本题和 0-1 背包整体上非常相似，状态包含当前物品 $i$ 和容量 $c$ ，目标是求不超过背包容量下的最大价值。
 
@@ -28,7 +28,7 @@ status: new
 
 <p align="center"> Fig. 物品在单位重量下的价值 </p>
 
-**第二步：贪心策略确定**
+### 第二步：贪心策略确定
 
 最大化背包内物品总价值，**本质上是要最大化单位重量下的物品价值**。由此便可推出本题的贪心策略：
 
@@ -40,6 +40,8 @@ status: new
 
 <p align="center"> Fig. 分数背包的贪心策略 </p>
 
+### 代码实现
+
 我们构建了一个物品类 `Item` ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解。
 
 === "Java"
@@ -220,7 +222,7 @@ status: new
 
 最差情况下，需要遍历整个物品列表，**因此时间复杂度为 $O(n)$** ，其中 $n$ 为物品数量。由于初始化了一个 `Item` 对象列表，**因此空间复杂度为 $O(n)$** 。
 
-**第三步：正确性证明**
+### 第三步：正确性证明
 
 采用反证法。假设物品 $x$ 是单位价值最高的物品，使用某算法求得最大价值为 $res$ ，但该解中不包含物品 $x$ 。
 

chapter_greedy/index.md

@@ -17,3 +17,4 @@ status: new
 - [15.1   贪心算法](https://www.hello-algo.com/chapter_greedy/greedy_algorithm/)
 - [15.2   分数背包问题](https://www.hello-algo.com/chapter_greedy/fractional_knapsack_problem/)
 - [15.3   最大容量问题](https://www.hello-algo.com/chapter_greedy/max_capacity_problem/)
+- [15.4   最大切分乘积问题](https://www.hello-algo.com/chapter_greedy/max_product_cutting_problem/)

chapter_greedy/max_capacity_problem.md

@@ -15,7 +15,7 @@ status: new
 
 <p align="center"> Fig. 最大容量问题的示例数据 </p>
 
-**第一步：问题分析**
+### 第一步：问题分析
 
 容器由任意两个隔板围成，**因此本题的状态为两个隔板的索引，记为 $[i, j]$** 。
 
@@ -27,7 +27,7 @@ $$
 
 设数组长度为 $n$ ，两个隔板的组合数量（即状态总数）为 $C_n^2 = \frac{n(n - 1)}{2}$ 个。最直接地，**我们可以穷举所有状态**，从而求得最大容量，时间复杂度为 $O(n^2)$ 。
 
-**第二步：贪心策略确定**
+### 第二步：贪心策略确定
 
 当然，这道题还有更高效率的解法。如下图所示，现选取一个状态 $[i, j]$ ，其满足索引 $i < j$ 且高度 $ht[i] < ht[j]$ ，即 $i$ 为短板、 $j$ 为长板。
 
@@ -84,7 +84,9 @@ $$
 === "<9>"
     ![max_capacity_greedy_step9](max_capacity_problem.assets/max_capacity_greedy_step9.png)
 
-代码实现如下所示。最多循环 $n$ 轮，**因此时间复杂度为 $O(n)$** 。变量 $i$ , $j$ , $res$ 使用常数大小额外空间，**因此空间复杂度为 $O(1)$** 。
+### 代码实现
+
+如下代码所示，循环最多 $n$ 轮，**因此时间复杂度为 $O(n)$** 。变量 $i$ , $j$ , $res$ 使用常数大小额外空间，**因此空间复杂度为 $O(1)$** 。
 
 === "Java"
 
@@ -206,7 +208,7 @@ $$
     [class]{}-[func]{maxCapacity}
     ```
 
-**第三步：正确性证明**
+### 第三步：正确性证明
 
 之所以贪心比穷举更快，是因为每轮的贪心选择都会“跳过”一些状态。
 

chapter_greedy/max_product_cutting_problem.md

@@ -0,0 +1,214 @@
+---
+comments: true
+status: new
+---
+
+# 15.4.   最大切分乘积问题
+
+!!! question
+
+    给定一个正整数 $n$ ，将其切分为至少两个正整数的和，求切分后所有整数的乘积最大是多少。
+
+### 第一步：问题分析
+
+![最大切分乘积的问题定义](max_product_cutting_problem.assets/max_product_cutting_definition.png)
+
+<p align="center"> Fig. 最大切分乘积的问题定义 </p>
+
+假设我们将 $n$ 切分为 $m$ 个整数因子，其中第 $i$ 个因子记为 $n_i$ ，即
+
+$$
+n = \sum_{i=1}^{m}n_i
+$$
+
+本题目标是求得所有整数因子的最大乘积，即
+
+$$
+\max(\prod_{i=1}^{m}n_i)
+$$
+
+我们需要思考的是：切分数量 $m$ 应该多大，每个 $n_i$ 应该是多少？
+
+### 第二步：贪心策略确定
+
+根据经验，两个整数的和往往比它们的积更小。假设从 $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}
+$$
+
+当 $n \geq 4$ 时，切分出一个 $2$ 后乘积会变大，这说明大于等于 $4$ 的整数都应该被切分。
+
+**贪心策略一**：如果切分方案中包含 $\geq 4$ 的因子，那么它就应该被继续切分。最终的切分方案只应出现 $1$ , $2$ , $3$ 这三种因子。
+
+![切分导致乘积变大](max_product_cutting_problem.assets/max_product_cutting_greedy_infer1.png)
+
+<p align="center"> Fig. 切分导致乘积变大 </p>
+
+接下来思考哪个因子是最优的。在 $1$ , $2$ , $3$ 这三个因子中，显然 $1$ 是最差的，因为 $1 \times (n-1) < n$ 恒成立，切分出 $1$ 会导致乘积减小。
+
+我们发现，当 $n = 6$ 时，有 $3 \times 3 > 2 \times 2 \times 2$ 。**这意味着切分出 $3$ 比切分出 $2$ 更优**。
+
+**贪心策略二**：在切分方案中，最多只应存在两个 $2$ 。因为三个 $2$ 可以被替换为两个 $3$ ，从而获得更大的乘积。
+
+![最优切分因子](max_product_cutting_problem.assets/max_product_cutting_greedy_infer3.png)
+
+<p align="center"> Fig. 最优切分因子 </p>
+
+总结以上，可推出贪心策略：
+
+1. 输入整数 $n$ ，从其不断地切分出因子 $3$ ，直至余数为 $0$ , $1$ , $2$ 。
+2. 当余数为 $0$ 时，代表 $n$ 是 $3$ 的倍数，因此不做任何处理。
+3. 当余数为 $2$ 时，不继续划分，保留之。
+4. 当余数为 $1$ 时，由于 $2 \times 2 > 1 \times 3$ ，因此应将最后一个 $3$ 替换为 $2$ 。
+
+### 代码实现
+
+在代码中，我们无需开启循环来切分，可以直接利用向下整除得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，即：
+
+$$
+n = 3 a + b
+$$
+
+需要单独处理边界情况：当 $n \leq 3$ 时，必须拆分出一个 $1$ ，乘积为 $1 \times (n - 1)$ 。
+
+=== "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++"
+
+    ```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);
+    }
+    ```
+
+=== "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))
+    ```
+
+=== "Go"
+
+    ```go title="max_product_cutting.go"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="max_product_cutting.js"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="max_product_cutting.ts"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+=== "C"
+
+    ```c title="max_product_cutting.c"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+=== "C#"
+
+    ```csharp title="max_product_cutting.cs"
+    [class]{max_product_cutting}-[func]{maxProductCutting}
+    ```
+
+=== "Swift"
+
+    ```swift title="max_product_cutting.swift"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+=== "Zig"
+
+    ```zig title="max_product_cutting.zig"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+=== "Dart"
+
+    ```dart title="max_product_cutting.dart"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+![最大切分乘积的计算方法](max_product_cutting_problem.assets/max_product_cutting_greedy_calculation.png)
+
+<p align="center"> Fig. 最大切分乘积的计算方法 </p>
+
+**时间复杂度取决于编程语言的幂运算的实现方法**。以 Python 为例，常用的幂计算函数有三种：
+
+- 运算符 `**` 和函数 `pow()` 的时间复杂度均为 $O(\log⁡ a)$ ；
+- 函数 `math.pow()` 内部调用 C 语言库的 `pow()` 函数，其执行浮点取幂，时间复杂度为 $O(1)$ 。
+
+变量 $a$ , $b$ 使用常数大小的额外空间，**因此空间复杂度为 $O(1)$** 。
+
+### 第三步：正确性证明
+
+使用反证法，只分析 $n \geq 3$ 的情况。
+
+1. **所有因子 $\leq 3$** :假设最优切分方案中存在 $\geq 4$ 的因子 $x$ ，那么一定可以将其继续划分为 $2(x-2)$ ，从而获得更大的乘积。这与假设矛盾。
+2. **切分方案不包含 $1$** :假设最优切分方案中存在一个因子 $1$ ，那么它一定可以合并入另外一个因子中，以获取更大乘积。这与假设矛盾。
+3. **切分方案最多包含两个 $2$** ：假设最优切分方案中包含三个 $2$ ，那么一定可以替换为两个 $3$ ，乘积更大。这与假设矛盾。