1078 最小生成树

链接：http://codevs.cn/problem/1078/

题目描述 Description

农民约翰被选为他们镇的镇长！他其中一个竞选承诺就是在镇上建立起互联网，并连接到所有的农场。当然，他需要你的帮助。 约翰已经给他的农场安排了一条高速的网络线路，他想把这条线路共享给其他农场。为了使花费最少，他想铺设最短的光纤去连接所有的农场。 你将得到一份各农场之间连接费用的列表，你必须找出能连接所有农场并所用光纤最短的方案。 每两个农场间的距离不会超过100000

输入描述 Input Description

第一行： 农场的个数，N（3<=N<=100）。

第二行..结尾: 接下来的行包含了一个N*N的矩阵,表示每个农场之间的距离。理论上，他们是N行，每行由N个用空格分隔的数组成，实际上，他们每行限制在80个字符以内，因此，某些行会紧接着另一些行。当然，对角线将会是0，因为线路从第i个农场到它本身的距离在本题中没有意义。

输出描述 Output Description

只有一个输出，是连接到每个农场的光纤的最小长度和。

样例输入 Sample Input

4

0  4  9 21

4  0  8 17

9  8  0 16

21 17 16  0

样例输出 Sample Output

28

算法分析：

这道题是典型的最小生成树模板题。

 prim算法：

#include <stdio.h>
#include<limits.h>

//Prim算法求最小生成树
const int maxn=101;  //顶点个数最大值
int Prim(int n,int dist[maxn],int map[maxn][maxn],int pre[maxn])
//n个顶点，dist[i]表示向外延伸的最短边长，map记录图信息，pre记录连接信息
{
    int total=0;
    int i,j,k;
    int min;
    bool p[maxn];//p[i]=true表示顶点i属于集合Va，反之属于集合Vb。

    for(i=2;i<=n;i++)//初始化
    {
        p[i]=false;
        dist[i]=map[1][i];
        pre[i]=1;
    }
    dist[1]=0; //从顶点1开始，把顶点1放入Va集合
    p[1]=true;

    for(i=1;i<n;i++)//循环n-1次，每次加入一个点到最小生成树的顶点集Va。
    {
        min=INT_MAX;
        k=0;
        for(j=1;j<=n;j++)//寻找属于Vb集合而且距离最近的那个点
        {
            if(!p[j]&&dist[j]<min)
            {
                min=dist[j];
                k=j;
            }
        }
        if(k==0) return -1;//假如没有点可以扩展，说明图G不连通，直接返回
        p[k]=true;
        total=total+min;
        //printf("(%d,%d,%d)
",pre[k],k,min);

        //遍历所以与顶点k邻接的、而且属于集合Vb的顶点j，更新到达j的距离以及到达j的最近的点
        for(j=1;j<=n;j++)
        {
            if(!p[j]&&map[k][j]!=INT_MAX&&map[k][j]<dist[j])
            {
                dist[j]=map[k][j];
                pre[j]=k;
            }
        }
    }
    return total;
}

