算法基础精选题单动态规划（dp）（区间dp）（个人题解）

最新推荐文章于 2024-07-25 21:13:04 发布

*goliter *

最新推荐文章于 2024-07-25 21:13:04 发布

阅读量982

点赞数 29

分类专栏：【237题】算法基础精选题单（牛客）（个人题解+刷题记录）文章标签：算法动态规划

本文链接：https://blog.csdn.net/Wzh20060111/article/details/139862569

版权

【237题】算法基础精选题单（牛客）（个人题解+刷题记录）专栏收录该内容

5 篇文章 0 订阅

订阅专栏

前言：

正文：

题单：【237题】算法基础精选题单_ACM竞赛_ACM/CSP/ICPC/CCPC/比赛经验/题解/资讯_牛客竞赛OJ_牛客网 (nowcoder.com)

NC16645 [NOIP2007]矩阵取数游戏：

NC207781 迁徙过程中的河流：

后记：

前言：

这些dp对我来说就没那么简单了，但写过这些题目之后我确实对区间dp有了一个简单的认识，区间dp一般都是二维的，由第一维表示左端点，第二维表示右端点，且状态一般由区间长度小的转移而来，所以我们写dp的转移时第一层循环由len来从小枚举区间长度，第二层循环枚举区间的左端点l，右端点就可以直接表示为l+len-1（也可先枚举右端点，再从右端点往左枚举左端点），初始化和状态转移方程就得根据相应题目来了，在写这写题目时我也学会了其他的一些技巧，比如环形数组的题该如何写以及__int128的用法（用来处理一些暴long long）的情况。

正文：

题单：【237题】算法基础精选题单_ACM竞赛_ACM/CSP/ICPC/CCPC/比赛经验/题解/资讯_牛客竞赛OJ_牛客网 (nowcoder.com)

NC50493 石子合并：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[410],dp1[410][410],dp2[410][410],pre[410];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		a[i+n]=a[i];
	}
	for(int i=1;i<=2*n;i++){
		pre[i]=pre[i-1]+a[i];
	}
	memset(dp1,127,sizeof(dp1));
	memset(dp2,0,sizeof(dp2));
	for(int j=1;j<=2*n;j++){
		for(int i=j;i>=1;i--){
			if(i==j)dp1[i][j]=dp2[i][j]=0;
			for(int k=i;k<j;k++){
				dp1[i][j]=min(dp1[i][k]+dp1[k+1][j]+pre[j]-pre[i-1],dp1[i][j]);
				dp2[i][j]=max(dp2[i][k]+dp2[k+1][j]+pre[j]-pre[i-1],dp2[i][j]);
			}
			//cout<<i<<" "<<j<<" "<<dp1[i][j]<<endl;
		}
	}
	ll ansn=0x3f3f3f3f,ansm=0;
	for(int i=1;i<=n;i++){
		ansn=min(ansn,dp1[i][i+n-1]);
		ansm=max(ansm,dp2[i][i+n-1]);
	}
	cout<<ansn<<endl<<ansm<<endl;
	return 0;
}

这题原型是比较经典的模板题，这题在原题上做了些修改，一是要求最小和最大的值，二是这是个环形的数组；对于一我们处理两个不同初值的dp数组，分别求min,max，对于二我们则将数组扩大到2n，a[n+i]=a[i]，这样枚举就能表示环形数组的所有情况，不过最后我们求答案时也要枚举所有长度为n的区间dp值。

dp的初始状态为 dp[i][j]=0（i==j ）

dp的状态转移方程我们可以知道为:

$dp[i][j]=dp[i,k]+dp[k+1,j]+pre[j]-pre[i-1]$

其中dp[i][j]表示将从石头i到石头j合并的得分（dp1为最小，dp2为最大）（同理dp[i][k]及dp[j]），pre[j]-pre[i-1]为此次合并的得分，由前缀和表示。

由此得结果。

NC50500 凸多边形的划分：

#include<bits/stdc++.h>
using namespace std;
__int128 read(){
	//直接在函数里面实现读字符串操作更简洁
	__int128 res=0;//初始结果赋值0
	char scan[1005];
	scanf("%s",scan);
	for(int i=0;i<strlen(scan);i++)
		res*=10,res+=scan[i]-'0';//实现进位
	return res;//返回__int128类型
}
void print(__int128 num){//递归调用，实现从高位向低位输出
	if(num>9) print(num/10);
	putchar(num%10+'0');
}
__int128 a[55],dp[55][55];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		a[i]=read();
	}
	for(int l=3;l<=n;l++){
		for(int i=1;i+l-1<=n;i++){
			int j=i+l-1;
			dp[i][j]=1e30;
			for(int k=i+1;k<j;k++){
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]+a[i]*a[k]*a[j]);
			}
		}
	}
	print(dp[1][n]);
	return 0;
}

