CF1530G What a Reversal 题解

题意简述

有两个长为 \(n\) 的 \(01\) 串 \(S\) 和 \(T\)，你可以进行至多 \(4n\) 次操作，每次翻转（注意不是反转）\(S\) 的一个恰有 \(k\) 个 \(1\) 的子串，目标串是 \(T\)。判断无解或者构造方案。\(\sum n \leq 2000\)

题解

这个题太神了啊……想了好多天才想出来。（为啥小 t 的构造题都这么难

首先 \(k=0\) 或者 \(k \geq n\) 的情况是 trivial 的，特判一下就好了。接下来说 \(1 \leq k < n\) 的情况。

如果 \(S\) 和 \(T\) 中 \(1\) 的个数不一样我们也想都不用想。

结论：操作是可逆的。

这个结论的正确性是显然的。这意味着我们只要把 \(S\)​ 和 \(T\)​ 都通过某一操作变成同一个串就好了。接下来做的事情目标都是把 \(S,T\) 在 \(2n\) 步之内变成同一个串。

然后我们考虑 \(S\) 作为 \(01\) 串的形式不是很容易操作，进行一步转化：

令 \(p_i\) 表示 \(S\) 中第 \(i\) 个 \(1\) 之后有几个连续的 \(0\)。比如 \(S = 1001100011\) 可以表示成 \(p = [0, 2, 0, 3, 0, 0]\)。

令 \(m\) 表示 \(S\) 中有几个 \(1\)，\(a_i\) 表示第 \(i\) 个 \(1\) 在 \(S\) 中的位置。令 \(a_0 = 0\)，\(a_{m + 1} = n + 1\)。

结论：翻转 \(S\) 的一个包含第 \(l\) 个到第 \(r\) 个 \(1\) 的合法子串，相当于把 \(p_{l..r-1}\) 翻转，并且把 \(p_{l-1}\) 和 \(p_r\) 变成 \(p_{l-1}'\) 和 \(p_r'\) 满足 \(p_{l-1}' + p_r' = p_{l-1}+p_{r}\)。

这个结论的正确性也是显然的。

我们对于每一个 \(i > k\) 并且 \(p_i > 0\) 的 \(i\) 进行操作：翻转 \([a_{i - k + 1},a_{i + 1} - 1]\) 这个区间。这个操作做了什么？

直观上考虑，这个操作使得最后若干位都是 \(1\)，把原本在后面的一段 \(0\) 放到前面去了。

从对 \(p\) 的贡献考虑，这个操作翻转了 \(p_{i - k + 1 .. i}\)，并且把 \(p_{i + 1}\) 变成 \(0\)，\(p_{i - k}\) 变成 \(p_{i - k} + p_{i + 1}\)。相当于把后面的 \(p\) 加到前面去了。

我们反复执行这个操作，就能使得所有的 \(0\)​ 都在第 \(k\)​ 个 \(1\)​ 之前，即 \(\forall i > k, p_i = 0\)​。

这个至多会使用 \(m-k\) 个操作。

然后考虑处理接下来的情况。如果我们翻转 \(p_{1..k-1}\)​​​ 和 \(p_{2..k}\)​​​，则显然 \(p_1, p_2, p_3, \ldots, p_{k-2},p_{k-1}, p_k\)​​​ 就会变成 \(p_{k-1}, p_k, p_1, p_2, \ldots, p_{k-2}\)​​​。

我们考虑在翻转 \(p_{1..k-1}\) 的时候把 \(p_k\) 全部加到 \(p_0\) 上面去，即翻转区间 \([a_1, a_{k+1}-1]\)。这样我们可以把 \(p_k\) 变成 \(0\)。

容易发现 \(p_{1..k}\) 发生了一个长度为 \(2\)​ 的循环移位。

Case 1

如果 \(k\) 是奇数，那么在 \(k\) 次移位之内 \(p_1, p_2, \ldots, p_k\) 中的每一个数都肯定到达过一次 \(p_k\)​ 的位置。（在每次操作时 \(p_k\) 位置上面的数分别是：\(p_k, p_{k-2}, p_{k-4}, p_{k-6}, \ldots, p_1, p_{k-1}, p_{k-3}, \ldots, p_2\)。）

因为每次移位把 \(p_k\) 位置上的数清零了，所以 \(k\) 次移位一定能够使 \(p_{1..k}\) 的数都是 \(0\)，\(p_0\) 的值为 \(\sum _{i=1} ^k p_i\)​ 即 \(m\)。

