做电商网站需要会些什么条件,怎样网站不用备案,商城网站都有什么功能模块,成都 网站原创动态规划解题套路框架
此文只在个人总结 labuladong 动态规划框架#xff0c;仅限于学习交流#xff0c;版权归原作者所有#xff1b;
动态规划问题#xff08;Dynamic Programming#xff09;应该是很多读者头疼的#xff0c;不过这类问题也是最具有技巧性#xff0c…动态规划解题套路框架
此文只在个人总结 labuladong 动态规划框架仅限于学习交流版权归原作者所有
动态规划问题Dynamic Programming应该是很多读者头疼的不过这类问题也是最具有技巧性最有意思的。本书使用了整整一个章节专门来写这个算法动态规划的重要性也可见一斑。
本文解决几个问题
动态规划是什么解决动态规划问题有什么技巧如何学习动态规划
刷题刷多了就会发现算法技巧就那几个套路我们后续的动态规划系列章节都在使用本文的解题框架思维如果你心里有数就会轻松很多。所以本文放在第一章来扒一扒动态规划的裤子形成一套解决这类问题的思维框架希望能够成为解决动态规划问题的一部指导方针。本文就来讲解该算法的基本套路框架下面上干货。
首先动态规划问题的一般形式就是求最值。动态规划其实是运筹学的一种最优化方法只不过在计算机问题上应用比较多比如说让你求最长递增子序列呀最小编辑距离呀等等。
既然是要求最值核心问题是什么呢求解动态规划的核心问题是穷举。因为要求最值肯定要把所有可行的答案穷举出来然后在其中找最值呗。 注 动态规划一般形式是求最值动态规划的核心问题是穷举 动态规划这么简单就是穷举就完事了我看到的动态规划问题都很难啊
首先虽然动态规划的核心思想就是穷举求最值但是问题可以千变万化穷举所有可行解其实并不是一件容易的事需要你熟练掌握递归思维只有列出正确的「状态转移方程」才能正确地穷举。而且你需要判断算法问题是否具备「最优子结构」是否能够通过子问题的最值得到原问题的最值。另外动态规划问题存在「重叠子问题」如果暴力穷举的话效率会很低所以需要你使用「备忘录」或者「DP table」来优化穷举过程避免不必要的计算。 注动态规划三要素 列出状态转移方程——来正确的穷举判断算法问题是否具备 最优子结构——通过子问题来得到原问题找到重叠子问题——通过 备忘录或者 dp Table 来优化穷举 以上提到的 重叠子问题、最优子结构、状态转移方程 就是动态规划三要素。具体什么意思等会会举例详解但是在实际的算法问题中写出状态转移方程是最困难的这也就是为什么很多朋友觉得动态规划问题困难的原因我来提供我总结的一个思维框架辅助你思考状态转移方程
明确 base case - 明确「状态」- 明确「选择」 - 定义 dp 数组/函数的含义。 注 状态选择定义 dp 数组/函数的含义 按上面的套路走最后的解法代码就会是如下的框架
# 自顶向下递归的动态规划
def dp(状态1, 状态2, ...):for 选择 in 所有可能的选择:# 此时的状态已经因为做了选择而改变result 求最值(result, dp(状态1, 状态2, ...))return result# 自底向上迭代的动态规划
# 初始化 base case
dp[0][0][...] base case
# 进行状态转移
for 状态1 in 状态1的所有取值for 状态2 in 状态2的所有取值for ...dp[状态1][状态2][...] 求最值(选择1选择2...)下面通过斐波那契数列问题和凑零钱问题来详解动态规划的基本原理。前者主要是让你明白什么是重叠子问题斐波那契数列没有求最值所以严格来说不是动态规划问题后者主要举集中于如何列出状态转移方程。
一、斐波那契数列
力扣第 509 题「斐波那契数open in new window」就是这个问题请读者不要嫌弃这个例子简单只有简单的例子才能让你把精力充分集中在算法背后的通用思想和技巧上而不会被那些隐晦的细节问题搞的莫名其妙。想要困难的例子接下来的动态规划系列里有的是。
力扣第 509 题「斐波那契数open in new window」就是这个问题请读者不要嫌弃这个例子简单只有简单的例子才能让你把精力充分集中在算法背后的通用思想和技巧上而不会被那些隐晦的细节问题搞的莫名其妙。想要困难的例子接下来的动态规划系列里有的是。
1、暴力递归
斐波那契数列的数学形式就是递归的写成代码就是这样
int fib(int N) {if (N 1 || N 2) return 1;return fib(N - 1) fib(N - 2);
}这个不用多说了学校老师讲递归的时候似乎都是拿这个举例。我们也知道这样写代码虽然简洁易懂但是十分低效低效在哪里假设 n 20请画出递归树 Tip 但凡遇到需要递归的问题最好都画出递归树这对你分析算法的复杂度寻找算法低效的原因都有巨大帮助。 这个递归树怎么理解就是说想要计算原问题 f(20)我就得先计算出子问题 f(19) 和 f(18)然后要计算 f(19)我就要先算出子问题 f(18) 和 f(17)以此类推。最后遇到 f(1) 或者 f(2) 的时候结果已知就能直接返回结果递归树不再向下生长了。
递归算法的时间复杂度怎么计算就是用子问题个数乘以解决一个子问题需要的时间。
首先计算子问题个数即递归树中节点的总数。显然二叉树节点总数为指数级别所以子问题个数为 O(2^n)。
然后计算解决一个子问题的时间在本算法中没有循环只有 f(n - 1) f(n - 2) 一个加法操作时间为 O(1)。
所以这个算法的时间复杂度为二者相乘即 O(2^n)指数级别爆炸。
观察递归树很明显发现了算法低效的原因存在大量重复计算比如 f(18) 被计算了两次而且你可以看到以 f(18) 为根的这个递归树体量巨大多算一遍会耗费巨大的时间。更何况还不止 f(18) 这一个节点被重复计算所以这个算法及其低效。
这就是动态规划问题的第一个性质重叠子问题。下面我们想办法解决这个问题。
2、带备忘录的递归解法
明确了问题其实就已经把问题解决了一半。即然耗时的原因是重复计算那么我们可以造一个「备忘录」每次算出某个子问题的答案后别急着返回先记到「备忘录」里再返回每次遇到一个子问题先去「备忘录」里查一查如果发现之前已经解决过这个问题了直接把答案拿出来用不要再耗时去计算了。
一般使用一个数组充当这个「备忘录」当然你也可以使用哈希表字典思想都是一样的。
int fib(int N) {// 备忘录全初始化为 0int[] memo new int[N 1];// 进行带备忘录的递归return dp(memo, N);
}// 带着备忘录进行递归
int dp(int[] memo, int n) {// base caseif (n 0 || n 1) return n;// 已经计算过不用再计算了if (memo[n] ! 0) return memo[n];memo[n] dp(memo, n - 1) dp(memo, n - 2);return memo[n];
}注带备忘录的递归解法套路 自顶向下的递归备忘录解决重叠子问题的无效计算 现在画出递归树你就知道「备忘录」到底做了什么。 实际上带「备忘录」的递归算法把一棵存在巨量冗余的递归树通过「剪枝」改造成了一幅不存在冗余的递归图极大减少了子问题即递归图中节点的个数。 递归算法的时间复杂度怎么计算就是用子问题个数乘以解决一个子问题需要的时间。
子问题个数即图中节点的总数由于本算法不存在冗余计算子问题就是 f(1), f(2), f(3) … f(20)数量和输入规模 n 20 成正比所以子问题个数为 O(n)。
解决一个子问题的时间同上没有什么循环时间为 O(1)。
所以本算法的时间复杂度是 O(n)比起暴力算法是降维打击。
至此带备忘录的递归解法的效率已经和迭代的动态规划解法一样了。实际上这种解法和常见的动态规划解法已经差不多了只不过这种解法是「自顶向下」进行「递归」求解我们更常见的动态规划代码是「自底向上」进行「递推」求解。
啥叫「自顶向下」注意我们刚才画的递归树或者说图是从上向下延伸都是从一个规模较大的原问题比如说 f(20)向下逐渐分解规模直到 f(1) 和 f(2) 这两个 base case然后逐层返回答案这就叫「自顶向下」。
啥叫「自底向上」反过来我们直接从最底下、最简单、问题规模最小、已知结果的 f(1) 和 f(2)base case开始往上推直到推到我们想要的答案 f(20)。这就是「递推」的思路这也是动态规划一般都脱离了递归而是由循环迭代完成计算的原因。 注从时间复杂度和空间复杂度的角度上自顶向下的带备忘录的递归解法 和 自底向上的动态规划 一样只不过前者都 递归后者走 递推 3、dp 数组的迭代递推解法
有了上一步「备忘录」的启发我们可以把这个「备忘录」独立出来成为一张表通常叫做 DP table在这张表上完成「自底向上」的推算岂不美哉
int fib(int N) {if (N 0) return 0;int[] dp new int[N 1];// base casedp[0] 0; dp[1] 1;// 状态转移for (int i 2; i N; i) {dp[i] dp[i - 1] dp[i - 2];}return dp[N];
}画个图就很好理解了而且你发现这个 DP table 特别像之前那个「剪枝」后的结果只是反过来算而已。实际上带备忘录的递归解法中的「备忘录」最终完成后就是这个 DP table所以说这两种解法其实是差不多的大部分情况下效率也基本相同。
这里引出「状态转移方程」这个名词实际上就是描述问题结构的数学形式 为啥叫「状态转移方程」其实就是为了听起来高端。
f(n) 的函数参数会不断变化所以你把参数 n 想做一个状态这个状态 n 是由状态 n - 1 和状态 n - 2 转移相加而来这就叫状态转移仅此而已。 注动态规划的状态就是 dp 数组的参数 n 你会发现上面的几种解法中的所有操作例如 return f(n - 1) f(n - 2)dp[i] dp[i - 1] dp[i - 2]以及对备忘录或 DP table 的初始化操作都是围绕这个方程式的不同表现形式。
可见列出「状态转移方程」的重要性它是解决问题的核心而且很容易发现其实状态转移方程直接代表着暴力解法。
千万不要看不起暴力解动态规划问题最困难的就是写出这个暴力解即状态转移方程。
只要写出暴力解优化方法无非是用备忘录或者 DP table再无奥妙可言。
这个例子的最后讲一个细节优化。
细心的读者会发现根据斐波那契数列的状态转移方程当前状态 n 只和之前的 n-1, n-2 两个状态有关其实并不需要那么长的一个 DP table 来存储所有的状态只要想办法存储之前的两个状态就行了。
所以可以进一步优化把空间复杂度降为 O(1)。这也就是我们最常见的计算斐波那契数的算法
int fib(int n) {if (n 0 || n 1) {// base casereturn n;}// 分别代表 dp[i - 1] 和 dp[i - 2]int dp_i_1 1, dp_i_2 0;for (int i 2; i n; i) {// dp[i] dp[i - 1] dp[i - 2];int dp_i dp_i_1 dp_i_2;// 滚动更新dp_i_2 dp_i_1;dp_i_1 dp_i;}return dp_i_1;
}这一般是动态规划问题的最后一步优化如果我们发现每次状态转移只需要 DP table 中的一部分那么可以尝试缩小 DP table 的大小只记录必要的数据从而降低空间复杂度。
上述例子就相当于把 DP table 的大小从 n 缩小到 2。我会在后文 对动态规划发动降维打击 进一步讲解这个压缩空间复杂度的技巧一般来说用来把一个二维的 DP table 压缩成一维即把空间复杂度从 O(n^2) 压缩到 O(n)。 注上文演示了从 递归解法 - 带备忘录的递归解法 - 自底向上的递推解法其中 状态 就是 dp Table 中的参数 有人会问动态规划的另一个重要特性「最优子结构」怎么没有涉及下面会涉及。斐波那契数列的例子严格来说不算动态规划因为没有涉及求最值以上旨在说明重叠子问题的消除方法演示得到最优解法逐步求精的过程。下面看第二个例子凑零钱问题。
二、凑零钱问题
这是力扣第 322 题「零钱兑换open in new window」
给你 k 种面值的硬币面值分别为 c1, c2 ... ck每种硬币的数量无限再给一个总金额 amount问你最少需要几枚硬币凑出这个金额如果不可能凑出算法返回 -1 。算法的函数签名如下
// coins 中是可选硬币面值amount 是目标金额
int coinChange(int[] coins, int amount);比如说 k 3面值分别为 125总金额 amount 11。那么最少需要 3 枚硬币凑出即 11 5 5 1。
你认为计算机应该如何解决这个问题显然就是把所有可能的凑硬币方法都穷举出来然后找找看最少需要多少枚硬币。
1、暴力递归
首先这个问题是动态规划问题因为它具有「最优子结构」的。要符合「最优子结构」子问题间必须互相独立。啥叫相互独立你肯定不想看数学证明我用一个直观的例子来讲解。
比如说假设你考试每门科目的成绩都是互相独立的。你的原问题是考出最高的总成绩那么你的子问题就是要把语文考到最高数学考到最高…… 为了每门课考到最高你要把每门课相应的选择题分数拿到最高填空题分数拿到最高…… 当然最终就是你每门课都是满分这就是最高的总成绩。
得到了正确的结果最高的总成绩就是总分。因为这个过程符合最优子结构「每门科目考到最高」这些子问题是互相独立互不干扰的。
但是如果加一个条件你的语文成绩和数学成绩会互相制约不能同时达到满分数学分数高语文分数就会降低反之亦然。
这样的话显然你能考到的最高总成绩就达不到总分了按刚才那个思路就会得到错误的结果。因为「每门科目考到最高」的子问题并不独立语文数学成绩户互相影响无法同时最优所以最优子结构被破坏。
回到凑零钱问题为什么说它符合最优子结构呢假设你有面值为 1, 2, 5 的硬币你想求 amount 11 时的最少硬币数原问题如果你知道凑出 amount 10, 9, 6 的最少硬币数子问题你只需要把子问题的答案加一再选一枚面值为 1, 2, 5 的硬币求个最小值就是原问题的答案。因为硬币的数量是没有限制的所以子问题之间没有相互制是互相独立的。 注这里有个很重要的前提就是硬币的数量是没有限制的子问题之间没有相互制约是相互独立的 Tip 关于最优子结构的问题后文 动态规划答疑篇 还会再举例探讨。 那么既然知道了这是个动态规划问题就要思考如何列出正确的状态转移方程 1、确定 base case这个很简单显然目标金额 amount 为 0 时算法返回 0因为不需要任何硬币就已经凑出目标金额了。
2、确定「状态」也就是原问题和子问题中会变化的变量。由于硬币数量无限硬币的面额也是题目给定的只有目标金额会不断地向 base case 靠近所以唯一的「状态」就是目标金额 amount。
3、确定「选择」也就是导致「状态」产生变化的行为。目标金额为什么变化呢因为你在选择硬币你每选择一枚硬币就相当于减少了目标金额。所以说所有硬币的面值就是你的「选择」。
4、明确 dp 函数/数组的定义。我们这里讲的是自顶向下的解法所以会有一个递归的 dp 函数一般来说函数的参数就是状态转移中会变化的量也就是上面说到的「状态」函数的返回值就是题目要求我们计算的量。就本题来说状态只有一个即「目标金额」题目要求我们计算凑出目标金额所需的最少硬币数量。 注 base case就是 dp 数组的边界条件状态把待求问题的解 作为状态是一个很好的思路比如这道题的 凑出目标金额 amount 的最少硬币硬币数量无限因此本文就只有一个状态只有 amount 作为状态了选择导致状态发生变化的行为本题就是选硬币dp 数组的含义我们这里讲的是自顶向下的解法所以会有一个递归的 dp 函数一般来说函数的参数就是状态转移中会变化的量也就是上面说到的「状态」函数的返回值就是题目要求我们计算的量 所以我们可以这样定义 dp 函数dp(n) 表示输入一个目标金额 n返回凑出目标金额 n 所需的最少硬币数量。
搞清楚上面这几个关键点解法的伪码就可以写出来了
// 伪码框架
int coinChange(int[] coins, int amount) {// 题目要求的最终结果是 dp(amount)return dp(coins, amount)
}// 定义要凑出金额 n至少要 dp(coins, n) 个硬币
int dp(int[] coins, int n) {// 做选择选择需要硬币最少的那个结果for (int coin : coins) {res min(res, 1 dp(coins, n - coin))}return res
}根据伪码我们加上 base case 即可得到最终的答案。显然目标金额为 0 时所需硬币数量为 0当目标金额小于 0 时无解返回 -1
int coinChange(int[] coins, int amount) {// 题目要求的最终结果是 dp(amount)return dp(coins, amount)
}// 定义要凑出金额 n至少要 dp(coins, n) 个硬币
int dp(int[] coins, int amount) {// base caseif (amount 0) return 0;if (amount 0) return -1;int res Integer.MAX_VALUE;for (int coin : coins) {// 计算子问题的结果int subProblem dp(coins, amount - coin);// 子问题无解则跳过if (subProblem -1) continue;// 在子问题中选择最优解然后加一res Math.min(res, subProblem 1);}return res Integer.MAX_VALUE ? -1 : res;
}Note 这里 coinChange 和 dp 函数的签名完全一样所以理论上不需要额外写一个 dp 函数。但为了后文讲解方便这里还是另写一个 dp 函数来实现主要逻辑。 另外我经常看到有人问子问题的结果为什么要加 1subProblem 1而不是加硬币金额之类的。我这里统一提示一下动态规划问题的关键是 dp 函数/数组的定义你这个函数的返回值代表什么你回过头去搞清楚这一点然后就知道为什么要给子问题的返回值加 1 了。 至此状态转移方程其实已经完成了以上算法已经是暴力解法了以上代码的数学形式就是状态转移方程 至此这个问题其实就解决了只不过需要消除一下重叠子问题比如 amount 11, coins {1,2,5} 时画出递归树看看 递归算法的时间复杂度分析子问题总数 x 解决每个子问题所需的时间。
子问题总数为递归树的节点个数但算法会进行剪枝剪枝的时机和题目给定的具体硬币面额有关所以可以想象这棵树生长的并不规则确切算出树上有多少节点是比较困难的。对于这种情况我们一般的做法是按照最坏的情况估算一个时间复杂度的上界。
假设目标金额为 n给定的硬币个数为 k那么递归树最坏情况下高度为 n全用面额为 1 的硬币然后再假设这是一棵满 k 叉树则节点的总数在 k^n 这个数量级。
接下来看每个子问题的复杂度由于每次递归包含一个 for 循环复杂度为 O(k)相乘得到总时间复杂度为 O(k^n)指数级别。
2、带备忘录的递归
类似之前斐波那契数列的例子只需要稍加修改就可以通过备忘录消除子问题
class Solution {int[] memo;int coinChange(int[] coins, int amount) {memo new int[amount 1];// 备忘录初始化为一个不会被取到的特殊值代表还未被计算Arrays.fill(memo, -666);return dp(coins, amount);}int dp(int[] coins, int amount) {if (amount 0) return 0;if (amount 0) return -1;// 查备忘录防止重复计算if (memo[amount] ! -666)return memo[amount];int res Integer.MAX_VALUE;for (int coin : coins) {// 计算子问题的结果int subProblem dp(coins, amount - coin);// 子问题无解则跳过if (subProblem -1) continue;// 在子问题中选择最优解然后加一res Math.min(res, subProblem 1);}// 把计算结果存入备忘录memo[amount] (res Integer.MAX_VALUE) ? -1 : res;return memo[amount];}
}不画图了很显然「备忘录」大大减小了子问题数目完全消除了子问题的冗余所以子问题总数不会超过金额数 n即子问题数目为 O(n)。处理一个子问题的时间不变仍是 O(k)所以总的时间复杂度是 O(kn)。
3、dp 数组的迭代解法
当然我们也可以自底向上使用 dp table 来消除重叠子问题关于「状态」「选择」和 base case 与之前没有区别dp 数组的定义和刚才 dp 函数类似也是把「状态」也就是目标金额作为变量。不过 dp 函数体现在函数参数而 dp 数组体现在数组索引
dp 数组的定义当目标金额为 i 时至少需要 dp[i] 枚硬币凑出。
根据我们文章开头给出的动态规划代码框架可以写出如下解法
int coinChange(int[] coins, int amount) {int[] dp new int[amount 1];// 数组大小为 amount 1初始值也为 amount 1Arrays.fill(dp, amount 1);// base casedp[0] 0;// 外层 for 循环在遍历所有状态的所有取值for (int i 0; i dp.length; i) {// 内层 for 循环在求所有选择的最小值for (int coin : coins) {// 子问题无解跳过if (i - coin 0) {continue;}dp[i] Math.min(dp[i], 1 dp[i - coin]);}}return (dp[amount] amount 1) ? -1 : dp[amount];
}Info 为啥 dp 数组中的值都初始化为 amount 1 呢因为凑成 amount 金额的硬币数最多只可能等于 amount全用 1 元面值的硬币所以初始化为 amount 1 就相当于初始化为正无穷便于后续取最小值。为啥不直接初始化为 int 型的最大值 Integer.MAX_VALUE 呢因为后面有 dp[i - coin] 1这就会导致整型溢出。 三、最后总结
第一个斐波那契数列的问题解释了如何通过「备忘录」或者「dp table」的方法来优化递归树并且明确了这两种方法本质上是一样的只是自顶向下和自底向上的不同而已。
第二个凑零钱的问题展示了如何流程化确定「状态转移方程」只要通过状态转移方程写出暴力递归解剩下的也就是优化递归树消除重叠子问题而已。
如果你不太了解动态规划还能看到这里真得给你鼓掌相信你已经掌握了这个算法的设计技巧。
计算机解决问题其实没有任何特殊的技巧它唯一的解决办法就是穷举穷举所有可能性。算法设计无非就是先思考“如何穷举”然后再追求“如何聪明地穷举”。
列出状态转移方程就是在解决“如何穷举”的问题。之所以说它难一是因为很多穷举需要递归实现二是因为有的问题本身的解空间复杂不那么容易穷举完整。
备忘录、DP table 就是在追求“如何聪明地穷举”。用空间换时间的思路是降低时间复杂度的不二法门除此之外试问还能玩出啥花活
之后我们会有一章专门讲解动态规划问题如果有任何问题都可以随时回来重读本文希望读者在阅读每个题目和解法时多往「状态」和「选择」上靠才能对这套框架产生自己的理解运用自如。
接下来可阅读 全文演化路径从上而下的递归 - 从上而下的带备忘录的递归 (备忘录解决重叠子问题的无效计算) - 从下而上的递推状态转移方程; 动态规划 4 要素 状态会变化的就是状态 选择导致状态发生变化的就是选择 dp数组到底几维是根据状态来定的比如0-1背包就是两倍dp[i][w] 表示对于前 i 个物品重量约束为 w 时候的最大价值 base case就是 dp 数组的边界条件 动态规划套路框架 # 1. 自顶向下递归的动态规划
def dp(状态1, 状态2, ...):for 选择 in 所有可能的选择:# 此时的状态已经因为做了选择而改变result 求最值(result, dp(状态1, 状态2, ...))return result# 2. 自底向上迭代的动态规划
# 初始化 base case
dp[0][0][...] base case
# 进行状态转移
for 状态1 in 状态1的所有取值for 状态2 in 状态2的所有取值for ...dp[状态1][状态2][...] 求最值(选择1选择2...)四、参考文献
动态规划解题套路框架
