最小生成树模块学习

最小生成树的引入

在日常生活中，通常会出现《经过全部城市的最短路》，《安装光缆的最小长度》《修路连接各个城市》等等。遇到这些问题该如何求解，最小生成树就是解决这些问题的。最小生成树有两种做法，第一种就是prim（普里姆算法），这个算法比较难理解，时间复杂度也高，使用堆优化后时间复杂度为O(mlog(n))，在用于稠密图的时候比较优秀。另外一种是Kruskal（克鲁斯卡尔算法），比较容易理解，代码也比较简洁，不过需要使用到并查集的知识点，接下来直接介绍Kruskal算法

Kruskal算法

如果有学过离散数学的对这种算法会比较清楚，在离散数学里面教过，还是重点考点，具体操作如下：

1.将所有的边取出来。

2.对边进行从小到大排序。

3.每次都取出最小的边，观察是否能够使用，这里的能够使用是表示不能与之前连起来的边组成环。如果形成了环，这个边就不能要，直到选的边数等于给定的点数减1，即是完成了最小生成树。

4.重复3。

                                                        

如图，这个就是避环法。样例设置得不怎么样，没有体现到避环，但是具体意思是表述清楚了的。接下来看题目练练手。

P1546 [USACO3.1] 最短网络 Agri-Net

P1546 [USACO3.1] 最短网络 Agri-Net

题目大意：要用最短的光纤来联通各个农场，会给出一个n，然后给出n*n的矩阵，第i行第j列表示农场i到农场j的距离为该数，当然第i个农场到他本身的距离为0，无需考虑安装光纤。

我们只需要按照上述操作一步一步写代码就行，定义一个结构体来储存农场的边的信息，u，v表示两个农场的编号，w表示两个农场的距离，将农场信息储存下来，利用sort将边长短的放在前面使用，每次成功安装一条光纤后，将两个农场放到一个集合，如果在查询到两个农场已经在一个集合了，这说明安装该路线就会形成环，就舍弃，接下来直接看代码：

#include<bits/stdc++.h>

using namespace std;
using ll = long long;

const ll N = 100 + 5,inf=1e18;
ll n,ans=0,cont=0;

int fa[N];//并查集
struct Node{
	ll u,v,w;
}g[N*N];

bool cmp(Node &a,Node &b){
	return a.w<b.w;
}

ll find(ll x){//查询祖先，不会并查集的得先去学一下，并查集并不难的
	if(fa[x]==x)return x;
	
	fa[x]=find(fa[x]);
	return fa[x];
}
void me(ll x,ll y){//合并两个点
	fa[x]=find(x);
	
	fa[fa[x]]=find(y);
}

void kru(){//Kruskal算法
	ll cot=0;
	for(int i=1;i<=cont;i++){
		ll u=find(g[i].u);
		ll v=find(g[i].v);
		if(u==v)continue;
		
		ans+=g[i].w;
		cot++;
		me(g[i].v,g[i].u);
		if(cont==n-1)break;//如果边数到了n-1则说明已经建好最小生成树了
        //这里可以判断无解情况，当遍历完所有的边后都还没到n-1,则无解
	}
}


int main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cin>>n;
	
	for(int i=1;i<=n;i++){
		fa[i]=i;
		for(int j=1;j<=n;j++){
			ll x;
			cin>>x;
			if(i==j)continue;
			g[++cont]={i,j,x};//储存边的信息
		}
	}
	sort(g+1,g+1+cont,cmp);
	kru();
	cout<<ans<<'\n';//因为题目保证会有解，所以不用关心无解情况
	return 0;
}

P1669 [USACO04DEC] Bad Cowtractors S

P1669 [USACO04DEC] Bad Cowtractors S
题目大意，和上一题一模一样，只需要修改sort的比较函数就行，将大的边放在前边选择就可以，本质上是一样的，不过该题多了一个特判有没有解的情况。

代码：

#include <bits/stdc++.h>

