CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-13 18:00:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

deploy

Browse Source
This commit is contained in:
krahets
2023-07-26 03:16:04 +08:00
parent a71f51e5b8
commit fd34c845bc
15 changed files with 208 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
chapter_dynamic_programming/dp_problem_features/index.html
View File

@@ -3382,14 +3382,13 @@
<h1 id="142">14.2. &nbsp; 动态规划问题特性<a class="headerlink" href="#142" title="Permanent link">&para;</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. &nbsp; 最优子结构<a class="headerlink" href="#1421" title="Permanent link">&para;</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. &nbsp; 无后效性<a class="headerlink" href="#1422" title="Permanent link">&para;</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>