一本通 3.4.5 最小生成树

1348：【例4-9】城市公交网建设问题

【题目描述】

有一张城市地图，图中的顶点为城市，无向边代表两个城市间的连通关系，边上的权为在这两个城市之间修建高速公路的造价，研究后发现，这个地图有一个特点，即任一对城市都是连通的。现在的问题是，要修建若干高速公路把所有城市联系起来，问如何设计可使得工程的总造价最少？

【题目分析】

最小生成树模板题，Kruskal算法和Prim算法均可以

【代码实现】

Prim算法

#include
using namespace std;

struct node {
	int from;
	int to;
	int dis;
	friend bool operator<(node a, node b) {
		return a.dis >= b.dis;
	}
};
vector edge[105];
priority_queue que;
bool vis[105];
int main() {
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= m; i++) {
		int x, y, w;
		cin >> x >> y >> w;
		edge[x].push_back({x, y, w});
		edge[y].push_back({y, x, w});
	}
	//init priority_queue
	vis[1] = 1;
	for (auto e : edge[1]) {
		que.push(e);
	}
	//loop resolve
	while (!que.empty()) {
		node a = que.top();
		que.pop();
		if (!vis[a.to]) {
			vis[a.to] = 1;
			cout << a.from << " " << a.to << endl;
			for (auto e : edge[a.to]){
				que.push(e);
			} 
		}
	}
	return 0;
}

Kruskal算法

#include
using namespace std;

struct node {
	int from, to, dis;
};
bool cmp(node &a, node &b) {
	return a.dis < b.dis;
}
vector edge;
int fa[105];

int find(int a) {
	return fa[a] == a ? a : fa[a] = find(fa[a]);
}
int main() {
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		fa[i] = i;
	}
	for (int i = 1; i <= m; i++) {
		int x, y, w;
		cin >> x >> y >> w;
		edge.push_back({x, y, w});
		edge.push_back({y, x, w});
	}

	sort(edge.begin(), edge.end(), cmp);

	for (auto e : edge) {
		int from = find(e.from);
		int to = find(e.to);
		if (from != to) {
			cout << e.from << " " << e.to << endl;
			fa[from] = to ;
		}
	}

	return 0;
}

1349：【例4-10】最优布线问题

【题目描述】

学校有n台计算机，为了方便数据传输，现要将它们用数据线连接起来。两台计算机被连接是指它们有数据线连接。由于计算机所处的位置不同，因此不同的两台计算机的连接费用往往是不同的。

当然，如果将任意两台计算机都用数据线连接，费用将是相当庞大的。为了节省费用，我们采用数据的间接传输手段，即一台计算机可以间接的通过若干台计算机（作为中转）来实现与另一台计算机的连接。

现在由你负责连接这些计算机，任务是使任意两台计算机都连通（不管是直接的或间接的）。

【题目分析】

最小生成树模板题，Kruskal算法和Prim算法均可

【代码实现】

Prim算法

#include 
#define MAXN 101
using namespace std;

const int inf = 0x3f3f3f3f;

bool vis[MAXN];
int dis[MAXN], e[MAXN][MAXN];
int ans = 0;
int n, m;

int main() {
	//input data
	//clock_t s = clock();
	//init
	cin >> n;

	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			scanf("%d",&e[i][j]);	
		}
	}

	for (int i = 0; i <= n; i++) {
		dis[i]=inf;
	}
	dis[1] = 0;
	for (int i = 1; i <= n; i++) {
		int k = 0;
		for (int j = 1; j <= n; j++) { //寻找与当前构造完的生成树最近的点
			if (vis[j]) continue;
			if (dis[j] < dis[k]) k = j;
		}

		ans += dis[k];
		vis[k] = true;
		for (int j = 1; j <= n; j++) { //更新其他点到生成树的距离
			if (e[k][j] < dis[j]) {
				dis[j] = e[k][j];
			}
		}
	}
	cout<

1350：【例4-11】最短网络(agrinet)

【题目描述】

