并查集(带权+路径压缩+连通点统计)

并查集

(集合,连通分量)
具体概念:并查集

把每一个单独不可分割的点作为最小的一个分量
然后做合并删除等操作

836. 合并集合

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

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

M a b，将编号为 a和 b的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；

Q a b，询问编号为 a和 b的两个数是否在同一个集合中；

输入格式

第一行输入整数 n和 m。
接下来 m行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。

输出格式

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

每个结果占一行。
数据范围

1≤n,m≤105

输入样例：

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

输出样例：

Yes
No
Yes

思想:将单独的点作为一个集合 然后集合的标志就是他本身的编号
加入点以后做优化(路径压缩)
让加入集合的点都指向标志
即find函数的实现
(回溯)

#include <iostream>
using namespace std;
const int N=100010;
int n,m;
int p[N];//记录每个点的父节点

int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
    /*
    ----------------
    
    除了祖先记录的是它本身
    其他节点记录的都是祖先
    
    所以find函数就是找到祖先
    回溯做路径压缩 让所有节点指向祖宗
    注意不是返回x
    如果返回x的话其他点没接上
    
    ----------------
    */
    
}
int main(void)
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
       p[i]=i;
    //初始化 使每个点各自为一个集合让他等于自己的编号
    
    while(m--)
    {
        char op;
        int a,b;
        cin>>op>>a>>b;
        
        if(op=='M')
        p[find(a)]=find(b);
    //将a的祖先的祖先 设置 为b的祖先 从而集合合并
        else
        printf("%s\n",find(a)==find(b)?"Yes":"No");
       
        
    }
    
    
    return 0;
    
}

AcWing 837. 连通块中点的数量

多用一个cnt数组维护

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

int p[N],cnt[N];

int n,m;

int find(int x)
{
    if(p[x]!=x)p[x]=find(p[x]);
    return p[x];
}
int main(void)
{
    scanf("%d%d",&n,&m);
    
    for(int i=1;i<=n;i++)
    p[i]=i,cnt[i]=1;
    
    while(m--)
    {
        string s;
        int a,b;
        cin>>s;
        if(s=="C")
        {
            scanf("%d%d",&a,&b);
            if(find(a)!=find(b))
            {
            
            cnt[find(b)]+=cnt[find(a)];//因为是接到b集合里 所以集合b的个数加上集合a的个数
            p[find(a)]=find(b);
            }
            
        }
        else if(s=="Q1")
        {
            scanf("%d%d",&a,&b);
            printf("%s\n",find(a)==find(b)?"Yes":"No");
        }
        else
        {
            scanf("%d",&a);
            printf("%d\n",cnt[find(a)]);
            
        }
        
        
        
    }
    
    
    return 0;
    
}

带权路径压缩 AcWing 240. 食物链

#include <iostream>
using namespace std;
const int N=500010;//动物数目<N 种类数是3种 
int p[N],d[N];//并查集来维护 p[x]表示x的父节点 d[x]表示x到父节点的距离
/*
----------------

在这N个动物里面 动物的种类只有3种 
我们首先可以让每一个动物各自为一个集合 就相当于一个动物就是一个种类
然后当我们提及的时候 就把动物放到一个集合里

首先我们考虑在一个集合里的 
比如刚好有三个节点
    %3==0 O  ①
   d 5 
    %3==1 O  ②
   d 2
    %3==2 O  ③

一个一个放进来 1 2 3 4 5 6....
然后在同一个集合只要知道和根节点的关系就可以推出和其他节点的关系了
模三余0说明和根节点是同类 余1说明吃根节点 余2说明被根节点吃(吃余1的)

----------------
*/
int find(int x)
{
    if(p[x]!=x)
    {
        int t=find(p[x]);//首先存下根节点 
        d[x]+=d[p[x]];//存下根节点后 就从根节点开始往后累加距离(路径压缩 加上权)
         /*
                  %3==0 O  ① p[p[x]]
             d 5 
                  %3==1 O  ②  p[x]
             d 2
                  %3==2 O  ③  x

       */

       p[x]=t;

    }
    return p[x];


}

int main(void) 
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++) p[i]=i;
    int res=0;
    while(k--)
    {
        int t,x,y;
        scanf("%d%d%d",&t,&x,&y);
        if(x>n||y>n)res++;//如果编号就n个 填了大于n的 就是假话
        else
        {
            int px=find(x),py=find(y);//找到 x y的父节点

            if(t==1)//如果说是同类
            {
                if(px==py&&(d[x]-d[y])%3)res++;
                else if(px!=py)//说明前面没有提到过 第一次提到的话都是真话 后面产生矛盾的就是假话
                {

                    p[px]=py;
                    d[px]=d[y]-d[x];
                    //(d[x]+d[px]-d[y])%3==0 就设d[px]=d[y]-d[x];
                }

            }
            else //如果是x吃y 
            {
                if(px==py&&(d[x]-d[y]-1)%3)res++;
               else if(px!=py)
               {
                  p[px]=py;
                  d[px]=d[y]-d[x]+1;
               }


            }


        }



    }
    printf("%d\n",res);

    return 0;

}