并查集学习笔记

也算是磕磕绊绊，断断续续的学历一段时间并查集了吧，也是时候改写一个blog总结一下啦。

先说一下普通并查集吧。
普通并查集就是单纯的把某些可以连起来的点用一条有向边连起来，表示他们属于“一类”，例如HDU1213，这就是一个并查集的裸题，直接把输入的点合并，之后统计有几个点的祖先是自己就行。
AC代码：

#include<iostream>
#include<cstdio>

using namespace std;

const int maxn=10010;

int f[maxn];

void init(int n)
{
    for(int i=1;i<=n;i++) f[i]=i;
}

int Find(int x)
{
    if(x==f[x]) return x;
    else return f[x]=Find(f[x]);
}

void Merge(int x,int y)
{
    int t1=Find(x),t2=Find(y);
    if(t1!=t2)
    {
        f[t1]=t2;
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        init(n);
        while(m--)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            Merge(x,y);
        }
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            if(f[i]==i) ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

还有一个例子就是HDU3635，这个很容易看出是一个并查集的题，但这个涉及到三个操作，一个是查找x的祖先，一个是查找x的祖先所在的位置含有的龙珠的个数，还有一个就是查找x一共转移了几次。第一个就是一个基础的Find操作，第二个直接定义一个sum数组，在Merge的时候把子节点的sum全部给父节点，并将子节点的sum清为0，最后直接查询就行，主要是最后一个，我考虑的是并查集维护的是一个树（或者说森林），Find操作向上查找了多少次，这颗龙珠就被转移了多少次，但这样就必须把路径压缩给去掉，所幸数据范围比较小，就卡过去啦；
AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>

using namespace std;

const int maxn=10010;

int n,m;
int f[maxn],sum[maxn];
int ans;

void init(int n)
{
    for(int i=1;i<=n;i++)
    {
        f[i]=i,sum[i]=1;
    }
}

int Find(int x)
{
    if(x==f[x]) return x;
    else
    {
        ans++;
        return Find(f[x]);
    }
}

void Merge(int x,int y)
{
    int t1=Find(x),t2=Find(y);
    if(t1!=t2)
    {
        f[t1]=t2;
        sum[t2]+=sum[t1];
        sum[t1]=0;
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    int cas=1;
    while(T--)
    {
        scanf("%d%d",&n,&m);
        init(n);
        printf("Case %d:\n",cas++);
        while(m--)
        {
            char C;
            cin>>C;
            if(C=='T')
            {
                int x,y;
                scanf("%d%d",&x,&y);
                Merge(x,y);
            }
            else
            {
                int x;
                scanf("%d",&x);
                ans=0;
                int t=Find(x);
                printf("%d %d %d\n",t,sum[t],ans);
            }
        }
    }
    return 0;
}

当然，一般比赛的时候很少可以看到某个算法的裸题，有些并查集的题要构建出并查集的模型才行。
例POJ1456，看到这题可以想到贪心，但由于数据范围很小，时限很多，直接暴力做不会超时，但这一题其实是可以用并查集来优化的。我们排序完之后遍历时最消耗时间就是去查找从d -> 1哪一个点还没有用，那我们就可以考虑并查集，每次将t-1更新为t的父节点，那们每次Find操作只要得到的t不为0就可以更新答案。
AC代码：

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

#define LL long long
const int maxn=10010;

struct node
{
    int id;
    LL val;
} a[maxn];

bool cmp(node aa,node bb)
{
    return aa.val>bb.val;
}

int f[maxn];

int Find(int x)
{
    if(x==f[x]) return x;
    else return f[x]=Find(f[x]);
}

void init(int n)
{
    for(int i=1; i<=n; i++)
    {
        f[i]=i;
    }
}

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int pos=0;
        for(int i=1; i<=n; i++)
        {
            scanf("%lld%d",&a[i].val,&a[i].id);
            pos=max(pos,a[i].id);
        }
        init(pos);
        sort(a+1,a+n+1,cmp);
        LL ans=0;
        for(int i=1; i<=n; i++)
        {
            int t=Find(a[i].id);
            if(t)
            {
                ans+=a[i].val;
                f[t]=t-1;
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

而普通并查集在图论里的操作还有很多，比如判断图是否连通，判断图里有没有环。。。这里就不一一赘述。

接下来讲一下并查集的升级版，带权并查集。
就直接更具题目来讲吧
POJ1182，这是一道带权并查集的经典题啦。首先我们用0表示x和y是同类，1表示x吃y，2表示x被y吃。那么根据矢量的运算法则，我们就可以把路劲压缩和Merge操作时的表达式给写出来，这样这题就可以做出来啦。
AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>

using namespace std;

const int maxn=5e4+7;

int f[maxn],Rank[maxn];

void init(int n)
{
    for(int i=1; i<=n; i++)
    {
        f[i]=i,Rank[i]=0;
    }
}

int Find(int x)
{
    if(x==f[x]) return x;
    else
    {
        int t=Find(f[x]);
        Rank[x]=(Rank[x]+Rank[f[x]])%3;
        return f[x]=t;
    }
}

void Merge(int x,int y,int val)
{
    int t1=Find(x),t2=Find(y);
    if(t1!=t2)
    {
        f[t1]=t2;
        Rank[t1]=(-Rank[x]+val+Rank[y]+3)%3;
    }
}

int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    init(n);
    int ans=0;
    while(k--)
    {
        int opt,x,y;
        scanf("%d%d%d",&opt,&x,&y);
        if(x>n||y>n)
        {
            ans++;
            continue;
        }
        int t1=Find(x),t2=Find(y);
        int temp;
        if(t1==t2)
        {
            temp=(Rank[x]-Rank[y]+3)%3;
            if(temp!=opt-1)
            {
                ans++;
            }
            else
            {
                Merge(x,y,opt-1);
            }
        }
        else
        {
            Merge(x,y,opt-1);
        }
    }
    printf("%d\n",ans);
    return 0;
}

带权并查集还有区间形的，例如这道题HDU3038，我们每次用(x-1,y]来记录x->y之间的值，还是一样，直接在路径压缩和Merge操作时根据矢量运算法则写出表达式就行。
AC代码：

#include<iostream>
#include<cstdio>

using namespace std;

#define LL long long
const LL maxn=200010;

int f[maxn];
LL Rank[maxn];

void init(int n)
{
    for(int i=0; i<=n; i++)
    {
        f[i]=i,Rank[i]=0;
    }
}

int Find(int x)
{
    if(x==f[x]) return x;
    else
    {
        int t=Find(f[x]);
        Rank[x]=Rank[x]+Rank[f[x]];
        return f[x]=t;
    }
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        init(n);
        LL ans=0;
        while(m--)
        {
            int x,y;
            LL val;
            scanf("%d%d%lld",&x,&y,&val);
            int t1=Find(x-1),t2=Find(y);
            if(t1!=t2)
            {
                if(t1<t2)
                {
                    f[t1]=t2;
                    Rank[t1]=Rank[y]-Rank[x-1]+val;
                }
                else
                {
                    f[t2]=t1;
                    Rank[t2]=Rank[x-1]-Rank[y]-val;
                }
            }
            else
            {
                if(Rank[x-1]-Rank[y]!=val)
                {
                    ans++;
                }
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}