数据结构专题系列 基础篇-8 最小生成树

已于 2022-02-24 13:11:30 修改
阅读量909 收藏
点赞数
分类专栏： 数据结构专题系列 文章标签： 最小生成树 Prim算法 Kruskal算法 图算法 网络优化
于 2022-02-24 13:02:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41801682/article/details/123101471
版权

数据结构专题系列 基础篇-8 最小生成树

--------------------------------------------------------------------------------

题目传送门

洛谷最小生成树 普及-组
洛谷最小生成树 普及/提高-组
--------------------------------------------------------------------------------
更多详见>>

OJ题解系列 目录导航帖
--------------------------------------------------------------------------------

序

这里是数据结构专题系列 基础篇-8 最小生成树
最小生成树作为树的一个分支，在简化图的算法中有着很好的应用，能够求解出连通图的最小边权和，同样，最小生成树会有许多新的变式，在基础部分我们只介绍最大生成树这一个扩展应用
基础部分的题目都是最小生成树的模板题（很多题目代码都基本一致，只是读入输出略有差别），第一道[模板]题，我们采用Prim算法加以解决，而剩余的其他题目我们则采用Kruskal算法加以解决，两个算法的复杂度分别为 O ( V l o g V + E ) , O ( ( V + E ) l o g V ) O(VlogV+E),O((V+E)logV) O(VlogV+E),O((V+E)logV)
接下来就是题解部分了，每道算法题都标注有对应的算法标签，对于那些易错、较难或是测试点比较特殊的题目会着重标注，本章推荐的题目有：

P2916 [USACO08NOV]Cheering up the Cow G树，二叉树 + 最小生成树(变式）
P4826 [USACO15FEB]Superbull S树，二叉树 + 最小生成树（最大生成树）
其余题目模板题（适合练习）

--------------------------------------------------------------------------------

难度: 普及-

P3366 【模板】最小生成树

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题，这里用Prim算法实现

#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int g[5005][5005];
int vis[5005];
int d[5005];
long long ans = 0;

int N,M;
void Prim(int v0){
	int i,j,k,minn;
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=N;i++){
		d[i]=INF;
	}
	d[v0]=0;
	ans = 0;
	 
	for(int i=1;i<=N;i++){
		minn = INF;
		for(int j=1;j<=N;j++){
			if(vis[j]==0 && minn>d[j]){
				minn = d[j];
				k=j;
			}
		}
		vis[k]=1;
		ans+=d[k];
		
		for(int j=1;j<=N;j++){
			if(vis[j]==0 && d[j]>g[k][j]){
				d[j]=g[k][j];
			}
		}
		
	}
}
int main(){
	cin>> N >>M;
	for(int i=1;i<=N;i++){
		for(int j=1;j<=N;j++){
			g[i][j]=INF;
		}
	}
	for(int i=0;i<M;i++){
		int x,y,z;
		cin >>x >>y >> z;
		g[x][y]=min(g[x][y],z);
		g[y][x]=min(g[y][x],z);
	}
	Prim(1);
	cout << ans <<endl;
	
	return 0;
}

--------------------------------------------------------------------------------

难度: 普及/提高-

P2916 [USACO08NOV]Cheering up the Cow G

算法标签: 树，二叉树 + 最小生成树
注意点: 一道好题！考察了最小生成树的变形结构（本题采用kruskal算法）：
由题意知，每条边和每个顶点至少被访问两次，因此最小生成树的边权=2个点权+边权*2，在读入数据的时候，就要对边权进行更新，此外，我们还需要选定一个起始顶点，这个点如果是两端的端点，那么不需要再计算一次（出发，返回，一共2次），但如果是内部顶点，还需计算一次(出发+回溯+返回,一共3次)

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e4+5;
int a[maxn];
struct node{
	int u,v;
	int dis;
};
node road[10*maxn];
bool cmp(node r1,node r2){
	return r1.dis < r2.dis;
}
int father[maxn];
int findfather(int x){
	if(x == father[x]){
		return x;
	}
	int F = findfather(father[x]);
	father[x] = F;
	return F;
}
void Union(int x,int y){
	int fx = findfather(x);
	int fy = findfather(y);
	if(fx!=fy){
		father[fx] = fy;
	}
}

