mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-26 02:46:30 +08:00
deploy
This commit is contained in:
krahets
parent
a71f51e5b8
commit
fd34c845bc
15 changed files with 208 additions and 187 deletions
|
|
@ -4414,23 +4414,22 @@
|
|||
<a id="__codelineno-47-29" name="__codelineno-47-29" href="#__codelineno-47-29"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nx">isSolution</span><span class="p">(</span><span class="nx">state</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-47-30" name="__codelineno-47-30" href="#__codelineno-47-30"></a><span class="w"> </span><span class="c1">// 记录解</span>
|
||||
<a id="__codelineno-47-31" name="__codelineno-47-31" href="#__codelineno-47-31"></a><span class="w"> </span><span class="nx">recordSolution</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="nx">res</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-32" name="__codelineno-47-32" href="#__codelineno-47-32"></a><span class="w"> </span><span class="k">return</span>
|
||||
<a id="__codelineno-47-33" name="__codelineno-47-33" href="#__codelineno-47-33"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-47-34" name="__codelineno-47-34" href="#__codelineno-47-34"></a><span class="w"> </span><span class="c1">// 遍历所有选择</span>
|
||||
<a id="__codelineno-47-35" name="__codelineno-47-35" href="#__codelineno-47-35"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nx">_</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="k">range</span><span class="w"> </span><span class="o">*</span><span class="nx">choices</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-47-36" name="__codelineno-47-36" href="#__codelineno-47-36"></a><span class="w"> </span><span class="c1">// 剪枝：检查选择是否合法</span>
|
||||
<a id="__codelineno-47-37" name="__codelineno-47-37" href="#__codelineno-47-37"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nx">isValid</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-47-38" name="__codelineno-47-38" href="#__codelineno-47-38"></a><span class="w"> </span><span class="c1">// 尝试：做出选择，更新状态</span>
|
||||
<a id="__codelineno-47-39" name="__codelineno-47-39" href="#__codelineno-47-39"></a><span class="w"> </span><span class="nx">makeChoice</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-40" name="__codelineno-47-40" href="#__codelineno-47-40"></a><span class="w"> </span><span class="c1">// 进行下一轮选择</span>
|
||||
<a id="__codelineno-47-41" name="__codelineno-47-41" href="#__codelineno-47-41"></a><span class="w"> </span><span class="nx">temp</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="nb">make</span><span class="p">([]</span><span class="o">*</span><span class="nx">TreeNode</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-42" name="__codelineno-47-42" href="#__codelineno-47-42"></a><span class="w"> </span><span class="nx">temp</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">append</span><span class="p">(</span><span class="nx">temp</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">.</span><span class="nx">Left</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">.</span><span class="nx">Right</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-43" name="__codelineno-47-43" href="#__codelineno-47-43"></a><span class="w"> </span><span class="nx">backtrackIII</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="nx">temp</span><span class="p">,</span><span class="w"> </span><span class="nx">res</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-44" name="__codelineno-47-44" href="#__codelineno-47-44"></a><span class="w"> </span><span class="c1">// 回退：撤销选择，恢复到之前的状态</span>
|
||||
<a id="__codelineno-47-45" name="__codelineno-47-45" href="#__codelineno-47-45"></a><span class="w"> </span><span class="nx">undoChoice</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-46" name="__codelineno-47-46" href="#__codelineno-47-46"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-47-47" name="__codelineno-47-47" href="#__codelineno-47-47"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-47-48" name="__codelineno-47-48" href="#__codelineno-47-48"></a><span class="p">}</span>
|
||||
<a id="__codelineno-47-32" name="__codelineno-47-32" href="#__codelineno-47-32"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-47-33" name="__codelineno-47-33" href="#__codelineno-47-33"></a><span class="w"> </span><span class="c1">// 遍历所有选择</span>
|
||||
<a id="__codelineno-47-34" name="__codelineno-47-34" href="#__codelineno-47-34"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nx">_</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="k">range</span><span class="w"> </span><span class="o">*</span><span class="nx">choices</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-47-35" name="__codelineno-47-35" href="#__codelineno-47-35"></a><span class="w"> </span><span class="c1">// 剪枝：检查选择是否合法</span>
|
||||
<a id="__codelineno-47-36" name="__codelineno-47-36" href="#__codelineno-47-36"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="nx">isValid</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-47-37" name="__codelineno-47-37" href="#__codelineno-47-37"></a><span class="w"> </span><span class="c1">// 尝试：做出选择，更新状态</span>
|
||||
<a id="__codelineno-47-38" name="__codelineno-47-38" href="#__codelineno-47-38"></a><span class="w"> </span><span class="nx">makeChoice</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-39" name="__codelineno-47-39" href="#__codelineno-47-39"></a><span class="w"> </span><span class="c1">// 进行下一轮选择</span>
|
||||
<a id="__codelineno-47-40" name="__codelineno-47-40" href="#__codelineno-47-40"></a><span class="w"> </span><span class="nx">temp</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="nb">make</span><span class="p">([]</span><span class="o">*</span><span class="nx">TreeNode</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-41" name="__codelineno-47-41" href="#__codelineno-47-41"></a><span class="w"> </span><span class="nx">temp</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">append</span><span class="p">(</span><span class="nx">temp</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">.</span><span class="nx">Left</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">.</span><span class="nx">Right</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-42" name="__codelineno-47-42" href="#__codelineno-47-42"></a><span class="w"> </span><span class="nx">backtrackIII</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="nx">temp</span><span class="p">,</span><span class="w"> </span><span class="nx">res</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-43" name="__codelineno-47-43" href="#__codelineno-47-43"></a><span class="w"> </span><span class="c1">// 回退：撤销选择，恢复到之前的状态</span>
|
||||
<a id="__codelineno-47-44" name="__codelineno-47-44" href="#__codelineno-47-44"></a><span class="w"> </span><span class="nx">undoChoice</span><span class="p">(</span><span class="nx">state</span><span class="p">,</span><span class="w"> </span><span class="nx">choice</span><span class="p">)</span>
|
||||
<a id="__codelineno-47-45" name="__codelineno-47-45" href="#__codelineno-47-45"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-47-46" name="__codelineno-47-46" href="#__codelineno-47-46"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-47-47" name="__codelineno-47-47" href="#__codelineno-47-47"></a><span class="p">}</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3382,14 +3382,13 @@
|
|||
|
||||
|
||||
<h1 id="142">14.2. 动态规划问题特性<a class="headerlink" href="#142" title="Permanent link">¶</a></h1>
|
||||
<p>在上节中，我们学习了动态规划问题的暴力解法，从递归树中观察到海量的重叠子问题，以及了解到动态规划是如何通过记录解来优化时间复杂度的。</p>
|
||||
<p>总的看来，<strong>子问题分解是一种通用的算法思路，在分治、动态规划、回溯中各有特点</strong>：</p>
|
||||
<p>在上节中，我们学习了动态规划是如何通过子问题分解来求解问题的。实际上，子问题分解是一种通用的算法思路，在分治、动态规划、回溯中各有特点：</p>
|
||||
<ul>
|
||||
<li>分治算法将原问题划分为几个独立的子问题，然后递归解决子问题，最后合并子问题的解得到原问题的解。</li>
|
||||
<li>动态规划也是将原问题分解为多个子问题，但与分治算法的主要区别是，<strong>动态规划中的子问题往往不是相互独立的</strong>，原问题的解依赖于子问题的解，而子问题的解又依赖于更小的子问题的解。</li>
|
||||
<li>回溯算法在尝试和回退中穷举所有可能的解，并通过剪枝避免不必要的搜索分支。原问题的解由一系列决策步骤构成，我们可以将每个决策步骤之前的子序列看作为一个子问题。</li>
|
||||
<li>「分治算法」递归地将原问题划分为多个互相独立的子问题，直至最小子问题，并在回溯中合并子问题的解，最终得到原问题的解。</li>
|
||||
<li>「动态规划」也对问题进行递归分解，但与分治算法的主要区别是，<strong>动态规划中的子问题往往不是相互独立的</strong>，原问题的解依赖于子问题的解，而子问题的解又依赖于更小的子问题的解。</li>
|
||||
<li>「回溯算法」在尝试和回退中穷举所有可能的解，并通过剪枝避免不必要的搜索分支。原问题的解由一系列决策步骤构成，我们可以将每个决策步骤之前的子序列看作为一个子问题。</li>
|
||||
</ul>
|
||||
<p>实际上，动态规划最常用来求解最优化问题。<strong>这类问题不仅包含重叠子问题，还具有另外两大特性：最优子结构、无后效性</strong>。</p>
|
||||
<p>实际上，动态规划常用来求解最优化问题，它们不仅包含重叠子问题，还具有另外两大特性：最优子结构、无后效性。</p>
|
||||
<h2 id="1421">14.2.1. 最优子结构<a class="headerlink" href="#1421" title="Permanent link">¶</a></h2>
|
||||
<p>我们对爬楼梯问题稍作改动，使之更加适合展示最优子结构概念。</p>
|
||||
<div class="admonition question">
|
||||
|
|
@ -3404,9 +3403,10 @@
|
|||
<div class="arithmatex">\[
|
||||
dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
||||
\]</div>
|
||||
<p>这便可以引出「最优子结构」的含义：<strong>原问题的最优解是从子问题的最优解构建得来的</strong>。本题显然具有最优子结构：我们从两个子问题最优解 <span class="arithmatex">\(dp[i-1]\)</span> , <span class="arithmatex">\(dp[i-2]\)</span> 中挑选出较优的那一个，并用它构建出原问题 <span class="arithmatex">\(dp[i]\)</span> 的最优解。</p>
|
||||
<p>那么，上节的爬楼梯题目有没有最优子结构呢？它要求解的是方案数量，看似是一个计数问题，但如果换一种问法：求解最大方案数量。我们意外地发现，<strong>虽然题目修改前后是等价的，但最优子结构浮现出来了</strong>：第 <span class="arithmatex">\(n\)</span> 阶最大方案数量等于第 <span class="arithmatex">\(n-1\)</span> 阶和第 <span class="arithmatex">\(n-2\)</span> 阶最大方案数量之和。所以说，最优子结构的解释方式比较灵活，在不同问题中会有不同的含义。</p>
|
||||
<p>根据以上状态转移方程，以及初始状态 <span class="arithmatex">\(dp[1] = cost[1]\)</span> , <span class="arithmatex">\(dp[2] = cost[2]\)</span> ，我们可以得出动态规划解题代码。</p>
|
||||
<p>这便可以引出「最优子结构」的含义：<strong>原问题的最优解是从子问题的最优解构建得来的</strong>。</p>
|
||||
<p>本题显然具有最优子结构：我们从两个子问题最优解 <span class="arithmatex">\(dp[i-1]\)</span> , <span class="arithmatex">\(dp[i-2]\)</span> 中挑选出较优的那一个，并用它构建出原问题 <span class="arithmatex">\(dp[i]\)</span> 的最优解。</p>
|
||||
<p>那么，上节的爬楼梯题目有没有最优子结构呢？它的目标是求解方案数量，看似是一个计数问题，但如果换一种问法：“求解最大方案数量”。我们意外地发现，<strong>虽然题目修改前后是等价的，但最优子结构浮现出来了</strong>：第 <span class="arithmatex">\(n\)</span> 阶最大方案数量等于第 <span class="arithmatex">\(n-1\)</span> 阶和第 <span class="arithmatex">\(n-2\)</span> 阶最大方案数量之和。所以说，最优子结构的解释方式比较灵活，在不同问题中会有不同的含义。</p>
|
||||
<p>根据状态转移方程，以及初始状态 <span class="arithmatex">\(dp[1] = cost[1]\)</span> , <span class="arithmatex">\(dp[2] = cost[2]\)</span> ，可以得出动态规划代码。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3563,7 +3563,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
<p><img alt="爬楼梯最小代价的动态规划过程" src="../dp_problem_features.assets/min_cost_cs_dp.png" /></p>
|
||||
<p align="center"> Fig. 爬楼梯最小代价的动态规划过程 </p>
|
||||
|
||||
<p>这道题同样也可以进行状态压缩，将一维压缩至零维，使得空间复杂度从 <span class="arithmatex">\(O(n)\)</span> 降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<p>本题也可以进行状态压缩，将一维压缩至零维，使得空间复杂度从 <span class="arithmatex">\(O(n)\)</span> 降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3699,7 +3699,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
</div>
|
||||
<h2 id="1422">14.2.2. 无后效性<a class="headerlink" href="#1422" title="Permanent link">¶</a></h2>
|
||||
<p>「无后效性」是动态规划能够有效解决问题的重要特性之一，定义为：<strong>给定一个确定的状态，它的未来发展只与当前状态有关，而与当前状态过去所经历过的所有状态无关</strong>。</p>
|
||||
<p>以爬楼梯问题为例，给定状态 <span class="arithmatex">\(i\)</span> ，它会发展出状态 <span class="arithmatex">\(i+1\)</span> 和状态 <span class="arithmatex">\(i+2\)</span> ，分别对应跳 <span class="arithmatex">\(1\)</span> 步和跳 <span class="arithmatex">\(2\)</span> 步。在做出这两种选择时，我们无需考虑状态 <span class="arithmatex">\(i\)</span> 之前的状态，即它们对状态 <span class="arithmatex">\(i\)</span> 的未来没有影响。</p>
|
||||
<p>以爬楼梯问题为例，给定状态 <span class="arithmatex">\(i\)</span> ，它会发展出状态 <span class="arithmatex">\(i+1\)</span> 和状态 <span class="arithmatex">\(i+2\)</span> ，分别对应跳 <span class="arithmatex">\(1\)</span> 步和跳 <span class="arithmatex">\(2\)</span> 步。在做出这两种选择时，我们无需考虑状态 <span class="arithmatex">\(i\)</span> 之前的状态，它们对状态 <span class="arithmatex">\(i\)</span> 的未来没有影响。</p>
|
||||
<p>然而，如果我们向爬楼梯问题添加一个约束，情况就不一样了。</p>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">带约束爬楼梯</p>
|
||||
|
|
@ -3709,14 +3709,14 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
|
|||
<p><img alt="带约束爬到第 3 阶的方案数量" src="../dp_problem_features.assets/climbing_stairs_constraint_example.png" /></p>
|
||||
<p align="center"> Fig. 带约束爬到第 3 阶的方案数量 </p>
|
||||
|
||||
<p>在该问题中，<strong>下一步选择不能由当前状态（当前楼梯阶数）独立决定，还和前一个状态（上轮楼梯阶数）有关</strong>。如果上一轮是跳 <span class="arithmatex">\(1\)</span> 阶上来的，那么下一轮就必须跳 <span class="arithmatex">\(2\)</span> 阶。</p>
|
||||
<p>不难发现，此问题已不满足无后效性，状态转移方程 <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> 也失效了，因为 <span class="arithmatex">\(dp[i-1]\)</span> 代表本轮跳 <span class="arithmatex">\(1\)</span> 阶，但其中包含了许多“上一轮跳 <span class="arithmatex">\(1\)</span> 阶上来的”方案，而为了满足约束，我们不能将 <span class="arithmatex">\(dp[i-1]\)</span> 直接计入 <span class="arithmatex">\(dp[i]\)</span> 中。</p>
|
||||
<p>为了解决该问题，我们需要扩展状态定义：<strong>状态 <span class="arithmatex">\([i, j]\)</span> 表示处在第 <span class="arithmatex">\(i\)</span> 阶、并且上一轮跳了 <span class="arithmatex">\(j\)</span> 阶</strong>，其中 <span class="arithmatex">\(j \in \{1, 2\}\)</span> 。此状态定义有效地区分了上一轮跳了 <span class="arithmatex">\(1\)</span> 阶还是 <span class="arithmatex">\(2\)</span> 阶，我们可以据此来决定下一步该怎么跳：</p>
|
||||
<p>在该问题中，如果上一轮是跳 <span class="arithmatex">\(1\)</span> 阶上来的，那么下一轮就必须跳 <span class="arithmatex">\(2\)</span> 阶。这意味着，<strong>下一步选择不能由当前状态（当前楼梯阶数）独立决定，还和前一个状态（上轮楼梯阶数）有关</strong>。</p>
|
||||
<p>不难发现，此问题已不满足无后效性，状态转移方程 <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> 也失效了，因为 <span class="arithmatex">\(dp[i-1]\)</span> 代表本轮跳 <span class="arithmatex">\(1\)</span> 阶，但其中包含了许多“上一轮跳 <span class="arithmatex">\(1\)</span> 阶上来的”方案，而为了满足约束，我们就不能将 <span class="arithmatex">\(dp[i-1]\)</span> 直接计入 <span class="arithmatex">\(dp[i]\)</span> 中。</p>
|
||||
<p>为此，我们需要扩展状态定义：<strong>状态 <span class="arithmatex">\([i, j]\)</span> 表示处在第 <span class="arithmatex">\(i\)</span> 阶、并且上一轮跳了 <span class="arithmatex">\(j\)</span> 阶</strong>，其中 <span class="arithmatex">\(j \in \{1, 2\}\)</span> 。此状态定义有效地区分了上一轮跳了 <span class="arithmatex">\(1\)</span> 阶还是 <span class="arithmatex">\(2\)</span> 阶，我们可以据此来决定下一步该怎么跳：</p>
|
||||
<ul>
|
||||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(1\)</span> ，即上一轮跳了 <span class="arithmatex">\(1\)</span> 阶时，这一轮只能选择跳 <span class="arithmatex">\(2\)</span> 阶；</li>
|
||||
<li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(2\)</span> ，即上一轮跳了 <span class="arithmatex">\(2\)</span> 阶时，这一轮可选择跳 <span class="arithmatex">\(1\)</span> 阶或跳 <span class="arithmatex">\(2\)</span> 阶；</li>
|
||||
</ul>
|
||||
<p>在该定义下，<span class="arithmatex">\(dp[i, j]\)</span> 表示状态 <span class="arithmatex">\([i, j]\)</span> 对应的方案数。由此，我们便能推导出以下的状态转移方程：</p>
|
||||
<p>在该定义下，<span class="arithmatex">\(dp[i, j]\)</span> 表示状态 <span class="arithmatex">\([i, j]\)</span> 对应的方案数。在该定义下的状态转移方程为：</p>
|
||||
<div class="arithmatex">\[
|
||||
\begin{cases}
|
||||
dp[i, 1] = dp[i-1, 2] \\
|
||||
|
|
@ -3901,8 +3901,8 @@ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2]
|
|||
<p class="admonition-title">爬楼梯与障碍生成</p>
|
||||
<p>给定一个共有 <span class="arithmatex">\(n\)</span> 阶的楼梯，你每步可以上 <span class="arithmatex">\(1\)</span> 阶或者 <span class="arithmatex">\(2\)</span> 阶。<strong>规定当爬到第 <span class="arithmatex">\(i\)</span> 阶时，系统自动会给第 <span class="arithmatex">\(2i\)</span> 阶上放上障碍物，之后所有轮都不允许跳到第 <span class="arithmatex">\(2i\)</span> 阶上</strong>。例如，前两轮分别跳到了第 <span class="arithmatex">\(2, 3\)</span> 阶上，则之后就不能跳到第 <span class="arithmatex">\(4, 6\)</span> 阶上。请问有多少种方案可以爬到楼顶。</p>
|
||||
</div>
|
||||
<p>在这个问题中，下次跳跃依赖于过去所有的状态，因为每一次跳跃都会在更高的阶梯上设置障碍，并影响未来的跳跃。对于这类问题，动态规划往往难以解决，或是因为计算复杂度过高而难以应用。</p>
|
||||
<p>实际上，许多复杂的组合优化问题（例如著名的旅行商问题）都不满足无后效性。对于这类问题，我们通常会选择使用其他方法，例如启发式搜索、遗传算法、强化学习等，从而降低时间复杂度，在有限时间内得到能够接受的局部最优解。</p>
|
||||
<p>在这个问题中，下次跳跃依赖于过去所有的状态，因为每一次跳跃都会在更高的阶梯上设置障碍，并影响未来的跳跃。对于这类问题，动态规划往往难以解决。</p>
|
||||
<p>实际上，许多复杂的组合优化问题（例如旅行商问题）都不满足无后效性。对于这类问题，我们通常会选择使用其他方法，例如启发式搜索、遗传算法、强化学习等，从而在有限时间内得到可用的局部最优解。</p>
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3456,22 +3456,22 @@
|
|||
<li>求解动态规划问题该从何处入手，完整步骤是什么？</li>
|
||||
</ol>
|
||||
<h2 id="1431">14.3.1. 问题判断<a class="headerlink" href="#1431" title="Permanent link">¶</a></h2>
|
||||
<p>总的来说，如果一个问题包含重叠子问题、最优子结构，并满足无后效性，那么它通常就适合用动态规划求解，但我们很难从问题描述上直接提取出这些特性。因此我们通常会放宽条件，<strong>先观察问题是否适合使用回溯（穷举）解决</strong>。</p>
|
||||
<p>总的来说，如果一个问题包含重叠子问题、最优子结构，并满足无后效性，那么它通常就适合用动态规划求解。然而，我们很难从问题描述上直接提取出这些特性。因此我们通常会放宽条件，<strong>先观察问题是否适合使用回溯（穷举）解决</strong>。</p>
|
||||
<p><strong>适合用回溯解决的问题通常满足“决策树模型”</strong>，这种问题可以使用树形结构来描述，其中每一个节点代表一个决策，每一条路径代表一个决策序列。</p>
|
||||
<p>换句话说，如果问题包含明确的决策概念，并且解是通过一系列决策产生的，那么它就满足决策树模型，通常可以使用回溯来解决。</p>
|
||||
<p>在此基础上，还有一些判断问题是动态规划问题的“加分项”，包括：</p>
|
||||
<p>在此基础上，还有一些动态规划问题的“加分项”，包括：</p>
|
||||
<ul>
|
||||
<li>问题包含最大（小）或最多（少）等最优化描述；</li>
|
||||
<li>问题的状态能够使用一个列表、多维矩阵或树来表示，并且一个状态与其周围的状态存在某种递推关系；</li>
|
||||
<li>问题包含最大（小）或最多（少）等最优化描述。</li>
|
||||
<li>问题的状态能够使用一个列表、多维矩阵或树来表示，并且一个状态与其周围的状态存在递推关系。</li>
|
||||
</ul>
|
||||
<p>而相应的“减分项”包括：</p>
|
||||
<ul>
|
||||
<li>问题的目标是找出所有可能的解决方案，而不是找出最优解。</li>
|
||||
<li>问题描述中有明显的排列组合的特征，需要返回具体的多个方案。</li>
|
||||
</ul>
|
||||
<p>如果一个问题满足决策树模型，并具有较为明显的“加分项“，我们就可以假设它是一个动态规划问题，并尝试求解它。</p>
|
||||
<p>如果一个问题满足决策树模型，并具有较为明显的“加分项“，我们就可以假设它是一个动态规划问题，并在求解过程中验证它。</p>
|
||||
<h2 id="1432">14.3.2. 问题求解步骤<a class="headerlink" href="#1432" title="Permanent link">¶</a></h2>
|
||||
<p>动态规划的解题流程可能会因问题的性质和难度而有所不同，但通常遵循以下步骤：描述决策，定义状态，建立 <span class="arithmatex">\(dp\)</span> 表，推导状态转移方程，确定边界条件等。</p>
|
||||
<p>动态规划的解题流程会因问题的性质和难度而有所不同，但通常遵循以下步骤：描述决策，定义状态，建立 <span class="arithmatex">\(dp\)</span> 表，推导状态转移方程，确定边界条件等。</p>
|
||||
<p>为了更形象地展示解题步骤，我们使用一个经典问题「最小路径和」来举例。</p>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
|
|
@ -3490,8 +3490,8 @@
|
|||
|
||||
<div class="admonition note">
|
||||
<p class="admonition-title">Note</p>
|
||||
<p>动态规划和回溯通常都会被描述为一个决策序列，而状态通常由所有决策变量构成。它应当包含描述解题进度的所有变量，其包含了足够的信息，能够用来推导出下一个状态。</p>
|
||||
<p>每个状态都对应一个子问题，我们会定义一个 <span class="arithmatex">\(dp\)</span> 表来存储所有子问题的解，状态的每个独立变量都是 <span class="arithmatex">\(dp\)</span> 表的一个维度。本质上看，<span class="arithmatex">\(dp\)</span> 表是子问题的解和状态之间的映射。</p>
|
||||
<p>动态规划和回溯过程可以被描述为一个决策序列，而状态由所有决策变量构成。它应当包含描述解题进度的所有变量，其包含了足够的信息，能够用来推导出下一个状态。</p>
|
||||
<p>每个状态都对应一个子问题，我们会定义一个 <span class="arithmatex">\(dp\)</span> 表来存储所有子问题的解，状态的每个独立变量都是 <span class="arithmatex">\(dp\)</span> 表的一个维度。本质上看，<span class="arithmatex">\(dp\)</span> 表是状态和子问题的解之间的映射。</p>
|
||||
</div>
|
||||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>对于状态 <span class="arithmatex">\([i, j]\)</span> ，它只能从上边格子 <span class="arithmatex">\([i-1, j]\)</span> 和左边格子 <span class="arithmatex">\([i, j-1]\)</span> 转移而来。因此最优子结构为：到达 <span class="arithmatex">\([i, j]\)</span> 的最小路径和由 <span class="arithmatex">\([i, j-1]\)</span> 的最小路径和与 <span class="arithmatex">\([i-1, j]\)</span> 的最小路径和，这两者较小的那一个决定。</p>
|
||||
|
|
@ -3504,24 +3504,26 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
|
||||
<div class="admonition note">
|
||||
<p class="admonition-title">Note</p>
|
||||
<p>基于定义好的 <span class="arithmatex">\(dp\)</span> 表，我们思考原问题和子问题的关系，找出如何通过子问题的解来构造原问题的解。</p>
|
||||
<p>最优子结构揭示了原问题和子问题的递推关系，一旦我们找到了最优子结构，就可以使用它来构建出状态转移方程。</p>
|
||||
<p>根据定义好的 <span class="arithmatex">\(dp\)</span> 表，思考原问题和子问题的关系，找出通过子问题的最优解来构造原问题的最优解的方法，即最优子结构。</p>
|
||||
<p>一旦我们找到了最优子结构，就可以使用它来构建出状态转移方程。</p>
|
||||
</div>
|
||||
<p><strong>第三步：确定边界条件和状态转移顺序</strong></p>
|
||||
<p>在本题中，当 <span class="arithmatex">\(i=0\)</span> 或 <span class="arithmatex">\(j=0\)</span> 时只有一种可能的路径，即只能向右移动或只能向下移动，因此首行和首列是边界条件。</p>
|
||||
<p>每个格子是由其左方格子和上方格子转移而来，因此我们使用两层循环来遍历矩阵即可，即外循环正序遍历各行、内循环正序遍历各列。</p>
|
||||
<p>在本题中，处在首行的状态只能向右转移，首列状态只能向下转移，因此首行 <span class="arithmatex">\(i = 0\)</span> 和首列 <span class="arithmatex">\(j = 0\)</span> 是边界条件。</p>
|
||||
<p>每个格子是由其左方格子和上方格子转移而来，因此我们使用采用循环来遍历矩阵，外循环遍历各行、内循环遍历各列。</p>
|
||||
<p><img alt="边界条件与状态转移顺序" src="../dp_solution_pipeline.assets/min_path_sum_solution_step3.png" /></p>
|
||||
<p align="center"> Fig. 边界条件与状态转移顺序 </p>
|
||||
|
||||
<div class="admonition note">
|
||||
<p class="admonition-title">Note</p>
|
||||
<p>边界条件即初始状态，在搜索中用于剪枝，在动态规划中用于初始化 <span class="arithmatex">\(dp\)</span> 表。状态转移顺序的核心是要保证在计算当前问题时，所有它依赖的更小子问题都已经被正确地计算出来。</p>
|
||||
<p>边界条件在动态规划中用于初始化 <span class="arithmatex">\(dp\)</span> 表，在搜索中用于剪枝。</p>
|
||||
<p>状态转移顺序的核心是要保证在计算当前问题的解时，所有它依赖的更小子问题的解都已经被正确地计算出来。</p>
|
||||
</div>
|
||||
<p>接下来，我们就可以实现动态规划代码了。然而，由于子问题分解是一种从顶至底的思想，因此按照“暴力搜索 <span class="arithmatex">\(\rightarrow\)</span> 记忆化搜索 <span class="arithmatex">\(\rightarrow\)</span> 动态规划”的顺序实现更加符合思维习惯。</p>
|
||||
<p>根据以上分析，我们已经可以直接写出动态规划代码。然而子问题分解是一种从顶至底的思想，因此按照“暴力搜索 <span class="arithmatex">\(\rightarrow\)</span> 记忆化搜索 <span class="arithmatex">\(\rightarrow\)</span> 动态规划”的顺序实现更加符合思维习惯。</p>
|
||||
<h3 id="_1">方法一：暴力搜索<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>从状态 <span class="arithmatex">\([i, j]\)</span> 开始搜索，不断分解为更小的状态 <span class="arithmatex">\([i-1, j]\)</span> 和 <span class="arithmatex">\([i, j-1]\)</span> ，包括以下递归要素：</p>
|
||||
<ul>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, j]\)</span> ；<strong>返回值</strong>：从 <span class="arithmatex">\([0, 0]\)</span> 到 <span class="arithmatex">\([i, j]\)</span> 的最小路径和 <span class="arithmatex">\(dp[i, j]\)</span> ；</li>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, j]\)</span> ；</li>
|
||||
<li><strong>返回值</strong>：从 <span class="arithmatex">\([0, 0]\)</span> 到 <span class="arithmatex">\([i, j]\)</span> 的最小路径和 <span class="arithmatex">\(dp[i, j]\)</span> ；</li>
|
||||
<li><strong>终止条件</strong>：当 <span class="arithmatex">\(i = 0\)</span> 且 <span class="arithmatex">\(j = 0\)</span> 时，返回代价 <span class="arithmatex">\(grid[0, 0]\)</span> ；</li>
|
||||
<li><strong>剪枝</strong>：当 <span class="arithmatex">\(i < 0\)</span> 时或 <span class="arithmatex">\(j < 0\)</span> 时索引越界，此时返回代价 <span class="arithmatex">\(+\infty\)</span> ，代表不可行；</li>
|
||||
</ul>
|
||||
|
|
@ -3675,14 +3677,14 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>我们尝试画出以 <span class="arithmatex">\(dp[2, 1]\)</span> 为根节点的递归树。观察下图，递归树包含一些重叠子问题，其数量会随着网格 <code>grid</code> 的尺寸变大而急剧增多。</p>
|
||||
<p>直观上看，<strong>存在多条路径可以从左上角到达同一单元格</strong>，这便是该问题存在重叠子问题的内在原因。</p>
|
||||
<p>下图给出了以 <span class="arithmatex">\(dp[2, 1]\)</span> 为根节点的递归树，其中包含一些重叠子问题，其数量会随着网格 <code>grid</code> 的尺寸变大而急剧增多。</p>
|
||||
<p>本质上看，造成重叠子问题的原因为：<strong>存在多条路径可以从左上角到达某一单元格</strong>。</p>
|
||||
<p><img alt="暴力搜索递归树" src="../dp_solution_pipeline.assets/min_path_sum_dfs.png" /></p>
|
||||
<p align="center"> Fig. 暴力搜索递归树 </p>
|
||||
|
||||
<p>每个状态都有向下和向右两种选择，从左上角走到右下角总共需要 <span class="arithmatex">\(m + n - 2\)</span> 步，所以最差时间复杂度为 <span class="arithmatex">\(O(2^{m + n})\)</span> 。请注意，这种计算方式未考虑临近网格边界的情况，当到达网络边界时只剩下一种选择。因此实际的路径数量会少一些。</p>
|
||||
<h3 id="_2">方法二：记忆化搜索<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>为了避免重复计算重叠子问题，我们引入一个和网格 <code>grid</code> 相同尺寸的记忆列表 <code>mem</code> ，用于记录各个子问题的解，提升搜索效率。</p>
|
||||
<p>我们引入一个和网格 <code>grid</code> 相同尺寸的记忆列表 <code>mem</code> ，用于记录各个子问题的解，并将重叠子问题进行剪枝。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3870,12 +3872,12 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>如下图所示，引入记忆化可以消除所有重复计算，时间复杂度取决于状态总数，即网格尺寸 <span class="arithmatex">\(O(nm)\)</span> 。</p>
|
||||
<p>引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 <span class="arithmatex">\(O(nm)\)</span> 。</p>
|
||||
<p><img alt="记忆化搜索递归树" src="../dp_solution_pipeline.assets/min_path_sum_dfs_mem.png" /></p>
|
||||
<p align="center"> Fig. 记忆化搜索递归树 </p>
|
||||
|
||||
<h3 id="_3">方法三：动态规划<a class="headerlink" href="#_3" title="Permanent link">¶</a></h3>
|
||||
<p>动态规划代码是从底至顶的，仅需循环即可实现。</p>
|
||||
<p>基于迭代实现动态规划解法。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:11"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JavaScript</label><label for="__tabbed_3_6">TypeScript</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label><label for="__tabbed_3_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4071,7 +4073,8 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图展示了最小路径和的状态转移过程。该过程遍历了整个网格，因此时间复杂度为 <span class="arithmatex">\(O(nm)\)</span> ；数组 <code>dp</code> 使用 <span class="arithmatex">\(O(nm)\)</span> 空间。</p>
|
||||
<p>下图展示了最小路径和的状态转移过程，其遍历了整个网格，<strong>因此时间复杂度为 <span class="arithmatex">\(O(nm)\)</span></strong> 。</p>
|
||||
<p>数组 <code>dp</code> 大小为 <span class="arithmatex">\(n \times m\)</span> ，<strong>因此空间复杂度为 <span class="arithmatex">\(O(nm)\)</span></strong> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:12"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><input id="__tabbed_4_12" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1"><1></label><label for="__tabbed_4_2"><2></label><label for="__tabbed_4_3"><3></label><label for="__tabbed_4_4"><4></label><label for="__tabbed_4_5"><5></label><label for="__tabbed_4_6"><6></label><label for="__tabbed_4_7"><7></label><label for="__tabbed_4_8"><8></label><label for="__tabbed_4_9"><9></label><label for="__tabbed_4_10"><10></label><label for="__tabbed_4_11"><11></label><label for="__tabbed_4_12"><12></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4113,8 +4116,8 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="_4">状态压缩<a class="headerlink" href="#_4" title="Permanent link">¶</a></h3>
|
||||
<p>如果希望进一步节省空间使用，可以考虑进行状态压缩。每个格子只与左边和上边的格子有关，因此我们可以只用一个单行数组来实现 <span class="arithmatex">\(dp\)</span> 表。</p>
|
||||
<p>由于数组 <code>dp</code> 只能表示一行的状态，因此我们无法提前初始化首列状态，而是在遍历每行中更新它。</p>
|
||||
<p>由于每个格子只与其左边和上边的格子有关，因此我们可以只用一个单行数组来实现 <span class="arithmatex">\(dp\)</span> 表。</p>
|
||||
<p>请注意，因为数组 <code>dp</code> 只能表示一行的状态，所以我们无法提前初始化首列状态，而是在遍历每行中更新它。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:11"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Java</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Python</label><label for="__tabbed_5_4">Go</label><label for="__tabbed_5_5">JavaScript</label><label for="__tabbed_5_6">TypeScript</label><label for="__tabbed_5_7">C</label><label for="__tabbed_5_8">C#</label><label for="__tabbed_5_9">Swift</label><label for="__tabbed_5_10">Zig</label><label for="__tabbed_5_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3382,7 +3382,7 @@
|
|||
|
||||
|
||||
<h1 id="146">14.6. 编辑距离问题<a class="headerlink" href="#146" title="Permanent link">¶</a></h1>
|
||||
<p>编辑距离，也被称为 Levenshtein 距离，是两个字符串之间互相转换的最小修改次数，通常用于在信息检索和自然语言处理中度量两个序列的相似度。</p>
|
||||
<p>编辑距离，也被称为 Levenshtein 距离，指两个字符串之间互相转换的最小修改次数，通常用于在信息检索和自然语言处理中度量两个序列的相似度。</p>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>输入两个字符串 <span class="arithmatex">\(s\)</span> 和 <span class="arithmatex">\(t\)</span> ，返回将 <span class="arithmatex">\(s\)</span> 转换为 <span class="arithmatex">\(t\)</span> 所需的最少编辑步数。</p>
|
||||
|
|
@ -3393,7 +3393,8 @@
|
|||
<p align="center"> Fig. 编辑距离的示例数据 </p>
|
||||
|
||||
<p><strong>编辑距离问题可以很自然地用决策树模型来解释</strong>。字符串对应树节点，一轮决策（一次编辑操作）对应树的一条边。</p>
|
||||
<p>如下图所示，在不限制操作的情况下，每个节点都可以派生出许多条边，每条边对应一种操作。实际上，从 <code>hello</code> 转换到 <code>algo</code> 有许多种可能的路径，下图展示的是最短路径。从决策树的角度看，本题目标是求解节点 <code>hello</code> 和节点 <code>algo</code> 之间的最短路径。</p>
|
||||
<p>如下图所示，在不限制操作的情况下，每个节点都可以派生出许多条边，每条边对应一种操作，这意味着从 <code>hello</code> 转换到 <code>algo</code> 有许多种可能的路径。</p>
|
||||
<p>从决策树的角度看，本题的目标是求解节点 <code>hello</code> 和节点 <code>algo</code> 之间的最短路径。</p>
|
||||
<p><img alt="基于决策树模型表示编辑距离问题" src="../edit_distance_problem.assets/edit_distance_decision_tree.png" /></p>
|
||||
<p align="center"> Fig. 基于决策树模型表示编辑距离问题 </p>
|
||||
|
||||
|
|
@ -3401,12 +3402,12 @@
|
|||
<p>每一轮的决策是对字符串 <span class="arithmatex">\(s\)</span> 进行一次编辑操作。</p>
|
||||
<p>我们希望在编辑操作的过程中，问题的规模逐渐缩小，这样才能构建子问题。设字符串 <span class="arithmatex">\(s\)</span> 和 <span class="arithmatex">\(t\)</span> 的长度分别为 <span class="arithmatex">\(n\)</span> 和 <span class="arithmatex">\(m\)</span> ，我们先考虑两字符串尾部的字符 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> ：</p>
|
||||
<ul>
|
||||
<li>若 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> 相同，我们可以直接跳过它们，接下来考虑 <span class="arithmatex">\(s[n-2]\)</span> 和 <span class="arithmatex">\(t[m-2]\)</span> ;</li>
|
||||
<li>若 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> 相同，我们可以跳过它们，直接考虑 <span class="arithmatex">\(s[n-2]\)</span> 和 <span class="arithmatex">\(t[m-2]\)</span> ;</li>
|
||||
<li>若 <span class="arithmatex">\(s[n-1]\)</span> 和 <span class="arithmatex">\(t[m-1]\)</span> 不同，我们需要对 <span class="arithmatex">\(s\)</span> 进行一次编辑（插入、删除、替换），使得两字符串尾部的字符相同，从而可以跳过它们，考虑规模更小的问题；</li>
|
||||
</ul>
|
||||
<p>也就是说，我们在字符串 <span class="arithmatex">\(s\)</span> 中进行的每一轮决策（编辑操作），都会使得 <span class="arithmatex">\(s\)</span> 和 <span class="arithmatex">\(t\)</span> 中剩余的待匹配字符发生变化。因此，状态为当前在 <span class="arithmatex">\(s\)</span> , <span class="arithmatex">\(t\)</span> 中考虑的第 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 个字符，记为 <span class="arithmatex">\([i, j]\)</span> 。</p>
|
||||
<p>状态 <span class="arithmatex">\([i, j]\)</span> 对应的子问题：<strong>将 <span class="arithmatex">\(s\)</span> 的前 <span class="arithmatex">\(i\)</span> 个字符更改为 <span class="arithmatex">\(t\)</span> 的前 <span class="arithmatex">\(j\)</span> 个字符所需的最少编辑步数</strong>。</p>
|
||||
<p>至此得到一个尺寸为 <span class="arithmatex">\((i+1) \times (j+1)\)</span> 的二维 <span class="arithmatex">\(dp\)</span> 表。</p>
|
||||
<p>至此，得到一个尺寸为 <span class="arithmatex">\((i+1) \times (j+1)\)</span> 的二维 <span class="arithmatex">\(dp\)</span> 表。</p>
|
||||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>考虑子问题 <span class="arithmatex">\(dp[i, j]\)</span> ，其对应的两个字符串的尾部字符为 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> ，可根据不同编辑操作分为三种情况：</p>
|
||||
<ol>
|
||||
|
|
@ -3417,16 +3418,16 @@
|
|||
<p><img alt="编辑距离的状态转移" src="../edit_distance_problem.assets/edit_distance_state_transfer.png" /></p>
|
||||
<p align="center"> Fig. 编辑距离的状态转移 </p>
|
||||
|
||||
<p>根据以上分析，可得最优子结构：<span class="arithmatex">\(dp[i, j]\)</span> 的最少编辑步数等于 <span class="arithmatex">\(dp[i, j-1]\)</span> , <span class="arithmatex">\(dp[i-1, j]\)</span> , <span class="arithmatex">\(dp[i-1, j-1]\)</span> 三者中的最少编辑步数，再加上本次编辑的步数 <span class="arithmatex">\(1\)</span> 。对应的状态转移方程为：</p>
|
||||
<p>根据以上分析，可得最优子结构：<span class="arithmatex">\(dp[i, j]\)</span> 的最少编辑步数等于 <span class="arithmatex">\(dp[i, j-1]\)</span> , <span class="arithmatex">\(dp[i-1, j]\)</span> , <span class="arithmatex">\(dp[i-1, j-1]\)</span> 三者中的最少编辑步数，再加上本次的编辑步数 <span class="arithmatex">\(1\)</span> 。对应的状态转移方程为：</p>
|
||||
<div class="arithmatex">\[
|
||||
dp[i, j] = \min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1
|
||||
\]</div>
|
||||
<p>请注意，<strong>当 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> 相同时，无需编辑当前字符</strong>，此时状态转移方程为：</p>
|
||||
<p>请注意，<strong>当 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> 相同时，无需编辑当前字符</strong>，这种情况下的状态转移方程为：</p>
|
||||
<div class="arithmatex">\[
|
||||
dp[i, j] = dp[i-1, j-1]
|
||||
\]</div>
|
||||
<p><strong>第三步：确定边界条件和状态转移顺序</strong></p>
|
||||
<p>当两字符串都为空时，编辑步数为 <span class="arithmatex">\(0\)</span> ，即 <span class="arithmatex">\(dp[0, 0] = 0\)</span> 。当 <span class="arithmatex">\(s\)</span> 为空但 <span class="arithmatex">\(t\)</span> 不为空时，最少编辑步数等于 <span class="arithmatex">\(t\)</span> 的长度，即 <span class="arithmatex">\(dp[0, j] = j\)</span> 。当 <span class="arithmatex">\(s\)</span> 不为空但 <span class="arithmatex">\(t\)</span> 为空时，等于 <span class="arithmatex">\(s\)</span> 的长度，即 <span class="arithmatex">\(dp[i, 0] = i\)</span> 。</p>
|
||||
<p>当两字符串都为空时，编辑步数为 <span class="arithmatex">\(0\)</span> ，即 <span class="arithmatex">\(dp[0, 0] = 0\)</span> 。当 <span class="arithmatex">\(s\)</span> 为空但 <span class="arithmatex">\(t\)</span> 不为空时，最少编辑步数等于 <span class="arithmatex">\(t\)</span> 的长度，即首行 <span class="arithmatex">\(dp[0, j] = j\)</span> 。当 <span class="arithmatex">\(s\)</span> 不为空但 <span class="arithmatex">\(t\)</span> 为空时，等于 <span class="arithmatex">\(s\)</span> 的长度，即首列 <span class="arithmatex">\(dp[i, 0] = i\)</span> 。</p>
|
||||
<p>观察状态转移方程，解 <span class="arithmatex">\(dp[i, j]\)</span> 依赖左方、上方、左上方的解，因此通过两层循环正序遍历整个 <span class="arithmatex">\(dp\)</span> 表即可。</p>
|
||||
<h3 id="_1">代码实现<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
|
|
@ -3696,8 +3697,8 @@ dp[i, j] = dp[i-1, j-1]
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="_2">状态压缩<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>下面考虑状态压缩，将 <span class="arithmatex">\(dp\)</span> 表的第一维删除。由于 <span class="arithmatex">\(dp[i,j]\)</span> 是由上方 <span class="arithmatex">\(dp[i-1, j]\)</span> 、左方 <span class="arithmatex">\(dp[i, j-1]\)</span> 、左上方状态 <span class="arithmatex">\(dp[i-1, j-1]\)</span> 转移而来，而正序遍历会丢失左上方 <span class="arithmatex">\(dp[i-1, j-1]\)</span> ，倒序遍历无法提前构建 <span class="arithmatex">\(dp[i, j-1]\)</span> ，因此两种遍历顺序都不可取。</p>
|
||||
<p>为解决此问题，我们可以使用一个变量 <code>leftup</code> 来暂存左上方的解 <span class="arithmatex">\(dp[i-1, j-1]\)</span> ，这样便只用考虑左方和上方的解，与完全背包问题的情况相同，可使用正序遍历。</p>
|
||||
<p>由于 <span class="arithmatex">\(dp[i,j]\)</span> 是由上方 <span class="arithmatex">\(dp[i-1, j]\)</span> 、左方 <span class="arithmatex">\(dp[i, j-1]\)</span> 、左上方状态 <span class="arithmatex">\(dp[i-1, j-1]\)</span> 转移而来，而正序遍历会丢失左上方 <span class="arithmatex">\(dp[i-1, j-1]\)</span> ，倒序遍历无法提前构建 <span class="arithmatex">\(dp[i, j-1]\)</span> ，因此两种遍历顺序都不可取。</p>
|
||||
<p>为此，我们可以使用一个变量 <code>leftup</code> 来暂存左上方的解 <span class="arithmatex">\(dp[i-1, j-1]\)</span> ，从而只需考虑左方和上方的解。此时的情况与完全背包问题相同，可使用正序遍历。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:11"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JavaScript</label><label for="__tabbed_3_6">TypeScript</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label><label for="__tabbed_3_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3410,7 +3410,7 @@
|
|||
|
||||
|
||||
<h1 id="141">14.1. 初探动态规划<a class="headerlink" href="#141" title="Permanent link">¶</a></h1>
|
||||
<p>「动态规划 Dynamic Programming」是一种通过将复杂问题分解为更简单的子问题的方式来求解问题的方法。它将一个问题分解为一系列更小的子问题，并通过存储子问题的解来避免重复计算，从而大幅提升时间效率。</p>
|
||||
<p>「动态规划 Dynamic Programming」是一个重要的算法范式，它将一个问题分解为一系列更小的子问题，并通过存储子问题的解来避免重复计算，从而大幅提升时间效率。</p>
|
||||
<p>在本节中，我们从一个经典例题入手，先给出它的暴力回溯解法，观察其中包含的重叠子问题，再逐步导出更高效的动态规划解法。</p>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">爬楼梯</p>
|
||||
|
|
@ -3649,20 +3649,24 @@
|
|||
</div>
|
||||
<h2 id="1411">14.1.1. 方法一：暴力搜索<a class="headerlink" href="#1411" title="Permanent link">¶</a></h2>
|
||||
<p>回溯算法通常并不显式地对问题进行拆解，而是将问题看作一系列决策步骤，通过试探和剪枝，搜索所有可能的解。</p>
|
||||
<p>对于本题，我们可以尝试将问题拆解为更小的子问题。设爬到第 <span class="arithmatex">\(i\)</span> 阶共有 <span class="arithmatex">\(dp[i]\)</span> 种方案，那么 <span class="arithmatex">\(dp[i]\)</span> 就是原问题，其子问题包括:</p>
|
||||
<p>我们可以尝试从问题分解的角度分析这道题。设爬到第 <span class="arithmatex">\(i\)</span> 阶共有 <span class="arithmatex">\(dp[i]\)</span> 种方案，那么 <span class="arithmatex">\(dp[i]\)</span> 就是原问题，其子问题包括:</p>
|
||||
<div class="arithmatex">\[
|
||||
dp[i-1] , dp[i-2] , \cdots , dp[2] , dp[1]
|
||||
\]</div>
|
||||
<p>由于每轮只能上 <span class="arithmatex">\(1\)</span> 阶或 <span class="arithmatex">\(2\)</span> 阶，因此当我们站在第 <span class="arithmatex">\(i\)</span> 阶楼梯上时，上一轮只可能站在第 <span class="arithmatex">\(i - 1\)</span> 阶或第 <span class="arithmatex">\(i - 2\)</span> 阶上，换句话说，我们只能从第 <span class="arithmatex">\(i -1\)</span> 阶或第 <span class="arithmatex">\(i - 2\)</span> 阶前往第 <span class="arithmatex">\(i\)</span> 阶。因此，<strong>爬到第 <span class="arithmatex">\(i - 1\)</span> 阶的方案数加上爬到第 <span class="arithmatex">\(i - 2\)</span> 阶的方案数就等于爬到第 <span class="arithmatex">\(i\)</span> 阶的方案数</strong>，即：</p>
|
||||
<p>由于每轮只能上 <span class="arithmatex">\(1\)</span> 阶或 <span class="arithmatex">\(2\)</span> 阶，因此当我们站在第 <span class="arithmatex">\(i\)</span> 阶楼梯上时，上一轮只可能站在第 <span class="arithmatex">\(i - 1\)</span> 阶或第 <span class="arithmatex">\(i - 2\)</span> 阶上。换句话说，我们只能从第 <span class="arithmatex">\(i -1\)</span> 阶或第 <span class="arithmatex">\(i - 2\)</span> 阶前往第 <span class="arithmatex">\(i\)</span> 阶。</p>
|
||||
<p>由此便可得出一个重要推论：<strong>爬到第 <span class="arithmatex">\(i - 1\)</span> 阶的方案数加上爬到第 <span class="arithmatex">\(i - 2\)</span> 阶的方案数就等于爬到第 <span class="arithmatex">\(i\)</span> 阶的方案数</strong>。公式如下：</p>
|
||||
<div class="arithmatex">\[
|
||||
dp[i] = dp[i-1] + dp[i-2]
|
||||
\]</div>
|
||||
<p>这意味着在爬楼梯问题中，<strong>各个子问题之间不是相互独立的，原问题的解可以从子问题的解构建得来</strong>。</p>
|
||||
<p><img alt="方案数量递推关系" src="../intro_to_dynamic_programming.assets/climbing_stairs_state_transfer.png" /></p>
|
||||
<p align="center"> Fig. 方案数量递推关系 </p>
|
||||
|
||||
<p>也就是说，在爬楼梯问题中，<strong>各个子问题之间不是相互独立的，原问题的解可以由子问题的解构成</strong>。</p>
|
||||
<p>我们可以基于此递推公式写出暴力搜索代码：以 <span class="arithmatex">\(dp[n]\)</span> 为起始点，<strong>从顶至底地将一个较大问题拆解为两个较小问题的和</strong>，直至到达最小子问题 <span class="arithmatex">\(dp[1]\)</span> 和 <span class="arithmatex">\(dp[2]\)</span> 时返回。</p>
|
||||
<p>请注意，最小子问题的解 <span class="arithmatex">\(dp[1] = 1\)</span> , <span class="arithmatex">\(dp[2] = 2\)</span> 是已知的，代表爬到第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 阶分别有 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 种方案。</p>
|
||||
<p>我们可以根据递推公式得到暴力搜索解法：</p>
|
||||
<ul>
|
||||
<li>以 <span class="arithmatex">\(dp[n]\)</span> 为起始点，<strong>递归地将一个较大问题拆解为两个较小问题的和</strong>，直至到达最小子问题 <span class="arithmatex">\(dp[1]\)</span> 和 <span class="arithmatex">\(dp[2]\)</span> 时返回。</li>
|
||||
<li>最小子问题的解 <span class="arithmatex">\(dp[1] = 1\)</span> , <span class="arithmatex">\(dp[2] = 2\)</span> 是已知的，代表爬到第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 阶分别有 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 种方案。</li>
|
||||
</ul>
|
||||
<p>观察以下代码，它和标准回溯代码都属于深度优先搜索，但更加简洁。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
@ -3812,17 +3816,18 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图展示了暴力搜索形成的递归树。对于问题 <span class="arithmatex">\(dp[n]\)</span> ，其递归树的深度为 <span class="arithmatex">\(n\)</span> ，时间复杂度为 <span class="arithmatex">\(O(2^n)\)</span> 。指数阶的运行时间增长地非常快，如果我们输入一个比较大的 <span class="arithmatex">\(n\)</span> ，则会陷入漫长的等待之中。</p>
|
||||
<p>下图展示了暴力搜索形成的递归树。对于问题 <span class="arithmatex">\(dp[n]\)</span> ，其递归树的深度为 <span class="arithmatex">\(n\)</span> ，时间复杂度为 <span class="arithmatex">\(O(2^n)\)</span> 。指数阶属于爆炸式增长，如果我们输入一个比较大的 <span class="arithmatex">\(n\)</span> ，则会陷入漫长的等待之中。</p>
|
||||
<p><img alt="爬楼梯对应递归树" src="../intro_to_dynamic_programming.assets/climbing_stairs_dfs_tree.png" /></p>
|
||||
<p align="center"> Fig. 爬楼梯对应递归树 </p>
|
||||
|
||||
<p>实际上，<strong>指数阶的时间复杂度是由于「重叠子问题」导致的</strong>。例如，问题 <span class="arithmatex">\(dp[9]\)</span> 被分解为子问题 <span class="arithmatex">\(dp[8]\)</span> 和 <span class="arithmatex">\(dp[7]\)</span> ，问题 <span class="arithmatex">\(dp[8]\)</span> 被分解为子问题 <span class="arithmatex">\(dp[7]\)</span> 和 <span class="arithmatex">\(dp[6]\)</span> ，两者都包含子问题 <span class="arithmatex">\(dp[7]\)</span> ，而子问题中又包含更小的重叠子问题，子子孙孙无穷尽也，绝大部分计算资源都浪费在这些重叠的问题上。</p>
|
||||
<p>观察上图发现，<strong>指数阶的时间复杂度是由于「重叠子问题」导致的</strong>。例如：<span class="arithmatex">\(dp[9]\)</span> 被分解为 <span class="arithmatex">\(dp[8]\)</span> 和 <span class="arithmatex">\(dp[7]\)</span> ，<span class="arithmatex">\(dp[8]\)</span> 被分解为 <span class="arithmatex">\(dp[7]\)</span> 和 <span class="arithmatex">\(dp[6]\)</span> ，两者都包含子问题 <span class="arithmatex">\(dp[7]\)</span> 。</p>
|
||||
<p>以此类推，子问题中包含更小的重叠子问题，子子孙孙无穷尽也。绝大部分计算资源都浪费在这些重叠的问题上。</p>
|
||||
<h2 id="1412">14.1.2. 方法二：记忆化搜索<a class="headerlink" href="#1412" title="Permanent link">¶</a></h2>
|
||||
<p>为了提升算法效率，<strong>我们希望所有的重叠子问题都只被计算一次</strong>。具体来说，考虑借助一个数组 <code>mem</code> 来记录每个子问题的解，并在搜索过程中这样做：</p>
|
||||
<ul>
|
||||
<p>为了提升算法效率，<strong>我们希望所有的重叠子问题都只被计算一次</strong>。为此，我们声明一个数组 <code>mem</code> 来记录每个子问题的解，并在搜索过程中这样做：</p>
|
||||
<ol>
|
||||
<li>当首次计算 <span class="arithmatex">\(dp[i]\)</span> 时，我们将其记录至 <code>mem[i]</code> ，以便之后使用；</li>
|
||||
<li>当再次需要计算 <span class="arithmatex">\(dp[i]\)</span> 时，我们便可直接从 <code>mem[i]</code> 中获取结果，从而将重叠子问题剪枝；</li>
|
||||
</ul>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:11"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JavaScript</label><label for="__tabbed_3_6">TypeScript</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label><label for="__tabbed_3_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4028,14 +4033,14 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>观察下图，<strong>经过记忆化处理后，所有重叠子问题都只需被计算一次，时间复杂度被优化至 <span class="arithmatex">\(O(n)\)</span></strong> ，这是一个巨大的飞跃。实际上，如果不考虑递归带来的额外开销，记忆化搜索解法已经几乎等同于动态规划解法的时间效率。</p>
|
||||
<p>观察下图，<strong>经过记忆化处理后，所有重叠子问题都只需被计算一次，时间复杂度被优化至 <span class="arithmatex">\(O(n)\)</span></strong> ，这是一个巨大的飞跃。</p>
|
||||
<p><img alt="记忆化搜索对应递归树" src="../intro_to_dynamic_programming.assets/climbing_stairs_dfs_memo_tree.png" /></p>
|
||||
<p align="center"> Fig. 记忆化搜索对应递归树 </p>
|
||||
|
||||
<h2 id="1413">14.1.3. 方法三：动态规划<a class="headerlink" href="#1413" title="Permanent link">¶</a></h2>
|
||||
<p><strong>记忆化搜索是一种“从顶至底”的方法</strong>：我们从原问题（根节点）开始，递归地将较大子问题分解为较小子问题，直至解已知的最小子问题（叶节点）；最终通过回溯将子问题的解逐层收集，得到原问题的解。</p>
|
||||
<p><strong>我们也可以直接“从底至顶”进行求解</strong>，得到标准的动态规划解法：从最小子问题开始，迭代地求解较大子问题，直至得到原问题的解。</p>
|
||||
<p>由于动态规划不包含回溯过程，因此无需使用递归，而可以直接基于递推实现。我们初始化一个数组 <code>dp</code> 来存储子问题的解，从最小子问题开始，逐步求解较大子问题。在以下代码中，数组 <code>dp</code> 起到了记忆化搜索中数组 <code>mem</code> 相同的记录作用。</p>
|
||||
<p><strong>记忆化搜索是一种“从顶至底”的方法</strong>：我们从原问题（根节点）开始，递归地将较大子问题分解为较小子问题，直至解已知的最小子问题（叶节点）。之后，通过回溯将子问题的解逐层收集，构建出原问题的解。</p>
|
||||
<p>与之相反，<strong>动态规划是一种“从底至顶”的方法</strong>：从最小子问题的解开始，迭代地构建更大子问题的解，直至得到原问题的解。</p>
|
||||
<p>由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无需使用递归。在以下代码中，我们初始化一个数组 <code>dp</code> 来存储子问题的解，它起到了记忆化搜索中数组 <code>mem</code> 相同的记录作用。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:11"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Java</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Python</label><label for="__tabbed_4_4">Go</label><label for="__tabbed_4_5">JavaScript</label><label for="__tabbed_4_6">TypeScript</label><label for="__tabbed_4_7">C</label><label for="__tabbed_4_8">C#</label><label for="__tabbed_4_9">Swift</label><label for="__tabbed_4_10">Zig</label><label for="__tabbed_4_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4183,7 +4188,8 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如对于爬楼梯问题，状态定义为当前所在楼梯阶数 <span class="arithmatex">\(i\)</span> 。<strong>动态规划的常用术语包括</strong>：</p>
|
||||
<p>与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如，爬楼梯问题的状态定义为当前所在楼梯阶数 <span class="arithmatex">\(i\)</span> 。</p>
|
||||
<p>总结以上，动态规划的常用术语包括：</p>
|
||||
<ul>
|
||||
<li>将数组 <code>dp</code> 称为「<span class="arithmatex">\(dp\)</span> 表」，<span class="arithmatex">\(dp[i]\)</span> 表示状态 <span class="arithmatex">\(i\)</span> 对应子问题的解；</li>
|
||||
<li>将最小子问题对应的状态（即第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 阶楼梯）称为「初始状态」；</li>
|
||||
|
|
@ -4193,7 +4199,7 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
<p align="center"> Fig. 爬楼梯的动态规划过程 </p>
|
||||
|
||||
<h2 id="1414">14.1.4. 状态压缩<a class="headerlink" href="#1414" title="Permanent link">¶</a></h2>
|
||||
<p>细心的你可能发现，<strong>由于 <span class="arithmatex">\(dp[i]\)</span> 只与 <span class="arithmatex">\(dp[i-1]\)</span> 和 <span class="arithmatex">\(dp[i-2]\)</span> 有关，因此我们无需使用一个数组 <code>dp</code> 来存储所有子问题的解</strong>，而只需两个变量滚动前进即可。如以下代码所示，由于省去了数组 <code>dp</code> 占用的空间，因此空间复杂度从 <span class="arithmatex">\(O(n)\)</span> 降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<p>细心的你可能发现，<strong>由于 <span class="arithmatex">\(dp[i]\)</span> 只与 <span class="arithmatex">\(dp[i-1]\)</span> 和 <span class="arithmatex">\(dp[i-2]\)</span> 有关，因此我们无需使用一个数组 <code>dp</code> 来存储所有子问题的解</strong>，而只需两个变量滚动前进即可。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:11"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Java</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Python</label><label for="__tabbed_5_4">Go</label><label for="__tabbed_5_5">JavaScript</label><label for="__tabbed_5_6">TypeScript</label><label for="__tabbed_5_7">C</label><label for="__tabbed_5_8">C#</label><label for="__tabbed_5_9">Swift</label><label for="__tabbed_5_10">Zig</label><label for="__tabbed_5_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4317,7 +4323,8 @@ dp[i] = dp[i-1] + dp[i-2]
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p><strong>我们将这种空间优化技巧称为「状态压缩」</strong>。在许多动态规划问题中，当前状态仅与前面有限个状态有关，不必保存所有的历史状态，这时我们可以应用状态压缩，只保留必要的状态，通过“降维”来节省内存空间。</p>
|
||||
<p>观察以上代码，由于省去了数组 <code>dp</code> 占用的空间，因此空间复杂度从 <span class="arithmatex">\(O(n)\)</span> 降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
|
||||
<p><strong>这种空间优化技巧被称为「状态压缩」</strong>。在常见的动态规划问题中，当前状态仅与前面有限个状态有关，这时我们可以应用状态压缩，只保留必要的状态，通过“降维”来节省内存空间。</p>
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3411,21 +3411,21 @@
|
|||
|
||||
<h1 id="144-0-1">14.4. 0-1 背包问题<a class="headerlink" href="#144-0-1" title="Permanent link">¶</a></h1>
|
||||
<p>背包问题是一个非常好的动态规划入门题目，是动态规划中最常见的问题形式。其具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。</p>
|
||||
<p>在本节中，我们先来学习基础的的 0-1 背包问题。</p>
|
||||
<p>在本节中，我们先来求解最常见的 0-1 背包问题。</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">\(wgt[i-1]\)</span> 、价值为 <span class="arithmatex">\(val[i-1]\)</span> ，现在有个容量为 <span class="arithmatex">\(cap\)</span> 的背包，每个物品只能选择一次，问在不超过背包容量下背包中物品的最大价值。</p>
|
||||
<p>请注意，物品编号 <span class="arithmatex">\(i\)</span> 从 <span class="arithmatex">\(1\)</span> 开始计数，数组索引从 <span class="arithmatex">\(0\)</span> 开始计数，因此物品 <span class="arithmatex">\(i\)</span> 对应重量 <span class="arithmatex">\(wgt[i-1]\)</span> 和价值 <span class="arithmatex">\(val[i-1]\)</span> 。</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> 的背包。每个物品只能选择一次，问在不超过背包容量下能放入物品的最大价值。</p>
|
||||
</div>
|
||||
<p>下图给出了一个 0-1 背包的示例数据，背包内的最大价值为 <span class="arithmatex">\(220\)</span> 。</p>
|
||||
<p>请注意，物品编号 <span class="arithmatex">\(i\)</span> 从 <span class="arithmatex">\(1\)</span> 开始计数，数组索引从 <span class="arithmatex">\(0\)</span> 开始计数，因此物品 <span class="arithmatex">\(i\)</span> 对应重量 <span class="arithmatex">\(wgt[i-1]\)</span> 和价值 <span class="arithmatex">\(val[i-1]\)</span> 。</p>
|
||||
<p><img alt="0-1 背包的示例数据" src="../knapsack_problem.assets/knapsack_example.png" /></p>
|
||||
<p align="center"> Fig. 0-1 背包的示例数据 </p>
|
||||
|
||||
<p>我们可以将 0-1 背包问题看作是一个由 <span class="arithmatex">\(n\)</span> 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。此外，该问题的目标是求解“在限定背包容量下的最大价值”，因此较大概率是个动态规划问题。我们接下来尝试求解它。</p>
|
||||
<p>我们可以将 0-1 背包问题看作是一个由 <span class="arithmatex">\(n\)</span> 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。</p>
|
||||
<p>该问题的目标是求解“在限定背包容量下的最大价值”，因此较大概率是个动态规划问题。</p>
|
||||
<p><strong>第一步：思考每轮的决策，定义状态，从而得到 <span class="arithmatex">\(dp\)</span> 表</strong></p>
|
||||
<p>在 0-1 背包问题中，不放入背包，背包容量不变；放入背包，背包容量减小。由此可得状态定义：当前物品编号 <span class="arithmatex">\(i\)</span> 和剩余背包容量 <span class="arithmatex">\(c\)</span> ，记为 <span class="arithmatex">\([i, c]\)</span> 。</p>
|
||||
<p>对于每个物品来说，不放入背包，背包容量不变；放入背包，背包容量减小。由此可得状态定义：当前物品编号 <span class="arithmatex">\(i\)</span> 和剩余背包容量 <span class="arithmatex">\(c\)</span> ，记为 <span class="arithmatex">\([i, c]\)</span> 。</p>
|
||||
<p>状态 <span class="arithmatex">\([i, c]\)</span> 对应的子问题为：<strong>前 <span class="arithmatex">\(i\)</span> 个物品在剩余容量为 <span class="arithmatex">\(c\)</span> 的背包中的最大价值</strong>，记为 <span class="arithmatex">\(dp[i, c]\)</span> 。</p>
|
||||
<p>需要求解的是 <span class="arithmatex">\(dp[n, cap]\)</span> ，因此需要一个尺寸为 <span class="arithmatex">\((n+1) \times (cap+1)\)</span> 的二维 <span class="arithmatex">\(dp\)</span> 表。</p>
|
||||
<p>待求解的是 <span class="arithmatex">\(dp[n, cap]\)</span> ，因此需要一个尺寸为 <span class="arithmatex">\((n+1) \times (cap+1)\)</span> 的二维 <span class="arithmatex">\(dp\)</span> 表。</p>
|
||||
<p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
|
||||
<p>当我们做出物品 <span class="arithmatex">\(i\)</span> 的决策后，剩余的是前 <span class="arithmatex">\(i-1\)</span> 个物品的决策。因此，状态转移分为两种情况：</p>
|
||||
<ul>
|
||||
|
|
@ -3438,18 +3438,16 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
\]</div>
|
||||
<p>需要注意的是，若当前物品重量 <span class="arithmatex">\(wgt[i - 1]\)</span> 超出剩余背包容量 <span class="arithmatex">\(c\)</span> ，则只能选择不放入背包。</p>
|
||||
<p><strong>第三步：确定边界条件和状态转移顺序</strong></p>
|
||||
<p>当无物品或无剩余背包容量时最大价值为 <span class="arithmatex">\(0\)</span> ，即所有 <span class="arithmatex">\(dp[i, 0]\)</span> 和 <span class="arithmatex">\(dp[0, c]\)</span> 都等于 <span class="arithmatex">\(0\)</span> 。</p>
|
||||
<p>当无物品或无剩余背包容量时最大价值为 <span class="arithmatex">\(0\)</span> ，即首列 <span class="arithmatex">\(dp[i, 0]\)</span> 和首行 <span class="arithmatex">\(dp[0, c]\)</span> 都等于 <span class="arithmatex">\(0\)</span> 。</p>
|
||||
<p>当前状态 <span class="arithmatex">\([i, c]\)</span> 从上方的状态 <span class="arithmatex">\([i-1, c]\)</span> 和左上方的状态 <span class="arithmatex">\([i-1, c-wgt[i-1]]\)</span> 转移而来，因此通过两层循环正序遍历整个 <span class="arithmatex">\(dp\)</span> 表即可。</p>
|
||||
<div class="admonition tip">
|
||||
<p class="admonition-title">Tip</p>
|
||||
<p>完成以上三步后，我们可以直接实现从底至顶的动态规划解法。而为了展示本题包含的重叠子问题，本文也同时给出从顶至底的暴力搜索和记忆化搜索解法。</p>
|
||||
</div>
|
||||
<p>根据以上分析，我们接下来按顺序实现暴力搜索、记忆化搜索、动态规划解法。</p>
|
||||
<h3 id="_1">方法一：暴力搜索<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>搜索代码包含以下要素：</p>
|
||||
<ul>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, c]\)</span> ；<strong>返回值</strong>：子问题的解 <span class="arithmatex">\(dp[i, c]\)</span> 。</li>
|
||||
<li><strong>终止条件</strong>：当物品编号越界 <span class="arithmatex">\(i = 0\)</span> 或背包剩余容量为 <span class="arithmatex">\(0\)</span> 时，终止递归并返回价值 <span class="arithmatex">\(0\)</span> 。</li>
|
||||
<li><strong>剪枝</strong>：若当前物品重量超出背包剩余容量，则只能不放入背包。</li>
|
||||
<li><strong>递归参数</strong>：状态 <span class="arithmatex">\([i, c]\)</span> ；</li>
|
||||
<li><strong>返回值</strong>：子问题的解 <span class="arithmatex">\(dp[i, c]\)</span> ；</li>
|
||||
<li><strong>终止条件</strong>：当物品编号越界 <span class="arithmatex">\(i = 0\)</span> 或背包剩余容量为 <span class="arithmatex">\(0\)</span> 时，终止递归并返回价值 <span class="arithmatex">\(0\)</span> ；</li>
|
||||
<li><strong>剪枝</strong>：若当前物品重量超出背包剩余容量，则只能不放入背包；</li>
|
||||
</ul>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
@ -3601,13 +3599,14 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>如下图所示，由于每个物品都会产生不选和选两条搜索分支，因此最差时间复杂度为 <span class="arithmatex">\(O(2^n)\)</span> 。</p>
|
||||
<p>观察递归树，容易发现其中存在一些「重叠子问题」，例如 <span class="arithmatex">\(dp[1, 10]\)</span> 等。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。</p>
|
||||
<p>如下图所示，由于每个物品都会产生不选和选两条搜索分支，因此时间复杂度为 <span class="arithmatex">\(O(2^n)\)</span> 。</p>
|
||||
<p>观察递归树，容易发现其中存在重叠子问题，例如 <span class="arithmatex">\(dp[1, 10]\)</span> 等。而当物品较多、背包容量较大，尤其是相同重量的物品较多时，重叠子问题的数量将会大幅增多。</p>
|
||||
<p><img alt="0-1 背包的暴力搜索递归树" src="../knapsack_problem.assets/knapsack_dfs.png" /></p>
|
||||
<p align="center"> Fig. 0-1 背包的暴力搜索递归树 </p>
|
||||
|
||||
<h3 id="_2">方法二：记忆化搜索<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>为了防止重复求解重叠子问题，我们借助一个记忆列表 <code>mem</code> 来记录子问题的解，其中 <code>mem[i][c]</code> 对应解 <span class="arithmatex">\(dp[i, c]\)</span> 。</p>
|
||||
<p>为了保证重叠子问题只被计算一次，我们借助记忆列表 <code>mem</code> 来记录子问题的解，其中 <code>mem[i][c]</code> 对应 <span class="arithmatex">\(dp[i, c]\)</span> 。</p>
|
||||
<p>引入记忆化之后，<strong>时间复杂度取决于子问题数量</strong>，也就是 <span class="arithmatex">\(O(n \times cap)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3794,12 +3793,11 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>引入记忆化之后，所有子问题都只被计算一次，<strong>因此时间复杂度取决于子问题数量</strong>，也就是 <span class="arithmatex">\(O(n \times cap)\)</span> 。</p>
|
||||
<p><img alt="0-1 背包的记忆化搜索递归树" src="../knapsack_problem.assets/knapsack_dfs_mem.png" /></p>
|
||||
<p align="center"> Fig. 0-1 背包的记忆化搜索递归树 </p>
|
||||
|
||||
<h3 id="_3">方法三：动态规划<a class="headerlink" href="#_3" title="Permanent link">¶</a></h3>
|
||||
<p>动态规划解法本质上就是在状态转移中填充 <span class="arithmatex">\(dp\)</span> 表的过程，代码如下所示。</p>
|
||||
<p>动态规划实质上就是在状态转移中填充 <span class="arithmatex">\(dp\)</span> 表的过程，代码如下所示。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:11"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JavaScript</label><label for="__tabbed_3_6">TypeScript</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label><label for="__tabbed_3_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3973,7 +3971,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>如下图所示，时间复杂度由数组 <code>dp</code> 大小决定，为 <span class="arithmatex">\(O(n \times cap)\)</span> 。</p>
|
||||
<p>如下图所示，时间复杂度和空间复杂度都由数组 <code>dp</code> 大小决定，即 <span class="arithmatex">\(O(n \times cap)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:14"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><input id="__tabbed_4_12" name="__tabbed_4" type="radio" /><input id="__tabbed_4_13" name="__tabbed_4" type="radio" /><input id="__tabbed_4_14" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1"><1></label><label for="__tabbed_4_2"><2></label><label for="__tabbed_4_3"><3></label><label for="__tabbed_4_4"><4></label><label for="__tabbed_4_5"><5></label><label for="__tabbed_4_6"><6></label><label for="__tabbed_4_7"><7></label><label for="__tabbed_4_8"><8></label><label for="__tabbed_4_9"><9></label><label for="__tabbed_4_10"><10></label><label for="__tabbed_4_11"><11></label><label for="__tabbed_4_12"><12></label><label for="__tabbed_4_13"><13></label><label for="__tabbed_4_14"><14></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4021,9 +4019,13 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="_4">状态压缩<a class="headerlink" href="#_4" title="Permanent link">¶</a></h3>
|
||||
<p>最后考虑状态压缩。以上代码中的数组 <code>dp</code> 占用 <span class="arithmatex">\(O(n \times cap)\)</span> 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 <span class="arithmatex">\(O(n^2)\)</span> 将低至 <span class="arithmatex">\(O(n)\)</span> 。代码省略，有兴趣的同学可以自行实现。</p>
|
||||
<p>那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由正上方或左上方的格子转移过来的。假设只有一个数组，当遍历到第 <span class="arithmatex">\(i\)</span> 行时，该数组存储的仍然是第 <span class="arithmatex">\(i-1\)</span> 行的状态，<strong>为了避免左方区域的格子在状态转移中被覆盖，应该采取倒序遍历</strong>。</p>
|
||||
<p>以下动画展示了在单个数组下从第 <span class="arithmatex">\(i=1\)</span> 行转换至第 <span class="arithmatex">\(i=2\)</span> 行的过程。建议你思考一下正序遍历和倒序遍历的区别。</p>
|
||||
<p>由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 <span class="arithmatex">\(O(n^2)\)</span> 将低至 <span class="arithmatex">\(O(n)\)</span> 。</p>
|
||||
<p>进一步思考，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由正上方或左上方的格子转移过来的。假设只有一个数组，当开始遍历第 <span class="arithmatex">\(i\)</span> 行时，该数组存储的仍然是第 <span class="arithmatex">\(i-1\)</span> 行的状态。</p>
|
||||
<ul>
|
||||
<li>如果采取正序遍历，那么遍历到 <span class="arithmatex">\(dp[i, j]\)</span> 时，左上方 <span class="arithmatex">\(dp[i-1, 1]\)</span> ~ <span class="arithmatex">\(dp[i-1, j-1]\)</span> 值可能已经被覆盖，此时就无法得到正确的状态转移结果。</li>
|
||||
<li>如果采取倒序遍历，则不会发生覆盖问题，状态转移可以正确进行。</li>
|
||||
</ul>
|
||||
<p>以下动画展示了在单个数组下从第 <span class="arithmatex">\(i = 1\)</span> 行转换至第 <span class="arithmatex">\(i = 2\)</span> 行的过程。请思考正序遍历和倒序遍历的区别。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:6"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1"><1></label><label for="__tabbed_5_2"><2></label><label for="__tabbed_5_3"><3></label><label for="__tabbed_5_4"><4></label><label for="__tabbed_5_5"><5></label><label for="__tabbed_5_6"><6></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4046,7 +4048,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>如以下代码所示，我们仅需将数组 <code>dp</code> 的第一维 <span class="arithmatex">\(i\)</span> 直接删除，并且将内循环修改为倒序遍历即可。</p>
|
||||
<p>在代码实现中，我们仅需将数组 <code>dp</code> 的第一维 <span class="arithmatex">\(i\)</span> 直接删除，并且把内循环更改为倒序遍历即可。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="6:11"><input checked="checked" id="__tabbed_6_1" name="__tabbed_6" type="radio" /><input id="__tabbed_6_2" name="__tabbed_6" type="radio" /><input id="__tabbed_6_3" name="__tabbed_6" type="radio" /><input id="__tabbed_6_4" name="__tabbed_6" type="radio" /><input id="__tabbed_6_5" name="__tabbed_6" type="radio" /><input id="__tabbed_6_6" name="__tabbed_6" type="radio" /><input id="__tabbed_6_7" name="__tabbed_6" type="radio" /><input id="__tabbed_6_8" name="__tabbed_6" type="radio" /><input id="__tabbed_6_9" name="__tabbed_6" type="radio" /><input id="__tabbed_6_10" name="__tabbed_6" type="radio" /><input id="__tabbed_6_11" name="__tabbed_6" type="radio" /><div class="tabbed-labels"><label for="__tabbed_6_1">Java</label><label for="__tabbed_6_2">C++</label><label for="__tabbed_6_3">Python</label><label for="__tabbed_6_4">Go</label><label for="__tabbed_6_5">JavaScript</label><label for="__tabbed_6_6">TypeScript</label><label for="__tabbed_6_7">C</label><label for="__tabbed_6_8">C#</label><label for="__tabbed_6_9">Swift</label><label for="__tabbed_6_10">Zig</label><label for="__tabbed_6_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3309,24 +3309,27 @@
|
|||
|
||||
<h1 id="147">14.7. 小结<a class="headerlink" href="#147" title="Permanent link">¶</a></h1>
|
||||
<ul>
|
||||
<li>动态规划通过将原问题分解为子问题来求解问题，并通过存储子问题的解来规避重复计算，实现高效的计算效率。子问题分解是一种通用的算法思路，在分治、动态规划、回溯中具有不同的性质。</li>
|
||||
<li>动态规划对问题进行分解，并通过存储子问题的解来规避重复计算，实现高效的计算效率。</li>
|
||||
<li>不考虑时间的前提下，所有动态规划问题都可以用回溯（暴力搜索）进行求解，但递归树中存在大量的重叠子问题，效率极低。通过引入记忆化列表，可以存储所有计算过的子问题的解，从而保证重叠子问题只被计算一次。</li>
|
||||
<li>记忆化递归是一种从顶至底的递归式解法，而与之对应的动态规划是一种从底至顶的递推式解法，就像是在“填写表格”一样。由于当前状态仅依赖于某些局部状态，因此我们可以消除 <span class="arithmatex">\(dp\)</span> 表的一个维度，从而降低空间复杂度。</li>
|
||||
<li>动态规划问题的三大特性：重叠子问题、最优子结构、无后效性。如果原问题的最优解可以从子问题的最优解构建得来，则此问题就具有最优子结构。无后效性指对于一个状态，其未来发展只与该状态有关，与其所经历的过去的所有状态无关。许多组合优化问题都不具有无后效性，无法使用动态规划快速求解。</li>
|
||||
<li>记忆化递归是一种从顶至底的递归式解法，而与之对应的动态规划是一种从底至顶的递推式解法，其如同“填写表格”一样。由于当前状态仅依赖于某些局部状态，因此我们可以消除 <span class="arithmatex">\(dp\)</span> 表的一个维度，从而降低空间复杂度。</li>
|
||||
<li>子问题分解是一种通用的算法思路，在分治、动态规划、回溯中具有不同的性质。</li>
|
||||
<li>动态规划问题的三大特性：重叠子问题、最优子结构、无后效性。</li>
|
||||
<li>如果原问题的最优解可以从子问题的最优解构建得来，则它就具有最优子结构。</li>
|
||||
<li>无后效性指对于一个状态，其未来发展只与该状态有关，与其所经历的过去的所有状态无关。许多组合优化问题都不具有无后效性，无法使用动态规划快速求解。</li>
|
||||
</ul>
|
||||
<p><strong>背包问题</strong></p>
|
||||
<ul>
|
||||
<li>背包问题是最典型的动态规划题目，具有 0-1 背包、完全背包、多重背包等变种问题。</li>
|
||||
<li>0-1 背包的状态定义为前 <span class="arithmatex">\(i\)</span> 个物品在剩余容量为 <span class="arithmatex">\(c\)</span> 的背包中的最大价值。这是一种常见的定义方式。不放入物品 <span class="arithmatex">\(i\)</span> ，状态转移至 <span class="arithmatex">\([i-1, c]\)</span> ，放入则转移至 <span class="arithmatex">\([i-1, c-wgt[i-1]]\)</span> ，由此便得到最优子结构，并构建出状态转移方程。对于状态压缩，由于每个状态依赖正上方和左上方的状态，因此需要倒序遍历列表，避免左上方状态被覆盖。</li>
|
||||
<li>完全背包的每种物品有无数个，因此在放置物品 <span class="arithmatex">\(i\)</span> 后，状态转移至 <span class="arithmatex">\([i, c-wgt[i-1]]\)</span> 。由于状态依赖于正上方和正左方的状态，因此状态压缩后应该正序遍历。</li>
|
||||
<li>零钱兑换问题是完全背包的一个变种。为从求“最大“价值变为求“最小”硬币数量，我们将状态转移方程中的 <span class="arithmatex">\(\max()\)</span> 改为 <span class="arithmatex">\(\min()\)</span> 。为从求“不超过”背包容量到求“恰好”凑出目标金额，我们使用 <span class="arithmatex">\(amt + 1\)</span> 来表示“无法凑出目标金额”的无效解。</li>
|
||||
<li>0-1 背包的状态定义为前 <span class="arithmatex">\(i\)</span> 个物品在剩余容量为 <span class="arithmatex">\(c\)</span> 的背包中的最大价值。根据不放入背包和放入背包两种决策，可得到最优子结构，并构建出状态转移方程。在状态压缩中，由于每个状态依赖正上方和左上方的状态，因此需要倒序遍历列表，避免左上方状态被覆盖。</li>
|
||||
<li>完全背包的每种物品的选取数量无限制，因此选择放入物品的状态转移与 0-1 背包不同。由于状态依赖于正上方和正左方的状态，因此在状态压缩中应当正序遍历。</li>
|
||||
<li>零钱兑换问题是完全背包的一个变种。它从求“最大”价值变为求“最小”硬币数量，因此状态转移方程中的 <span class="arithmatex">\(\max()\)</span> 应改为 <span class="arithmatex">\(\min()\)</span> 。从求“不超过”背包容量到求“恰好”凑出目标金额，因此使用 <span class="arithmatex">\(amt + 1\)</span> 来表示“无法凑出目标金额”的无效解。</li>
|
||||
<li>零钱兑换 II 问题从求“最少硬币数量”改为求“硬币组合数量”，状态转移方程相应地从 <span class="arithmatex">\(\min()\)</span> 改为求和运算符。</li>
|
||||
</ul>
|
||||
<p><strong>编辑距离问题</strong></p>
|
||||
<ul>
|
||||
<li>编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。</li>
|
||||
<li>编辑距离问题的状态定义为将 <span class="arithmatex">\(s\)</span> 的前 <span class="arithmatex">\(i\)</span> 个字符更改为 <span class="arithmatex">\(t\)</span> 的前 <span class="arithmatex">\(j\)</span> 个字符所需的最少编辑步数。考虑字符 <span class="arithmatex">\(s[i]\)</span> 和 <span class="arithmatex">\(t[j]\)</span> ，具有三种决策：在 <span class="arithmatex">\(s[i-1]\)</span> 之后添加 <span class="arithmatex">\(t[j-1]\)</span> 、删除 <span class="arithmatex">\(s[i-1]\)</span> 、将 <span class="arithmatex">\(s[i-1]\)</span> 替换为 <span class="arithmatex">\(t[j-1]\)</span> ，它们都有相应的剩余子问题，据此就可以找出最优子结构与构建状态转移方程。值得注意的是，当 <span class="arithmatex">\(s[i] = t[j]\)</span> 时，无需编辑当前字符，直接跳过即可。</li>
|
||||
<li>在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。利用一个变量暂存左上方状态，即转化至完全背包地情况，可以在状态压缩后使用正序遍历。</li>
|
||||
<li>编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，其定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。</li>
|
||||
<li>编辑距离问题的状态定义为将 <span class="arithmatex">\(s\)</span> 的前 <span class="arithmatex">\(i\)</span> 个字符更改为 <span class="arithmatex">\(t\)</span> 的前 <span class="arithmatex">\(j\)</span> 个字符所需的最少编辑步数。当 <span class="arithmatex">\(s[i] \ne t[j]\)</span> 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 <span class="arithmatex">\(s[i] = t[j]\)</span> 时，无需编辑当前字符。</li>
|
||||
<li>在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。为此，我们利用一个变量暂存左上方状态，从而转化到与完全背包等价的情况，可以在状态压缩后进行正序遍历。</li>
|
||||
</ul>
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2861,10 +2861,10 @@
|
|||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1451" class="md-nav__link">
|
||||
14.5.1. 完全背包问题
|
||||
14.5.1. 完全背包
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="14.5.1. 完全背包问题">
|
||||
<nav class="md-nav" aria-label="14.5.1. 完全背包">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
|
|
@ -3413,10 +3413,10 @@
|
|||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1451" class="md-nav__link">
|
||||
14.5.1. 完全背包问题
|
||||
14.5.1. 完全背包
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="14.5.1. 完全背包问题">
|
||||
<nav class="md-nav" aria-label="14.5.1. 完全背包">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
|
|
@ -3516,11 +3516,11 @@
|
|||
|
||||
|
||||
<h1 id="145">14.5. 完全背包问题<a class="headerlink" href="#145" title="Permanent link">¶</a></h1>
|
||||
<p>在本节，我们先求解 0-1 背包的一个变种问题：完全背包问题；再了解完全背包的一种特例问题：零钱兑换。</p>
|
||||
<h2 id="1451">14.5.1. 完全背包问题<a class="headerlink" href="#1451" title="Permanent link">¶</a></h2>
|
||||
<p>在本节中，我们先求解另一个常见的背包问题：完全背包，再了解它的一种特例：零钱兑换。</p>
|
||||
<h2 id="1451">14.5.1. 完全背包<a class="headerlink" href="#1451" title="Permanent link">¶</a></h2>
|
||||
<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>，问在不超过背包容量下能放入物品的最大价值。</p>
|
||||
</div>
|
||||
<p><img alt="完全背包问题的示例数据" src="../unbounded_knapsack_problem.assets/unbounded_knapsack_example.png" /></p>
|
||||
<p align="center"> Fig. 完全背包问题的示例数据 </p>
|
||||
|
|
@ -3533,14 +3533,14 @@
|
|||
<p>这就导致了状态转移的变化，对于状态 <span class="arithmatex">\([i, c]\)</span> 有：</p>
|
||||
<ul>
|
||||
<li><strong>不放入物品 <span class="arithmatex">\(i\)</span></strong> ：与 0-1 背包相同，转移至 <span class="arithmatex">\([i-1, c]\)</span> ；</li>
|
||||
<li><strong>放入物品 <span class="arithmatex">\(i\)</span></strong> ：状态转移至 <span class="arithmatex">\([i, c-wgt[i-1]]\)</span> 而非 0-1 背包的 <span class="arithmatex">\([i-1, c-wgt[i-1]]\)</span> ；</li>
|
||||
<li><strong>放入物品 <span class="arithmatex">\(i\)</span></strong> ：与 0-1 背包不同，转移至 <span class="arithmatex">\([i, c-wgt[i-1]]\)</span> ；</li>
|
||||
</ul>
|
||||
<p>因此状态转移方程变为：</p>
|
||||
<p>从而状态转移方程变为：</p>
|
||||
<div class="arithmatex">\[
|
||||
dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
|
||||
\]</div>
|
||||
<h3 id="_1">代码实现<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>对比两道题目的动态规划代码，状态转移中有一处从 <span class="arithmatex">\(i-1\)</span> 变为 <span class="arithmatex">\(i\)</span> ，其余完全一致。</p>
|
||||
<p>对比两道题目的代码，状态转移中有一处从 <span class="arithmatex">\(i-1\)</span> 变为 <span class="arithmatex">\(i\)</span> ，其余完全一致。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3715,7 +3715,8 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="_2">状态压缩<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>由于当前状态是从左边和上边的状态转移而来，<strong>因此状态压缩后应该对 <span class="arithmatex">\(dp\)</span> 表中的每一行采取正序遍历</strong>，这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解为什么要改为正序遍历。</p>
|
||||
<p>由于当前状态是从左边和上边的状态转移而来，<strong>因此状态压缩后应该对 <span class="arithmatex">\(dp\)</span> 表中的每一行采取正序遍历</strong>。</p>
|
||||
<p>这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解两者的区别。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:6"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3916,14 +3917,13 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
|
|||
<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> ，<strong>每种硬币可以重复选取</strong>，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 <span class="arithmatex">\(-1\)</span> 。</p>
|
||||
</div>
|
||||
<p>如下图所示，凑出 <span class="arithmatex">\(11\)</span> 元最少需要 <span class="arithmatex">\(3\)</span> 枚硬币，方案为 <span class="arithmatex">\(1 + 2 + 5 = 11\)</span> 。</p>
|
||||
<p><img alt="零钱兑换问题的示例数据" src="../unbounded_knapsack_problem.assets/coin_change_example.png" /></p>
|
||||
<p align="center"> Fig. 零钱兑换问题的示例数据 </p>
|
||||
|
||||
<p><strong>零钱兑换问题可以看作是完全背包问题的一种特殊情况</strong>，两者具有以下联系与不同点：</p>
|
||||
<p><strong>零钱兑换可以看作是完全背包的一种特殊情况</strong>，两者具有以下联系与不同点：</p>
|
||||
<ul>
|
||||
<li>两道题可以相互转换，“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”；</li>
|
||||
<li>目标不同，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量；</li>
|
||||
<li>优化目标相反，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量；</li>
|
||||
<li>背包问题是求“不超过”背包容量下的解，零钱兑换是求“恰好”凑到目标金额的解；</li>
|
||||
</ul>
|
||||
<p><strong>第一步：思考每轮的决策，定义状态，从而得到 <span class="arithmatex">\(dp\)</span> 表</strong></p>
|
||||
|
|
@ -3933,17 +3933,18 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
|
|||
<p>与完全背包的状态转移方程基本相同，不同点在于：</p>
|
||||
<ul>
|
||||
<li>本题要求最小值，因此需将运算符 <span class="arithmatex">\(\max()\)</span> 更改为 <span class="arithmatex">\(\min()\)</span> ；</li>
|
||||
<li>优化主体是“硬币数量”而非”商品价值“，因此在选中硬币时执行 <span class="arithmatex">\(+1\)</span> 即可；</li>
|
||||
<li>优化主体是硬币数量而非商品价值，因此在选中硬币时执行 <span class="arithmatex">\(+1\)</span> 即可；</li>
|
||||
</ul>
|
||||
<div class="arithmatex">\[
|
||||
dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
|
||||
\]</div>
|
||||
<p><strong>第三步：确定边界条件和状态转移顺序</strong></p>
|
||||
<p>当目标金额为 <span class="arithmatex">\(0\)</span> 时，凑出它的最少硬币个数为 <span class="arithmatex">\(0\)</span> ，即所有 <span class="arithmatex">\(dp[i, 0]\)</span> 都等于 <span class="arithmatex">\(0\)</span> 。当无硬币时，<strong>无法凑出任意 <span class="arithmatex">\(> 0\)</span> 的目标金额</strong>，即是无效解。为使状态转移方程中的 <span class="arithmatex">\(\min()\)</span> 函数能够识别并过滤无效解，我们考虑使用 <span class="arithmatex">\(+ \infty\)</span> 来表示它们，即令所有 <span class="arithmatex">\(dp[0, a]\)</span> 都等于 <span class="arithmatex">\(+ \infty\)</span> 。</p>
|
||||
<p>当目标金额为 <span class="arithmatex">\(0\)</span> 时，凑出它的最少硬币个数为 <span class="arithmatex">\(0\)</span> ，即首列所有 <span class="arithmatex">\(dp[i, 0]\)</span> 都等于 <span class="arithmatex">\(0\)</span> 。</p>
|
||||
<p>当无硬币时，<strong>无法凑出任意 <span class="arithmatex">\(> 0\)</span> 的目标金额</strong>，即是无效解。为使状态转移方程中的 <span class="arithmatex">\(\min()\)</span> 函数能够识别并过滤无效解，我们考虑使用 <span class="arithmatex">\(+ \infty\)</span> 来表示它们，即令首行所有 <span class="arithmatex">\(dp[0, a]\)</span> 都等于 <span class="arithmatex">\(+ \infty\)</span> 。</p>
|
||||
<h3 id="_3">代码实现<a class="headerlink" href="#_3" title="Permanent link">¶</a></h3>
|
||||
<p>然而，大多数编程语言并未提供 <span class="arithmatex">\(+ \infty\)</span> 变量，因此只能使用整型 <code>int</code> 的最大值来代替，而这又会导致大数越界：<strong>当 <span class="arithmatex">\(dp[i, a - coins[i-1]]\)</span> 是无效解时，再执行 <span class="arithmatex">\(+ 1\)</span> 操作会发生溢出</strong>。</p>
|
||||
<p>为解决该问题，我们采用一个不可能达到的大数字 <span class="arithmatex">\(amt + 1\)</span> 来表示无效解，因为凑出 <span class="arithmatex">\(amt\)</span> 的硬币个数最多为 <span class="arithmatex">\(amt\)</span> 个。</p>
|
||||
<p>在最后返回前，判断 <span class="arithmatex">\(dp[n, amt]\)</span> 是否等于 <span class="arithmatex">\(amt + 1\)</span> ，若是则返回 <span class="arithmatex">\(-1\)</span> ，代表无法凑出目标金额。</p>
|
||||
<p>大多数编程语言并未提供 <span class="arithmatex">\(+ \infty\)</span> 变量，只能使用整型 <code>int</code> 的最大值来代替。而这又会导致大数越界：状态转移方程中的 <span class="arithmatex">\(+ 1\)</span> 操作可能发生溢出。</p>
|
||||
<p>为此，我们采用数字 <span class="arithmatex">\(amt + 1\)</span> 来表示无效解，因为凑出 <span class="arithmatex">\(amt\)</span> 的硬币个数最多为 <span class="arithmatex">\(amt\)</span> 个。</p>
|
||||
<p>最后返回前，判断 <span class="arithmatex">\(dp[n, amt]\)</span> 是否等于 <span class="arithmatex">\(amt + 1\)</span> ，若是则返回 <span class="arithmatex">\(-1\)</span> ，代表无法凑出目标金额。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:11"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Java</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Python</label><label for="__tabbed_4_4">Go</label><label for="__tabbed_4_5">JavaScript</label><label for="__tabbed_4_6">TypeScript</label><label for="__tabbed_4_7">C</label><label for="__tabbed_4_8">C#</label><label for="__tabbed_4_9">Swift</label><label for="__tabbed_4_10">Zig</label><label for="__tabbed_4_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4158,7 +4159,7 @@ dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>下图展示了零钱兑换的动态规划过程。</p>
|
||||
<p>下图展示了零钱兑换的动态规划过程，和完全背包非常相似。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:15"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><input id="__tabbed_5_12" name="__tabbed_5" type="radio" /><input id="__tabbed_5_13" name="__tabbed_5" type="radio" /><input id="__tabbed_5_14" name="__tabbed_5" type="radio" /><input id="__tabbed_5_15" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1"><1></label><label for="__tabbed_5_2"><2></label><label for="__tabbed_5_3"><3></label><label for="__tabbed_5_4"><4></label><label for="__tabbed_5_5"><5></label><label for="__tabbed_5_6"><6></label><label for="__tabbed_5_7"><7></label><label for="__tabbed_5_8"><8></label><label for="__tabbed_5_9"><9></label><label for="__tabbed_5_10"><10></label><label for="__tabbed_5_11"><11></label><label for="__tabbed_5_12"><12></label><label for="__tabbed_5_13"><13></label><label for="__tabbed_5_14"><14></label><label for="__tabbed_5_15"><15></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4209,7 +4210,7 @@ dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="_4">状态压缩<a class="headerlink" href="#_4" title="Permanent link">¶</a></h3>
|
||||
<p>由于零钱兑换和完全背包的状态转移方程如出一辙，因此状态压缩方式也相同。</p>
|
||||
<p>零钱兑换的状态压缩的处理方式和完全背包一致。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="6:11"><input checked="checked" id="__tabbed_6_1" name="__tabbed_6" type="radio" /><input id="__tabbed_6_2" name="__tabbed_6" type="radio" /><input id="__tabbed_6_3" name="__tabbed_6" type="radio" /><input id="__tabbed_6_4" name="__tabbed_6" type="radio" /><input id="__tabbed_6_5" name="__tabbed_6" type="radio" /><input id="__tabbed_6_6" name="__tabbed_6" type="radio" /><input id="__tabbed_6_7" name="__tabbed_6" type="radio" /><input id="__tabbed_6_8" name="__tabbed_6" type="radio" /><input id="__tabbed_6_9" name="__tabbed_6" type="radio" /><input id="__tabbed_6_10" name="__tabbed_6" type="radio" /><input id="__tabbed_6_11" name="__tabbed_6" type="radio" /><div class="tabbed-labels"><label for="__tabbed_6_1">Java</label><label for="__tabbed_6_2">C++</label><label for="__tabbed_6_3">Python</label><label for="__tabbed_6_4">Go</label><label for="__tabbed_6_5">JavaScript</label><label for="__tabbed_6_6">TypeScript</label><label for="__tabbed_6_7">C</label><label for="__tabbed_6_8">C#</label><label for="__tabbed_6_9">Swift</label><label for="__tabbed_6_10">Zig</label><label for="__tabbed_6_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -4421,7 +4422,7 @@ dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1)
|
|||
<div class="arithmatex">\[
|
||||
dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]]
|
||||
\]</div>
|
||||
<p>当目标金额为 <span class="arithmatex">\(0\)</span> 时，无需选择任何硬币即可凑出目标金额，因此应将所有 <span class="arithmatex">\(dp[i, 0]\)</span> 都初始化为 <span class="arithmatex">\(1\)</span> 。当无硬币时，无法凑出任何 <span class="arithmatex">\(>0\)</span> 的目标金额，因此所有 <span class="arithmatex">\(dp[0, a]\)</span> 都等于 <span class="arithmatex">\(0\)</span> 。</p>
|
||||
<p>当目标金额为 <span class="arithmatex">\(0\)</span> 时，无需选择任何硬币即可凑出目标金额，因此应将首列所有 <span class="arithmatex">\(dp[i, 0]\)</span> 都初始化为 <span class="arithmatex">\(1\)</span> 。当无硬币时，无法凑出任何 <span class="arithmatex">\(>0\)</span> 的目标金额，因此首行所有 <span class="arithmatex">\(dp[0, a]\)</span> 都等于 <span class="arithmatex">\(0\)</span> 。</p>
|
||||
<h3 id="_5">代码实现<a class="headerlink" href="#_5" title="Permanent link">¶</a></h3>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="7:11"><input checked="checked" id="__tabbed_7_1" name="__tabbed_7" type="radio" /><input id="__tabbed_7_2" name="__tabbed_7" type="radio" /><input id="__tabbed_7_3" name="__tabbed_7" type="radio" /><input id="__tabbed_7_4" name="__tabbed_7" type="radio" /><input id="__tabbed_7_5" name="__tabbed_7" type="radio" /><input id="__tabbed_7_6" name="__tabbed_7" type="radio" /><input id="__tabbed_7_7" name="__tabbed_7" type="radio" /><input id="__tabbed_7_8" name="__tabbed_7" type="radio" /><input id="__tabbed_7_9" name="__tabbed_7" type="radio" /><input id="__tabbed_7_10" name="__tabbed_7" type="radio" /><input id="__tabbed_7_11" name="__tabbed_7" type="radio" /><div class="tabbed-labels"><label for="__tabbed_7_1">Java</label><label for="__tabbed_7_2">C++</label><label for="__tabbed_7_3">Python</label><label for="__tabbed_7_4">Go</label><label for="__tabbed_7_5">JavaScript</label><label for="__tabbed_7_6">TypeScript</label><label for="__tabbed_7_7">C</label><label for="__tabbed_7_8">C#</label><label for="__tabbed_7_9">Swift</label><label for="__tabbed_7_10">Zig</label><label for="__tabbed_7_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
|
|
|||
|
|
@ -3396,16 +3396,16 @@
|
|||
|
||||
|
||||
<h1 id="152">15.2. 分数背包问题<a class="headerlink" href="#152" title="Permanent link">¶</a></h1>
|
||||
<p>分数背包是 0-1 背包问题的一个变种问题。</p>
|
||||
<p>分数背包是 0-1 背包的一个变种问题。</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">\(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>，问在不超过背包容量下背包中物品的最大价值。</p>
|
||||
</div>
|
||||
<p><img alt="分数背包问题的示例数据" src="../fractional_knapsack_problem.assets/fractional_knapsack_example.png" /></p>
|
||||
<p align="center"> Fig. 分数背包问题的示例数据 </p>
|
||||
|
||||
<p>本题和 0-1 背包整体上非常相似，状态包含当前物品 <span class="arithmatex">\(i\)</span> 和容量 <span class="arithmatex">\(c\)</span> ，目标是求不超过背包容量下的最大价值。</p>
|
||||
<p>不同点在于，本题允许只选择物品的一部分，我们可以对物品任意地进行切分，并按照重量比例来计算物品价值，因此有：</p>
|
||||
<p>不同点在于，本题允许只选择物品的一部分，<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">\(w\)</span> ，则背包增加的价值为 <span class="arithmatex">\(w \times val[i-1] / wgt[i-1]\)</span> ；</li>
|
||||
|
|
@ -3424,7 +3424,7 @@
|
|||
<p align="center"> Fig. 分数背包的贪心策略 </p>
|
||||
|
||||
<h3 id="_2">代码实现<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>我们构建了一个物品类 <code>Item</code> ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解。</p>
|
||||
<p>我们建立了一个物品类 <code>Item</code> ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3646,12 +3646,14 @@
|
|||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>最差情况下，需要遍历整个物品列表，<strong>因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> ，其中 <span class="arithmatex">\(n\)</span> 为物品数量。由于初始化了一个 <code>Item</code> 对象列表，<strong>因此空间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> 。</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">正确性证明<a class="headerlink" href="#_3" title="Permanent link">¶</a></h3>
|
||||
<p>采用反证法。假设物品 <span class="arithmatex">\(x\)</span> 是单位价值最高的物品，使用某算法求得最大价值为 <span class="arithmatex">\(res\)</span> ，但该解中不包含物品 <span class="arithmatex">\(x\)</span> 。</p>
|
||||
<p>现在从背包中拿出单位重量的任意物品，并替换为单位重量的物品 <span class="arithmatex">\(x\)</span> 。由于物品 <span class="arithmatex">\(x\)</span> 的单位价值最高，因此替换后的总价值一定大于 <span class="arithmatex">\(res\)</span> 。<strong>这与 <span class="arithmatex">\(res\)</span> 是最优解矛盾，说明最优解中必须包含物品 <span class="arithmatex">\(x\)</span> 。</strong></p>
|
||||
<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>如下图所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。这个类比可以帮助我们从几何角度清晰地看到贪心策略的有效性。</p>
|
||||
<p>如下图所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。</p>
|
||||
<p>通过这个类比，我们可以从几何角度理解贪心策略的有效性。</p>
|
||||
<p><img alt="分数背包问题的几何表示" src="../fractional_knapsack_problem.assets/fractional_knapsack_area_chart.png" /></p>
|
||||
<p align="center"> Fig. 分数背包问题的几何表示 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -3410,13 +3410,13 @@
|
|||
|
||||
|
||||
<h1 id="151">15.1. 贪心算法<a class="headerlink" href="#151" title="Permanent link">¶</a></h1>
|
||||
<p>贪心算法是一种常见的解决优化问题的算法，其基本思想是在问题的每个决策阶段，都选择当前看起来最优的选择，即“贪心”地做出局部最优的决策，以期望获得全局最优解。贪心算法因其简洁、高效的特性，在许多实际问题中都有着广泛的应用。</p>
|
||||
<p>贪心算法和动态规划都是解决优化问题的常用策略，它们有一些相似之处，比如都依赖最优子结构性质。两者的不同点在于：</p>
|
||||
<p>贪心算法是一种常见的解决优化问题的算法，其基本思想是在问题的每个决策阶段，都选择当前看起来最优的选择，即贪心地做出局部最优的决策，以期望获得全局最优解。贪心算法简洁且高效，在许多实际问题中都有着广泛的应用。</p>
|
||||
<p>贪心算法和动态规划都常用于解决优化问题。它们有一些相似之处，比如都依赖最优子结构性质。两者的不同点在于：</p>
|
||||
<ul>
|
||||
<li><strong>动态规划会根据之前阶段的所有决策来考虑当前决策</strong>，并使用过去子问题的解来构建当前子问题的解。</li>
|
||||
<li><strong>贪心算法从不重新考虑过去的决策</strong>，而是一路向前地进行贪心选择，不断缩小问题范围，直至问题被解决。</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>
|
||||
|
|
@ -3425,7 +3425,7 @@
|
|||
<p><img alt="零钱兑换的贪心策略" src="../greedy_algorithm.assets/coin_change_greedy_strategy.png" /></p>
|
||||
<p align="center"> Fig. 零钱兑换的贪心策略 </p>
|
||||
|
||||
<p>实现代码如下所示。你可能会不由地发出感叹：So Clean ！因为贪心算法仅用十行代码就解决了零钱兑换问题。</p>
|
||||
<p>实现代码如下所示。你可能会不由地发出感叹：So Clean ！贪心算法仅用十行代码就解决了零钱兑换问题。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3570,24 +3570,26 @@
|
|||
<p><img alt="贪心无法找出最优解的示例" src="../greedy_algorithm.assets/coin_change_greedy_vs_dp.png" /></p>
|
||||
<p align="center"> Fig. 贪心无法找出最优解的示例 </p>
|
||||
|
||||
<p>也就是说，对于零钱兑换问题，贪心算法无法保证找到全局最优解，并且有可能找到非常差的解，因此该问题更适合用动态规划解决。</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. 贪心算法特性<a class="headerlink" href="#1512" title="Permanent link">¶</a></h2>
|
||||
<p>那么问题来了，什么样的问题适合用贪心算法求解呢？或者说，贪心算法在什么情况下可以保证找到最优解？</p>
|
||||
<p>相较于动态规划，贪心算法的使用条件更加苛刻，其主要关注问题的两个性质：</p>
|
||||
<ul>
|
||||
<li><strong>贪心选择性质</strong>：只有当局部最优选择始终可以导致全局最优解时，贪心算法才能保证得到最优解。</li>
|
||||
<li><strong>最优子结构</strong>：原问题的最优解包含子问题的最优解。值得注意的是，一些问题的最优子结构并不明显，但仍然可使用贪心算法解决。</li>
|
||||
<li><strong>最优子结构</strong>：原问题的最优解包含子问题的最优解。</li>
|
||||
</ul>
|
||||
<p>最优子结构已经在动态规划章节中介绍过，不再赘述，我们主要探究如何判断问题的贪心选择性质。虽然贪心选择性质的描述看上去比较简单，<strong>但实际上对于许多问题，证明贪心选择性质不是一件易事</strong>。</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>一篇论文 Pearson, David. "A polynomial-time algorithm for the change-making problem." <em>Operations Research Letters</em> 33.3 (2005): 231-234. 专门讨论了该问题。作者给出了一个 <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. 贪心解题步骤<a class="headerlink" href="#1513" title="Permanent link">¶</a></h2>
|
||||
<p>贪心问题的解决流程大体可分为三步：</p>
|
||||
|
|
@ -3596,20 +3598,20 @@
|
|||
<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>
|
||||
</ul>
|
||||
<p>为了保证正确性，我们应该对贪心策略进行严谨的数学证明，<strong>通常需要用到反证法或数学归纳法</strong>。</p>
|
||||
<p>然而，正确性证明往往也不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行 Debug ，一步步修改与验证贪心策略。</p>
|
||||
<p>然而，正确性证明也很可能不是一件易事。如若没有头绪，我们通常会选择面向测试用例进行 Debug ，一步步修改与验证贪心策略。</p>
|
||||
<h2 id="1514">15.1.4. 贪心典型例题<a class="headerlink" href="#1514" title="Permanent link">¶</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>
|
||||
<li><strong>股票买卖问题</strong>：给定一组股票的历史价格，你可以进行多次买卖，但如果你已经持有股票，那么在卖出之前不能再买，目标是获取最大利润。</li>
|
||||
<li><strong>霍夫曼编码</strong>：霍夫曼编码是一种用于无损数据压缩的贪心算法。通过构建霍夫曼树，每次选择出现频率最小的两个节点合并，最后得到的霍夫曼树的带权路径长度（即编码长度）最小。</li>
|
||||
<li><strong>Dijkstra 算法</strong>：它是一种解决给定源顶点到其余各顶点的最短路径问题的贪心算法。</li>
|
||||
</ol>
|
||||
|
|
|
|||
|
|
@ -3398,24 +3398,25 @@
|
|||
<h1 id="153">15.3. 最大容量问题<a class="headerlink" href="#153" title="Permanent link">¶</a></h1>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>输入一个数组 <span class="arithmatex">\(ht\)</span> ，数组中的每个元素代表一个垂直隔板的高度。数组中的任意两个隔板，以及它们之间的空间可以组成一个容器。容器的容量等于高度和宽度的乘积（即面积），其中高度由较短的隔板决定，宽度是两个隔板的数组索引之差。</p>
|
||||
<p>输入一个数组 <span class="arithmatex">\(ht\)</span> ，数组中的每个元素代表一个垂直隔板的高度。数组中的任意两个隔板，以及它们之间的空间可以组成一个容器。</p>
|
||||
<p>容器的容量等于高度和宽度的乘积（即面积），其中高度由较短的隔板决定，宽度是两个隔板的数组索引之差。</p>
|
||||
<p>请在数组中选择两个隔板，使得组成的容器的容量最大，返回最大容量。</p>
|
||||
</div>
|
||||
<p><img alt="最大容量问题的示例数据" src="../max_capacity_problem.assets/max_capacity_example.png" /></p>
|
||||
<p align="center"> Fig. 最大容量问题的示例数据 </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>
|
||||
<h3 id="_1">贪心策略确定<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>当然，这道题还有更高效率的解法。如下图所示，现选取一个状态 <span class="arithmatex">\([i, j]\)</span> ，其满足索引 <span class="arithmatex">\(i < j\)</span> 且高度 <span class="arithmatex">\(ht[i] < ht[j]\)</span> ，即 <span class="arithmatex">\(i\)</span> 为短板、 <span class="arithmatex">\(j\)</span> 为长板。</p>
|
||||
<p>这道题还有更高效率的解法。如下图所示，现选取一个状态 <span class="arithmatex">\([i, j]\)</span> ，其满足索引 <span class="arithmatex">\(i < j\)</span> 且高度 <span class="arithmatex">\(ht[i] < ht[j]\)</span> ，即 <span class="arithmatex">\(i\)</span> 为短板、 <span class="arithmatex">\(j\)</span> 为长板。</p>
|
||||
<p><img alt="初始状态" src="../max_capacity_problem.assets/max_capacity_initial_state.png" /></p>
|
||||
<p align="center"> Fig. 初始状态 </p>
|
||||
|
||||
<p>我们发现，<strong>如果将长板 <span class="arithmatex">\(j\)</span> 向短板 <span class="arithmatex">\(i\)</span> 靠近，则容量一定变小</strong>。这是因为在移动长板 <span class="arithmatex">\(j\)</span> 后：</p>
|
||||
<p>我们发现，<strong>如果此时将长板 <span class="arithmatex">\(j\)</span> 向短板 <span class="arithmatex">\(i\)</span> 靠近，则容量一定变小</strong>。这是因为在移动长板 <span class="arithmatex">\(j\)</span> 后：</p>
|
||||
<ul>
|
||||
<li>宽度 <span class="arithmatex">\(j-i\)</span> 肯定变小；</li>
|
||||
<li>高度由短板决定，因此高度只可能不变（ <span class="arithmatex">\(i\)</span> 仍为短板）或变小（移动后的 <span class="arithmatex">\(j\)</span> 成为短板）；</li>
|
||||
|
|
@ -3423,7 +3424,7 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
|
|||
<p><img alt="向内移动长板后的状态" src="../max_capacity_problem.assets/max_capacity_moving_long_board.png" /></p>
|
||||
<p align="center"> Fig. 向内移动长板后的状态 </p>
|
||||
|
||||
<p>反向思考，<strong>我们只有向内收缩短板 <span class="arithmatex">\(i\)</span> ，才有可能使容量变大</strong>。因为虽然宽度一定变小，<strong>但高度可能会变大</strong>（移动后的短板 <span class="arithmatex">\(i\)</span> 变长了）。</p>
|
||||
<p>反向思考，<strong>我们只有向内收缩短板 <span class="arithmatex">\(i\)</span> ，才有可能使容量变大</strong>。因为虽然宽度一定变小，<strong>但高度可能会变大</strong>（移动后的短板 <span class="arithmatex">\(i\)</span> 可能会变长）。</p>
|
||||
<p><img alt="向内移动长板后的状态" src="../max_capacity_problem.assets/max_capacity_moving_short_board.png" /></p>
|
||||
<p align="center"> Fig. 向内移动长板后的状态 </p>
|
||||
|
||||
|
|
@ -3466,7 +3467,8 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
|
|||
</div>
|
||||
</div>
|
||||
<h3 id="_2">代码实现<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>如下代码所示，循环最多 <span class="arithmatex">\(n\)</span> 轮，<strong>因此时间复杂度为 <span class="arithmatex">\(O(n)\)</span></strong> 。变量 <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">\(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>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:11"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
@ -3609,15 +3611,14 @@ cap[i, j] = \min(ht[i], ht[j]) \times (j - i)
|
|||
</div>
|
||||
<h3 id="_3">正确性证明<a class="headerlink" href="#_3" title="Permanent link">¶</a></h3>
|
||||
<p>之所以贪心比穷举更快，是因为每轮的贪心选择都会“跳过”一些状态。</p>
|
||||
<p>比如在状态 <span class="arithmatex">\(cap[i, j]\)</span> 下，<span class="arithmatex">\(i\)</span> 为短板、<span class="arithmatex">\(j\)</span> 为长板。若贪心地将短板 <span class="arithmatex">\(i\)</span> 向内移动一格，会导致以下状态被“跳过”，<strong>意味着之后无法验证这些状态的容量大小</strong>。</p>
|
||||
<p>比如在状态 <span class="arithmatex">\(cap[i, j]\)</span> 下，<span class="arithmatex">\(i\)</span> 为短板、<span class="arithmatex">\(j\)</span> 为长板。若贪心地将短板 <span class="arithmatex">\(i\)</span> 向内移动一格，会导致以下状态被“跳过”。<strong>这意味着之后无法验证这些状态的容量大小</strong>。</p>
|
||||
<div class="arithmatex">\[
|
||||
cap[i, i+1], cap[i, i+2], \cdots, cap[i, j-2], cap[i, j-1]
|
||||
\]</div>
|
||||
<p><img alt="移动短板导致被跳过的状态" src="../max_capacity_problem.assets/max_capacity_skipped_states.png" /></p>
|
||||
<p align="center"> Fig. 移动短板导致被跳过的状态 </p>
|
||||
|
||||
<p>观察发现，<strong>这些被跳过的状态实际上就是将长板 <span class="arithmatex">\(j\)</span> 向内移动的所有状态</strong>。而在第二步中，我们已经证明内移长板一定会导致容量变小，也就是说这些被跳过的状态的容量一定更小。</p>
|
||||
<p>也就是说，被跳过的状态都不可能是最优解，<strong>跳过它们不会导致错过最优解</strong>。</p>
|
||||
<p>观察发现，<strong>这些被跳过的状态实际上就是将长板 <span class="arithmatex">\(j\)</span> 向内移动的所有状态</strong>。而在第二步中，我们已经证明内移长板一定会导致容量变小。也就是说，被跳过的状态都不可能是最优解，<strong>跳过它们不会导致错过最优解</strong>。</p>
|
||||
<p>以上的分析说明，<strong>移动短板的操作是“安全”的</strong>，贪心策略是有效的。</p>
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3413,7 +3413,7 @@ n = \sum_{i=1}^{m}n_i
|
|||
\]</div>
|
||||
<p>我们需要思考的是：切分数量 <span class="arithmatex">\(m\)</span> 应该多大，每个 <span class="arithmatex">\(n_i\)</span> 应该是多少？</p>
|
||||
<h3 id="_1">贪心策略确定<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>根据经验，两个整数的和往往比它们的积更小。假设从 <span class="arithmatex">\(n\)</span> 中分出一个因子 <span class="arithmatex">\(2\)</span> ，则它们的乘积为 <span class="arithmatex">\(2(n-2)\)</span> 。我们将该乘积与 <span class="arithmatex">\(n\)</span> 作比较：</p>
|
||||
<p>根据经验，两个整数的乘积往往比它们的加和更大。假设从 <span class="arithmatex">\(n\)</span> 中分出一个因子 <span class="arithmatex">\(2\)</span> ，则它们的乘积为 <span class="arithmatex">\(2(n-2)\)</span> 。我们将该乘积与 <span class="arithmatex">\(n\)</span> 作比较：</p>
|
||||
<div class="arithmatex">\[
|
||||
\begin{aligned}
|
||||
2(n-2) & \geq n \newline
|
||||
|
|
@ -3421,14 +3421,14 @@ n = \sum_{i=1}^{m}n_i
|
|||
n & \geq 4
|
||||
\end{aligned}
|
||||
\]</div>
|
||||
<p>当 <span class="arithmatex">\(n \geq 4\)</span> 时，切分出一个 <span class="arithmatex">\(2\)</span> 后乘积会变大，这说明大于等于 <span class="arithmatex">\(4\)</span> 的整数都应该被切分。</p>
|
||||
<p>我们发现当 <span class="arithmatex">\(n \geq 4\)</span> 时，切分出一个 <span class="arithmatex">\(2\)</span> 后乘积会变大，<strong>这说明大于等于 <span class="arithmatex">\(4\)</span> 的整数都应该被切分</strong>。</p>
|
||||
<p><strong>贪心策略一</strong>：如果切分方案中包含 <span class="arithmatex">\(\geq 4\)</span> 的因子，那么它就应该被继续切分。最终的切分方案只应出现 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(3\)</span> 这三种因子。</p>
|
||||
<p><img alt="切分导致乘积变大" src="../max_product_cutting_problem.assets/max_product_cutting_greedy_infer1.png" /></p>
|
||||
<p align="center"> Fig. 切分导致乘积变大 </p>
|
||||
|
||||
<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) < n\)</span> 恒成立，切分出 <span class="arithmatex">\(1\)</span> 会导致乘积减小。</p>
|
||||
<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) < n\)</span> 恒成立，即切分出 <span class="arithmatex">\(1\)</span> 反而会导致乘积减小。</p>
|
||||
<p>我们发现，当 <span class="arithmatex">\(n = 6\)</span> 时，有 <span class="arithmatex">\(3 \times 3 > 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><img alt="最优切分因子" src="../max_product_cutting_problem.assets/max_product_cutting_greedy_infer3.png" /></p>
|
||||
<p align="center"> Fig. 最优切分因子 </p>
|
||||
|
||||
|
|
@ -3440,11 +3440,11 @@ n & \geq 4
|
|||
<li>当余数为 <span class="arithmatex">\(1\)</span> 时，由于 <span class="arithmatex">\(2 \times 2 > 1 \times 3\)</span> ，因此应将最后一个 <span class="arithmatex">\(3\)</span> 替换为 <span class="arithmatex">\(2\)</span> 。</li>
|
||||
</ol>
|
||||
<h3 id="_2">代码实现<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>在代码中，我们无需开启循环来切分，可以直接利用向下整除得到 <span class="arithmatex">\(3\)</span> 的个数 <span class="arithmatex">\(a\)</span> ，用取模运算得到余数 <span class="arithmatex">\(b\)</span> ，即：</p>
|
||||
<p>在代码中，我们无需通过循环来切分整数，而可以利用向下整除运算得到 <span class="arithmatex">\(3\)</span> 的个数 <span class="arithmatex">\(a\)</span> ，用取模运算得到余数 <span class="arithmatex">\(b\)</span> ，此时有：</p>
|
||||
<div class="arithmatex">\[
|
||||
n = 3 a + b
|
||||
\]</div>
|
||||
<p>需要单独处理边界情况：当 <span class="arithmatex">\(n \leq 3\)</span> 时，必须拆分出一个 <span class="arithmatex">\(1\)</span> ，乘积为 <span class="arithmatex">\(1 \times (n - 1)\)</span> 。</p>
|
||||
<p>请注意，对于 <span class="arithmatex">\(n \leq 3\)</span> 的边界情况，必须拆分出一个 <span class="arithmatex">\(1\)</span> ，乘积为 <span class="arithmatex">\(1 \times (n - 1)\)</span> 。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
|
|
|
|||
|
|
@ -3311,14 +3311,14 @@
|
|||
<ul>
|
||||
<li>贪心算法通常用于解决最优化问题，其原理是在每个决策阶段都做出局部最优的决策，以期望获得全局最优解。</li>
|
||||
<li>贪心算法会迭代地做出一个又一个的贪心选择，每轮都将问题转化成一个规模更小的子问题，直到问题被解决。</li>
|
||||
<li>贪心算法不仅实现简单，还具有很高的解题效率。相比于动态规划，贪心算法的时间复杂度通常低一个数量级。</li>
|
||||
<li>贪心算法不仅实现简单，还具有很高的解题效率。相比于动态规划，贪心算法的时间复杂度通常更低。</li>
|
||||
<li>在零钱兑换问题中，对于某些硬币组合，贪心算法可以保证找到最优解；对于另外一些硬币组合则不然，贪心算法可能找到很差的解。</li>
|
||||
<li>贪心问题具有两大性质：贪心选择性质和最优子结构。贪心选择性质代表贪心策略的有效性。</li>
|
||||
<li>适合用贪心算法求解的问题具有两大性质：贪心选择性质和最优子结构。贪心选择性质代表贪心策略的有效性。</li>
|
||||
<li>对于某些复杂问题，贪心选择性质的证明并不简单。相对来说，证伪更加容易，例如零钱兑换问题。</li>
|
||||
<li>求解贪心问题主要分为三步：问题分析、贪心策略确定、正确性证明。其中，贪心策略确定是核心步骤，而正确性证明是难点。</li>
|
||||
<li>分数背包问题在 0-1 背包的基础上，允许选择物品的一部分，因此可使用贪心算法求解。可以采用反证法证明贪心策略的正确性。</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>
|
||||
<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>
|
||||
</ul>
|
||||
|
||||
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
BIN
sitemap.xml.gz
BIN
sitemap.xml.gz
Binary file not shown.
Loading…
Reference in a new issue