Fig. 分数背包问题的示例数据
+ +**第一步：问题分析** + +本题和 0-1 背包整体上非常相似，状态包含当前物品 $i$ 和容量 $c$ ，目标是求不超过背包容量下的最大价值。 + +不同点在于，本题允许只选择物品的一部分，我们可以对物品任意地进行切分，并按照重量比例来计算物品价值，因此有： + +1. 对于物品 $i$ ，它在单位重量下的价值为 $val[i-1] / wgt[i-1]$ ，简称为单位价值； +2. 假设放入一部分物品 $i$ ，重量为 $w$ ，则背包增加的价值为 $w \times val[i-1] / wgt[i-1]$ ； + + + +Fig. 物品在单位重量下的价值
+ +**第二步：贪心策略确定** + +最大化背包内物品总价值，**本质上是要最大化单位重量下的物品价值**。由此便可推出本题的贪心策略： + +1. 将物品按照单位价值从高到低进行排序。 +2. 遍历所有物品，**每轮贪心地选择单位价值最高的物品**。 +3. 若剩余背包容量不足，则使用当前物品的一部分填满背包即可。 + + + +Fig. 分数背包的贪心策略
+ +**第三步：正确性证明** + +采用反证法。假设物品 $x$ 是单位价值最高的物品，使用某算法求得最大价值为 $res$ ，但该解中不包含物品 $x$ 。 + +现在从背包中拿出单位重量的任意物品，并替换为单位重量的物品 $x$ 。由于物品 $x$ 的单位价值最高，因此替换后的总价值一定大于 $res$ 。**这与 $res$ 是最优解矛盾，说明最优解中必须包含物品 $x$ 。** + +对于该解中的其他物品，我们也可以构建出上述矛盾。总而言之，**单位价值更大的物品总是更优选择**，这说明贪心策略是有效的。 + +**实现代码** + +我们构建了一个物品类 `Item` ，以便将物品按照单位价值进行排序。在循环贪心选择中，分为放入整个物品或放入部分物品两种情况。当背包已满时，则跳出循环并返回解。 + +=== "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++" + + ```cpp title="fractional_knapsack.cpp" + /* 物品 */ + class Item { + public: + int w; // 物品重量 + int v; // 物品价值 + + Item(int w, int v) : w(w), v(v) { + } + }; + + /* 分数背包：贪心 */ + double fractionalKnapsack(vectorFig. 分数背包问题的几何表示
+ +最差情况下，需要遍历整个物品列表，**因此时间复杂度为 $O(n)$** ，其中 $n$ 为物品数量。由于初始化了一个 `Item` 对象列表，**因此空间复杂度为 $O(n)$** 。 diff --git a/chapter_greedy/greedy_algorithm.md b/chapter_greedy/greedy_algorithm.md new file mode 100644 index 000000000..2fa5d90b4 --- /dev/null +++ b/chapter_greedy/greedy_algorithm.md @@ -0,0 +1,209 @@ +--- +comments: true +status: new +--- + +# 15.1. 贪心算法 + +贪心算法是一种常见的解决优化问题的算法，其基本思想是在问题的每个决策阶段，都选择当前看起来最优的选择，即“贪心”地做出局部最优的决策，以期望获得全局最优解。贪心算法因其简洁、高效的特性，在许多实际问题中都有着广泛的应用。 + +贪心算法和动态规划都是解决优化问题的常用策略，它们有一些相似之处，比如都依赖最优子结构性质。两者的不同点在于： + +- **动态规划会根据之前阶段的所有决策来考虑当前决策**，并使用过去子问题的解来构建当前子问题的解。 +- **贪心算法从不重新考虑过去的决策**，而是一路向前地进行贪心选择，不断缩小问题范围，直至问题被解决。 + +我们先通过例题“零钱兑换”来初步了解贪心算法的工作原理。这道题已经在动态规划章节中介绍过，相信你对它并不陌生。 + +!!! question + + 给定 $n$ 种硬币，第 $i$ 个硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，**每种硬币可以重复选取**，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 $-1$ 。 + +贪心算法会迭代地做出一个又一个的贪心选择，每轮都将问题转化成一个规模更小的子问题，直到问题被解决。 + +这道题的贪心策略在生活中很常见：给定目标金额，**我们贪心地选择不大于且最接近它的硬币**，不断循环该步骤，直至凑出目标金额为止。 + + + +Fig. 零钱兑换的贪心策略
+ +实现代码如下所示。你可能会不由地发出感叹：So Clean ！因为贪心算法仅用十行代码就解决了零钱兑换问题。 + +=== "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 (coins[i] > amt) { + i--; + } + // 选择 coins[i] + amt -= coins[i]; + count++; + } + // 若未找到可行方案，则返回 -1 + return amt == 0 ? count : -1; + } + ``` + +=== "C++" + + ```cpp title="coin_change_greedy.cpp" + /* 零钱兑换：贪心 */ + int coinChangeGreedy(vectorFig. 贪心无法找出最优解的示例
+ +也就是说，对于零钱兑换问题，贪心算法无法保证找到全局最优解，并且有可能找到非常差的解，因此该问题更适合用动态规划解决。 + +一般情况下，贪心算法适用于以下两种问题： + +1. **可以保证找到最优解**：贪心算法在这种情况下往往是最优选择，因为它往往比回溯、动态规划更高效。 +2. **可以找到近似最优解**：此时贪心算法也是可用的。因为对于很多复杂问题来说，寻找最优解是非常困难的，能以较高效率找到次优解也是非常不错的。 + +## 15.1.2. 贪心算法特性 + +那么问题来了，什么样的问题适合用贪心算法求解呢？或者说，贪心算法在什么情况下可以保证找到最优解？ + +相较于动态规划，贪心算法的使用条件更加苛刻，其主要关心问题的两个性质： + +- **贪心选择性质**：只有当局部最优选择始终可以导致全局最优解时，贪心算法才能保证得到最优解。 +- **最优子结构**：原问题的最优解包含子问题的最优解。值得注意的是，一些问题的最优子结构并不明显，但仍然可使用贪心算法解决。 + +最优子结构已经在动态规划章节中介绍过，不再赘述，我们主要探究如何判断问题的贪心选择性质。虽然贪心选择性质的描述看上去比较简单，**但实际上对于许多问题，证明贪心选择性质不是一件易事**。 + +例如零钱兑换问题，我们虽然能够容易地举出反例，对贪心选择性质进行证伪。但如果问：**满足什么条件的硬币组合可以使用贪心算法求解**？我们往往只能凭借直觉或穷举例子来给出一个模棱两可的答案，而难以给出严谨的数学证明。 + +!!! quote + + 一篇论文 Pearson, David. "A polynomial-time algorithm for the change-making problem." *Operations Research Letters* 33.3 (2005): 231-234. 专门讨论了该问题。作者给出了一个 $O(n^3)$ 时间复杂度的算法，用于判断一个硬币组合是否可以使用贪心算法找出任何金额的最优解。 + +## 15.1.3. 贪心解题步骤 + +贪心问题的解决流程大体可分为三步： + +1. **问题分析**：梳理与理解问题特性，包括状态定义、优化目标和约束条件等。这一步在回溯和动态规划中都有涉及。 +2. **确定贪心策略**：确定如何在每一步中做出贪心选择。这个策略能够在每一步减小问题的规模，并最终能解决整个问题。 +3. **正确性证明**：通常需要证明问题具有贪心选择性质和最优子结构。这个步骤可能需要使用到数学证明，例如归纳法或反证法等。 + +确定贪心策略是求解问题的核心步骤，但实施起来并没有那么容易。主要有两方面原因： + +1. **不同问题的贪心策略的差异较大**。对于许多问题来说，贪心策略都比较浅显，我们通过一些大概的思考与尝试就能得出。而对于一些复杂问题，贪心策略可能非常隐蔽，这种情况就非常考验个人的解题经验与算法能力了。 +2. **某些贪心策略具有较强的迷惑性**。当我们满怀信心设计好贪心策略，写出解题代码并提交运行，很可能发现部分测试样例无法通过。这是因为设计的贪心策略只是“部分正确”的，上文介绍的零钱兑换就是个很好的例子。 + +为了保证正确性，我们应该对贪心策略进行严谨的数学证明，**通常需要用到反证法或数学归纳法**。 + +然而，正确性证明往往也不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行 Debug ，一步步修改与验证贪心策略。 + +## 15.1.4. 贪心典型例题 + +贪心算法常常应用在满足贪心选择性质和最优子结构的优化问题中，以下是一些典型的贪心算法问题： + +1. **硬币找零问题**：在某些硬币组合下，贪心算法总是可以得到最优解。 +2. **区间调度问题**：假设你有一些任务，每个任务在一段时间内进行，你的目标是完成尽可能多的任务。如果每次都选择结束时间最早的任务，那么贪心算法就可以得到最优解。 +3. **分数背包问题**：给定一组物品和一个载重量，你的目标是选择一组物品，使得总重量不超过载重量，且总价值最大。如果每次都选择性价比最高（价值/重量）的物品，那么贪心算法在一些情况下可以得到最优解。 +4. **股票买卖问题**：给定一组股票的历史价格，你可以进行多次买卖，但不能同时参与多次交易，这意味着如果你已经持有股票，那么在卖出之前不能再买，你的目标是获取最大利润。这类问题通常可以使用贪心算法解决。 +5. **霍夫曼编码**：霍夫曼编码是一种用于无损数据压缩的贪心算法。通过构建霍夫曼树，每次选择出现频率最小的两个节点合并，最后得到的霍夫曼树的带权路径长度（即编码长度）最小。 +6. **Dijkstra 算法**：它是一种解决给定源顶点到其余各顶点的最短路径问题的贪心算法。 diff --git a/chapter_greedy/index.md b/chapter_greedy/index.md new file mode 100644 index 000000000..78300d396 --- /dev/null +++ b/chapter_greedy/index.md @@ -0,0 +1,18 @@ +--- +comments: true +icon: material/head-heart-outline +status: new +--- + +# 15. 贪心 + +