并查集的实现

并查集的思想就是把一个个有着相同性质或者被执行相同操作的区域当成一个集合来对待，集合与集合之间的区别就在于他们的祖先不一样。

我们将一个元素抽象为一个人, 一个集合抽象为一个家族

开始时, 每个人的父亲和祖先都是自己, 但是在后面, 他们会认其他人为父亲

如何判断两个元素A和B是否在同一个家族中? 只要A的祖先和B的祖先在同一个集合中即可

什么是祖先? 如果儿子找父亲, 父亲找爷爷, 爷爷找太爷爷, 直到某一个太太太太太爷爷没有父亲(或者说父亲是自己)那么他就是这个大家族(集合)的祖先

如果A想加入B家族, 那么只要让A的祖先认B家族中的某一个人为父亲即可. 这样的话A如果想认祖归宗, 那么他的祖先就肯定是B家族里的祖先了, 这样他们就是一家人了

值得注意的是, A如果想加入B家族, 那么A的祖先虽然可以认B家族中的任何一个人为父亲, 但是为了找祖先找起来方便, 一般是让A的祖先认B的祖先为父亲的. 还有就是, 如果A家族后代比B家族多(深度更深), 那么让B家族的祖先认A家族的祖先是更为明智的选择

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int f[10005];
//找到x真正的父亲
int find(int x){
        if(f[x]==x) return x;
        else{
                f[x]=find(f[x]);
                return f[x];
        }
}
int main(){
        for(int i=0;i<=n;i++)
                f[i]=i;//先将他们的父亲和祖先都定义成自己
        for(int i=m;i>1;i--){
                int px=find(x);//找到x的祖先
                int py=find(y);//找到y的祖先
                if(px!=py){//当他们的父亲不相同时，就说明他们不是同一个连通块的
                        f[px]=py;
                        //执行相应的操作
                }
                else{
                        //执行相应的操作
                }
        }
        return 0;
}

常用的几个子函数是这样的

//初始化父亲与深度
void init(int sum){
        for(int i=0;i<sum;i++){
                f[i]=i;
                deep[i]=0;
        }
}
//寻找x的父亲
int findf(int x){
        if(f[x]==x) return x;
        else{
                f[x]=findf(f[x]);
                return f[x];
        }
}
//判断二者的父亲是否相同
bool same(int x,int y){
        return findf(x)==findf(y);
}
//将深度小的那个集合连到深度大的集合上去
void unite(int x,int y){
        x=findf(x);
        y=findf(y);
        if(x==y) return;
        if(deep[x]<deep[y]){
                f[x]=y;
        }
        else if(deep[x]>deep[y]){
                f[y]=x;
        }
        else{
                f[y]=x;
                deep[x]++;
                //或者是f[x]=y;deep[y]++;这个都无所谓
        }
}