动态规划

1 动态规划

递推写法：自底向上；递归写法：自顶向下

一个问题必须拥有重叠子问题和最优子结构，才能用动态规划去解决。

1.1 分治与动态规划

共同点：都是将问题分解为子问题，然后合并子问题的解得到原问题的解。

不同点：分治法解决的问题不拥有重叠子问题，而动态规划解决的问题拥有重叠子问题；分治法解决的问题不一定是最优化问题，而动态规划解决的问题一定是最优化问题。

1.2 贪心与动态规划

共同点：都要求原问题必须拥有最优子结构

不同点：动态规划是从边界开始向上得到目标问题的解，贪心不一定得到最优解

2 最大连续子序列和

#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=10010;
int a[maxn],dp[maxn];	//a[i]存放序列，dp[i]存放以a[i]结尾的连续序列的最大和 

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=i;i<n;i++){
		//状态转移方程
		dp[i]=max(a[i],dp[i-1]+a[i]); 
	} 
	//得到dp数组的最大值 
	int k=0;
	for(int i=1;i<n;i++){
		if(dp[i]>dp[k])
			k=i;
	} 
	printf("%d\n",dp[k]);
	return 0;
}

3 最长不下降子序列LIS

#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=10010;
int a[maxn],dp[maxn];

int main(){
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	int ans=-1;
	for(int i=0;i<n;i++){
		dp[i]=1;
		for(int j=0;j<i;j++){
			if(a[j]<=a[i]&&dp[j]+1>dp[i])
				dp[i]=dp[j]+1;	//状态转移方程，用以更新dp[i] 
		}
		ans=max(ans,dp[i]);
	}
	printf("%d",ans);
	return 0;
} 

4 最长公共子序列LCS

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std; 
const int N=100;
char a[N],b[N];
int dp[N][N];
int main(){
	int n;
	gets(a+1);	//从下标为1开始读入 
	gets(b+1);
	int lena=strlen(a+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]);
		}
	} 
	//dp[lena][lenb]是答案
	printf("%d\n",dp[lena][lenb]); 
	return 0;
} 

5 最长回文子串

#include<stdio.h>
#include<string.h>
const int maxn=1010;
char s[maxn];
int dp[maxn][maxn];	//dp[i][j]表示从i到j是否有回文串 

int main(){
	gets(s);
	int len=strlen(s),ans=1;	//ans是当前最长回文子串长度 
	//边界
	for(int i=0;i<len;i++){
		dp[i][i]=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;
}

6 DAG最长路

const int maxn=1010;
const int inf=1000000000;
int n;	//顶点数 
int g[maxn][maxn];	//g[i][j]存储从i到j的边权 
int dp[maxn]={0};	//dp[i]存储以i为起点的最长路径长度 
int choice[maxn]={-1};	//choice[i]存储以i为起点的最长路径后继结点 

int DP(int i){
	if(dp[i]>0) return dp[i];	//如果dp[i]已计算得到
	for(int j=0;j<n;j++){		//遍历i的所有出边 
		if(g[i][j]!=inf){
			int temp=DP(j)+g[i][j];	//单独计算，防止if中调用DP函数两次 
			if(temp>dp[i]){	//可以获得更长的路径 
				dp[i]=temp;	//覆盖dp[i] 
				choice[i]=j;	
			}
		}
	}
	return dp[i]; 
}

//调用printPath前需要先得到最大的dp[i]，然后将i作为路径起点传入 
void printPath(int i){
	printf("%d",i);
	while(choice[i]!=-1){
		i=choice[i];
		printf("->%d",i);
	}
} 

7 背包问题

#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=100;	//物品最大件数
const int maxv=1000;//V的上限
int w[maxn],c[maxn],dp[maxv]; 
int main(){
	int n,V;
	scanf("%d%d",&n,&V);
	for(int i=0;i<n;i++)
		scanf("%d",&w[i]);
	for(int i=0;i<n;i++)
		scanf("%d",&c[i]);
	//边界
	for(int v=0;v<=V;v++)
		dp[v]=0;
	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]);
	}	
//	for(int i=1;i<=n;i++){
//		for(int v=w[i];v<=V;v++){
//			dp[i][v]=max(dp[i][v],dp[i][v-w[i]]+c[i]);
//		}
//	}
	
	//完全背包问题
	for(int i=0;i<=n;i++){
		for(int v=w[i];v<=V;v++){	//正向枚举v 
			dp[v]=max(dp[v],dp[v-w[i]]+c[i]);
		}
	} 
	//寻找dp[0...V]中最大值
	int max=0;
	for(int v=0;v<=V;v++){
		if(dp[v]>max)
			max=dp[v];
	} 
	printf("%d\n",max); 
	return 0;
}