农民约翰被选为他们镇的镇长！他其中一个竞选承诺就是在镇上建立起互联网，并连接到所有的农场。当然，他需要你的帮助。约翰已经给他的农场安排了一条高速的网络线路，他想把这条线路共享给其他农场。为了用最小的消费，他想铺设最短的光纤去连接所有的农场。你将得到一份各农场之间连接费用的列表，你必须找出能连接所有农场并所用光纤最短的方案。每两个农场间的距离不会超过100000100000。

【题目分析】

最小生成树模板题，Kruskal算法和Prim算法均可

【代码实现】

Prim算法

#include 
#define MAXN 101
using namespace std;

const int inf = 0x3f3f3f3f;

bool vis[MAXN];
int dis[MAXN], e[MAXN][MAXN];
int ans = 0;
int n, m;

int main() {
	cin >> n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			scanf("%d",&e[i][j]);	
		}
	}

	for (int i = 0; i <= n; i++) {
		dis[i]=inf;
	}
	
	dis[1] = 0;
	for (int i = 1; i <= n; i++) {
		int k = 0;
		for (int j = 1; j <= n; j++) { //寻找与当前构造完的生成树最近的点
			if (vis[j]) continue;
			if (dis[j] < dis[k]) k = j;
		}

		ans += dis[k];
		vis[k] = true;
		for (int j = 1; j <= n; j++) { //更新其他点到生成树的距离
			if (e[k][j] < dis[j]) {
				dis[j] = e[k][j];
			}
		}
	}
	cout<

1351：【例4-12】家谱树

【题目描述】

有个人的家族很大，辈分关系很混乱，请你帮整理一下这种关系。

给出每个人的孩子的信息。

输出一个序列，使得每个人的后辈都比那个人后列出。

【题目分析】

拓扑排序模板题
方法1：移除入度为0的点，并将相邻点的入度减1，依次循环直到所有点都被输出
方法2：对所有的点进行深搜，在每个点返回时加入栈，搜索完成后依次弹出点

【代码实现】

方法1：

#include 

using namespace std;
const int maxn = 1001;
int n;
vector p[maxn];
int indeg[maxn];
int vis[maxn];
queue Q;
int main() {
	cin >> n ;
	for (int i = 1; i <= n; i++) {
		int x;
		while (cin >> x, x != 0) {
			p[i].push_back(x);
			indeg[x]++;
		}
	}
	for (int i = 1; i <= n; i++) { //找到起点
		if (indeg[i] == 0) Q.push(i);
	}
	while (!Q.empty()) {
		int u = Q.front();
		Q.pop();
		cout << u << " ";
		for (int i = 0; i < (int ) p[u].size(); i++) { //依次找后续节点
			if (--indeg[p[u][i]] == 0)
				Q.push(p[u][i]);
		}
	}
	return 0;
}

方法2： 

#include 

using namespace std;

vector p[105];
stack sta;
bool vis[105];
void dfs(int x) {

	for (auto e : p[x]) {
		if (vis[e]) continue;
		vis[e] = 1;
		dfs(e);
	}
	sta.push(x);
}
int main() {
	//input data
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		int x;
		while (cin >> x, x != 0) p[i].push_back(x);
	}

	for (int i = 1; i <= n; i++) {
		if (!vis[i]) vis[i] = 1, dfs(i);
	}

	while (!sta.empty())  cout << sta.top() << " ", sta.pop();
	return 0;
}

1391：局域网(net)

【题目描述】

某个局域网内有n(n≤100)台计算机，由于搭建局域网时工作人员的疏忽，现在局域网内的连接形成了回路，我们知道如果局域网形成回路那么数据将不停的在回路内传输，造成网络卡的现象。因为连接计算机的网线本身不同，所以有一些连线不是很畅通，我们用f(i,j)表示i,j之间连接的畅通程度(f(i,j)≤1000)，f(i,j)值越小表示i,j之间连接越通畅，f(i,j)为00表示i,j之间无网线连接。现在我们需要解决回路问题，我们将除去一些连线，使得网络中没有回路，并且被除去网线的Σf(i,j)最大，请求出这个最大值。

【题目分析】

