deploy

chapter_greedy/fractional_knapsack_problem/index.html

@@ -3398,32 +3398,32 @@
 <h1 id="152">15.2 &nbsp; 分数背包问题<a class="headerlink" href="#152" title="Permanent link">&para;</a></h1>
 <div class="admonition question">
 <p class="admonition-title">Question</p>
-<p>给定 <span class="arithmatex">\(n\)</span> 个物品，第 <span class="arithmatex">\(i\)</span> 个物品的重量为 <span class="arithmatex">\(wgt[i-1]\)</span>、价值为 <span class="arithmatex">\(val[i-1]\)</span> ，和一个容量为 <span class="arithmatex">\(cap\)</span> 的背包。每个物品只能选择一次，<strong>但可以选择物品的一部分，价值根据选择的重量比例计算</strong>，问在不超过背包容量下背包中物品的最大价值。</p>
+<p>给定 <span class="arithmatex">\(n\)</span> 个物品，第 <span class="arithmatex">\(i\)</span> 个物品的重量为 <span class="arithmatex">\(wgt[i-1]\)</span>、价值为 <span class="arithmatex">\(val[i-1]\)</span> ，和一个容量为 <span class="arithmatex">\(cap\)</span> 的背包。每个物品只能选择一次，<strong>但可以选择物品的一部分，价值根据选择的重量比例计算</strong>，问在限定背包容量下背包中物品的最大价值。示例如图 15-3 所示。</p>
 </div>
 <p><a class="glightbox" href="../fractional_knapsack_problem.assets/fractional_knapsack_example.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="分数背包问题的示例数据" class="animation-figure" src="../fractional_knapsack_problem.assets/fractional_knapsack_example.png" /></a></p>
 <p align="center"> 图 15-3 &nbsp; 分数背包问题的示例数据 </p>
 
-<p>分数背包和 0-1 背包整体上非常相似，状态包含当前物品 <span class="arithmatex">\(i\)</span> 和容量 <span class="arithmatex">\(c\)</span> ，目标是求不超过背包容量下的最大价值。</p>
-<p>不同点在于，本题允许只选择物品的一部分。如图 15-4 所示，<strong>我们可以对物品任意地进行切分，并按照重量比例来计算物品价值</strong>。</p>
+<p>分数背包问题和 0-1 背包问题整体上非常相似，状态包含当前物品 <span class="arithmatex">\(i\)</span> 和容量 <span class="arithmatex">\(c\)</span> ，目标是求限定背包容量下的最大价值。</p>
+<p>不同点在于，本题允许只选择物品的一部分。如图 15-4 所示，<strong>我们可以对物品任意地进行切分，并按照重量比例来计算相应价值</strong>。</p>
 <ol>
-<li>对于物品 <span class="arithmatex">\(i\)</span> ，它在单位重量下的价值为 <span class="arithmatex">\(val[i-1] / wgt[i-1]\)</span> ，简称为单位价值。</li>
+<li>对于物品 <span class="arithmatex">\(i\)</span> ，它在单位重量下的价值为 <span class="arithmatex">\(val[i-1] / wgt[i-1]\)</span> ，简称单位价值。</li>
 <li>假设放入一部分物品 <span class="arithmatex">\(i\)</span> ，重量为 <span class="arithmatex">\(w\)</span> ，则背包增加的价值为 <span class="arithmatex">\(w \times val[i-1] / wgt[i-1]\)</span> 。</li>
 </ol>
 <p><a class="glightbox" href="../fractional_knapsack_problem.assets/fractional_knapsack_unit_value.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="物品在单位重量下的价值" class="animation-figure" src="../fractional_knapsack_problem.assets/fractional_knapsack_unit_value.png" /></a></p>
 <p align="center"> 图 15-4 &nbsp; 物品在单位重量下的价值 </p>
 
 <h3 id="1">1. &nbsp; 贪心策略确定<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
-<p>最大化背包内物品总价值，<strong>本质上是要最大化单位重量下的物品价值</strong>。由此便可推出图 15-5 所示的贪心策略。</p>
+<p>最大化背包内物品总价值，<strong>本质上是最大化单位重量下的物品价值</strong>。由此便可推理出图 15-5 所示的贪心策略。</p>
 <ol>
 <li>将物品按照单位价值从高到低进行排序。</li>
 <li>遍历所有物品，<strong>每轮贪心地选择单位价值最高的物品</strong>。</li>
-<li>若剩余背包容量不足，则使用当前物品的一部分填满背包即可。</li>
+<li>若剩余背包容量不足，则使用当前物品的一部分填满背包。</li>
 </ol>
-<p><a class="glightbox" href="../fractional_knapsack_problem.assets/fractional_knapsack_greedy_strategy.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="分数背包的贪心策略" class="animation-figure" src="../fractional_knapsack_problem.assets/fractional_knapsack_greedy_strategy.png" /></a></p>
-<p align="center"> 图 15-5 &nbsp; 分数背包的贪心策略 </p>
+<p><a class="glightbox" href="../fractional_knapsack_problem.assets/fractional_knapsack_greedy_strategy.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="分数背包问题的贪心策略" class="animation-figure" src="../fractional_knapsack_problem.assets/fractional_knapsack_greedy_strategy.png" /></a></p>
+<p align="center"> 图 15-5 &nbsp; 分数背包问题的贪心策略 </p>
 
 <h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
