Prim（普利姆）演算法

1.概覽

普里姆演算法（Prim演算法），圖論中的一種演算法，可在加權連通圖裡搜尋最小生成樹。意即由此演算法搜尋到的邊子集所構成的樹中，不但包括了連通圖裡的所有頂點（英語：Vertex (graph theory)），且其所有邊的權值之和亦為最小。該演算法於1930年由捷克數學家沃伊捷赫·亞爾尼克（英語：Vojtěch Jarník）發現；並在1957年由美國電腦科學家羅伯特·普里姆（英語：Robert C. Prim）獨立發現；1959年，艾茲格·迪科斯徹再次發現了該演算法。因此，在某些場合，普里姆演算法又被稱為DJP演算法、亞爾尼克演算法或普里姆－亞爾尼克演算法。

2.演算法簡單描述

1).輸入：一個加權連通圖，其中頂點集合為V，邊集合為E；

2).初始化：V_new = {x}，其中x為集合V中的任一節點（起始點），E_new = {},為空；

3).重複下列操作，直到V_new = V：

a.在集合E中選取權值最小的邊<u, v>，其中u為集合V_new中的元素，而v不在V_new集合當中，並且v∈V（如果存在有多條滿足前述條件即具有相同權值的邊，則可任意選取其中之一）；

b.將v加入集合V_new中，將<u, v>邊加入集合E_new中；

4).輸出：使用集合V_new和E_new來描述所得到的最小生成樹。

下面對演算法的圖例描述

圖例	說明	不可選	可選	已選（Vnew）
	此為原始的加權連通圖。每條邊一側的數字代表其權值。	-	-	-
	頂點D被任意選為起始點。頂點A、B、E和F通過單條邊與D相連。A是距離D最近的頂點，因此將A及對應邊AD以高亮表示。	C, G	A, B, E, F	D
	下一個頂點為距離D或A最近的頂點。B距D為9，距A為7，E為15，F為6。因此，F距D或A最近，因此將頂點F與相應邊DF以高亮表示。	C, G	B, E, F	A, D
	演算法繼續重複上面的步驟。距離A為7的頂點B被高亮表示。	C	B, E, G	A, D, F
	在當前情況下，可以在C 、E與G間進行選擇。C距B為8，E距B為7，G距F為11。E最近，因此將頂點E與相應邊BE高亮表示。	無	C, E, G	A, D, F, B
	這裡，可供選擇的頂點只有C和G。C距E為5，G距E為9，故選取C，並與邊EC一同高亮表示。	無	C, G	A, D, F, B, E
	頂點G是唯一剩下的頂點，它距F為11，距E為9，E最近，故高亮表示G及相應邊EG。	無	G	A, D, F, B, E, C
	現在，所有頂點均已被選取，圖中綠色部分即為連通圖的最小生成樹。在此例中，最小生成樹的權值之和為39。	無	無	A, D, F, B, E, C, G

3.簡單證明prim演算法

反證法：假設prim生成的不是最小生成樹

1).設prim生成的樹為G₀

2).假設存在G_min使得cost(G_min)<cost(G₀)   則在G_min中存在<u,v>不屬於G₀

3).將<u,v>加入G₀中可得一個環，且<u,v>不是該環的最長邊(這是因為<u,v>∈G_min)

4).這與prim每次生成最短邊矛盾

5).故假設不成立，命題得證.

 4.演算法程式碼實現

#define MAX  100000
#define VNUM  10+1                                             //這裡沒有ID為0的點,so id號範圍1~10

int edge[VNUM][VNUM]={/*輸入的鄰接矩陣*/};
int lowcost[VNUM]={0};                                         //記錄Vnew中每個點到V中鄰接點的最短邊
int addvnew[VNUM];                                             //標記某點是否加入Vnew
int adjecent[VNUM]={0};                                        //記錄V中與Vnew最鄰近的點


void prim(int start)
{
     int sumweight=0;
     int i,j,k=0;

     for(i=1;i<VNUM;i++)                                      //頂點是從1開始
     {
        lowcost[i]=edge[start][i];
        addvnew[i]=-1;                                         //將所有點至於Vnew之外,V之內，這裡只要對應的為-1，就表示在Vnew之外
     }

     addvnew[start]=0;                                        //將起始點start加入Vnew
     adjecent[start]=start;
                                                 
     for(i=1;i<VNUM-1;i++)                                        
     {
        int min=MAX;
        int v=-1;
        for(j=1;j<VNUM;j++)                                      
        {
            if(addvnew[j]!=-1&&lowcost[j]<min)                 //在Vnew之外尋找最短路徑
            {
                min=lowcost[j];
                v=j;
            }
        }
        if(v!=-1)
        {
            printf("%d %d %d\n",adjecent[v],v,lowcost[v]);
            addvnew[v]=0;                                      //將v加Vnew中

            sumweight+=lowcost[v];                             //計算路徑長度之和
            for(j=1;j<VNUM;j++)
            {
                if(addvnew[j]==-1&&edge[v][j]<lowcost[j])      
                {
                    lowcost[j]=edge[v][j];                     //此時v點加入Vnew 需要更新lowcost
                    adjecent[j]=v;                             
                }
            }
        }
    }
    printf("the minmum weight is %d",sumweight);
}

