PAT-ADVANCED1013——Battle Over Cities
我的PAT-ADVANCED代码仓：https://github.com/617076674/PAT-ADVANCED
原题链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805500414115840
题目描述：
题目翻译：
1013 城市之间的战争
在战争中，所有的城市都通过高速公路连接在一起，这一点是至关重要的。如果一个城市被敌人占领了，那么所有连接这个城市的高速公路都会被封闭。我们必须马上知道为了使得余下的城市保持连接状态，我们是否需要修建其他的高速公路。给你一张城市地图，上面标识出了所有余下的高速公路，你需要快速说出需要修建的高速公路的数量。
举个例子，如果我们有3座城市，2条高速公路分别连接city1-city2、city1-city3。如果city1被敌人占领了，我们就需要修建一条高速公路，那就是city2-city3。
输入格式：
每个输入文件包含一个测试用例。对每个测试用例，第一行包含3个数字：N(<= 1000)表示城市总数量，M表示高速公路数量，K表示需要检查的城市数量。接下来的M行，每行用2个整数描述一条高速公路，这2个整数分别代表这条高速公路所连接的两个城市的编号。城市编号从1到N。最后一行有K个数字，代表了我们关注的城市。
输出格式：
对K个城市中的每一个城市，分别在1行中输出如果该城市被敌人占领所需要修建的高速公路的数量。
输入样例：
3 2 3
1 2
1 3
1 2 3输出样例：
1
0
0知识点：图的深度优先遍历、并查集
思路一：图的深度优先遍历（邻接矩阵实现）
本题的实质是求除去某个点之外，图中有几个连通块。用图的深度优先遍历算法即可。
时间复杂度是O(K * N)。空间复杂度是O(N ^ 2)。
注意点：
城市编号是1 ~ N，而不是0 ~ N - 1。
C++代码：
#include
#include
using namespace std;
int N, M, K;
vector graph[1001];
int lost_city, count;
bool visited[1001];
void dfs(int nowVisit);
int main(){
scanf("%d %d %d", &N, &M, &K);
int city1, city2;
for(int i = 0; i < M; i++){
scanf("%d %d", &city1, &city2);
graph[city1].push_back(city2);
graph[city2].push_back(city1);
}
for(int i = 0; i < K; i++){
fill(visited + 1, visited + N + 1, false);
count = 0;
scanf("%d", &lost_city);
for(int j = 1; j <= N; j++){
if(j == lost_city){
continue;
}
if(!visited[j]){
dfs(j);
count++;
}
}
printf("%d\n", count - 1);
}
return 0;
}
void dfs(int nowVisit){
visited[nowVisit] = true;
for(int i = 0; i < graph[nowVisit].size(); i++){
int v = graph[nowVisit][i];
if(!visited[v] && v != lost_city){
dfs(v);
}
}
} C++解题报告：
思路二：并查集（邻接表实现）
时间复杂度是O(kN)。空间复杂度是O(N + M)。
注意为并查集添加路径压缩操作。
C++代码：
#include
#include
#include
using namespace std;
struct edge{
int u, v;
edge(int _u, int _v){
u = _u;
v = _v;
}
};
int N, M, K;
vector edges;
int lost_city, count;
int father[1001];
set fathers;
int findFather(int x);
void unionTwo(int a, int b);
int main(){
scanf("%d %d %d", &N, &M, &K);
int city1, city2;
for(int i = 0; i < M; i++){
scanf("%d %d", &city1, &city2);
edges.push_back(edge(city1, city2));
}
for(int i = 0; i < K; i++){
for(int j = 1; j < N + 1; j++){
father[j] = j;
}
count = 0;
fathers.clear();
scanf("%d", &lost_city);
for(int j = 0; j < edges.size(); j++){
if(edges[j].u == lost_city || edges[j].v == lost_city){
continue;
}
unionTwo(edges[j].u, edges[j].v);
}
for(int j = 1; j < N + 1; j++){
if(j == lost_city){
continue;
}
fathers.insert(findFather(j));
}
printf("%d\n", fathers.size() - 1);
}
return 0;
}
int findFather(int x){
int a = x;
while(x != father[x]){
x = father[x];
}
while(a != father[a]){
int z = a;
a = father[a];
father[z] = x;
}
return x;
}
void unionTwo(int a, int b){
int a_father = findFather(a);
int b_father = findFather(b);
if(a_father != b_father){
father[a_father] = b_father;
}
} C++解题报告：
思路三：图的广度优先遍历（邻接表实现）
本题的实质是求除去某个点之外，图中有几个连通块。用图的广度优先遍历算法也可以实现。
时间复杂度是O(K * N)。空间复杂度是O(N + K)。
C++代码：
#include
#include
#include
using namespace std;
int N, M, K;
vector graph[1001]; //无向图
bool inq[1001];
int lost_city, count;
void bfs(int nowVisit);
int main() {
scanf("%d %d %d", &N, &M, &K);
int city1, city2;
for(int i = 0; i < M; i++) {
scanf("%d %d", &city1, &city2);
graph[city1].push_back(city2);
graph[city2].push_back(city1);
}
for(int i = 0; i < K; i++) {
scanf("%d", &lost_city);
count = 0;
fill(inq + 1, inq + N + 1, false);
for(int j = 1; j < N + 1; j++) {
if(j == lost_city) {
continue;
}
if(!inq[j]) {
bfs(j);
count++;
}
}
printf("%d\n", count - 1);
}
return 0;
}
void bfs(int nowVisit) {
queue q;
q.push(nowVisit);
inq[nowVisit] = true;
while(!q.empty()) {
int now = q.front();
q.pop();
for(int i = 0; i < graph[now].size(); i++) {
if(graph[now][i] != lost_city && !inq[graph[now][i]]) {
q.push(graph[now][i]);
inq[graph[now][i]] = true;
}
}
}
} C++解题报告：
