天梯赛 L2-013 红色警报 (25 分) 暴搜/并查集

这篇博客介绍了两种解决城市连通性问题的方法,包括深度优先搜索(DFS)和并查集。在战争场景下,当失去一个城市可能导致国家分裂成多个无法连通的区域时,程序会触发红色警报。通过输入城市和道路信息以及被占领的城市,代码会判断并输出是否触发警报。最后,如果所有城市都被占领,程序会输出'GameOver.'。

天梯赛 L2-013 红色警报 (25 分)


题目

战争中保持各个城市间的连通性非常重要。本题要求你编写一个报警程序,当失去一个城市导致国家被分裂为多个无法连通的区域时,就发出红色警报。注意:若该国本来就不完全连通,是分裂的k个区域,而失去一个城市并不改变其他城市之间的连通性,则不要发出警报。

输入

输入在第一行给出两个整数N(0 < N ≤ 500)和M(≤ 5000),分别为城市个数(于是默认城市从0到N-1编号)和连接两城市的通路条数。随后M行,每行给出一条通路所连接的两个城市的编号,其间以1个空格分隔。在城市信息之后给出被攻占的信息,即一个正整数K和随后的K个被攻占的城市的编号。
注意:输入保证给出的被攻占的城市编号都是合法的且无重复,但并不保证给出的通路没有重复。

输出格式:

对每个被攻占的城市,如果它会改变整个国家的连通性,则输出Red Alert: City k is lost!,其中k是该城市的编号;否则只输出City k is lost.即可。如果该国失去了最后一个城市,则增加一行输出Game Over.

测试样例

输入样例:

5 4
0 1
1 3
3 0
0 4
5
1 2 0 4 3

输出样例:

City 1 is lost.
City 2 is lost.
Red Alert: City 0 is lost!
City 4 is lost.
City 3 is lost.
Game Over.

简单分析:

  • DFS暴搜
  • 并查集

代码:

1.暴搜

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;

const int N = 510;

int n, m, k;
vector<int> g[N];
bool st[N];

void dfs(int u) {
	st[u] = true;
	for (int i = 0; i < g[u].size(); i++)
		if (!st[g[u][i]])
			dfs(g[u][i]);
}

int cnt() {
	int cnt = 0;
	for (int i = 0; i < n; i++)
		if (!st[i]) {
			cnt++;
			dfs(i);
		}
	memset(st, 0, sizeof st);
	return cnt;
}

int main() {
	cin >> n >> m;
	for (int i = 0; i < m; i++) {
		int a, b;
		cin >> a >> b;
		g[a].push_back(b);
		g[b].push_back(a);
	}

	int sum = cnt();
	vector<int> lost;

	cin >> k;
	for (int i = 0; i < k; i++) {
		int x;
		cin >> x;
		lost.push_back(x);
		for (int j = 0; j < lost.size(); j++)
			st[lost[j]] = true;

		int cur = cnt();
		if (cur <= sum) printf("City %d is lost.\n", x);
		else printf("Red Alert: City %d is lost!\n", x);

		sum = cur;
	}
	if (n == lost.size()) puts("Game Over.");

	return 0;
}

2.并查集

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1e4;

int n, m, k;
int p[N];
bool st[N];

struct node {
	int x, y;
}a[N];

int find(int x) {
	if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}

void merge(int x, int y) {
	x = find(x), y = find(y);
	p[x] = y;
}

int main() {
	cin >> n >> m;
	for (int i = 1; i < n; i++) p[i] = i;

	for (int i = 0; i < m; i++) {
		cin >> a[i].x >> a[i].y;
		merge(a[i].x, a[i].y);
	}

	int sum = 0;
	for (int i = 0; i < n; i++)
		if (p[i] == i)
			sum++;

	cin >> k;
	bool flag = false;
	if (k >= n) flag = true;

	while (k--) {
		int x, cnt = 0;
		cin >> x;
		st[x] = true;

		for (int i = 0; i < n; i++) p[i] = i;
		for (int i = 0; i < m; i++) {
			if (st[a[i].x] || st[a[i].y]) continue;
			merge(a[i].x, a[i].y);
		}
		for (int i = 0; i < n; i++)
			if (p[i] == i)
				cnt++;

		if (cnt == sum || cnt - 1 == sum) printf("City %d is lost.\n", x);
		else printf("Red Alert: City %d is lost!\n", x);
		sum = cnt;
	}
	if (flag) puts("Game Over.");

	return 0;
}

感悟

努力学习中

参考

1暴搜
2并查集

### L2-013 红色警报 Java 并查集 实现与解题思路 L2-013 红色警报问题通常涉及图的连通性析,使用并查集(Union-Find)是一种高效的解决方案。以下是基于并查集的实现和解题思路。 #### 解题思路 1. **初始化并查集**:为每个城市配一个独立的集合,初始时每个城市的父节点是自身。 2. **处理边的关系**:对于每一对有直接联系的城市,通过并查集的合并操作将它们归入同一集合。 3. **统计连通量的数量**:在所有关系处理完毕后,统计有多少个不同的连通量,即有多少组相互有联系的城市。 4. **输出结果**:根据题目要求输出连通量的具体信息或数量。 #### Java 并查集实现代码 以下是一个完整的 Java 实现代码: ```java import java.util.*; public class Main { private static int[] parent; // 并查集数组,用于存储每个节点的父节点 public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); // 城市数量 int M = scanner.nextInt(); // 道路数量 // 初始化并查集 parent = new int[N]; for (int i = 0; i < N; i++) { parent[i] = i; } // 处理道路关系 for (int i = 0; i < M; i++) { int cityA = scanner.nextInt(); int cityB = scanner.nextInt(); union(cityA, cityB); } // 统计连通量数量 Set<Integer> connectedComponents = new HashSet<>(); for (int i = 0; i < N; i++) { connectedComponents.add(find(i)); } // 输出结果 System.out.println(connectedComponents.size()); for (Integer root : connectedComponents) { List<Integer> group = new ArrayList<>(); for (int i = 0; i < N; i++) { if (find(i) == root) { group.add(i); } } Collections.sort(group); // 按编号排序 System.out.print(group.size() + " "); for (int city : group) { System.out.print(city + " "); } System.out.println(); } } // 查找操作:路径压缩 private static int find(int x) { if (parent[x] != x) { parent[x] = find(parent[x]); } return parent[x]; } // 合并操作 private static void union(int x, int y) { int rootX = find(x); int rootY = find(y); if (rootX != rootY) { parent[rootX] = rootY; } } } ``` #### 代码解析 1. **初始化**:`parent` 数组用于记录每个节点的父节点,初始时每个节点的父节点是其自身[^5]。 2. **查找操作**:`find` 方法实现了路径压缩,确保每次查找的时间复杂度接近 O(1)。 3. **合并操作**:`union` 方法将两个节点所在的集合合并为一个集合。 4. **统计连通量**:通过 `Set` 数据结构记录所有不同的根节点,这些根节点代表了不同的连通量。 #### 注意事项 - 输入数据中可能包含重复的道路关系,但并查集的特性可以自动忽略重复的合并操作。 - 输出时需要对每个连通量内的城市按编号从小到大排序[^6]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值