Kruskal（克魯斯卡爾）演算法

1.概覽

Kruskal演算法是一種用來尋找最小生成樹的演算法，由Joseph Kruskal在1956年發表。用來解決同樣問題的還有Prim演算法和Boruvka演算法等。三種演算法都是貪婪演算法的應用。和Boruvka演算法不同的地方是，Kruskal演算法在圖中存在相同權值的邊時也有效。

2.演算法簡單描述

1).記Graph中有v個頂點，e個邊

2).新建圖Graph_new，Graph_new中擁有原圖中相同的e個頂點，但沒有邊

3).將原圖Graph中所有e個邊按權值從小到大排序

4).迴圈：從權值最小的邊開始遍歷每條邊 直至圖Graph中所有的節點都在同一個連通分量中

                if 這條邊連線的兩個節點於圖Graph_new中不在同一個連通分量中

                                         新增這條邊到圖Graph_new中

圖例描述：

首先第一步，我們有一張圖Graph，有若干點和邊 

將所有的邊的長度排序，用排序的結果作為我們選擇邊的依據。這裡再次體現了貪心演算法的思想。資源排序，對區域性最優的資源進行選擇，排序完成後，我們率先選擇了邊AD。這樣我們的圖就變成了右圖

在剩下的變中尋找。我們找到了CE。這裡邊的權重也是5

依次類推我們找到了6,7,7，即DF，AB，BE。

下面繼續選擇， BC或者EF儘管現在長度為8的邊是最小的未選擇的邊。但是現在他們已經連通了（對於BC可以通過CE,EB來連線，類似的EF可以通過EB,BA,AD,DF來接連）。所以不需要選擇他們。類似的BD也已經連通了（這裡上圖的連通線用紅色表示了）。

3.簡單證明Kruskal演算法

對圖的頂點數n做歸納，證明Kruskal演算法對任意n階圖適用。

歸納基礎：

n=1，顯然能夠找到最小生成樹。

歸納過程：

假設Kruskal演算法對n≤k階圖適用，那麼，在k+1階圖G中，我們把最短邊的兩個端點a和b做一個合併操作，即把u與v合為一個點v'，把原來接在u和v的邊都接到v'上去，這樣就能夠得到一個k階圖G'(u,v的合併是k+1少一條邊)，G'最小生成樹T'可以用Kruskal演算法得到。

我們證明T'+{<u,v>}是G的最小生成樹。

用反證法，如果T'+{<u,v>}不是最小生成樹，最小生成樹是T，即W(T)<W(T'+{<u,v>})。顯然T應該包含<u,v>，否則，可以用<u,v>加入到T中，形成一個環，刪除環上原有的任意一條邊，形成一棵更小權值的生成樹。而T-{<u,v>}，是G'的生成樹。所以W(T-{<u,v>})<=W(T')，也就是W(T)<=W(T')+W(<u,v>)=W(T'+{<u,v>})，產生了矛盾。於是假設不成立，T'+{<u,v>}是G的最小生成樹，Kruskal演算法對k+1階圖也適用。

由數學歸納法，Kruskal演算法得證。

#include<cstdio>  
#include<algorithm>    
using namespace std;    
struct Edge    
{    
    int f,t,q;    
};    
Edge s[10000];    
bool cmp(Edge a,Edge b )    
{    
    return a.q<b.q;    
}    
int pre[100];    
int Find(int p)   //並查集 找根   
{    
    while(p!=pre[p])    
    p=pre[p];    
    return p;    
}    
void Merge(int x,int y)  //   
{    
    int fx=Find(x);    
    int fy=Find(y);    
    if(fx!=fy)    
    pre[fx]=fy;    
}    
int main()    
{    
    int n,m;    
    while(scanf("%d",&n),n)    
    {    
        m=n*(n-1)/2;    
        for(int i=1;i<=n;i++)    
        {    
            pre[i]=i;    
        }    
        for(int j=0;j<m;j++)    
        {    
            scanf("%d%d%d",&s[j].f,&s[j].t,&s[j].q);    
        }    
        sort(s,s+m,cmp);  //排序   
        int sum=0;    
        for(int j=0;j<m;j++)    
        {    
            int fx=Find(s[j].f);    
            int fy=Find(s[j].t);    
            if(fx!=fy)  //在這裡判斷  
            {    
             sum=sum+s[j].q;    
             Merge(s[j].f,s[j].t);    
            }    
        }    
        printf("%d\n",sum);    
    }    
    return 0;    
}