【区间dp】合并石子

1 基本模型

P1775 石子合并（弱化版）

1.1 解题思路

· 如果只有一堆石子，那么无法合并，代价为0；
· 如果是两堆石子，直接合并，代价为两堆石子的重量之和；
· 如果是三堆石子及以上，我们需要将石子划分成两堆，用一个变量j，枚举区间起点到j和j+1到区间终点，
合并石子的代价，找到最小值。合并石子的代价计算方式是原先两堆石子先前付出的代价加上当前区间石子的重量之和。
所以我们的区间长度l可以从3枚举到n，当前区间石子重量之和借助前缀和s数组来计算。状态转移方程为：
	dp[i][i+l-1]=min(dp[i][i + l - 1], dp[i][j] + dp[j + 1][i + l - 1] + s[i + l - 1] - s[i - 1])
不过，后面我发现长度为2时，同样使用上述状态转移方程，故l可以从2开始枚举。

1.2 AC代码

#include <bits/stdc++.h>
#define N 105
using namespace std;
int dp[N][N], s[N], a[N], n;

int main() {
	cin >> n;
	memset(dp, 0x3f, sizeof(dp));
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		s[i] = s[i - 1] + a[i];
		dp[i][i] = 0;
	}
	for (int l = 2; l <= n; l++) {
		for (int i = 1; i <= n - l + 1; i++) {
			for (int j = i; j < i + l - 1; j++) {
				dp[i][i + l - 1] = min(dp[i][i + l - 1], dp[i][j] + dp[j + 1][i + l - 1] + s[i + l - 1] - s[i - 1]);
			}
		}
	}
	cout << dp[1][n];
	return 0;
}

2 升级模型

P1880 NOI1995 石子合并

2.1 解题思路

这道题和前面洛谷P1775的差别在于P1775石子排布是线性的，而P1880石子排布是环状的，不过我们可以将环状的转为线性的，举个例子有四堆石子重量依次为2，5，3，1，我们依次以输入的每个数为起点，罗列长度为4的序列：

可以得到如下表格：

序列1	2	5	3	1
序列2	5	3	1	2
序列3	3	1	2	5
序列4	1	2	5	3

一个环有n个数，就可以按照上述方式生成n个序列，并存储在一个二维数组中。然后枚举二维数组的线性数据套用基本模型即可。

2.2 四重循环 代码实现

#include<bits/stdc++.h>
#define N 105
using namespace std;
int dp[N][N], s[N], a[N], n,b[N][N],ans_min=0x3f3f,ans_max=-0x3f3f;
void dp_min(){
	for(int k=1;k<=n;k++){
		memset(dp, 0x3f, sizeof(dp));
		for(int i=1;i<=n;i++){
			s[i] = s[i - 1] + b[k][i];
			dp[i][i] = 0;
		}
		for (int l = 2; l <= n; l++) {
			for (int i = 1; i <= n - l + 1; i++) {
				for (int j = i; j < i + l - 1; j++) {
					dp[i][i + l - 1] = min(dp[i][i + l - 1], dp[i][j] + dp[j + 1][i + l - 1] + s[i + l - 1] - s[i - 1]);
				}
			}
		}
		ans_min=min(dp[1][n],ans_min);
	}
	cout<<ans_min<<endl;
}
void dp_max(){
	for(int k=1;k<=n;k++){
		memset(dp, -0x3f, sizeof(dp));
		for(int i=1;i<=n;i++){
			s[i] = s[i - 1] + b[k][i];
			dp[i][i] = 0;
		}
		for (int l = 2; l <= n; l++) {
			for (int i = 1; i <= n - l + 1; i++) {
				for (int j = i; j < i + l - 1; j++) {
					dp[i][i + l - 1] = max(dp[i][i + l - 1], dp[i][j] + dp[j + 1][i + l - 1] + s[i + l - 1] - s[i - 1]);
				}
			}
		}
		ans_max=max(dp[1][n],ans_max);
	}
	cout<<ans_max<<endl;
}
int main(){
	cin >> n;
	for (int i = 1; i <= n; i++) 
		cin >> a[i];
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			b[i][j]=a[1+(i+j)%n];
		} 
	}
	dp_min();dp_max();
	return 0;
} 

2.3 代码优化——三重循环

2.2中的四重循环时间复杂都比较高，而且还要另开一个n×n的二维数组。优化的方法是我们将原先的数据在a数组中再按顺序复制一份，按照下图，亦可以得到n个有序序列。以输入的每个数为起点，从长度为2开始枚举，一直到长度为n，计算每个区间长度的最大最小代价。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N=105;
int dp[N*2][N*2], s[N*2], a[N*2], n;
void dp_min(){
	memset(dp, 0x3f, sizeof(dp));
	for(int i=1;i<=n*2;i++){
		s[i] = s[i - 1] + a[i];
		dp[i][i] = 0;
	}
	for (int l = 2; l <= n; l++) {
		for (int i = 1; i <= 2*n - l + 1; i++) {
			for (int j = i; j < i + l - 1; j++) {
				dp[i][i + l - 1] = min(dp[i][i + l - 1], dp[i][j] + dp[j + 1][i + l - 1] + s[i + l - 1] - s[i - 1]);
			}
		}
	}
	int ans_min=0x3f3f;
	for(int i=1;i<=n;i++) ans_min=min(ans_min,dp[i][n+i-1]);
	cout<<ans_min<<endl;
}
void dp_max(){
	memset(dp, -0x3f, sizeof(dp));
	for(int i=1;i<=n*2;i++)
		dp[i][i] = 0;
	for (int l = 2; l <= n; l++) {
		for (int i = 1; i <= 2*n - l + 1; i++) {
			for (int j = i; j < i + l - 1; j++) {
				dp[i][i + l - 1] = max(dp[i][i + l - 1], dp[i][j] + dp[j + 1][i + l - 1] + s[i + l - 1] - s[i - 1]);
			}
		}
	}
	int ans_max=-0x3f3f;
	for(int i=1;i<=n;i++) ans_max=max(ans_max,dp[i][n+i-1]);
	cout<<ans_max<<endl;
}
int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		a[i+n]=a[i];
	}
	dp_min(); dp_max();
	return 0;
}