杭电1232畅通工程(最小生成树模板)

本文介绍了一个经典的图论问题——畅通工程问题,旨在通过最少的道路建设使所有城镇间均可实现交通。文章提供了详细的算法思路和实现代码,利用并查集算法解决如何计算最少需要新增多少条道路的问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >


畅通工程

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 56531    Accepted Submission(s): 30155


Problem Description
某省调查城镇交通状况,得到现有城镇道路统计表,表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通(但不一定有直接的道路相连,只要互相间接通过道路可达即可)。问最少还需要建设多少条道路?
 

Input
测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数,分别是城镇数目N ( < 1000 )和道路数目M;随后的M行对应M条道路,每行给出一对正整数,分别是该条道路直接连通的两个城镇的编号。为简单起见,城镇从1到N编号。 
注意:两个城市之间可以有多条道路相通,也就是说
3 3
1 2
1 2
2 1
这种输入也是合法的
当N为0时,输入结束,该用例不被处理。 
 

Output
对每个测试用例,在1行里输出最少还需要建设的道路数目。
 

Sample Input
  
  
4 2
1 3
3 3
4 3 1 2
5 2
1 3 2 3 1 2
0
3 5
999 0
 

Sample Output
  
  
1
0
998
2
Hint
Hint
Huge input, scanf is recommended.
 

Source
 

Recommend
JGShining
http://acm.hdu.edu.cn/showproblem.php?pid=1232

用一个数组将一个点和其父节点联系起来,另外,一个点的父节点是本身时,该点的根节点也是他自己。小常识:n个点至少需要n-1条边相为一棵树

代码如下:

#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX=1e3+10;
int n,m,par[MAX];//用数组par[]将每个有关系的点连接起来,若par[a]=b即a的父节点为b 

int find(int x) 
{
	int j,r=x;
	while(par[r]!=r)
		r=par[r];//查找根节点r,根据:根节点的父节点是本身 
    while(x!=r)  
    {  
       j=par[x];  
       par[x]=r;  //路径压缩(防止大树加到小树上) ,减少树的分层 
       x=j;  
    }  
	return r;
}

int main()
{
	while(~scanf("%d",&n),n)//输入n=0时,不做处理该语句等价于while(scanf("%d",&n)&&n) 
	{
		int f1,f2,p,q,total;
		for(int i=1;i<=n;i++)
		par[i]=i;//孤立的点的父节点为本身 
		total=n-1;//n个孤立的点至少用n-1条线相连在一起 
		scanf("%d",&m);//m条道路 
		while(m--)
		{
			scanf("%d %d",&p,&q);
			f1=find(p);
			f2=find(q);
			if(f1!=f2)
			{
				par[f1]=f2;//合并 ,(根节点不同,不在一棵树上时) 
				total--;
			}
		}
		printf("%d\n",total);
	}
	return 0;
}

