零基礎學並查集算法

時間 2019-11-17

標籤零基礎算法简体版

原文原文鏈接

並查集是我暑假從高手那裏學到的一招，以爲真是太精妙的設計了。之前我沒法解決的一類問題居然能夠用如此簡單高效的方法搞定。不分享出來真是對不起party了。（party：我靠，關我嘛事啊？我跟你很熟麼？）php

首先在地圖上給你若干個城鎮，這些城鎮均可以看做點，而後告訴你哪些對城鎮之間是有道路直接相連的。最後要解決的是整幅圖的連通性問題。好比隨意給你兩個點，讓你判斷它們是否連通，或者問你整幅圖一共有幾個連通分支，也就是被分紅了幾個互相獨立的塊。像暢通工程這題，問還須要修幾條路，實質就是求有幾個連通分支。若是是1個連通分支，說明整幅圖上的點都連起來了，不用再修路了；若是是2個連通分支，則只要再修1條路，從兩個分支中各選一個點，把它們連起來，那麼全部的點都是連起來的了；若是是3個連通分支，則只要再修兩條路……c++

如下面這組數據輸入數據來講明算法

4 2 1 3 4 3編程

第一行告訴你，一共有4個點，2條路。下面兩行告訴你，一、3之間有條路，四、3之間有條路。那麼整幅圖就被分紅了1-3-4和2兩部分。只要再加一條路，把2和其餘任意一個點連起來，暢通工程就實現了，那麼這個這組數據的輸出結果就是1。好了，如今編程實現這個功能吧，城鎮有幾百個，路有不知道多少條，並且可能有迴路。這可如何是好？數組

我之前也不會呀，自從用了並查集以後，嗨，效果還真好！咱們全家都用它！網絡

並查集由一個整數型的數組和兩個函數構成。數組pre[]記錄了每一個點的前導點是什麼，函數find是查找，join是合併。數據結構

int pre[1000 ];數據結構和算法

int find(int x) //查找根節點函數

{

int r=x;

while ( pre[r ] != r ) //返回根節點 r

r=pre[r ];

int i=x , j ;

while( i != r ) //路徑壓縮

{

j = pre[ i ]; // 在改變上級以前用臨時變量 j 記錄下他的值

pre[ i ]= r ; //把上級改成根節點

i=j;

}

return r ;

}

void join(int x,int y) //判斷x y是否連通，

//若是已經連通，就不用管了 //若是不連通，就把它們所在的連通分支合併起,

{

int fx=find(x),fy=find(y);

if(fx!=fy)

pre[fx ]=fy;

}

爲了解釋並查集的原理，我將舉一個更有愛的例子。話說江湖上散落着各式各樣的大俠，有上千個之多。他們沒有什麼正當職業，成天揹着劍在外面走來走去，碰到和本身不是一路人的，就免不了要打一架。但大俠們有一個優勢就是講義氣，絕對不打本身的朋友。並且他們信奉「朋友的朋友就是個人朋友」，只要是能經過朋友關係串聯起來的，無論拐了多少個彎，都認爲是本身人。這樣一來，江湖上就造成了一個一個的羣落，經過兩兩之間的朋友關係串聯起來。而不在同一個羣落的人，不管如何都沒法經過朋友關係連起來，因而就能夠放心往死了打。可是兩個本來互不相識的人，如何判斷是否屬於一個朋友圈呢？

咱們能夠在每一個朋友圈內推舉出一個比較有名望的人，做爲該圈子的表明人物，這樣，每一個圈子就能夠這樣命名「齊達內朋友之隊」「羅納爾多朋友之隊」……兩人只要互相對一下本身的隊長是否是同一我的，就能夠肯定敵友關係了。

可是還有問題啊，大俠們只知道本身直接的朋友是誰，不少人壓根就不認識隊長，要判斷本身的隊長是誰，只能漫無目的的經過朋友的朋友關係問下去：「你是否是隊長？你是否是隊長？」這樣一來，隊長面子上掛不住了，並且效率過低，還有可能陷入無限循環中。因而隊長下令，從新組隊。隊內全部人實行分等級制度，造成樹狀結構，我隊長就是根節點，下面分別是二級隊員、三級隊員。每一個人只要記住本身的上級是誰就好了。遇到判斷敵友的時候，只要一層層向上問，直到最高層，就能夠在短期內肯定隊長是誰了。因爲咱們關心的只是兩我的之間是否連通，至於他們是如何連通的，以及每一個圈子內部的結構是怎樣的，甚至隊長是誰，並不重要。因此咱們能夠聽任隊長隨意從新組隊，只要不搞錯敵友關係就行了。因而，門派產生了。

