(英语:Dynamic programming,简称 DP),是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的,通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。
重叠子问题是指在问题的求解过程中,存在多次使用相同的子问题的情况,即在求解问题的不同阶段,需要求解的子问题可能是相同的。重叠子问题是动态规划算法设计的基础之一,利用子问题的重叠性可以减少重复计算,提高算法效率。
最优子结构是指问题的最优解可以通过子问题的最优解来构造得到。也就是说,问题的最优解包含子问题的最优解。通俗地说,就是大问题的最优解可以由小问题的最优解推出。这是动态规划的关键性质之一。
举个例子,假设有一个包含n个元素的序列,需要找出其中的最长递增子序列(LIS,Longest Increasing Subsequence)。这个问题就具有最优子结构性质。如果一个序列的LIS已知,那么如果在其末尾添加一个元素,就有两种情况:
1.如果该元素大于当前LIS的末尾元素,那么新序列的LIS为当前LIS加上这个元素,长度为原序列的LIS长度加1;
2.如果该元素小于等于当前LIS的末尾元素,那么当前LIS不会受到影响,新序列的LIS仍然是原序列的LIS。
因此,该问题的最优解可以通过已知的子问题的最优解构造得到。
动态规划最核心的思想,就在于拆分子问题,记住过往,减少重复计算。
我们来看下,网上比较流行的一个例子:
A : "1+1+1+1+1+1+1+1 =?"
A : "上面等式的值是多少"
B : 计算 "8"
A : 在上面等式的左边写上 "1+" 呢?
A : "此时等式的值为多少"
B : 很快得出答案 "9"
A : "你怎么这么快就知道答案了"
A : "只要在8的基础上加1就行了"
A : "所以你不用重新计算,因为你记住了第一个等式的值为8!动态规划算法也可以说是 '记住求过的解来节省时间'"
leetcode原题:一只青蛙一次可以跳上1级台阶,也可以跳上2级台阶。求该青蛙跳上一个 10 级的台阶总共有多少种跳法
基本思想:动态规划从较小问题的解,由交叠性质,逐步决策出较大问题的解,它是从f(1)往f(10)方向,往上推求解,所以称为自底向上的解法。
什么意思,我们从第一个台阶往上推,假设跳到第n级台阶的跳数我们定义为f(n):
1.当只有1级台阶时,只有一种跳法,即f(1)= 1;
2.当只有2级台阶时,有两种跳法。第一种是直接跳两级。第二种是先跳一级,然后再跳一级。即f(2) = 2;
3.当有3级台阶时,也有两种跳法。第一种是从第1级台阶直接跳两级。第二种是从第2级台阶跳一级。即f(3) = f(1) + f(2);
4.要想跳到第4级台阶,要么是先跳到第3级,然后再跳1级台阶上去;要么是先跳到第2级,然后一次迈2级台阶上去。即f(4) = f(2) + f(3);
此时,我门就能得到公式:
f(1) = 1;
f(2) = 2;
f(3) = f(1) + f(2);
f(4) = f(2) + f(3);
…
f(10) = f(8) + f(9);
即f(n) = f(n - 2) + f(n - 1)。
此时我们来看看动态规划的典型特征在此题中的展现:
1.最优子结构:f(n-1)和f(n-2) 称为 f(n) 的最优子结构。
2.重叠子问题:比如f(10)= f(9)+f(8),f(9) = f(8) + f(7) ,f(8)就是重叠子问题。
3.状态转移方程:f(n)= f(n-1)+f(n-2)就称为状态转移方程。
4.边界:f(1) = 1, f(2) = 2 就是边界。
代码思路如图:
class Solution {
public:
int numWays(int n) {
int dp[101] = {0};
int mod = 1000000007;
dp[0] = 1;
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= mod;
}
return dp[n] % mod;
}
};
这个方法空间复杂度是O(n),但是呢,仔细观察上图,可以发现,f(n)只依赖前面两个数,所以只需要两个变量a和b来存储,就可以满足需求了,因此空间复杂度是O(1)就可以啦。
代码实现:
class Solution {
public:
int numWays(int n) {
if (n < 2) {
return 1;
}
if (n == 2) {
return 2;
}
int a = 1;
int b = 2;
int temp = 0;
for (int i = 3; i <= n; i++) {
temp = (a + b)% 1000000007;
a = b;
b = temp;
}
return temp;
}
};
动态规划的核心思想就是拆分子问题,记住过往,减少重复计算。 并且动态规划一般都是自底向上的,因此到这里,基于青蛙跳阶问题,总结了一下做动态规划的思路:
1.穷举分析
2.确定边界
3.找出规律,确定最优子结构
4.写出状态转移方程
1.穷举分析
(1)当台阶数是1的时候,有一种跳法,f(1) =1)
(2)当只有2级台阶时,有两种跳法,第一种是直接跳两级,第二种是先跳一级,然后再跳一级。即f(2) = 2;
(3)当台阶是3级时,想跳到第3级台阶,要么是先跳到第2级,然后再跳1级台阶上去,要么是先跳到第 1级,然后一次迈 2 级台阶上去。所以f(3) = f(2) + f(1) =3
(4)当台阶是4级时,想跳到第3级台阶,要么是先跳到第3级,然后再跳1级台阶上去,要么是先跳到第 2级,然后一次迈 2 级台阶上去。所以f(4) = f(3) + f(2) =5
(5)当台阶是5级时…
2.确定边界
通过穷举分析,我们发现,当台阶数是1的时候或者2的时候,可以明确知道青蛙跳法。f(1) =1,f(2) = 2,当台阶n>=3时,已经呈现出规律f(3) = f(2) + f(1) =3,因此f(1) =1,f(2) = 2就是青蛙跳阶的边界。
3.找规律,确定最优子结构
n>=3时,已经呈现出规律 f(n) = f(n-1) + f(n-2) ,因此,f(n-1)和f(n-2) 称为 f(n) 的最优子结构。什么是最优子结构?有这么一个解释:一道动态规划问题,其实就是一个递推问题。假设当前决策结果是f(n),则最优子结构就是要让 f(n-k) 最优,最优子结构性质就是能让转移到n的状态是最优的,并且与后面的决策没有关系,即让后面的决策安心地使用前面的局部最优解的一种性质
4.通过前面3步,穷举分析,确定边界,最优子结构,我们就可以得出状态转移方程啦:
1.当nums只有10的时候,最长子序列[10],长度1。
2.当nums加入9时,最长子序列[10]或[9],长度1。
3.当nums加入2时,最长子序列[10]或[9]或[2],长度1。
4.当nums加入5时,最长子序列[2, 5],长度2。
5.当nums加入3时,最长子序列[2, 5]或[2, 3],长度2。
6.当nums加入7时,最长子序列[2, 5, 7]或[2, 3, 7],长度3。
…
7.当nums再加入一个元素18时,最长递增子序列是[2,5,7,101]或者[2,3,7,101]或者[2,5,7,18]或者[2,3,7,18],长度是4。
对于nums数组的每一个元素而言,当我们还没有开始遍历寻找时,它们的初始最长子序列就是它们本身长度为1。
通过上面分析,我们可以发现一个规律:
nums[i]结尾的自增子序列,只要找到结尾nums[j]比nums[i]小的子序列,加上nums[i] 就可以。显然,可能形成多种新的子序列,我们选最长那个,就是的最长递增子序列。
得到最优子结构:
最长递增子序列(nums[i]) = max(最长递增子序列(nums[j])) + nums[i]; 0<= j < i, nums[j] < nums[i];
我们设立dp数组储存以nums数组的元素结尾的最长子序列的长度,将其初始化为1,由最优子结构得到状态转移方程:
dp[i] = max(dp[j]) + 1; 0<= j < i, nums[j] < nums[i];
3.1.5 代码
class Solution {
public:
int lengthOfLIS(vector& nums) {
vector dp(nums.size(), 1);
int ans = 1;
for (int i = 1; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
if (nums[j] < nums[i]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
ans = max(ans, dp[i]);
}
return ans;
}
};