C++ 最小產生樹之Prim（普裡姆）演算法__web

最小產生樹之Prim（普裡姆）演算法
最小產生樹：是在一個給定的無向圖G(V,E)中求一棵樹T，使得這棵樹擁有圖G中的所有頂點，且所有邊都是來自圖G中的邊，並且滿足整棵樹的邊權之和最小。
如上圖給出了一個圖G及其最小產生樹T，其中紅色的線即為最小產生樹的邊。最小產生樹T包含了圖G中所有的頂點，且由它們產生的樹的邊權之和為15，是所有產生樹中權值最小的。 最小產生樹有3個性質： （1）最小產生樹是樹，因此其邊數等於定點數減1，且樹內一定不會有環； （2）對給定的圖G(V,E)，其最小產生樹可以不唯一，但是其邊權之和一定是唯一的； （3）由於最小產生樹是無向圖上產生的，因此其根結點可以是這棵樹上的任意一個結點。
Prim演算法 Prim演算法是用來解決最小產生樹問題的。 基本思想：對圖G（V,E）設定集合S，存放已經被訪問的頂點，然後每次從集合V-S中選擇與集合S的最短距離最小的一個頂點（記為u），訪問並加入集合S。之後，令頂點u為中介點，最佳化所有從u能到達的頂點v與集合S之間的最短距離。這樣的操作執行n次（n為頂點個數），直到集合S已包含所有頂點。 注意：可以發現，prim演算法的思想和最短路徑中Dijkstra演算法的思想幾乎完全相同，只是在涉及最短距離時使用了集合S代替Dijkstra演算法中的起點s。 下面舉例來說明一下prim是如何求最小產生樹的。 假設從頂點V0開始， 當前集合V={V0,V1,V2,V3,V4,V5}（藍色），集合S={}（黃色），頂點V0與集合S之間的距離為0，其它均為INF（一個很大的數） ： （1）如圖(a)，選擇與集合S距離最小的頂點V0，將其加入到集合S中，並串連頂點V0與其它頂點的邊，此時 集合V={V1,V2,V3,V4,V5}，集合S={V0}； （2）如圖(b)，選擇與集合S距離最小的頂點V4， 將其加入到集合S中，並串連頂點V4與其它頂點的邊，此時 集合V={V1,V2,V3,V5}，集合S={V0,V4}； （3）如圖(c)，選擇與集合S距離最小的頂點V5， 將其加入到集合S中，並串連頂點V5與其它頂點的邊，此時 集合V={V1,V2,V3}，集合S={V0,V4,V5}； （4）如圖(d)，選擇與集合S距離最小的頂點V1， 將其加入到集合S中，並串連頂點V1與其它頂點的邊，此時 集合V={V2,V3}，集合S={V0,V1,V4.V5}； （5）如圖(e)，選擇與集合S距離最小的頂點V3， 將其加入到集合S中，並串連頂點V3與其它頂點的邊，此時 集合V={V2}，集合S={V0,V1,V3,V4,V5}； （6）如圖(f)，最後選擇頂點V2， 將其加入到集合S中，此時 集合V={}，集合S={V0,V1,V2,V3,V4,V5}； 此時集合S已經包含了所有的頂點，演算法結束。


Prim演算法流程： 對圖G（V,E）設定集合S，存放已經被訪問的頂點，然後執行n次下面的兩個步驟（n為頂點個數）： 每次從集合V-S中選擇與集合S的最短距離最小的一個頂點（記為u），訪問並加入集合S，同時把這條離集合最近的邊加入到最小產生樹中。 令頂點u為中介點，最佳化所有從u能到達的未訪問的頂點v與集合S之間的最短距離。 具體實現： prim演算法需要實現兩個關鍵的概念，即集合S的實現，頂點Vi(0<=i<=n-1)與集合S的最短距離。 集合S的實現使用一個bool型數組vis[]表示頂點是否已經被訪問，其中vis[i]=true表示頂點Vi已被訪問，vis[i]=false則表示頂點Vi未被訪問； 令int型數組d[]來存放頂點Vi與集合S的最短距離。初始時除了起點s的d[s]=0，其餘頂點賦值為一個很大的數來表示INF，即不可達。 虛擬碼如下：

//G為圖，數組d為頂點與集合S的最短距離Prim(G, d[]){     初始化;     for(迴圈n次){          u = 使d[u]最小的未被訪問的頂點的標號;          記u已被訪問;          for(從u出發能到達的所有頂點v){               if(v未被訪問 && 以u為中介點使得v與集合S的最短距離d[v]更優){                    將G[u][v]賦值給v與集合S的最短距離d[v];                }           }      }}

