【POj】1651 2955（区间dp）

这两道区间DP都是自己想的，值得写一下题解，区间DP养成ing！

2955题目大意：字符串只有（、）、[、]组成，完整的括号之间不能包含不完整的括号，最后让你算出有多少个合法的括号数。

dp[i][j]表示的是i到j中最多的括号数，容易知道如果i位置和j位置的符号匹配的话，那么dp[i][j]=dp[i+1][j-1]+2;

但是考虑到这种情况"()()“这种情况是指两个合法的部分，并且没有相交，这样的话，中间部分个数就不是最大，最大的个数是由两部分相加，所以这边还需要

dp[i][j]=max(dp[i][j],dp[i][k]+dp[k][j])，由于k位置至多与前后其中一个匹配，所以这边在个数中间大于1个的情况下，k与k+1是一样的。

我一开始是写成dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j])这样的话会漏掉一组数据，例如“（（）”，这样的话就没办法处理，只能用数据来解释了。

附上AC代码：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
char str[110];
int dp[110][110];
bool equ(int i, int j)
{
	if ((str[i] == '('&&str[j] == ')') || (str[i] == '['&&str[j] == ']'))
		return true;
	return false;

}
int main()
{
	while (scanf("%s", str+1) && strcmp(str+1, "end"))
	{
		memset(dp, 0, sizeof(dp));
		int len = strlen(str+1);
		for (int l = 1; l < len;l++)
		for (int i = 1; i + l <= len; i++)
		{
			int j = i + l;
			if (equ(i,j))
				dp[i][j] = dp[i + 1][j - 1] + 2;
			for (int k = i + 1; k < j;k++)
				dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j]);
		}
		cout << dp[1][len] << endl;
	}
}

1651题目大意：有一组数，每次可以将一个数抽出，代价是这数与相邻两数的乘积，没有邻数的就不能抽，这就意味着头尾不能抽。求最小代价

思路：这道题我的想法是这样的dp[i][j]表示的是i到j当中最小的代价，那我依然枚举k,不过这边我是将k位置的数当作是最后一个取的，因为根据区间dp的想法，从已知推出未知，那么k是最后一个取的话，那么其他的都已经确定，这就意味着我k要乘的两个邻居也就确定了，我们可以很容易的写出来就是这个区间的头尾两个元素，然后我们在加上dp[i][k],dp[k][j]，于原来比较大小，便是答案。

如何运用已知条件来假设已知，从而从小区间（小区间往往更容易算，甚至可以初始化）来推出大区间，所以在做的过程当中需要明白从小到的这么一个过程。

状态转移方程：dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + a[i] * a[k] * a[j]);

AC代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
int a[110];
long long dp[110][110];
int main()
{
	int n;
	while (cin >> n)
	{
		for (int i = 1; i <= n; i++)
			cin >> a[i];
		memset(dp, 0, sizeof(dp));
		for (int len = 2; len < n;len++)
		for (int i = 1; i + len <= n; i++)
		{
			
			int j = i + len;
			dp[i][j] = 0x7fffffff;
			for (int k = i + 1; k < j; k++)
				dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + a[i] * a[k] * a[j]);
		}
		cout << dp[1][n] << endl;
	}
}