这题像是能量项链的变式。状态转移方程为下：

$dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]+a[i]*a[k]*a[j])$

画个图大家自己体会下（可能不是很形象）：

其中dp[i][j]表示将i到j点这个多边形分割后权值和的最小值(i,j在这里是一个表示首，一个表示尾)，

a[i]*a[k]*a[j]为这个三角形的权值。

由于要求最小值，所以初始化为最大数，在加上数据会暴long long ，所以这里就要用到__int128了，他可以表示-2^127~2^127大小的数，但不能直接输入输出，必须采用我代码中那样的自定义函数。

NC235246 田忌赛马：

#include<bits/stdc++.h>
using namespace std;
const int N=2005;
int a[N],b[N],g[N][N],dp[N][N];
bool cmp(int n1,int n2){
	return n1>n2;
}
int main(){
	int n,ans;
	cin>>n;
	for(int i=1;i<=n;++i)cin>>a[i];
	for(int i=1;i<=n;++i)cin>>b[i];
	sort(a+1,a+n+1,cmp),sort(b+1,b+n+1,cmp);
	for(int i=1;i<=n;++i)
		for(int j=1;j<=n;++j){
			if(a[i]>b[j]) g[i][j]=200;
			else if(a[i]==b[j]) g[i][j]=0;
			else g[i][j]=-200;
		}
	for(int i=1;i<=n;++i){
		dp[i][0]=dp[i-1][0]+g[n-i+1][i];
		dp[i][i]=dp[i-1][i-1]+g[i][i];
		for(int j=1;j<i;++j) dp[i][j]=max(dp[i-1][j]+g[n-i+j+1][i],dp[i-1][j-1]+g[j][i]);
	}
	ans=dp[n][1];
	for(int i=2;i<=n;++i)ans=max(ans,dp[n][i]);
	cout<<ans<<endl;
	return 0;
}

首先给国王和田忌的马从小到大排序

接下来是贪心策略：

首先比最快的马，如果能赢就直接赢。
如果赢不了，就比国王和田忌最慢的马，能赢就赢。
如果最慢的马也赢不了，就用最慢的马去对国王最快的马。

设dp[i][j]表示齐王按从强到弱的顺序出马和田忌进行了i场比赛之后，从""头""取了j匹较强的马，从""尾""取了i-j匹较弱的马，所能获得的最大盈利。

其中g[i][j]表示田忌的马和齐王的马分别按照由强到弱的顺序排序之后，田忌的第 i 匹马和齐王的第 j 匹马赛跑所能取得的盈利，胜为 200 ，负为 −200 ，平为 0。

得状态转移方程为：