int main(){
	int N,P;
	scanf("%d%d",&N,&P);
	int minn = INT_MAX;
	for(int i=1;i<=N;i++){
		scanf("%d",&a[i]);
		minn = min(minn,a[i]);
	}
	for(int i=0;i<P;i++){
		scanf("%d%d%d",&road[i].u,&road[i].v,&road[i].dis);
		road[i].dis *= 2;
		road[i].dis += a[road[i].u];
		road[i].dis += a[road[i].v];
	}
	sort(road,road+P,cmp);
	for(int i=1;i<=N;i++){
		father[i] = i;
	}
	int cnt = 0;
	int ans = 0;
	for(int i=0;i<P && cnt<N-1;i++){
		int u = road[i].u;
		int v = road[i].v;
		if(findfather(u)!=findfather(v)){
			Union(u,v);
			cnt++;
			ans += road[i].dis;
		}
	}
	cout << ans+minn << endl;
	return 0;
}

P2330 [SCOI2005]繁忙的都市

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int n,m,s,t;
int prt[maxn];
typedef struct xiaoming{
	int x;
	int y;
	int z;
}xiaoming;
xiaoming a[maxn];

bool cmp(const xiaoming &x1,const xiaoming &x2){
	return x1.z<x2.z;
}
int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x] = Getfather(prt[x]);
	return prt[x];
}
void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=n;i++){
		prt[i]=i;
	}
	for(int i=1;i<=m;i++){
		f1 = Getfather(a[i].x);	
		f2 = Getfather(a[i].y);
		if(f1!=f2){
			prt[f1] = f2;
			k++;
			if(k==n-1){
				cout << a[i].z << endl;
				break;
			}
		}
	}
	
}
int main(){
	cin >> n >> m ;
	for(int i=1;i<=m;i++){
		cin >> a[i].x >> a[i].y >> a[i].z;
	}
	cout << n-1 << " ";
	sort(a+1,a+m+1,cmp);
	Kruskal();
	return 0;
}

P1396 营救

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e4*2+5;
int n,m,s,t;
int prt[maxn];
typedef struct xiaoming{
	int x;
	int y;
	int z;
}xiaoming;
xiaoming a[maxn];
bool cmp(const xiaoming &x1,const xiaoming &x2){
	return x1.z<x2.z;
}
int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x] = Getfather(prt[x]);
	return prt[x];
}
void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=n;i++){
		prt[i]=i;
	}
	for(int i=1;i<=m;i++){
		f1 = Getfather(a[i].x);	
		f2 = Getfather(a[i].y);
		if(f1!=f2){
			prt[f1] = f2;
			k++;
			if(Getfather(s)==Getfather(t)){
				cout << a[i].z << endl;
				break;
			}
		}
	}
	
}
int main(){
	cin >> n >> m >> s >> t;
	for(int i=1;i<=m;i++){
		cin >> a[i].x >> a[i].y >> a[i].z;
	}
	sort(a+1,a+m+1,cmp);
	Kruskal();
	return 0;
}

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

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int n,m=0;
long long ans = 0;
int t[105][105];
int prt[maxn];
typedef struct xiaoming{
	int x;
	int y;
	int z;
}xiaoming;
xiaoming a[maxn];

bool cmp(const xiaoming &x1,const xiaoming &x2){
	return x1.z<x2.z;
}
int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x] = Getfather(prt[x]);
	return prt[x];
}
void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=n;i++){
		prt[i]=i;
	}
	for(int i=1;i<=m;i++){
		f1 = Getfather(a[i].x);	
		f2 = Getfather(a[i].y);
		if(f1!=f2){
			ans = ans +a[i].z;
			prt[f1] = f2;
			k++;
			if(k==n-1){
				cout << ans << endl;
				break;
			}
		}
	}
	
}
int main(){
	cin >> n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			cin >> t[i][j];
		}
	}
	for(int i=1;i<=n-1;i++){
		for(int j=i+1;j<=n;j++){
			++m;
			a[m].x=i;
			a[m].y=j;
			a[m].z=t[i][j];
		}
	}
	
	sort(a+1,a+m+1,cmp);
	Kruskal();
	return 0;
}

