CF1689E & CF1685C & CF1658F & CF1659E
介绍一些神奇的性质题
CF1689E：
给定一张 \(n\) 个点构成的图，每个点有一个非负整数的权值 \(a_1,a_2,\cdots,a_n\)。
\(i,j\) 有边当且仅当 \(a_i\&a_j\gt0\)。
每次可以进行以下两种操作之一：
- 选择一个元素 \(a_i\) 并将它加 \(1\)
- 选择一个元素 \(a_i\) 并将它减 \(1\)（只有 \(a_i\gt0\) 时才可执行此操作）
可以证明存在一个有穷的操作序列使得这张图连通，求出最少的操作次数。
显然先将所有的 \(0\) 变成 \(1\)。
然后发现剩下的操作次数不大于 \(2\)，一种具体的方式如下：
- 考虑所有 \(\text{lowbit}\) 最高的数
- 如果只有一个，将它减一即可
- 否则随便找一个加一，再随便找一个减一
于是枚举所有一步操作的情况一一检验即可，时间复杂度为 \(\mathcal O(n^2\log n)\)。
Code：
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int T;
int n, a[N], ans;
int x;
int tot;
bool vis[N]; int fa[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool check() {
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int k = 0; k < 30; ++k) {
int p = n;
for (int i = 1; p == n && i < n; ++i) if (a[i] >> k & 1) p = i;
int Fa = find(p);
for (int i = p + 1; i <= n; ++i) if (a[i] >> k & 1) fa[find(i)] = Fa;
}
for (int i = 2; i <= n; ++i) if (find(i) != find(1)) return false;
return true;
}
void dfs(int u) {
vis[u] = 1, ++tot;
for (int v = 1; v <= n; ++v)
if (!vis[v] && (a[u] & a[v])) dfs(v);
}
void solve() {
scanf("%d", &n), ans = tot = x = 0; memset(vis + 1, 0, sizeof (bool) * n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (!a[i]) a[i] = 1, ++ans;
x = max(x, a[i] & -a[i]);
}
dfs(1);
if (tot == n) {
printf("%d\n", ans);
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
return;
}
bool flag = 0;
for (int i = 1; i <= n; ++i) {
--a[i];
if (check()) { flag = 1; break; }
a[i] += 2;
if (check()) { flag = 1; break; }
--a[i];
}
if (flag) {
printf("%d\n", ans + 1);
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
return;
}
flag = 0;
for (int i = 1; i <= n; ++i) if ((a[i] & -a[i]) == x) {
if (!flag) {
--a[i], flag = 1;
}
else {
++a[i]; break;
}
}
printf("%d\n", ans + 2);
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
CF1658C：
给定一个由 \(n\) 个
(与 \(n\) 个)组成的括号串，求出最少翻转多少个区间可以使得整个括号串合法，并构造一组方案。\(1\le n\le10^5\)
令左括号为 \(+1\)，右括号为 \(-1\)，需要使得最终序列前缀和都非负。
结论：任意括号串只需要翻转不超过 \(2\) 个区间。
证明：令 \(a_i\) 表示将括号看成 \(+1,-1\) 之后的 \([1,i]\) 的前缀和，则找到 \(a_x\) 值最大的任意一个 \(x\)，翻转 \([1,x],[x+1,2n]\) 显然合法。这个画个图自己看看就明白了。
不需要翻转的情况判一下就好了，问题转到了是否存在只翻转一个区间的方案。
令 \(l,r\) 是最前和最后一个前缀和 \(\lt0\) 的位置，那么最终翻转的区间 \([L,R]\) 一定要满足 \(L\le l,R\gt r\)，最终 \([1,L),(R,2n]\) 的前缀和没有改变，考虑 \(i\in[L,R]\) 的前缀和的改变，记 \(b_i\) 是新的前缀和，\(b_i=a_{L-1}+a_R-a_{i^{′}}\)，其中 \(i^{′}\) 是 \(i\) 翻转前的位置。
那么贪心的选择 \(L\le l,R\gt r\) 且 \(a_{L-1},a_R\) 最大的 \([L,R]\) 检验即可。
Code：
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int T;
int n; char s[N], t[N];
int a[N], b[N];
void solve() {
scanf("%d%s", &n, s + 1), n *= 2;
for (int i = 1; i <= n; ++i) a[i] = a[i - 1] + (s[i] == '(' ? 1 : -1);
int L = 1, R = n;
while (L <= n && a[L] >= 0) ++L; if (L == n + 1) return printf("%d\n", 0), void();
while (R > 0 && a[R] >= 0) --R;
for (int i = L; i; --i) a[i] > a[L - 1] && (L = i + 1);
for (int i = R; i <= n; ++i) a[i] > a[R] && (R = i);
for (int i = 1; i <= n; ++i) t[i] = s[i];
reverse(t + L, t + R + 1);
int p = 1;
for (int i = 2; i <= n; ++i) a[i] > a[p] && (p = i);
for (int i = 1; i <= n; ++i) b[i] = b[i - 1] + (t[i] == '(' ? 1 : -1);
for (int i = 1; i <= n; ++i) if (b[i] < 0) { return printf("%d\n%d %d\n%d %d\n", 2, 1, p, p + 1, n), void(); }
printf("%d\n%d %d\n", 1, L, R);
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
CF1658F：
定义一个 01 串的可爱度为 \(\frac{串中1的个数}{串长度}\)。
现在有一个长度为 \(n\) 的 01 串 \(s\)，要从中选取若干个不相交的子串，要求：
- 所有子串长度加起来为 \(m\)。
- 所有子串拼起来后，可爱度和 \(s\) 的可爱度一样。
现在要求你给出一个合法选取方案，并保证方案的子串个数最少。输出你的方案的子串个数，并输出每个子串的起始结束位置。
记字符串有 \(A\) 个 \(\texttt{0}\) 和 \(B\) 个 \(\texttt{1}\)，那么将一个 \(\texttt{0}\) 的价值记为 \(-B\)，\(\texttt{1}\) 的价值记为 \(A\)。那么价值和为 \(0\) 的子串的可爱度与整个串的可爱度是一样的。
结论：把最后一个字符和第一个字符连起来，形成一个环，环上一定存在一个长度为 \(m\) 的区间的价值和为 \(0\)。
证明：如果每个区间价值和都 \(\gt0\) 或每个区间价值和都 \(\lt0\)，整个串的价值和不可能为 \(0\)。如果存在一个 \(\gt0\) 的区间和 \(\lt0\) 的区间，因为相邻区间中字符 \(\texttt{1}\) 的数量的变化量不超过 \(1\)，所以中间总存在一个价值和为 \(0\) 的区间。
于是答案不超过 \(2\)，检查是否能为 \(1\) 即可。
别忘了特判串里要有小数个 \(1\) 的情况，这一定不合法。
Code：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200005;
int T;
int n, m, cnt;
int a[N*2];
char s[N];
void solve() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
cnt = 0;
for (int i = 1; i <= n; ++i) cnt += (s[i] == '1');
if ((1ll * m * cnt) % n) return printf("%d\n", -1), void();
for (int i = 1; i <= n; ++i) a[i + n] = a[i] = s[i] - '0';
for (int i = 1; i <= n * 2; ++i) a[i] = a[i] * n - cnt;
for (int i = 1; i <= n * 2; ++i) a[i] += a[i - 1];
int l = 0, r = 0;
for (int i = m; i <= n * 2; ++i) {
if (a[i - m] == a[i]) {
l = i - m + 1, r = i;
break;
}
}
if (r <= n) printf("%d\n%d %d\n", 1, l, r);
else printf("%d\n%d %d\n%d %d\n", 2, 1, r - n, l, n);
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
CF1659E：
给定一个 \(n\) 个节点 \(m\) 条边的无向简单连通图，边有边权。
我们定义一条途径（即可以重复经过同一个节点或同一条边的路径）的权值如下：
- 设该途径按顺序经过的边的权值为 \(w_1,w_2,w_3,\cdots\)。
则该途径的权值为 \(\text{mex}(\{w_1,w_1\&w_2,w_1\&w_2\&w_3,\cdots\})\)。
其中 \(\&\) 表示按位与运算，\(\text{mex}(S)\) 表示 \(S\) 中未出现过的最小自然数。
给定 \(q\) 次询问，每次给定两个不同的整数 \(u,v\)，求所有从节点 \(u\) 开始到节点 \(v\) 结束的途径中，途径权值的最小值。
观察样例发现答案只有 \(0,1,2\)，那么是否是这样呢？
的确如此
证明：假设答案 \(\gt2\)，则说明至少出现了 \(0,1,2\)，因为权值是 \(\&\)，即单调不增，那么肯定出现 \(2\)，但是发现 \(2\) 怎么 \(\&\) 都不会变成 \(1\)。假设不成立。
判断答案能否为 \(0\)：
对每一位开一个并查集，维护图的连通性，判断两点是否在其中一张图中连通即可。
判断答案能否为 \(1\)：
则此时一定存在一个位置满足前面的权值都 \(\gt1\)，且后面的权值都是 \(0\)。
换句话说，只要在走某条边之前的与和大于 \(1\)，走之后与和为 \(0\) 就可以了，然后接下来怎么走都可以，所以这样答案与终点无关。
那么怎么得到这样一条路径呢？
显然我们需要选定一位 \(i\)（不能是二进制下最低的一位），然后从出发点走遍所有边权二进制这一位为 \(1\) 的边，然后我们只需要找是否存在一条边能够让与和变成 \(0\)。
具体实现的话需要利用前面建立的并查集，并且记录每一个点所有的出边的边权的与和 \(f_i\)，然后算出在同一个联通块里面的点 \(f_i\) 的与和，如果是 \(0\) 代表这一个联通块内的点作为出发点可以做到答案为 \(1\)。
如果不是 \(0\) 也不是 \(1\)，那就是 \(2\)。
Code：
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
int f[N], g[N];
int fa[30][N];
bool flag[N];
int find(int x, int k) {
if (x == fa[k][x]) return x;
return fa[k][x] = find(fa[k][x], k);
}
void merge(int u, int v, int k) {
int fu = find(u, k), fv = find(v, k);
if (fu == fv) return;
fa[k][fu] = fv;
}
bool check(int u, int v) {
for (int i = 0; i < 30; ++i) if (find(u, i) == find(v, i)) return true;
return false;
}
int main() {
ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
cin >> n >> m; for (int i = 1; i <= n; ++i) f[i] = (1 << 30) - 1; for (int i = 0; i < 30; ++i) for (int j = 1; j <= n; ++j) fa[i][j] = j;
for (int i = 1, u, v, w; i <= m; ++i) {
cin >> u >> v >> w;
f[u] &= w, f[v] &= w;
for (int j = 0; j < 30; ++j) if (w >> j & 1) {
merge(u, v, j);
}
}
for (int k = 1; k < 30; ++k) {
for (int i = 1; i <= n; ++i) g[i] = (1 << 30) - 1;
for (int i = 1; i <= n; ++i) g[find(i, k)] &= f[i];
for (int i = 1; i <= n; ++i) if (g[find(i, k)] == 0) flag[i] = 1;
}
int Q; cin >> Q;
while (Q--) {
int u, v; cin >> u >> v;
if (check(u, v)) cout << 0 << '\n';
else if (flag[u]) cout << 1 << '\n';
else cout << 2 << '\n';
}
return 0;
}
