POJ Find them, Catch them 并查集变形

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.

题意：

判断给定两个坏蛋是否属于同一帮派。

思路：

建一个数组表示集合之间的关系， 然后再建一个数组， 表示与根节点的关系，为0表示与根节点的帮派相同， 为1表示与根节点不同。这里讲讲查找和合并两个集合如何操作。

合并：

先找到两个集合的根节点， 因为两个人之间的关系已经确定了， 他们与他们各自的根节点的关系也确定了， 所以他们根节点的关系可以根据他们子节点的关系确定， 然后将其中一个根节点a连到另一个根节点b上，然后a就成了b的子节点。 然后他们的子节点在查找的途中可以确定与他们新的根节点b之间的关系。

查找：

查找的本质就是查找他们的根节点。 然后在这基础上进行改进。 通过迭代的方式来确定与父节点的关系， 先递归递到与父节点最近的位置c， 然后将c的值进行修改， 之后返回， 然后依次向下修改值。

之后进行判断是否为同一帮派时，只需要find他们本身，修改未修改的关系，

然后返回父节点，比较他们是否属于同一个父节点，如果不是，则不确定关系，如果是，那么只要他们与父节点的关系相同，

那么就是同一帮派，否则不是。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int maxn=100005;
int t;
int n,m;
int peo[maxn];
int diff[maxn];
//找根节点
int finds (int x)
{
    int temp=peo[x];
    if(x==peo[x])
       return x;
    else
        peo[x]=finds(peo[x]);
    //确定与根节点的关系
    diff[x]=(diff[temp]+diff[x])%2;
    return peo[x];
}
//将两个集合合并
void  unite (int x,int y)
{
    //找到他们各自的根节点
    int ttemp1=finds(x);
    int ttemp2=finds(y);
    //将其中一个根节点变为另一个根节点的子节点
    if(ttemp1!=ttemp2)
    {
        peo[ttemp1]=ttemp2;
        //修改成为子节点的根节点与另一个根节点的关系，之后再进行一次find操作
        //那么这个集合元素与根节点的关系就更新完了
        diff[ttemp1]=(diff[y]-diff[x]+1)%2;
    }
}
int main()
{
    scanf("%d",&t);
    while (t--)
    {
       scanf("%d%d",&n,&m);
       for (int i=1;i<=n;i++)
       {
            peo[i]=i;
       }
       memset (diff,0,sizeof(diff));
       while (m--)
       {
           char s[5];
           int x,y;
           scanf("%s",s);
           scanf("%d%d",&x,&y);
           if(s[0]=='A')
           {
               int ttemp1=finds(x);
               int ttemp2=finds(y);
               if(ttemp1==ttemp2)
               {
                   if(diff[x]==diff[y])
                       printf("In the same gang.\n");
                   else
                       printf("In different gangs.\n");
               }
               else
               {
                   printf("Not sure yet.\n");
               }
           }
           else
           {

           }
       }

    }
    return 0;
}