-<p>我们建立了一个物品类 <code>Item</code> ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解。</p>
+<p>我们建立了一个物品类 <code>Item</code> ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解：</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:12"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3829,13 +3829,13 @@
 </div>
 </div>
 </div>
-<p>最差情况下，需要遍历整个物品列表，<strong>因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> ，其中 <span class="arithmatex">\(n\)</span> 为物品数量。</p>
+<p>在最差情况下，需要遍历整个物品列表，<strong>因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> ，其中 <span class="arithmatex">\(n\)</span> 为物品数量。</p>
 <p>由于初始化了一个 <code>Item</code> 对象列表，<strong>因此空间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> 。</p>
 <h3 id="3">3. &nbsp; 正确性证明<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
 <p>采用反证法。假设物品 <span class="arithmatex">\(x\)</span> 是单位价值最高的物品，使用某算法求得最大价值为 <code>res</code> ，但该解中不包含物品 <span class="arithmatex">\(x\)</span> 。</p>
 <p>现在从背包中拿出单位重量的任意物品，并替换为单位重量的物品 <span class="arithmatex">\(x\)</span> 。由于物品 <span class="arithmatex">\(x\)</span> 的单位价值最高，因此替换后的总价值一定大于 <code>res</code> 。<strong>这与 <code>res</code> 是最优解矛盾，说明最优解中必须包含物品 <span class="arithmatex">\(x\)</span></strong> 。</p>
 <p>对于该解中的其他物品，我们也可以构建出上述矛盾。总而言之，<strong>单位价值更大的物品总是更优选择</strong>，这说明贪心策略是有效的。</p>
-<p>如图 15-6 所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。这个类比可以帮助我们从几何角度理解贪心策略的有效性。</p>
+<p>如图 15-6 所示，如果将物品重量和物品单位价值分别看作一张二维图表的横轴和纵轴，则分数背包问题可转化为“求在有限横轴区间下的最大围成面积”。这个类比可以帮助我们从几何角度理解贪心策略的有效性。</p>
 <p><a class="glightbox" href="../fractional_knapsack_problem.assets/fractional_knapsack_area_chart.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="分数背包问题的几何表示" class="animation-figure" src="../fractional_knapsack_problem.assets/fractional_knapsack_area_chart.png" /></a></p>
 <p align="center"> 图 15-6 &nbsp; 分数背包问题的几何表示 </p>
 

chapter_greedy/greedy_algorithm/index.html

@@ -2992,7 +2992,7 @@
       
         <li class="md-nav__item">
   <a href="#1511" class="md-nav__link">
-    15.1.1 &nbsp; 贪心优点与局限性
+    15.1.1 &nbsp; 贪心的优点与局限性
   </a>
   
 </li>
@@ -3328,7 +3328,7 @@
       
         <li class="md-nav__item">
   <a href="#1511" class="md-nav__link">
-    15.1.1 &nbsp; 贪心优点与局限性
+    15.1.1 &nbsp; 贪心的优点与局限性
   </a>
   
 </li>
@@ -3410,22 +3410,22 @@
 
 <!-- Page content -->
 <h1 id="151">15.1 &nbsp; 贪心算法<a class="headerlink" href="#151" title="Permanent link">&para;</a></h1>
-<p>「贪心算法 greedy algorithm」是一种常见的解决优化问题的算法，其基本思想是在问题的每个决策阶段，都选择当前看起来最优的选择，即贪心地做出局部最优的决策，以期望获得全局最优解。贪心算法简洁且高效，在许多实际问题中都有着广泛的应用。</p>
-<p>贪心算法和动态规划都常用于解决优化问题。它们之间存在一些相似之处，比如都依赖最优子结构性质，但工作原理是不同的。</p>
+<p>「贪心算法 greedy algorithm」是一种常见的解决优化问题的算法，其基本思想是在问题的每个决策阶段，都选择当前看起来最优的选择，即贪心地做出局部最优的决策，以期获得全局最优解。贪心算法简洁且高效，在许多实际问题中有着广泛的应用。</p>
+<p>贪心算法和动态规划都常用于解决优化问题。它们之间存在一些相似之处，比如都依赖最优子结构性质，但工作原理不同。</p>
 <ul>
 <li>动态规划会根据之前阶段的所有决策来考虑当前决策，并使用过去子问题的解来构建当前子问题的解。</li>
-<li>贪心算法不会重新考虑过去的决策，而是一路向前地进行贪心选择，不断缩小问题范围，直至问题被解决。</li>
+<li>贪心算法不会考虑过去的决策，而是一路向前地进行贪心选择，不断缩小问题范围，直至问题被解决。</li>
 </ul>
