最小生成树（Prime and Kruskal）

极小连通子图：这个子图是连通的，删掉其中任意一条边则不连通。
生成树：包含一个图所有的顶点的极小连通子图。
最小生成树：代价最小，所有的边权值加起来最小。
最小生成树应用举例：城市之间修路，每两个城市之间需要能够相互到达（直达或者间接到达），花费最小。
最小生成树算法：Prime算法、Kruskal算法
Prime算法：归并点，适合于稠密图
Kruskal算法：归并边，适合于稀疏图

Prime算法：
首先需要将所有的顶点划分为两个集合，不断地一个集合中的顶点划到另一个集合中，这个过程利用了一个辅助结构体closedge，建一个数组，其成员存了到已经归并的顶点集中哪一个最近，最近的权值是多少。
过程就是先把起始点放到已经归并的集合中，然后将其余点初始化，然后找到最小的点，放进去，更新closedge数组，找最小的点这个过程要有G.vexnum-1次，所以使用一个for循环，我判断一个顶点已经进入到归并完成的集合的方式是close【i】.lowcost=-1。

AC代码：☟

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

typedef struct
{
    int vexs[55];
    int arcs[55][55];
    int arcnum,vexnum;
}AMGraph;

typedef struct
{
    int adjvex;
    int lowcost;
}Closedge;

int Prim(AMGraph G,Closedge close[55])
{
    int ans=0;
    int i;
    for(i=2;i<=G.vexnum;i++)
    {
        close[i].adjvex=1;
        close[i].lowcost=G.arcs[1][i];
    }
    close[1].lowcost=-1;
    //int min=0;
    for(i=1;i<G.vexnum;i++)
    {
        int j;
        Closedge kmin;
        kmin.lowcost=9999999;
        kmin.adjvex=2;
        int num=2;
        for(j=2;j<=G.vexnum;j++)
        {
            if(close[j].lowcost>0)
            {
                if(close[j].lowcost<kmin.lowcost)
                {
                    kmin=close[j];
                    num=j;
                } 
            }
        }
        ans+=close[num].lowcost;
        close[num].lowcost=-1;
        //cout<<num<<endl;

        for(j=2;j<=G.vexnum;j++)
        {
            if(G.arcs[num][j]<close[j].lowcost)
            {
                close[j].adjvex=num;
                close[j].lowcost=G.arcs[num][j];
            }
        }
    }
    return ans;
}

int main()
{
    int p;
    long long r;
    //scanf("%d",&p);
    while(scanf("%d",&p)!=EOF&&p)
    {
        AMGraph G;
        G.vexnum=p;
        G.arcnum=r;
        //memset(G.arcs,0,sizeof(G.arcs));
        scanf("%lld",&r);
        int i,j;
        for(i=1;i<=p;i++)
        for(j=1;j<=p;j++)
            G.arcs[i][j]=99999;
        for(i=1;i<=p;i++)
            G.vexs[i]=i;
        //cout<<r<<endl;
        Closedge close[55];

        for(i=0;i<r;i++)
        {
            int s,e,value;
            scanf("%d%d%d",&s,&e,&value);

            G.arcs[s][e]=G.arcs[s][e]<value?G.arcs[s][e]:value;
            G.arcs[e][s]=G.arcs[s][e];

        }
        cout<<Prim(G,close)<<endl;  
    }
    return 0;
}

Kruskal算法：
kruskal的方法就是归并边，我认为比Prime要简单一些，将边从小到大排序，依次遍历，如果当前最小边的两个顶点未在一个连通分量中，就把这条边添加到最小生成树中，否则下一条边。
这个处理联通分量是比较耗时一个过程，刚刚翻我以前写的blog，其实是可以用拓扑排序处理的，现在在复习数据结构，就可以直接遍历一遍数组。
所以需要两个辅助结构。