第11章——动态规划

11.1.1什么是动态规划
是一种解决最优化问题的算法思想。简单来说，动态规划将一个复杂的问题分解为多个子问题，通过综合子问题的解来得到问题的最优解。
需要注意的是，动规将每个求解的子问题的解记录下来，这样当碰到相同问题时，直接使用结果，而不是重复计算。（提高效率，但不是核心）
一般用递归或者递推来实现动规，其中递归此处又称记忆化搜索。
11.1.2 动规的递归写法
为避免重复计算，可开一个数组。
斐波那契数列为例

int F(int n){
	if(n==0||n==1)
	return 1;
	if(dp[n]!=-1)
	return dp[n];
	else{
		dp[n]=F(n-1)+F(n-2);
		return dp[n];
	}
}

这又引出一个概念：如果一个问题可以划分为若干个子问题，且这些子问题会重复出现，那么称这个为重叠子问题。一个问题必须有重叠子问题，才可以使用动态规划。
11.1.3 动规的递推写法
状态转移方程
使用递推方法：自底而上
使用递归方法：自顶而下

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1000;
int f[maxn][maxn],dp[maxn][maxn];
int main (){
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++)
		scanf("%d",&f[i][j]); 
	}
	for(int j=1;j<=n;j++)
	dp[n][j]=f[n][j];
	for(int i=n-1;i>=1;i++){
		for(int j=1;j<=i;j++){
			dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+f[i][j];
		}
	}
	printf("%d\n",dp[1][1]);
	return 0;
}

通过例题再引申出一个概念，如果一个问题的最优解可以由子问题的最优解有效的构造出来，那么称这个问题叫做最优子结构。
一个问题必须拥有最优子结构和重叠子问题，才能使用动态规划。
下面指出概念的区别：
（1）分治与动态规划：
分治和动规都是将问题分成子问题，然后合并子问题的解到原问题的解。分治的子问题不拥有重叠子结构，而动规必须要是重叠子结构。
例如：归并排序和快排，都是分别处理左序列和右序列，然后合并。其中没有重叠子问题，所以用的是分治。
（2）贪心与动态规划：贪心和动规都要求原问题要有最优子结构。二者的区别在于，贪心的计算方法类似于“自顶而上”，但不用等待子问题求解完毕之后再选择哪一个，而是选择一种策略直接选择一个子问题去求解，没有选择的子问题直接抛去。也就是说，他总是在上一步选择完之后，继续选择，即这种所谓“最优选择”的正确性必须用归纳法证明。所以说，贪心像壮士断腕，既然选择，就不后悔。而动规需要看那个笑到最后，暂时领先说明不了什么。
11.2 最大连续子序列和

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=10010;
int A[maxn][maxn],dp[maxn][maxn];
int main (){
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&A[i]);
	}
	dp[0]=A[0];
	for(int i=1;i<n;i++){
		dp[i]=max(A[i],dp[i-1]+A[i]);
	}
	int k=0;
	for(int i=1;i<n;i++){
		if(dp[i]>dp[k])
		k=i;
	}
	printf("%d\n",dp[k]);
	return 0;
} 

此处状态无后效性：当前状态记录历史信息，一旦当前状态确定，就不会再改变，且未来的决策只能在已有的状态下进行。
当然不是所有状态都是无后效性的。设计状态和状态转移方程，才是动态规划的核心。
11.3 最长不下降子序列（LIS）
最长不下降子序列是找到最长的子序列，使得这个子序列是非递减的。

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=100;
int A[maxn],dp[maxn];
int main (){
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	scanf("%d",&A[i]);
	int ans=-1;
	for(int i=1;i<=n;i++){
		dp[i]=1;
		for(int j=1;j<=i;j++){
			if(A[i]>=A[j]&&dp[j]+1>dp[i]){
				dp[i]=dp[j]+1;
			}
		}
		ans=max(ans,dp[i]);
	}
	printf("%d\n",ans);
	return 0;
} 

11.4 最长公共子序列（LCS）
给定两个字符串（或者数字序列），求一个字符串，使得这个字符串是A和B的最长公共部分

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=100;
char A[maxn],B[maxn];
int dp[maxn][maxn];
int main(){
	int n;
	gets(A+1); //从下标1，开始读入 
	gets(B+1);
	int lenA=strlen(A+1); //由于读取从从1开始，所以读取长度也从1开始 
	int lenB=strlen(B+1); 
	for(int i=0;i<=lenA;i++)
	dp[i][0]=0; 
	for(int j=0;j<=lenB;j++)
	dp[0][j]=0;
	for(int i=1;i<=lenA;i++){
		for(int j=1;j<=lenB;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]); 
		}
	}
	printf("%d",dp[lenA][lenB]);
	return 0;
}

11.5 最长回文子串

#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1010;
char s[maxn];
int dp[maxn][maxn];
int main (){
	gets(s);
	int len=strlen(s);
	int ans=1;
	memset(dp,0,sizeof(dp));
	for(int i=0;i<len;i++){
		dp[1][1]=1;
		if(i<len-1){
			if(s[i]==s[i+1]){
				dp[i][i+1]=1;
				ans=2;
			}
		}
	}
	for(int L=3;L<=len;L++){  //枚举字串的长度 
		for(int i=0;i+L-1<len;i++){  //枚举字串的起始长度 
			int j=i+L-1;
			if(s[i]==s[j]&&dp[i+1][j-1]==1)
			dp[i][j]=1;
			ans=L;
		}
	}
	printf("%d\n",ans);
	return 0;
}

11.6 DAG最长路
DAG是有向无环图，DAG上的最长路或者最短路是一类很重要的问题，DAG最长路径和最短路径思想一致。
（1）求DAG中最长路径（不固定起点和终点）
（2）固定终点，求最长路径
11.7背包问题
11.7.1 多阶段动态规划问题
有若干个有序的阶段，每个阶段之和上一阶段有关，，一般把这类问题称为多阶段动态规划问题。
11.7.2 01背包问题
令dp[i][v]表示前i件物品，恰好装入容量为v的背包中所获得最大的价值。
对第i件有两种策略：
（1）不放第i件物品，那么问题转化为前i-1件物品恰好装入容量为v的背包，所获得最大的价值，也即dp[i-1][v]。
（2）放第i件物品，那么问题就转化为前i-1件物品恰好装入容量为v-w【i】的背包所获得的最大的价值，也即dp[i-1][v-w[i]]+c[i];
因此为dp[i][v]=max{dp[i-1][v],dp[i-1][v[w[i]]+c[i]}
边界：dp[0][v]=0;

for(int i=1;i<=n;i++){
	for(int v=w[i];v<=V;v++){
		dp[i][v]=max(dp[i-1][v],dp[i-1][v[w[i]]]+c[i]);
	}
}

滚动数组：

for(int i=1;i<=n;i++){
	for(int v=V;v>=w[i];v--){
		dp[v]=max(dp[v],dp[v[w[i]]]+c[i]);
	}
}

特别说明：如果是二维数组存放，v的枚举无论是顺序还是逆序都可以，一维数组，v的枚举必须是逆序
11.7.3 完全背包问题
（1）不放第i件：dp[i][v]=dp[i-1][v];
(2)放第i件：dp[i][v]=dp[i][v-w[i]]+c[i]; //每种可放任意件
一维状态转移方程：dp[v]=max(dp[v]+dp[v-w[i]]+c[i]);
11.8 总结