-<p>我们先通过例题“零钱兑换”了解贪心算法的工作原理。这道题已经在动态规划章节中介绍过，相信你对它并不陌生。</p>
+<p>我们先通过例题“零钱兑换”了解贪心算法的工作原理。这道题已经在“完全背包问题”章节中介绍过，相信你对它并不陌生。</p>
 <div class="admonition question">
 <p class="admonition-title">Question</p>
-<p>给定 <span class="arithmatex">\(n\)</span> 种硬币，第 <span class="arithmatex">\(i\)</span> 种硬币的面值为 <span class="arithmatex">\(coins[i - 1]\)</span> ，目标金额为 <span class="arithmatex">\(amt\)</span> ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 <span class="arithmatex">\(-1\)</span> 。</p>
+<p>给定 <span class="arithmatex">\(n\)</span> 种硬币，第 <span class="arithmatex">\(i\)</span> 种硬币的面值为 <span class="arithmatex">\(coins[i - 1]\)</span> ，目标金额为 <span class="arithmatex">\(amt\)</span> ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币数量。如果无法凑出目标金额则返回 <span class="arithmatex">\(-1\)</span> 。</p>
 </div>
-<p>本题的贪心策略如图 15-1 所示。给定目标金额，<strong>我们贪心地选择不大于且最接近它的硬币</strong>，不断循环该步骤，直至凑出目标金额为止。</p>
+<p>本题采取的贪心策略如图 15-1 所示。给定目标金额，<strong>我们贪心地选择不大于且最接近它的硬币</strong>，不断循环该步骤，直至凑出目标金额为止。</p>
 <p><a class="glightbox" href="../greedy_algorithm.assets/coin_change_greedy_strategy.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="零钱兑换的贪心策略" class="animation-figure" src="../greedy_algorithm.assets/coin_change_greedy_strategy.png" /></a></p>
 <p align="center"> 图 15-1 &nbsp; 零钱兑换的贪心策略 </p>
 
-<p>实现代码如下所示。你可能会不由地发出感叹：So Clean ！贪心算法仅用十行代码就解决了零钱兑换问题。</p>
+<p>实现代码如下所示。你可能会不由地发出感叹：So clean ！贪心算法仅用约十行代码就解决了零钱兑换问题：</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:12"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3670,11 +3670,11 @@
 </div>
 </div>
 </div>
-<h2 id="1511">15.1.1 &nbsp; 贪心优点与局限性<a class="headerlink" href="#1511" title="Permanent link">&para;</a></h2>
+<h2 id="1511">15.1.1 &nbsp; 贪心的优点与局限性<a class="headerlink" href="#1511" title="Permanent link">&para;</a></h2>
 <p><strong>贪心算法不仅操作直接、实现简单，而且通常效率也很高</strong>。在以上代码中，记硬币最小面值为 <span class="arithmatex">\(\min(coins)\)</span> ，则贪心选择最多循环 <span class="arithmatex">\(amt / \min(coins)\)</span> 次，时间复杂度为 <span class="arithmatex">\(O(amt / \min(coins))\)</span> 。这比动态规划解法的时间复杂度 <span class="arithmatex">\(O(n \times amt)\)</span> 提升了一个数量级。</p>
 <p>然而，<strong>对于某些硬币面值组合，贪心算法并不能找到最优解</strong>。图 15-2 给出了两个示例。</p>
 <ul>
-<li><strong>正例 <span class="arithmatex">\(coins = [1, 5, 10, 20, 50, 100]\)</span></strong>：在该硬币组合下，给定任意 <span class="arithmatex">\(amt\)</span> ，贪心算法都可以找出最优解。</li>
+<li><strong>正例 <span class="arithmatex">\(coins = [1, 5, 10, 20, 50, 100]\)</span></strong>：在该硬币组合下，给定任意 <span class="arithmatex">\(amt\)</span> ，贪心算法都可以找到最优解。</li>
 <li><strong>反例 <span class="arithmatex">\(coins = [1, 20, 50]\)</span></strong>：假设 <span class="arithmatex">\(amt = 60\)</span> ，贪心算法只能找到 <span class="arithmatex">\(50 + 1 \times 10\)</span> 的兑换组合，共计 <span class="arithmatex">\(11\)</span> 枚硬币，但动态规划可以找到最优解 <span class="arithmatex">\(20 + 20 + 20\)</span> ，仅需 <span class="arithmatex">\(3\)</span> 枚硬币。</li>
 <li><strong>反例 <span class="arithmatex">\(coins = [1, 49, 50]\)</span></strong>：假设 <span class="arithmatex">\(amt = 98\)</span> ，贪心算法只能找到 <span class="arithmatex">\(50 + 1 \times 48\)</span> 的兑换组合，共计 <span class="arithmatex">\(49\)</span> 枚硬币，但动态规划可以找到最优解 <span class="arithmatex">\(49 + 49\)</span> ，仅需 <span class="arithmatex">\(2\)</span> 枚硬币。</li>
 </ul>
