最小生成树（HDOJ 1863）

畅通工程

http://acm.hdu.edu.cn/showproblem.php?pid=1863

1.Prim算法：

Prim算法是由一个点（最初的集合）向外延伸，找到与集合相连权值最小的边，

然后把对应顶点拉到集合里，直到所有的顶点全部在集合里为止。

Prim算法的演示如下：

http://sjjp.tjuci.edu.cn/sjjg/DataStructure/DS/web/flashhtml/prim.htm

#include <stdio.h>
const int INF=;
const int MAXV=;
int map[MAXV][MAXV];
int res;
void Prim(int map[MAXV][MAXV],int numV)
{
    int i,j,k;
    int lowcost[MAXV];
    lowcost[]=;         //顶点1已经在集合里
    for(i=;i<=numV;i++)
    {
        lowcost[i]=map[][i];    //lowcost[]里存储的是当前集合相连的所有边的权值
    }
    for(i=;i<=numV;i++)       //依次循环除1以外的其余点，把它拉集合里
    {
        int min=INF;
        k=;            //k初始化为1，是为了避免下一个循环里的k=j没执行，k为任意值，lowcost[k]数组溢出
        for(j=;j<=numV;j++)
        {
            if(lowcost[j]!=&&lowcost[j]<min)   //查找集合外与集合相连的点
            {
                min=lowcost[j];
                k=j;
            }
        }
        res+=min;
        lowcost[k]=;       //lowcost[k]=0表示顶点k被拉到集合里
        for(j=;j<=numV;j++)
        {
            if(lowcost[j]!=&&map[k][j]<lowcost[j])
            {
                lowcost[j]=map[k][j];
            }   //顶点k加入集合后，集合发生变化，更新与集合相连边的权值
        }
    }
}
int main()
{
    int n,m,i,j;
    int begin,end,w;
    while(scanf("%d%d",&n,&m)!=EOF&&n)
    {
        for(i=;i<=m;i++)
        {
            for(j=;j<=m;j++)
            {
                if(i==j)
                    map[i][j]=;
                if(i!=j)
                    map[i][j]=INF;
            }     //创建邻接矩阵
        }
        for(i=;i<=n;i++)
        {
            scanf("%d%d%d",&begin,&end,&w);
            map[begin][end]=w;
            map[end][begin]=w;
        }
        res=;
        Prim(map,m);
        if(res>INF)    //表示lowcost里还有INF，即图不连通
            printf("?\n");
        else
            printf("%d\n",res);
    }
    return ;
}

2.Kruskal算法

Kruskal算法是先将所有的边按权值从小到大排序，在依次加边，

直到加了（顶点数-1）条边。注意：加边时避免出现环。

#include <stdio.h>
#include <stdlib.h>
struct node
{
    int begin;
    int end;
    int w;
};
node edge[];
int res,count;
int cmp(const void *p1,const void *p2)
{
    return (*(node*)p1).w-(*(node*)p2).w;
}
int Find(int *parent,int f)
{
    while(parent[f]!=f)
        f=parent[f];
    return f;
}   //寻找根节点，有点类似于并查集
void Kruskal(int numV,int numE)
{
    int n,m,i;
    int parent[];
    for(i=;i<=numV;i++)
        parent[i]=i;
    for(i=;i<numE;i++)
    {
        n=Find(parent,edge[i].begin);
        m=Find(parent,edge[i].end);
        if(n!=m)
        {
            parent[n]=m;
            count++;
            res+=edge[i].w;
        }//如果一条边的两个端点的的节点相同，加上这条边后就出现环
    }
}
int main()
{
    int n,m,i;
    while(scanf("%d%d",&n,&m)!=EOF&&n)
    {
        for(i=;i<n;i++)
        {
            scanf("%d%d%d",&edge[i].begin,&edge[i].end,&edge[i].w);
        }
        qsort(edge,n,sizeof(edge[]),cmp);
        res=count=;
        Kruskal(m,n);
        if(count<m-)    //加入的边数<顶点数-1，说明图不连通
            printf("?\n");
        else
            printf("%d\n",res);
    }
    return ;
}

小结：Prim算法是基于顶点来加边，而Kruskal算法是基于边