并查集

并查集（Union-find)：

首先看一下查找的过程，两行代码：

//查找x元素所在集合的编号
int find(x)
{
    if(x != p[x]) p[x] = find(p[x]);
    return p[x];
}

if(find(x) != find(y)) p[find(x)] = find(y);//合并

for(int i = 0;i<n;i++) p[i] = i; p[0] = 0, p[1] = 1, p[3] = 3, p[5] = 5;

举个例子：比如有5、3、1、0四个数字来合并的话,

p[find(5)] = find(3) = 3, p[find(3)] = find(1) = 1, p[find(1)] = find(0) = 0;

 

p[5] = 3, p[3] = 1, p[1] = 0; p[0] = 0 = 0;

我们再来看这两行代码：if(x != p[x]) p[x] = find(p[x]); return p[x];

5 != p[5]=3, 3!=p[3], p[3] = find(p[3]) = 1, 1 != p[1], p[1] = 0 = find(0), 但是0 = p[0] = 0的, 所以直接return p[x] = 0;

 例题：

4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4
初始的时候p[1] = 1, p[2] = 2, p[3] = 3, p[4] = 4;
合并1和2，即：p[find(1)] = find(2);
合并3和4，即：p[find(3)] = find(4);

 

判断的时候就是find(1) p[1] = 2 = find(2) , 2 = p[2], return 2 find(1) = find(2) = 2;

所以1和2 是属于同一个集合。

 

#include <cstdio>
#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];
}
int main()
{
    cin>>n>>m;
    for(int i = 0;i<n;i++) p[i] = i;
    while(m--)
    {
        char op;int a,b;
        cin>>op;
        if(op == 'M')
        {
            cin>>a>>b;
            p[find(a)] = find(b);
        }
        else if(op == 'Q')
        {
            cin>>a>>b;
            if(find(a) == find(b)) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }
    }
}

 

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

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

#include <cstdio>
#include <iostream>
using namespace std;
const int N = 100010;
int n,m;
int p[N],s[N];
int find(int x)
{
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}
int main()
{
    cin>>n>>m;
    for(int i = 1;i<=n;i++)
    {
        p[i] = i;
        s[i] = 1;
    }
    while(m--)
    {
        char op[2];int a,b;
        cin>>op;
        if(op[0] == 'C')
        {
            cin>>a>>b;
            if(find(a) == find(b)) continue;
            s[find(b)] += s[find(a)];
            p[find(a)] = find(b);
        }
        else if(op[1] == '1')
        {
            cin>>a>>b;
            if(find(a) == find(b)) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }
        else
        {
            cin>>a;
            cout<<s[find(a)]<<endl;
        }
    }
}

多了一个求连通块中的个数。那么只需要计算每个连通块根节点的大小就可以了，当两个连通块合并的时候，size进行合并，p[find(a)] = find(b), size[find(b)] += size[find(a)];千万注意这里不是size[b] += size[a];而是先找到原来两个块中的根节点的大小 再把它们加起来就可以了。

 

//NOI2001食物链，带权并查集
#include <cstdio>
#include <iostream>
using namespace std;
const int N = 50010;
int n,m;
int p[N],d[N];
int find(int x)
{
    if(p[x] != x)
    {
        int t = find(p[x]);//如果是p[x] = find(p[x])，这里p[x]是根节点了，所以要保存路径上的每个节点到根节点之间的距离
        d[x] += d[p[x]];
        p[x] = t;
    }
    return p[x];
}
//1吃0，2吃1，0吃2，012代表每个节点到根节点的距离%3
int main()
{
    cin>>n>>m;
    for(int i = 1;i<=n;i++) p[i] = i;
    int res = 0;
    while(m--)
    {
        int t,x,y;
        cin>>t>>x>>y;
        if(x > n || y > n) res++;
        else{
            int px = find(x), py = find(y);
            if(t == 1)
            {
                //同一棵树 如果到根节点距离%3不同，那么是不同类
                if(px == py && (d[x] - d[y]) % 3) res++;
                else if(px != py)
                {
                    //不在同一颗树，先搞到同一颗树上，(dx+d[px]-dy)%3==0
                    p[px] = py;
                    d[px] = d[y] - d[x];
                }
            }
            if(t == 2)//x吃y
            {
                //(dx-dy-1)%3 ==0 若不为0则是假的
                if(px == py && (d[x] - d[y] - 1) % 3) res++;
                else if(px != py){
                    //不在同一颗树，先搞到同一颗树上，那么dx+d[px]-dy-1 %3 ==0
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x];
                }
            }
        }
    }
    cout<<res<<endl;
}

 

 

 012:代表节点x到根节点px距离d[x] % 3，

0可以代表3的整数倍，1代表3的整数倍余1，2代表3的整数倍余2；

 

 

 

 

 

 一、当是同类 判断是不是假，不在一棵树的情况下：

p[px] = p[y], ？= d[px], 同一类的话dx + d[px]和d[y]余数肯定相等

//不在同一颗树，先搞到同一颗树上，(dx+d[px]-dy)%3==0
                    p[px] = py;
                    d[px] = d[y] - d[x];

//如果是同一棵树 如果到根节点距离%3不同，那么是不同类
                if(px == py && (d[x] - d[y]) % 3) res++;

二、当判断x吃y是否合理时，不在同一颗树情况下：

//不在同一颗树，先搞到同一颗树上，dx + d[px] 比 dy 要多1才能满足x吃y是合理的。那么dx+d[px]-dy-1 %3 ==0
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x];

//在同一棵树(dx-dy-1)%3 ==0 若不为0则是假的
                if(px == py && (d[x] - d[y] - 1) % 3) res++;

在这个递归里面找根节点的过程：

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

在这里，不仅是路径压缩，路径上的每个节点的p[x]都指向了根节点，同时还计算了每个节点到根节点之间的距离。

以上图为例，一开始带进来的是5，然后5 ！=p[5](3), p[5] = find(3), 3 != p[3](1), p[3] = find(1), 1!=p[1], p[1] = find(0), 0 == p[0],返回回去：

0 = p[0] = p[1] = p[3] = p[5] = find(5), 那么这条路径上所有结点的p[x]都是等于根节点了。

d[x]也是一样的递归思路,d[x] += d[p[x]]，d[0] = 0, d[1] = d1 + d[0]=1, d[3] = d3 + d1 = 4, d[5] = d5 + d[3] = 9, 在这里也是这条路径上所有点到根节点的距离都求到了，即是d[x]。

PS：尤其要注意的是这里不能先计算p[x] = find(p[x])，如果先这样写了，那么所有的距离p[x]都是根节点的距离即是0，就错了。

而应该是先保存，在加到距离里，最后再赋到每一个p[x]里面。

int t = find(p[x]); d[x] += d[p[x]]; p[x] = t;