@@ -3682,10 +3682,10 @@
 <p align="center"> 图 15-2 &nbsp; 贪心无法找出最优解的示例 </p>
 
 <p>也就是说，对于零钱兑换问题，贪心算法无法保证找到全局最优解，并且有可能找到非常差的解。它更适合用动态规划解决。</p>
-<p>一般情况下，贪心算法适用于以下两类问题。</p>
+<p>一般情况下，贪心算法的适用情况分以下两种。</p>
 <ol>
 <li><strong>可以保证找到最优解</strong>：贪心算法在这种情况下往往是最优选择，因为它往往比回溯、动态规划更高效。</li>
-<li><strong>可以找到近似最优解</strong>：贪心算法在这种情况下也是可用的。对于很多复杂问题来说，寻找全局最优解是非常困难的，能以较高效率找到次优解也是非常不错的。</li>
+<li><strong>可以找到近似最优解</strong>：贪心算法在这种情况下也是可用的。对于很多复杂问题来说，寻找全局最优解非常困难，能以较高效率找到次优解也是非常不错的。</li>
 </ol>
 <h2 id="1512">15.1.2 &nbsp; 贪心算法特性<a class="headerlink" href="#1512" title="Permanent link">&para;</a></h2>
 <p>那么问题来了，什么样的问题适合用贪心算法求解呢？或者说，贪心算法在什么情况下可以保证找到最优解？</p>
@@ -3694,28 +3694,28 @@
 <li><strong>贪心选择性质</strong>：只有当局部最优选择始终可以导致全局最优解时，贪心算法才能保证得到最优解。</li>
 <li><strong>最优子结构</strong>：原问题的最优解包含子问题的最优解。</li>
 </ul>
-<p>最优子结构已经在动态规划章节中介绍过，不再赘述。值得注意的是，一些问题的最优子结构并不明显，但仍然可使用贪心算法解决。</p>
-<p>我们主要探究贪心选择性质的判断方法。虽然它的描述看上去比较简单，<strong>但实际上对于许多问题，证明贪心选择性质不是一件易事</strong>。</p>
+<p>最优子结构已经在“动态规划”章节中介绍过，这里不再赘述。值得注意的是，一些问题的最优子结构并不明显，但仍然可使用贪心算法解决。</p>
+<p>我们主要探究贪心选择性质的判断方法。虽然它的描述看上去比较简单，<strong>但实际上对于许多问题，证明贪心选择性质并非易事</strong>。</p>
 <p>例如零钱兑换问题，我们虽然能够容易地举出反例，对贪心选择性质进行证伪，但证实的难度较大。如果问：<strong>满足什么条件的硬币组合可以使用贪心算法求解</strong>？我们往往只能凭借直觉或举例子来给出一个模棱两可的答案，而难以给出严谨的数学证明。</p>
 <div class="admonition quote">
 <p class="admonition-title">Quote</p>
-<p>有一篇论文给出了一个 <span class="arithmatex">\(O(n^3)\)</span> 时间复杂度的算法，用于判断一个硬币组合是否可以使用贪心算法找出任何金额的最优解。</p>
+<p>有一篇论文给出了一个 <span class="arithmatex">\(O(n^3)\)</span> 时间复杂度的算法，用于判断一个硬币组合能否使用贪心算法找出任意金额的最优解。</p>
 <p>Pearson, David. A polynomial-time algorithm for the change-making problem. Operations Research Letters 33.3 (2005): 231-234.</p>
 </div>
 <h2 id="1513">15.1.3 &nbsp; 贪心解题步骤<a class="headerlink" href="#1513" title="Permanent link">&para;</a></h2>
 <p>贪心问题的解决流程大体可分为以下三步。</p>
 <ol>
 <li><strong>问题分析</strong>：梳理与理解问题特性，包括状态定义、优化目标和约束条件等。这一步在回溯和动态规划中都有涉及。</li>
-<li><strong>确定贪心策略</strong>：确定如何在每一步中做出贪心选择。这个策略能够在每一步减小问题的规模，并最终能解决整个问题。</li>
-<li><strong>正确性证明</strong>：通常需要证明问题具有贪心选择性质和最优子结构。这个步骤可能需要使用到数学证明，例如归纳法或反证法等。</li>
+<li><strong>确定贪心策略</strong>：确定如何在每一步中做出贪心选择。这个策略能够在每一步减小问题的规模，并最终解决整个问题。</li>
+<li><strong>正确性证明</strong>：通常需要证明问题具有贪心选择性质和最优子结构。这个步骤可能需要用到数学证明，例如归纳法或反证法等。</li>
 </ol>
-<p>确定贪心策略是求解问题的核心步骤，但实施起来可能并不容易，主要包含以下原因。</p>
+<p>确定贪心策略是求解问题的核心步骤，但实施起来可能并不容易，主要有以下原因。</p>
 <ul>
