CF1693F

首先可以假定整个序列 \(c_0\ge c_1\)，否则我们把 \(0\) 变成 \(1\)，\(1\) 变成 \(0\)，并翻转序列。新序列答案与原序列相同。
结论：仅操作 \(c_0=c_1\) 的区间的最小答案和原题一致。
证明：考虑操作了一个 \(c_0-c_1=d\) 的区间。区间第一个数，若是 \(0\)，那我们的操作区间其实不应该包含它。也就是说第一个数是 \(1\)，那么我们找到一个 \(1\) 和 \(0\) 数量相等的前缀将其排序，第一个数就变成了 \(0\)。然后我们把它去掉，就花费了 \(1\) 的代价进入了 \(d-1\) 的子问题，直到 \(d=0\) 可以一次性排序。这就相当于把原操作拆成了 \(d+1\) 个 \(c_0=c_1\) 的操作。
得知这个结论以后，就可以考虑贪心了。
贪心策略：每次操作一个最长的 \(c_0=c_1\) 的前缀，然后把其中的 \(0\) 删掉。若此时 \(c_0\le c_1\) 了，就可以从删掉的 \(0\) 里面补回来一些，然后一次排好，否则重复此过程。
正确性可以感性理解，在最后一次操作前，前 \(c_0-c_1\) 个数应当全是 \(0\)。那么第一个 \(1\) 肯定是需要往后，而且肯定是越早越好。
具体实现，我们求出 \(mx_i\) 表示最大使得每个前缀中 \(0\) 比 \(1\) 多 \(i\) 个的位置。就可以在每次删掉若干个 \(0\) 后求出下一段 \(01\) 个数相等的最长前缀了。

Code：

#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int T;
int n;
int a[N]; char s[N];
int mx[N];

void solve() {
	scanf("%d%s", &n, s);
	int c0 = 0, c1 = 0;
	for (int i = 0; i < n; ++i) a[i] = s[i] - '0', c0 += a[i] == 0;
	c1 = n - c0;
	if (!c1) return printf("%d\n", 0), void();
	for (int i = 0; i < n; ++i) {
		bool flag = 1;
		if (a[i] == 1) {
			for (int j = i + 1; j < n; ++j) flag &= a[j];
			if (flag) return printf("%d\n", 0), void();
			break;
		}
	}
	if (c0 < c1) {
		swap(c0, c1), reverse(a, a + n);
		for (int i = 0; i < n; ++i) a[i] ^= 1;
	}
	memset(mx, 0, sizeof (int) * (n + 1));
	for (int i = 0, cur = 0; i < n; ++i) {
		if (a[i]) --cur; else ++cur;
		if (cur >= 0) mx[cur] = i;
	}
	int delta = c0 - c1, cur = 0;
	while (a[cur] == 0 && cur < n) ++cur;
	int ans = 0;
	while (cur < delta) {
		++ans;
		cur += (mx[cur] - cur + 1) / 2;
	}
	printf("%d\n", ans + 1);
}

int main() {
	scanf("%d", &T);
	while (T--) solve();
	return 0;
}