算法笔记_图算法专题_最小生成树

最小生成树

1.基本概念

1.定义：
（1）在给定一个无向图中求一棵树T
（2）使得这棵树拥有图G的所有顶点，边都是来自图G的边
（3）并且满足边权之和最小

2.性质：
（1）因为是树，所以边数=顶点数-1
（2）对给定的图G，其最小生成树可以不唯一，但边权之和一定是唯一的
（3）根节点可以是这棵树上的任意一个结点

2.最小生成树的求法

（1）prim算法
特点：类似于Dijkstra算法，只是在求解最短距离时，用集合S代替了起点s
伪代码：
	Prim(G,d[]){
		初始化;
		for(循环n次){
			u = 使d[u]最小的还未访问过的顶点的标号; 
			记u已被访问;
			for(从u出发能到达的所有顶点v){
				if(v从未访问&&以u为中介点使得v与集合S的最短距离d[v]更优){
					将G[u][v]赋值给v与集合S的最短距离d[v]; 
				} 
			} 
		} 
	}
	
邻接矩阵版：
	const INF = 1000000000;
	
	int n,G[MAXV][MAXV];
	int d[MAXV];//顶点和集合S的最短距离 
	bool vis[MAXV] = {false};
	
	int prim(){//默认0号为根节点，函数返回最小生成树的边权之和 
		//初始化 
		fill(d,d+MAXV,INF)
		d[0] = 0;
		int ans = 0;//存放最小生成树的边权之和 
		
		for(int i=0;i<n;i++){
			int u = -1,MIN = INF;
			for(int j=0;j<n;j++){
				if(vis[j]==false&&d[j]<MIN){
					u = j;
					MIN = d[j];
				}
			}
			//找不到小于INF的d[u]，则剩下的顶点和集合S不连通
			if(u==-1) return;
			vis[u] = true;
			ans += d[u]; //将与集合S距离最小的边加入最小生成树
			
			//更新d[v] 
			for(int v=0;v<n;v++){
				if(G[u][v]!=INF&&vis[v]==false&&G[u][v]<d[v]){
					d[v] = G[u][v];
				}
			} 
		}
		return ans;
	}
邻接表版：
	struct Node{
		int v,dis;
	};
	
	vector<Node> Adj[MAXV];
	int n;
	int d[MAXV];
	bool vis[MAXV] = {false};
	
	int prim(){
		//初始化 
		fill(d,d+MAXV,INF);
		d[0] = 0;
		int ans = 0;
		
		for(int i=0;i<n;i++){
			int u = -1,MIN = INF;
			for(int j=0;j<n;j++){
				if(vis[j]==false&&d[j]<MIN){
					u = j;
					MIN = d[j];
				}
			}
			//找不到小于INF的d[u]，则剩下的顶点和集合S不连通
			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;
	}

(2)kruskal算法
伪代码：
	int kruskal(){
		令最小生成树的边权之和为ans，最小生成树的当前边数为Num_Edge;
		将所有边按边权从小到大排序;
		for(从小到大枚举所有边){
			if(当前测试边的两个端点在不同的连通块中){
				将该测试边加入最小生成树中;
				ans += 测试边的边权;
				最小生成树的当前边数Num_Edge+1
				当边数Num_Edge等于顶点数-1时结束循环; 
			}
		} 
		return ans;
	} 
问题：
1.如何判断测试边的两个端点是否再不同的连通块中
2.如何将测试边加入最小生成树
解决：
使用并查集，查找功能解决第一个问题，合并功能解决第二个问题

实现：
	int father[N];//并查集数组 
	int findFather(int x){//并查集查询函数 
		if(father[x] = x){
			return x;
		}
		else return findFather(father[x]);
	} 
	
	struct edge{
		int u,v;//边的两个端点 
		int cost;//边权 
	}E[MAXE];
	
	bool cmp(edge a,edge b){
		return a.cost<b.cost;
	} 
	
	//n表示顶点个数，m表示图的边数，函数返回最小生成树的边权之和 
	int kruskal(int n,int m){
		int ans = 0,Num_Edge = 0;
		for(int i=1;i<=n;i++){//假设顶点范围为[1,n] 
			father[i] = i; 
		}
		
		sort(E,E+m,cmp);//按边权大小从小到大排序 
		
		for(int i=0;i<m;i++){
			int faU = findFather(E[i].u);
			int faV = findFathre(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;//无法连通时返回-1
		else return ans; 
	}