-<li><strong>不同问题的贪心策略的差异较大</strong>。对于许多问题来说，贪心策略都比较浅显，我们通过一些大概的思考与尝试就能得出。而对于一些复杂问题，贪心策略可能非常隐蔽，这种情况就非常考验个人的解题经验与算法能力了。</li>
-<li><strong>某些贪心策略具有较强的迷惑性</strong>。当我们满怀信心设计好贪心策略，写出解题代码并提交运行，很可能发现部分测试样例无法通过。这是因为设计的贪心策略只是“部分正确”的，上文介绍的零钱兑换就是个典型案例。</li>
+<li><strong>不同问题的贪心策略的差异较大</strong>。对于许多问题来说，贪心策略比较浅显，我们通过一些大概的思考与尝试就能得出。而对于一些复杂问题，贪心策略可能非常隐蔽，这种情况就非常考验个人的解题经验与算法能力了。</li>
+<li><strong>某些贪心策略具有较强的迷惑性</strong>。当我们满怀信心设计好贪心策略，写出解题代码并提交运行，很可能发现部分测试样例无法通过。这是因为设计的贪心策略只是“部分正确”的，上文介绍的零钱兑换就是一个典型案例。</li>
 </ul>
 <p>为了保证正确性，我们应该对贪心策略进行严谨的数学证明，<strong>通常需要用到反证法或数学归纳法</strong>。</p>
-<p>然而，正确性证明也很可能不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行 Debug ，一步步修改与验证贪心策略。</p>
+<p>然而，正确性证明也很可能不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行代码调试，一步步修改与验证贪心策略。</p>
 <h2 id="1514">15.1.4 &nbsp; 贪心典型例题<a class="headerlink" href="#1514" title="Permanent link">&para;</a></h2>
 <p>贪心算法常常应用在满足贪心选择性质和最优子结构的优化问题中，以下列举了一些典型的贪心算法问题。</p>
 <ul>
@@ -3723,7 +3723,7 @@
 <li><strong>区间调度问题</strong>：假设你有一些任务，每个任务在一段时间内进行，你的目标是完成尽可能多的任务。如果每次都选择结束时间最早的任务，那么贪心算法就可以得到最优解。</li>
 <li><strong>分数背包问题</strong>：给定一组物品和一个载重量，你的目标是选择一组物品，使得总重量不超过载重量，且总价值最大。如果每次都选择性价比最高（价值 / 重量）的物品，那么贪心算法在一些情况下可以得到最优解。</li>
 <li><strong>股票买卖问题</strong>：给定一组股票的历史价格，你可以进行多次买卖，但如果你已经持有股票，那么在卖出之前不能再买，目标是获取最大利润。</li>
-<li><strong>霍夫曼编码</strong>：霍夫曼编码是一种用于无损数据压缩的贪心算法。通过构建霍夫曼树，每次选择出现频率最小的两个节点合并，最后得到的霍夫曼树的带权路径长度（即编码长度）最小。</li>
+<li><strong>霍夫曼编码</strong>：霍夫曼编码是一种用于无损数据压缩的贪心算法。通过构建霍夫曼树，每次选择出现频率最低的两个节点合并，最后得到的霍夫曼树的带权路径长度（编码长度）最小。</li>
 <li><strong>Dijkstra 算法</strong>：它是一种解决给定源顶点到其余各顶点的最短路径问题的贪心算法。</li>
 </ul>
 

chapter_greedy/index.html

@@ -3326,8 +3326,8 @@
 </div>
 <div class="admonition abstract">
 <p class="admonition-title">Abstract</p>
-<p>向日葵朝着太阳转动，时刻都在追求自身成长的最大可能。</p>
-<p>贪心策略在一轮轮的简单选择中，逐步导向最佳的答案。</p>
+<p>向日葵朝着太阳转动，时刻追求自身成长的最大可能。</p>
+<p>贪心策略在一轮轮的简单选择中，逐步导向最佳答案。</p>
 </div>
 <h2 id="_1">本章内容<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h2>
 <ul>

chapter_greedy/max_capacity_problem/index.html

@@ -3398,19 +3398,19 @@
 <h1 id="153">15.3 &nbsp; 最大容量问题<a class="headerlink" href="#153" title="Permanent link">&para;</a></h1>
 <div class="admonition question">
 <p class="admonition-title">Question</p>
-<p>输入一个数组 <span class="arithmatex">\(ht\)</span> ，数组中的每个元素代表一个垂直隔板的高度。数组中的任意两个隔板，以及它们之间的空间可以组成一个容器。</p>
-<p>容器的容量等于高度和宽度的乘积（即面积），其中高度由较短的隔板决定，宽度是两个隔板的数组索引之差。</p>
-<p>请在数组中选择两个隔板，使得组成的容器的容量最大，返回最大容量。</p>
+<p>输入一个数组 <span class="arithmatex">\(ht\)</span> ，其中的每个元素代表一个垂直隔板的高度。数组中的任意两个隔板，以及它们之间的空间可以组成一个容器。</p>
+<p>容器的容量等于高度和宽度的乘积（面积），其中高度由较短的隔板决定，宽度是两个隔板的数组索引之差。</p>
+<p>请在数组中选择两个隔板，使得组成的容器的容量最大，返回最大容量。示例如图 15-7 所示。</p>
 </div>
 <p><a class="glightbox" href="../max_capacity_problem.assets/max_capacity_example.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="最大容量问题的示例数据" class="animation-figure" src="../max_capacity_problem.assets/max_capacity_example.png" /></a></p>
 <p align="center"> 图 15-7 &nbsp; 最大容量问题的示例数据 </p>
 
 <p>容器由任意两个隔板围成，<strong>因此本题的状态为两个隔板的索引，记为 <span class="arithmatex">\([i, j]\)</span></strong> 。</p>
