分组并查集（种类并查集）

这是并查集的一种变形。在这种并查集中，节点被分为了不同的n类（类别一般较少）。其大致结构与并查集相同，但区别在于，分组并查集需要一个relation数组，来存储节点的种类。这就需要注意结点与其根节点之间的关系。下面具体问题具体分析。

A Bug's Life

Background
Professor Hopper is researching the sexual behavior of a rare species of bugs. He assumes that they feature two different genders and that they only interact with bugs of the opposite gender. In his experiment, individual bugs and their interactions were easy to identify, because numbers were printed on their backs.
Problem
Given a list of bug interactions, decide whether the experiment supports his assumption of two genders with no homosexual bugs or if it contains some bug interactions that falsify it.

Input

The first line of the input contains the number of scenarios. Each scenario starts with one line giving the number of bugs (at least one, and up to 2000) and the number of interactions (up to 1000000) separated by a single space. In the following lines, each interaction is given in the form of two distinct bug numbers separated by a single space. Bugs are numbered consecutively starting from one.

Output

The output for every scenario is a line containing "Scenario #i:", where i is the number of the scenario starting at 1, followed by one line saying either "No suspicious bugs found!" if the experiment is consistent with his assumption about the bugs' sexual behavior, or "Suspicious bugs found!" if Professor Hopper's assumption is definitely wrong.

Sample Input

2
3 3
1 2
2 3
1 3
4 2
1 2
3 4

Sample Output

Scenario #1:
Suspicious bugs found!

Scenario #2:
No suspicious bugs found!

题意为：告诉你n只昆虫之间相互的关系，问你是否存在同性恋的昆虫。

如1->2,2->3,3->1，则一定存在同性的昆虫。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#define N 2005
using namespace std;
int root[N],relation[N], n, k;
int flag;
int T,a,b;

int findroot(int x)
{
    if(x==root[x])
        return root[x];
    int t=findroot(root[x]);
    relation[x]=(relation[root[x]]+relation[x])%2;       //由根向下更改现结点与新的根节点的关系
    root[x]=t;
    return root[x];
}

void Union(int x,int y)
{
    int a=findroot(x),b=findroot(y);
    if(a==b)           //根节点相同，判断与根节点的关系是否相同
    {
        if(relation[x]==relation[y])
            flag=1;
        return;
    }
    root[a]=b;
    relation[a]=(relation[x]-relation[y]+1+2)%2;     //根节点不同，并查集合并，并且更改根节点之间的关系
}
int main()
{
    scanf("%d",&T);
    for (int Case=1;Case<=T;Case++)
    {
        scanf("%d%d",&n,&k);
        flag=0;
        for(int i=0;i<=n;i++)
            root[i]=i,relation[i]=0;
        for(int i=0;i<k;i++)
        {
            scanf("%d%d",&a,&b);
            if(flag)
                continue;
            Union(a,b);
        }
        printf("Scenario #%d:\n",Case);
        if(flag)
            printf("Suspicious bugs found!\n");
        else
            printf("No suspicious bugs found!\n");
        printf("\n");
    }
    return 0;
}

食物链

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。
现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。
有人用两种说法对这N个动物所构成的食物链关系进行描述：
第一种说法是"1 X Y"，表示X和Y是同类。
第二种说法是"2 X Y"，表示X吃Y。
此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。
1） 当前的话与前面的某些真的话冲突，就是假话；
2） 当前的话中X或Y比N大，就是假话；
3） 当前的话表示X吃X，就是假话。
你的任务是根据给定的N（1 <= N <= 50,000）和K句话（0 <= K <= 100,000），输出假话的总数。

Input

第一行是两个整数N和K，以一个空格分隔。
以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。
若D=1，则表示X和Y是同类。
若D=2，则表示X吃Y。

Output

只有一个整数，表示假话的数目。

Sample Input

100 7
1 101 1 
2 1 2
2 2 3 
2 3 3 
1 1 3 
2 3 1 
1 5 5

Sample Output

3

题意明确，同样是种类并查集，只不过由原来的两种类别变成了三种类别，操作依然不变。

代码：

//By Sean Chen
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
int n,m,root[50005],relation[50005];
int d,a,b;
int cnt;

int findroot(int x)
{
    if (x==root[x])
        return x;
    int t=findroot(root[x]);
    relation[x]=(relation[root[x]]+relation[x])%3;
    root[x]=t;
    return t;
}

void Uni(int x,int y)
{
    int ra=findroot(x),rb=findroot(y);
    if (ra==rb)
    {
        if (d==1 && relation[x]!=relation[y])
            cnt++;
        if (d==2)
        {
            if (relation[x]==1 && relation[y]!=0)
                cnt++;
            if (relation[x]==2 && relation[y]!=1)
                cnt++;
            if (relation[x]==0 && relation[y]!=2)
                cnt++;
        }
    }
    else
    {
        root[ra]=rb;
        if (d==1)
            relation[ra]=(relation[y]-relation[x]+3)%3;
        else
            relation[ra]=(relation[y]-relation[x]+3+1)%3;
    }
    return;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=0;i<=n;i++)
    {
        relation[i]=0;
        root[i]=i;
    }
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&d,&a,&b);
        if (a>n || b>n || (d==2 && a==b))
        {
            cnt++;
            continue;
        }
        Uni(a,b);
    }
    cout<<cnt<<endl;
    return 0;
}