Prim算法--c++

普里姆算法（Prim算法）：
图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。

算法思路：
选择一个初始顶点，每一步找已达到顶点能达到未达到顶点的最短的一条边加入，然后更新到每个未达到顶点的最短距离，直到所有顶点都达到。

算法实现：

# include <iostream>
# include <climits>
using namespace std;

int graph[][6] = {{-1,45,28,10,INT_MAX,INT_MAX},
                  {45,-1,12,INT_MAX,21,INT_MAX},
                  {28,12,-1,17,26,INT_MAX},
                  {10,INT_MAX,17,-1,15,13},
                  {INT_MAX,21,26,15,-1,11},
                  {INT_MAX,INT_MAX,INT_MAX,13,11,-1}};

struct Edge{
    int n1;
    int n2;
    int len;
    Edge(){}
    Edge(int n1, int n2, int len):n1(n1),n2(n2),len(len){}
    bool operator< (Edge &other){return len<other.len;}
    bool operator== (Edge &other){return len==other.len;}
};

void prim(int size){
    Edge edges[size-1];
    int start = 0;
    bool active[size];

    for ( int i=0; i<size-1; ++i){
        edges[i].n1 = start;
        edges[i].n2 = (start+i+1)%(size);
        edges[i].len = graph[start][(start+i+1)%(size)];
        active[i] = 0;
    }
    active[start] = 1; //如果能访问到该点，则为1

    for ( int k=0; k<size-1; ++k){//循环size-1次，使每个点都被访问到

        Edge min_edge = edges[k];
        int min_i=k;
        for (int i=k; i<size-1; ++i)//选出到没有访问到的节点中最小的边
            if (edges[i].len < min_edge.len){
                min_edge = edges[i];
                min_i = i;
            }
        active[min_edge.n2] = 1;

        //交换i,k处数据
        Edge tmp = edges[k];
        edges[k] = edges[min_i];
        edges[min_i] = tmp;

        //更新k+1到最后
        for( int i=k+1; i<size;i++)
            if(edges[i].len>graph[min_edge.n2][edges[i].n2]){
                edges[i].len = graph[min_edge.n2][edges[i].n2];
                edges[i].n1 = min_edge.n2;
            }
    }

    //输出结果
    for (int i=0;i<size-1;i++)
        cout << edges[i].n1 << "-->" << edges[i].n2 << " : " << edges[i].len<<endl;
}
main()
{
    prim(6);
}

0-->3 : 10
3-->5 : 13
5-->4 : 11
3-->2 : 17
2-->1 : 12