-<p>根据题意，容量等于高度乘以宽度，其中高度由短板决定，宽度是两隔板的索引之差。设容量为 <span class="arithmatex">\(cap[i, j]\)</span> ，则可得计算公式：</p>
+<p>根据题意，容量等于高度乘以宽度，其中高度由短板决定，宽度是两隔板的数组索引之差。设容量为 <span class="arithmatex">\(cap[i, j]\)</span> ，则可得计算公式：</p>
 <div class="arithmatex">\[
 cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
 \]</div>
-<p>设数组长度为 <span class="arithmatex">\(n\)</span> ，两个隔板的组合数量（即状态总数）为 <span class="arithmatex">\(C_n^2 = \frac{n(n - 1)}{2}\)</span> 个。最直接地，<strong>我们可以穷举所有状态</strong>，从而求得最大容量，时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> 。</p>
+<p>设数组长度为 <span class="arithmatex">\(n\)</span> ，两个隔板的组合数量（状态总数）为 <span class="arithmatex">\(C_n^2 = \frac{n(n - 1)}{2}\)</span> 个。最直接地，<strong>我们可以穷举所有状态</strong>，从而求得最大容量，时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> 。</p>
 <h3 id="1">1. &nbsp; 贪心策略确定<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
 <p>这道题还有更高效率的解法。如图 15-8 所示，现选取一个状态 <span class="arithmatex">\([i, j]\)</span> ，其满足索引 <span class="arithmatex">\(i &lt; j\)</span> 且高度 <span class="arithmatex">\(ht[i] &lt; ht[j]\)</span> ，即 <span class="arithmatex">\(i\)</span> 为短板、<span class="arithmatex">\(j\)</span> 为长板。</p>
 <p><a class="glightbox" href="../max_capacity_problem.assets/max_capacity_initial_state.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="初始状态" class="animation-figure" src="../max_capacity_problem.assets/max_capacity_initial_state.png" /></a></p>
@@ -3425,13 +3425,13 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
 <p><a class="glightbox" href="../max_capacity_problem.assets/max_capacity_moving_short_board.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="向内移动短板后的状态" class="animation-figure" src="../max_capacity_problem.assets/max_capacity_moving_short_board.png" /></a></p>
 <p align="center"> 图 15-10 &nbsp; 向内移动短板后的状态 </p>
 
-<p>由此便可推出本题的贪心策略：初始化两指针分裂容器两端，每轮向内收缩短板对应的指针，直至两指针相遇。</p>
+<p>由此便可推出本题的贪心策略：初始化两指针分列容器两端，每轮向内收缩短板对应的指针，直至两指针相遇。</p>
 <p>图 15-11 展示了贪心策略的执行过程。</p>
 <ol>
 <li>初始状态下，指针 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 分列与数组两端。</li>
 <li>计算当前状态的容量 <span class="arithmatex">\(cap[i, j]\)</span> ，并更新最大容量。</li>
 <li>比较板 <span class="arithmatex">\(i\)</span> 和 板 <span class="arithmatex">\(j\)</span> 的高度，并将短板向内移动一格。</li>
-<li>循环执行第 <code>2.</code> 和 <code>3.</code> 步，直至 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 相遇时结束。</li>
+<li>循环执行第 <code>2.</code> 步和第 <code>3.</code> 步，直至 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 相遇时结束。</li>
 </ol>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:9"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">&lt;1&gt;</label><label for="__tabbed_1_2">&lt;2&gt;</label><label for="__tabbed_1_3">&lt;3&gt;</label><label for="__tabbed_1_4">&lt;4&gt;</label><label for="__tabbed_1_5">&lt;5&gt;</label><label for="__tabbed_1_6">&lt;6&gt;</label><label for="__tabbed_1_7">&lt;7&gt;</label><label for="__tabbed_1_8">&lt;8&gt;</label><label for="__tabbed_1_9">&lt;9&gt;</label></div>
 <div class="tabbed-content">
@@ -3468,7 +3468,7 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
 
 <h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
 <p>代码循环最多 <span class="arithmatex">\(n\)</span> 轮，<strong>因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> 。</p>
