并查集初步

并查集本质上是对集合的操作，即通过标记、连接把元素分为不同集合
它的强大之处在于通过简单标记父节点就能把不同元素归结到固定的几个根节点，通过回溯根节点，就能判断两元素是否同属于一个集合。
当然，在处理的时候，也会出现将整个集合并入另一个集合的情况，此时只要将被并入集合的根的父节点链接到接收集合的根上即可。
放一道例题，帮助理解：
The Suspects

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

题意不再赘述（懒~）
代码如下：

#include <iostream>
#include <cstdio>
using namespace std;
#define maxm    510
#define maxn  30010
#define sus 0
int root[maxn];
//通过回溯递归找到根节点
int find(int x)
{
    if(x==root[x])
        return x;
    return find(root[x]);
}
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0) break;
        int i,j,k;

        //初始化，每个点的父节点初始化为自己，和回溯的终止条件对应
        for(i=0;i<=n;i++)
        {
            root[i]=i;
        }

        for(i=1;i<=m;i++)
        {
            scanf("%d",&k);
            int c,d;
            scanf("%d",&c);
            for(j=2;j<=k;j++)
            {
                scanf("%d",&d);
                //如果当前两个点原本分属两个集合，现在在题干的约束下需要合并时，将d所在集合整个并入c所在集合
                if(find(c)!=find(d))
                {
                    //合并操作
                    root[find(d)]=find(c);
                    c=d;
                }
            }
        }
        int sum=0;
        for(i=0;i<n;i++)
        {
            if(find(0)==find(i))
            sum++;
        }
        printf("%d\n",sum);
    }
    return 0;
}

这种解法就是将和suspect同社团的成员所在的其他社团通通并入suspect所在的社团集合，这样的话，最后这个社团有多少人就有多少嫌疑人。