使得网络中没有回路，并且被除去网线的Σf(i,j)最大，即留下的网线可以生成一个最小生成树，将所有网线的权值相加减去最小生成树的权值，得到最大的移除权值。

算法实现：Kruskal算法或者Prim算法求解最小生成树的权值和

【代码实现】

#include 

using namespace std;
const int maxn = 1001;
struct Edges {
	int u;
	int v;
	int w;
} edge[maxn * 50];
inline bool cmp(const Edges &a, const Edges &b) {
	return a.w < b.w;
}

int n, m;
int father[maxn];
int find(int x) {
	if (father[x] != x)
		father[x] = find(father[x]);
	return father[x];
}
int ans = 0;
int main() {
	//input data
	//clock_t s = clock();
	int sum = 0;
	cin >> n >> m;
	for (int i = 1; i <= m; i++) {
		cin >> edge[i].u >> edge[i].v >> edge[i].w;
		sum += edge[i].w;
	}

	sort(edge + 1, edge + m + 1, cmp);
	for (int i = 1; i <= n; i++) {
		father[i] = i;
	}
	int _count = 0;
	for (int i = 1; i <= m; i++) {
		int fa_u = find(edge[i].u);
		int fa_v = find(edge[i].v);
		if (fa_u != fa_v) {
			ans += edge[i].w;
			father[fa_u] = fa_v;
			_count++;
			if (_count >= n - 1) break;
		}

	}
	cout << sum - ans;
	//output time
	//cout <

1392：繁忙的都市(city)

【题目描述】

城市C是一个非常繁忙的大都市，城市中的道路十分的拥挤，于是市长决定对其中的道路进行改造。城市C的道路是这样分布的：城市中有n个交叉路口，有些交叉路口之间有道路相连，两个交叉路口之间最多有一条道路相连接。这些道路是双向的，且把所有的交叉路口直接或间接的连接起来了。每条道路都有一个分值，分值越小表示这个道路越繁忙，越需要进行改造。但是市政府的资金有限，市长希望进行改造的道路越少越好，于是他提出下面的要求：

1．改造的那些道路能够把所有的交叉路口直接或间接的连通起来。

2．在满足要求1的情况下，改造的道路尽量少。

3．在满足要求1、2的情况下，改造的那些道路中分值最大值尽量小。

作为市规划局的你，应当作出最佳的决策，选择那些道路应当被修建。

【题目分析】

根据题意：将所有交叉路口直接或间接的连接起来，并使得所有路口的分值之和最小，就是求连接所有交叉路口的最小生成树。

算法实现：Kruskal算法或者Prim算法求解最小生成树的权值和

【代码实现】

#include 

using namespace std;
const int maxn = 1001;
struct Edges {
	int u;
	int v;
	int w;
} edge[maxn * 50];
inline bool cmp(const Edges &a, const Edges &b) {
	return a.w < b.w;
}

int n, m;
int father[maxn];
int find(int x) {
	if (father[x] != x)
		father[x] = find(father[x]);
	return father[x];
}
int ans = 0;
int main() {
	//input data
	//clock_t s = clock();
	int sum = 0;
	cin >> n >> m;
	for (int i = 1; i <= m; i++) {
		cin >> edge[i].u >> edge[i].v >> edge[i].w;
		sum += edge[i].w;
	}

	sort(edge + 1, edge + m + 1, cmp);
	for (int i = 1; i <= n; i++) {
		father[i] = i;
	}
	int maxw = 0;
	int _count = 0;
	for (int i = 1; i <= m; i++) {
		int fa_u = find(edge[i].u);
		int fa_v = find(edge[i].v);
		if (fa_u != fa_v) {
			maxw = max(maxw, edge[i].w);
			father[fa_u] = fa_v;
			_count++;
			if (_count >= n - 1) break;
		}

	}
	cout << n - 1 << " " << maxw;
	return 0;
}

1393：联络员(liaison)

【题目描述】

Tyvj已经一岁了，网站也由最初的几个用户增加到了上万个用户，随着Tyvj网站的逐步壮大，管理员的数目也越来越多，现在你身为Tyvj管理层的联络员，希望你找到一些通信渠道，使得管理员两两都可以联络（直接或者是间接都可以）。Tyvj是一个公益性的网站，没有过多的利润，所以你要尽可能的使费用少才可以。

目前你已经知道，Tyvj的通信渠道分为两大类，一类是必选通信渠道，无论价格多少，你都需要把所有的都选择上；还有一类是选择性的通信渠道，你可以从中挑选一些作为最终管理员联络的通信渠道。数据保证给出的通行渠道可以让所有的管理员联通。

【题目分析】

必选的通信渠道相加，将连接点进行并查集合并，对可选的通讯渠道排序，依次选择可选渠道使得所有点连通，Kruskal算法思想

【代码实现】

#include 

using namespace std;
const int maxn = 2005;
struct Edges {
	int u;
	int v;
	int w;
} edge[maxn * 50];
inline bool cmp(const Edges &a, const Edges &b) {
	return a.w < b.w;
}

int n, m;
int father[maxn];
int find(int x) {
	if (father[x] != x)
		father[x] = find(father[x]);
	return father[x];
}
int ans = 0;
int main() {
	//input data
	cin >> n >> m;
	int index = 0;
	int _count = 0;
	for (int i = 1; i <= n; i++) {  //init bing cha ji
		father[i] = i;
	}
	for (int i = 1; i <= m; i++) {
		int x, y, q, w;
		cin >> q >> x >> y >> w;
		if (q == 1) {          //direct solve
			ans += w;
			int fa_x = find(x);
			int fa_y = find(y);
			if (fa_x != fa_y) {
				father[fa_y] = fa_x;
				_count++;
			}
		}
		if (q == 2) {          //save data
			edge[++index].u = x;
			edge[index].v = y;
			edge[index].w = w;
		}

	}
	//sort and add edges
	sort(edge + 1, edge + index + 1, cmp);
	for (int i = 1; i <= index; i++) {
//		cout << edge[i].w << " ";
		int fa_u = find(edge[i].u);
		int fa_v = find(edge[i].v);
		if (fa_u != fa_v) {
			ans += edge[i].w;
			father[fa_v] = fa_u;
			_count++;
			if (_count >= n - 1) break;
		}

	}
	//cout answers
	cout << ans;
	return 0;
}

1394：连接格点(grid)

【题目描述】

有一个M行N列的点阵，相邻两点可以相连。一条纵向的连线花费一个单位，一条横向的连线花费两个单位。某些点之间已经有连线了，试问至少还需要花费多少个单位才能使所有的点全部连通。

【题目分析】

根据已经相连的线，将线的两端点进行并查集合并，枚举竖边将端点并查集合并，费用加1，枚举横边将端点并查集合并，费用加2，输出结果  Kruskal算法思想

【代码实现】

 

#include 

using namespace std;

struct node {
	int x, y;
};
node fa[1005][1005];

node find(node a) {
	if (a.x == fa[a.x][a.y].x && a.y == fa[a.x][a.y].y) return a;
	return fa[a.x][a.y] = find(fa[a.x][a.y]);
}
bool merge(node a, node b) {
	node fa_a = find(a);
	node fa_b = find(b);
	if (fa_a.x != fa_b.x || fa_a.y != fa_b.y) {
		fa[fa_a.x][fa_a.y] = fa_b;
		return true;
	}
	return false;
}
int main() {
	//input data
	int m, n;
	cin >> m >> n;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			fa[i][j] = {i, j};
		}
	}

	int sx, sy, fx, fy;
	while (cin >> sx >> sy >> fx >> fy) {
		merge({sx, sy}, {fx, fy});
	}

	int sum = 0;
	//先枚举竖边
	for (int i = 1; i < m; i++) {
		for (int j = 1; j <= n; j++) {
			if (merge({i, j}, {i + 1, j})) sum++;
		}
	}
	//再枚举横边
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j < n; j++) {
			if (merge({i, j}, {i, j + 1})) sum += 2;
		}
	}
	cout << sum << endl;
	return 0;
}