区间DP入门题目 acwing 算法基础课+提高课

最新推荐文章于 2024-08-22 17:27:46 发布

灬德布罗意的猫灬

最新推荐文章于 2024-08-22 17:27:46 发布

阅读量70

点赞数

分类专栏： DP 文章标签：算法动态规划 c++ 学习

本文链接：https://blog.csdn.net/m0_60921016/article/details/129719003

版权

DP 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

这几天算法设计课上在学区间DP，借这个机会简单整理一下区间DP的思路和题目

我将介绍并分析以下几道典型的区间DP题目：

282. 石子合并 - AcWing题库

1068. 环形石子合并 - AcWing题库

320. 能量项链 - AcWing题库

479. 加分二叉树 - AcWing题库

石子合并

设有 N堆石子排成一排，其编号为 1,2,3,…,N

每堆石子有一定的质量，可以用一个整数来描述，现在要将这 N 堆石子合并成为一堆。

每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。

问题是：找出一种合理的方法，使总的代价最小，输出最小代价。

输入格式

第一行一个数 N 表示石子的堆数。

第二行 N 个数，表示每堆石子的质量(均不超过 1000)。

输出格式

输出一个整数，表示最小代价。

数据范围

1≤N≤300

输入样例：

4
1 3 5 2

输出样例：

这是一道入门区间DP问题：

我们主要从本题中抽象出区间DP的一般枚举思路

len（长度）

起点

断点

#include<iostream>
using namespace std;
const int N=310;
int n;
int s[N];
int f[N][N];
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		int x;
		cin>>x;
		s[i]=s[i-1]+x;
	}
	
	for(int len=1;len<=n;len++)
	 for(int i=1;i+len-1<=n;i++)
	 {
	 	int j=i+len-1;
	 	if(i==j)f[i][j]=0;
	 	else  f[i][j]=1e18;
	 	for(int k=i;k<j;k++)
	 	 f[i][j]=min(f[i][k]+f[k+1][j]+s[j]-s[i-1],f[i][j]);
	 }	 
	 
	 cout<<f[1][n];
	
}

还有一点要注意的就是我们初始状态的确定一定要仔细~~

环形石子合并

将 n 堆石子绕圆形操场排放，现要将石子有序地合并成一堆。

规定每次只能选相邻的两堆合并成新的一堆，并将新的一堆的石子数记做该次合并的得分。

请编写一个程序，读入堆数 n及每堆的石子数，并进行如下计算：

选择一种合并石子的方案，使得做 n−1 次合并得分总和最大。
选择一种合并石子的方案，使得做 n−1 次合并得分总和最小。

输入格式:

第一行包含整数 n，表示共有 n 堆石子。

第二行包含 n 个整数，分别表示每堆石子的数量。

输出格式:

输出共两行：

第一行为合并得分总和最小值，

第二行为合并得分总和最大值。

数据范围

1≤n≤200

输入样例：

4
4 5 9 4

输出样例：

43
54

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int n;
int a[N];
int f[N][N][2];
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		int x;
		cin>>x;
		a[i]=a[n+i]=x;
	}
	for(int i=1;i<=n*2;i++)a[i]+=a[i-1];
	
	for(int len=1;len<=n;len++)
	 for(int i=1;i+len-1<=2*n;i++)
	  {
	  	int j=i+len-1;
	  	
	  	if(i==j)f[i][j][0]=f[i][j][1]=0;
	  	
	  	else 
	  	{
	  		f[i][j][0]=0x3f3f3f3f;
	  		f[i][j][1]=-0x3f3f3f3f;
	  	}
	  	
	  	for(int k=i;k<j;k++)
	  	{
	  		f[i][j][0]=min(f[i][j][0],f[i][k][0]+f[k+1][j][0]+a[j]-a[i-1]);
	  		f[i][j][1]=max(f[i][j][1],f[i][k][1]+f[k+1][j][1]+a[j]-a[i-1]);
	  	}
	  	 
	  }
	 int res1=0x3f3f3f3f;
	 int res2=-0x3f3f3f3f; 
	for(int i=1;i+n-1<=2*n;i++)
	{
		res1=min(res1,f[i][i+n-1][0]);
		res2=max(res2,f[i][i+n-1][1]);
	}
	
	cout<<res1<<endl<<res2;
	 

}

环形石子合并，经典破环成链，然后对两倍长度做石子合并然后找n长度的答案就可以了~

能量项链

在 Mars 星球上，每个 Mars 人都随身佩带着一串能量项链，在项链上有 N 颗能量珠。

能量珠是一颗有头标记与尾标记的珠子，这些标记对应着某个正整数。

并且，对于相邻的两颗珠子，前一颗珠子的尾标记一定等于后一颗珠子的头标记。

因为只有这样，通过吸盘（吸盘是 Mars 人吸收能量的一种器官）的作用，这两颗珠子才能聚合成一颗珠子，同时释放出可以被吸盘吸收的能量。

如果前一颗能量珠的头标记为 m，尾标记为 r，后一颗能量珠的头标记为 r，尾标记为 n，则聚合后释放的能量为 m×r×n（Mars 单位），新产生的珠子的头标记为 m，尾标记为 n。

需要时，Mars 人就用吸盘夹住相邻的两颗珠子，通过聚合得到能量，直到项链上只剩下一颗珠子为止。

显然，不同的聚合顺序得到的总能量是不同的，请你设计一个聚合顺序，使一串项链释放出的总能量最大。