所以我们可以在至多 \(2k + m - k = m + k \leq 2n\) 次操作内把 \(S\) 变成 \(0000..0011111\) 这种形式。（\(0\) 全部在 \(1\) 的前面）我们对于 \(T\) 进行同样的操作再把顺序倒过来就行了。

Case 2

如果 \(k\) 是偶数的话，我们明显并不能把所有的 \(p_i\) 都加到 \(p_0\) 上面。因为我们无论如何操作，循环移位的话总是有一半的位置不能到达 \(p_k\)。

为什么呢？

因为奇数总是管奇数，偶数总是管偶数。

那你不是把奇数都放到一个数，把偶数放到一个数就好了吗？

有道理啊/qd/qd/qd/qd/qd

结论：如果 \(k\)​ 是偶数，则 \(\sum_{x\text{ is even}} p_x\)​ 和 \(\sum _{x \text{ is odd}} p_x\) 是一个定值。

因为奇数总是管奇数，偶数总是管偶数。

那你就把奇数都放到一个数，把偶数放到一个数就好了。

具体的，我们在进行翻转 \(p_{1..k}\) 的时候把 \(p_k\) 加到 \(p_0\) 上面，在翻转 \(p_{2..k+1}\) 的时候把 \(p_1\) 加到 \(p_{k+1}\) 上。这样，在 \(k\) 次循环移位之后，我们一定可以把奇数位的都加到 \(p_{k+1}\)，偶数位的都加到 \(p_0\)。

所以我们可以至多 \(m - k + 2k = m + k \leq 2n\) 次操作内把 \(S\) 变成 \(000..00111111111100..01111111\) 这种形式（里面第一个连续 \(1\) 段一定是 \(k\) 个 \(1\)）。

实现有点细节，不知道为什么有些人写的很简单。

#include <bits/stdc++.h>

const int N = 2005;

int n, k, m, p[N], q[N];
char s[N], t[N];
std::vector<std::pair<int, int>> r1, r2;
// p[] & q[] describes the p array of string s & t.
// r1, r2 describes the steps that can make s & t the same intended string.

int s_eq_t() { for (int i = 1; i <= n; ++i) if (s[i] != t[i]) return 0; return 1; }
// s_eq_t() checks if s & t is the same string.

int get_k_eq_m() {
	for (int i = 1 - n; i < n; ++i) {
		int flg = 1;
		for (int j = 1; j <= n; ++j)
			if (s[j] != ((i + j > 0 && i + j <= n) ? t[i + j] : 0)) { flg = 0; break; }
		if (flg) return i;
	}
	return n;
}
// get_k_eq_m() checks if s is a cyclic shift of t, and returns the steps if it is.

void sol_k_eq_m() {
	int st, ed;
	for (int i = 1; i <= n; ++i) if (s[i]) { st = i; break; }
	for (int i = n; i; --i) if (s[i]) { ed = i; break; }
	int k = get_k_eq_m(); // checks if s is a cyclic shift of t.
	if (k < n) {
		puts("2");
		printf("%d %d\n", std::min(st, st + k), std::max(ed, ed + k));
		printf("%d %d\n", st + k, ed + k);
		return;
	}
	std::reverse(t + 1, t + n + 1);
	k = get_k_eq_m(); // checks if s is a cyclic shift of t's reverse.
	if (k < n) {
		puts("3");
		printf("%d %d\n", std::min(st, st + k), std::max(ed, ed + k));
		printf("%d %d\n", st + k, ed + k);
		printf("1 %d\n", n);
		return;
	}
	puts("-1"); // if not, no solution
}
// sol_k_eq_m() solves the case of k equals m.

void get_p(char *s, int *p) {
	int lst = 0, cnt = 0;
	for (int i = 1; i <= n; ++i)
		if (s[i]) p[cnt++] = i - lst - 1, lst = i;
	p[cnt] = n - lst;
}
// get_p() calculates the array p according to s.

