P1880 [NOI1995] 石子合并------动态规划（区间dp）

题目描述

在一个圆形操场的四周摆放 N 堆石子，现要将石子有次序地合并成一堆，规定每次只能选相邻的 2 堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。

试设计出一个算法,计算出将 N 堆石子合并成 1 堆的最小得分和最大得分。

输入格式

数据的第 1 行是正整数 N，表示有 N 堆石子。

第 2 行有 N 个整数，第 i 个整数 ai​ 表示第 i 堆石子的个数。

输出格式

输出共 2 行，第 1 行为最小得分，第 2 行为最大得分。

输入输出样例

输入 #1复制

4
4 5 9 4

输出 #1复制

43
54

说明/提示

1≤N≤100，0≤ai​≤20。

 在写这题之前建议各位同志去看看董晓老师几分钟的小视频哈哈哈，大有帮助！

线性石子合并：E28【模板】区间DP 石子合并——信息学竞赛算法_哔哩哔哩_bilibili

环形石子合并：E29 区间DP 环形石子合并_哔哩哔哩_bilibili

 OK！相信各位都已经看完回来啦！是不是感觉长脑子了今天，还不快感谢俺！

 线性石子合并：

感觉跟我前面写过的回文串问题------动态规划-优快云博客有点像，大家不妨也可以去看看，嘿嘿

举例：

5
1 3 4 2 5

 下面是我根据自己的理解做的一个小图哈哈哈哈：

 线性石子合并代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int n;//石子堆数 
int a[N];//记录每堆石子的质量
int s[N];//记录前缀和
int dp[N][N];//dp[l][r]表示把石子从l到r合并成一堆石子的最小代价 
int main()
{
	//预处理 
	memset(dp,0x3f,sizeof(dp)); 
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];//每堆石子的质量 
		s[i]=s[i-1]+a[i];//前缀和 
		dp[i][i]=0;//单堆石子合并的代价为0 
	} 
	
	//状态计算
	for(int len=2;len<=n;len++)//阶段：枚举区间长度（先从长度为2开始）
	{
		for(int i=1;len+i-1<=n;i++)//状态：枚举区间起点 
		{
			int j=len+i-1;//区间终点
			for(int k=i;k<j;k++)//决策：枚举分割点
			{
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+s[j]-s[i-1]);
			} 
		}
	} 
	cout<<dp[1][n]<<endl;
	return 0;
}

 环形石子合并：

        这题讲的就是环形石子合并，我们只要把石子数组复制一份接到末尾，形成一个2N的数列，就可以模拟环形啦，虽然此时长度变长了，但是我们只要枚举出长度为N的区间最优得分就OK了。

环形石子合并代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=220,INF=0x3f3f3f3f;
int n;//石子堆数 
int a[N];//记录每堆石子的质量
int s[N];//记录前缀和 
int dp1[N][N];//dp1[l][r]表示把石子从l到r合并成一堆石子的最小代价 
int dp2[N][N];//dp2[l][r]表示把石子从l到r合并成一堆石子的最大代价 
int main()
{
	//预处理 
	memset(dp1,INF,sizeof(dp1)); 
	memset(dp2,-INF,sizeof(dp2)); 
	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++)
	{
		s[i]=s[i-1]+a[i];//前缀和 
		dp1[i][i]=0;//单堆石子合并的代价为0 
		dp2[i][i]=0;//单堆石子合并的代价为0 
	} 
	//状态计算
	for(int len=2;len<=n;len++)//阶段：枚举区间长度（先从长度为2开始，还是长度为n结束，虽然石子堆数被扩大了1倍）
	{
		for(int i=1;len+i-1<=2*n;i++)//状态：枚举区间起点 
		{
			int j=len+i-1;//区间终点
			for(int k=i;k<j;k++)//决策：枚举分割点
			{
				dp1[i][j]=min(dp1[i][j],dp1[i][k]+dp1[k+1][j]+s[j]-s[i-1]);//计算区间最小代价 
				dp2[i][j]=max(dp2[i][j],dp2[i][k]+dp2[k+1][j]+s[j]-s[i-1]);//计算区间最大代价 
			} 
		}
	} 
	
	//我们最终只关心长度为N的区间的最优得分（如dp1[i][i+n-1]），而这些区间恰好覆盖圆环一次 
	int minn=INF,maxx=-INF;
	for(int i=1;i<=n;i++)
	{
		minn=min(minn,dp1[i][i+n-1]);
		maxx=max(maxx,dp2[i][i+n-1]);
	} 
	cout<<minn<<endl<<maxx<<endl; 
	return 0;
}

 希望能帮助到各位同志，若俺有理解不对的地方，还希望各位能评论区留言告诉俺嘿嘿嘿，谢谢！