POJ 1258

最小生成树，模板题，直接按照模板来 就可以了。

注意：这里程序没有终止条件，就是一直是输入样例。

#include <iostream>
using namespace std;

#define MAXV 110
#define MAX 100010

int n;
int map[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV];

void Prim(){
    int i,j,k;
    k = 0;
    for(i=1;i<=n;i++){
        d[i] = map[1][i];
        vis[i] = 0;
    }
    for(i=1;i<=n;i++){
        int temp = MAX;
        for(j=1;j<=n;j++){
            if(!vis[j]&&d[j]<temp){
                temp = d[j];
                k = j;
            }
        }
        vis[k] =  1;
        for(j=1;j<=n;j++){
            if(!vis[j]&&d[j]>map[k][j])
                d[j] = map[k][j];
        }
    }
    for(i=1;i<=n;i++)
        d[1] += d[i];
    cout<<d[1]<<endl;
}

int main(){
    int i,j;
    while(cin>>n){
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                cin>>map[i][j];
        Prim();
    }
    return 0;
}

Prim算法是这样来做的： 
    首先以一个结点作为最小生成树的初始结点，然后以迭代的方式找出与最小生成树中各结点权重最小边，并加入到最小生成树中。加入之后如果产生回路则跳过这条边，选择下一个结点。当所有结点都加入到最小生成树中之后，就找出了连通图中的最小生成树了。

算法特点
    　该算法的特点是当前形成的集合T始终是一棵树。将T中U和TE分别看作红点和红边集，V-U看作蓝点集。算法的每一步均是在连接红、蓝点集的紫边中选择一条轻边扩充进T中。MST性质保证了此边是安全的。T从任意的根r开始，并逐渐生长直至U=V，即T包含了 C中所有的顶点为止。MST性质确保此时的T是G的一棵MST。因为每次添加的边是使树中的权尽可能小，因此这是一种"贪心"的策略。
算法分析
    　该算法的时间复杂度为O(n2)。与图中边数无关，该算法适合于稠密图。

Kruskal算法：

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

#define MAXV 110

int p[MAXV];

struct pro{
    int u;
    int v;
    int w;
}E[MAXV*MAXV];

bool cmp(pro a,pro b){
    return a.w<b.w;
}

int Find(int a){
    return a == p[a]?a:a=Find(p[a]);
}

int main(){
    int n;
    int i,j,value;
    while(cin>>n){
        int k = 0;
        int ans = 0;
        for(i=1;i<=n;i++)
            p[i] = i;
        for(i=1;i<=n;i++){
            for(j=1;j<=n;j++){
                cin>>value;
                if(j>=i+1){
                    E[k].u = i;
                    E[k].v = j;
                    E[k].w = value;
                    k++;
                }
            }
        }
        sort(E,E+k,cmp);
        for(i=0;i<k;i++){
            int x = Find(E[i].u);
            int y = Find(E[i].v);
            if(x!=y){
                ans += E[i].w;
                p[x] = y;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

    Kruskal算法与Prim算法的不同之处在于，Kruskal在找最小生成树结点之前，需要对所有权重边做从小到大排序。将排序好的权重边依次加入到最小生成树中，如果加入时产生回路就跳过这条边，加入下一条边。当所有结点都加入到最小生成树中之后，就找出了最小生成树。

算法描述：克鲁斯卡尔算法需要对图的边进行访问，所以克鲁斯卡尔算法的时间复杂度只和边又关系，可以证明其时间复杂度为O（ElogE）。
算法过程：
1.将图各边按照权值进行排序
2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符合条件则继续遍历图，寻找下一个最小权值的边。
3.递归重复步骤2，直到找出n-1条边为止（设图有n个结点，则最小生成树的边数应为n-1条），算法结束。得到的就是此图的最小生成树。


        克鲁斯卡尔（Kruskal）算法因为只与边相关，则适合求稀疏图的最小生成树。而prime算法因为只与顶点有关，所以适合求稠密图的最小生成树。


       无疑，Kruskal算法在效率上要比Prim算法快，因为Kruskal只需要对权重边做一次排序，而Prim算法则需要做多次排序。尽管Prim算法每次做的算法涉及的权重边不一定会涵盖连通图中的所有边，但是随着所使用的排序算法的效率的提高，Kruskal算法和Prim算法之间的差异将会清晰的显性出来。