并查集

//-----并查集的初始化-----

//一开始有n个元素，互相独立，则构成了n个集合，每个集合的代表元素就是它本身

const int maxn = 100010;

int fa[maxn + 1];   //fa数组记录每个元素由谁代表
int sz[maxn + 1];   //sz数组记录每个集合的元素个数
int dep[maxn + 1];  //dep数组记录每个集合的树深度

inline void Initialize(int n){
    for (int i = 1;i <= n;i++){ //一共有n个点
        fa[i] = i;              //把代表元素设置为自己
        sz[i] = dep[i] = 1;     //一开始的深度就是1，子树大小也是1，因为只有自己孤零零的一个元素
    }
    return;
}

//-----集合合并-----

int Findset(int x){     //这个是用来找代表元素的函数，递归找
    if (fa[x] == x){
        return x;
    }
    return Findset(fa[x]);
}

void Union(int x, int y){
    int fx = Findset(x);
    int fy = Findset(y);
    if (fx == fy){      //如果发现是一家子的，那得了直接完事儿了
        return;
    }
    fa[fx] = fy;        //否则我们就搞个强扭的瓜，扭到一起去  反过来写也是可以
    return;
}

//-----路径压缩-----

//大致思路就是在查询的操作过程中，把沿途经过的每一个节点的fa都设置为集合的代表元

int QuicklyFindset(int x){
    if (x == fa[x]){    //如果就是代表元素就直接返回咯
        return x;
    }
    fa[x] = QuicklyFindset(fa[x]);      //在不是的情况下每一次都设置一遍
    return fa[x];
}

/*
上述代码简写版：
int QuicklyFindset(int x){
    return x == fa[x] ? x : (fa[x] == QuicklyFindset(fa[x]));
}
*/

//-----启发式合并-----

//log的复杂度

//大体思路：在合并集合的过程中，我们尽量选择包含元素个数少的集合，将它合并到另一个集合之中去，使要改变代表元的元素尽可能的少
//这种将较小的集合合并到较大的集合之中的方法被称为 启发式合并，在其他的数据结构中也很常见

void HeuristicUnion(int x, int y){
    int fx = Findset(x);
    int fy = Findset(y);
    if (fx == fy){
        return;
    }
    if (sz[fx] > sz[fy]){
        swap(fx, fy);   //确定谁是骡子谁是马
    }
    fa[fx] = fy;
    sz[fy] += sz[fx];   //子树的大小也要加起来
    return;
}

//-----按深度合并-----

//log的复杂度

//大体思路：每一次合并的过程中，将深度较小的集合合并到深度较大的一方去，并更新一下新集合的深度
//值得一提的是，在路径压缩的时候，可能会破坏维护的深度值，但其实整体算法的复杂度不会变差

void DeepUnion(int x, int y){
    int fx = Findset(x);
    int fy = Findset(y);
    if (fx == fy){
        return;
    }
    if (dep[fx] > dep[fy]){
        swap(fx, fy);
    }
    fa[fx] = fy;
    if (dep[fx] == dep[fy]){    //只有两棵树深度相等的时候才会更新
        dep[fy]++;
    }
    return;
}