乐师理工ACM集训-最小生成树

最新推荐文章于 2022-04-13 20:39:16 发布
最新推荐文章于 2022-04-13 20:39:16 发布
阅读量229 收藏 1
点赞数 1
分类专栏： 2020暑假集训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45309822/article/details/107881195
版权

文章目录

HDU1233 还是畅通工程

传送门：HDU1233 还是畅通工程

解题思路

  N个点，N * (N - 1) / 2 条边，且 N < 100，邻接矩阵存图，朴素prim即可。

AC代码1【朴素prim + 邻接矩阵】

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 105;
const int INF = 0x3f3f3f3f;
int n, m, len;
int dis[MAXN],vis[MAXN];
int g[MAXN][MAXN];
priority_queue<pii,vector<pii>,greater<pii> > q;
void init()
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			g[i][j] = INF;
		}
		g[i][i] = 0;
	}
}
int prim()
{
	int ans = 0;
	memset(dis,INF,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[1] = 0;
	while (true)
	{
		int v = -1;
		for (int i = 1; i <= n; i++)
		{
			if (!vis[i] && (v == -1 || dis[i] < dis[v]))
			{
				v = i;
			}
		}
		if (v == -1)
		{
			break;
		}
		vis[v] = true;
		ans += dis[v];
		for (int i = 1; i <= n; i++)
		{
			dis[i] = min(dis[i],g[v][i]);
		}
	}
	return ans;
}
int main()
{
	int a, b, c;
	while (scanf("%d",&n) && n)
	{
		init();
		m = (n * (n - 1)) >> 1;
		while (m--)
		{
			scanf("%d%d%d",&a, &b, &c);
			g[a][b] = g[b][a] = min(g[a][b], c);
		}
		printf("%d\n",prim());
	}
	return 0;
}

AC代码2【堆优化prim + 邻接矩阵】

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 105;
const int INF = 0x3f3f3f3f;
int n, m, len;
int dis[MAXN],vis[MAXN];
int g[MAXN][MAXN];
priority_queue<pii,vector<pii>,greater<pii> > q;
void init()
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			g[i][j] = INF;
		}
		g[i][i] = 0;
	}
}
int prim()
{
	int ans = 0;
	memset(dis,INF,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[1] = 0;
	q.push(pii(0,1));
	while (!q.empty())
	{
		pii temp = q.top();
		q.pop();
		int v = temp.second;
		if (vis[v])
		{
			continue;
		}
		vis[v] = true;
		ans += dis[v];
		for (int i = 1; i <= n; i++)
		{
			if (!vis[i] && dis[i] > g[v][i])
			{
				dis[i] = g[v][i];
				q.push(pii(dis[i],i));
			}
		}
	}
	return ans;
}
int main()
{
	int a, b, c;
	while (scanf("%d",&n) && n)
	{
		init();
		m = (n * (n - 1)) >> 1;
		while (m--)
		{
			scanf("%d%d%d",&a, &b, &c);
			g[a][b] = g[b][a] = min(g[a][b], c);
		}
		printf("%d\n",prim());
	}
	return 0;
}

AC代码3【堆优化prim+ 邻接表】

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 105;
const int INF = 0x3f3f3f3f;
int n, m;
int dis[MAXN],vis[MAXN];
vector<pii> edge[MAXN];
priority_queue<pii,vector<pii>,greater<pii> > q;
int prim()
{
	int ans = 0;
	memset(dis,INF,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[1] = 0;
	q.push(pii(0,1));
	while (!q.empty())
	{
		pii t = q.top();
		q.pop();
		int v = t.second;
		if (vis[v])
		{
			continue;
		}
		vis[v] = 1;
		ans += dis[v];
		for (int i = 0; i < edge[v].size(); i++)
		{
			int p = edge[v][i].first;
			int w = edge[v][i].second;
			if (dis[p] > w)
			{
				dis[p] = w;
				q.push(pii(dis[p], p));
			}	
		}
	}	
	for (int i = 0; i <= n; i++)
	{
		edge[i].clear();
	}
	return ans;
}
int main()
{
	int a, b, c;
	while (scanf("%d",&n) && n)
	{
		m = (n * (n - 1)) >> 1;
		while (m--)
		{
			scanf("%d%d%d",&a, &b, &c);
			edge[a].push_back(pii(b,c));
			edge[b].push_back(pii(a,c));
		}
		printf("%d\n",prim());
	}
	return 0;
}

HDU1879 继续畅通工程

传送门：HDU1879 继续畅通工程

解题思路

  N个点，N * (N - 1) / 2 条边，且 1 < N < 100，可以用邻接矩阵存图。对于已经修建道路的两座城市，使其距离为0，然后用朴素prim即可。

AC代码【朴素prim + 邻接矩阵】

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 800;
const int INF = 0x3f3f3f3f;
int n, m, len;
int dis[MAXN],vis[MAXN];
int g[MAXN][MAXN];
priority_queue<pii,vector<pii>,greater<pii> > q;
void init()
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			g[i][j] = INF;
		}
		g[i][i] = 0;
	}
}
int prim()
{
	int ans = 0;
	memset(dis,INF,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[1] = 0;
	while (true)
	{
		int v = -1;
		for (int i = 1; i <= n; i++)
		{
			if (!vis[i] && (v == -1 || dis[i] < dis[v]))
			{
				v = i;
			}
		}
		if (v == -1)
		{
			break;
		}
		vis[v] = true;
		ans += dis[v];
		for (int i = 1; i <= n; i++)
		{
			dis[i] = min(dis[i],g[v][i]);
		}
	}
	return ans;
}
int main()
{
	int a, b, c, d;
	while (scanf("%d",&n) && n)
	{
		init();
		m = (n * (n - 1)) >> 1;
		while (m--)
		{
			scanf("%d%d%d%d",&a, &b, &c, &d);
			// 城市之间已有直接连通的道路，无需修建
			if (d == 1)
			{
				c = 0;
			}
			g[a][b] = g[b][a] = min(g[a][b], c);
		}
		printf("%d\n",prim());
	}
	return 0;
}

POJ1751 Highways

传送门：POJ1751 Highways

题目大意

  给定一个N和N个城市的坐标，然后给定一个M和M对已经相连的城市。问：将要将所有城市连通起来且总路径最少，还需连接哪些城市？
  提示：本题有Special judge，即连接城市的输出可以与给定样例不一致，只要正确即可。

解题思路

  N个城市，任意两个城市都要求得距离，那就是N * (N - 1) / 2条边，由题意可知1 <= N <= 750，所以对于prim算法可以直接采用邻接矩阵存图。
  然后这里并不需要求得总路径长度,所以不用求得具体距离（对两点间距离无需开根）。

AC代码1【朴素prim + 邻接矩阵】

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 800;
const int INF = 0x3f3f3f3f;
int n, m, len;
int dis[MAXN],vis[MAXN],pre[MAXN],x[MAXN],y[MAXN];
int g[MAXN][MAXN];
priority_queue<pii,vector<pii>,greater<pii> > q;
void prim()
{
	memset(dis,INF,sizeof(dis));
	memset(vis,0,sizeof(vis));
	// 用 pre 数组记录某个点是由哪个点中转而来
	for (int i = 1; i <= n; i++)
	{
		pre[i] = 1;
	}
	dis[1] = 0;
	while (true)
	{
		int v = -1;
		for (int i = 1; i <= n; i++)
		{
			if (!vis[i] && (v == -1 || dis[i] < dis[v]))
			{
				v = i;
			}
		}
		if (v == -1)
		{
			break;
		}
		vis[v] = true;
		// 若点 pre[v] 和点 v 不连通
		if (g[pre[v]][v])
		{
			// 这两点间需要建路
			printf("%d %d\n",pre[v],v);
		}
		for (int i = 1; i <= n; i++)
		{
			if (dis[i] > g[v][i])
			{
				dis[i] = g[v][i];
				// 点 i 由点 v 更新而来
				pre[i] = v;
			}
		}
	}
}
int main()
{
	int a, b;
	scanf("%d",&n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d%d",&x[i],&y[i]);
		for (int j = 1; j < i; j++)
		{
			// 求距离，因为不需要具体距离，所以无需开根
			len = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
			g[i][j] = g[j][i] = len;
		}
	}
	scanf("%d",&m);
	while (m--)
	{
		scanf("%d%d",&a, &b);
		// 已经修建道路的城市距离为 0 
		g[a][b] = g[b][a] = 0;
	}
	prim();
	return 0;
}

AC代码2【kruskal】

#include<stdio.h>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 800;
const int INF = 0x3f3f3f3f;
int x[MAXN], y[MAXN], father[MAXN];
int n, m, len, node = 0;
struct Node
{
	int a, b, c;
	Node(){}
	bool operator < (const Node& x) const
	{
		return c < x.c;
	}
	Node(int x, int y, int z)
	{
		a = x;
		b = y;
		c = z;
	}
}edge[MAXN * MAXN];
void init(int maxn)
{
	for (int i = 1; i <= maxn; i++)
	{
		father[i] = i;
	}
	node = 0;
}
int find(int x)
{
	if (father[x] == x)
	{
		return x;
	}
	return father[x] = find(father[x]);
}
bool merge(int x, int y)
{
	x = find(x);
	y = find(y);
	if (x != y)
	{
		father[x] = y;
		// 两个点未连接
		return true;
	}
	// 两个点已连接
	return false;
}
void kruskal()
{
	// 对边排序，便于后续对边贪心
	sort(edge,edge + node);
	int cnt = 0;
	for (int i = 0; i < node; i++)
	{
		// 每次取出一条边，判断两个点是否已经连接
		if (merge(edge[i].a, edge[i].b))
		{
			printf("%d %d\n",edge[i].a, edge[i].b);
		}
		// 已经找到 N - 1 条边了
		if (cnt == n - 1)
		{
			break;
		}
	}
	return ;
}
int main()
{
	int a, b;
	scanf("%d",&n);
	init(n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d%d",&x[i],&y[i]);
		for (int j = 1; j < i; j++)
		{
			// 求距离，因为不需要具体距离，所以无需开根
			len = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
			edge[node++] = Node(i,j,len);
		}
	}
	scanf("%d",&m);
	while (m--)
	{
		scanf("%d%d",&a, &b);
		// 已经修建道路的城市在一个集合中
		merge(a, b);
	}
	kruskal();
	return 0;
}

HDU5253 连接的管道

传送门：HDU5253 连接的管道

解题思路

  求最小生成树的总路径长度。根据题意可知是稀疏图，所以可以采用kruskal算法，然后每次建边可以只建立两条边（与左边的田建边、与上边的田建边）。

AC代码【kruskal】

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
int field[MAXN], father[MAXN];
int n, m, N, ind = 1, node = 0;
struct Node
{
	int a, b, c;
	Node(){}
	Node(int x, int y, int z)
	{
		a = x;
		b = y;
		c = z;
	}
	bool operator < (const Node& x) const
	{
		return c < x.c;
	}
}edge[MAXN << 1];
void init(int maxn)
{
	for (int i = 1; i <= maxn; i++)
	{
		father[i] = i;
	}
	ind = 1;
	node = 0;
}
int find(int x)
{
	if (father[x] == x)
	{
		return x;
	}
	return father[x] = find(father[x]);
}
bool merge(int x, int y)
{
	x = find(x);
	y = find(y);
	if (x != y)
	{
		father[x] = y;
		// 两个点未连接
		return true;
	}
	// 两个点已连接
	return false;
}
int kruskal()
{
	// 对边排序，便于后续对边贪心
	sort(edge,edge + node);
	int ans = 0, cnt = 0;
	for (int i = 0; i < node; i++)
	{
		// 每次取出一条边，判断两个点是否已经连接
		if (merge(edge[i].a, edge[i].b))
		{
			ans += edge[i].c;
			cnt++;
		}
		// 已经找到 N - 1 条边了
		if (cnt == N - 1)
		{
			break;
		}
	}
	return ans;
}
int main()
{
	int T;
	while(~scanf("%d",&T))
	{
		for (int t = 1; t <= T; t++)
		{
			scanf("%d%d",&n,&m);
			// n * m 个田地
			N = n * m;
			init(N);
			for (int i = 1; i <= n; i++)
			{
				for (int j = 1; j <= m; j++)
				{
					scanf("%d",&field[ind]);
					// 和左边的田建边
					if (j > 1)
					{
						edge[node++] = Node(ind, ind - 1,abs(field[ind] - field[ind - 1]));
					}
					// 和上面的田建边
					if (i > 1)
					{
						edge[node++] = Node(ind, ind - m, abs(field[ind] - field[ind - m]));
					}
					ind++;
				}
			}
			printf("Case #%d:\n%d\n",t,kruskal());
		}
	}
	return 0;
}
勿忘∮心安
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACM必做50题的解题-最小生成树
10-19
本资源"ACM必做50题的解题-最小生成树.rar"包含了一组与最小生成树相关的题目和解决方案，旨在帮助参赛者熟练掌握这一关键算法。 首先，我们要理解什么是“最小生成树”。在无向加权图中，如果每条边都有一个非负...
ACMICPC-Latex模板：一个简单的ACM-ICPC（LaTeX）模板生成器
02-04
一个简单的ACM-ICPC模板生成器 一个非常简单的ACM-ICPC代码模板生成工具。 从源代码目录生成模板而无需将其复制到docx或tex文件，仅需执行一条命令。 您只需要做的就是使用python gen.py生成模板PDF文件。 要求 ...
ACM模板——最小生成树
weixin_30387339的博客
03-24 92
int mincost[maxn]; bool used[maxn]; int MST() { _for(i,0,V) { mincost[i] = INF; used[i] = false; } mincost[0] = 0; int res = 0; while...
【ACM】最小生成树（Prim算法）
小小小草儿的博客哟
12-09 836
算法分析： prim算法适合稠密图，时间复杂度为O(n^2),时间复杂度与边的条数无关。 概念： 边带有权值的图称为带权图或者网，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。 1.最小生成树（MST）：权值最小的生成树。 2.构造最小生成树应该满足一下两个性质： 尽可能的选取权值小的边，但是不能构成回路。 选取n-1条恰当的边连通n个顶点。MST性
ACM训练日志33-最小生成树
weixin_40630836的博客
01-10 161
poj_1258 Description Farmer John has been elected mayor of his town! One of his campaign promises was to bring internet connectivity to all farms in the area. He needs your help, of course. Farmer Joh...
【ACM】- POJ-1861 Network 【最小生成树】
三个石头
09-15 227
题目链接 题目分析 最小生成树问题，不过要求得不是路径和，而是使生成树中的最长边最小； | 细节： 1、结点编号1~N 2、注意题目给的测试数据有BUG； 解题思路 Kruskal算法 + 并查集； AC程序（C++） /********************************** *@ID: 3stone *@ACM: POJ-1861 Network *@Time...
ACM_模板_最小生成树
RaAlGhul的博客
02-28 636
最小生成树，其本质还是并查集，经典运用就是Kruskal算法，对边权进行排序后，由小到大进行合并处理，直到形成一颗树为止。 #include//最小生成树 #include using namespace std; int root[101]; int N,Q,i,j,a,b,d,t,ans; struct road { int s; int e; int d; }edge[5051];
哈尔滨理工大学ACM-ICPC 集训队
03-16
【哈尔滨理工大学ACM-ICPC集训队】是该校为了备战ACM-ICPC（国际大学生程序设计竞赛）而设立的专门训练团队。这个团队在2012年时已经积累了丰富的培训经验和资源，旨在提升学生的算法基础和数据结构能力。 【ACM...
最小生成树总结acm竞赛
04-24
在ACM（国际大学生程序设计竞赛）中，最小生成树算法是常见的一种解决问题的策略。本篇文章将详细探讨最小生成树及其在ACM竞赛中的应用。 首先，最小生成树（Minimum Spanning Tree, MST）是指在一个加权无向连通图...
acm 最小生成树 prim算法
04-19
### ACM 最小生成树 Prim算法 #### 知识点概览 1. **Prim算法简介** 2. **并查集的使用** 3. **代码详解** 4. **Prim算法的应用场景** #### Prim算法简介 Prim算法是一种用于寻找图中所有顶点构成的最小生成树...
ACM入门之【最小生成树】
辉小歌的博客
03-11 212
prim模板 int g[N][N],dist[N],n,m,ans; int st[N]; void prim() { memset(dist,0x3f,sizeof dist); dist[1]=0; for(int i=0;i<n;i++) { int t=-1; for(int j=1;j<=n;j++) if(!st[j]&&(t==-1 || dist[j]<dist[t])) t=j; .
ACM 最小生成树 Constructing Roads
请赐教
02-06 430
最小生成树：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。   最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。     在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边，而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集且为无循环图，...
关于ACM中的最小生成树
wolfguy的world-class旅途
10-30 952
最常见的最小生成树，无非就两种： prim kruscal。 两者皆为贪心思想，局部最优（或无限接近最优）以达到全局最优的效果。 很多人疑惑，到底什么是最小生成树 维基百科的定义链接： http://zh.wikipedia.org/wiki/最小生成树 定义很严谨，但是这个定义并不形象。其实最小生成树无非是把无向图转化为树结构的过程，在这个过程中存在一个从出发点遍历
[ACM] poj 2485 Highways (最小生成树）
逆风的方向 更适合飞翔
05-26 2406
Highways Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 21056   Accepted: 9723 Description The island nation of Flatopia is perfectly flat. Unfortunately,
ACM最小生成树模版
Doneone_的博客
04-04 564
            前几天去忙蓝桥杯省赛了唉，好几天没写博客了。不知道在那个算法群里看到大佬说3个填空题就可以获奖了。。。全程做选择题，结果后面没时间，有一个大题都没来得及看题目，还有一题怂了，明明最近都是写图论却还是怕图论。。。唉，打这种差一点的水漂打得难受。今天把学弟群里的专题拿去刷了，最小生成树。PS:不得不说，学弟真的tql。。。         最小生成树： 在数据结构里学了pr...
ACM入门-最小生成树及其应用
TGX的博客
12-14 1374
前置知识 邻接矩阵、并查集 什么是最小生成树？ 今天要讲解的算法是最小生成树，那么什么是最小生成树呢？由于是面向新手的算法教程，尽量用大白话来讲清楚最小生成树这个定义。 假定有这么一个问题，有6个城市，城市之间有一些道路，修道路需要花费不同的金额，现在要你选择其中一些道路，使得所有城市可以互相到达（联通）且花费最小。这个问题的答案就是最小生成树，我们把这个问题抽象为一张图，每个城市是一个点，城市与城市的道路是一条无向边。 如何求解这个问题？ Prim算法 算法思路：将所有城市分为两个集合，一个集合X是已经
Lonlife-ACM 1000 - Spoon Devil's 3-D Matrix(最小生成树)——“玲珑杯”acm比赛-试运行赛
queuelovestack的专栏
10-01 1568
Lonlife-ACM 1000 - Spoon Devil's 3-D Matrix(最小生成树)——“玲珑杯”acm比赛-试运行赛
【ACM之路】6.最小生成树 - Kruskal算法
爱学习的大白菜的博客
06-19 274
介绍： Kruskal算法是最小生成树算法，它适合于边少的稀疏图 。 思想： 首先按照边的权值，从小到大排序，每次从剩余的边中选择 “权值最小的 且边的两个顶点不在同一个集合内的边”。 （就是不产生回路的边），加入到生成树中，直到加入了n-1条边为止。 前置知识： ①. 并查集。 ②. 快速排序 题目举例： 一共有6个城市...
最小生成树
m0_62134640的博客
04-13 268
一.kruskal（克鲁斯卡尔）算法（易理解）（稀疏图） 这个算法就是将每条边用结构体进行存储下来，（例如egde.start表示边的起点，egde.to标识终点，egde.val 表示终点）接着对每条边进行排序，权值（egde.val）小的在前面，接着我们采用并查集的方法从前面开始枚举 每一条边来记录关系（如果已经存在关系就跳过），最后当建立的关系数等于节点数减一时，说明已经建立好 了最小生成树 例题：洛谷P3366 输入格式 第一行包含两个整数 N,M，表示该图共有 N个结点和 M条无向边。
ACM竞赛：最小生成树算法解析与团队组建策略
在ACM竞赛中，生成树问题是一个重要的概念，涉及寻找一个连通无环图的最小边集，使其所有顶点都被包含在内。两个主要的算法用于解决这个问题：Prim算法和Kruskal算法。Prim算法从一个起点开始，逐步添加边，直到形成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值