void sol(int *p, std::vector<std::pair<int, int>> &r) {
	auto get_pos = [&](int x)->int {
		if (x == 0) return 0;
		if (x == m + 1) return n + 1;
		int res = 0;
		for (int i = 0; i < x; ++i) res += p[i];
		return res + x;
	}; // get the position of the xth 1 according to p[].
	for (int i = m; i > k; --i)
		if (p[i]) {
			int st = get_pos(i - k + 1);
			int ed = get_pos(i + 1) - 1;
			if (st != ed) r.emplace_back(st, ed);
			p[i - k] += p[i], p[i] = 0;
			std::reverse(p + i - k + 1, p + i);
		} // if i > k and p[i] has a value, add p[i] to p[i - k]. 
	// This operation makes p[i] = 0 for all i > k.
	for (int t = 0; t < k; ++t) {
		int st = get_pos(1);
		int ed = get_pos(k + 1);
		if (st != ed - 1) r.emplace_back(st, ed - 1);
		p[0] += p[k], p[k] = 0;
		std::reverse(p + 1, p + k);
		st = get_pos(2);
		ed = get_pos(k + 1);
		if (st != ed) r.emplace_back(st, ed);
		std::reverse(p + 2, p + k + 1);
	} // do k cyclic shifts of [1..k] such that all numbers has reached the position p[k] once. add p[k] to p[0].
	// This operation makes p[i] = 0 for all i in [1, k].
	// After this, p[i] = 0 stands for all i > 0.
	// Therefore, applying sol() to both s and t makes them the same string with all 0s at the front of the string. 
}
// sol() solves the case k is odd.

void sol2(int *p, std::vector<std::pair<int, int>> &r) {
	auto get_pos = [&](int x) {
		if (x == 0) return 0;
		if (x == m + 1) return n + 1;
		int res = 0;
		for (int i = 0; i < x; ++i) res += p[i];
		return res + x;
	}; // get the position of the xth 1 according to p[].
	for (int i = m; i > k; --i)
		if (p[i]) {
			int st = get_pos(i - k + 1);
			int ed = get_pos(i + 1) - 1;
			if (st != ed) r.emplace_back(st, ed);
			p[i - k] += p[i], p[i] = 0;
			std::reverse(p + i - k + 1, p + i);
		} // if i > k and p[i] has a value, add p[i] to p[i - k]. 
	// This operation makes p[i] = 0 for all i > k. (same as the one in sol())
	for (int t = 0; t < k; ++t) {
		int st = get_pos(1);
		int ed = get_pos(k + 1);
		if (st != ed - 1) r.emplace_back(st, ed - 1);
		p[0] += p[k], p[k] = 0;
		std::reverse(p + 1, p + k);
		st = get_pos(1);
		ed = get_pos(k + 1);
		p[k + 1] += p[1], p[1] = 0;
		if (st + 1 != ed) r.emplace_back(st + 1, ed);
		std::reverse(p + 2, p + k + 1);
	} // do k cyclic shifts of [1..k] such that all numbers has reached the position p[k] or p[1] once.
	// This operation makes p[i] = 0 for all i in [1, k].
	// After this, p[i] = 0 stands for all i in [1, k] \cup [k + 2, m]
	// Therefore, applying sol() to both s and t makes them the same string 000..0001111..11(k 1s)000.0000111.11
}
// sol2() solves the case k is even.

int main() {
	int T; scanf("%d", &T);
	while (T--) {
		scanf("%d%d%s%s", &n, &k, s + 1, t + 1);
		int cnts = 0, cntt = 0;
		for (int i = 1; i <= n; ++i) s[i] -= '0', t[i] -= '0';
		for (int i = 1; i <= n; ++i) cnts += s[i], cntt += t[i];
		if (cnts != cntt) { puts("-1"); continue; } else m = cnts;
		if (s_eq_t()) { puts("0"); continue; }
		if (k == 0 || k > m) { puts("-1"); continue; }
		if (k == m) { sol_k_eq_m(); continue; }
		get_p(s, p);
		get_p(t, q);
		r1.clear(), r2.clear();
		if (k & 1) {
			sol(p, r1);
			sol(q, r2);
		} else {
			int tmp[2][2]; 
			memset(tmp, 0, sizeof(tmp));
			for (int i = 0; i <= m; ++i) tmp[0][i & 1] += p[i];
			for (int i = 0; i <= m; ++i) tmp[1][i & 1] += q[i];
			if (tmp[0][0] != tmp[1][0] || tmp[0][1] != tmp[1][1]) { puts("-1"); continue; }
			sol2(p, r1);
			sol2(q, r2);
		}
		printf("%d\n", (int)r1.size() + (int)r2.size());
		for (unsigned i = 0; i < r1.size(); ++i) printf("%d %d\n", r1[i].first, r1[i].second);
		for (unsigned i = r2.size() - 1; ~i; --i) printf("%d %d\n", r2[i].first, r2[i].second); // output in reverse order
	}
	return 0;
}