1118 Birds in Forest (25分)

Some scientists took pictures of thousands of birds in a forest. Assume that all the birds appear in the same picture belong to the same tree. You are supposed to help the scientists to count the maximum number of trees in the forest, and for any pair of birds, tell if they are on the same tree.

Input Specification:
Each input file contains one test case. For each case, the first line contains a positive number N (≤10
​4
​​ ) which is the number of pictures. Then N lines follow, each describes a picture in the format:

K B
​1
​​ B
​2
​​ … B
​K
​​

where K is the number of birds in this picture, and B
​i
​​ 's are the indices of birds. It is guaranteed that the birds in all the pictures are numbered continuously from 1 to some number that is no more than 10
​4
​​ .

After the pictures there is a positive number Q (≤10
​4
​​ ) which is the number of queries. Then Q lines follow, each contains the indices of two birds.

Output Specification:
For each test case, first output in a line the maximum possible number of trees and the number of birds. Then for each query, print in a line Yes if the two birds belong to the same tree, or No if not.

Sample Input:
4
3 10 1 2
2 3 4
4 1 5 7 8
3 9 6 4
2
10 5
3 7

Sample Output:
2 10
Yes
No

并查集的题，初始化，找根结点，合并，三大操作。
将一幅画中的结点存入数组中，然后依次合并（前一个结点和后一个结点合并即可），不要在此时就将isRoot数组++，因为后序的操作可能会使这个块的根结点改变。
处理完数据后，遍历记录鸟类种类的数组，如果这个鸟个数不为0，就将isRoot(该鸟的根结点)++，这样可以准确的知道有几个根结点。
最后两个鸟是否属于一个树，只需要findFather的值是否相同即可

#include<iostream>
using namespace std;
const int N = 10001;
int father[N];
int isRoot[N] = {0};

void init(){
    for(int i = 0; i < N; i++){
        father[i]=i;
    }
}

int findFather(int x){
    int a = x;
    while(father[x] != x){
        x = father[x];
    }
    //路径压缩
    while(father[a] != a){
        int f = a;
        a = father[a];//找到a的父结点，将整条路上的结点的父结点都设为x
        father[f] = x;//x是根结点
    }
    return x;
}

void Union(int a, int b){
    int faA = findFather(a);
    int faB = findFather(b);
    if(faA != faB){
        father[faA] = faB;
    }
}

int main(){
    init();
    int n, k, hashTable[N] = {0},birds[N];
    int tree = 0, category = 0;
    cin>>n;
    for(int i = 0; i < n; i++){
        cin>>k;
        for(int j = 0; j < k; j++){
            cin>>birds[j];
            hashTable[birds[j]]++;
        }
        int root = birds[0];
        for(int j = 1; j < k; j++){
            Union(birds[j],root);
            root = findFather(root);
        }
    }
    for(int i = 0; i < N; i++){
        if(hashTable[i] != 0){
            category++;
            isRoot[findFather(i)]++;
        }
    }
    for(int i = 0; i < N; i++){
        if(isRoot[i] != 0) tree++;
    }
    cout<<tree<<" "<<category<<endl;
    int q, a, b;
    cin>>q;
    for(int i = 0; i <q; i++){
        cin>>a>>b;
        if(findFather(a) != findFather(b)){
            cout<<"No\n";
        }
        else cout<<"Yes\n";
    }
    return 0;
}

合并一张图上所有的鸟，使其成为一个集合。后面如果这个鸟再次出现，那么这张图上的所有鸟都会被加入之前那个集合。最后遍历出现过的鸟，找出每只鸟所在块的根结点并将其数组对应的位++，然后遍历isRoot数组，不为0的就是根结点，有几个根结点就是几个块，也就是几棵树

#include<iostream>
using namespace std;
const int maxn = 10005;
int father[maxn];//其实通过这个和findFather来记录是否在同一个集群的
int isRoot[maxn] = {0};

void init(){
    for(int i = 0; i < maxn; i++){
        father[i] = i;
    }
}
int findFather(int v){
    int a = v;
    while(v!=father[v]){
        v = father[v];
    }
    while(a != father[a]){
        int z = a;
        a = father[a];
        father[z] = v;
    }
    return v;
}

void Union(int a, int b){
    int faA = findFather(a);
    int faB = findFather(b);
    if(faA != faB) father[faA] = faB;
}

int main(){
    int n,k,birds[maxn];
    int hashTable[maxn] = {0};//记录i号鸟是否出现过
    cin>>n;
    init();
    for(int i = 0; i < n; i++){
        cin>>k;
        for(int j = 0; j < k; j++){
            cin>>birds[j];
            hashTable[birds[j]]++;
        }
        for(int j = 1; j < k; j++){
            Union(birds[j],birds[j-1]);
        }
    }
    int category = 0, trees = 0;
    for(int i = 0; i < maxn; i++){
        if(hashTable[i] != 0){
            category++;
            isRoot[findFather(i)]++;
        }
    }
    for(int i = 0; i < maxn; i++){
        if(isRoot[i]!=0) trees++;
    }
    cout<<trees<<" "<<category<<endl;
    int q,u,v;
    cin>>q;
    for(int i = 0; i < q; i++){
        cin>>u>>v;
        if(findFather(u) == findFather(v)) cout<<"Yes\n";
        else cout<<"No\n";
    }
    return 0;
}