P2872 [USACO07DEC]Building Roads S

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e6+1e3+5;
int prt[maxn];
double ans = 0.0;
typedef struct farm{
	int x;
	int y;
	double z;
}farm;
farm a[maxn];
int N,M;
int sum = 1;
bool cmp(const farm &x1,const farm &y1){
	return x1.z<y1.z;
} 
typedef struct city{
	int x;
	int y;
}city;
city c[maxn];

double dis(int x,int y){
	return (double)sqrt((double)(c[x].x-c[y].x)*(c[x].x-c[y].x)+(double)(c[x].y-c[y].y)*(c[x].y-c[y].y));
}

int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x] = Getfather(prt[x]);
	return prt[x];
}
void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=N;i++){
		prt[i]=i;
	}
	for(int i=1;i<sum;i++){
		f1 = Getfather(a[i].x);
		f2 = Getfather(a[i].y);
		if(f1!=f2){
			ans =  ans + a[i].z;
			prt[f1] = f2;
			k++;
			if(k==N-1){
				break;
			}
		}
	}
}
int main(){
	cin >> N >> M;
	for(int i=1;i<=N;i++){
		cin>> c[i].x >> c[i].y;
	}

	for(int i=1;i<N;i++){
		for(int j=i+1;j<=N;j++){
			a[sum].x = i;
			a[sum].y = j;
			a[sum++].z = dis(i,j);
		}
	}
	
	for(int i=sum;i<sum+M;i++){
		cin >> a[i].x >> a[i].y;
		a[i].z = 0;
	}
	
	sum = sum + M;
	sort(a+1,a+sum,cmp);
	Kruskal();
	printf("%.2lf\n",ans);
	
	return 0;
}

P1194 买礼物

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal + 最优选取
注意题面中的这句话：特别的，如果 K I , J = 0 K_{I,J}=0 KI,J​=0，那么表示这两样东西之间不会导致优惠,不要理解成可通过0元获取！

#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e5+5;
int a[505][505];
int father[505];
int cnt = 0;
struct node{
	int x;
	int y;
	int dis;
};
node t[maxn];
bool cmp(node t1,node t2){
	return t1.dis < t2.dis;
}
int findfather(int x){
	if(x == father[x]){
		return x;
	}
	int F = findfather(father[x]);
	father[x] = F;
	return F;
}
void Union(int x,int y){
	int fx = findfather(x);
	int fy = findfather(y);
	if(fx!=fy){
		father[fx] = fy;
	}
}
int main(){
	int A,B;
	cin >> A >> B;
	for(int i=1;i<=B;i++){
		father[i] = i;
	}
	for(int i=1;i<=B;i++){
		for(int j=1;j<=B;j++){
			scanf("%d",&a[i][j]); 
		}
	}	
	for(int i=1;i<=B-1;i++){
		for(int j=i+1;j<=B;j++){
			if(a[i][j]){
				t[cnt].x = i;
				t[cnt].y = j;
				t[cnt].dis = a[i][j];
				cnt++;	
			}
				t[cnt].x = i;
				t[cnt].y = j;
				t[cnt].dis = A;
				cnt++;
		}
	}
	sort(t,t+cnt,cmp);
	int ans = 0;
	int count = 0;
	for(int i=0;i<cnt && count<B-1;i++){
		int u = t[i].x;
		int v = t[i].y;
		if(findfather(u)!=findfather(v)){
			Union(u,v);
			count++;
			ans += t[i].dis;
		}
	}
	cout << ans + A << endl;
	return 0;
}

P1547 [USACO05MAR]Out of Hay S

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int n,m,s,t;
int prt[maxn];
typedef struct xiaoming{
	int x;
	int y;
	int z;
}xiaoming;
xiaoming a[maxn];

