算法篇：最小生成树（Kruscal&&Prim）

---

时间限制: 1 s

 空间限制: 128000 KB

 题目等级 : 白银 Silver

题目描述 Description

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

输入描述 Input Description

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

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

输出描述 Output Description

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

样例输入 Sample Input

4

0  4  9 21

4  0  8 17

9  8  0 16

21 17 16  0

样例输出 Sample Output

28

---

方法一：

/****
  最小生成树(Kruscal算法)Swordfish O(E*LogE)
****/
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
using namespace std;
struct struct_edges
{
    int bv,tv; //bv起点tV终点
    double w;//权值
};
struct_edges edges[10100];//边集
struct struct_a
{
    double x;
    double y;
};
struct_a arr_xy[101];
int point[101],n,e;  //n顶点数，e边数(注意是无向网络)
double sum;
int kruscal_f1(int point[],int v)
{
    int i=v;
    while(point[i]>0)   i=point[i];
    return i;
}
bool UDlesser(struct_edges a, struct_edges b){
	return a.w<b.w;
}
void kruscal() //只需要准备好n,e递增的边集edges[]即口J一使用
{
    int v1,v2,i,j;
    for(i=0;i<n;i++)
	point[i]=0;
    i=j=0;
    while(j<n-1&&i<e){
      v1=kruscal_f1(point,edges[i].bv);
      v2=kruscal_f1(point,edges[i].tv);
      if(v1!=v2){
          sum+= edges[i].w;   //注意sum初始为0
          point[v1]=v2;
            j++;
        }
        i++;
    }
}
int main()
{
    int i,j;
    scanf("%d",&n);
        sum=0;
        e=0;
      for(i=0;i<n;i++)
          for(j=0;j<n;j++)
            {
             cin>>edges[e].w;  
              if(i>=j)  continue;
              edges[e].bv=i;
              edges[e].tv=j;

				  e++;
            }
          sort(edges,edges+e,UDlesser);
          kruscal();
          printf("%d",(int)sum); 
}

---

方法二：

/**
最小生成树(Prim算法)
ZJU 1203 Swordfish O(N^2)
**/
#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
double sum,arr_list[101][101];
double min1;
int i, j,n;
struct struct_a{
    float x;
    float y;
};
struct_a arr_xy[101];
struct struct_b{ 
    int point;
    float lowcost;
};
struct_b closedge[101];
void prim(int n)    //prim需要准备:n顶点数arr_list[][]顶点的邻接矩阵也是从0开始计数
{
    int i,j,k;
    k=0;
    for(j=0; j<n ;j++){
      if(j!=k){
                closedge[j].point=k;
				closedge[j].lowcost=arr_list[k][j];
              }
    }
    closedge[k].lowcost=0;
    for(i=0;i<n;i++){
        min1=10000;
        for(j=0; j<n ;j++){
            if (closedge[j].lowcost!=0&&closedge[j].lowcost<min1){
                k=j;
              min1=closedge[j].lowcost;
            }
        }
      sum+=closedge[k].lowcost;   //要改成sum+=min;  sum Gp为所求值
        closedge[k].lowcost=0;
        for(j=0; j<n ;j++){
          if(arr_list[k][j]<closedge[j].lowcost){
              closedge[j].point=k;
              closedge[j].lowcost=arr_list[k][j];
            }
        }
    }
}
int main()
{
    cin>>n;
        sum=0;
        for(i=0; i<n;i++)
          for(j=0; j<n ;j++)  //得到邻接矩阵arr_list[][]
                  cin>>arr_list[i][j];
        prim(n);
		printf("%d",(int)sum);	
}

---