并查集简述 (HDU-1213-How Many Tables)

并查集主要解决集合的有关运算，主要操作是查找操作和并操作。

1、集合的储存方式。

为便于查找，集合通常以树结构储存，每个元素分 数据域和指针域，可以用链式储存，也可以用结构数组储存，用根节点来表示一个集合。这个性质也决定了集合中是子节点指向父节点。

typedef struct 
{
    ElementType Data;
    int Parent;
}SetType;

下标	Data	Parent
0	1	-1
1	2	0
2	3	-1
3	4	0
4	5	2
5	6	-1
6	7	0
7	8	2
8	9	5
9	10	5

负数表示根节点，非负数表示父节点的下标

2、集合的查找。

集合既然用根节点表示，查找某元素所在的集合也就可以用集合表示了。

int Find ( SetType *S, ElementType X )
{
    int i = 0;
    while( i<MaxSize && S[i].Data != X )
        i++;
    if( i >= MaxSize ) return ERROR;
    while( S[i].Parent >= 0 )
        i = S[i].Parent ;
    return i;
}

3、集合的并。

将x1和x2所在的集合并在一起，就是将根节点并在一起，当然前提是他们本来就不属于同一集合。

void Union ( SetType *S, ElementType X1, ElementType X2 )
{
    int Root1, Root2;
    Root1 = Find ( S, X1 );
    Root2 = Find ( S, X2 );
    if( Root1 != Root2 )
        S[Root2].Parent = Root1;
}

上题：

How Many Tables

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 44039    Accepted Submission(s): 21990

Problem Description

Today is Ignatius' birthday. He invites a lot of friends. Now it's dinner time. Ignatius wants to know how many tables he needs at least. You have to notice that not all the friends know each other, and all the friends do not want to stay with strangers.

One important rule for this problem is that if I tell you A knows B, and B knows C, that means A, B, C know each other, so they can stay in one table.

For example: If I tell you A knows B, B knows C, and D knows E, so A, B, C can stay in one table, and D, E have to stay in the other one. So Ignatius needs 2 tables at least.

Input

The input starts with an integer T(1<=T<=25) which indicate the number of test cases. Then T test cases follow. Each test case starts with two integers N and M(1<=N,M<=1000). N indicates the number of friends, the friends are marked from 1 to N. Then M lines follow. Each line consists of two integers A and B(A!=B), that means friend A and friend B know each other. There will be a blank line between two cases.

Output

For each test case, just output how many tables Ignatius needs at least. Do NOT print any blanks.

Sample Input

2

5 3

1 2

2 3

4 5

5 1

2 5

Sample Output

2 4

Source

杭电ACM省赛集训队选拔赛之热身赛

#include <iostream>
using namespace std;

typedef int ElementType;
typedef struct
{
    ElementType Data;
    int Parent;
}SetType;

SetType S[1001];
int MaxSize;

int Find ( SetType *S, ElementType X )
{
    int i = 0;
    while( i<MaxSize && S[i].Data != X )
        i++;
    while( S[i].Parent >= 0 )
        i = S[i].Parent ;
    return i;
}

void Union ( SetType *S, ElementType X1, ElementType X2 )
{
    int Root1, Root2;
    Root1 = Find ( S, X1 );
    Root2 = Find ( S, X2 );
    if( Root1 != Root2 )
        S[Root2].Parent = Root1;
}

int main()
{
    int t;
    cin >> t;
    while ( t-- )
    {
        int num = 0;
        int n, m, i;
        cin >> n >> m;
        for( i=0; i<n; i++ )
        {
            S[i].Parent = -1;
            S[i].Data   = i + 1;
        }
        MaxSize = n;
        for( i=0; i<m; i++ )
        {
            int a, b;
            cin >> a >> b;
            Union( S, a, b );
        }
        for( i=0; i<n; i++ )
        {
            if(S[i].Parent == -1)
                num++;
        }
        cout << num << endl;
    }
    return 0;
}