蓝桥备赛 4.2-4.3 最小生成树（Prim堆优化 && Kruskal）

所谓最小生成树

在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边，而 w(u, v) 代表此的边权重，若存在 T 为 E 的子集且为无循环图，使得的 w(T) 最小，则此 T 为 G 的最小生成树。

换句话说，最小生成树其实是最小权重生成树的简称。注意！树是不能含有环的，最小生成树也是

此类型的题主要有两种算法：
Prim算法 和 Kruskal算法 （普里姆算法和克鲁斯卡尔算法）
数据结构：邻接表 和 结构体

Prim算法思路：（一个点一个点地找）

1、初始化最短距离min_dis[n]为INF，是否访问数组vis[ ]
2、从起点出发，记录与它相连的边，并记录权值，更新最短距离min_dis[ ]
3、在min_dis[n]中找到值最小的顶点i，设置vis[i]为true，表示已确定到该点最短距离，再遍历该点所能到达的点，更新min_dis[ ]，重复步骤3，直到循环n次（因为每一次循环都确定一个点）
注：min_dis[i] = k 表示到达i点的边中最小的权值是k

Kruskal算法思路：（一条边一条边地找）

1、将n个节点分割成n个独立的集合
2、将（ n - 1 ）条边按从小到大排序（sort即可）
3、每次取最小的一条边，判断该边的两个端点，是否分别处于两个集合，若是，则连接，若不是，则循环取下一条最短边，直到找出（n - 1）条边（这里主要采用 并查集 的方法）

传送门：P3366 【模板】最小生成树

Kruskal算法相对较简单，先看Kruskal算法
首先需要了解学习一下 并查集

1、并：用于将两个点（连通块）合并（是否连通 就是 是否可达到）
2、查：判断两个点是否在同一个集合里

参考：【算法与数据结构】—— 并查集 up讲得很有意思

查实现：

循环：
int find ( int x ) {
 while ( x != pre[x] )
  x = pre[x];
 return x;
}

递归：
int find ( int x ) {
 while ( x != pre[x] )
  p[x] = find (pre[x]);
 return pre[x];
}

并实现：

a = find(a);
b = find(b);
if(a != b)
 pre[a] = b;//把a加入b

Kruskal 完整AC代码：

#include<iostream>
#include<algorithm>
using namespace std;

int p[5005]; 
int N,M;
int a,b,c;
int sum,num;
bool flag;

struct edge{
	int x;
	int y;
	int z;
}; 

bool cmp( edge e1, edge e2)  {
	return e1.z < e2.z;
}
edge e[200005];

//并查集 
int find(int x){
	if(p[x] != x)
		p[x] = find(p[x]);
	return p[x];
} 

void Kruskal(){
	sum=0;
	num=0;
	for(int i=1;i<=M;i++){
		int p1=find(e[i].x);
		int p2=find(e[i].y);
		if(p1 == p2) continue;
		else{
			p[p1]=p2;//合并该两个连通图
			sum += e[i].z; 
			num++;
			if(num == N-1) {
				flag = true;
				return;
			}
		}
	}
	
}

int main(){
	cin>>N>>M;
	for(int i=1;i<=N;i++) p[i]=i;//分成n个不同的集合 
	
	for(int i=1;i<=M;i++){
		cin>>a>>b>>c;
		e[i].x=a;
		e[i].y=b;
		e[i].z=c;
	}
	sort(e+1,e+1+M,cmp);
	
	Kruskal();
	if(flag) cout<<sum<<endl; 
	else cout<<"orz"<<endl;
	
	return 0;
}

4.3 prim算法 直接入手 prim的堆优化
和 Dijkstra 有点像
完整AC代码：

#include<iostream>
#include<queue>
#include<vector> 
#include<cstring>
using namespace std;

#define INF 1e4+5
int min_dis[5005];
int vis[5005];
int N,M;
int x,y,z;
int start,ans;

struct edge{
	int v;
	int w;
	edge(int m,int n){
		v = m; w = n;
	}
	bool operator < (const edge &e) const {
		return w > e.w;
	}
};

priority_queue<edge> q;
vector<edge> arr[5005]; 

void prim(){
	int num=0;//加入的点的个数 
	ans=0;
	min_dis[start]=0;
	q.push(edge(start,0)); 
	while(!q.empty() && num<N){
		edge e = q.top();
		q.pop();
		int min_i = e.v; 
		if(vis[min_i]) continue;
		vis[min_i] = true;
		num++;
		ans += e.w;
		for(int i=0;i<arr[min_i].size();i++){
			int next_node = arr[min_i][i].v;
			int weight = arr[min_i][i].w;
			if(vis[next_node]) continue;
			if(weight < min_dis[next_node]){
				min_dis[next_node] = weight;
				q.push(edge(next_node,weight));
			}
		}
	}
	if(num == N) cout<<ans<<endl;
	else cout<<"orz"<<endl;
}


int main(){
	cin>>N>>M;
	memset(min_dis,INF,sizeof min_dis);
	while(M--){
		cin>>x>>y>>z;
		arr[x].push_back(edge(y,z));
		arr[y].push_back(edge(x,z));//很关键 
	}
	start = x;//随便哪个点是起点 
	
	prim();
	
	return 0;
}