并查集（poj 2524，poj 1611，poj 2236，poj 1308，hdoj 1272）

刚刚接触并查集，还不是很熟练，先从板子题开始吧

poj 2524 Ubiquitous Religions
题目大意： 统计一群人中加的宗教有最多有几种。
题解： 将m组数据挨个读入，进行合并，先寻找每个人的祖先，如果祖先不同，则进行合并。最后统计祖先是本身的个数即为answer
AC代码：

#include <iostream>
using namespace std;
int n,m,time=0;
int parent[50001];
int ranks[50001];//合并时如果两棵树的rank不同，则从rank小的向rank大的连边
void initialize()//初始化parent数组
{
    for(int i=1;i<=n;i++)
    {
        parent[i]=i;
        ranks[i]=0;
    }
}
int find_root(int x)//查找祖先
{
    int x_root=x;
    while(parent[x_root]!=x_root)
    {
        x_root=parent[x_root];
    }
    return x_root;
}
void unite(int x,int y)//合并
{
    int x_root=find_root(x);
    int y_root=find_root(y);
    if(x_root!=y_root)
    {
        if(ranks[x_root]<ranks[y_root])
            parent[x_root]=y_root;
        else
            if(ranks[y_root]<ranks[x_root])
            parent[y_root]=x_root;
        else
        {
            parent[y_root]=x_root;
            ranks[x_root]++;
        }
    }
}
int main()
{
    while(cin>>n>>m&&n+m)
    {
        int ans=0;
        initialize();
        for(int i=0;i<m;i++)
        {
            int x,y;
            cin>>x>>y;
            unite(x,y);
        }
        time++;
        for(int i=1;i<=n;i++)
        {
            if(parent[i]==i)
                ans++;
        }
        cout<<"Case "<<time<<": "<<ans<<endl;
    }
}

poj 1611 The Suspects
题目大意： 0是病人，与0同组的其他人都是嫌疑人，并且其他与嫌疑人一个组的也是嫌疑人（一旦组中的成员是嫌疑人，该组中的所有成员都是嫌疑人 ）。求共有多少嫌疑人。
题解： 此题用并查集将与0有接触的人合并在一起，最后计算所有成员中与0同祖先的成员个数。
AC代码：

#include <iostream>
using namespace std;
int n,m;
int parent[30001],ranks[30001];
void init()
{
    for(int i=0;i<=n;i++)
    {
        parent[i]=i;
        ranks[i]=0;
    }
}
int find_root(int x)
{
    while(parent[x]!=x)
    {
        x=parent[x];
    }
    return x;
}
void unite(int x,int y)
{
    x=find_root(x);
    y=find_root(y);
    if(x!=y)
    {
        if(ranks[x]>ranks[y])
            parent[y]=x;
        else
            if(ranks[x]<ranks[y])
            parent[x]=y;
        else
        {
            parent[y]=x;
            ranks[x]++;
        }
    }
}
int main()
{
    while(cin>>n>>m&&n+m)
    {
        init();
        for(int i=0;i<m;i++)
        {
            int t,a,b;
            cin>>t;
            for(int j=0;j<t;j++)
            {
                if(j==0)
                    cin>>a;
                else
                {
                    cin>>b;
                    unite(a,b);
                    a=b;
                }
            }
        }
        int root=find_root(0);
        int ans=0;
        for(int i=0;i<=n;i++)
        {
            if(find_root(i)==root)
                ans++;
        }
        cout<<ans<<endl;
    }
}

poj 2236 Wireless Network
题目大意： 地震将电脑网络全都打破了，需要挨个连接起来，给出电脑数量和能够支持的最长距离。并且有两个操作，一个操作是修复电脑，另一个是检验两个电脑是否可以连接在一起。也就是说，如果计算机A和计算机B可以直接通信，或者计算机C可以与A和A进行通信，则计算机A和计算机B可以进行通信。
题解： 此题用并查集写，先排除两个电脑距离大于规定距离的电脑，然后再维护并查集就可以了。
AC代码：