-<p>变量 <span class="arithmatex">\(i\)</span>、<span class="arithmatex">\(j\)</span>、<span class="arithmatex">\(res\)</span> 使用常数大小额外空间，<strong>因此空间复杂度为 <span class="arithmatex">\(O(1)\)</span></strong> 。</p>
+<p>变量 <span class="arithmatex">\(i\)</span>、<span class="arithmatex">\(j\)</span>、<span class="arithmatex">\(res\)</span> 使用常数大小的额外空间，<strong>因此空间复杂度为 <span class="arithmatex">\(O(1)\)</span></strong> 。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:12"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Python</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Java</label><label for="__tabbed_2_4">C#</label><label for="__tabbed_2_5">Go</label><label for="__tabbed_2_6">Swift</label><label for="__tabbed_2_7">JS</label><label for="__tabbed_2_8">TS</label><label for="__tabbed_2_9">Dart</label><label for="__tabbed_2_10">Rust</label><label for="__tabbed_2_11">C</label><label for="__tabbed_2_12">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3740,8 +3740,8 @@ cap[i, i+1], cap[i, i+2], \dots, cap[i, j-2], cap[i, j-1]
 <p><a class="glightbox" href="../max_capacity_problem.assets/max_capacity_skipped_states.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="移动短板导致被跳过的状态" class="animation-figure" src="../max_capacity_problem.assets/max_capacity_skipped_states.png" /></a></p>
 <p align="center"> 图 15-12 &nbsp; 移动短板导致被跳过的状态 </p>
 
-<p>观察发现，<strong>这些被跳过的状态实际上就是将长板 <span class="arithmatex">\(j\)</span> 向内移动的所有状态</strong>。而在第二步中，我们已经证明内移长板一定会导致容量变小。也就是说，被跳过的状态都不可能是最优解，<strong>跳过它们不会导致错过最优解</strong>。</p>
-<p>以上的分析说明，<strong>移动短板的操作是“安全”的</strong>，贪心策略是有效的。</p>
+<p>观察发现，<strong>这些被跳过的状态实际上就是将长板 <span class="arithmatex">\(j\)</span> 向内移动的所有状态</strong>。前面我们已经证明内移长板一定会导致容量变小。也就是说，被跳过的状态都不可能是最优解，<strong>跳过它们不会导致错过最优解</strong>。</p>
+<p>以上分析说明，移动短板的操作是“安全”的，贪心策略是有效的。</p>
 
 <!-- Source file information -->
 

chapter_greedy/max_product_cutting_problem/index.html

@@ -3398,7 +3398,7 @@
 <h1 id="154">15.4 &nbsp; 最大切分乘积问题<a class="headerlink" href="#154" title="Permanent link">&para;</a></h1>
 <div class="admonition question">
 <p class="admonition-title">Question</p>
-<p>给定一个正整数 <span class="arithmatex">\(n\)</span> ，将其切分为至少两个正整数的和，求切分后所有整数的乘积最大是多少。</p>
+<p>给定一个正整数 <span class="arithmatex">\(n\)</span> ，将其切分为至少两个正整数的和，求切分后所有整数的乘积最大是多少，如图 15-13 所示。</p>
 </div>
 <p><a class="glightbox" href="../max_product_cutting_problem.assets/max_product_cutting_definition.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="最大切分乘积的问题定义" class="animation-figure" src="../max_product_cutting_problem.assets/max_product_cutting_definition.png" /></a></p>
 <p align="center"> 图 15-13 &nbsp; 最大切分乘积的问题定义 </p>
@@ -3407,7 +3407,7 @@
 <div class="arithmatex">\[
 n = \sum_{i=1}^{m}n_i
 \]</div>
-<p>本题目标是求得所有整数因子的最大乘积，即</p>
+<p>本题的目标是求得所有整数因子的最大乘积，即</p>
 <div class="arithmatex">\[
 \max(\prod_{i=1}^{m}n_i)
 \]</div>
@@ -3428,11 +3428,11 @@ n &amp; \geq 4
 
 <p>接下来思考哪个因子是最优的。在 <span class="arithmatex">\(1\)</span>、<span class="arithmatex">\(2\)</span>、<span class="arithmatex">\(3\)</span> 这三个因子中，显然 <span class="arithmatex">\(1\)</span> 是最差的，因为 <span class="arithmatex">\(1 \times (n-1) &lt; n\)</span> 恒成立，即切分出 <span class="arithmatex">\(1\)</span> 反而会导致乘积减小。</p>
 <p>如图 15-15 所示，当 <span class="arithmatex">\(n = 6\)</span> 时，有 <span class="arithmatex">\(3 \times 3 &gt; 2 \times 2 \times 2\)</span> 。<strong>这意味着切分出 <span class="arithmatex">\(3\)</span> 比切分出 <span class="arithmatex">\(2\)</span> 更优</strong>。</p>
-<p><strong>贪心策略二</strong>：在切分方案中，最多只应存在两个 <span class="arithmatex">\(2\)</span> 。因为三个 <span class="arithmatex">\(2\)</span> 总是可以被替换为两个 <span class="arithmatex">\(3\)</span> ，从而获得更大乘积。</p>
+<p><strong>贪心策略二</strong>：在切分方案中，最多只应存在两个 <span class="arithmatex">\(2\)</span> 。因为三个 <span class="arithmatex">\(2\)</span> 总是可以替换为两个 <span class="arithmatex">\(3\)</span> ，从而获得更大的乘积。</p>
 <p><a class="glightbox" href="../max_product_cutting_problem.assets/max_product_cutting_greedy_infer2.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="最优切分因子" class="animation-figure" src="../max_product_cutting_problem.assets/max_product_cutting_greedy_infer2.png" /></a></p>
 <p align="center"> 图 15-15 &nbsp; 最优切分因子 </p>
 
