最小生成樹——模板

題目

模版題很簡單；
一共有n個城市（從1開始編號），有m條路線，求出一條能連通n個城市的最小路線；

分析

首先需要找到一條能連通所有城市的路線；
其次要保證這條路徑的路程最短；

算法簡介

常用兩種算法：
Kruskal 時間複雜度爲eloge e爲總共的邊數。
1.先將各個邊的權值從小到大排序；
2.按從小到大的順序依次將邊連接的點加入到一個集合中，並利用並查集確定一個祖先節點，使其中的節點能連接在一起，確定關係；
prim 普里姆算法 時間複雜度（n^2 未被優化） （優化後，elogn）n爲節點數；
1.現將初始值賦好；
2.算法主體思想就是，從一點出發，找到與之相連的最短路徑的頂點，貪心尋找，逐漸將一個點變成兩個，三個，然後就是將這些被搜索過的點，去尋找未被搜索點的最小值；

1.kru，算法模板；

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
#include<vector>
#include<cmath>
using namespace std;
const int N=1e3;
int bin[N];                 // 並查集的標記數組，注意要初始化；
struct node{               // 結構體存邊，方便使用，排序；
    int a,b,val;
}edge[N<<2];
bool cpu(node a, node b)    // 將邊權按從小到大排序；
{
    return a.val<b.val;
}
int find1(int x)            // 並查集尋找祖先節點；這也是並查集的標準模板；
{
    if(bin[x]==x) return x;                    
    return bin[x]=find1(bin[x]);    // 遞歸尋找，並且實現路徑壓縮，減少時間複雜度；
}
int kru(int n,int m)
{
    int i,val,x,y,fx,fy,cnt=0,sum=0;
    for(i=0;i<m;i++){
        x=edge[i].a;
        y=edge[i].b;
        val=edge[i].val;
        fx=find1(x);
        fy=find1(y);
        if(fx!=fy){                  // 若找到的祖先節點不同，說明兩點還沒被連接，是新的邊；
            bin[fx]=fy;
            sum+=val;        // 將新的邊權加入總和；
            cnt++;            // 增加了一條邊；
        }
        if(cnt==n-1)           // 若邊數等於n-1說明全部連通了，跳出循環；
            break;
    }
    if(cnt==n-1)
        return sum;
    return -1;           // 若邊數不等於n-1說明不能實現全部連通；
}
int main()
{
    int n,m,i;
    scanf("%d%d",&n,&m);
    for(i=0;i<m;i++){
        scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].val);
    }
    for(i=1;i<=n;i++)          // 並查集標記數組初始化；
        bin[i]=i;
    int ans=kru(n,m);
    if(ans)
        printf("%d\n",ans);
    else
        printf("-1\n");
    return 0;
}

prim算法（未被優化）

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
const int N=200;
const int inff=0x3f3f3f3f;      // 很大的數，用於比較；
int mp[N][N],dis[N];          // mp，鄰接矩陣建邊；dis[]用於存儲最小的未被處理點的邊權；
bool p[N];                    // 標記點是否被處理過；
int prim(int n,int m)
{
    int i,j,m1,m2,ans=0;
    for(i=2;i<=m;i++){
        m1=inff;                 // m1 找到dis[]中未被處理點的最小值；
        for(j=1;j<=m;j++){
            if(p[j]&&dis[j]<=m1){
                m1=dis[j];
                m2=j;
            }
        }
        p[m2]=false;         // 找到了m2點，爲本次處理點；
        ans+=m1;
        for(j=1;j<=m;j++){
            if(p[j]&&dis[j]>mp[m2][j]){
                dis[j]=mp[m2][j];
            }
        }
    }
    if(ans>=inff)
        return 0;
    return ans;
}
int main()
{
    int n,m,i,x,y,val;
    while(scanf("%d",&n)!=EOF&&n){
        memset(mp,inff,sizeof(mp));
        memset(p,true,sizeof(p));
        memset(dis,inff,sizeof(dis));
        scanf("%d",&m);
        for(i=0;i<n;i++){
            scanf("%d%d%d",&x,&y,&val);
            mp[x][y]=mp[y][x]=val;
        }
        for(i=1;i<=m;i++){            // 注意這兒是選擇開始的點；
            if(dis[i]>mp[x][i])
                dis[i]=mp[x][i];
        }
        p[x]=false;
        int k=find1(n,m);
        if(k)
            printf("%d\n",k);
        else
            printf("-1\n");
    }
    return 0;
}

優化，算了吧，優先隊列。。。。。感覺還不如用kru 算法，清晰明瞭；