0 題意很簡單，略。

1

（下面的描述中，所提及的集合的深度和集合的寬度是指：

以1,3,4都指向2為例：
    2   
 /  |  \
1   3   4
樹的深度為2（兩層），樹的寬度為3（1 3 4 三個）

）

①關於按秩合併中秩的一點說明，我理解的秩是集合的深度，大部分部落格的程式碼與我的理解相同（即2-④ Join()中按秩合併程式碼中的秩就是嚴格代表著集合的深度），但是有的部落格上:

 p1=Find(a),p2=Find(b); 
    if(rank[p1]<=rank[p2]){
        parents[p1]=p2;
        rank[p2]+=rank[p1];
    }
    else if(rank[p2]<=rank[p1]){
        parents[p2]=p1;
        rank[p1]+=rank[p2];
    }
 

②路徑壓縮和按秩合併的舉例理解：

1)路徑壓縮（對Find()優化，只需參考2①，2②、2③中的Find()部分）

//路徑壓縮前，每次查詢最低端的元素的最高負責人（這個集合的代表），都要不斷往上查對它負責的元素，直到查到最後那個只需要對自己負責的元素即為這一連串元素的最高負責人。
1->2, Find(1)=Find(2)=2
1->2->3, Find(1)=Find(2)=Find(3)=3;
1->2->3->4, Find(1)=Find(2)=Find(3)=Find(4);

//路徑壓縮後，每次查詢最低端的元素的代表完畢之後，都順便將該元素以及該元素上面的所有元素的負責人都設定為直接對最高負責人負責，就方便了再次查詢。
1->2, Find(1)=Find(2)=2
1->2->3 ---- 1->3,2->3, Find(1)=3,Find(2)=3,Find(3)=3
1->2->3->4 ---- 1->4,2->4,3->4, Find(1)=4,Find(2)=4,Find(3)=4,Find(4)=4;
 

2)按秩合併（對Join()優化，只需參考2①，2④中的Join()部分）

//按秩合併前，有可能出現一個長串，那麼路徑壓縮時，需要改變的值就很多
Join(1,2)  1->2
Join(2,3)  1->2->3
Join(3,4)  1->2->3->4
Find(1)    1->4,2->4,3->4 //(路徑壓縮時需要改變三個值，即與被併入集合的深度有關)

//按秩合併後，總是儘可能使合併後的新集合的深度不會繼續加深，那麼路徑壓縮時，改變的值就相對較少
 Join(1, 2)
   2   3   4 
  /
 1
 
 Join(2, 3)
   2    4
 /   \
1     3

 Join(3, 4)
    2   
 /  |  \
1   3   4

Find(1)=2, 1->2 //（路徑壓縮時相對改變較少的值）
 

2關於POJ2524的AC CODE

①樸素程式碼

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
///樸素程式碼（沒有路徑壓縮，也沒有按秩合併）
using namespace std;
int n,m;
int kase=0;
int parents[50010];
int cnt;//記錄最後答案，每次Join成功，就自減減一次，最後得到的即一共有多少個集合（當然也可以最後走一個for，有一個數的root是指向自己的就自加加一次，那麼得到的代表個數自然就是集合個數）
int Find(int x){
    int root=x;
    while(root!=parents[root]){
        root=parents[root];//找到x的真正根節點，即最後的root
    }
    return root;
}
void Join(int a,int b){
    int p1=Find(a);
    int p2=Find(b);
    if(p1==p2){
        return ;
    }
    parents[p1]=p2;//不按秩合併，那麼新的集合的代表由原來的兩個舊集合中哪個舊集合的代表來充當就不重要了，於是隨便指定了一個
    cnt--;
    return ;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&n!=0){
        cnt=n;
        for(int i=1;i<=n;i++){
            parents[i]=i;
        }
        int a;
        int b;
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            Join(a,b);
        }

        cout<<"Case "<<++kase<<": "<<cnt<<endl;
    }

    return 0;
}