-<p>总结以上，可推出以下贪心策略。</p>
+<p>综上所述，可推理出以下贪心策略。</p>
 <ol>
 <li>输入整数 <span class="arithmatex">\(n\)</span> ，从其不断地切分出因子 <span class="arithmatex">\(3\)</span> ，直至余数为 <span class="arithmatex">\(0\)</span>、<span class="arithmatex">\(1\)</span>、<span class="arithmatex">\(2\)</span> 。</li>
 <li>当余数为 <span class="arithmatex">\(0\)</span> 时，代表 <span class="arithmatex">\(n\)</span> 是 <span class="arithmatex">\(3\)</span> 的倍数，因此不做任何处理。</li>
@@ -3714,7 +3714,7 @@ n = 3 a + b
 <p>使用反证法，只分析 <span class="arithmatex">\(n \geq 3\)</span> 的情况。</p>
 <ol>
 <li><strong>所有因子 <span class="arithmatex">\(\leq 3\)</span></strong> ：假设最优切分方案中存在 <span class="arithmatex">\(\geq 4\)</span> 的因子 <span class="arithmatex">\(x\)</span> ，那么一定可以将其继续划分为 <span class="arithmatex">\(2(x-2)\)</span> ，从而获得更大的乘积。这与假设矛盾。</li>
-<li><strong>切分方案不包含 <span class="arithmatex">\(1\)</span></strong> ：假设最优切分方案中存在一个因子 <span class="arithmatex">\(1\)</span> ，那么它一定可以合并入另外一个因子中，以获取更大乘积。这与假设矛盾。</li>
+<li><strong>切分方案不包含 <span class="arithmatex">\(1\)</span></strong> ：假设最优切分方案中存在一个因子 <span class="arithmatex">\(1\)</span> ，那么它一定可以合并入另外一个因子中，以获得更大的乘积。这与假设矛盾。</li>
 <li><strong>切分方案最多包含两个 <span class="arithmatex">\(2\)</span></strong> ：假设最优切分方案中包含三个 <span class="arithmatex">\(2\)</span> ，那么一定可以替换为两个 <span class="arithmatex">\(3\)</span> ，乘积更大。这与假设矛盾。</li>
 </ol>
 

chapter_greedy/summary/index.html

@@ -3317,13 +3317,13 @@
 <!-- Page content -->
 <h1 id="155">15.5 &nbsp; 小结<a class="headerlink" href="#155" title="Permanent link">&para;</a></h1>
 <ul>
-<li>贪心算法通常用于解决最优化问题，其原理是在每个决策阶段都做出局部最优的决策，以期望获得全局最优解。</li>
+<li>贪心算法通常用于解决最优化问题，其原理是在每个决策阶段都做出局部最优的决策，以期获得全局最优解。</li>
 <li>贪心算法会迭代地做出一个又一个的贪心选择，每轮都将问题转化成一个规模更小的子问题，直到问题被解决。</li>
 <li>贪心算法不仅实现简单，还具有很高的解题效率。相比于动态规划，贪心算法的时间复杂度通常更低。</li>
 <li>在零钱兑换问题中，对于某些硬币组合，贪心算法可以保证找到最优解；对于另外一些硬币组合则不然，贪心算法可能找到很差的解。</li>
 <li>适合用贪心算法求解的问题具有两大性质：贪心选择性质和最优子结构。贪心选择性质代表贪心策略的有效性。</li>
 <li>对于某些复杂问题，贪心选择性质的证明并不简单。相对来说，证伪更加容易，例如零钱兑换问题。</li>
-<li>求解贪心问题主要分为三步：问题分析、贪心策略确定、正确性证明。其中，贪心策略确定是核心步骤，正确性证明往往是难点。</li>
+<li>求解贪心问题主要分为三步：问题分析、确定贪心策略、正确性证明。其中，确定贪心策略是核心步骤，正确性证明往往是难点。</li>
 <li>分数背包问题在 0-1 背包的基础上，允许选择物品的一部分，因此可使用贪心算法求解。贪心策略的正确性可以使用反证法来证明。</li>
 <li>最大容量问题可使用穷举法求解，时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> 。通过设计贪心策略，每轮向内移动短板，可将时间复杂度优化至 <span class="arithmatex">\(O(n)\)</span> 。</li>
 <li>在最大切分乘积问题中，我们先后推理出两个贪心策略：<span class="arithmatex">\(\geq 4\)</span> 的整数都应该继续切分、最优切分因子为 <span class="arithmatex">\(3\)</span> 。代码中包含幂运算，时间复杂度取决于幂运算实现方法，通常为 <span class="arithmatex">\(O(1)\)</span> 或 <span class="arithmatex">\(O(\log n)\)</span> 。</li>