算法分析与实践-作业1

求无向网的最小生成树的算法有两种：Prim和Kruskal，这两种都是生成最小生成树比较常见的方法。
先说Prim算法：
假设G=(V,E)为一网图，其中V为顶点的集合，E为边的集合。从某一顶点u1出发，选择与它关联的具有最小权值的边(u1, v)，将其顶点v加入到生成树顶点
集合U中。U用于存放G的最小生成树中的顶点，T存放G的最小生成树中的边。
令集合U的初值为U={u1} (假设构造最小生成树时，从顶点u1出发)，集合T的初值为T={ }。
以后每一步从U中选择一个顶点u（u属于U），而另一个顶点v属于V-U的边中，选取具有最小权值的边（u，v），将顶点v加入集合U中，将边（u,v）加入集合T中，如此不断重复，直到U=V时，最小生成树构造完毕，这时集合T中包含了最小生成树的所有边。

     > >  #include<iostream>
> > #include<cstring>
> > #include<algorithm> using namespace std; const int N=501,INF=0X3f3f3f3f; int n,m,g[N][N],dis[N]; bool st[N]; void prim(){
> >     memset(dis,0x3f,sizeof(dis));
> >     int res=0;
> >     for(int i=0;i<n;i++){
> >         int t=-1;
> >         for(int j=1;j<=n;j++){
> >             if(!st[j]&&(t==-1||dis[t]>dis[j]))
> >                 t=j;
> >         }
> >         if(i&&dis[t]==INF){
> >             cout<<"impossible"<<endl;
> >             return ;
> >         }
> >         if(i)res+=dis[t];
> >         for(int j=1;j<=n;j++)
> >             dis[j]=min(dis[j],g[t][j]);
> >         st[t]=true;
> >     }
> >     cout<<res<<endl; } int main(void){
> >     cin>>n>>m;
> >     memset(g,0x3f,sizeof(g));
> >     for(int i=0,a,b,c;i<m;i++){
> >         cin>>a>>b>>c;
> >         g[a][b]=g[b][a]=min(g[a][b],c);
> >     }
> >     prim();
           return 0; }

接着再来说Kruskal：先构造一个只含 n 个顶点、而边集为空的子图，把子图中各个顶点看成各棵树上的根结点，之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，即把两棵树合成一棵树，反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直到森林中只有一棵树，也即子图中含有 n-1 条边为止。

#include <stdio.h>
#include <stdlib.h>
#define Max 50
typedef struct road *Road;
typedef struct road
{
	int a , b;
	int w;
}road;
typedef struct graph *Graph;
typedef struct graph
{
	int e , n;
	Road data;
}graph;
Graph initGraph(int m , int n)
{
	Graph g = (Graph)malloc(sizeof(graph));
	g->n = m;
	g->e = n;
	g->data = (Road)malloc(sizeof(road) * (g->e));
	return g;
}
void create(Graph g)
{
	int i;
	for(i = 1 ; i <= g->e ; i++)
	{
		int x , y, w;
		scanf("%d %d %d",&x,&y,&w);
		if(x < y)
		{
			g->data[i].a = x;
			g->data[i].b = y;
		}
		else
		{
			g->data[i].a = y;
			g->data[i].b = x;
		}
		g->data[i].w = w;
	}
}
int getRoot(int v[], int x)
{
	while(v[x] != x)
	{
		x = v[x];
	}
	return x;
}
void sort(Road data, int n)
{
	int i , j;
	for(i = 1 ; i <= n-1 ; i++)
	{
		for(j = 1 ; j <= n-i ; j++)
		{
			if(data[j].w > data[j+1].w)
			{
				road t = data[j];
				data[j] = data[j+1];
				data[j+1] = t;
			}
		}
	}
}
int Kruskal(Graph g)
{
	int sum = 0;
	//并查集
	int v[Max];
	int i;
	//init
	for(i = 1 ; i <= g->n ; i++)
	{
		v[i] = i;
	}
	sort(g->data , g->e);
	//main
	for(i = 1 ; i <= g->e ; i++)
	{
		int a , b;
		a = getRoot(v,g->data[i].a);
		b = getRoot(v,g->data[i].b);
		if(a != b)
		{
			v[a] = b;
			sum += g->data[i].w;
		}
	}
	return sum;
}
int main()
{
	int m , n , id = 1;
	while(scanf("%d %d",&m,&n) != EOF)
	{
		int r , i;
		Graph g = initGraph(m,n);
		create(g);
		r = Kruskal(g);
		printf("Case %d:%d\n",id++,r);
		free(g);
	}
	return 0;
}