int main(int argc, char *argv[])
{
    int N,map[maxn][maxn],dist[maxn],pre[maxn];
    int i,j,res;
    freopen("data.in","r",stdin);
    scanf("%d",&N);
    for(i=1;i<=N;i++)
        for(j=1;j<=N;j++)
            scanf("%d",&map[i][j]);
    res=Prim(N,dist,map,pre);
    printf("%d
",res);
    return 0;
}

 下面是另一个版本的prim算法代码：

#include<stdio.h>
#include<stdlib.h>
#define MAXV 100
#define INF 100005
void prim(int **edges,int n,int v);
int main(int argc, char *argv[])
{
    int N,**edges;
    int i,j;
    scanf("%d",&N);
    edges=(int **)malloc(sizeof(int*)*N);
    for(i=0;i<N;i++)
        edges[i]=(int *)malloc(sizeof(int)*N);
    for(i=0;i<N;i++)
        for(j=0;j<N;j++)
            scanf("%d",&edges[i][j]);
    prim(edges,N,0);
    return 0;
}
void prim(int **edges,int n,int v)
{
    int total=0;
    int lowcost[MAXV];
    // lowcost[k]=0标记k已经加入U.另外，lowcost[k]=w表示从最小生成树的点到达k节点的最短边是w 
    int min;
    int closest[MAXV],i,j,k;    //对于某个节点i∈V-U， closest[i]=v表示节点i借助某条边依附于处在U中的节点v。
    for (i=0;i<n;i++)         //给lowcost[]和closest[]置初值
    {    
        lowcost[i]=edges[v][i];
        closest[i]=v;           //closest[i]=v表示当前状态下到达i点的最合适的经过点是v 
    }
    for (i=1;i<n;i++)              //找出n-1个顶点
    {
        min=INF;
        for (j=0;j<n;j++)       //在(V-U)中找出离U最近的顶点k
            if (lowcost[j]!=0 && lowcost[j]<min) 
            {
                min=lowcost[j];
                k=j;            //k记录最近顶点的编号
            }
        //printf(" 边(%d,%d)权为:%d
",closest[k]+1,k+1,min);
        total=total+min;
        lowcost[k]=0;             //标记k已经加入U
        for (j=0;j<n;j++)       //修改数组lowcost和closest
            if (edges[k][j]!=0 && edges[k][j]<lowcost[j]) 
            {
                lowcost[j]=edges[k][j];
                closest[j]=k; //closest[j]=k表示构造最小生成树过程中，当前状态下到达j节点最优的路径是经过k节点。
            }
    }
    //printf("最小生成树权值之和：%d
",total);
    printf("%d
",total);
}

下面是kruskal算法实现的代码：

#include <stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;

//并查集
const int maxn=1010;//最大顶点个数
int UFSTree[maxn];
void initUFSTree()//初始化并查集的数组
{
    for(int i=0;i<maxn;i++) UFSTree[i]=i;
}
int find(int x)//查找x所在的团队的队长
{
    int root=x;
    while(UFSTree[root]!=root) root=UFSTree[root];

    int i=x,j;
    while(i!=root)
    {
        j=UFSTree[i];
        UFSTree[i]=root;
        i=j;
    }
    return root;
}
void merge(int x,int y)//合并x和y所在的两个团队
{
    int fx=find(x),fy=find(y);
    if(fx!=fy) UFSTree[x]=y;
}

//kruskal算法:利用前向星结构存储图
const int maxe=100010;//边的最大条数
struct node
{
    int from,to;//一条边的起点和终点
    int w;//边的权值
    int selected;//标记该条边是否已经被选择
}edge[maxe];
bool cmp(node a,node b)
{
    if(a.w!=b.w) return a.w<b.w;
    if(a.from!=b.from) return a.from<b.from;
    return a.to<b.to;
}
int kruskal(node *edge,int n,int m)
{
    int total=0;//最小生成树的权值总和
    int k=0;//记录目前为止已经合并了多少条边
    int i,x,y;
    sort(edge+1,edge+1+m,cmp);
    for(i=1;i<=m;i++)
    {
        if(k==n-1) break;//已经合并了n-1条边，最小生成树已经构造好，可以返回。
        x=find(edge[i].from);
        y=find(edge[i].to);
        if(x!=y)
        {
            merge(x,y);
            k++;
            edge[i].selected=true;
            total=total+edge[i].w;
        }
    }
    return total;
}
int main()
{
    int N,M=0;
    int i,j,temp,res;
    freopen("data.in","r",stdin);
    scanf("%d",&N);
    for(i=1;i<=N;i++)
        for(j=1;j<=N;j++)
        {
            scanf("%d",&temp);
            if(i!=j)
            {
                M++;
                edge[M].from=i;
                edge[M].to=j;
                edge[M].w=temp;
                edge[M].selected=false;
            }
        }
    initUFSTree();
    res=kruskal(edge,N,M);
    printf("%d
",res);
    return 0;
}