POJ 1703 Find them, Catch them(并查集的扩展应用)

Find them, Catch them

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 21755		Accepted: 6471

Description

The police office in Tadu City decides to say ends to the chaos, as launch actions to root up the TWO gangs in the city, Gang Dragon and Gang Snake. However, the police first needs to identify which gang a criminal belongs to. The present question is, given two criminals; do they belong to a same clan? You must give your judgment based on incomplete information. (Since the gangsters are always acting secretly.)

Assume N (N <= 10^5) criminals are currently in Tadu City, numbered from 1 to N. And of course, at least one of them belongs to Gang Dragon, and the same for Gang Snake. You will be given M (M <= 10^5) messages in sequence, which are in the following two kinds:

1. D [a] [b]
where [a] and [b] are the numbers of two criminals, and they belong to different gangs.

2. A [a] [b]
where [a] and [b] are the numbers of two criminals. This requires you to decide whether a and b belong to a same gang.

Input

The first line of the input contains a single integer T (1 <= T <= 20), the number of test cases. Then T cases follow. Each test case begins with a line with two integers N and M, followed by M lines each containing one message as described above.

Output

For each message "A [a] [b]" in each case, your program should give the judgment based on the information got before. The answers might be one of "In the same gang.", "In different gangs." and "Not sure yet."

Sample Input

1
5 5
A 1 2
D 1 2
A 1 2
D 2 4
A 1 4

Sample Output

Not sure yet.
In different gangs.
In the same gang.
代码一：

/* 功能Function Description:     POJ-1703  并查集的应用的扩展
   开发环境Environment:          DEV C++ 4.9.9.1
   技术特点Technique:
   版本Version:
   作者Author:                   可笑痴狂
   日期Date:                      20120808
   备注Notes:
  【转】
    解析：并查集的题目，并查集的拓展。
    一般的思路是先初始化，各个数自成一个组，然后是两个gangs自成一个组，
    但由于两个给定元素有三种关系: In the same gang;  In different gangs;  Not sure yet; 
    采用此模型的缺点是判断两个元素关系还未确定这种情况比较复杂，故模型需要改进。本题的正确模型是将已经确定关系的元素组成一个集合，
    然后利用两个元素的 father是同一个来确定这两个元素之间的关系。father[a]中存放的是a的根结点，rank中存放的是father[a]与a的关系，
    0表示两者不在同一个gangs中，1表示两者在同一个gangs中。具体的程序还是沿袭了并查集的Make_Set（）、Find_Set()、 Union_Set()
    的三步骤。
    心得：并查集有三步是必须的：Make_Set（）、Find_Set()、Union_Set()。  rank[a]的改变是伴随着father[a]的改变而更新的
    （有father改变就有rank改变），要是father改变了，而rank未改变，此时的rank就记录了一个错误的值，father未改变
    （即使实际的father已不是现在的值，但只要father未改变，rank 的值就是“正确”的，认识到这点很重要。）
*/

#include<stdio.h>
int father[100005],rank[100005];

int find(int a)
{
    int t;
    if(father[a]==a)
        return a;

    t=father[a];
    father[a]=find(father[a]);
    rank[a]=(rank[a]+rank[t]+1)%2;//必须有，更新路径压缩之后a与根结点之间的关系； father改变，rank就必须要跟着改变
    
    return father[a];
}

void merge(int a,int b)
{
    int fa,fb;
    fa=find(a);
    fb=find(b);
    if(fa!=fb)
    {
        father[fa]=fb;
        rank[fa]=(rank[a]+rank[b])%2;//fa结点以下的结点的rank不需要改,因为在find中会自动更新
    }
}

int main()
{
    int T,a,b,m,n,i;
    char cmd[2];
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;++i)
        {
            father[i]=i;
            rank[i]=1;
        }
        for(i=0;i<m;++i)
        {
            scanf("%s%d%d",cmd,&a,&b);
            if(cmd[0]=='A')
            {
                if(find(a)==find(b))
                {
                    //在使用rank之前，已经在用find函数寻找a的时候将a路径上的所有结点的rank值改变过了
                    if((rank[a]+rank[b])%2==0)       //a和b与根节点的关系相同---都是0后者都是1，说明是同一个帮派
                        printf("In the same gang.\n");
                    else
                        printf("In different gangs.\n");
                }
                else
                    printf("Not sure yet.\n");
            }
            else
                merge(a,b);
        }
    }
    return 0;
}

 代码二：

//重新做了一遍，又理了理思路 
#include<iostream>
#include<cstdio>
using namespace std;

int father[100005],relation[100005];

void init(int n);
int find(int x);

int main()
{
    int T,N,M,x,y,fx,fy,r1,r2;
    char w[3];
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &N, &M);
        init(N);
        while(M--)
        {
            scanf("%s%d%d", w, &x, &y);
            fx=find(x);
            fy=find(y);
            if(w[0]=='D')
            {
                if(fx != fy)
                {
                    father[fx]=fy;
                    //相当于已知 a 与 b 的关系(relation[x]),已知 c与 d 的关系(relation[y]),已知 b 与 c 的关系(1),求 a 与 d 的关系 
                    relation[fx]=(relation[x]+relation[y]+1)%2;
                }
            }
            else
            {
                if(fx!=fy)
                    printf("Not sure yet.\n");
                else
                {
                    if(relation[x]!=relation[y])
                        printf("In different gangs.\n");
                    else
                        printf("In the same gang.\n");
                }
            }
        }
    }
    return 0;
}
void init(int n)
{
    int i;
    for(i=0;i<=n;++i)
    {
        father[i]=i;
        relation[i]=0;
    }
}
int find(int x)
{
    if(x==father[x])
    {
        return x;
    }
    else
    {
        int t=father[x];
        father[x]=find(father[x]);
        
        //相当于已知 a 与 b 的关系，已知 b 与 c 的关系，求 a 与 c 的关系 
        relation[x]=(relation[x]+relation[t])%2;//(注意顺序，只有当前节点的父亲节点与根节点的关系确定了才能正确确定)
        return father[x];                         //当前节点与根节点的关系所以这条语句一定不能放在上一条语句的上边 
    }
}