例如：设 N=4，4颗珠子的头标记与尾标记依次为 (2，3)(3，5)(5，10)(10，2)

我们用记号 ⊕⊕ 表示两颗珠子的聚合操作，(j⊕k)表示第 j，k 两颗珠子聚合后所释放的能量。则

第 4、14、1 两颗珠子聚合后释放的能量为：(4⊕1)=10×2×3=60

这一串项链可以得到最优值的一个聚合顺序所释放的总能量为 ((4⊕1)⊕2)⊕3)=10×2×3+10×3×5+10×5×10=710

输入格式

输入的第一行是一个正整数 N，表示项链上珠子的个数。

第二行是 N 个用空格隔开的正整数，所有的数均不超过 1000，第 i 个数为第 i 颗珠子的头标记，当 i< 时，第 i 颗珠子的尾标记应该等于第 i+1 颗珠子的头标记，第 N 颗珠子的尾标记应该等于第 1 颗珠子的头标记。

至于珠子的顺序，你可以这样确定：将项链放到桌面上，不要出现交叉，随意指定第一颗珠子，然后按顺时针方向确定其他珠子的顺序。

输出格式

输出只有一行，是一个正整数 E，为一个最优聚合顺序所释放的总能量。

数据范围

4≤N≤100
1≤E≤2.1×109

输入样例：

4
2 3 5 10

输出样例：

这道题就是算法设计与分析课上讲的第一道矩阵连乘问题的环形版本从这道题目中可以发现

很多的题目的设计（那种偏算法的题目的设计其实就是很多知识点拼凑起来的~）

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int f[N][N];
int n;
int p[N];

int main()
{
	cin>>n;
	
	for(int i=1;i<=n;i++)
	 {
	 	int x;
	 	cin>>x;
	 	if(i==1)p[n]=p[n+n]=x;
	 	else p[i-1]=p[i-1+n]=x; 
	 	
	 }
	 
	 for(int len=1;len<=n;len++)
	  for(int i=1;i+len-1<=2*n;i++)
	  {
	  	int j=i+len-1;
	  	if(i==j)f[i][j]=0;
	  	else f[i][j]=-0x3f3f3f3f;
	  	
	  	for(int k=i;k<j;k++)
	  	 f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]+p[i-1]*p[k]*p[j]);
	  	
	  }
	int res=-0x3f3f3f3f;  
	for(int i=1;i+n-1<=2*n;i++)
     res=max(res,f[i][i+n-1]);
	

	  
	cout<<res;
	
	
	
}

二叉加分树

设一个 n 个节点的二叉树 tree 的中序遍历为（1,2,3,…,n），其中数字 1,2,3,…,n为节点编号。

每个节点都有一个分数（均为正整数），记第 i个节点的分数为 di，tree 及它的每个子树都有一个加分，任一棵子树 subtree（也包含 tree 本身）的加分计算方法如下：

subtree的左子树的加分 × subtree的右子树的加分＋ subtree的根的分数

若某个子树为空，规定其加分为 11。

叶子的加分就是叶节点本身的分数，不考虑它的空子树。

试求一棵符合中序遍历为（1,2,3,…,n）且加分最高的二叉树 tree。

要求输出：

（1）tree的最高加分

（2）tree的前序遍历

输入格式

第 1 行：一个整数 n，为节点个数。

第 2 行：n 个用空格隔开的整数，为每个节点的分数（0<分数<100）。

输出格式

第 1 行：一个整数，为最高加分（结果不会超过int范围）。

第 2 行：n个用空格隔开的整数，为该树的前序遍历。如果存在多种方案，则输出字典序最小的方案。

数据范围

n<30

输入样例：

5
5 7 1 2 10

输出样例：

145
3 1 2 4 5

这道题需要我们对问题分析之后转化成区间DP问题，同时简单记录以下结果的扩展情况然后跑一遍DFS用来输出结果就可以了

这里我们要学会的主要是特判的语法还有就是如何记录路径？如何像我们数据结构中学的那样来前序输出我们的前序遍历序列

#include<bits/stdc++.h>
using namespace std;
const int N=110;

int g[N][N];
int f[N][N];
int w[N];
int n;
void dfs(int l,int r)
{
	if(l>r)return;
	int k=g[l][r];
	printf("%d ",k);
	dfs(l,k-1),dfs(k+1,r);
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)cin>>w[i];
	
	for(int len=1;len<=n;len++)
	 for(int i=1;i+len-1<=n;i++)
	 {
	 	int j=i+len-1;
	 	if(i==j)f[i][j]=w[i],g[i][j]=i;
	    else
	 	{
	 		
	 	for(int k=i;k<=j;k++)
	 	{
	 		int t1 = k==i?1:f[i][k-1];
	 		int t2 = k==j?1:f[k+1][j];
	 		
	 		int score=t1*t2+w[k];
	 		
	 		if(score>f[i][j])
	 		{
	 			f[i][j]=score;
	 			g[i][j]=k;
	 		}
	 	}
	 		
	 		
	 	}
	 	
	 }
	 
	 cout<<f[1][n]<<endl;
	 
	 dfs(1,n);
	 
}

本题很容易犯错的就是在DP过程中丢了那个else 分析可以知道如果我们i==j的时候不加限制，也会进行k的遍历更新 w[k]+1>w[k] 这是非常容易犯错的地方必须严格的注意一下这一点~~