http://i3.6.cn/cvbnm/6f/ec/f4/1e9cfcd3def64d26ed1a49d72c1f6db9.jpg

下面咱們來看並查集的實現。 int pre[1000]; 這個數組，記錄了每一個大俠的上級是誰。大俠們從1或者0開始編號（依據題意而定），pre[15]=3就表示15號大俠的上級是3號大俠。若是一我的的上級就是他本身，那說明他就是掌門人了，查找到此爲止。也有孤家寡人自成一派的，好比歐陽鋒，那麼他的上級就是他本身。每一個人都只認本身的上級。好比胡青牛同窗只知道本身的上級是楊左使。張無忌是誰？不認識！要想知道本身的掌門是誰，只能一級級查上去。 find這個函數就是找掌門用的，意義再清楚不過了（路徑壓縮算法先不論，後面再說）。

int find(int x) //查找我（x）的掌門

{

int r=x; //委託 r 去找掌門

while (pre[r ]!=r) //若是r的上級不是r本身（也就是說找到的大俠他不是掌門 = =）

r=pre[r ] ; // r 就接着找他的上級，直到找到掌門爲止。

return r ; //掌門駕到~~~

}

再來看看join函數，就是在兩個點之間連一條線，這樣一來，原先它們所在的兩個板塊的全部點就均可以互通了。這在圖上很好辦，畫條線就好了。但咱們如今是用並查集來描述武林中的情況的，一共只有一個pre[]數組，該如何實現呢？仍是舉江湖的例子，假設如今武林中的形勢如圖所示。虛竹小和尚與周芷若MM是我很是喜歡的兩我的物，他們的終極boss分別是玄慈方丈和滅絕師太，那明顯就是兩個陣營了。我不但願他們互相打架，就對他倆說：「大家兩位拉拉勾，作好朋友吧。」他們看在個人面子上，贊成了。這一讚成可非同小可，整個少林和峨眉派的人就不能打架了。這麼重大的變化，可如何實現呀，要改動多少地方？其實很是簡單，我對玄慈方丈說：「大師，麻煩你把你的上級改成滅絕師太吧。這樣一來，兩派原先的全部人員的終極boss都是師太，那還打個球啊！反正咱們關心的只是連通性，門派內部的結構沒關係的。」玄慈一聽確定火大了：「我靠，憑什麼是我變成她手下呀，怎麼不反過來？我抗議！」抗議無效，上天安排的，最大。反正誰加入誰效果是同樣的，我就隨手指定了一個。這段函數的意思很明白了吧？

void join(int x,int y) //我想讓虛竹和周芷若作朋友

{

int fx=find(x),fy=find(y); //虛竹的老大是玄慈，芷若MM的老大是滅絕

if(fx!=fy) //玄慈和滅絕顯然不是同一我的

pre[fx ]=fy; //方丈只好委委屈屈地當了師太的手下啦

}

再來看看路徑壓縮算法。創建門派的過程是用join函數兩我的兩我的地鏈接起來的，誰當誰的手下徹底隨機。最後的樹狀結構會變成什麼胎脣樣，我也徹底沒法預計，一字長蛇陣也有可能。這樣查找的效率就會比較低下。最理想的狀況就是全部人的直接上級都是掌門，一共就兩級結構，只要找一次就找到掌門了。哪怕不能徹底作到，也最好儘可能接近。這樣就產生了路徑壓縮算法。設想這樣一個場景：兩個互不相識的大俠碰面了，想知道能不能揍。因而趕忙打電話問本身的上級：「你是否是掌門？」上級說：「我不是呀，個人上級是誰誰誰，你問問他看看。」一路問下去，原來兩人的最終boss都是東廠曹公公。「哎呀呀，原來是記己人，西禮西禮，在下三營六組白麪葫蘆娃!」「幸會幸會，在下九營十八組仙子狗尾巴花！」兩人高高興興地手拉手喝酒去了。「等等等等，兩位同窗請留步，還有事情沒完成呢！」我叫住他倆。「哦，對了，還要作路徑壓縮。」兩人醒悟。白麪葫蘆娃打電話給他的上級六組長：「組長啊，我查過了，其習偶們的掌門是曹公公。不如偶們一塊兒及接拜在曹公公手下吧，免得級別過低，之後查找掌門麻環。」「唔，有道理。」白麪葫蘆娃接着打電話給剛纔拜訪過的三營長……仙子狗尾巴花也作了一樣的事情。這樣，查詢中全部涉及到的人物都彙集在曹公公的直接領導下。每次查詢都作了優化處理，因此整個門派樹的層數都會維持在比較低的水平上。路徑壓縮的代碼，看得懂很好，看不懂也不要緊，直接抄上用就好了。總之它所實現的功能就是這麼個意思。

