HDU 5693：D Game（区间DP）

D Game

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 370    Accepted Submission(s): 133

Problem Description

众所周知，度度熊喜欢的字符只有两个：B 和D。

今天，它发明了一个游戏：D游戏。

度度熊的英文并不是很高明，所以这里的D，没什么高深的含义，只是代指等差数列[(等差数列百科)](http://baike.baidu.com/view/62268.htm)中的公差D。

这个游戏是这样的，首先度度熊拥有一个公差集合 {D} ，然后它依次写下 N 个数字排成一行。游戏规则很简单：

1. 在当前剩下的有序数组中选择 X(X≥2)  个连续数字；

2. 检查 1 选择的 X 个数字是否构成等差数列，且公差  d∈{D} ；

3. 如果 2 满足，可以在数组中删除这 X 个数字；

4. 重复  1−3  步，直到无法删除更多数字。

度度熊最多能删掉多少个数字，如果它足够聪明的话？

 

Input

第一行一个整数 T ，表示 T(1≤T≤100)  组数据。

每组数据以两个整数  N ， M  开始 。接着的一行包括  N  个整数，表示排成一行的有序数组  Ai 。接下来的一行是  M  个整数，即给定的公差集合  Di 。

1≤N,M≤300

−1 000 000 000≤Ai,Di≤1 000 000 000

 

Output

对于每组数据，输出最多能删掉的数字 。

 

Sample Input

  
  

   
   3
3 1
1 2 3
1
3 2
1 2 4
1 2
4 2
1 3 4 3
1 2
  
  

 

Sample Output

  
  

   
   3
2
4
  
  

 

http://acm.hdu.edu.cn/showproblem.php?pid=5693

2016"百度之星" - 初赛（Astar Round2A）

解题思路：n的范围只有300，适合区间DP

dp[i][r]表示从i到r能删掉的最多数字，初始化dp[i][r] = max(dp[i][j]+dp[j+1][r])，然后可以分成四种情况

①区间第一个数与最后一个数可以一起删除，且中间所有的数都能被删除，即flag[i][r]==1 && dp[i+1][r-1]==r-i-1

②区间第一个数与区间中某个数aj可以一起删除，且在这两个数中间所有数都能被删除，即flag[i][j]==1 && dp[i+1][j-1]==j-i-1

③区间最后一个数与区间中某个数aj可以一起删除，且在这两个数中间所有数都能被删除，即flag[j][r]==1 && dp[j+1][r-1]==r-j-1

④区间第一个数与区间中某个数aj还有去见最后一个数可以一起删除，且在这三个数中间所有数都能被删除，即flag[i][j]==1 && flag[j][r]==1 && a[r]-a[j]==a[j]-a[i] && dp[i+1][j-1]==j-i-1 && dp[j+1][r-1]==r-j-1

然后在上面四种情况中取最大的即可

复杂度：n^3

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int flag[307][307], dp[307][307];
int main(void)
{
	int T, n, m, i, j, k, r, temp;
	int a[307];
	scanf("%d", &T);
	while(T--)
	{
		memset(dp, 0, sizeof(dp));
		memset(flag, 0, sizeof(flag));
		scanf("%d%d", &n, &m);
		for(i=1;i<=n;i++)
			scanf("%d", &a[i]);
		for(i=1;i<=m;i++)
		{
			scanf("%d", &temp);
			for(j=1;j<=n-1;j++)
			{
				for(k=j+1;k<=n;k++)
				{
					if(a[k]-a[j]==temp)
						flag[j][k] = 1;
				}
			}
		}
		for(k=1;k<=n-1;k++)
		{
			for(i=1;i+k<=n;i++)
			{
				r = i+k;
				dp[i][r] = max(dp[i+1][r], dp[i][r-1]);
				if(flag[i][r]==1 && dp[i+1][r-1]==r-i-1)
					dp[i][r] = max(dp[i][r], dp[i+1][r-1]+2);
				for(j=i+1;j<=r-1;j++)
					dp[i][r] = max(dp[i][r], dp[i][j]+dp[j+1][r]);
				for(j=i+1;j<=r-1;j++)
				{
					if(flag[i][j]==1 && dp[i+1][j-1]==j-i-1)
						dp[i][r] = max(dp[i][r], dp[j+1][r]+dp[i+1][j-1]+2);
					if(flag[j][r]==1 && dp[j+1][r-1]==r-j-1)
						dp[i][r] = max(dp[i][r], dp[i][j-1]+dp[j+1][r-1]+2);
					if(flag[i][j]==1 && flag[j][r]==1 && a[r]-a[j]==a[j]-a[i] && dp[i+1][j-1]==j-i-1 && dp[j+1][r-1]==r-j-1)
						dp[i][r] = r-i+1;
				}
			}
		}
		printf("%d\n", dp[1][n]);
	}
	return 0;
}