hdu 1233 还是畅通工程 最小生成树（prim算法 + kruskal算法）

还是畅通工程

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)


Problem Description

某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。

当N为0时，输入结束，该用例不被处理。

Output

对每个测试用例，在1行里输出最小的公路总长度。

Sample Input

3
1 2 1
1 3 2
2 3 4
4
1 2 1
1 3 4
1 4 1
2 3 3
2 4 2
3 4 5
0

Sample Output

3
5

Hint

Hint

Huge input, scanf is recommended.

在无向带权连通图G中，如果一个连通子树包含所有顶点，并且连接这些顶点的边权之和最小，

那么这个连通子图就是G的最小生成树。求最小生成树的一个常见算法是Prim算法。

prim算法（时间复杂度为O(n^3)):

Prim算法的基本思想是：

1）设置两个集合V和S，任意选择一个顶点作为起始顶点，将起始顶点放入集合S，其余顶点存入集合

V中；2）然后使用贪心策略，选择一条长度最短并且端点分别在S和V中边（即为最小生成树的中的一条

边），将这条边在V中的端点加入到集合S中；3）循环执行第2）步直到S中包含了所有顶点。

#include<stdio.h>
#include<string.h>
#define inf 0x3f3f3f3f
int map[100][100],s[100],vis[100];
int n,m;
int prim()
{
int i,j,t,p,min,minpos,cnt;
int ans=0;
cnt=0;  /*记录已经加入的点的个数*/
vis[1]=1; /*从第一个点开始找*/
s[cnt++]=1; /*s数组保存已经加入的点*/
while(cnt<n)  /*点还没有加入完*/
{
t=cnt;
min=inf;
for(i=0;i<t;i++)
{
p=s[i];
for(j=1;j<=n;j++)
{
if(!vis[j]&&map[p][j]<min)  /*在已经加入的点和没加入的点之间找出一条最短路，*/
{
min=map[p][j];
minpos=j; /*记录下新找到的最短路的端点*/
}
}
}
ans+=min;
s[cnt++]=minpos; /*更新已经加入的点*/
vis[minpos]=1;
}
return ans;
}
int main()
{
int u,v,w,i;
while(~scanf("%d",&n)&&n)
{
m=n*(n-1)/2;
memset(vis,0,sizeof(vis));
memset(map,inf,sizeof(map));
for(i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&w);
map[u][v]=w;
map[v][u]=w;
}
int sum=prim();
printf("%d\n",sum);
}
return 0;
}

上面的算法有三个循环，时间复杂度为O（N^3)，考虑到由于使用的是贪心策略，则每添加一个新顶点到集合S中的时候，才会改变V中每个点到S中的点的最小边的长度。因此可以用一个数组nearest
(N为顶点个数）记录在生成最小数的过程中，记录V中每个点的到S中点的最小边长，用另外一个数组adj
记录使得该边最小的对应的邻接点。那么O（N）的时间了找到最短的边，并且能在O（N)的时间里更新nearest
和adj
。因此可以得到O(N^2)的算法。

#include<stdio.h>
#include<string.h>
#define inf 0x3f3f3f3f
int map[100][100];
int n,m;
/*记当前生成树的节点集合为S,未使用的节点结合为V*/
int vis[100]; //标记某个点是否在S中
int adj[100]; //记录与S中的点最接近的点
int nearest[100];  //记录V中每个点到S中的点的最短边
int prim()
{
int i,j,min;
int ans=0;
vis[1]=1;
for(i=2;i<=n;i++)
{
nearest[i]=map[1][i];
adj[i]=1;
}
int cnt=n-1; /*记录边的条数*/
while(cnt--)
{
min=inf;
j=1;
for(i=1;i<=n;i++)
{
if(!vis[i]&&nearest[i]<min)
{
min=nearest[i];
j=i;
}
}
ans+=map[j][adj[j]];
vis[j]=1;
for(i=1;i<=n;i++)
{
if(!vis[i]&&map[i][j]<nearest[i])
{
nearest[i]=map[i][j]; /*找最短的边*/
adj[i]=j; /*找最接近的点*/
}
}
}
return ans;
}
int main()
{
int i,sum,u,v,w;
while(~scanf("%d",&n)&&n)
{
memset(vis,0,sizeof(vis));
memset(map,0,sizeof(map));
m=n*(n-1)/2;
for(i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&w);
map[u][v]=map[v][u]=w;
}
sum=prim();
printf("%d\n",sum);
}
return 0 ;
}

Kruskal算法(时间复杂度O（ElogE），E为边数）：

给定无向连同带权图G = (V,E),V = {1,2,...,n}。Kruskal算法构造G的最小生成树的基本思想是：

（1）首先将G的n个顶点看成n个孤立的连通分支。将所有的边按权从小大排序。

（2）从第一条边开始，依边权递增的顺序检查每一条边。并按照下述方法连接两个不同的连通分支：当查看到第k条边(v,w)时，如果端点v和w分别是当前两个不同的连通分支T1和T2的端点是，就用边(v,w)将T1和T2连接成一个连通分支，然后继续查看第k+1条边；如果端点v和w在当前的同一个连通分支中，就直接再查看k+1条边。这个过程一个进行到只剩下一个连通分支时为止。

此时，已构成G的一棵最小生成树。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int father[100];
int n,m;
struct point
{
int u;
int v;
int w;
}a[5000];
bool comp(point a1,point a2) /*按权值从小到大排序*/
{
return a1.w<a2.w;
}
void initial() /*并查集初始化*/
{
for(int i=0;i<=100;i++)
father[i]=i;
}
int find(int x)  /*查找根节点*/
{
if(father[x]==x)
return x;
return find(father[x]);
}
void merge(int p,int q)  /*合并两个集合*/
{
int pp=find(p);
int qq=find(q);
if(pp!=qq)
{
if(pp<qq)
father[qq]=pp;
else
father[pp]=qq;
}
}
int kruskal()
{
initial();  /*初始化*/
int ans=0;
sort(a+1,a+m+1,comp); /*排序*/
for(int i=1;i<=m;i++)
{
int x=find(a[i].u);
int y=find(a[i].v);
if(x!=y)  /*两端点不属于同一集合*/
{
ans+=a[i].w;
merge(x,y); /*合并*/
}
}
return ans;
}
int main()
{
int i,sum;
while(~scanf("%d",&n)&&n!=0)
{
m=n*(n-1)/2;
for(i=1;i<=m;i++)
scanf("%d%d%d",&a[i].u,&a[i].v,&a[i].w);
sum=kruskal();
printf("%d\n",sum);
}
return 0;
}