Codeforces Round 917 (Div. 2)

A. Least Product#

• 存在 $a[i]=0$，$min=0$，不需要任何操作。
• 负数个数为偶数（包括0），$min=0$，把任意一个改为 $0$。
• 负数个数为奇数，$min=\prod a[i]$，不需要任何操作。

void solve() {
	int n;
	cin >> n;
	vector<int> b, c, d;
	for(int i = 0; i < n; ++ i) {
		int x;
		cin >> x;
		if(x > 0) b.push_back(x);
		else if(x == 0) c.push_back(x);
		else d.push_back(x);
	}
	if(c.size()) puts("0");
	else if(d.size() % 2 == 0) puts("1\n1 0");
	else puts("0");
}

B. Erase First or Second Letter#

枚举每个字符 $s[i]$，统计以当前字符为第一个元素的方案数。
因为第一个元素已经确定，所以只能删 $[i+1,j]$的子串。
先前出现过的字符直接 $continue$。

void solve() {
	int n;
	string s;
	cin >> n >> s;
	ll ans = 0;
	vector<bool> vis(26, 0);
	for(int i = 0; i < n; ++ i) {
		if(!vis[s[i] - 'a']) {
			vis[s[i] - 'a'] = 1;
			ans += (n - i);
		}
	}
	cout << ans << '\n';
}

C. Watering an Array#

考虑把数组清零后怎么贪。
在若干次操作后，整个数组一定是非增的，因此每一天最多有一个位置满足条件。
显然，每两天就进行一次 $reset$ 操作为最优。

---

现在回过来处理原始数组。
枚举操作到第 $i$ 天后再清零。
一次清零最多能得到 $n$ 个贡献。
因此当 $i>2n$ 后，一定不如一开始就清零更优，$i$ 枚举到 $2n$ 就行。
注意 $i$ 要严格小于 $d$，否则没有多余天数给清零操作。

void solve() {
	int n, k, d;
	cin >> n >> k >> d;
	vector<int> a(n + 1), v(k);
	int ans = 0;
	for(int i = 1; i <= n; ++ i) {
		cin >> a[i];
		if(a[i] == i) ++ ans;
	}
	for(int &x : v) cin >> x;
	ans += (d - 1) >> 1;
	for(int i = 0; i < 2 * n; ++ i) {
		if(i == d - 1) break;
		int res = 0;
		for(int j = 1; j <= v[i % k]; ++ j) ++ a[j];
		for(int j = 1; j <= n; ++ j) if(a[j] == j) ++ res;
		res += (d - i - 2) >> 1;
		ans = max(ans, res);
	}
	cout << ans << '\n';
} 

D. Yet Another Inversions Problem#

E. Construct Matrix#

一个显然的性质：若得到一组关于 $k$ 的解，则对答案整个取反后能得到 $k=n^2-k$ 的解。#

首先考虑无解。

• 若 $k$ 为奇数，无解。
• 若 $n>2$ 且 $k=2$ 或 $k=n^2-2$，无解。

我们不妨假设剩下的情况都是有解的。
情况一：$n=k$，很好构造。

void case1() {	// k == n
	for(int i = 1; i <= n; ++ i) a[i][i] = 1; 
}

情况二：$nmod4=0$

• 在一行（列）里添加偶数个 $1$ 不会对原异或值有任何改动。

根据这条性质，容易想到用 ${\displaystyle \frac{k}{4}}$ 个 $2\times 2$ 的单元去填整个网格。

$$\left[\begin{array}{cc}1& 1\\ 1& 1\end{array}\right]$$

void case2() {	// k % 4 == 0
	for(int i = 1; i <= n; ++ i) {
		for(int j = 1; j <= n; ++ j) {
			if(!a[i][j] && k) {
				a[i][j] = a[i + 1][j] = a[i][j + 1] = a[i + 1][j + 1] = 1;
				k -= 4;
			}
		}
	}
}

情况三：$nmod4=2$
去思考如何把情况三转化到情况二。
我们可以在网格的左上角构造如下 $4\times 4$ 的单元格。

$$\left[\begin{array}{cccc}1& 1& 0& 0\\ 1& 0& 1& 0\\ 0& 1& 1& 0\\ 0& 0& 0& 0\end{array}\right]$$

把 $k$ 整体减去 $6$ 后成功转化为情况二。
按照上述构造方法需要考虑 $k_{max}=n^2-9$。
如果 $k$ 大于其最大值，则令 $k=n^2-k$，最后翻转答案。

void Reverse (){
	for(int i = 1; i <= n; ++ i)
		for(int j = 1; j <= n; ++ j)
			a[i][j] ^= 1;
}
void case3() { // k % 4 == 2
	
	bool f = 0;
	if(k > n * n - 9) f = 1, k = n * n - k;
	
	a[1][1] = a[1][2] = a[2][1] = a[2][3] = a[3][2] = a[3][3] = 1; 
	k -= 6;
	
	for(int i = 1; i <= n; ++ i) {
		for(int j = 1; j <= n; ++ j) {
			if(i <= 4 && j <= 4) continue;
			if(!a[i][j] && k) {
				a[i][j] = a[i + 1][j] = a[i][j + 1] = a[i + 1][j + 1] = 1;
				k -= 4;
			}
		}
	}
	if(f) Reverse();
}

F. Construct Tree#

先把 $a$ 排序。

• 性质一：对于任意两条边 $e1,e2$，一定存在至少一条路径同时通过这两条边。

容易得到，若 $a[n]+a[n-1]>d$，则一定无解。

• 性质二：若存在边集 $E$（不含 $a[n]$）的子集 $S$ 满足 $\sum S=d-a[n]$，则一定有解。

把 $S$ 中所有边构成一条链挂在根节点上
对于剩余的边则一个一个挂上去。
注意：此时已经将性质一中的无解情况去掉了，可以证明此时满足条件。。

• 性质三：设 $S_1,S_2$ 为边集 $E$（不含 $a[n]$）的两个互不重合的子集。若 $S_1$ 与 $S_2$ 的和都大于 $a[n]$，则一定有解。

把 $S_1$ 中所有边构成一条链挂在根节点上，$S_2$ 同样操作。
对于剩余的边则一个一个挂上去。
可以证明此时满足条件。

对于性质三，我们可以用 $dp[i][j]$ 表示 $S_1$ 总和为 $i$，$S_2$ 总和为 $j$ 的方案是否存在。
对于性质二，可以用 $dp[0][n-a[n]]$ 表示状态。
联想到 $01$ 背包问题，复杂度 $O(n{d}^2)$，会超时。
由于状态是 $01$ 的，可以用 $bitset$ 压下位，复杂度 $O({\displaystyle \frac{n{d}^2}{\omega }})$，可以通过。

int n, d, a[N];
bitset<N> dp[N];

void solve() {
	cin >> n >> d;
	for(int i = 1; i <= n; ++ i) cin >> a[i];
	sort(a + 1, a + n + 1);
	if(a[n] + a[n - 1] > d) {
		puts("No");
		return;
	}
	for(int i = 0; i <= d; ++ i) dp[i].reset();
	dp[0][0] = 1;
	for(int i = 1; i < n; ++ i) {
		for(int j = d; j >= 0; -- j) {
			if(j + a[i] <= d) dp[j + a[i]] |= dp[j];
			dp[j] |= dp[j] << a[i];
		}
	}
	bool ok = dp[0][d - a[n]];
	for(int i = a[n]; i <= d - a[n]; ++ i) ok |= dp[i][d - i];
	puts(ok ? "Yes" : "No");
}