http://i3.6.cn/cvbnm/60/98/92/745b3eac68181e4ee1fa8d1b8bca38bc.jpg

hdu1232

 1 #include<iostream>
 2 using namespace std;
 3 int  pre[1050];
 4 bool t[1050];               //t 用於標記獨立塊的根結點
 5 int Find(int x)
 6 {
 7     int r=x;
 8     while(r!=pre[r])
 9         r=pre[r];
10     
11     int i=x,j;
12     while(pre[i]!=r)
13     {
14         j=pre[i];
15         pre[i]=r;
16         i=j;
17     }
18     return r;
19 }
20 void mix(int x,int y)
21 {
22     int fx=Find(x),fy=Find(y);
23     if(fx!=fy)
24     {
25         pre[fy]=fx;
26     }
27 } 
28 int main()
29 {
30     int N,M,a,b,i,j,ans;
31     while(scanf("%d%d",&N,&M)&&N)
32     {
33         for(i=1;i<=N;i++)          //初始化 
34             pre[i]=i;
35         
36         for(i=1;i<=M;i++)          //吸取並整理數據 
37         {
38             scanf("%d%d",&a,&b);
39             mix(a,b);
40         }
41         memset(t,0,sizeof(t));
42         for(i=1;i<=N;i++)          //標記根結點
43         {
44             t[Find(i)]=1;
45         }
46         for(ans=0,i=1;i<=N;i++)
47             if(t[i])
48                 ans++;
49                 
50         printf("%d\n",ans-1);
51         
52     }
53     return 0;
54 }

//如下爲原文附的代碼:
//回到開頭提出的問題，個人代碼以下：
#include <bits/stdc++.h>
using namespace std;
int pre[1000];
int find(int x)
{
    int r=x;
   while (pre[r ]!=r)
   r=pre[r ];
   int i=x; int j;
   while(i!=r)
   {
       j=pre[i ];
       pre[i ]=r;
       i=j;
   }
   return r;
}
int main()
{
   int n,m,p1,p2,i,total,f1,f2;
   while(scanf("%d",&n) && n)         //讀入n，若是n爲0，結束
   {                                                    //剛開始的時候，有n個城鎮，一條路都沒有 //那麼要修n-1條路才能把它們連起來
       total=n-1;
       //每一個點互相獨立，自成一個集合，從1編號到n //因此每一個點的上級都是本身
       for(i=1;i<=n;i++) { pre[i ]=i; }                //共有m條路
       scanf("%d",&m);
       while(m--)
       { //下面這段代碼，其實就是join函數，只是稍做改動以適應題目要求
           //每讀入一條路，看它的端點p1，p2是否已經在一個連通分支裏了
           scanf("%d %d",&p1,&p2);
           f1=find(p1);
           f2=find(p2);
               //若是是不連通的，那麼把這兩個分支連起來
               //分支的總數就減小了1，還需建的路也就減了1
           if(f1!=f2)
            {
               pre[f2 ]=f1;
               total--;
            }
           //若是兩點已經連通了，那麼這條路只是在圖上增長了一個環 //對連通性沒有任何影響，無視掉
      }
//最後輸出還要修的路條數
       printf("%d\n",total);
   }
   return 0;
}

關於動態連通性

咱們看一張圖來了解一下什麼是動態連通性：

