POJ 1611 The Suspects

The Suspects

Time Limit: 1000MS		Memory Limit: 20000K
Total Submissions: 17669		Accepted: 8547

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

继POJ 1182（好像是这个） 食物链之后第二次写并查集问题这一次是自己写出来的，哈哈哈，虽然RE一次，还是蛮得意的
出现Runtime Error的可以跑一下下面这组测试数据（我根据Discuss里的提示自己想的哦）：
100 4
2 0 1
5 10 7 13 12 14
3 13 10 17
2 7 8
如果你的程序没有跑死，那么正确答案是：2
问题就在于第二个集合和第三个集合中一部分已经属于同一个集合，如果不加判断就进行合并的话，可能会导致并查集的树变成了一个环，根节点消失了，再Find()的时候就会无穷递归下去，导致堆栈溢出

源代码如下：

#include<stdio.h>

long father[30050];

void MakeSet (long n)
{
    int i;
    for (i = 0; i < n; i++)
        father[i] = i;
}

long Find (long t)
{
    if (t != father[t])
        return father[t] = Find (father[t]);
    return father[t];
}

int main()
{
    long i, n, m, k, pre, next, ans;
    while (scanf ("%ld %ld", &n, &m) == 2)
    {
        if (n == 0 && m == 0)
            break;
        MakeSet (n);
        ans = 0;
        while (m--)
        {
            scanf ("%ld", &k);
            scanf ("%ld", &pre);
            for (i = 2; i <= k; i++)
            {
                if (Find (pre) == 0)
                    break;
                scanf ("%ld", &next);
                if (Find (pre) != Find (next))
                    father[Find (pre)] = next;
                pre = next;
            }
            for (; i <= k; i++)
            {
                scanf ("%ld", &next);
                father[Find (next)] = 0;
            }
        }
        for (i = 0; i < n; i++)
            if (Find (i) == 0)
                ans++;
        printf ("%ld\n", ans);
    }
    return 0;
}