bool cmp(const xiaoming &x1,const xiaoming &x2){
	return x1.z<x2.z;
}
int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x] = Getfather(prt[x]);
	return prt[x];
}
void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=n;i++){
		prt[i]=i;
	}
	for(int i=1;i<=m;i++){
		f1 = Getfather(a[i].x);	
		f2 = Getfather(a[i].y);
		if(f1!=f2){
			prt[f1] = f2;
			k++;
			if(k==n-1){
				cout << a[i].z << endl;
				break;
			}
		}
	}
	
}
int main(){
	cin >> n >> m ;
	for(int i=1;i<=m;i++){
		cin >> a[i].x >> a[i].y >> a[i].z;
	}
	sort(a+1,a+m+1,cmp);
	Kruskal();
	return 0;
}

P2820 局域网

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int n,m,s,t;
long long ans = 0;
long long sum = 0;
int prt[maxn];
typedef struct xiaoming{
	int x;
	int y;
	int z;
}xiaoming;
xiaoming a[maxn];

bool cmp(const xiaoming &x1,const xiaoming &x2){
	return x1.z<x2.z;
}
int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x] = Getfather(prt[x]);
	return prt[x];
}
void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=n;i++){
		prt[i]=i;
	}
	for(int i=1;i<=m;i++){
		f1 = Getfather(a[i].x);	
		f2 = Getfather(a[i].y);
		if(f1!=f2){
			ans = ans +a[i].z;
			prt[f1] = f2;
			k++;
			if(k==n-1){
				cout << sum-ans << endl;
				break;
			}
		}
	}
	
}
int main(){
	cin >> n >> m ;
	for(int i=1;i<=m;i++){
		cin >> a[i].x >> a[i].y >> a[i].z;
		sum+=a[i].z;
	}
	sort(a+1,a+m+1,cmp);
	Kruskal();
	return 0;
}

P2504 [HAOI2006]聪明的猴子

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal + 二维坐标距离

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e6+5;
int a[505];
int father[1005];
int cnt = 0;
struct node{
	int x;
	int y;
	double dis;
};
node t[maxn];
struct input{
	int x;
	int y;
};
input in[1005];

bool cmp(node t1,node t2){
	return t1.dis < t2.dis;
}
int findfather(int x){
	if(x == father[x]){
		return x;
	}
	int F = findfather(father[x]);
	father[x] = F;
	return F;
}
void Union(int x,int y){
	int fx = findfather(x);
	int fy = findfather(y);
	if(fx!=fy){
		father[fx] = fy;
	}
}
int main(){
	int M;
	cin >> M;
	for(int i=1;i<=M;i++){
		cin >> a[i];
	}
	int N;
	cin >> N;
	for(int i=1;i<=N;i++){
		cin >> in[i].x >> in[i].y;
	}
	for(int i=1;i<=N-1;i++){
		for(int j=i+1;j<=N;j++){
			t[cnt].x = i;
			t[cnt].y = j;
			t[cnt].dis = sqrt(	(in[i].x-in[j].x)*(in[i].x-in[j].x) +
								(in[i].y-in[j].y)*(in[i].y-in[j].y)	);
			cnt++;
		}
	}
	sort(t,t+cnt,cmp);
	for(int i=1;i<=N;i++){
		father[i] = i; 
	}
	int count = 0;
	double ans = 0.0;
	for(int i=0;i<cnt && count<N-1;i++){
		int u = t[i].x;
		int v = t[i].y;
		if(findfather(u) != findfather(v)){
			Union(u,v);
			count++;
			ans = t[i].dis;
		}
	}
	int res = 0;
	for(int i=1;i<=M;i++){
		if(a[i]>=ans){
			res++;
		}
	}
	cout << res << endl;
	return 0;
}

P1991 无线通讯网

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal + 二维坐标距离

#include<bits/stdc++.h>
using namespace std;
typedef struct city{
	int x;
	int y;
	double z;
}city;
const int maxn = 1e5*2+5;
int prt[maxn];
city a[maxn];
int x[maxn];
int y[maxn];

int S,P;
double ans = 0.0;
int sum = 1;
	
double dis(int x1,int x2,int y1,int y2){
	return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}

bool cmp(const city &x,const city &y){
	return x.z < y.z;
}

