並查集算法

算法思想：

1.初始化功能：把每個點所在集合初始化為其自身。

2.查找功能：查找元素所在的集合，即根節點。

2.合並功能：將兩個元素所在的集合合並為一個集合。

例題：若某個家族人員過於龐大，要判斷兩個是否是親戚，確實不容易，給出某個親戚關系圖，求任意給出的兩個人是否具有親戚關系。

規定：x和y是親戚，y和z是親戚，那么x和z也是親戚。如果x,y是親戚，那么x的親戚都是y的親戚，y的親戚也都是x的親戚。

Input（輸入）

第一行：三個整數n,m,p，（n< =5000,m< =5000,p< =5000）分別表示有n個人，m個親戚關系，詢問p對親戚關系。以下m行：每行兩個數a,b.(1<=a,b<=n),表示a和b具有親戚關系。接下來p行：每行兩個數

a，b。表示詢問a和b是否具有親戚關系。

Output（輸出）

共P行，每行一個’Yes’或’No’。表示第p個詢問的答案為“有”或“沒有”親戚關系。

 

樣例：

9 7 1

2 4

5 7

1 3

8 9

1 2

5 6

2 3

1 9

我們可以給每個人建立一個集合，集合的元素值有他自己，表示最開始時他不知道任何人是它的親戚。以后每次給出一個親戚關系a, b，則a和他的親戚與b和他的親戚就互為親戚了，將a所在集合與b所在集合合並。對於樣例數據的操作全過程如下：

初始狀態：{1} {2} {3} {4} {5} {6} {7} {8} {9}

輸入關系 分離集合

輸入第二行：2 4  后：{2,4}{1} {3} {5} {6} {7} {8} {9}

輸入第三行：5 7  后：{2,4} {5,7} {1} {3} {6} {8} {9}

輸入第四行：1 3  后： {1,3} {2,4} {5,7}{6} {8} {9}

輸入第五行：8 9  后：{1,3} {2,4} {5,7} {8,9}{6}

輸入第六行：1 2  后： {1,2,3,4} {5,7} {8,9}{6}

輸入第七行：5 6  后：{1,2,3,4} {5,6,7} {8,9}

輸入第八行：2 3  后：{1,2,3,4} {5,6,7} {8,9}

判斷親戚關系

輸入第二行：2 4  后：因為1,9不在同一集合內，所以輸出"NO"。

最后我們得到3個 集合{1,2,3,4}、{5,6,7}、{8,9}，於是判斷兩個人是否親戚的問題就變成判斷兩個數是否在同一個集合中的問題.

算法需要以下幾個子過程：

(1) 開始時，為每個人建立一個集合SUB-Make-Set(x)；

(2) 得到一個關系a b，合並相應集合SUB-Union(a,b)；

(3) 此外我們還需要判斷兩個人是否在同一個 集合中，這就涉及到如何標識集合的問題。我們可以在每個集合中選一個代表標識集合，因此我們需要一個子過程給出每個集合的代表元SUB-Find-Set(a)。於是判斷兩個人是否在同一個集合中，即兩個人是否為親戚，等價於判斷SUB-Find-Set(a)=SUB-Find-Set(b)。

有了以上子過程的支持，我們就有如下算法。

 

//初始化
for(int i=0;i<n;i++)
{
    SUB-Make-Set(i);
}
//合並
for(int i=0;i<n;i++)
{
    if(SUB-Find-Set(ai) != SUB-Find-Set(bi))
　　{　
       SUB-Union(ai, bi);
    }
}

//詢問
fou(int i=0;i<n;i++)
{  
    if(SUB-Find-Set(ci)==SUB-Find-Set(di))
　　{ 
      output “Yes” 
    }
　　else
　　{ 
      output “No” 
    }
}

 

解決問題的關鍵便為選擇合適的數據結構實現並查集的操作，使算法的實現效率最高。

 

優化反向

1. 單鏈表實現

一個節點對應一個人，在同一個集合中的節點串成一條鏈表就得到了單鏈表的實現。在集合中我們以單鏈表的第一個節點作為集合的代表元。於是每個節點x（x也是人的編號）應包含這些信息：指向代表元即表首的指針head[x]，指向表尾的指針tail[x]，下一個節點的指針next[x]。

SUB-Make-Set(x)過程設計如下：

SUB-Make-Set(x)
{
    for(int i=0;i<x;i++)
    {
        head[x]=x;
        tail[x]=x;
        next[x]=0;
    }
}

求代表元的SUB-Find-Set(x)過程設計如下：

SUB-Find-Set(x)
{
    return head[x];
}

前兩個過程比較簡單，SUB-Union(a,b)稍微復雜一點。我們要做的是將b所在 鏈表加到a所在鏈表尾，然后b所在鏈表中的所有節點的代表元 指針改指a所在鏈表的表首節點。

過程的偽代碼如下：

SUB-Union(a,b)
{
    next[tail[head[a]]]=head[b];
    int p=head[b];
    while(p!=0)
    {
        head[p]=head[a];
        p=next[p];
    }
}

整個算法PROBLEM-Relations的 時間復雜度為O(N+M+N^2+Q)=O(N^2+M+Q)。

由於算法的時間復雜度中O(M+Q)是必需的，因此我們要讓算法更快，就要考慮如何使減小O(N^2)。

我們想到合並鏈表時，我們可以用一種啟發式的方法：將較短的表合並到較長表上。為此每個節點中還需包含表的長度的信息。這比較容易實現，我們就不寫出 偽代碼了。

