并查集（模板题）

并查集：

并查集是一种树形的数据结构，用于处理一些不相交集合的合并及查询问题。

并查集通过一个一维数组来实现。

两个作用：

（1）查询元素a和元素b是否属于同一集合；

（2）合并元素a和元素b所在的集合；

三个操作：

第一步：初始化

void init(int n)
{
    for(int i=0;i<=n;i++)
        f[i]=i;//初始化，使所有数的父亲节点都等于TA本身，即是所有数都为毫不相干的根节点
}

第二步：查找根节点（即找祖先)

递归版本：

int find_f(int x)  ///不停找爹，直到找到祖宗为止 
{
    if(f[x]==x)
    	return x;
    else{
     	f[x]=find_f(f[x]);///路径压缩，把递归过程中遇到的结点的祖宗结点也直接修改了
     	return f[x];
    }
}

循环版本：

int find_f(int x)
{
    while(x!=f[x]) //让x和x的父亲变成他的父亲的父亲
    	x=f[x]=f[f[x]];//直到找到祖先才结束循环(x==fa[x])就意味着找到爹了
    return x;
}

第三步：合并子集

void merge(int x,int y)
{
    int v1=find_f(x); ///获取祖宗结点值
    int v2=find_f(y);
    if(v1!=v2) {
		cout<<"NO"<<endl;///当前x,y不在一个集合内
        f[v2]=v1;///靠左合并，把右边y点的祖先改为左边x点的祖先（即将右边的集合，作为左边的子集）
        return;
    }
    cout<<"YES"<<endl;///当前x,y在一个集合内
}

P3367 【模板】并查集

题目描述

如题，现在有一个并查集，你需要完成合并和查询操作。

输入格式：

第一行包含两个整数n、m，表示共有n个元素和m个操作。

接下来m行，每行包含三个整数Z、X、Y

当Z=1时，将X与Y所在的集合合并

当Z=2时，输出X与Y是否在同一集合内，是的话输出Y；否则话输出N

输出格式：

如上，对于每一个Z=2的操作，都有一行输出，每行包含一个大写字母，为Y或者N

输入输出样例

输入样例：
4 7
2 1 2
1 1 2
2 1 2
1 3 4
2 1 4
1 2 3
2 1 4
输出样例：
N
Y
N
Y
说明
时空限制：1000ms,128M

数据规模：

对于30%的数据，N<=10，M<=20；

对于70%的数据，N<=100，M<=1000；

对于100%的数据，N<=10000，M<=200000。

这是一道并查集模板题，AC代码如下：

路径压缩：

#include
using namespace std;
int f[10010];
void init(int n)
{
    for(int i=0;i<=n;i++){
        f[i]=i;
    }
}
int get(int x)
{
    if(f[x]==x)return x;
    return f[x]=get(f[x]);///注意是return f[x]=get(f[x])而不是return get(f[x])。return get(f[x])可能会使其陷入死递归，导致超时。
}
void merge(int x,int y,int z)
{
    int v1=get(x);
    int v2=get(y);
    if(z==2){
        if(v1==v2)cout<<"Y"<<endl;
        else cout<<"N"<<endl;
    }
    else if(z==1){
        if(v1!=v2) f[v2]=v1;
    }
}
int main()
{
    ios::sync_with_stdio(false);
    int n,m,x,y,z;
    cin>>n>>m;
    init(n);
    for(int i=1;i<=m;i++){
        cin>>z>>x>>y;
        merge(x,y,z);
    }
    return 0;
}

路径压缩+启发式合并:

#include
using namespace std;
int f[10010],depth[100010];
void init(int n)
{
    for(int i=0;i<=n;i++){
        f[i]=i;
        depth[i]=0;
    }
}
int getf(int v) //查找他的父节点
{
    if(f[v]==v)
        return v;
    return f[v]=getf(f[v]); ///路径压缩
    ///也可以不用路径压缩，直接return getf(f[v]);
}
//下面为启发式合并的核心代码，增加一个depth数组来储存每个节点的深度，总是把节点并在深度大的节点上
void Merge(int u,int v,int z)///按照秩来做启发式合并
{
    int t1=getf(u);
    int t2=getf(v);
    if(z==1){
        if(t1!=t2){
            if(depth[t1]>depth[t2]){
                f[t2]=t1;
            }
            else if(depth[t1]<depth[t2]){
                f[t1]=t2;
            }
            else if(depth[t1]==depth[t2]){
                f[t2]=t1;
                depth[t1]++;
            }
        }
    }
    else if(z==2){
        if(t1==t2)cout<<"Y"<<endl;
        else cout<<"N"<<endl;
    }
}
int main()
{
	ios::sync_with_stdio(false);
    int n,m,x,y,z;
    cin>>n>>m;
    init(n);
    for(int i=1;i<=m;i++){
        cin>>z>>x>>y;
        Merge(x,y,z);
    }
    return 0;
}

并查集中的启发式合并
图论算法----并查集中的启发式合并

题目：

Description

这是一道模板题。

维护一个 n 点的无向图，支持：

加入一条连接 u 和 v 的无向边

查询 u 和 v 的连通性

由于本题数据较大，因此输出的时候采用特殊的输出方式：用 0 或 1 代表每个询问的答案，将每个询问的答案依次从左到右排列，把得到的串视为一个二进制数，输出这个二进制数 mod 998244353 的值。

Input
第一行包含两个整数 n, m，表示点的个数和操作的数目。

接下来 m 行每行包括三个整数 op, u, v 。

如果 op=0，则表示加入一条连接 u 和 v 的无向边；
如果 op=1，则表示查询 u 和 v 的连通性。

n ≤ 4000000 , m ≤ 8000000

Output
一行包括一个整数表示答案。

Sample Input
3 6
1 1 0
0 0 1
1 0 1
1 1 2
0 2 1
1 2 1

Sample Output
5

Hint
答案串为 101 。

Code

#include
using namespace std;
typedef long long ll;
const ll mod=998244353;
ll n,m,f[4000005],ans;
void init(int n)
{
    for(ll i=0;i<=n;i++)
        f[i]=i;
    return;
}
ll get(ll x)
{
    if(f[x]==x)
        return x;
    return f[x]=get(f[x]);
}
inline void merge(int x,int y)
{
    ll s1=get(x),s2=get(y);
    if(s1!=s2){
        f[s2]=s1;
    }
    return;
}
inline bool find_d(int x,int y)
{
    if(get(x)==get(y))
        return 1;
    else return 0;
}

int main()
{
    ll op,x,y;
    scanf("%lld%lld",&n,&m);
    init(n);
    for(int i=1;i<=m;i++){
        scanf("%lld%lld%lld",&op,&x,&y);
        if(op==1){
            if(find_d(x,y)){
                ans=ans*2+1;
                ans%=mod;
            }   //题目数据过大，二进制转换为十进制后可能会超long long，所以不能等全部存起
            else{  //来再去转为十进制， 要每算完一步就转为十进制然后取模
                ans*=2;
                ans%=mod;
            }
        }
        else if(op==0){
            merge(x,y);
        }
    }
    printf("%lld\n",ans%mod);
    return 0;
}