int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x]=Getfather(prt[x]);
	return prt[x];
}
void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=P;i++){
		prt[i]=i;
	}
	for(int i=1;i<sum;i++){
		f1 = Getfather(a[i].x);
		f2 = Getfather(a[i].y);
		if(f1!=f2){
			ans = a[i].z;
			k++;
			prt[f1]=f2;
			if(k==P-S){
				break;
			}	
		}
	}
	
}

int main(){
	cin >> S >> P;
	for(int i=1;i<=P;i++){
		cin >> x[i] >> y[i];
	}

	for(int i=1;i<=P-1;i++){
		for(int j=i+1;j<=P;j++){
			a[sum].x=i;
			a[sum].y=j;
			a[sum].z = dis(x[i],x[j],y[i],y[j]);
			sum++;
		}
	}
	
	sort(a+1,a+sum+1,cmp);
	
	Kruskal();
	printf("%.2lf\n",ans);
	return 0;
}

P4826 [USACO15FEB]Superbull S

算法标签: 树，二叉树 + 最大生成树
注意点: 模板题 + kruskal （最大生成树）

#include<bits/stdc++.h>
using namespace std;
const int maxn = 4e6+5;
int a[2005];
int father[2005];
int cnt = 0;
struct node{
	int x;
	int y;
	int dis;
};
node t[maxn];
bool cmp(node t1,node t2){
	return t1.dis > t2.dis;
}
int findfather(int x){
	if(x == father[x]){
		return x;
	}
	int F = findfather(father[x]);
	father[x] = F;
	return F;
}
void Union(int x,int y){
	int fx = findfather(x);
	int fy = findfather(y);
	if(fx!=fy){
		father[fx] = fy;
	}
}
int main(){
	int n;
	cin >> n;
	for(int i=1;i<=n;i++){
		cin >> a[i];
	}
	for(int i=1;i<=n-1;i++){
		for(int j=i+1;j<=n;j++){
			t[cnt].x = i;
			t[cnt].y = j;
			t[cnt].dis = a[i] ^ a[j];
			cnt++;
		}
	}
	for(int i=1;i<=n;i++){
		father[i] = i;
	}
	sort(t,t+cnt,cmp);
	long long ans = 0;
	int count = 0;
	for(int i=0;i<cnt && count<n-1;i++){
		int u = t[i].x;
		int v = t[i].y;
		if(findfather(u)!=findfather(v)){
			Union(u,v);
			count++;
			ans += t[i].dis;
		}
	}
	cout << ans << endl;
	return 0;
}

P1195 口袋的天空

算法标签: 树，二叉树 + 最小生成树
注意点: 模板题 + kruskal

#include<bits/stdc++.h>
using namespace std;
int prt[1005];
int N,M,K;

typedef struct Edge{
	int x;
	int y;
	int z;
}Edge;
Edge a[10005];

bool cmp(const Edge &x,const Edge &y){
	return x.z< y.z;
}

long long ans = 0;

int Getfather(int x){
	if(prt[x]==x){
		return x;
	}
	prt[x]=Getfather(prt[x]);
	return prt[x];
}

