AGC030 简要题解

A - Poisonous Cookies

题意

• 有\(A\)个能解毒的普通饼干，\(B\)个能解毒的美味饼干，\(C\)个有毒的美味饼干，求最多能吃多少个美味饼干，每次吃完有毒的饼干后要解毒后才能继续吃。

题解

输出\(\text{min(A + B + 1, C) + B}\)即可。

代码

#include <bits/stdc++.h>

using namespace std;

int main() {

	int a, b, c; 

	cin >> a >> b >> c;
	printf("%d\n", min(a + b + 1, c) + b);

	return 0;
}

B - Tree Burning

题意

• 在一个长为\(L\)的环上有\(n\)个关键点，求访问完所有关键点走的路径长度最大值。

题解

可以发现最优解一定是先往一个方向走，然后每次变换方向，那么枚举往一个方向走到第几个点，取最大值即可。

代码

#include <bits/stdc++.h>

using namespace std; 

const int N = 2e5 + 9;

ll n, L, ans, a[N], b[N], Sa[N], Sb[N];

ll Qa(int l, int r) { return Sa[r] - Sa[l - 1]; }
ll Qb(int l, int r) { return Sb[r] - Sb[l - 1]; }

void Solve() {
	for (int i = n; i; -- i) {
		int blen = (n - i) >> 1, alen = n - i - blen;
		chkmax(ans, ((n - i) & 1 ? b[n - blen] : a[n - alen]) + (Qb(n - blen + 1, n) + Qa(i, i + alen - 1)) * 2);
	}
}

int main() {

	scanf("%d%d", &L, &n);
	for (int i = 1; i <= n; ++ i)
		scanf("%d", &a[i]);

	for (int i = 1; i <= n; ++ i) {
		b[i] = L - a[i];
		Sa[i] = Sa[i - 1] + a[i];
		Sb[i] = Sb[i - 1] + b[i];
	}
	Solve();

	for (int i = 1; i <= n; ++ i)
		a[i] = b[n - i + 1];

	for (int i = 1; i <= n; ++ i) {
		b[i] = L - a[i];
		Sa[i] = Sa[i - 1] + a[i];
		Sb[i] = Sb[i - 1] + b[i];
	}
	Solve();

	cout << ans << endl;

	return 0;
}

C - Coloring Torus

题意

• 构造一个\(\text{n × n}\)的矩阵，满足其中出现了\(k\)种数，对于每种数出现的每个位置，满足这些位置上下左右出现的每种数的个数相同，\(k\le10^3,n\le500\)。

题解

首先\(k\le500\)的很好填，直接\(n = k\)，每行都一样填满所有颜色即可。

如果\(k>500\)，我们令\(n = 2\lceil \frac k 4\rceil\)，我们有个很直观的想法就是每个位置\((x,y)\)填\(\text{(x + y) mod n + 1}\)，这个东西满足题意应该很显然，但是颜色数可能不够，我们把偶数行拿出来，让偶数行填\(\text{(x + y) mod n + n + 1}\)，如果大于\(\text{k}\)就不加\(\text n\)，想一下这样为什么是对的，可以加\(\text{n}\)的位置一定是一行连续的数，那么对于奇数行的一个数，加\(\rm{n}\)的位置一定一个在下方一个在上方，左右的数是不会加的，而对于偶数行加的位置一个在左边一个在右边，上下的数是不会加的，这样就可以了。

代码

#include <bits/stdc++.h>

using namespace std;

int a[501][501];

int main() {

	int k;
	scanf("%d", &k);

	if (k <= 500) {
		cout << k << endl;
		for (int i = 1; i <= k; ++ i)
			for (int j = 1; j <= k; ++ j)
				printf("%d%c", i, j == k ? '\n' : ' ' );
		return 0;
	}

	int n = ((k + 3) / 4) << 1;
	cout << n << endl;
	for (int i = 1; i <= n; ++ i)
		for (int j = 1; j <= n; ++ j) {
			a[i][j] = (i + j) % n + (i & 1 ? 0 : n) + 1;
			if (a[i][j] > k) a[i][j] -= n;
			printf("%d%c", a[i][j], j == n ? '\n' : ' ');
		}

	return 0;
}

D - Inversion Sum

题意

• 给你一个长为\(n\)的数列，\(q\)个交换两个位置的数的操作，对于每个操作是否执行所有\(2^q\)种情况的逆序对数的和。

题解

我们可以计算\(q\)轮操作后的期望逆序对数，乘上\(2^q\)即可，那么就很简单了，设\(\rm{dp[i][j][k]}\)为\(i\)轮操作后\(j<k\)的概率，那么每次操作只会修改\(O(n)\)个\(\rm{DP}\)值，复杂度\(O(n^2+nq)\)。

代码

#include <bits/stdc++.h>

#define For(i, a, b) for (int i = a; i <= b; ++ i)

using namespace std;

const int N = 3000 + 3;
const int mod = 1e9 + 7;

int qpow(int a, int x) {
	int ret = 1;
	while (x) {
		if (x & 1) ret = ret * (ll)a % mod;
		x >>= 1, a = a * (ll)a % mod;
	}
	return ret;
}

int f[N][N], a[N], ans;

int main() {
	int n, q, x, y;

	scanf("%d%d", &n, &q);
	For(i, 1, n) scanf("%d", &a[i]);
	For(i, 1, n) For(j, 1, n) f[i][j] = a[i] < a[j];

	For(cas, 1, q) {
		read(x), read(y);
		f[x][y] = f[y][x] = 500000004ll * (f[x][y] + f[y][x]) % mod;
		For(i, 1, n) if (i ^ x && i ^ y) {
			f[x][i] = f[y][i] = 500000004ll * (f[x][i] + f[y][i]) % mod;
			f[i][x] = f[i][y] = 500000004ll * (f[i][x] + f[i][y]) % mod;
		}
	}

	For(i, 1, n) For(j, i + 1, n) (ans += f[j][i]) %= mod;
	cout << 1ll * ans * qpow(2, q) % mod << endl;

	return 0;
}