using namespace std;
using ll=long long;
const ll N = 1e3 + 5, M = 2e4 + 5;
const ll INF =1e8;

struct edge {
	int u;
	int v;
	int w;
} e[M];
ll f[N], cnt, m, n, ans;

bool cmp(edge x, edge y) { //根据权重排序
	return x.w > y.w;
}

int find(int x) { //查找并查集
	if (f[x] == x) {
		return x;
	} else {
		f[x] = find(f[x]); //路径压缩
		return f[x];
	}
}

void Kruskal() {
	sort(e + 1, e + m + 1, cmp);
	bool flag=false;
	for (int i = 1; i <= m; i++) {
		int u = find(e[i].u);
		int v = find(e[i].v);
		if (u == v)continue; //判断两个点是否在同一颗树,同一棵树则成环跳过
		ans += e[i].w;
		f[v] = u; //v点的父亲为u，意思为(u,v)这条边加入
		cnt++;
		if (cnt == n - 1)break; //所有的点构成构成一棵树
	}
	if(cnt!=n-1){//判断有无解
		ans=-1;
	}
}

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) { //初始化，开始时每一个点都在各自的集合
		f[i] = i;
	}
	for (int i = 1; i <= m; i++) {
		cin >> e[i].u >> e[i].v >> e[i].w;
	}
	Kruskal();
	cout << ans << '\n';
	return 0;
}

蓝桥8086 【城市规划大师】

 题目传送门
还是最小生成树问题，要求尽量减少建筑成本，又要考虑两个城市中间的矛盾，题目看起来很烦，要求太多了，又有一些城市不宜建筑公路。

思路：

代码大体都是一样的，就是多了一个城市不宜建筑公路的问题，想到这里我会不自觉想起使用map来储存不可建筑的城市，当mp[{u,v}]==true的时候我们就不能建筑，直接跳过就行，这个时候就想到了c++stl库的tuple元组，里面可以存储两个或者更多个元素。

直接上代码大家就明白了，毕竟都做了两个题了，这个题也不在话下的：

#include<bits/stdc++.h>

using namespace std;
using ll = long long;

const ll N = 1e3 + 5,inf=1e18;

int fa[N];

ll n, k, ans = 0, cont = 0;
ll x[N],y[N];
map<tuple<int, int>, bool>mp;//元组

struct Node {
	ll u,v,w;
} g[N*N];

bool cmp(Node a, Node b) {
	return a.w < b.w;
}

int find(int x) {
	if (fa[x] == x)return x;
	else {
		fa[x] = find(fa[x]);
		return fa[x];
	}

}

void me(ll x,ll y){
  fa[x]=find(x);

  fa[fa[x]]=find(y);
}

void krul() {
	ll cnt=0;
	for(int i=1;i<=cont;i++){
		if(mp[{g[i].u,g[i].v}])continue;//不宜建筑公路
		ll u=find(g[i].u);
		ll v=find(g[i].v);
		if(u==v)continue;
		ans+=g[i].w;
		cnt++;
		me(g[i].u,g[i].v);
		if(cnt==n-1)break;
	}
}

ll root(ll x,ll y,ll xx,ll yy){
	return abs(x-xx)+abs(y-yy);
}

int main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		fa[i]=i;
		cin>>x[i]>>y[i];
	}
	
	for(int i=1;i<n;i++){
		for(int j=i+1;j<=n;j++){
			g[++cont]={i,j,root(x[i],y[i],x[j],y[j])};
		}
	}
	for(int i=1;i<=k;i++){
		ll a,b;
		cin>>a>>b;
		mp[{a,b}]=mp[{b,a}]=true;
	}
	
	sort(g+1,g+1+cont,cmp);
	
	krul();

	cout << ans << '\n';

	return 0;
}

好了，学到这里最小生成树大家应该已经吃透了，今天的学习到此结束，有什么想法或者不明白的地方可以直接评论区留言或者私信告诉我，那么拜拜了吖！