考虑一个题是否能用动态规划求解：
（1）能够定义子问题，并且原问题能够用子问题表示
（2）子问题的解应该能通过其他子问题求出
不满足以上条件的话，该题不能用动态规划求解。
如何找递推关系：
看最大的问题如何由第二大的问题推出（和递归的思路一样，和二叉树当时总结的“只看根和左右子树”的思路也一样），拿“最长公共子序列来说”，有如下两个序列：
BBAAAAE
BBBBE
如何去找递推思路呢？BBAAAAE和 BBBBE的最长公共子序列个数就=各自去掉最后一位，BBAAAA和BBBB的最长公共子序列个数+1。
如果最后一位不相同呢？
BBAAAAE
BBBBA
1.打家劫舍**
注意：
（1）一开始我只想到了隔一家偷一次，这样写出来的代码通过率还可以（暴力求解）
但是没想到，像上图这样的情况，隔两家偷才是最好的偷法。
(2)递归也可以求解，但是会超时
(3)动态规划
步骤一：定义子问题
稍微接触过一点动态规划的朋友都知道动态规划有一个“子问题”的定义。什么是子问题？子问题是和原问题相似，但规模较小的问题。例如这道小偷问题，原问题是“从全部房子中能偷到的最大金额”，将问题的规模缩小，子问题就是“从 k个房子中能偷到的最大金额”，用 f(k)表示。
步骤二：写出子问题的递推关系
这一步是求解动态规划问题最关键的一步。然而，这一步也是最无法在代码中体现出来的一步。在做题的时候，最好把这一步的思路用注释的形式写下来。做动态规划题目不要求快，而要确保无误。否则，写代码五分钟，找 bug 半小时，岂不美哉？
我们来分析一下这道小偷问题的递推关系：
假设一共有 n 个房子，每个房子的金额分别是 H_0, H_1,H_n−1 ，子问题 f(k)表示从前 k个房子（即 H_0, H_1, …, H_k-1)中能偷到的最大金额。那么，偷 k 个房子有两种偷法：
步骤三：确定 DP 数组的计算顺序
在确定了子问题的递推关系之后，下一步就是依次计算出这些子问题了。在很多教程中都会写，动态规划有两种计算顺序，一种是自顶向下的、使用备忘录的递归方法，一种是自底向上的、使用 dp 数组的循环方法。不过在普通的动态规划题目中，99% 的情况我们都不需要用到备忘录方法，所以我们最好坚持用自底向上的 dp 数组。
DP 数组也可以叫”子问题数组”，因为 DP 数组中的每一个元素都对应一个子问题。如下图所示，dp[k] 对应子问题 f(k)，即偷前 k 间房子的最大金额。
class Solution {
public:
int rob(vector<int>& nums) {
int k=nums.size();
/*------特殊情况--------*/
if(k==0)
return 0;
if(k==1)
return nums[0];
/*---------------------*/
int dp[k+1];
dp[0]=0; //边界
dp[1]=nums[0]; //边界
for(int i=2;i<=k;i++){
dp[i]=max(dp[i-1],dp[i-2]+nums[i-1]); //迭代子问题
}
return dp[k]; //最终的问题
}
};
此外，
动态规划的题目，还可以用递归的思路来求解，不过时间复杂度太大了。
class Solution {
public:
int rob(vector<int>& nums) {
int k=nums.size();
return f(k,nums);
}
int f(int k,vector<int>& nums){
if(k==0)
return 0;
if(k==1)
return nums[0];
return max(f(k-1,nums),f(k-2,nums)+nums[k-1]);
}
};
可以看到大多数的测试用例是可以通过的。
我们通过画图来看一下动态规划和递归在复杂度上的区别。动态规划以求解dp[7]为例，递归为了绘制方便以求解dp[5]为例。
可以看出，递归的复杂度远大于动态规划。原因在于，递归法（分治法）在子问题和子子问题等上被重复计算了很多次（例如dp[2]被计算了3次），而动态规划则具有记忆性，通过填写表把所有已经解决的子问题答案纪录下来，在新问题里需要用到的子问题可以直接提取，避免了重复计算，从而节约了时间。
2.爬楼梯*
解析：
（1）定义子问题：爬k阶有f(k)种方法，原问题的解是f(n)
（2）子问题的递推关系：由题目可以得知，只能爬一步或两步，那么就子问题可以分解成两部分。
①假设已经爬了k-1层，那么此时爬到k层只能迈一步，也就是说爬到k-1层所用的方法全部可以用来爬到k层。
②假设已经爬了k-2层，那么此时爬到k层只能迈两步（迈一步再迈一步属于上一种情况）。所以爬到k-2层所用的方法全部可以用来爬到k层。
f(k)=f(k-1)+f(k-2)
（3）边界
有几个边界呢？这就要从递推关系里去看，我们发现求f(k)的时候需要已知f(k-1)和f(k-2)两个量，所以边界就是两个啦。题目又说给出的n是正整数，那么边界就是n=1时和n=2时啦。
class Solution {
public:
int climbStairs(int n) {
/*-----特殊情况------*/
if(n==1)
return 1;
if(n==2)
return 2;
/*------------------*/
int dp[n+1]; //加一为了不用思考
dp[1]=1; //边界
dp[2]=2; //边界
for(int i=3;i<=n;i++){ //从这里也能看出边界是3-1和3-2
dp[i]=dp[i-1]+dp[i-2]; //迈一步+迈两步
}
return dp[n];
}
};
此外，
如果用递归求解，依然会超时。
class Solution {
public:
int climbStairs(int n) {
if(n==1)
return 1;
if(n==2)
return 2;
return climbStairs(n-1)+climbStairs(n-2); //迈一步+迈两步
}
};
3. 01 背包问题
首先，这是一个二维的递推，理解起来可能有些困难。但是背过就行！
有的题目中是这样描述的：一个背包有给定的最大体积，若干物品有给定的体积和重量。求使得背包重量最大。
有的题目中是这样描述的：一个背包有给定的最大重量，若干物品有给定的重量和价值。求使得背包价值最大。
思路：
（1）定义子问题：dp[i][j]表示放入第i个物品时，背包剩余体积最大为j时的最大重量
（2）子问题的递推关系：
当前物品的体积小于等于背包剩余体积时，我可以选择把物品放进去，也可以选择不放，当然哪个更有利（使重量最大选哪个）；
当前物品的体积大于背包剩余体积时，根本放不进去。
if(当前物品的体积小于等于背包剩余体积时) dp[i][j]=max(dp[i-1][j-物品体积]+物品重量, dp[i-1][j])
if(当前物品的体积大于背包剩余体积时) dp[i][j]=dp[i-1][j]
（3）边界
二维的边界是一维数组（类似于一维数组的边界是前面的数值）：dp[0][1] 、dp[0][2]、 …dp[0][n]。如图所示，也就是先把第一行填成0。
| 物品/体积 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 没有物体 | 0 | 0 | 0 | 0 | 0 | 0 |
| 第1个物品 | ||||||
| 第2个物品 | ||||||
| 第3个物品 |
如果你一开始没思考好边界，那么写主要代码时也能感受出边界是什么。你看这行关键代码，dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);我们的i是从1开始的，那么dp[i-1][]是不是没有值呀？那就需要提前表示出来，那它就是边界。
（4）递推的感觉是，整体从上往下推（第一重循环），每一行从左往右推（第二重循环）。
| 物品/体积 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 第0个物品 | 0 | 0 | 0 | 0 | 0 | 0 |
| 第1个物品 ↓ | → | → | → | → | → | → |
| 第2个物品 ↓ | ||||||
| 第3个物品 ↓ |
#include <bits/stdc++.h>
using namespace std;
/*
dp[i][j]表示放入第i个包时，背包剩余体积为j时的最大重量
*/
int main(int argc, char *argv[])
{
int N,V;
int dp[21][1010];
int w[21];
int v[21];
cout<<"how many stuff?"<<endl;
cin>>N;//输入有几个物品
cout<<"the volumn of bag:"<<endl;
cin>>V;//背包的最大体积
for(int i=1;i<=N;i++){
cout<<"bag "<<i<<endl;
cin>>w[i]>>v[i]; //输入每个物品的重量 ，体积
}
/*----边界-------*/
for(int j=0;j<=V;j++){ //边界条件
dp[0][j]=0;
}
for(int i=1;i<=N;i++){
for(int j=0;j<=V;j++){
if(j>=v[i]) //放得下，可选择放或者不放
dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
else //放不下，只能不放
dp[i][j]=dp[i-1][j];
}
}
cout<<dp[N][V]<<endl;
return 0;
}
4.最长公共子序列
注意：
（1）定义子问题：
dp[i][j]字符串A的前i个和字符串B的前j个拥有的最长公共子序列的长度
（2）子问题的递推关系：
（3）边界
当其中一个子序列为空时，公共子序列个数为0。所以dp的边界如下图所示
| 字符串a/字符串b | A | B | B | D | A | |
|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | |
| B | 0 | |||||
| D | 0 | |||||
| C | 0 | |||||
| A | 0 | |||||
| 本次代码中对边界的赋值也比较巧妙，直接memset(dp,0,sizeof(dp)) |
4.1 如果单纯求最长公共子序列的个数：
#include <bits/stdc++.h>
using namespace std;
/*
dp[i][j]字符串A的前i个和字符串B的前j个拥有的最长公共子序列的长度
*/
int main()
{
int dp[101][101]; //字符串长度最长100
string a,b;
cin>>a;
cin>>b;
/*----------边界----------*/
memset(dp,0,sizeof(dp));
/*----------递推-----------*/
for(int i=1;i<=a.size();i++){
for(int j=1;j<=b.size();j++){
if(a[i]==b[j])
dp[i][j]=dp[i-1][j-1]+1;
else
dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
}
}
cout<<"The amount of the same subset is:"<<dp[a.size()][b.size()]<<endl;;
return 0;
}
4.2 如果还要输出最长公共子序列，那么还要加上回溯的操作
这就需要我们区分当a[i]!=b[j]时，到底选的哪一个。因为回溯的时候涉及到了字符串a和字符串b各自指针的移动，到底移动a的字符串还是b的就得看选的哪一种情况。
这里借助和dp一样大小的数组来记录。
#include <bits/stdc++.h>
using namespace std;
/*
dp[i][j]字符串A的前i个和字符串B的前j个拥有的最长公共子序列的长度
*/
int dp[101][101]; //字符串长度最长100
int note[101][101];
string a,b;
void printIt(int i,int j){
if(i==0||j==0) return; //别忘了递归出口
if(note[i][j]==1){
printIt(i-1,j-1);
cout<<a[i-1]; //先找到的后输出
}else if(note[i][j]==2){
printIt(i-1,j);
}else
printIt(i,j-1);
}
int main()
{
cin>>a;
cin>>b;
/*----------边界----------*/
memset(dp,0,sizeof(dp));
memset(note,0,sizeof(note));
/*----------递推-----------*/
for(int i=1;i<=a.size();i++){
for(int j=1;j<=b.size();j++){
if(a[i]==b[j]){
dp[i][j]=dp[i-1][j-1]+1;
note[i][j]=1; //做个标记
}
else{
if(dp[i-1][j]>dp[i][j-1]){
dp[i][j]=dp[i-1][j];
note[i][j]=2; //做个标记
}else{
dp[i][j]=dp[i][j-1];
note[i][j]=3; //做个标记
}
}
}
}
cout<<"The amount of the same subset is:"<<dp[a.size()][b.size()]<<endl;
/*--------输出最长公共子序列---------*/
printIt(a.size(),b.size());
return 0;
}
5.最长上升子序列
首先区分最长上升子序列（左）和最长不下降子序列（右）。
思路：
（1）定义子问题：dp[i]表示以第i个数结尾的最长上升子序列的个数
（2）边界：dp[1]=1
（3）子问题的递推关系：
比如说当前子序列是5 2 3 7 4 6，我要求dp[6]。我地去6前面找比6小的数，看他们谁的dp[j]+1最大，这个最大值就是dp[6]
注意：
这个题不是dp[n]就是最终答案（这和子问题的定义有关）。需要用ans一直记录当前情况下的最长上升子序列个数。最终答案是ans。如果你不用ans记录的话，需要最后来个排序，求出dp数组的最大值。
# include<bits/stdc++.h>
using namespace std;
int main(){
int a[100+1];
int dp[100+1];
char y;
int k=1;
do{
scanf("%d",&a[k]) ;
k++; //一共输入了k-1个
}while((y=getchar())!='\n');
/*------边界-------*/
dp[1]=1;
/*----------------*/
int ans=1; //一直更新这个最大值
for(int i=2;i<=k-1;i++){
dp[i]=1; //至少是1吧
for(int j=1;j<i;j++){ //内层循环找到了比自己小的数的dp最大值
if(a[j]<a[i]){
dp[i]=max(dp[i],dp[j]+1);
}
}
ans=max(ans,dp[i]); //但那个最大值不一定是整体的最大值
}
printf("%d",ans);
return 0;
}
如果要打印最长上升子序列：找到那个dp[i]=ans的i。遍历a[1]到a[i]输出比a[i]小的数。
38万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
