合并石子（算是真正意义上的第一次敲区间DP）

题目描述

题目描述
在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。
试设计出1个算法,计算出将N堆石子合并成1堆的最小得分和最大得分.
输入输出格式
输入格式：
数据的第1行试正整数N,1≤N≤100,表示有N堆石子.第2行有N个数,分别表示每堆石子的个数.
输出格式：
输出共2行,第1行为最小得分,第2行为最大得分.
输入输出样例
输入样例#1：
4
4 5 9 4
输出样例#1：
43
54

心路历程

之前一直有听说过这道题，也不知道自己写过没有(然后就发现自己实际上没有写过 )
其实一直不是很了解什么是区间DP，就算是写了这道题之后也不是很理解什么是区间DP。。。
但是对一道可以卡我两个思路的题，我觉得还是很有价值记录一下的。

一开始在noip模拟赛的时候，我就看到了一道相似的合并能量珠的题。
刚拿道题就是完全没有思路，写了一个暴力拿了50分的部分分。
之后我就了解到了合并石子这道题，知道了区间DP。

思路

1. 题目最终要求的答案是，n堆石子合并成一堆石子的价值。
2. 那么在合并成一堆石子之前，必然有一个状态是$[1,k]和[k+1,n]$两堆石子合并成一堆石子，把这种状态普通化，$[l,k]+[k+1,r]->[l,r]$这样子的话就是基于区间大小的状态转移方程。
   令sum是该序列的前缀和。
3. $f[l,r]=f[l,k]+f[k+1,r]+sum[r]-sum[l-1]$(这个时候只需要找到一个k值使得答案最大或是最小)
   $f[l,k]+f[k+1,r]$指的是在合并$[l,r]$之间的前两个区间的价值；
   $sum[r]-sum[l-1]$指的是由两个区间此时合并成一个区间$[l,r]$的价值.

但是此时有一个最大的麻烦，就是这个题中的序列是环状的，并非是链状的。
这个时候就有两个思路：

1. 破环为链（拆环）
   把每个点都当做是一个断点，依次枚举处理，最后的目标是$f[1,n]$
2. 复制两倍长度
   这样子的话就可以在处理的时候把环当作是链来处理，只是在最后得到答案的时候，需要依次枚举每一个$[1,n]$的断点，比较答案。

两个思路大致相同，思想都是破环为链，之后再处理，不过就是枚举的地方不同罢了。

code

1. 破环为链（其实很早之前就写过一遍了，但是为了写这次的博客，又写了一遍，但是只得到了20分，o(╥﹏╥)o ）

打代码的过程中出现的一些问题：
再打一遍最后得了20分；
没有比较最后的结果，直接输出了最后一次破环为链的答案。

//Author:melody
#include<bits/stdc++.h>
using namespace std;

const int nn=110;
int n;
int ans1=10000000,ans2=0;
int a[nn],b[nn],sum[nn];
int g[nn][nn],f[nn][nn];

int inline read()
{
	int x=0,f=1; char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0'; ch=getchar();}
	return x*f;
}

int main()
{
	n=read();
	for(int i=1;i<=n;++i)	a[i]=read();
	for(int i=1;i<=n;++i)
	{
		memset(g,0x3f3f3f,sizeof(g));
		memset(f,0,sizeof(f));
		memset(sum,0,sizeof(sum));
		int cnt=i-1;
		for(int j=1;j<=n;++j)
		{
			if(cnt==n)	cnt=0; 
			b[j]=a[++cnt],g[j][j]=0,sum[j]=sum[j-1]+b[j];
		}
		for(int len=2;len<=n;++len)
			for(int l=1;l<=n-len+1;++l)
			{
				int r=l+len-1;
				for(int k=l;k<r;++k)
				{
					g[l][r]=min(g[l][k]+g[k+1][r]+sum[r]-sum[l-1],g[l][r]);
					f[l][r]=max(f[l][k]+f[k+1][r]+sum[r]-sum[l-1],f[l][r]);
				}
			}
		ans1=min(ans1,g[1][n]);
		ans2=max(ans2,f[1][n]); 
	}
	cout<<ans1<<endl;
	cout<<ans2<<endl;
	return 0;
}

2. 复制两倍长度

打代码的过程中出现的一些问题：

1.复制之后，要枚举断点；（与之前不同的是，如果是先枚举断点，那么最后的答案就是f[1][n])
【但是在一开始敲代码的过程中你没有枚举断点】
枚举断点的时候只需要枚举到[1,n]

2.在枚举l的时候，也要把2*n的范围内都遍历一遍。【但是你只遍历了一次】

//melody
#include<bits/stdc++.h>
using namespace std;

const int nn=210;

int n;
int a[nn],sum[nn];
int f[nn][nn],g[nn][nn];

inline int read()
{
	int x=0,f=1; char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0'; ch=getchar();}
	return x*f;
}

int main()
{
	n=read();
	memset(g,0x3f3f3f,sizeof(g));
	for(int i=1;i<=n;++i)	a[i]=read(),g[i][i]=0,sum[i]=sum[i-1]+a[i];
	for(int i=n+1;i<=2*n;++i)	a[i]=a[i-n],g[i][i]=0,sum[i]=sum[i-1]+a[i];/*复制两倍*/

	for(int len=2;len<=n;++len)
	 	for(int l=1;l<=2*n-len+1;++l)
	 	{
	 		int r=l+len-1;
	 		for(int k=l;k<r;++k)
	 		{
	 			g[l][r]=min(g[l][k]+g[k+1][r]+sum[r]-sum[l-1],g[l][r]);
	 			f[l][r]=max(f[l][k]+f[k+1][r]+sum[r]-sum[l-1],f[l][r]);
			}
		}
	int ans1=10000000,ans2=0;
	for(int i=1;i<=n;++i)
	{
		ans1=min(ans1,g[i][i+n-1]);
		ans2=max(ans2,f[i][i+n-1]);
	}
	cout<<ans1<<endl;
	cout<<ans2<<endl;
	return 0;
}

我们的征程是星辰大海