#include <iostream>
#include <string.h>
using namespace std;
int x[1010],y[1010];
int vis[1010],parent[1010],ranks[1010];
int n,d;
bool check(int a,int b)
{
    if((x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b])>d*d)
        return false;
    return true;
}
void init()
{
    for(int i=1;i<=n;i++)
    {
        parent[i]=i;
        ranks[i]=0;
    }
}
int find_root(int x)
{
    while(parent[x]!=x)
        x=parent[x];
    return x;
}
void unite(int a,int b)
{
    a=find_root(a);
    b=find_root(b);
    if(a!=b)
    {
        if(ranks[a]<ranks[b])
            parent[a]=b;
        else
            if(ranks[a]>ranks[b])
            parent[b]=a;
        else
        {
            parent[b]=a;
            ranks[a]++;
        }
    }
}
int main()
{
    cin>>n>>d;
    memset(vis,0,sizeof(vis));
    init();
    for(int i=1;i<=n;i++)
        cin>>x[i]>>y[i];
    char tmp;
    while(cin>>tmp)
    {
        if(tmp=='O')
        {
            int a;
            cin>>a;
            vis[a]=1;
            for(int i=1;i<=n;i++)
            {
                if(i==a||!vis[i])//如果还没有被修复就不用合并了
                    continue;
                if(!check(i,a))//检查是否符合距离的最值
                    continue;
                unite(i,a);
            }
        }
        else
        {
            int a,b;
            cin>>a>>b;
            if(find_root(a)==find_root(b))
                cout<<"SUCCESS"<<endl;
            else
                cout<<"FAIL"<<endl;
        }
    }
}

poj 1308 Is It A Tree?
题目大意： 判断所给出的图是否是树。树的条件为：只有一个根节点，每个节点的入度不超过1。
题解： 总的来说，就是判断一个图中是否有环。这也正是并查集的作用之一。
AC代码：

#include <iostream>
#include <set>
using namespace std;
typedef long long int ll;
ll parent[100001];
int flag=0;
void init()
{
    for(int i=0;i<100001;i++)
        parent[i]=i;
}
int find_root(int x)
{
    return parent[x]==x ? x : parent[x]=find_root(parent[x]);
}
void unite(int x,int y)
{
    x=find_root(x);
    y=find_root(y);
    if(x!=y)
        parent[y]=x;
    else
        flag=1;//如果两个点的根节点相同，则说明有环
}
int main()
{
    ll a,b,k=0;
    while(1)
    {
        flag=0;
        k++;
        init();
        set<ll>st;
        cin>>a>>b;
        if(a==-1&&b==-1)
            return 0;
        if(a==0&&b==0)
        {
            cout<<"Case "<<k<<" is a tree."<<endl;
            continue;
        }
        if(a==b)
            flag=1;
        st.insert(a);
        st.insert(b);
        parent[b]=a;
        while(cin>>a>>b&&a+b)
        {
            unite(a,b);
            if(a==b)//如果两个点相等也不符合要求，自己不能指向自己
                flag=1;
            st.insert(a);
            st.insert(b);
        }
        set<ll>::iterator it=st.begin();
        int tmp=find_root(*it);
        it++;
        for(;it!=st.end();it++)
        {
            if(find_root(*it)!=tmp)
            {
                flag=1;//如果有多个根节点也不符合要求
                break;
            }
        }
        if(flag)
            cout<<"Case "<<k<<" is not a tree."<<endl;
        else
            cout<<"Case "<<k<<" is a tree."<<endl;
    }
}

hdoj 1272 小希的迷宫
题目大意： 判断一个图是不是树
题解： 并查集判环。即当把每组数据合并到树上时，两个数的根节点不能相等，若相等则说明图上有环，即从一个点到另一个点有两条及以上的路径，不符合要求。当合并数据时，发现两个数据的根节点相等，则标记 flag=1（即不符合要求）具体做法同上题相似，只是这个题要注意，当输入的两个数据相等时，也是符合要求的，但上一题就不符合emm
AC代码：

#include <iostream>
#include <set>
using namespace std;
typedef long long int ll;
int flag=0;
ll parent[100010];
void init()
{
    for(int i=0;i<100010;i++)
        parent[i]=i;
}
int find_root(int x)
{
    return parent[x]==x ? x : parent[x]=find_root(parent[x]);
}
void unite(int x,int y)
{
    x=find_root(x);
    y=find_root(y);
    if(x==y) //若根节点相同，则有环，不符合要求，标记flag=1
        flag=1;
    else
        parent[y]=x;
}
int main()
{
    ll a,b;
    while(1)
    {
        flag=0;
        init();
        set<ll>st;
        cin>>a>>b;
        if(a==0&&b==0)
        {
            cout<<"Yes"<<endl;
            continue;
        }
        if(a==-1)
            break;
//        if(a==b)  这里不用判断输入的两个数是否相等
//            flag=1;
        st.insert(a);
        st.insert(b);
        parent[b]=a; //第一对数据也别忘了合并！！！
        while(cin>>a>>b&&a+b)
        {
//            if(a==b)
//                flag=1;
            unite(a,b);
            st.insert(a);
            st.insert(b);
        }
        set<ll>::iterator it=st.begin();
        int tmp=find_root(*it); //这里一定要写find_root，不能写成parent[]！！！
        it++;
        for(;it!=st.end();it++)
        {
            if(find_root(*it)!=tmp) //还有这里
            {
                flag=1;
                break;
            }
        }
        if(flag)
            cout<<"No"<<endl;
        else
            cout<<"Yes"<<endl;
    }
}