动态规划——区间DP

题型1.石子合并

有 n 堆石子排成一排,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的花费。

试设计出一个算法,计算出将 n 堆石子经过n-1次合并，最后合并成 1 堆的最小花费。

输入格式：
数据的第 1 行是正整数 n，表示有 n 堆石子。
第 2 行有 n 个整数，第 i 个整数 ai​ 表示第 i 堆石子的个数。

输出格式：
总的最小花费。

输入样例：
3 
2 4 5

输出样例：
17


思路：
dp[i][j]为第i堆石子到第j堆石子的最小花费。
sum[i][j]为从第 i 到 j 的区间和。状态转移方程为：dp[i][j] = min(dp[i][k] + dp[k+1][j]) + sum[i][j]，i<=k<=j

代码如下，时间复杂度为O(n^3)，只能用来处理规模n<250的问题。

#include <iostream>
#include <algorithm>
#include <climits>
using namespace std;
const int maxn = 300;
int sum[maxn], n; //sum[i]为下标1~i的数的和 

int Minval() {
	int dp[maxn][maxn]; //dp[i][j]为第i堆石子到第j堆石子的最小花费 
	for(int i = 1; i <= n; i++) dp[i][i] = 0;
	
    //O(n^3)
    //这里的三重for循环顺序不能改，因为得先获得len=1的dp[i][i+1] 才能为后面的len=2的dp[i][i+2]做服务
	for(int len = 1; len < n; len++) { //len是i和j之间的距离 
		for(int i = 1; i <= n-len; i++) { //从第i堆开始 
			int j = i + len; //到第j堆结束
			dp[i][j] = INT_MAX;
			for(int k = i; k < j; k++) { //i和j之间用k进行分割
				dp[i][j] = min(dp[i][j],
					dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1]);
			}
		}
	}
	
	return dp[1][n];
}

int main()
{
	while (cin >> n) {
		sum[0] = 0;
		for(int i = 1; i <= n; i++) {
			int x;
			cin >> x;
			sum[i] = sum[i-1] + x; //sum[i,j]的值等于sum[j]-sum[i-1]
		}
		cout << Minval() << endl;
	}
	
	return 0;
}

 

题目变形↓
P1880 [NOI1995] 石子合并
题目链接

题目描述

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

 

思路 ：
首先，如果要在一个首尾相连的环上dp的话，比较方便的做法是断环为链。
假设输入的数是a[1],a[2],……,a[n]
那么使a[n+1]=a[1],a[n+2]=a[2],……,a[2*n]=a[n]
会发现n个数的环上的每一段都在2*n个数的链上了
于是就在该链上dp等价于在环上dp

然后dp的状态和转移方程和上面的题目类似，只不过在答案输出时，
最小值ans1 = min(ans1, dp1[i][i+n-1])   (1 <= i <= n)
最大值ans2 = max(ans2, dp[i][i+n-1])    (1 <= i <= n)

 

下面解题代码

#include <cstdio>
#include <algorithm>
#include <climits>
#include <cstring>
using namespace std;
const int maxn = 100 * 2 + 10; //断环为链，例如: 1 2 3这个环，可以变为: 1 2 3  1 2 3
int a[2*maxn], sum[2 * maxn], n; //sum[i]为下标1~i的数的和
int dp1[maxn][maxn]; //dp[i][j]为第i堆1石子到第j堆石子的最小得分(断环为链后)
int dp2[maxn][maxn]; //dp[i][j]为第i堆石子到第j堆石子的最大得分(断环为链后)

void f() {
	for(int len = 1; len < n; len++) { //len是i和j的距离 
		for(int i = 1; i <= 2*n-len; i++) { //枚举起点
			int j = i + len; //j为终点
			dp1[i][j] = INT_MAX, dp2[i][j] = INT_MIN; //这样做为了方便被替代 
			for(int k = i; k < j; k++) { //i和j之间用k进行分割
				dp1[i][j] = min(dp1[i][j], dp1[i][k] + dp1[k+1][j] + sum[j] - sum[i-1]);
				dp2[i][j] = max(dp2[i][j], dp2[i][k] + dp2[k+1][j] + sum[j] - sum[i-1]);
			}
		}
	}	
}

