1. 并查集基础：从连通性维护到关系拓展
作为一名算法工程师，我处理过大量需要维护元素连通性的场景。从社交网络的好友关系到电路板的连通检查，并查集（Disjoint Set Union）始终是我工具箱中的利器。今天我想系统梳理并查集的三种进阶用法，这些技巧曾帮我高效解决了许多复杂问题。
并查集本质上是一种树型数据结构，它擅长处理不相交集合的合并与查询。想象你正在管理一个大型公司的部门架构：当两个部门合并时，你需要快速确定某个员工属于哪个部门，这就是并查集的典型应用场景。
1.1 核心操作原理解析
标准并查集提供两个基本操作：
- Find：查找元素所属集合的代表元（通常称为"族长"）
- Union：合并两个元素所在的集合
在代码实现时，我们使用一个父指针数组fa[]来表示森林结构。初始化时每个元素自成一派（fa[i] = i），合并操作通过修改父指针来实现集合归并。
cpp复制int fa[MAXN]; // 父节点数组
void init(int n) {
for(int i=1; i<=n; ++i)
fa[i] = i; // 初始各自为政
}
int find(int x) {
return x == fa[x] ? x : fa[x] = find(fa[x]); // 路径压缩
}
void merge(int x, int y) {
fa[find(x)] = find(y); // 族长认亲
}
关键技巧：路径压缩通过在find过程中将节点直接指向根节点，将树高保持在接近常数的水平。这使得单次操作的时间复杂度接近O(α(n))，其中α是反阿克曼函数，增长极其缓慢。
1.2 实战应用：亲戚关系判断
考虑洛谷P1551亲戚关系问题。我们需要判断任意两人是否属于同一家族。这正是并查集的拿手好戏——将具有亲戚关系的两人合并到同一集合，查询时只需比较根节点是否相同。
cpp复制void solve() {
int n, m, p;
cin >> n >> m >> p;
init(n);
while(m--) {
int a, b;
cin >> a >> b;
merge(a, b);
}
while(p--) {
int a, b;
cin >> a >> b;
cout << (find(a) == find(b) ? "Yes" : "No") << endl;
}
}
常见踩坑点：
- 忘记初始化父数组，导致所有元素都指向0
- 合并时直接
fa[x]=y而没使用find，造成部分节点脱离集合 - 路径压缩不彻底，导致树形退化为链状，影响效率
2. 种类并查集：处理对立关系的扩展模型
当问题升级到需要处理"敌人的敌人是朋友"这类复杂关系时，标准并查集就力不从心了。我在解决食物链问题时，发现种类并查集（也叫扩展域并查集）能完美建模这种多态关系。
2.1 三域模型构建技巧
对于A吃B，B吃C，C吃A的食物链问题，我们扩展并查集为三个逻辑域：
- 域1 (1~n)：表示同类关系
- 域2 (n+1~2n)：表示捕食关系
- 域3 (2n+1~3n)：表示被捕食关系
每次声明关系时，需要同步维护三个域的连接状态。例如声明x和y是同类时：
- 合并x和y（同类域）
- 合并x+n和y+n（捕食域）
- 合并x+2n和y+2n（被捕食域）
cpp复制void solve() {
int n, k, ans = 0;
cin >> n >> k;
init(3*n); // 三倍空间初始化
while(k--) {
int op, x, y;
cin >> op >> x >> y;
if(x > n || y > n) { ans++; continue; }
if(op == 1) { // 声称x和y同类
if(find(x) == find(y+n) || find(y) == find(x+n)) {
ans++; // 与已知捕食关系矛盾
} else {
merge(x, y);
merge(x+n, y+n);
merge(x+2n, y+2n);
}
} else { // 声称x吃y
if(find(x) == find(y) || find(y) == find(x+n)) {
ans++; // 同类或反向捕食矛盾
} else {
merge(x, y+n);
merge(x+n, y+2n);
merge(x+2n, y);
}
}
}
cout << ans << endl;
}
调试经验：
- 域的范围计算容易出错，建议使用
x+n而非x+n*1等明确写法 - 合并三个域时漏掉任何一个都会导致逻辑漏洞
- 先检查矛盾再合并，顺序不能颠倒
3. 带权并查集：用向量运算维护关系
种类并查集虽然直观，但需要多倍内存。在内存敏感的场景，我更喜欢使用带权并查集（加权并查集）。它通过记录节点与父节点的相对关系来推导任意两节点的关系。
3.1 权值设计与路径压缩
定义权值数组rel[]，其中rel[x]表示x与fa[x]的关系：
- 0：同类
- 1：x吃fa[x]
- 2：x被fa[x]吃（实际编码中用-1更直观，但取模运算需要处理负数）
路径压缩时，权值需要重新计算：
cpp复制int find(int x) {
if(fa[x] != x) {
int root = find(fa[x]);
rel[x] = (rel[x] + rel[fa[x]]) % 3;
fa[x] = root;
}
return fa[x];
}
3.2 关系合并的向量计算
当已知x与y的关系为r时，合并它们的根节点需要计算根节点间的相对关系。运用向量思想：
设x的根为fx，y的根为fy，则有：
code复制x -> fx = rel[x]
y -> fy = rel[y]
x -> y = r
根据向量运算：fx -> fy = (rel[x] + r - rel[y]) % 3
实现代码：
cpp复制void merge(int x, int y, int r) { // r为x与y的关系
int fx = find(x), fy = find(y);
if(fx != fy) {
fa[fx] = fy;
rel[fx] = (rel[y] - rel[x] + r + 3) % 3;
}
}
3.3 食物链问题的加权解法
cpp复制void solve() {
int n, k, ans = 0;
cin >> n >> k;
for(int i=1; i<=n; ++i) fa[i] = i, rel[i] = 0;
while(k--) {
int op, x, y;
cin >> op >> x >> y;
if(x > n || y > n) { ans++; continue; }
if(op == 1) { // 声称同类
if(find(x) == find(y)) {
if(rel[x] != rel[y]) ans++;
} else {
merge(x, y, 0);
}
} else { // 声称x吃y
if(find(x) == find(y)) {
if((rel[x] - rel[y] + 3) % 3 != 1) ans++;
} else {
merge(x, y, 1);
}
}
}
cout << ans << endl;
}
性能对比：
- 种类并查集：O(3n)空间，操作时间复杂度O(α(n))
- 带权并查集：O(n)空间，操作时间复杂度O(α(n))
- 实际测试中，带权版本通常快20%-30%，但调试难度稍高
4. 工程实践中的优化技巧
在ACM竞赛和工业级应用中，我总结了以下优化经验：
- 按秩合并：记录树的高度，总是让小树合并到大树下，能进一步平衡树高
cpp复制int rank[MAXN];
void merge(int x, int y) {
x = find(x); y = find(y);
if(rank[x] > rank[y]) swap(x,y);
fa[x] = y;
if(rank[x] == rank[y]) rank[y]++;
}
- 动态扩容：当元素范围未知时，使用哈希表替代数组实现动态并查集
python复制fa = {}
def find(x):
if x not in fa: fa[x] = x
while fa[x] != x: fa[x] = fa[fa[x]]; x = fa[x]
return x
-
批量合并：处理大规模数据时，可以先收集所有合并操作，再批量处理
-
关系验证：在关键操作前添加断言检查关系一致性
cpp复制assert((rel[x] + rel[fa[x]]) % 3 == rel[find(x)]);
并查集的魅力在于其简洁而强大的抽象能力。掌握这三种形态后，你会发现它们能优雅解决许多看似复杂的问题，比如：
- 图的动态连通性检查
- 图像连通区域标记
- 棋盘类游戏的局势判断
- 分布式系统中的节点一致性维护
记得第一次成功用带权并查集解决食物链问题时，那种豁然开朗的感觉至今难忘。希望这篇分享能帮你少走些弯路，直接领略到数据结构精妙的设计之美。