POJ 1611 The Suspects 并查集 详细题解

                                                         The Suspects

Time Limit:1000MS    Memory Limit:20000KB    64bit IO Format:%I64d & %I64u

Description

Severe acute respiratory syndrome (SARS), an atypical pneumonia of unknown aetiology, was recognized as a global threat in mid-March 2003. To minimize transmission to others, the best strategy is to separate the suspects from others.
In the Not-Spreading-Your-Sickness University (NSYSU), there are many student groups. Students in the same group intercommunicate with each other frequently, and a student may join several groups. To prevent the possible transmissions of SARS, the NSYSU collects the member lists of all student groups, and makes the following rule in their standard operation procedure (SOP).
Once a member in a group is a suspect, all members in the group are suspects.
However, they find that it is not easy to identify all the suspects when a student is recognized as a suspect. Your job is to write a program which finds all the suspects.

Input

The input file contains several cases. Each test case begins with two integers n and m in a line, where n is the number of students, and m is the number of groups. You may assume that 0 < n <= 30000 and 0 <= m <= 500. Every student is numbered by a unique integer between 0 and n−1, and initially student 0 is recognized as a suspect in all the cases. This line is followed by m member lists of the groups, one line per group. Each line begins with an integer k by itself representing the number of members in the group. Following the number of members, there are k integers representing the students in this group. All the integers in a line are separated by at least one space.
A case with n = 0 and m = 0 indicates the end of the input, and need not be processed.

Output

For each case, output the number of suspects in one line.

Sample Input

100 4
2 1 2
5 10 13 11 12 14
2 0 1
2 99 2
200 2
1 5
5 1 2 3 4 5
1 0
0 0

Sample Output

4
1
1

解体思路：每个数都有一个自己的团体，如果两个数相遇了，且他俩不属于同一个团体，就要进行吞并（大鱼吃小鱼）。为什么呢？因为一旦两个数相遇，就说明不管是两个团体中的谁感染了，这两个团体中的所有人都要被列为嫌疑人，也就是说，相遇即为一体。

操作方法：一个团体中的数很多，为了保证简便，所以在每个团体中都选出了一个老大，老大掌管他的团体中有多少人，当不同的团体之间进行比较时，都是拿老大进行比较，看看谁是大鱼谁是小鱼。

解法正确性原因：不断的更新每个团体的情况，团体中的每一个数都可以进行组织的更新，使得遍历一边之后，每个数都可以直接找到他所在团体的老大，进而查询到该团体中由多少人。

AC代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<deque>
#include<iostream>
using namespace std;
int captain[30009];
int con[30009];
void init()
{
    int i,p,j;
    for(i=0;i<=30000;i++)
    {
        captain[i]=i;
        con[i]=1;
    }
}
int seek(int x)
{
    while(x!=captain[x])
        x=captain[x];
    return x;
}

void combine(int x,int y)
{
    int master1;
    int master2;
    master1=seek(x);
    master2=seek(y);
    if(master1!=master2)
    {
        if(con[master1]<=con[master2])
        {
            con[master2]+=con[master1];
            captain[master1]=master2;
        }
        else
        {
            con[master1]+=con[master2];
            captain[master2]=master1;
        }
    }
}
int main()
{
    int n,m,i,p,j,x;
    int head;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)
            break;
        init();
        for(i=1;i<=m;i++)
        {
            scanf("%d",&p);
            scanf("%d",&head);
            for(j=1;j<p;j++)
            {
                scanf("%d",&x);
                combine(head,x);
            }
        }
        printf("%d\n",con[seek(0)]);
    }
    return 0;
}