并查集（Union_find sets）

算法介绍

数据结构与算法（图论系列）——并查集

问题1：合并集合

描述

一共有n个数，编号是1~n，最开始每个数各自在一个集合中。

现在要进行m个操作，操作共有两种：

1. “M a b”，将编号为a和b的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
2. “Q a b”，询问编号为a和b的两个数是否在同一个集合中；

数据范围：1≤n,m≤10^5

输入

第一行输入整数n和m。

接下来m行，每行包含一个操作指令，指令为“M a b”或“Q a b”中的一种。

输出

对于每个询问指令”Q a b”，都要输出一个结果，如果a和b在同一集合内，则输出“Yes”，否则输出“No”。

每个结果占一行。

输入样例 1 

4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4

输出样例1

Yes
No
Yes

 代码实现

#include<iostream>
#include<stdio.h>
using namespace std;
const int N=100010;

int p[N];//记录每个元素所在集合的帮主
int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)p[i]=i;//初始化每个集合一个元素

    while(m--)
    {
        char op[2];
        int a,b;
        scanf("%s%d%d",op,&a,&b);
        if(*op=='M')p[find(a)]=find(b);
        else
        {
            if(find(a)==find(b))puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

问题2：连通块中点的数量

描述

给定一个包含n个点（编号为1~n）的无向图，初始时图中没有边。

现在要进行m个操作，操作共有三种：

1. “C a b”，在点a和点b之间连一条边，a和b可能相等；
2. “Q1 a b”，询问点a和点b是否在同一个连通块中，a和b可能相等；
3. “Q2 a”，询问点a所在连通块中点的数量；

数据范围:1≤n,m≤10^5

输入

第一行输入整数n和m。

接下来m行，每行包含一个操作指令，指令为“C a b”，“Q1 a b”或“Q2 a”中的一种。

输出

对于每个询问指令”Q1 a b”，如果a和b在同一个连通块中，则输出“Yes”，否则输出“No”。

对于每个询问指令“Q2 a”，输出一个整数表示点a所在连通块中点的数量

每个结果占一行。

输入样例 2

5 5
C 1 2
Q1 1 2
Q2 1
C 2 5
Q2 5

输出样例 2

Yes
2
3

代码实现

#include<iostream>
#include<stdio.h>
#include<string>
using namespace std;
const int N=100010;

int p[N];//记录每个元素所在集合的帮主
int num[N];
int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)p[i]=i,num[i]=1;//初始化每个集合一个元素

    while(m--)
    {
        string op;
        int a,b;
        cin>>op;
        if(op=="C")
        {
            scanf("%d%d",&a,&b);
            a=find(a),b=find(b);
            if(a!=b)p[a]=b,num[b]+=num[a];
        }
        else
        {
            if(op=="Q1")
            {
                scanf("%d%d",&a,&b);
                if(find(a)==find(b))puts("Yes");
                else puts("No");
            }
            else
            {
                scanf("%d",&a);
                printf("%d\n",num[find(a)]);
            }
        }
    }
    return 0;
}

Kruskal算法求最小生成树

描述

给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n = |V|，m = |E|。

由V中的全部n个顶点和E中n - 1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。

数据范围

1≤n≤10^51≤m≤2*10^5

图中涉及边的边权的绝对值均不超过1000

输入

第一行包含两个整数n和m。

接下来m行，每行包含三个整数u、v、w，表示点u和点v之间存在一条权值为w的边。

输出

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出impossible

代码实现

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=100005,M=200005,INF=0x3f3f3f3f;
struct Edge
{
    bool operator<(const Edge& W)const
    {
        return w<W.w;
    }
    int u,v,w;
}edges[M];
int p[N];
int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}
int n,m;
int kruskal()
{
    sort(edges,edges+m);
    for(int i=1;i<=n;i++)p[i]=i;
    int res=0,cnt=0;
    for(int i=0;i<m;i++)
    {
        int a=edges[i].u,b=edges[i].v,w=edges[i].w;
        a=find(a),b=find(b);
        if(a!=b)
        {
            res+=w;
            p[a]=b;
            cnt++;
        }
    }
    if(cnt<n-1)return INF;
    return res;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        edges[i]={u,v,w};
    }
    int t=kruskal();
    if(t==INF)puts("impossible");
    else printf("%d\n",t);
    return 0;
}