prim算法求最小生成树过程解析

一、原理

我直接贴我们课件的截图吧：

二、所需数据结构

总结起来就是一个结构体+一个二维数组+3个一维数组
1.需要一个结构体来存储边的信息，包括边的id和权重：

typedef struct line{
    int weight;
    int id;
}line;

2.用二维数组来存储这个图：

line G[maxver][maxver];

3.一个edges[maxver]数组，存放最小生成树的某个顶点，每个(i,edges[i])代表暂时不在最小生成树中的顶点i到最小生成树的某个顶点的最短弧：

int edges[maxver];

4.一个minweight[maxver]数组，存放弧的权重，每个minweight[i]代表顶点i到最小生成树的弧的长度，如果取0表示顶点i已经在最小生成树里了

int minweight[maxver];

5.一个min_tree[maxver]数组，存放最小生成树的弧的id号

int min_tree[maxver];//存放最小生成树的弧的序号

三、prim代码实现（含思路解析）

void prim(){
    //1.初始化edges数组和minweight数组
    int i,j,k;
    for(i=1;i<n;i++){
        minweight[i]=G[i][0].weight;
        edges[i]=0;
    }
    //2.把起点加入到最小生成树中
    minweight[0]=0;
    //3.然后开始找弧，需要经过n-1次查找
    for(i=1;i<n;i++){
        //3.1先从那些不在最小生成树里面的顶点开始，找它们到最小生成树之间最短的弧
        int min=inf;
        for(j=0,k=0;j<n;j++){
            if(minweight[j]!=0&&minweight[j]<min){
                min=minweight[j];
                k=j;
            }
        }
        //3.2完成上述循环后，就找到了第一条最短弧，先把k加入到最小生成树中
        minweight[k]=0;
        min_tree[i]=G[k][edges[k]].id;
        sum_weight+=G[k][edges[k]].weight;
        //3.3像初始化edges数组和minweight数组那样，更新这两个数组
        for(j=0;j<n;j++){
            if(minweight[j]!=0&&G[j][k].weight<minweight[j]){
                minweight[j]=G[j][k].weight;
                edges[j]=k;
            }
        }
    }
}

四、解题完整代码：

4.1 题目

【问题描述】

学校的主要办公科研楼有新主楼、逸夫楼、如心楼、办公楼、图书馆、主楼、一号楼等等;。北航网络中心计划要给相关建筑物间铺设光缆进行网络连通，请给出用料最少的铺设方案。

编写程序输入一个办公区域分布图及建筑物之间的距离，计算出用料最少的铺设方案（只有一组最优解，不用考虑多组解)。要求采用Prim或Kruskal算法实现。

<o:p></o:p>

【输入形式】

办公区域分布图的顶点（即建筑物）按照自然数（0，1，2，n-1）进行编号，从标准输入中首先输入两个正整数，分别表示线路图的顶点的数目和边的数目，然后在接下的行中输入每条边的信息，每条边占一行，具体形式如下：

<n> <e>

<id> <vi> <vj> <weight><o:p></o:p>

…

即顶点vi和vj之间边的权重是weight，边的编号是id。

【输出形式】

输出铺设光缆的最小用料数，然后另起一行输出需要铺设的边的id，并且输出的id值按照升序输出。

【样例输入】

 6 10

1 0 1 600

2 0 2 100

3 0 3 500

4 1 2 500

5 2 3 500

6 1 4 300

7 2 4 600

8 2 5 400

9 3 5 200

10 4 5 600

【样例输出】

1500

2 4 6 8 9

4.2 AC代码

#include <stdio.h>
#include <malloc.h>
#define inf 66535
#define maxver 1000

int n,e;
int id,vi,vj,weight;

typedef struct line{
    int weight;
    int id;
}line;

line G[maxver][maxver];
int edges[maxver];
int minweight[maxver];
int min_tree[maxver];//存放最小生成树的弧的序号
int sum_weight;

void fill(int id,int vi,int vj,int weight){
    G[vi][vj].weight=weight;
    G[vi][vj].id=id;
    G[vj][vi].weight=weight;
    G[vj][vi].id=id;
}

void init_graph(int n){
    int i,j;
    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            G[i][j].weight=inf;
        }
    }
}

void prim(){
    //1.初始化edges数组和minweight数组
    int i,j,k;
    for(i=1;i<n;i++){
        minweight[i]=G[i][0].weight;
        edges[i]=0;
    }
    //2.把起点加入到最小生成树中
    minweight[0]=0;
    //3.然后开始找弧，需要经过n-1次查找
    for(i=1;i<n;i++){
        //3.1先从那些不在最小生成树里面的顶点开始，找它们到最小生成树之间最短的弧
        int min=inf;
        for(j=0,k=0;j<n;j++){
            if(minweight[j]!=0&&minweight[j]<min){
                min=minweight[j];
                k=j;
            }
        }
        //3.2完成上述循环后，就找到了第一条最短弧，先把k加入到最小生成树中
        minweight[k]=0;
        min_tree[i]=G[k][edges[k]].id;
        sum_weight+=G[k][edges[k]].weight;
        //3.3像初始化edges数组和minweight数组那样，更新这两个数组
        for(j=0;j<n;j++){
            if(minweight[j]!=0&&G[j][k].weight<minweight[j]){
                minweight[j]=G[j][k].weight;
                edges[j]=k;
            }
        }
    }
}

//冒泡排序，让最小生成树的边的序号升序输出
void bubble(){
    int i,j,tmp;
    for(i=n-1;i>1;i--){
        for(j=1;j<i;j++){
            if(min_tree[j]>min_tree[j+1]){
                tmp=min_tree[j];
                min_tree[j]=min_tree[j+1];
                min_tree[j+1]=tmp;
            }
        }
    }
}

int main(){
    scanf("%d%d",&n,&e);
    int i=0;
    init_graph(n);
    while(e--){
        scanf("%d%d%d%d",&id,&vi,&vj,&weight);
        fill(id,vi,vj,weight);
    }
    prim();
    printf("%d\n",sum_weight);
    bubble();
    for(i=1;i<n;i++){
        printf("%d ",min_tree[i]);
    }
    puts("");
}