void Kruskal(){
	int f1,f2,k;
	k=0;
	for(int i=1;i<=N;i++){
		prt[i]=i;
	}
	for(int i=1;i<=M;i++){
		f1 = Getfather(a[i].x);
		f2 = Getfather(a[i].y);
		if(f1!=f2){ 
			ans = ans + a[i].z;
			prt[f1] = f2;
			k++;
			if(k==N-K){
				break;
			}
		}
	}
}
int main(){
	
	cin >> N >> M >> K;
	if(N-M>K){
		cout << "No Answer"<<endl;
		return 0;
	}
	
	for(int i=1;i<=M;i++){
		int x,y,z;
		cin >> x >> y >> z;
		a[i].x = x;
		a[i].y = y;
		a[i].z = z;
	}
	sort(a+1,a+M+1,cmp);
	Kruskal();
	cout << ans << endl;
	return 0;
}
computer literacy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小生成树 数据结构 课程设计 离散数学
05-16
总的来说，"最小生成树 数据结构 课程设计 离散数学"这个主题涵盖了计算机科学中的多个重要领域，包括数据结构、算法、图论和数学建模。对于学习者来说，深入理解和掌握这些知识不仅有助于提升编程能力，也有助于...
计算机软件基础数据结构作业题——无向带权图最小生成树提取
11-06
本人是南京航空航天大学的学生，我们的一个计算机软件基础大作业是编写4个程序，分别是约瑟夫斯问题、停车场管理、带权图的最小生成树提取、几种排序算法的比较。希望能够帮助到大家，尤其是南航的学弟学妹们！工程...
C++数据结构——习题6-5 最小生成树（Prim算法）
weixin_44546342的博客
05-23 2381
习题6-5 最小生成树 省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。已知村庄数N和可建道路数M，设初始状态下任意村庄之间没有路，请编写程序，根据输入的两村庄间修建道路的费用情况，计算这些村庄畅通所需要的最低成本。 输入格式: 测试数据有多组。每组测试数据第1行输入村庄数目N ( 1< N < 11 )和道路数M；随后的M行输入村庄间道路的成本，每行给3个正整数，分别是两个村庄的编号（从1编号到N），修建此两村庄间
最小生成树详解（模板 + 例题）
zgdlxs的博客
02-10 5964
1.什么是最小生成树 一个图中可能存在多条相连的边,我们一定可以从一个图中挑出一些边生成一棵树。这仅仅是生成一棵树,还未满足最小,当图中每条边都存在权重时,这时候我们从图中生成一棵树(n - 1 条边)时,生成这棵树的总代价就是每条边的权重相加之和。 一个有N个点的图，边一定是大于等于N-1条的。图的最小生成树，就是在这些边中选择N-1条出来，连接所有的N个点。这N-1条边的边权之和是所有方案中最小的。 2.最小生成树的应用 要在n个城市之间铺设光缆，主要目标是要使这 n 个城市的任意两个...
最小生成树算法及例题整理
最新发布
m0_74120503的博客
02-19 1402
本题看似麻烦，但是既然涉及到最小生成树，那么我们可以想一想最小生成树的建立过程，我们从kluskal的角度来考虑，每次建边，就是将两个 不连通的集合连通，两个不连通的集合就说明除了当前这条边以外，两个集合没有任何边相连，如果要得到完全图，那么很显然两个集合之间要建立更多的边，这些边的具体数目取决于两个集合的大小。这个算法的思路就是将所有的边排序，然后从小到大遍历所有的边，如果这条边连接的两点不在一个集合中，那么就将它们并成一个集合，否则就略过这条边。最开始连通块的数量肯定是n，每连接一次，那么数量就少1.
数据结构复习（最小生成树——最短路径）
努力的程序员
06-02 2734
最小生成树 最短路径
最小生成树练习总结
Two_Punch的博客
01-06 399
最小生成树 最小生成树简称MST（Minimum Spanning Tree）,最小生成树算法有Prim算法和Kruskal算法，prim算法其实就是在dijkstra算法上面稍微修改一哈，当然也可以加heap优化，而Kruskal就有点意思了，因为这个算法在解决判断环的问题的时候用了并查集。还是先来书上的描述 书上的代码： 说实话这个并查集用的是真的溜~ poj2421 poj1287 这...
构造可以使n个城市连接的最小生成树
07-06
本文详细介绍了如何使用C语言来构造一个能使n个城市连接起来的最小生成树所需的基础数据结构和相关操作。通过这些基础组件，我们可以进一步实现具体的最小生成树算法，如Prim算法或Kruskal算法等，从而解决实际问题...
Matlab中求解最小生成树的程序
05-01
本篇文章将详细介绍如何在Matlab中实现最小生成树(Minimum Spanning Tree, MST)的计算过程，特别是通过使用避圈法（Kruskal算法、克鲁斯卡尔算法）。最小生成树是指在一个加权无向图中寻找一个子图，该子图包含所有...
b+树时间复杂度_数据结构与算法——最小生成树
weixin_39687621的博客
11-24 776
1 引言在之前的文章中已经详细介绍了图的一些基础操作。而在实际生活中的许多问题都是通过转化为图的这类数据结构来求解的，这就涉及到了许多图的算法研究。例如：在n个城市之间铺设光缆，以保证这n个城市中的任意两个城市之间都可以通信。由于铺设光缆的价格很高，且各个城市之间的距离不同，这就使得在各个城市之间铺设光缆的价格不同。那么如何选择铺设线路的方案，才能使费用最低呢？这就涉及到我们今天...
最小生成树两大常用模板
饮酒在风里的博客
09-27 438
稠密图： PRIM 给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。 求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。 给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。 由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无...
算法导论23章最小生成树习题—23.2练习
我们都是被分成两半的人，一边热爱生活，一边憎恨生活。面对生活，我们总是在矛盾的两端摇摆，在反复的矛盾和犹豫中，一边踉跄前行，一边重振旗鼓。我渴望改变，渴望变得更好，渴望找到出口……就像一个溺水人的挣扎，就像一个救生圈。我是一个矛盾集合体，想要变得快乐，但是
12-03 1816
23.2-1对于同一个输人图，Kruskal 算法返回的最小生成树可以不同。这种不同来源于对边进行排序时，对权重相同的边进行的不同处理。证明:对于图G的每棵最小生成树T，都存在一种办法来对G的边进行排序，使得Kruskal算法所返回的最小生成树就是T。假设我们想选择 T 作为最小生成树。然后，为了使用 Kruskal 算法获得此树，我们将首先按边的权重对边进行排序，然后通过选取包含在最小生成树中的一条边来解决边权重中的连接，并将所有不在T中的边权视为稍大，即使它们具有相同的实际权重。 通过这种排序，我们能够
数据结构与算法——最小生成树问题（什么是最小生成树、Prim算法、Kruskal算法）
li13437542099的博客
07-10 310
数据结构——最小生成树问题（什么是最小生成树、Prim算法、Kruskal算法） 什么是最小生成树： 1.是一颗树无回路个顶点一定有条边2.是生成树包含全部顶点条边都在图里3.边的权重和最小向生成树中任加一条边都一定构成回路最小生成树存在图连通。
7-14 最小生成树的唯一性（30 分） 生成树综合练习题
江河湖海
03-19 4226
题目描述: 7-14 最小生成树的唯一性（30 分） 给定一个带权无向图，如果是连通图，则至少存在一棵最小生成树，有时最小生成树并不唯一。本题就要求你计算最小生成树的总权重，并且判断其是否唯一。 输入格式： 首先第一行给出两个整数：无向图中顶点数 N（≤500）和边数 M。随后 M 行，每行给出一条边的两个端点和权重，格式为“顶点1 顶点2 权重”，其中顶点从 1
【学习笔记----数据结构19-图的最小生成树】
Will 的专栏
11-12 1236
我们把构造连通网的最小代价生成树称为最小生成树（Minimum   Cost   Spanning Tree）   普里姆（Prim）算法   也就是说，现在我们已经有一个存储结构 MGraph的G，它的arc二维数组如图所示。数组中我们用65535代表∞ 于是普里母算法代码如下。其中INFINITY权值极大值，这里用65535代表，MAXVEX为顶点个数最大值，此处大于等于9即
图结构练习——最小生成树
勿忘初心丶
08-17 231
图结构练习——最小生成树 Time Limit: 1000MS Memory limit: 65536K 题目描述  有n个城市，其中有些城市之间可以修建公路，修建不同的公路费用是不同的。现在我们想知道，最少花多少钱修公路可以将所有的城市连在一起，使在任意一城市出发，可以到达其他任意的城市。   输入  输入包含多组数据，格式如下。 第
最小生成树习题
m0_53203911的博客
05-18 166
最短网络 #include<iostream> #include<cstring> using namespace std; const int N=110; int g[N][N]; int dist[N]; int n; bool st[N]; int prim(){ int res=0; memset(dist,0x3f,sizeof dist); dist[1]=0; for(int i=1;i<=n;i++){ int
【洛谷】最小生成树题目笔记
tidongCrazy的博客
07-10 631
题目链接 P1536 村村通 P1547 Out of Hay P2820 局域网 P1546 最短网络 Agri-Net P2330 繁忙的都市 一、村村通 裸的最小生成树…… 一道水的不能再水的题…… 先贴上代码 #include<bits/stdc++.h> using namespace std; int n,m,f[2000020],ans=0; struct pvp{i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值