农场问题之Prim算法和Krukal算法对比

问题描述：

农民约翰被选为他们镇的镇长！他其中一个竞选承诺就是在镇上建立起互联网，并连接到所有的农场。当然，他需要你的帮助。约翰已经给他的农场安排了一条高速的网络线路，他想把这条线路共享给其他农场。为了使花费最少，他想铺设最短的光纤去连接所有的农场。你将得到一份各农场之间连接费用的列表，你必须找出能连接所有农场并所用光纤最短的方案。每两个农场间的距离不会超过100000 

 

输入

第一行： 农场的个数，N（3<=N<=100）。 

 

第二行..结尾: 接下来的行包含了一个N*N的矩阵,表示每个农场之间的距离。理论上，他们是N行，每行由N个用空格分隔的数组成，实际上，他们每行限制在80个字符以内，因此，某些行会紧接着另一些行。当然，对角线将会是0，因为线路从第i个农场到它本身的距离在本题中没有意义。 

 

输出

只有一个输出，是连接到每个农场的光纤的最小长度和。

 

样例输入

4

0    4   9   21

4    0   8   17

9    8   0   16

21  17  16   0

 

样例输出

28

 

 

Kruskal：

初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。

1. 把图中的所有边按代价从小到大排序；

2. 把图中的n个顶点看成独立的n棵树组成的森林；

3. 按权值从小到大选择边，所选的边连接的两个顶点ui,viui,vi,应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。

4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

 

Prim：

每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

1. 图的所有顶点集合为VV；初始令集合u={s},v=V−uu={s},v=V−u;

2. 在两个集合u,vu,v能够组成的边中，选择一条代价最小的边(u0,v0)(u0,v0)，加入到最小生成树中，并把v0v0并入到集合u中。

3. 重复上述步骤，直到最小生成树有n-1条边或者n个顶点为止。

由于不断向集合u中加点，所以最小代价边必须同步更新；需要建立一个辅助数组closedge,用来维护集合v中每个顶点与集合u中最小代价边信息

 

Kruskal：时间复杂度主要在于对边进行排序，时间复杂度为O(ElogE)    （适合顶点多边少）

Prim：上面写法的算法时间复杂度为O(V2)    （适合顶点少边）

具体代码：

Prim：

#include<stdio.h>
int m,n,sum,e[110][110],book[110],dis[110];
int inf = 99999999;
void Prim() {
    int i,j,k,min;
    for(i = 1; i <= n; i ++) {
        dis[i] = e[1][i];
        book[i] = 0;
    }
    dis[1] = 0;
    book[1] = 1;
    for(i = 1; i < n; i ++) {
        min = inf;
        for(j = 1; j <= n; j ++)
            if(book[j] == 0 && dis[j] < min)
            {
                min = dis[j];
                k = j;
            }
        sum += min;
        book[k] = 1;
        for(j = 1; j <= n; j ++)
            if(book[j] == 0 && dis[j] > e[k][j])
                dis[j] = e[k][j];
    }
}
int main()  {
    int i,j;
    while(scanf("%d",&n) != EOF) {
        sum = 0;
        for(i = 1; i <= n; i ++)
            for(j = 1; j <= n; j ++)
                scanf("%d",&e[i][j]);
        Prim();
        printf("%d\n",sum);
    }
    return 0;
}

 

Kruskal：

//Kruskal
#include<bits/stdc++.h>
using namespace std;

struct node {
    int a,b; //边的起点为a，终点为b
    int len; //边的长度
};

node edge[10005];
int father[10005];
int n,m;  //n为顶点数，m为边数

int cmp(node x, node y) { //按边长由小到大排序
    return x.len < y.len;
}

int getfather(int x) { //判断两个顶点是否同属一棵生成树
    if(x != father[x]) father[x] = getfather(father[x]);
    return father[x];
}

void kruskal() {
    int x,y;
    int k=0,cnt=0,tot=0;  //cnt统计合并次数，为n-1次时得到最小生成树 
    while(cnt < n-1) {
        k++;
        x = getfather(edge[k].a);
        y = getfather(edge[k].b);
        if(x != y) {
            father[x] = y;
            tot += edge[k].len;
            cnt++;
        }
    }
    cout << tot;
}

int main() {
    cin >> n; //农场个数
    int temp = 0;
    for(int i=1; i<=n; i++) {
        for(int j=1; j<=n; j++) {
            int t;
            cin >> t;
            if(i != j) {
                temp++;
                edge[temp].a = i;
                edge[temp].b = j;
                edge[temp].len = t;
            }
        }
    }
    for(int i=1; i<=n; i++) {
        father[i] = i;
    }
    sort(edge+1,edge+1+temp,cmp);
    kruskal();
    return 0;
}