假設咱們輸入了一組整數對，即上圖中的(4, 3) (3, 8)等等，每對整數表明這兩個points/sites是連通的。那麼隨着數據的不斷輸入，整個圖的連通性也會發生變化，從上圖中能夠很清晰的發現這一點。同時，對於已經處於連通狀態的points/sites，直接忽略，好比上圖中的(8, 9)。

動態連通性的應用場景：

網絡鏈接判斷：

若是每一個pair中的兩個整數分別表明一個網絡節點，那麼該pair就是用來表示這兩個節點是須要連通的。那麼爲全部的pairs創建了動態連通圖後，就可以儘量少的減小布線的須要，由於已經連通的兩個節點會被直接忽略掉。

變量名等同性(相似於指針的概念)：

在程序中，能夠聲明多個引用來指向同一對象，這個時候就能夠經過爲程序中聲明的引用和實際對象創建動態連通圖來判斷哪些引用其實是指向同一對象。

對問題建模：

在對問題進行建模的時候，咱們應該儘可能想清楚須要解決的問題是什麼。由於模型中選擇的數據結構和算法顯然會根據問題的不一樣而不一樣，就動態連通性這個場景而言，咱們須要解決的問題多是：

給出兩個節點，判斷它們是否連通，若是連通，不須要給出具體的路徑
給出兩個節點，判斷它們是否連通，若是連通，須要給出具體的路徑

就上面兩種問題而言，雖然只有是否可以給出具體路徑的區別，可是這個區別致使了選擇算法的不一樣，本文主要介紹的是第一種狀況，即不須要給出具體路徑的Union-Find算法，而第二種狀況可使用基於DFS的算法。

建模思路：

最簡單而直觀的假設是，對於連通的全部節點，咱們能夠認爲它們屬於一個組，所以不連通的節點必然就屬於不一樣的組。隨着Pair的輸入，咱們須要首先判斷輸入的兩個節點是否連通。如何判斷呢？按照上面的假設，咱們能夠經過判斷它們屬於的組，而後看看這兩個組是否相同，若是相同，那麼這兩個節點連通，反之不連通。爲簡單起見，咱們將全部的節點以整數表示，即對N個節點使用0到N-1的整數表示。而在處理輸入的Pair以前，每一個節點必然都是孤立的，即他們分屬於不一樣的組，可使用數組來表示這一層關係，數組的index是節點的整數表示，而相應的值就是該節點的組號了。該數組能夠初始化爲：

for(int i = 0; i < size; i++)  
    id[i] = i;

即對於節點i，它的組號也是i。

初始化完畢以後，對該動態連通圖有幾種可能的操做：

查詢節點屬於的組

數組對應位置的值即爲組號

判斷兩個節點是否屬於同一個組

分別獲得兩個節點的組號，而後判斷組號是否相等

鏈接兩個節點，使之屬於同一個組

分別獲得兩個節點的組號，組號相同時操做結束，不一樣時，將其中的一個節點的組號換成另外一個節點的組號

獲取組的數目

初始化爲節點的數目，而後每次成功鏈接兩個節點以後，遞減1

API

咱們能夠設計相應的API：

注意其中使用整數來表示節點，若是須要使用其餘的數據類型表示節點，好比使用字符串，那麼能夠用哈希表來進行映射，即將String映射成這裏須要的Integer類型。

分析以上的API，方法connected和union都依賴於find，connected對兩個參數調用兩次find方法，而union在真正執行union以前也須要判斷是否連通，這又是兩次調用find方法。所以咱們須要把find方法的實現設計的儘量的高效。因此就有了下面的Quick-Find實現。

Quick-Find 算法：

 1 public class UF
 2 {
 3     private int[] id; // access to component id (site indexed)
 4     private int count; // number of components
 5     public UF(int N)
 6     {
 7         // Initialize component id array.
 8         count = N;
 9         id = new int[N];
10         for (int i = 0; i < N; i++)
11             id[i] = i;
12     }
13     public int count()
14     { return count; }
15     public boolean connected(int p, int q)
16     { return find(p) == find(q); }
17     public int find(int p)
18     { return id[p]; }
19     public void union(int p, int q)
20     { 
21         // 得到p和q的組號
22         int pID = find(p);
23         int qID = find(q);
24         // 若是兩個組號相等，直接返回
25         if (pID == qID) return;
26         // 遍歷一次，改變組號使他們屬於一個組
27         for (int i = 0; i < id.length; i++)
28             if (id[i] == pID) id[i] = qID;
29         count--;
30     }
31 }