具體代碼實現： 鄰接矩陣版：

const int INF = 1000000000;/*Prim演算法求無向圖的最小產生樹，返回最小產生樹的邊權之和*/int Prim(int n, int s, vector<vector<int>> G, vector<bool>& vis, vector<int>& d){       /*       param       n:                                     頂點個數       s:                                     初始點       G:                                     圖的鄰接矩陣       vis:                                   標記頂點是否已被訪問       d:                                     儲存頂點與集合S的最短距離       return:                                最小產生樹的邊權之和       */       fill(d.begin(), d.end(), INF);                                        //初始化最短距離，全部為INF       d[s] = 0;                                                             //初始點與集合S的距離為0       int sum = 0;                                                          //記錄最小產生樹的邊權之和       for (int i = 0; i < n; ++i)       {              int u = -1;                                                    //u使得d[u]最小              int MIN = INF;                                                 //記錄最小的d[u]              for (int j = 0; j < n; ++j)                                    //開始尋找最小的d[u]              {                     if (vis[j] == false && d[j] < MIN)                     {                           MIN = d[j];                           u = j;                     }              }              //找不到小於INF的d[u]，則剩下的頂點與集合S不連通              if (u == -1)                     return -1;              vis[u] = true;                                                  //標記u為已訪問              sum += d[u];                                                    //將與集合S距離最小的邊加入到最小產生樹              for (int v = 0; v < n; ++v)              {                     //v未訪問 && u能夠到達v && 以u為中介點可以使v離集合S更近                     if (vis[v] == false && G[u][v] != INF && G[u][v] < d[v])                           d[v] = G[u][v];                                    //更新d[v]              }       }       return sum;                                                            //返回最小產生樹的邊權之和}

鄰接表版

const int INF = 1000000000;struct Node{       int v;       int dis;       Node(int x, int y):v(x),dis(y){}};int Prim(int n, int s, vector<vector<Node>> Adj, vector<bool>& vis, vector<int>& d){       /*       param       n：                       頂點個數       s：                       初始點       Adj：                     圖的鄰接表       vis：                     標記頂點是否被訪問       d：                       儲存起點s到其他頂點的最短距離       return:                   最小產生樹的邊權之和       */       fill(d.begin(), d.end(), INF);                                //初始化最短距離，全部為INF       d[s] = 0;                                                     //初始點與集合S的距離為0       int sum = 0;                                                  //記錄最小產生樹的邊權之和       for (int i = 0; i < n; ++i)       {              int u = -1;                                            //u使得d[u]最小              int MIN = INF;                                         //記錄最小的d[u]              for (int j = 0; j < n; ++j)                            //開始尋找最小的d[u]              {                     if (vis[j] == false && d[j] < MIN)                     {                           MIN = d[j];                           u = j;                     }              }              //找不到小於INF的d[u]，則剩下的頂點與集合S不連通              if (u == -1)                     return -1;              vis[u] = true;                                          //標記u為已訪問              sum += d[u];                                            //將與集合S距離最小的邊加入到最小產生樹              for (int j = 0; j < Adj[u].size(); ++j)              {                     int v = Adj[u][j].v;                     if (vis[v] == false && Adj[u][j].dis < d[v])                           d[v] = Adj[u][j].dis;                      //更新d[v]              }       }       return sum;}

測驗上面的例子代碼如下：

int main(){int n = 6;/*鄰接矩陣*///vector<vector<int>> G = { {0,4,INF,INF,1,2},//{4,0,6,INF,INF,3},//{INF,6,0,6,INF,5},//{INF,INF,6,0,4,5},//{1,INF,INF,4,0,3},//{2,3,5,5,3,0} };/*鄰接表*/vector<vector<Node>> Adj = { {Node(4,1),Node(5,2),Node(1,4)},{Node(0,4),Node(5,3),Node(2,6)},{Node(1,6),Node(3,6),Node(5,5)},{Node(2,6),Node(4,4),Node(5,5)},{Node(0,1),Node(5,3),Node(3,4)},{Node(0,2),Node(1,3),Node(2,5),Node(3,5),Node(4,3)} };/*for (auto x : Adj){for (auto y : x)cout << y.v<<"-"<<y.dis << "  ";cout << endl;}*/vector<bool> vis(n);vector<int> d(n);//int res = Prim(n, 0, G, vis, d);//鄰接矩陣版int res = Prim1(n, 0, Adj, vis, d);//鄰接表版cout << res << endl;return 0;}

運行結果如下：
時間複雜度為 O(n^2)，只與圖中頂點個數有關，與邊數無關，因此prim演算法適用於 稠密圖。