图论：并查集、最小生成树

并查集应用相当广泛，之前学习过但是现在又遗忘了......在此做一个整理记录。首先是并查集的模板，参考洛谷P3367，以下为代码：

#include<bits/stdc++.h>
using namespace std;
int n,m;
int root[10005];

int getRoot(int i)    //递归的处理方式，可能会爆栈
{
    if(root[i]==i){
        return i;
    }
    int temp=getRoot(root[i]);
    root[i]=temp;
    return temp;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        root[i]=i;
    }
    int s,x,y;
    while(m--){
        scanf("%d%d%d",&s,&x,&y);
        if(s==1){
            int a=getRoot(x);
            int b=getRoot(y);
            if(a!=b){
                root[a]=b;     //此处务必注意：不是root[x]=b，许久不看出现了纰漏
            }
        }
        else if(s==2){
            if(getRoot(x)==getRoot(y)){
                printf("Y\n");
            }
            else{
                printf("N\n");
            }
        }
    }
    return 0;
}

并查集主要表现的是集合思想，借助集合来处理问题。并查集的应用包括：

1）在一个图上查找联通分量的个数。传统做法是依次判断root[i]==i来计数，但是点较多的时候会超时；可以在初始时设置num=点的个数，每联通一条边则连接块个数num--。

2）记录集合的统计信息：和、积、最大最小值等，需要借助额外的数组来记录。使用并查集时可以在根节点对当前集合的信息进行记录

3）最小生成树

在一个无向连接图中，如果存在一个没有回路的子图，则该子图为原图的一棵生成树。在带权图所有的生成树中，边权和最小的那（几）棵为最小生成树。

Kruskal算法或者Prim算法。首先是Kruskal算法：依次遍历按权值排好序的边，根据当前边尝试连接并查集。遍历完所有边之后进行判断即可。

与Kruskal算法侧重于边所不同的是，Prim算法侧重于点。Kruskal算法选择当前最小的边，尝试加其加入到生成树中，而Prim算法选择当前距离已有树最近的点，加入树中。由此，Kruskal算法借助并查集可以方便地处理，但Prim算法则不借助并查集，但是代码实现也有相似之处（理解之后就比较容易写

针对Kruskal算法和Prim算法不同的特性，可以用来处理不同的情境。由于Kruskal算法以边为中心，需要对边进行一定处理；而Prim每次选择最近的点，因此当面临稠密图（尤其是完全图）时Prim具有很强的优越性，不需要对边进行提前处理（节省空间），当前处理的哪个点就对相关的边进行计算即可。但是在边已经提供的情况下，还是选Kruskal算法方便一点。

Kruskal算法样例就不说明了。Prim算法的样例，洛谷P1265

#include<bits/stdc++.h>
using namespace std;
int n;
struct node
{
    int x,y;
}nodes[5005];
bool mark[5005];
double dis[5005];

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&nodes[i].x,&nodes[i].y);
        mark[i]=false;
        dis[i]=1e8;
    }

    dis[1]=0;
    int pos;
    double ans=0;
    for(int i=1;i<=n;i++){
        double minn=1e8;
        for(int j=1;j<=n;j++){
            if(!mark[j]&&dis[j]<minn){
                minn=dis[j];
                pos=j;
            }
        }
        ans+=minn;
        mark[pos]=true;
        for(int j=1;j<=n;j++){
            double d=sqrt((double)(nodes[pos].x-nodes[j].x)*(nodes[pos].x-nodes[j].x)+(double)(nodes[pos].y-nodes[j].y)*(nodes[pos].y-nodes[j].y));
            if(d<dis[j]){
                dis[j]=d;
            }
        }
    }
    printf("%.2lf\n",ans);
    return 0;
}

4）种类并查集

普通并查集可以说是在维护“朋友的朋友是朋友”这样的关系，但是处理“敌人的敌人是朋友”就需要种类并查集。准确来说，种类并查集维护的是一种循环对称的关系。如果是三个及以上的集合，只要每个集合都是等价的，且集合间的每个关系都是等价的，就能够用种类并查集进行维护。参考例题：洛谷P2024。

#include<bits/stdc++.h>
using namespace std;
int n,k,root[150005];

int getRoot(int x)
{
    if(root[x]==x){
        return x;
    }
    int temp=getRoot(root[x]);
    root[x]=temp;
    return temp;
}
int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++){
        root[i]=i;
        root[i+n]=i+n;
        root[i+2*n]=i+2*n;
    }
    int s,x,y,ans=0;
    while(k--){
        scanf("%d%d%d",&s,&x,&y);
        if(x>n||y>n){
            ans++;
            continue;
        }
        if(s==1){
            if(getRoot(x)==getRoot(y+n)||getRoot(x)==getRoot(y+2*n)){
                ans++;
                continue;
            }
            else{
                root[getRoot(x)]=getRoot(y);
                root[getRoot(x+n)]=getRoot(y+n);
                root[getRoot(x+2*n)]=getRoot(y+2*n);
            }
        }
        if(s==2){
            if(x==y){
                ans++;
                continue;
            }
            if(getRoot(x)==getRoot(y)||getRoot(x)==getRoot(y+2*n)){
                ans++;
                continue;
            }
            else{
                root[getRoot(x)]=getRoot(y+n);
                root[getRoot(x+n)]=getRoot(y+2*n);
                root[getRoot(x+2*n)]=getRoot(y);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}