CF1736E - Swap and Take(DP)(前缀最大优化)

1736E - Swap and Take

每轮交换相邻两数，交换后任其一置0，第i轮取第i位的得分，希望总分和最大。$N\le 500$

DP显然的DP。

我一开始设的状态f[i][j]=前i个数用了j次转移的最大得分。发现一个问题，样例2过不去。

我发现了一个错误的性质，从后面往前移的数，一定会移动回原来的位置，甚至更后。然后很容易写出一个状态转移方程，分两种情况，当前最后这个数往前移动到某个位置之后再回来，$f[i][j]=\max (f[i][j],f[i-k-1][j-2k]+a[i]\ast k)$。然后让$f[i+k][j+k]=max(f[i+k][j+k],f[i][j]+k\ast a[i])$。

其实样例2就给出了一个反例，是可以不用回到原点的，只要后面有人补上来就可以。答案设的f[t][last][m] = 前t个用了m次转移，最后一个数是a[last]。

如果是将last顺延一位，
f [ t ] [ l a s t ] [ m ] = max ⁡ { f [ t ] [ l a s t ] [ m ] , f [ t − 1 ] [ l a s t ] [ m − 1 ] } f[t][last][m] = \max\{f[t][last][m], f[t-1][last][m-1]\} f[t][last][m]=max{f[t][last][m],f[t−1][last][m−1]}

如果是将后面a[last]调到i这来，
f [ t ] [ l a s t ] [ m ] = max ⁡ 1 ≤ j ≤ l a s t − 1 { f [ t ] [ l a s t ] [ m ] , f [ t − 1 ] [ j ] [ m − ( l a s t − t ) ] } f[t][last][m] = \max_{1\le j\le last - 1}\{f[t][last][m], f[t-1][j][m-(last-t)]\} f[t][last][m]=1≤j≤last−1max​{f[t][last][m],f[t−1][j][m−(last−t)]}

这样是$\mathcal{O}(N^4)$，发现第二个转移是前缀最大值，可以另外处理，降低复杂度$\mathcal{O}(N^3)$。

#include<bits/stdc++.h>
using namespace std;
const int N = 510;

int ans = 0, a[N], dp[N][N][N], prefix[N][N];

void solve()
{
	memset(dp, -0x3f, sizeof(dp));
	int n;
	scanf("%d", &n);
	for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= n; j++)
		{
			for(int k = 0; k <= i; k++)
			{
				if(k) dp[i][j][k] = dp[i - 1][j][k - 1] + a[j];
				if(j >= i)
				{
					int need = j - i;
					if(need > k) continue;
					dp[i][j][k] = max(dp[i][j][k], prefix[k - need][j - 1] + a[j]);
				}
			}
		}
		for(int j = 1; j <= n; j++)
			for(int k = 0; k <= i; k++) prefix[k][j] = max(prefix[k][j], dp[i][j][k]);
		for(int j = 0; j <= i; j++)
			for(int k = 1; k <= n; k++)
			{
				prefix[j][k] = max(prefix[j][k], prefix[j][k - 1]);
				ans = max(ans, prefix[j][k]);
			}
	}
	cout << ans;
}

int main()
{
	int T = 1;
	//scanf("%d", &T);
	while(T--) solve();
}