舉個例子，好比輸入的Pair是(5， 9)，那麼首先經過find方法發現它們的組號並不相同，而後在union的時候經過一次遍歷，將組號1都改爲8。固然，由8改爲1也是能夠的，保證操做時都使用一種規則就行。

上述代碼的find方法十分高效，由於僅僅須要一次數組讀取操做就可以找到該節點的組號，可是問題隨之而來，對於須要添加新路徑的狀況，就涉及到對於組號的修改，由於並不能肯定哪些節點的組號須要被修改，所以就必須對整個數組進行遍歷，找到須要修改的節點，逐一修改，這一下每次添加新路徑帶來的複雜度就是線性關係了，若是要添加的新路徑的數量是M，節點數量是N，那麼最後的時間複雜度就是MN，顯然是一個平方階的複雜度，對於大規模的數據而言，平方階的算法是存在問題的，這種狀況下，每次添加新路徑就是「牽一髮而動全身」，想要解決這個問題，關鍵就是要提升union方法的效率，讓它再也不須要遍歷整個數組。

Quick-Union 算法：

考慮一下，爲何以上的解法會形成「牽一髮而動全身」？由於每一個節點所屬的組號都是單獨記錄，各自爲政的，沒有將它們以更好的方式組織起來，當涉及到修改的時候，除了逐一通知、修改，別無他法。因此如今的問題就變成了，如何將節點以更好的方式組織起來，組織的方式有不少種，可是最直觀的仍是將組號相同的節點組織在一塊兒，想一想所學的數據結構，什麼樣子的數據結構可以將一些節點給組織起來？常見的就是鏈表，圖，樹，什麼的了。可是哪一種結構對於查找和修改的效率最高？毫無疑問是樹，所以考慮如何將節點和組的關係以樹的形式表現出來。

若是不改變底層數據結構，即不改變使用數組的表示方法的話。能夠採用parent-link的方式將節點組織起來，舉例而言，id[p]的值就是p節點的父節點的序號，若是p是樹根的話，id[p]的值就是p，所以最後通過若干次查找，一個節點老是可以找到它的根節點，即知足id[root] = root的節點也就是組的根節點了，而後就可使用根節點的序號來表示組號。因此在處理一個pair的時候，將首先找到pair中每個節點的組號(即它們所在樹的根節點的序號)，若是屬於不一樣的組的話，就將其中一個根節點的父節點設置爲另一個根節點，至關於將一顆獨立的樹編程另外一顆獨立的樹的子樹。直觀的過程以下圖所示。可是這個時候又引入了問題。

在實現上，和以前的Quick-Find只有find和union兩個方法有所不一樣：

 1 private int find(int p)
 2 { 
 3     // 尋找p節點所在組的根節點，根節點具備性質id[root] = root
 4     while (p != id[p]) p = id[p];
 5     return p;
 6 }
 7 public void union(int p, int q)
 8 { 
 9     // Give p and q the same root.
10     int pRoot = find(p);
11     int qRoot = find(q);
12     if (pRoot == qRoot) 
13         return;
14     id[pRoot] = qRoot;    // 將一顆樹(即一個組)變成另一課樹(即一個組)的子樹
15     count--;
16 }

樹這種數據結構容易出現極端狀況，由於在建樹的過程當中，樹的最終形態嚴重依賴於輸入數據自己的性質，好比數據是否排序，是否隨機分佈等等。好比在輸入數據是有序的狀況下，構造的BST會退化成一個鏈表。在咱們這個問題中，也是會出現的極端狀況的，以下圖所示。

爲了克服這個問題，BST能夠演變成爲紅黑樹或者AVL樹等等。

然而，在咱們考慮的這個應用場景中，每對節點之間是不具有可比性的。所以須要想其它的辦法。在沒有什麼思路的時候，多看看相應的代碼可能會有一些啓發，考慮一下Quick-Union算法中的union方法實現：

 1 public void union(int p, int q)
 2 { 
 3     // Give p and q the same root.
 4     int pRoot = find(p);
 5     int qRoot = find(q);
 6     if (pRoot == qRoot) 
 7         return;
 8     id[pRoot] = qRoot;  // 將一顆樹(即一個組)變成另一課樹(即一個組)的子樹
 9     count--;
10 }

