D. Almost Triple Deletions（dp/逆向思维/好题）

题目

参考

题意

给定长度为n的数组，现在可以执行若干次操作
如果a[i],a[i+1]不相等，则从数组a中消去元素a[i],a[i+1]，将剩余元素按原来顺序，拼接成新数组a。
问最终能得到的、元素都相同的数组，长度最大是多少。

思路

没有脑洞是想不到，正向思路想半天想不来，去偷瞄了下官方题解。

逆向思考，什么情况下，可以将数组都消去，使得剩余元素个数为0呢？需要满足2个条件。

• 首先，数组长度要是偶数，如果是偶数，至少会剩下一个元素消不去。
• 其次，数组中，出现次数最多的元素（不妨称它为x）个数，要不超过n/2，这样的话，我们每次选择与x相邻的、且值
  不相等的元素去做消除，最终一定可以将所有元素消去。

定义dp[i]，表示以第i个元素结束，能得到的取值都为a[i]的数组的最大长度。

以下所有说明，是以数组下标，从0到n-1，为基础。

1、初始化

dp[0]=1。
对于大于0的下标i，如果数组a[0],…a[i-1]能完全消去（长度为0，且max_count<=len/2），则dp[i]=1；否则dp[i]=0。

2、dp计算

对于大于0的下标i，如果存在下标j<i，满足

• 数组a[j+1],…a[i-1]能完全消去（长度为0，且max_count<=len/2）
• dp[j]>0（大于0，才能说明元素数组a[0],…a[j-1]能完全消去）
• a[j]==a[i]

则更新dp[i]=max(dp[i],dp[j]+1)

3、答案计算

计算出dp值后，我们还需要计算最终的res，如果存在下标j，使得

• 数组a[j+1],…a[n-1]能完全消去（长度为0，且max_count<=len/2）
• dp[j]>0（大于0，才能说明元素数组a[0],…a[j-1]能完全消去）

则更新res=max(res,dp[j])

代码

#include <bits/stdc++.h> 
using namespace std;
#define ll long long
const int maxn = 200010;
const int mod = 1e9 + 7;

int n, m; 
int a[maxn], dp[maxn];
//map<int, int> mp; // 用map被卡常了。。。 
int mp[maxn];
void clear_mp() {
	for (int i = 1; i <= n; ++i) {
		mp[i] = 0;
	}
}
void solve() {
	scanf("%d", &n);
	for (int i = 0; i < n; ++i) {
		scanf("%d", &a[i]);
	}

//	mp.clear();
	clear_mp();
	int mx = 0;
	for (int i = 0; i < n - 1; ++i) {
		if (++mp[a[i]] > mx) {
			mx = mp[a[i]];
		}
		// length a[0, ... i] is even
		// mx <= length / 2
		if ((i & 1) && mx <= (i + 1) / 2) {
			dp[i+1] = 1;
		} else {
			dp[i+1] = 0;
		}
	}
	dp[0] = 1;
	for (int i = 1; i < n; ++i) {
		clear_mp();
		mx = 0;
		if (a[i] == a[i-1] && dp[i-1]) {// spcial judge
			dp[i] = max(dp[i], dp[i-1] + 1);
		}
		for (int j = i - 1; j > 0; --j) {
			if (++mp[a[j]] > mx) {
				mx = mp[a[j]];
			}
			// a[j-1] exist, 
			// length a[j, j+1, ... i-1] is even,
			// mx <= length / 2
			// a[j-1] == a[i]
			// dp[j-1] > 0
			if (((i - j) % 2 == 0) && mx <= (i - j) / 2 && a[j-1] == a[i] && dp[j-1] > 0) {
				dp[i] = max(dp[i], dp[j-1] + 1);
			}
		}
		
	}
	clear_mp();
	mx = 0;
	int res = dp[n-1];
	for (int j = n - 1; j > 0; --j) {
		if (++mp[a[j]] > mx) {
			mx = mp[a[j]];
		}
		// a[j-1] exist, 
		// length a[j, j+1, ... n-1] is even,
		// mx <= length / 2
		// dp[j-1] > 0
		if (((n - j) % 2 == 0) && mx <= (n - j) / 2 && dp[j-1] > 0) {
			res = max(res, dp[j-1]);
		}
	}
	
//	for (int i = 0; i < n; ++i) {
//		printf("%d ", dp[i]);
//	}
//	printf("\n------------------------\n");
	printf("%d\n", res);
}

int main() {
	int t;
	scanf("%d", &t);
	while (t--) {
		solve();
	}
}