合並鏈表后的 時間復雜度：

首先我們給出一個固定對象x的代表元指針head[x]被更新次數的 上界。由於每次x的代表元指針被更新時，x必然在較小的 集合中，因此x的代表元指針被更新一次后，集合至少含2個元素。類似地，下一次更新后，集合至少含4個元素，繼續下去，當x的代表元指針被更新 log k 次后，集合至少含k個元素，而集合最多含n個元素，所以x的代表元指針至多被更新 log n 次。所以M次SUB-Union(a,b)操作的時間復雜度為O(NlogN+M)。算法總的時間復雜度為O(NlogN+M+Q)。

2.並查集森林

編輯

並查集的另一種更快的實現是用有根樹來表示 集合：每棵樹表示一個集合，樹中的節點對應一個人。

每個節點x包含這些信息：父節點指針p[x]，樹的深度rank[x]。其中rank[x]將用於啟發式合並過程。

於是建立集合過程的 時間復雜度依然為O(1)。

SUB-Make-Set(x)
{
    for(int i=0;i<x;i++)
    {
        p[i]=i;
        rank[i]=0;
    }
}

用森林的數據結構來實現的最大好處就是降低SUB-Union(a,b)過程的時間復雜度。

SUB-Union(a,b)
{
    //SUB-Link(SUB-Find-Set(a),SUB-Find-Set(b))
    SUB-Link(a,b)
    p[a]=b;
}

合並 集合的工作只是將a所在樹的根節點的父節點改為b所在樹的根節點。這個操作只需O(1)的時間。而SUB-Union(a,b)的時間效率決定於SUB-Find-Set(x)的快慢。

SUB-Find-Set(x)
{
    if(x==p[a])
    {
        return x;
    }
    else
    {
        return SUB-Find-Set(p[x]);
    }
}

這個過程的時效與樹的深度成線性關系，因此其平均 時間復雜度為O(logN)，但在最壞情況下（樹退化成 鏈表），時間復雜度為O(N)。於是PROBLEM-Relations最壞情況的時間復雜度為O(N(M+Q))。有必要對算法進行優化。

第一個優化是啟發式合並。在優化 單鏈表時，我們將較短的表鏈到較長的表尾，在這里我們可以用同樣的方法，將深度較小的樹指到深度較大的樹的根上。這樣可以防止樹的退化，最壞情況不會出現。SUB-Find-Set(x)的時間復雜度為O(log N)，PROBLEM-Relations時間復雜度為O(N + logN (M+Q))。SUB-Link(a,b)作相應改動。

SUB-Link(a,b)
{
    if(rank[a]>rank[b])
    {
        p[b]=a;
        rank[b]+=rank[a];
    }
    else
    {
        p[a]=b;
        rank[a]+=rank[b];
    }
}

然而算法的耗時主要還是花在SUB-Find-Set(x)上。

第二個優化是路徑壓縮。它非常簡單而有效。如圖所示，在SUB-Find-Set(1)時，我們“順便”將節點1, 2, 3的父節點全改為節點4，以后再調用SUB-Find-Set(1)時就只需O(1)的時間。

圖0-0-4

於是SUB-Find-Set(x)的代碼改為：

SUB-Find-Set(x)
{
    if(x!=p[x])
    {
        p[x]=SUB-Find-Set(p[x]);
    }
    return p[x];
}

該過程首先找到樹的根，然后將路徑上的所有節點的父節點改為這個根。實現時，遞歸的程序有許多棧的操作，改成非遞歸會更快些。

SUB-Find-Set(x)
{
    int r=x;
    while(r!=p[x])
    {
        r=p[r];
    }
    while x?r
     do q←p[x]
     p[x]←r
     x←q
     return r
}

改進后的算法 時間復雜度的分析十分復雜，如果完整的寫出來足可寫一節，這里我們只給出結論：改進后的PROBLEM-Relations其時間復雜度為O(N+(M+Q)*A(M+Q,N))，其中A(M+Q,N)為Ackerman函數的增長極為緩慢的逆函數。你不必了解與Ackerman函數相關的內容，只需知道在任何可想象得到的並查集數據結構的應用中，A(M+Q,N)≤4，因此PROBLEM-Relations的時間復雜度可認為是線性的O(N+M+Q)。

優化路徑壓縮

思想

每次查找的時候，如果路徑較長，則修改信息，以便下次查找的時候速度更快。

實現

第一步，找到根結點。

第二步，修改查找路徑上的所有節點，將它們都指向根結點。

 

int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    return fa[x]=find(fa[x]);
}

 

模板：

/fa[x]表示x的最遠祖先
int fa[50002];
//初始化，一開始每個點單獨成集合
void build(int qwq) 
{
    for(int i=1;i<=qwq;i++)
    {
        fa[i]=i;
    }
    return ;
} 
//找到x的最遠祖先，並且壓縮路徑
int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    return fa[x]=find(fa[x]);
}
//判斷x,y是不是在同一個集合里，直接判斷最遠祖先是不是一樣的 
bool che(int x,int y)
{
    return find(x)==find(y);
}
//合並x,y，我們在判斷x和y是不是同一個集合里，
//路徑壓縮之后fa[x],fa[y]已經是最遠祖先了，
//所以直接將fa[x]的父親連接在fa[y]的祖先上
void mer(int x,int y)
{
    if(!che(x,y)) 
    {
        fa[fa[x]]=fa[y];
    }
    return ;
}