最小生成树问题（——模板习题与总结）

　　首先，图论中的最小生成树问题就是给出一个大小为n*m邻接矩阵或者n个顶点m条边（包含每条边路径花费）的数据，让我们计算使得这n个顶点直接或间接联通所需要的最小花费。

　　其次，所给的数据分为稀疏图和稠密图，对于一个图，理论上n个顶点可以有n*(n-1)条边，如果该图中存在的边数m远小于n*（n-1），可以称之为稀疏图，如果该图中存在的边数m接近n*（n-1），可以称之为稠密图。

　　接下来，先总结一下prim算法。我们将图中所有的顶点分为两类：树顶点（已被选入生成树的顶点）和非树顶点（还未被选入生成树的顶点）。首先选择任意一个顶点加入生成树。接下来要找出一条边添加到生成树，这需要枚举每一个树顶点到每一个非树顶点所有的边，然后找到最短边加入到生成树。按照此方法重复n-1次，直到将所有顶点都加入到生成树中。

　　prim算法模板题：http://hihocoder.com/problemset/problem/1097

　　AC代码：

#include<stdio.h>
#include<string.h>
int e[1100][1100],book[1100],dis[1100];        // 顶点数n<=1000 
const int inf=99999999;                        
int main()
{
    int n,i,j,k,c,sum,min;
    while(scanf("%d",&n) != EOF)
    {
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                scanf("%d",&e[i][j]);        
        for(i=1;i<=n;i++)
            dis[i]=e[1][i];
        
        memset(book,0,sizeof(book));
        book[1]=1;
        c=1;
        sum=0;
        while(c < n)
        {
            min=inf;
            for(j=0,i=1;i<=n;i++)
            {
                if(!book[i] && dis[i] < min) //注意是且的关系,该点没有被访问过而且距离生成树最近 
                {
                    min=dis[i];
                    j=i;
                }
            }
            book[j]=1;                        //标记该点被访问过 
            c++;                            //计加入的顶点数 
            sum += dis[j];                    //累计花费 
            for(k=1;k<=n;k++)                //更新生成树到各各非树顶点的距离 
            {
                if(!book[k] && dis[k] > e[j][k])
                    dis[k]=e[j][k];
            }
         }
         printf("%d
",sum);
    } 
    return 0;
}

　　上述算法的时间复杂度是O（N*N），适用于顶点数较少的稠密图（因为顶点数太多，一是开不了那么大的数组，二是容易超时）。如果数组开不了那么大，又想用prim算法的话，可以使用邻接表来存储图，但是这里更推荐使用Kruskal算法，因为较容易实现，不局限于数组的大小，效率也很高。

　　再总结一下Kruskal算法，首先将边按照边的权值进行从小到大排序，每次从剩余的边中选择权值较小且边的两个顶点不在同一个集合内的边（即不会产生回路的边），加入到生成树中，直到加入了n-1条边为止。

　　Kruskal算法模板题：http://hihocoder.com/problemset/problem/1098

　　AC代码：

#include<stdio.h>
#include<string.h>
struct edge
{
    int u,v,w;
};
struct edge e[1000010];
#include<algorithm>
using namespace std;
bool cmp(struct edge x,struct edge y)
{return x.w<y.w;}
int f[100010];
int merge(int v,int u);
int getf(int v);
int main()
{
    int n,m,i,sum,c;
    while(scanf("%d%d",&n,&m) != EOF)
    {
        for(i=1;i<=m;i++)
            scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
        sort(e+1,e+m+1,cmp);
        for(i=1;i<=n;i++)                //初始化并查集 
            f[i]=i;
        sum=0;
        c=0;
        for(i=1;i<=m;i++)                //遍历每条边 
        {
            if( merge(e[i].u,e[i].v) )    //判断是否能够构成回路 
            {
                c++;
                sum += e[i].w;
            }
            if(c==n-1)
                break;
        }
        printf("%d
",sum);
    }
    return 0;
} 
int getf(int v)
{
    return f[v]==v ? v : f[v]=getf(f[v]);
}
int merge(int v,int u)
{
    int t1,t2;
    t1=getf(v);
    t2=getf(u);
    if(t1 != t2)
    {
        f[t2]=t1;                        //收录 
        return 1;                        //返回1表示不能构成回路，可以建造这条路 
    }
    return 0;                            //返回0表示能构成回路，不可以建造这条路 
}

　　上述算法的时间复杂度为O（MlogM），综合来说效率还是很高的，适用于稀疏图。

　　最后，总的来说最小生成树中Kruskal算法还是较优的，应优先使用。