【集训day4】动态规划

线性DP

1.最长上升子序列

#include<stdio.h>
#include<algorithm>
using namespace std;
int dp[505][505];
int a[505][505];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++){
			scanf("%d",&a[i][j]);
		}
	}
	int ma=-999999999;
	dp[1][1]=a[1][1];
	for(int i=2;i<=n;i++){
		for(int j=1;j<=i;j++){
			dp[i][j]=a[i][j]+max(dp[i-1][j],dp[i-1][j-1]);
		}
	}
	for(int i=1;i<=n;i++){
		ma=max(ma,dp[n][i]);
	}
	printf("%d",ma);
	return 0;
}

2.最长公共子序列

#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
char a[1005];
char b[1005];
int dp[1005][1005];
//dp[i][j]表示a序列的前i个位置与b序列的前j个位置的最长公共子序列
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		cin>>a[i];
		dp[i][0]=0;
	}
	for(int i=1;i<=m;i++) {
		cin>>b[i];
		dp[0][i]=0;
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
			//dp[i][j]从前两种状态中大的一种继承而来
			if(a[i]==b[j]) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
			//如果有新的公共部分，再决定是否更新dp[i][j]
		}
	}
	printf("%d",dp[n][m]);
	return 0;
 } 

3.最长公共上升子序列

#include<stdio.h>
#include<algorithm>
using namespace std;
int dp[3005][3005];
//最后一个公共数以b[j]为准 
int a[3005];
int b[3005];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n;i++) scanf("%d",&b[i]);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(a[i]==b[j]){//有新的公共数字出现 
				dp[i][j]=1;
				for(int k=1;k<j;k++){
					if(b[j]>b[k])
					dp[i][j]=max(dp[i][j],dp[i-1][k]+1);
				}
			}
			else dp[i][j]=dp[i-1][j];
		}
	}
	int ans =0;
    for(int i=1;i<=n;i++) ans=max(ans,dp[n][i]);
	printf("%d",ans);
	return 0;
 } 

4.数字三角形

#include<stdio.h>
#include<algorithm>
using namespace std;
int dp[1005][1005];
int a[1005][1005];
int main(){
	int r;
	scanf("%d",&r);
	for(int i=1;i<=r;i++){
		for(int j=1;j<=i;j++){
			scanf("%d",&a[i][j]);
		}
	}
	dp[1][1]=a[1][1];
	for(int i=2;i<=r;i++){
		for(int j=1;j<=i;j++){
			dp[i][j]=a[i][j]+max(dp[i-1][j],dp[i-1][j-1]);
		}
	}
	int ans=-1;
	for(int i=1;i<=r;i++){
		ans=max(ans,dp[r][i]);
	}
	printf("%d",ans);
	return 0;
}

区间DP

1.石子合并

考虑任意两堆石子l与r，当l与r能合并时，l-r中间的所有石子堆已经合并
阶段划分取决于当前石子堆数
如有n堆石子，最左边石子堆为l,最右边石子堆为r，可任意取其中相邻的两堆合并，dp[l][r]仅记录这些合并操作中花费最小的

初始条件：
1.当l=r时，这个代价应该就是0（自己与自己合并等于没合并）
2.由于要决出最小值，初始dp[l][r]应为无穷大(l≠r)

第一层循环：阶段
len=2时，逐个逐个计算相邻两堆的合并花费，如12合并，23合并……
len>2时，就可取任意两堆计算，如len=3时，既可知12,3合并花费，又可知1,23合并花费
后面k循环即划分出不同的合并情况

for(int len=2;len<=n;len++)

第二层循环：取端点
由于区间大小已定，只要确定左端点，右端点也随之确定

for(int l=1;l<=n-len+1;l++)
	r=l+len-1;

第三层循环： 实际上k的作用是划分出合并的中间点
状态转移：取能达到当前这两堆石子的状态的所有前一步合并方案中花费最小的那一个

for(int k=l;k<r;k++){
	dp[l][r]=min(dp[l][r],dp[l][k]+dp[k+1][r]);
}

更新：还要加上此时相邻的石子堆l与石子堆r的合并花费

	dp[l][r]=dp[l][r]+b[r]-b[l-1];//用前缀和计算区间和

#include<stdio.h>
#include<algorithm>
#define INF 0x3f3f3f3f
#define MAXN 305 
using namespace std;
const int maxn=305;
int dp[maxn][maxn];
int a[maxn];
int b[maxn];//用于计算前缀和 
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++) {//输入+计算前缀和 
		scanf("%d",&a[i]);
		if(i==1) b[1]=a[1];
		else b[i]=b[i-1]+a[i]; 
	}
	for(int i=1;i<=n;i++){//dp数组初始化 
		for(int j=1;j<=n;j++){
			if(i==j) dp[i][j]=0;
			else dp[i][j]=INF; 
		}
	}
	int l,r;
	for(int len=2;len<=n;len++){//计算 
		for(l=1;l<=n-len+1;l++){
			r=l+len-1;
			for(int k=l;k<r;k++){
				dp[l][r]=min(dp[l][r],dp[l][k]+dp[k+1][r]);
			}
			dp[l][r]+=b[r]-b[l-1];
			//printf("dp[%d][%d]=%d\n",l,r,dp[l][r]);
		}
	}
	printf("%d",dp[1][n]);
	return 0;
}

背包DP