上面 id[pRoot] = qRoot 這行代碼看上去彷佛不太對勁。由於這也屬於一種「硬編碼」，這樣實現是基於一個約定，即p所在的樹老是會被做爲q所在樹的子樹，從而實現兩顆獨立的樹的融合。那麼這樣的約定是否是老是合理的呢？顯然不是，好比p所在的樹的規模比q所在的樹的規模大的多時，p和q結合以後造成的樹就是十分不和諧的一頭輕一頭重的」畸形樹「了。

因此咱們應該考慮樹的大小，而後再來決定究竟是調用：

id[pRoot] = qRoot 或者是 id[qRoot] = pRoot

即老是size小的樹做爲子樹和size大的樹進行合併。這樣就可以儘可能的保持整棵樹的平衡。

因此如今的問題就變成了：樹的大小該如何肯定？

咱們回到最初的情形，即每一個節點最一開始都是屬於一個獨立的組，經過下面的代碼進行初始化：

for (int i = 0; i < N; i++)  
    id[i] = i;    // 每一個節點的組號就是該節點的序號

以此類推，在初始狀況下，每一個組的大小都是1，由於只含有一個節點，因此咱們可使用額外的一個數組來維護每一個組的大小，對該數組的初始化也很直觀：

    for (int i = 0; i < N; i++)  
        sz[i] = 1;    // 初始狀況下，每一個組的大小都是1

而在進行合併的時候，會首先判斷待合併的兩棵樹的大小，而後按照上面圖中的思想進行合併，實現代碼：

 1 public void union(int p, int q)
 2 {
 3     int i = find(p);
 4     int j = find(q);
 5     if (i == j) return;
 6     // 將小樹做爲大樹的子樹
 7     if (sz[i] < sz[j]) { id[i] = j; sz[j] += sz[i]; }
 8     else { id[j] = i; sz[i] += sz[j]; }
 9     count--;
10 }

Quick-Union 和 Weighted Quick-Union 的比較：

能夠發現，經過sz數組決定如何對兩棵樹進行合併以後，最後獲得的樹的高度大幅度減少了。這是十分有意義的，由於在Quick-Union算法中的任何操做，都不可避免的須要調用find方法，而該方法的執行效率依賴於樹的高度。樹的高度減少了，find方法的效率就增長了，從而也就增長了整個Quick-Union算法的效率。

上圖其實還能夠給咱們一些啓示，即對於Quick-Union算法而言，節點組織的理想狀況應該是一顆十分扁平的樹，全部的孩子節點應該都在height爲1的地方，即全部的孩子都直接鏈接到根節點。這樣的組織結構可以保證find操做的最高效率。

那麼如何構造這種理想結構呢？

在find方法的執行過程當中，不是須要進行一個while循環找到根節點嘛？若是保存全部路過的中間節點到一個數組中，而後在while循環結束以後，將這些中間節點的父節點指向根節點，不就好了麼？可是這個方法也有問題，由於find操做的頻繁性，會形成頻繁生成中間節點數組，相應的分配銷燬的時間天然就上升了。那麼有沒有更好的方法呢？仍是有的，即將節點的父節點指向該節點的爺爺節點，這一點很巧妙，十分方便且有效，至關於在尋找根節點的同時，對路徑進行了壓縮，使整個樹結構扁平化。相應的實現以下，實際上只須要添加一行代碼：

 1     private int find(int p)  
 2     {  
 3         while (p != id[p])  
 4         {  
 5             // 將p節點的父節點設置爲它的爺爺節點  
 6             id[p] = id[id[p]];  
 7             p = id[p];  
 8         }  
 9         return p;  
10     }

至此，動態連通性相關的Union-Find算法基本上就介紹完了，從容易想到的Quick-Find到相對複雜可是更加高效的Quick-Union，而後到對Quick-Union的幾項改進，讓咱們的算法的效率不斷的提升。

這幾種算法的時間複雜度以下所示：

Algorithm	Constructor	Union	Find
Quick-Find	N	N	1
Quick-Union	N	Tree height	Tree height
Weighted Quick-Union	N	lgN	lgN
Weighted Quick-Union With Path Compression	N	Very near to 1 (amortized)	Very near to 1 (amortized)