并查集初步

 先来几道基础并查集。

http://ybt.ssoier.cn:8088/problem_show.php?pid=1346
http://ybt.ssoier.cn:8088/problem_show.php?pid=1385

看看上面两道题大致对并查集的作用有了一定的了解，是不是感觉知道求答案的思路，但就是很难用代码实现。

今天就是来介绍c++图论中的重要一环，个人认为并查集在图论中作用巨大！

大致思想：

判定两支队伍是否属于同一个集合，方法就是看他们的最高领袖是否是同一个人。 
同样的，判断两个元素是否属于同一个集合，就看他们的最高父节点是否是同一个。 
然后是集合的合并，合并其实就非常简单，让其中任何一个集合的最高父节点变成另外一个集合的最高父节点的子节点，合并就完成了。

其中找最高父节点（也就是祖先）是并查集的关键。

这里就使用一个father()函数来实现（既可以用while循环，也可以用递归，看个人喜好）

int f[10005];//记录每个点的祖先。
int father(int v)
{
    while(f[v]!=v)//判断这个点自身是不是指向自己，
    {             //如果指向自己，这个点暂时就是这个集合的祖先
        v=f[v];
    }
    return v;
}

但光靠上面的father()函数有点浪费时间，因为每个点在循环（或递归）中要跳多次才能找到自己的祖先，于是就出现下面的优化方式，称为路径压缩。

这次我们用递归写。

int f[10005]
int father(int v)
{
    if(f[v]!=v)f[v]=father(f[v]);
    return f[v];
}

相信可以看出，运用路径压缩就是在寻找祖先的过程中，顺便改变了这个点的长辈结点们所指向的祖先，优化之后跳跃的次数。

如下图所示

最后在注意一下每个结点在最初要将自己的祖先指向自己，因为在最初他们各自都是独立的自己是自己的祖先。

当然我在网上看到了一个额外的部分，就是还添加了一个rank[]数组来存储每个集合的秩。

就是高度（说白了就是有几代人），然后将小的集合加在大的集合上。

但个人觉得这不是必要的，只要指向同个祖先就行了，不过这看个人爱好。

下面来一个模板，既然是模板还是加个rank[]以示完整性。

int father[MAX];   /* father[x]表示x的父节点*/  
int rank[MAX];     /* rank[x]表示x的秩*/  
  
  
 /* 初始化集合*/  
void Make_Set(int x)  
{  
    father[x] = x; //根据实际情况指定的父节点可变化  
     rank[x] = 0;   //根据实际情况初始化秩也有所变化  
}  
  
  
/* 查找x元素所在的集合,回溯时压缩路径*/  
int Find_Set(int x)  
{  
    if (x != father[x])  
    {  
        father[x] = Find_Set(father[x]); //这个回溯时的压缩路径是精华  
    }  
    return father[x];  
}  
  
/*  
   按秩合并x,y所在的集合 
   下面的那个if else结构不是绝对的，具体根据情况变化 
   但是，宗旨是不变的即，按秩（即树的高度）合并，实时更新秩。 这个树的高度其实可要可不要记不记录都无所谓
*/  
void Union(int x, int y)  
{  
    x = Find_Set(x);  
    y = Find_Set(y);  
    if (x == y) return;  
    if (rank[x] > rank[y])   
    {  
        father[y] = x;  
    }  
    else  
    {  
        if (rank[x] == rank[y])  
        {  
            rank[y]++;  
        }  
        father[x] = y;  
    }  
}

看完模板之后就来试一下上面的例题吧。

下面是例题2的代码。

#include<cstdio>
using namespace std;
int a[20005];
int b[20005];
int father(int v)
{
    int u=v;     
    while(a[v]!=v)
    {
        v=a[v];
    }
    while(a[u]!=u)
    {
        int e=u;
        u=a[u];
        a[e]=v;
    }
    return v;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        a[i]=i;
    }
    for(int i=1;i<=m;i++)
    {
        int x,y,p;
        scanf("%d%d%d",&p,&x,&y);
        if(p==0)
        {
            int a1,b1;
            a1=father(x);
            b1=father(y);
            if(a1!=b1)
            {
                a[a1]=b1;
            }
        }
        else 
        {
            if(b[x]==0)b[x]=y;
            else
            {
                a[y]=father(b[x]);
            }
            if(b[y]==0)b[y]=x;
            else
            {
                a[x]=father(b[y]);
            }
        }
    }
    int num=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i]==i)num++;
    }
    printf("%d",num);
    return 0;
}

如果觉得上面的题都是小菜一碟，那就看看下面的吧。

至少是noip提高+/省选-的。

https://www.luogu.org/problemnew/show/2024食物链

https://www.luogu.org/problemnew/show/1197星球大战

https://www.luogu.org/problemnew/show/1196 银河英雄传说

星球大战解题

这道题看似很长其实也不是十分的难

如果我们去正向摧毁 想想都有点困难

要不 我们使用逆向思维？

没错 这道题就把摧毁转换成修建（和平就是好）

利用并查集判断联通就好了

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
vector<int> link[400005];//记录每个点相连接的点。
struct sd{
    int x,y;
};//用结构体存每条边。
sd edge[400005];
int f[400005];//记录每个点的祖先。
int boom[400005];//记录被干掉了的星球
int res[400005];
int father(int v)
{
    if(f[v]!=v)f[v]=father(f[v]);
    return f[v];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    f[i]=i;
    for(int i=1;i<=m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        link[a].push_back(b);
        link[b].push_back(a);
        edge[i].x=a;//存每条边的两个端点。
        edge[i].y=b;
    }
    int k;
    scanf("%d",&k);
    for(int i=1;i<=k;i++)
    {
        int x1;
        scanf("%d",&x1);
        f[x1]=-1;
        boom[i]=x1;//记录每个爆炸的星球。
    }
    int num=0;//用于记录还有多少条边连在一起。
    for(int i=1;i<=m;i++)
    {
        if(f[edge[i].x]!=-1&&f[edge[i].y]!=-1)
        {
            int fx=father(edge[i].x);
            int fy=father(edge[i].y);
            if(fx!=fy)
            {
                f[fx]=fy;
                num++;
            }
        }
    }
    int sum=n-k-num;//并查集个数==点的个数-边的个数。
    int kk=1;
    res[kk]=sum;
    for(int i=k;i>=1;i--)
    {
        f[boom[i]]=boom[i];
        sum++;//每添加进去一个被摧毁的星球，并查集的个数就要加1。
        for(int j=link[boom[i]].size()-1;j>=0;j--)
        {//寻找每个可以与新加的星球向连得星球。
            int fx;
            fx=father(boom[i]);
            if(f[link[boom[i]][j]]!=-1)   
            {   //注意！！！要判断相连的点是不是被摧毁了，摧毁了则不能相连。
                int fy=father(link[boom[i]][j]);
                if(fx!=fy)
                {
                    sum--;//每连一对星球，并查集个数减一。
                    f[fx]=fy;
                }
            }
        }
        kk++;
        res[kk]=sum;//存储每次的并查集个数。
    }
    for(int i=kk;i>=1;i--)//倒序输出，记住！！！要倒序。
    printf("%d
",res[i]);
    return 0;
}