CF1420E

直接计算有多少对守卫被保护比较困难，可以计算有多少对守卫是没有被保护的。（只用考虑都没拿盾牌的就好了）

设有 \(t\) 个守卫拿着盾牌，初始状态为 \(a_{1\cdots n}\)。

这相当于在一个 \(01\) 串 \(s\) 中填写 \(t\) 个 \(1\)，将 \(s\) 中的 \(0\) 分成 \(t+1\) 个部分，设这些部分大小分别为 \(c_{1\cdots t+1}\)，那么就是要最小化 \(\sum \dfrac{c_i\times (c_i-1)}{2}\)。

定义一个 \(01\) 串 \(s\) 的代价为由 \(a\) 通过移动一个 \(1\) 到相邻的 \(0\) 的位置的操作变成 \(s\) 的最小操作次数。

显然 \(1\) 之间的相对位置是不会发生改变的。

因此设 \(a\) 中 \(1\) 的位置依次为 \(p_{1\cdots t}\)，\(s\) 中为 \(q_{1\cdots t}\)，则代价为 \(\sum \left|p_i-q_i\right|\)。

有了以上的铺垫，就可以 DP 了。

设 \(f(i,j,k,l)\) 为考虑到第 \(i\) 位，已经填了 \(j\) 个 \(1\)，并且最后一个 \(1\) 离 \(i\) 的距离是 \(k\)，代价为 \(l\) 的答案。

• 下一位不填 \(1\)。\(f(i+1,j,k+1,l)\gets f(i,j,k,l)+k\)。
• 下一位填 \(1\)。\(f(i+1,j+1,0,l+\left|p_{j+1}-(i+1)\right|)\gets f(i,j,k,l)\)。

设 \(g_i=\dfrac{(n-t)(n-t-1)}{2}-\min\limits_{k}f(n,t,k,i)\)，对 \(g_i\) 取个前缀 \(\max\) 即可。

时空复杂度均为 \(\mathcal O(n^5)\)，滚动数组优化一下空间是可以过的。

Code：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 85, M = 3205;
const ll inf = 0x3f3f3f3f3f3f3f3f;
int n, m, a[N], pos[N], cnt;
bool vis[2][M][N][N];
ll f[2][M][N][N], ans[M];

void chkmin(int p, int j, int k, int l, ll v) {
	if (!vis[p][j][k][l]) f[p][j][k][l] = v, vis[p][j][k][l] = 1;
	else f[p][j][k][l] = min(f[p][j][k][l], v);
}

int main() {
	scanf("%d", &n), m = n * (n - 1) / 2;
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &a[i]);
		if (a[i]) pos[++cnt] = i;
	}
	if (cnt == n || !cnt) {
		for (int i = 0; i <= m; ++i) printf("%d ", 0);
		return 0;
	}
	vis[0][0][0][0] = 1;
	for (int i = 0, p = 0; i < n; ++i, p ^= 1)
		for (int j = 0; j <= m; ++j)
			for (int k = 0; k <= i; ++k)
				for (int l = 0; l <= i; ++l) if (vis[p][j][k][l]) {
					vis[p][j][k][l] = 0;
					chkmin(p ^ 1, j, k, l + 1, f[p][j][k][l] + l);
					if (k < cnt) chkmin(p ^ 1, j + abs(pos[k + 1] - (i + 1)), k + 1, 0, f[p][j][k][l]);
				}
	for (int i = 0; i <= m; ++i) {
		ans[i] = inf;
		for (int j = 0; j <= n; ++j) if (vis[n & 1][i][cnt][j]) ans[i] = min(ans[i], f[n & 1][i][cnt][j]);
		if (i) ans[i] = min(ans[i], ans[i - 1]);
	}
	for (int i = 0; i <= m; ++i) printf("%lld ", (n - cnt) * (n - cnt - 1) / 2 - ans[i]);
	return 0;
}

上述做法常数非常大。

不过可以简化一下状态定义，设 \(f(i,j,k)\) 表示考虑了前 \(i\) 位，第 \(i\) 位上填 \(1\)，已经填了 \(j\) 个 \(1\)，代价为 \(k\) 时候的答案。

转移就枚举下一个 \(1\) 填在哪，时间复杂度依旧为 \(\mathcal O(n^5)\)，但是空间复杂度降为了 \(\mathcal O(n^4)\)，该做法常数非常小。

Code：

#include <bits/stdc++.h>
using namespace std;
const int N = 80, inf = 0x3f3f3f3f;
int n, a[N+5], cnt[2], pos[N+5];
int total, mx;
int f[N+5][N*(N-1)/2+5][N+5];

int calc(int x) {
	return x * (x - 1) / 2;
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &a[i]);
		++cnt[a[i]];
		if (a[i]) {
			pos[cnt[1]] = i;
		}
	}
	total = calc(cnt[0]);
	mx = calc(n);
	if (!cnt[1]) {
		for (int i = 0; i <= mx; ++i) printf("%d ", 0);
		return 0;
	}
	memset(f, 0x3f, sizeof f);
	for (int i = 1; i < n; ++i) {
		f[i][abs(pos[1] - i)][1] = calc(i - 1);
		for (int j = 0; j <= mx; ++j) {
			for (int k = 1; k <= i && k < cnt[1]; ++k) if (f[i][j][k] != inf) {
				int rest = cnt[1] - k;
				for (int l = i + 1; l <= n - rest + 1; ++l) {
					int nxt = j + abs(pos[k + 1] - l);
					if (nxt <= mx) f[l][nxt][k + 1] = min(f[l][nxt][k + 1], f[i][j][k] + calc(l - i - 1));
				}
			}
		}
	}
	int ans = total;
	for (int j = 0; j <= mx; ++j) {
		for (int i = cnt[1]; i <= n; ++i) if (f[i][j][cnt[1]] != inf)
			ans = min(ans, f[i][j][cnt[1]] + calc(n - i));
		printf("%d ", total - ans);
	}
	return 0;
}