②遞迴的路徑壓縮

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
///遞迴的路徑壓縮（對Find()的優化）
using namespace std;
int n,m;
int kase=0;
int cnt;
int parents[50010];
int Find(int x){
    int root=x;
    if(root!=parents[root])
        root=Find(parents[root]);//找到x的真正根節點，即最後的root<span style="font-family: Arial, Helvetica, sans-serif;">，同時在遞歸回溯時，將中間經過的元素的直接負責人都設定為最高負責人，方便下一次查詢</span>
    return root;
}
void Join(int a,int b){
    int p1=Find(a);
    int p2=Find(b);
    if(p1==p2){
        return ;
    }

    parents[p1]=p2;//不按秩合併，那麼新的集合的代表由原來的兩個舊集合中哪個舊集合的代表來充當就不重要了，於是隨便指定了一個
    cnt--;
    return ;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&n!=0){
        cnt=n;
        for(int i=1;i<=n;i++){
            parents[i]=i;
        }

        int a;
        int b;
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            Join(a,b);
        }

        cout<<"Case "<<++kase<<": "<<cnt<<endl;
    }

    return 0;
}

③非遞迴路徑壓縮

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
///非遞迴（防止棧溢位）路徑壓縮（對Find()的優化）
using namespace std;
int n,m;
int kase=0;
int cnt;
int parents[50010];
int Find(int x){
    int root=x;
    while(root!=parents[root]){
        root=parents[root];//找到x的真正根節點，即最後的root
    }
    int temp2;
    while(x!=parents[x]){
        temp2=parents[x];//重新尋找一遍，並將途中所有節點都指向根節點，即壓縮路徑，不用遞迴防止棧溢位
        parents[x]=root;
        x=temp2;
    }
    return root;
}
void Join(int a,int b){
    int p1=Find(a);
    int p2=Find(b);
    if(p1==p2){
        return ;
    }

    parents[p1]=p2;//不按秩合併，那麼新的集合的代表由原來的兩個舊集合中哪個舊集合的代表來充當就不重要了，於是隨便指定了一個
    cnt--;
    return ;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&n!=0){
        cnt=n;
        for(int i=1;i<=n;i++){
            parents[i]=i;
        }

        int a;
        int b;
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            Join(a,b);
        }

        cout<<"Case "<<++kase<<": "<<cnt<<endl;
    }

    return 0;
}

④非遞迴路徑壓縮+按秩合併

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
///非遞迴（防止棧溢位）路徑壓縮（對Find()的優化）+按秩合併（對Join()的優化）
///(先理解路徑壓縮然後就容易理解按軼合併的必要性,正是因為按軼（深度）合併的存在，使得合併之後儘量增加樹的寬度而不增加深度（當兩個集合的深度相同時合併後形成的新集合是原來的集合的深度+1），從而使路徑壓縮儘可能壓縮的路徑層數變少)
using namespace std;
int n,m;
int kase=0;
int cnt;
int parents[50010];
int rank[50010];//以此為代表的集合的深度，用於合併時的比較
int Find(int x){
    int root=x;
    while(root!=parents[root]){
        root=parents[root];//找到x的真正根節點，即最後的root
    }
    int temp2;
    while(x!=parents[x]){
        temp2=parents[x];//重新尋找一遍，並將途中所有節點都指向根節點，即壓縮路徑
        parents[x]=root;
        x=temp2;
    }
    return root;
}
void Join(int a,int b){
    int p1=Find(a);
    int p2=Find(b);
    if(p1==p2){
        return ;
    }
    
    cnt--;
    if(rank[p1]<rank[p2]){
        parents[p1]=p2;
    }
    else if(rank[p2]<rank[p1]){
        parents[p2]=p1;
    }
    else if(rank[p1]==rank[p2]){
        parents[p1]=p2;//兩個集合的秩（深度）相同時，新的代表是哪個就不重要了（因為路徑壓縮的效率只與深度有關，所以相等深度的兩個舊集合哪個寬度更大並不重要）
        rank[p2]++;//新的集合的秩（深度）要+1；
    }
    return ;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&n!=0){
        cnt=n;
        for(int i=1;i<=n;i++){
            parents[i]=i;
            rank[i]=0;
        }

        int a;
        int b;
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            Join(a,b);
        }

        cout<<"Case "<<++kase<<": "<<cnt<<endl;
    }

    return 0;
}

理解不同之處，歡迎指正。