最小生成树（Kruskal和Prim算法）

关于图的几个概念定义：

• 连通图：在无向图中，若任意两个顶点vi与vj都有路径相通，则称该无向图为连通图。
• 强连通图：在有向图中，若任意两个顶点vi与vj都有路径相通，则称该有向图为强连通图。
• 连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。
• 生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。
• 最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。 
  

---

下面介绍两种求最小生成树算法

1.Kruskal算法

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。 
1. 把图中的所有边按代价从小到大排序； 
2. 把图中的n个顶点看成独立的n棵树组成的森林； 
3. 按权值从小到大选择边，所选的边连接的两个顶点ui,vi,应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。 
4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

代码实现

#include<iostream>  
#include<cstdio>  
#include<cstring>  
#include<algorithm>  
#include<vector>  
#include<map>  
using namespace std;  
#define N 50005  
int n,m,pre[N];  
map<string,int>id;  
struct ss  
{  
    int x,y,len;  
}node[N];  
bool cmp(ss a,ss b)  
{  
    return a.len<b.len;  
}  
void input()  
{  
    int k=1;  
    string s1,s2;  
    char s11[10],s22[10];  
    id.clear();  
    scanf("%d%d",&n,&m);  
    for(int i=0;i<m;i++){  
            scanf("%s%s%d",s11,s22,&node[i].len);  
            s1=s11;  
            s2=s22;  
            if(!id[s1])id[s1]=k++;  
            if(!id[s2])id[s2]=k++;  
            node[i].x=id[s1];  
            node[i].y=id[s2];  
    }  
    sort(node,node+m,cmp);  
    //for(int i=0;i<m;i++)printf("%d %d %d\n",node[i].x,node[i].y,node[i].len);  
}  
int find(int x)  
{  
    if(x!=pre[x])pre[x]=find(pre[x]);  
    return pre[x];  
}  
int kruskal(int t)  
{  
    int a,b,cnt=0,sum=0;;  
    for(int i=1;i<=n;i++)pre[i]=i;  
    for(int i=t;i<m;i++)  
    {  
        a=find(node[i].x);  
        b=find(node[i].y);  
        if(a!=b)  
        {  
            pre[b]=a;  
            cnt++;  
            sum+=node[i].len;  
            if(cnt==n-1)  
            {  
                return sum;  
            }  
        }  
    }  
    return -1;  
}  
int main()  
{  
    int T;  
    scanf("%d",&T);  
    while(T--)  
    {  
        input();  
        printf("%d\n",kruskal(0));  
    }  
  
    return 0;  
} 

2.Prim算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

1. 图的所有顶点集合为V；初始令集合u={s},v=V−u;
2. 在两个集合u,v能够组成的边中，选择一条代价最小的边(u0,v0)，加入到最小生成树中，并把v0并入到集合u中。
3. 重复上述步骤，直到最小生成树有n-1条边或者n个顶点为止。

由于不断向集合u中加点，所以最小代价边必须同步更新；

代码实现

#include <stdio.h>  
#include <stdlib.h>  
#include <iostream>  
#define N 55  
#define INF 1<<30  
using namespace std;  
int n,m,map[N][N];  
void input()  
{  
    int i,j,x,y,p,len;  
    cin>>m;  
    for(i=1; i<=n; i++)  
        for(j=1; j<=n; j++)  
            map[i][j] = INF;  
    for(i=1; i<=m; i++)  
    {  
        cin>> x >> y >> len;  
        if( map[x][y] > len )  
            map[x][y] = map[y][x] = len ;  
    }  
}  
void prim()  
{  
    int vis[N],dis[N],i;  
    for(i=1;i<=n;i++)  
    {  
        vis[i]=0;  
        dis[i]=INF;  
    }  
    int k;  
    int now=1;  
    vis[now]=1;  
    dis[now]=0;  
    for(k=1;k<=n;k++)  
    {  
        for(i=1;i<=n;i++)  
        {  
            if(!vis[i]&&map[now][i]!=INF)  
            {  
                if(dis[i]>map[now][i])dis[i]=map[now][i];  
            }  
        }  
        int min=INF;  
        for(i=1;i<=n;i++)  
        {  
            if(!vis[i]&&dis[i]<min){  
                now=i;  
                min=dis[i];  
            }  
  
        }vis[now]=1;  
    }  
    int sum=0;  
    for(i=1;i<=n;i++)  
    {  
        sum+=dis[i];  
    }  
    printf("%d\n",sum);  
}  
int main()  
{  
  //  freopen("test.in","r",stdin);  
    while( cin>>n && n )  
    {  
        input();  
        prim();  
    }  
    return 0;  
}