最小生成树

Prim

算法思想比较简单，只要在集合中选择距离给定点最短即可。

const int MAXV = 1000;//最大顶点数
const int INF = 0x3fffffff;//无穷大

//邻接矩阵
int n,G[MAXV][MAXV];//n为顶点数
int d[MAXV];//顶点与集合S之间的距离
bool vis[MAXV] = {false};

intprim(){//默认0号为初始点，函数返回最小生成树边权之和 
	fill(d,d+MAXV,INF);
	d[0] = 0;//只有0号顶点到集合S的距离为0
	int ans = 0;
	for(int i=0;i<n;i++){
		int u=-1, MIN = INF;
		if(vis[i] == false && d[j]<MIN){
			u=j;
			MIN=d[j];
		}
		if(u==-1)
			return;
		vis[u] = true;
		ans+=d[u];
		for(int v=0;v<n;v++){
			if(vis[v] == false && G[u][v] != INF && G[u][v]<d[v]){
				d[v] = G[u][v];
			}	
		}
	}	
	return ans;
}

//邻接表
struct node{
	int v,dis;//v为边的目标顶点，dis为边权 
}; 
vector<node> Adj[MAXV];
int n,d[MAXV];
bool vis[MAXV] = {false};

intprim(){
	fill(d,d+MAXV,INF);
	d[0] = 0;//只有0号顶点到集合S的距离为0
	int ans = 0;
	for(int i=0;i<n;i++){
		int u=-1, MIN = INF;
		if(vis[i] == false && d[j]<MIN){
			u=j;
			MIN=d[j];
		}
		if(u==-1)
		return;
		vis[u] = true;
		ans+=d[u];
		for(int j=0;j<Adj[u].size();j++){
			int v=Adj[u][j].v;
			if(vis[v] == false && Adj[u][j].dis<d[v]){
				d[v] = Adj[u][j].dis;
			}
		}
	} 
	return ans;
}

Kruskal

借助于并查集来解决连通块问题。

struct edge{
	int u,v;//边的两个端点编号
	int cost;//边权 
}E[MAXV];
bool cmp(edge a,edge b){
	return a.cost<b.cost;
}
int father[n];//并查集数组
int findfather(int s){
} 
int kruskal(int n, int m){
	int ans=0,Num_Edge = 0;
	for(int i=1;i<=n;i++){
		father[i] = i;
	}
	sort(E,E+m,cmp);
	for(int i=0;i<m;i++){//枚举所有边 
		//查询测试边两个端点所在集合的根节点 
		int faU = findFather(E[i].u);
		int faV = findFather(E[i].v);
		if(faU!=faV){//不在一个集合 
			father[faU] = faV;
			ans+=E[i].cost;
			Num_Edge++;
			if(Num_Edge==n-1)
				break; 
		}
	}
	if(Num_Edge!=n-1)
		return -1;
	else
		return ans; 
}