[ 20230308 CQYC省选模拟赛 T2 ] 塑料内存条

题意

给定 \(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;
}