E - Less than 3

题意

• 给你两个\(01\)串\(\rm{S, T}\)，每次可以把一位取反，求\(\rm{S-T}\)的最小操作次数，同时需要保证操作过程种不会出现连续的三个字符。

题解

这个东西不太好做，考虑转换模型，我们在\(01\)之间加一块红色的隔板，\(10\)间加一块蓝色的隔板，同时串首尾都有无穷多块隔板。

那么我们发现每次取反一个位置相当于把隔板移动了一格，同时隔板间是不能跨越的，隔板匹配的一个方案对应着一个合法的操作方案。

如果已经知道了隔板位置的话，因为隔板不能跨越，我们知道操作次数的下界是每对对应隔板的坐标差，同时我们可以构造一种方法达到这个下界，大概就是每次要移动隔板的时候移动中间一段连续的两边的都不动，所以可以\(O(n)\)求出操作次数，那么直接枚举\(\rm S\)串前有多少个隔板，取最小值即可，复杂度\(O(n^2)\)。

代码

#include <bits/stdc++.h>

#define mp make_pair
#define For(i, a, b) for (int i = a; i <= b; ++ i)

using namespace std;

const int N = 5e3 + 7;

pair<int, int> a[N], b[N];

char s[N], t[N];

int n, ans = inf, c, d;

void Solve() {
	For(i, 0, n) {
		if ((a[1].y + b[1].y + i) & 1) continue;
		int res = 0, now = 1;
		while (now <= c) {
			int ps = a[now].x, pt = now + i <= d ? b[now + i].x : n + 1;
			res += abs(pt - ps), ++ now;
		}
		while (now + i <= d) res += n + 1 - b[now + i].x, ++ now;
		For(j, 1, i) {
			int pt = j <= d ? b[j].x : n + 1;
			res += pt - 1;
		}
		chkmin(ans, res);
	}
}

int main() {

	scanf("%d%s%s", &n, s + 1, t + 1);

	For(i, 1, n) {
		if (s[i] != s[i - 1])
			a[++ c] = mp(i, s[i] ^ 48);
		if (t[i] != t[i - 1])
			b[++ d] = mp(i, t[i] ^ 48);
	}
	Solve(), swap(c, d), swap(a, b), Solve();

	printf("%d\n", ans);

	return 0;
}

F - Permutation and Minimum

题意

• 给你一个长为\(2n\)的排列\(a\)，\(a\)的有些位置还没有填数，定义序列\(b\)满足\(b[i]=\min(a[2i],a[2i-1])\)，求有多少种不同的序列\(a\)。

题解

先考虑\(a\)序列什么都没填的情况，我们可以先不考虑顺序，那么方案数就是长度为\(2n\)的括号序列数乘上\(n!\)，这启示我们往括号序列的方向上思考。

我们把\(2n\)个数分类，有的已经确定了就不用管，而没有确定的就只有相邻数没填或者两个数都没填的，我们分别记为特殊括号和普通括号。设\(f(i,j,k)\)表示\([i,2n]\)的数已经确定，其中还有\(j\)个特殊括号，\(k\)个普通括号没有匹配的方案数，我们每次考虑当前这个数作为左括号还是右括号。特别地如果当前这个数是普通左括号要匹配一个普通右括号时，先把方案数记作\(1\)，也就是先不分配位置，最后若有\(m\)对普通括号匹配了，他们的位置可以任意排，所以还要乘个\(m!\)，复杂度\(O(n^3)\)。

代码

#include <bits/stdc++.h>

using namespace std;

const int N = 300 + 7;
const int mod = 1e9 + 7;

int n, cnt;
int f[N << 1][N][N];
int a[N << 1], b[N << 1];

int main() { 

	scanf("%d", &n);
	for (int i = 1; i <= n; ++ i) {
		int y = i << 1, x = y - 1;
		scanf("%d%d", &a[x], &a[y]);
		if (a[x] ^ -1) {
			if (a[y] == -1) b[a[x]] = -1;
			else b[a[x]] = b[a[y]] = 1;
		} else {
			if (a[y] ^ -1) b[a[y]] = -1;
			else ++ cnt;
		}
	}

	// f[i][j][k] [i, 2n] is ok, j special ), k normal )。

	f[n << 1 | 1][0][0] = 1;
	for (int i = n << 1; i; -- i) {
		if (b[i] == 1) memcpy(f[i], f[i + 1], sizeof(f[i]));
		else {
			for (int j = 0; j <= n; ++ j)
				for (int k = 0; k <= n; ++ k) {
					if (b[i] ^ -1) {
						(f[i][j][k + 1] += f[i + 1][j][k]) %= mod;
						if (j) (f[i][j - 1][k] += 1ll * j * f[i + 1][j][k] % mod) %= mod;
						if (k) (f[i][j][k - 1] += f[i + 1][j][k] % mod) %= mod;
					} else {
						(f[i][j + 1][k] += f[i + 1][j][k]) %= mod;
						if (k) (f[i][j][k - 1] += f[i + 1][j][k]) %= mod;
					}
				}
		}
	}

	for (int i = 1; i <= cnt; ++ i)
		f[1][0][0] = 1ll * f[1][0][0] * i % mod;
	printf("%d\n", f[1][0][0]);

	return 0;
}