最小生成树（Prim算法）

最小生成树（Prim算法）

普里姆算法（Prim算法）：

    图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，
    且其所有边的权值之和亦为最小。

    此算法采用贪心算法的思想，运行时间为O( n^2 )，适用于稠密图。

算法描述：

    1.输入：一个加权连通图，其中顶点集合为V，边集合为E；
    2.初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {}为空；
    3.重复下列操作，直到Vnew = V：
        (1).在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述；
            条件即具有相同权值的边，则可任意选取其中之一）；
        (2).将v加入集合Vnew中，将<u, v>边加入集合Enew中；
    4.输出：使用集合Vnew和Enew来描述所得到的最小生成树。

输入样例：

    6           //顶点个数
    10          //边条数
    ABCDEF      //顶点
    A B 6 
    A C 1 
    A D 5 
    B C 5 
    C D 5 
    B E 3 
    E C 6 
    C F 4 
    F D 2 
    E F 6

样例输出：

    (A,C)(C,F)(F,D)(C,B)(B,E)

具体算法如下：

#include <iostream>
#include <malloc.h>
#include <climits>
using namespace std;
#define VRType int
#define VertexType char
#define MAX_VERTEX_NUM 100

typedef struct ArcNode{
    int adjvex;
    VRType info;
    struct ArcNode *nextarc;
}ArcNode;

typedef struct VNode{
    VertexType data;
    ArcNode *firstarc;
}AdjList[MAX_VERTEX_NUM];

typedef struct{
    AdjList vertices[MAX_VERTEX_NUM];
    int vexnum, arcnum;
}ALGraph;

void CreatALGraph(ALGraph *&G)
{
    int i, t;
    char a, b;
    ArcNode *arc;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    cin>>G->vexnum>>G->arcnum;
    for(i=0; i<G->vexnum; i++){
        cin>>G->vertices[i]->data;
        G->vertices[i]->firstarc = NULL;
    }
    for(i=0; i<G->arcnum; i++){
        arc = (ArcNode *)malloc(sizeof(ArcNode));
        cin>>a;
        cin>>b;
        cin>>arc->info;
        arc->adjvex = b-'A';
        t = a-'A';
        arc->nextarc = G->vertices[t]->firstarc;
        G->vertices[t]->firstarc = arc;
    }
}

struct{
    VertexType adjvex;
    VRType lowcost;
}closedge[MAX_VERTEX_NUM];

void Prim(ALGraph *G)
{

    int i, j, k=0, min;
    for(i=0; i<G->vexnum; i++){
        closedge[i].adjvex = G->vertices[i]->data;
        closedge[i].lowcost = INT_MAX;
    }
    closedge[0].lowcost = 0;
    ArcNode *arc;
    for(i=1; i<G->vexnum; i++){
        min = INT_MAX;
        arc = G->vertices[k]->firstarc;
        while(arc){
            if((closedge[arc->adjvex].lowcost) && (arc->info < closedge[arc->adjvex].lowcost)){
                closedge[arc->adjvex].adjvex = G->vertices[k]->data;
                closedge[arc->adjvex].lowcost = arc->info;
            }
            arc = arc->nextarc;
        }
        for(j=0; j<G->vexnum; j++)
            if((closedge[j].lowcost) && (closedge[j].lowcost<min)){
                k = j;
                min = closedge[j].lowcost;
            }
        cout<<'('<<closedge[k].adjvex<<','<<G->vertices[k]->data<<')';
        closedge[k].lowcost = 0;
    }
    cout<<endl;
}

int main()
{
    ALGraph *g;
    CreatALGraph(g);
    Prim(g);
    return 0;
}