再探带权并查集
典型例题
权值
故名思义，在带权并查集中，我们需要让每个节点携带一个“权值”。
那么这个权值应该是什么呢？其实答案就在并查集当中。
由于在并查集当中我们可以在 \(O(1)\) 时间内找到一个节点的根节点，那么我们可以让这个权值表示为：某个节点到根节点的距离。
如何维护权值
首先我们需要一个“懒标记数组 \(d\)”，至于为什么称其为“懒标记”，稍后再解释。这个数组就是用来记录我们权值的数组。
即，\(d[i]\) 表示 \(i\) 到根节点的距离。
其次，我们需要在 \(find\) 函数中做一点手脚。这个也稍后解释，
懒标记数组和find()
明明就是用来维护权值的数组，为什么我们要称其为懒标记呢？
试想一下，当我们将以 \(fb\) 为根的集合添加到以 \(fa\) 为根的集合的尾部，我们是需要修改以 \(fb\) 为根的子树集合里面所有点的 \(d[]\) 的，是不是想象就可怕呢？
好，现在我们试着正经分析一下，如果我们真的要一次性修改以 \(fb\) 为根的子树集合中的所有点，有什么办法可以得到这些点吗？
贪心的想，我们肯定希望直接找到集合中的所有点，然后修改，但这是不可能的！由于我们在并查集中只能找到根节点，而不能从根节点找孩子节点，所以我们只能遍历所有点，判断每一个点所在的集合是否为 \(fb\)，这么做的时间复杂度为 \(O(N)\)，如果执行 \(N\) 次这样的操作，就是平方级别的复杂度！这肯定无法接受！
但我们又无法回避这个问题，该如何做呢？ -- 参考线段树中懒标记的做法
当我们需要修改以 \(fb\) 为根的集合中所有点的权值时，我们只修改该集合根节点 \(fb\) 的权值，然后其余的点我们不做操作！
等我们对集合中的某个点 \(x\)（不是该集合的根节点） 执行 \(find\) 操作时，\(find\) 会找到 \(x\) 的所有父节点，直到根节点。
我们发现，我们找到了一条从直接从底层节点到根节点的路径，并且寻找这个路径的过程是递归的（线性）！
既然递归的路径是从底到根，那么回溯时的路径必然是从根到底，而从根到底的过程就可以找到根的所孩子，这些孩子就是该根所在集合中的子树节点！
这个时候（回溯），就可以用来修改我们的懒标记，将他们变成正确的值。
并且，从根到底的回溯也能保证答案的正确性，因为当某个节点的根被修改时，它所有的子节点也需要修改，子树的值依赖于它的根的值，因此保证根的正确性，才能保证底的正确性。
例如，我们让根节点指向一个新的根节点，那么不仅原来的根节点的 \(d[]\) 变化了，它的所有子节点的 \(d[]\) 也需要变化。
最后，还有一个疑问？如果你每次 \(find(x)\) 都会修改 \(x\) 到树根的路径上的 \(d\)，那么会不会导致一个点被重复多次修改，导致它的 \(d[]\) 比实际更大呢？
答案是不会的，因为在第一次 \(find(x)\) 之后，\(x\) 会因为路径压缩，直接指向树的根节点，这样当下一次再 \(find(x)\) 时，会直接返回 \(pre[x]\)，不会涉及到清除懒标记（修正它的 \(d[]\)）这一步。
图解
顺便解释一下清除懒标记（修正 \(d[]\)）的公式：d[x] = d[x] + d[pre[x]]
具体含义：一个节点到根节点的距离 = 它到父节点的距离 + 父节点到根节点的距离
因此，在修正一个节点 \(x\) 时，我们需要先修正它的父节点 \(pre[x]\) 到树根的 \(d[pre[x]]\)，这一点从公式也可以清晰的看出
这也就是我们在 \(find(x)\) 中 int root = find(pre[x]); 做的事情，如果写的更清楚一点，那就是：
int find(int x)
{
if(pre[x] == x) return x; // 原本的find
find(pre[x]); // 1. 先修正所有祖先节点(父->根)
s[x] = s[x] + s[pre[x]]; // 2. 修正自己
return pre[x] = find(pre[x]); // 原本的find
}
可以发现，不过是比原本的路径压缩 \(find\) 多了两条语句罢了！如果我们把最后一句return pre[x] = find(pre[x]); 再优化一下，那就是下面的形式，不过该优化对时间效率的提升很小，因为在我们执行 find(pre[x]) 之后，\(pre[x]\) 便已经直接指向根节点 \(root\)，这样当我们下次再执行 \(find(pre[x])\) 时，由于已经路径压缩过了，实际查找速度是 \(O(1)\) 的。
int find(int x)
{
if(pre[x] == x) return x;
int root = find(pre[x]); // 1. 先修正所有祖先节点(父->根)
s[x] = s[x] + s[pre[x]]; // 2. 修正自己
return pre[x] = root;
}
代码
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 30010;
int pre[N];
int d[N], s[N];
// s[i] 表示 i 所在集合中点的个数
// d[i] 标识 i 到其集合中根节点的距离（带有懒标记的权值数组
int find(int x)
{
// 当 pre[x] == x，即该节点就是集合的根节点时
// 不存在岁回溯路径，也就不需要也不能去除懒标记
if(pre[x] == x) return x;
// 存在回溯路径，去除懒标记
// 先递归，一直找到根节点
int root = find(pre[x]);
// 从根节点开始往下回溯
d[x] += d[pre[x]]; // d[x]_new = d[x]_old + d[pre[x]];，参考上面的图
return pre[x] = root; // 别忘了路径压缩
}
void merge(int a, int b)
{
int fa = find(a), fb = find(b);
if(fa == fb) return ;
// 可以合并
// 只修改a的根节点fa
pre[fa] = fb;
d[fa] += s[fb];
// 修改集合大小
s[fb] += s[fa];
}
int main()
{
for(int i = 0; i < N; i ++ )
{
pre[i] = i;
s[i] = 1;
d[i] = 0; // 初始状态时，自己就是自己的根节点
}
int T; cin >> T;
while(T -- )
{
string op; int a, b;
cin >> op >> a >> b;
if(op == "M") merge(a, b);
else
{
int fa = find(a), fb = find(b);
if(fa != fb) cout << -1 << endl;
// 注意a和b可能相等的情况
else cout << max(0, abs(d[a] - d[b]) - 1) << endl;
}
}
return 0;
}
2024/3/11
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 30010;
int pre[N], d[N], cnt[N];
int find(int x)
{
if(pre[x] == x) return x;
int root = find(pre[x]);
d[x] = d[x] + d[pre[x]];
return pre[x] = root;
}
int main()
{
for(int i = 0; i < N; i ++ ) pre[i] = i, cnt[i] = 1;
int q; cin >> q;
while(q -- )
{
string op; int a, b;
cin >> op >> a >> b;
int fa = find(a), fb = find(b);
if(op == "M")
{
if(fa != fb)
{
pre[fa] = fb;
d[fa] += cnt[fb];
cnt[fb] += cnt[fa];
}
}
else
{
if(fa != fb) cout << -1 << endl;
else
{
if(a == b) cout << 0 << endl;
else cout << abs(d[a] - d[b]) - 1 << endl;
}
}
}
return 0;
}