$dp[i][j]=max(dp[i-1][j]+g[n-i+j+1][i],dp[i-1][j-1]+g[j][i]$

NC13230 合并回文子串:

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e6+5;
char a[N],b[N];
ll dp[55][55][55][55];
int main(){
	int t;
	cin>>t;
	while(t--){
		memset(dp,0,sizeof(dp));
		int ans=0;
		scanf("%s",a+1);
		scanf("%s",b+1);
		int sa=strlen(a+1),sb=strlen(b+1);
		for(int x=0;x<=sa;x++){
			for(int y=0;y<=sb;y++){
				for(int i=1,j=x;j<=sa;i++,j++){
					for(int k=1,l=y;l<=sb;k++,l++){
						if(x+y<=1) dp[i][j][k][l]=1;
						else{
							if(a[i]==a[j]) dp[i][j][k][l]|=dp[i+1][j-1][k][l];
                            if(b[k]==b[l]) dp[i][j][k][l]|=dp[i][j][k+1][l-1];
                            if(a[i]==b[l]) dp[i][j][k][l]|=dp[i+1][j][k][l-1];
                            if(b[k]==a[j]) dp[i][j][k][l]|=dp[i][j-1][k+1][l];
						}
						if(dp[i][j][k][l])ans=max(ans,x+y);
					}
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}

初始状态只有一个字母的状态一定是回文。

假设A[i] ~ A[j]与B[k] ~ B[l]构成了一个回文串(这里设dp[i][j][k][l])，则他能转移到的区间有
1：a[i-1]==a[j+1]时 dp[i-1][j+1][k][l]
2：a[i-1]==b[l+1]时 dp[i-1][j][k][l+1]
3：b[k-1]==a[j+1]时 dp[i][j+1][k-1][l]
4：b[k-1]==b[l+1]时 dp[i][j][k-1][l+1]
那么对应的转移方程就为

$if(a[i]==a[j]) dp[i][j][k][l]|=dp[i+1][j-1][k][l];$

$if(a[i]==b[l]) dp[i][j][k][l]|=dp[i+1][j][k][l-1];$

$if(b[k]==b[l]) dp[i][j][k][l]|=dp[i][j][k+1][l-1];$

$if(b[k]==a[j]) dp[i][j][k][l]|=dp[i][j-1][k+1][l];$

NC16645 [NOIP2007]矩阵取数游戏：

#include<bits/stdc++.h>
using namespace std;
__int128 read(){
    //直接在函数里面实现读字符串操作更简洁
    __int128 res=0;//初始结果赋值0
    char scan[1005];
    scanf("%s",scan);
    for(int i=0;i<strlen(scan);i++)
        res*=10,res+=scan[i]-'0';//实现进位
    return res;//返回__int128类型
}
void print(__int128 num){//递归调用，实现从高位向低位输出
    if(num>9) print(num/10);
    putchar(num%10+'0');
}
typedef long long ll;
__int128 pow2(__int128 a,__int128 b){
	__int128 res=1;
	while(b){
		if(b&1)res*=a;
		a*=a,b/=2;
	}
	return res;
}
__int128 a[100][100];
__int128 dp[100][100][100];
int main(){
	ll n,m;
	__int128 ans=0;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			a[i][j]=read();
		}
	}
	for(int k=1;k<=n;k++){
		for(int len=1;len<=m;len++){
			for(int i=1;i<=m,i+len-1<=m;i++){
				int j=i+len-1;
				if(i==j)dp[i][j][k]=a[k][i]*pow2(2,m-len+1);
				else dp[i][j][k]=max(dp[i+1][j][k]+a[k][i]*pow2(2,m-len+1),dp[i][j-1][k]+a[k][j]*pow2(2,m-len+1));
				//cout<<i<<" "<<j<<" "<<k<<" "<<dp[i][j][k]<<endl;
			}
		}
		//cout<<dp[1][m][k]<<endl;
		ans+=dp[1][m][k];
	}
	print(ans);
	return 0;
}

（自己独立思考写出来的，很有成就感）

因为每次只能取行首或者行尾，所以每行取得顺序都是独立的，由此可以从求最大的得分和转换成求每行的最大得分和。然后用区间dp计算每一行，状态转移方程为：

$dp[i][j][k]=max(dp[i+1][j][k]+a[k][i]*pow2(2,m-len+1),dp[i][j-1][k]+a[k][j]*pow2(2,m-len+1))$

k表示第几行.i,j表示区间，a[k][i]*pow2(2,m-len+1)表示取该数的得分，根据len来判断这次为第几次取数。

NC207781 迁徙过程中的河流：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[100005],dp[100005];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	sort(a+1,a+n+1);
	dp[1]=a[1];dp[2]=a[2];
	for(int i=3;i<=n;i++){
		dp[i]=min(dp[i-1]+a[1]+a[i],dp[i-2]+a[1]+2*a[2]+a[i]);
	}
	cout<<dp[n];
	return 0;
}

说实话这题更像是线性dp，从题目中规律可以看出来在某个人要过河的时候要么是最快的那个人来接他，要么是还剩下两个让最快的把船开回来然后让这两个过去，之后让第二快的把船开过来，全部过去。这两个在题目中的样例里面都有体现。转移方程为：

$dp[i]=min(dp[i-1]+a[1]+a[i],dp[i-2]+a[1]+2*a[2]+a[i])$

后记：

题对我确实很难，不过我也还算收获满满，写博客过程中也相当于是把写题过程在梳理了一遍，希望这篇博客不只能帮助到我自己吧。

*goliter *

关注

29
点赞
踩
25

收藏

觉得还不错? 一键收藏
2
评论
算法基础精选题单动态规划（dp）（区间dp）（个人题解）

目录前言：正文：题单：【237题】算法基础精选题单_ACM竞赛_ACM/CSP/ICPC/CCPC/比赛经验/题解/资讯_牛客竞赛OJ_牛客网 (nowcoder.com)NC50493 石子合并：NC50500 凸多边形的划分：NC235246 田忌赛马：NC13230 合并回文子串:NC16645 [NOIP2007]矩阵取数游戏：NC207781 迁徙过程中的河流：后记：这些dp对我来说就没那么简单了，但写过这些题目之后我确实对区间dp有了一个简单的认识，区间dp一般都是二维的，由第一维表示左
复制链接

扫一扫