Prim算法

 Problem Description

设有一连通无向网，其顶点值为字符型并假设各值互不相等，采用邻接矩阵表示法存储表示，用Prim算法求出其最小生成树，要求当候选最短边集中出现多条权值相同的最短边时，优先选取编号小的顶点。

 Input

有多组测试数据，每组数据的第一行为两个整数n和e，表示n个顶点和e条边（0<n<20）；第二行为其n个顶点的值，按输入顺序进行存储；接着有e行，表示e条边的信息，每条边信息占一行，包括边所依附的顶点下标i和j，以及该边上的权值，数据之间用空格隔开。

 Output

输出其最小生成树，每组输出占多行，每两组数据之间有一空行，具体格式见样例。

 Sample Input

6 9
ABCDEF
0 1 34
0 2 46
0 5 19
1 4 12
2 3 17
2 5 25
3 4 38
3 5 25
4 5 26

 Sample Output

(A,F)19
(F,C)25
(C,D)17
(F,E)26
(E,B)12

#include <iostream>
#include <stdlib.h>
#define maxvex 20
#include<stdio.h>
using namespace std;

typedef  struct {
    int adjvex;
} ArcNode1,ArcNode[maxvex][maxvex];
typedef struct {
    ArcNode arc;
    int vertexnum,arcnum;
    char vexs[maxvex];
} Graph;
typedef struct {
    int adjvex;
    int lowcost;
} ShortEdge[maxvex];

void CreatUDG(Graph& G,int n,int e) {
    G.vertexnum=n;
    G.arcnum=e;
    for(int i=0; i<G.vertexnum; i++) {
        for(int j=0; j<G.vertexnum; j++) {
            G.arc[i][j].adjvex=999;
        }
    }
    for(int i=0; i<G.vertexnum; i++) {
        cin>>G.vexs[i];
    }
    for(int i=0; i<G.arcnum; i++) {
        int a,b,w;
        cin>>a>>b>>w;
        G.arc[a][b].adjvex=w;
        G.arc[b][a].adjvex=w;
    }
}



ShortEdge shortEdge;

void init(int v,Graph G) {
    for(int i=0; i<G.vertexnum; i++) {
        if(i!=v) {
            shortEdge[i].adjvex=v;
            shortEdge[i].lowcost=G.arc[v][i].adjvex;
        }
    }
}



int MinEdge(Graph G,int v) {
    int min=999;
    int min_i=-1;
    for(int i=0; i<G.vertexnum; i++) {
        if(shortEdge[i].lowcost>0&&shortEdge[i].lowcost<min) {
            min=shortEdge[i].lowcost;
            min_i=i;
        }

    }
    return min_i;
}

void Prim(Graph G,int v) {
    shortEdge[v].lowcost=0;
    for(int i=0; i<G.vertexnum-1; i++) {
        int k=MinEdge(G,v);
        cout<<"("<<G.vexs[shortEdge[k].adjvex]<<","<<G.vexs[k]<<")"<<shortEdge[k].lowcost<<endl;
        shortEdge[k].lowcost=0;
        for(int j=0; j<G.vertexnum; j++) {
            if(i!=k) {
                if(shortEdge[j].lowcost>G.arc[k][j].adjvex) {
                    shortEdge[j].lowcost=G.arc[k][j].adjvex;
                    shortEdge[j].adjvex=k;
                }
            }
        }
    }
}

int main() {
  
    int n,e;
    int count=0;
    while(cin>>n>>e) {
        if(count!=0) cout<<endl;
        Graph G;
        CreatUDG(G,n,e);
        init(0,G);
        Prim(G,0);
        count++;
    }
    return 0;
}