【algorithm】算法学习--并查集

并查集

1.将两个集合合并

2.询问两个元素是否在一个集合当中

近乎O（1）的时间复杂度内快速完成以上两个操作 按质合并

基本原理：每个集合用一棵树来表示。树根的编号就是整个集合的编号。每个节点存储它的父节点,p[x]表示x的父节点

如何判断树根：if(p[x]==x)

如何求x的集合编号：while(p[x]!=x) x=p[x];

如何合并两个集合：p[x]是x的集合编号，p[y]是y的集合编号。p[x]=y 合并X和Y的集合，就是相当于让其中一个树插到另一个数根节点下面

概念理解题：836. 合并集合 - AcWing题库

#include <iostream>

using namespace std;

const int N = 1e5+10;

int p[N],n,m;

int find(int x)//找祖宗节点
{
    if(p[x]!=x) p[x]=find(p[x]);//一层一层递归找父节点直到找到根节点
    return p[x];//直到找到根节点也就是p[x]=x
}

int main()
{
    scanf("%d%d",&n,&m);

    //最开始每个数各自在一个集合中。
    for(int i=1;i<=n;i++)
    p[i]=i;

    while(m--)
    {
        char op[2];
        int x,y;
        //cin>>op>>x>>y;
        scanf("%s%d%d",op,&x,&y);
        //cout<<op<<" "<<x<<' '<<y<<endl;
        if(op[0]=='M') p[find(x)]=p[find(y)];
        else
        {
            if(find(x)!=find(y))
            printf("No\n");
            else
            printf("Yes\n");
        }
    }
    return 0;
}

练习题：837. 连通块中点的数量 - AcWing题库

#include <iostream>

using namespace std;

const int N = 1e5+10;
int p[N],n,m,num[N];

int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        p[i]=i;
        num[i]=1;
    }


    while(m--)
    {
        char op[2];
        int a,b;
        scanf("%s",op);
        if(op[0]=='C')
        {
            scanf("%d%d",&a,&b);
            if(find(a)==find(b)) continue;//这里注意一下如果a和b在同一个根下
            //再次连接就不起什么作用。
            //先在根上把根下的节点的数量加上
            num[find(b)]+=num[find(a)];
            p[find(a)]=find(b);

        }
        if(op[0]=='Q'&&op[1]=='1')
        {
            scanf("%d%d",&a,&b);
            if(find(a)==find(b))
            printf("Yes\n");
            else
            printf("No\n");
        }
        if(op[0]=='Q'&&op[1]=='2')
        {
            scanf("%d",&a);
            printf("%d\n",num[find(a)]);
        }
    }

    return 0;
}

首先得理解什么是并查集。这道题目是也算是并查集的一个板子题。

并查集的find()函数：

//使用嵌套函数
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);//注意这里不是x=p[x];
    return p[x];
}

//可能很多人看不懂这里的find函数
//这里详细解释一下：
int find(int x)
{
    if(p[x]!=x)
{
    int tmp=find(p[x]);//找到当前的根节点，然后回溯
    p[x]=tmp;//路径压缩，让每一个节点都与根节点相连。也就是处理根节点一个根节点，其余都是叶节点
}
    return p[x];//这里返回的就是当前树的根节点
}
//使用循环
while(p[x]!=x)
p[x]=find(p[x]);

如何理解这里的路径压缩？

路径压缩是运用在并查集查找里的。

这里假设一个这样的树：

当我要查询find(4)的时候

最后就变成了这样：

练习题：240. 食物链 - AcWing题库

这一题自己没有做出来。

用并查集维护额外信息。

完成这道题目的我用了很长的时间，看y总的视频也是看了很久才看懂

首先这样理解：

A、B、C 三种是互相吃的关系

有三句话需要注意：

1. 当前的话与前面的某些真的话冲突，就是假话；
2. 当前的话中 X 或 Y 比 N 大，就是假话；
3. 当前的话表示 X 吃 X，就是假话

其中对于条件2可以进行一个if判断即可。

对于三种动物互相捕猎的关系，可以将当前节点与根节点的距离进行模3处理；对于取模结果相同的归为一类；

每一步的权值都是1。

因此先找到a和b的根节点：pa与pb

对于操作1：

操作1是判断a与b同类；

如果说a和b在同一个树下，即pa==pb

只需要判断d[a]与d[b]都模3后的值是否一样；一样则说明是同类，不一样那就是假话

如果a和b不在同一个树下，即pa!=pb

那么就需要对两个树进行合并：

对于操作2：

操作2是判断a吃b的，依托与我们起初建立的模3模型，这里的a吃b其实就是d[a]-d[b]=1

如果两个节点在同一颗树下，即pa==pb.那就说明如果d[a]-d[b]!=1那么说的就是假话

如果a和b不在同一颗树下，就是说pa!=pb

那么就需要对两个树进行合并

#include <iostream>

using namespace std;

const int N = 5e5+10;
int n,m,p[N],d[N];

int find(int x)
{
    if(p[x]!=x)
    {
        int tmp=find(p[x]);
        d[x]+=d[p[x]];
        p[x]=tmp;
    }
    return p[x];
}
int main()
{
    cin>>n>>m;

    for(int i=1;i<=n;i++) p[i]=i;

    int res=0;
    while(m--)
    {
        int op,a,b;
        cin>>op>>a>>b;
        if(a>n||b>n) //条件2的判断
        {
            res++;
            continue;
        }

     else
        {
            int pa=find(a),pb=find(b);//先找到当前a b的根节点
            if(op==1)
            {
                if(pa==pb&&(d[a]-d[b])%3) res++;
                else if(pa!=pb)
                {
                    p[pa]=pb;
                    d[pa]=d[b]-d[a];
                }
            }
            else
            {
                if(pa==pb&&(d[a]-d[b]-1)%3) res++;
//这里的(d[a]-d[b]-1)%3就是判断d[a]%3是否比d[b]%3大1
//可以采用这种结构简介判断
                else if(pa!=pb)
                {
                    p[pa]=pb;
                    d[pa]=d[b]+1-d[a];
                }
            }
        }
    }

    cout<<res<<endl;
}

/*
2 1 2
2 2 3 
2 3 3 
1 1 3 
2 3 1 
1 5 5
*/
/*
起初p[i]=i   d[i]=0;
对于 2 1 2：
pa=1,pb=2;
p[1]=2;d[1]=d[2]+1-d[a]=1;

对于2 2 3
pa=2,p[3]=3;
p[2]=3;d[2]=d[3]+1-d[2]=1;

对于2 3 3
pa=3,pb=3;
pa==pb (d[3]-d[3]-1)%3!=0  假话；

对于1 1 3
pa=3,pb=3;
pa==pb (d[3]-d[3])%3==0

对于2 3 1
pa=3,pb=3;
pa==pb (d[3]-d[3]-1)%3!=0  假话；

对于1 5 5
pa=5 pb=5
pa==pb  (d[b]-d[a])%3==0 
*/