int main()
{
	while (~scanf("%d", &n)) { //读完时，scanf()返回EOF(-1，二进制表示下各个位为1)
		memset(sum, 0, sizeof(sum));
		memset(dp1, 0, sizeof(dp1));
		memset(dp2, 0, sizeof(dp2));
		for(int i = 1; i <= n; i++) {
			scanf("%d",&a[i]);
			a[n+i] = a[i];
		}
		for(int i = 1; i <= 2*n; i++) sum[i] = sum[i-1] + a[i];
		
		f();
		int ans1 = INT_MAX, ans2 = INT_MIN;
		for(int i = 1; i <= n; i++) {
			ans1 = min(ans1, dp1[i][i+n-1]);
			ans2 = max(ans2, dp2[i][i+n-1]);
		}
			
		printf("%d\n%d\n", ans1, ans2);
	}
	
	return 0;
}
		
		
	

 

 

---

 

 

题型2.回文串

回文串是正读和反读都一样的字符串，例如"abcdcba"。
 

poj 3280 "Cheapest Palindrome"

题目大意：
给定字符串s，长度为m，有n个小写字母构成。在s的任意位置增删字母，把它变为回文串，增删特定字母的花费不同。求最小花费。

输入：
第1行：两个以空格分隔的整数：N和M
第2行：此行恰好包含构成初始ID字符串的M个字符
第3行..N +2：每行包含三个以空格分隔的实体：输入字母的字符和两个整数，分别是添加和删除该字符的成本。

输出：
具有单个整数的一行，这是更改给定名称标签的最低成本。

输入样例：
3 4
abcb
a 1000 1100
b 350 700
c 200 800

输出样例：
900


思路：
可以使用区间DP的方法求解。
定义状态dp[i][j]表示字符串s的子区间s[i, j]变成回文的最小花费。
并且，在考虑删除和插入的花费时，其实这两种操作是等价的(这头加和那头减是一样的)，比如原始字符串s为:ab，如果在最后加上一个'a'，会变成aba；如果删掉最前面的'a'，会变成b，两种操作都会使得原字符串变为回文串，所以两种操作是等价的。
所以只要取这两种操作的最小值就行了。用数组w[]定义各个字符的花费。

状态转移方程为：dp[i][j] = min(dp[i+1][j] + w[s[i]-'a'], dp[i][j-1] + w[s[j]-'a'])

因为需要从小区间扩展到大区间，所以 i 从 s 的尾端开始，逐步回退扩大区间，直到首端。


解题代码

#include <cstdio>
#include <algorithm>
using namespace std;
int w[30], n, m, dp[2010][2010];
char s[2010], ch;

int main()
{
	int t1, t2;
	while (~scanf("%d %d", &n,&m)) { //n是用到的字符个数，m是s的长度 
		scanf("%s",s);
		for(int i = 0; i < n; i++) {
			getchar(); //吃掉换行符 
			scanf("%c %d %d", &ch, &t1, &t2); //读取每个字符的插入和删除的花费
			w[ch-'a'] = min(t1, t2); //取其中的最小值
		}
		
		for(int i = m - 1; i >= 0; i--) { //i是子区间的起点
			for(int j = i+1; j < m; j++) { //j是子区间的终点
				if (s[i] == s[j]) 
					dp[i][j] = dp[i+1][j-1];
				else
					dp[i][j] = min(dp[i+1][j] + w[s[i]-'a'], dp[i][j-1] + w[s[j]-'a']);
			}
		}
		
		printf("%d\n", dp[0][m-1]);
	}
	
	return 0;
}