题意
给定 \(n\) 个不可重集，初始每个集合 \(i\) 有元素 \(c_i\)。
请你以下 \(3\) 种操作：
1 x y在集合 \(x\) 插入 \(y\)。2 x y将 \(y\) 集合所有数插入 \(x\)，并删除 \(y\) 集合（不影响别的集合的下标）3 x y求 \(x\) 集合与 \(y\) 集合的交之和。
Sol
可塑性记忆。
注意到前两个操作可以用启发式合并在 \(n \log n\) 时间内简单维护。
考虑如何查询，发现暴力的复杂度为 \(min(|x|, |y|)\)。
不难想到对于集合的大小根号分治。
我们将大小 \(\ge \sqrt n\) 的集合称为 关键集。
集中注意力，注意到如果我们维护关键集两两之间的答案，就可以保证查询的复杂度。
关键集的数量不超过 \(\sqrt n\)，所以每出现一个关键集合，可以暴力 \(O(n + m)\) 预处理出。
对于操作 \(1\)，若当前为关键集，直接加入元素后暴力更新其他所有关键集的答案。
对于操作 \(2\)，分类讨论。
- 普通集插普通集，暴力插入即可
- 普通集插关键集，注意到普通集的所有元素只会被插入关键集一次，所以直接对于每个元素暴力插入，并更新所有关键集的答案。
- 关键集插关键集，这个操作只会有 \(\sqrt n\) 次，直接暴力 \(O(n + m)\) 做即可。
复杂度：\(O(n \sqrt n + n \log n)\) (n, m 同阶)。
Code
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <array>
#include <queue>
#include <vector>
#include <bitset>
#include <cassert>
#define int long long
using namespace std;
#ifdef ONLINE_JUDGE
#define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
char buf[1 << 23], *p1 = buf, *p2 = buf, ubuf[1 << 23], *u = ubuf;
#endif
int read() {
int p = 0, flg = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
p = p * 10 + c - '0';
c = getchar();
}
return p * flg;
}
void write(int x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) {
write(x / 10);
}
putchar(x % 10 + '0');
}
const int N = 1e6 + 5, bsi = 605;
array <vector <int>, N> isl;
bitset <N> vis;
array <int, N> idx, dfn, cur;
array <bitset <N>, 2 * bsi> mp;
array <array <int, 2 * bsi>, 2 * bsi> ksl;
int cnt;
int A, B;
void pushup(int x, int k) {
for (int i = 1; i <= cnt; i++)
if (mp[i][k])
ksl[dfn[idx[x]]][i] += A?k:1, ksl[i][dfn[idx[x]]] += A?k:1;
}
void newnode(int x, int n) {
cnt++;
dfn[idx[x]] = cnt;
cur[cnt] = idx[x];
vis[idx[x]] = 1;
for (auto k : isl[idx[x]])
mp[dfn[idx[x]]][k] = 1;
for (auto k : isl[idx[x]])
pushup(x, k);
}
void modify1(int x, int y, int n) {
assert(idx[x] <= n);
if (vis[idx[x]]) {
if (!mp[dfn[idx[x]]][y])
isl[idx[x]].push_back(y), pushup(x, y);
mp[dfn[idx[x]]][y] = 1;
return;
}
bool flg = 0;
for (auto k : isl[idx[x]])
if (k == y) flg = 1;
if (flg) return;
isl[idx[x]].push_back(y);
if (isl[idx[x]].size() > bsi)
newnode(x, n);
}
bitset <N> tp;
void modify2(int x, int y, int n) {
if (isl[idx[x]].size() < isl[idx[y]].size())
swap(idx[x], idx[y]);
if (vis[idx[y]]) {
for (auto k : isl[idx[y]]) {
if (mp[dfn[idx[x]]][k]) continue;
mp[dfn[idx[x]]][k] = 1;
isl[idx[x]].push_back(k);
}
for (int i = 1; i <= cnt; i++) {
ksl[dfn[idx[x]]][i] = ksl[i][dfn[idx[x]]] = 0;
for (auto k : isl[cur[i]])
if (mp[dfn[idx[x]]][k])
ksl[dfn[idx[x]]][i] += A?k:1, ksl[i][dfn[idx[x]]] += A?k:1;
}
}
else {
if (vis[idx[x]]) {
for (auto k : isl[idx[y]]) {
if (mp[dfn[idx[x]]][k]) continue;
pushup(x, k), mp[dfn[idx[x]]][k] = 1;
isl[idx[x]].push_back(k);
}
}
else {
queue <int> q;
for (auto k : isl[idx[x]])
tp[k] = 1, q.push(k);
for (auto k : isl[idx[y]])
if (!tp[k]) isl[idx[x]].push_back(k);
while (!q.empty())
tp[q.front()] = 0, q.pop();
if (isl[idx[x]].size() > bsi)
newnode(x, n);
}
}
}
int query(int x, int y) {
if (isl[idx[x]].size() > isl[idx[y]].size())
swap(x, y);
int ans = 0;
if (!vis[idx[x]]) {
queue <int> q;
for (auto k : isl[idx[x]])
tp[k] = 1, q.push(k);
if (!vis[idx[y]]) {
for (auto k : isl[idx[y]])
if (tp[k])
ans += A?k:1;
}
else {
for (auto k : isl[idx[x]])
if (mp[dfn[idx[y]]][k])
ans += A?k:1;
}
while (!q.empty())
tp[q.front()] = 0, q.pop();
}
else
ans = ksl[dfn[idx[x]]][dfn[idx[y]]];
return ans;
}
signed main() {
freopen("plasticmemories.in", "r", stdin);
freopen("plasticmemories.out", "w", stdout);
int n = read(), q = read();
A = read(), B = read();
for (int i = 1; i <= n; i++) {
int x = read();
idx[i] = i;
isl[i].push_back(x);
}
while (q--) {
int op = read(), x = read(), y = read();
if (op == 1) modify1(x, y, n);
if (op == 2) modify2(x, y, n);
if (op == 3) {
int ans = query(x, y);
// if (!A) ans = (bool)ans;
if (!B) ans = (bool)ans;
write(ans), puts("");
}
}
return 0;
}