区间DP入门（石子合并1+P1880 [NOI1995]石子合并）

区间DP：即利用解决小区间问题，逐步求解大区间问题的一种DP应用。

给出区间DP的一般模板

for(i = 1;i <= n;i++)
    dp[i][i] = 初始值；//一般为0
for(len = 2;len <= n;len++){//len选择区间长度
    for(i = 1;i <= n;i++){//枚举起点
        j = i + len - 1;//合并终点
        if(j > n)break;//不可越界
        for(k = i;k < j;k++)//枚举分割点，寻找最优分割
            dp[i][j] = max(dp[i][j], dp[i][k] + dp[k + 1][j] + w[i][j]);//状态转移
    }

}

模板很清楚明白，在这里只解释一下他的状态转移方程。dp[i][j] = max(dp[i][j], dp[i][k] + dp[k + 1][j] + w[i][j]);在这里即求i到j区间的问题而k为分割点。以此求取最大的分割方式。即通过小区间求取大的区间。

接下来附上两个石子合并的题型。

石子合并1

Description

有n堆石子排成一行，每次选择相邻的两堆石子，将其合并为一堆，记录该次合并的得分为两堆石子个数之和。已知每堆石子的石子个数，求当所有石子合并为一堆时，最小的总得分。

Input

第一行一个整数n(1 <= n <= 200)，表示石子堆数； 第二行n个整数a(1 <= a <= 100)，表示每堆石子的个数。

Output

一个整数，表示最小总得分。

Sample Input

5
7 6 5 7 100

Sample Output

175

AC代码

#include
#include
#include
#include
using namespace std;
const int maxn = 300;
int n;
int a[maxn], dp[maxn][maxn], sum[maxn];
const int INF = 1000000;
int main()
{
	cin >> n;
	memset(dp, INF, sizeof(dp));
	memset(sum, 0, sizeof(sum));
	for (int i = 1; i <= n; i++)
	{
		int t;
		cin >> t;
		sum[i] = sum[i - 1] + t;
		dp[i][i] = 0;
	}
	int j;
	for (int len = 2; len <= n; len++)
	{
		for (int i = 1; i < n; i++)
		{
			int j = i + len - 1;			
			if (j > n)
				break;
			for (int k = i; k < j; k++)
			{
				dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1]);
			}
		}
	}
	cout << dp[1][n]<

环形的石子合并：

题目描述

在一个圆形操场的四周摆放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

思路我们可以开数组为她的两倍，两次存进，这样就又变成了线性区间合并。状态转移方程也不变了。

#include
#include
#include
#include
using namespace std;
const int maxn = 300;
int n;
int a[maxn], dp[maxn][maxn],ap[maxn][maxn], sum[maxn][maxn];
const int INF = 1000000000;
int main()
{
    cin >> n;
    memset(sum, 0, sizeof(sum));
    memset(a, 0, sizeof(a));
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        a[i + n] = a[i];
    }
    for (int i = 1; i<=2 * n; i++) {
        for (int j = i; j<=2 * n; j++) {
            if (i == j) {
                dp[i][i] = 0; ap[i][i] = 0;//初始化	
            }
            else {
                ap[i][j] = 0; dp[i][j] = INF;
            }
        }
    }
    for (int i = 1; i <= 2 * n; i++)
    {
        for (int j = i;j <= 2 * n; j++)
        {
            if (j == i)
                sum[i][j] = a[i];
            else {
                sum[i][j] = sum[i][j - 1] + a[j];
            }
        }
    }
    for (int len = 2; len <= n; len++)
    {
        for (int i = 1; i <= 2*n-len+1; i++)
        {
            int j = i + len - 1;
             
            for (int k = i; k < j; k++)
            {
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[i][j]);
                ap[i][j] = max(ap[i][j], ap[i][k] + ap[k + 1][j] + sum[i][j]);
            }
        }
    }
    int maxu = -10000, minu = INF;
    for (int i = 1; i <=n; i++)
    {
        maxu = max(maxu, ap[i][n + i-1]);
        minu = min(minu, dp[i][n+ i-1]);
    }
    cout << minu << endl << maxu << endl;
    return 0;
}