<think>好的,我现在需要为用户介绍最小生成树模板。首先,我得回忆一下最小生成树的基本概念和相关算法最小生成树(Minimum Spanning Tree,MST)是在一个加权无向图中找到一棵包含所有顶点的树,并且边的权值之和最小。常用的算法有Prim算法和Kruskal算法。 接下来,我需要确定用户的需求是什么。他们可能是在准备算法竞赛或者学习图论,需要模板代码来实现这两种算法。因此,我应该分别解释这两种算法的原理,然后给出代码模板,并比较它们的适用场景。 对于Kruskal算法,核心是使用并查集来管理连通性,按边的权重从小到大排序,依次选择不形成环的边。这里要注意路径压缩和按秩合并优化并查集的操作,以提高效率。代码部分需要结构体或类来存储边,以及并查集的实现。时间复杂度方面,Kruskal是O(M log M),适合边较少的稀疏图。 然后是Prim算法,这通常使用优先队列(堆)来实现,类似于Dijkstra算法。需要维护一个最小堆来选择当前权值最小的边,同时记录哪些顶点已加入生成树。Prim算法的时间复杂度取决于使用邻接矩阵还是邻接表,以及是否用堆优化。使用堆优化的版本是O(M log N),适合边较多的稠密图。 在编写代码模板时,要确保语法正确,变量命名清晰,并加上必要的注释。例如,在Kruskal的模板中,需要初始化并查集,排序边,然后遍历合并;在Prim的模板中,则需要构建邻接表,使用优先队列,并维护一个visited数组。 同时,应该指出两种算法的区别:Kruskal更适合稀疏图,而Prim在稠密图中表现更好。这是因为Kruskal的时间复杂度主要取决于边的数量,而Prim在邻接矩阵的情况下是O(),对于稠密图来说可能更快,但堆优化后更适合边多的情况。 可能用户会混淆这两种算法的应用场景,所以需要明确说明。另外,示例输入输出可以帮助用户理解模板的使用方法,比如给出一个具体的图结构,展示算法如何逐步构建最小生成树。 最后,需要检查是否有遗漏的细节,比如处理图不连通的情况(此时无法生成MST),或者在代码中处理可能的异常。确保提供的模板代码能够正确处理各种情况,比如边权为负数时是否影响算法逻辑(不影响,因为MST允许负权边,只要总权最小)。 总结起来,我需要分步骤介绍两种算法,提供清晰的代码模板,并比较它们的优缺点和使用场景,帮助用户根据具体问题选择合适的算法。</think>最小生成树(Minimum Spanning Tree, MST)是连接加权无向图所有顶点的边权总和最小的树。以下是两种常用算法模板及解析: --- ### 一、Kruskal 算法(贪心+并查集) **适用场景**:稀疏图(边少) **时间复杂度**:O(M log M) (M为边数) #### 算法步骤: 1. 将边按权值升序排序 2. 初始化并查集 3. 遍历所有边,用并查集判断是否形成环 4. 累计不形成环的边权 ```cpp #include <vector> #include <algorithm> using namespace std; struct Edge { int u, v, w; Edge(int _u, int _v, int _w) : u(_u), v(_v), w(_w) {} }; vector<Edge> edges; int parent[1005]; int find(int x) { return parent[x] == x ? x : parent[x] = find(parent[x]); } bool unite(int x, int y) { x = find(x), y = find(y); if (x == y) return false; parent[y] = x; return true; } int kruskal(int n) { // n为顶点数 sort(edges.begin(), edges.end(), [](Edge& a, Edge& b) { return a.w < b.w; }); for (int i = 1; i <= n; ++i) parent[i] = i; int sum = 0, cnt = 0; for (auto& e : edges) { if (unite(e.u, e.v)) { sum += e.w; if (++cnt == n-1) break; // 选够n-1条边 } } return cnt == n-1 ? sum : -1; // -1表示图不连通 } ``` --- ### 二、Prim 算法(优先队列) **适用场景**:稠密图(边多) **时间复杂度**:O(M log N) (N为顶点数) #### 算法步骤: 1. 任选起始点,初始化优先队列 2. 每次取出离当前树最近的顶点 3. 更新相邻顶点到树的距离 ```cpp #include <vector> #include <queue> #include <climits> using namespace std; typedef pair<int, int> pii; // {weight, vertex} int prim(vector<vector<pii>>& graph, int n) { vector<bool> vis(n+1, false); priority_queue<pii, vector<pii>, greater<pii>> pq; int sum = 0, cnt = 0; pq.push({0, 1}); // 从顶点1开始 while (!pq.empty()) { auto [w, u] = pq.top(); pq.pop(); if (vis[u]) continue; vis[u] = true; sum += w; cnt++; for (auto& [v, cost] : graph[u]) { if (!vis[v]) { pq.push({cost, v}); } } } return cnt == n ? sum : -1; // -1表示图不连通 } ``` --- ### 三、算法对比 | 特性 | Kruskal | Prim | |-------------|-----------------------------|--------------------| | 数据结构 | 并查集 + 排序 | 优先队列 | | 适用场景 | 稀疏图(边少) | 稠密图(边多) | | 时间复杂度 | O(M log M) | O(M log N) | | 是否需要邻接表 | 不需要 | 需要 | --- ### 四、使用示例 输入(邻接表): ``` 顶点数n=3,边: 1-2 (权重5) 2-3 (权重6) 1-3 (权重4) ``` 输出: ``` 最小生成树权值和 = 5 + 4 = 9 ``` --- 根据图的稠密程度选择算法:稀疏图优先用Kruskal,邻接矩阵存储的稠密图可用朴素版Prim(时间复杂度O())。模板代码需根据具体题目调整顶点编号方式(0-based或1-based)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值