PAT1 1013 Battle Over Cities

题目链接
我的github

题目大意

有$N$个城市，这些城市之间共有$M$条边（无向边），如果某个城市被摧毁，那么它的边也会摧毁，现在告诉了$K$个城市，要求假设对每个$K_i$城市，如果被摧毁了，则最少需要新建多少条边才能将剩下的城市连通。
城市的编号从$1$~$N$

输入

每组包含一个测试用例，每个用例的第一行有三个数$N,M,K$且$N$＜1000，接下来有$M$行，每行有两个整数表示这两个整数所对应的城市之间是连通的，最后一行有$K$个数

输出

对每个$K_i$城市以一行输出如果这个城市被摧毁了，将剩下的城市连通所需要新建的边数

样例输入

3 2 3
1 2
1 3
1 2 3

样例输出

1
0
0

解析

这道题本质上就是要求对每个可能被摧毁的城市，求剩下的无向图的连通分量数cnt，那么需要新建的边的数量就是cnt-1
对每个城市使用dfs遍历所有与它相连通的城市并做上标记，同时cnt++这样遍历完之后就是要求的连通分量数
不知道为什么，python总是过不了，据说是python的input输入的锅，在处理大量输入的时候会比较慢，所以过不了

def dfs(node):
    global n, m, k, edge, city
    city[node] = True
    for i in range(n):
        if edge[node][i] and (not city[i]):
            dfs(i)


n, m, k = 0, 0, 0
edge = list()  #城市之间是否连通
city = list()  #城市是否访问过


def solve():
    global n, m, k, edge, city
    n, m, k = map(int, input().split())
    edge = [[False for i in range(n)] for j in range(n)]
    for i in range(m):
        c1, c2 = map(int, input().split())
        edge[c1 - 1][c2 - 1] = edge[c2 - 1][c1 - 1] = True
    check = list(map(int, input().split()))
    for i in range(k):
        cnt = 0  #连通分量
        city = [False for j in range(n)]
        city[check[i] - 1] = True  #将自己排除
        for j in range(n):
            if not city[j]:
                dfs(j)   #dfs将连通的城市都访问一遍
                cnt += 1
        print(cnt - 1)


if __name__ == "__main__":
    solve()

但是我又用c++写了一遍，思路一样，然后过了

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<cstring>
#include<string>
#include<cmath>

#define inf 0xffffffff

using namespace std;

const int maxn=1005;

int n, m, k;
bool city[maxn];  //城市是否访问过
bool edge[maxn][maxn];  //城市之间是否连通

void dfs(int node)
{
    city[node]=true;
    for(int i=0; i<n; i++)
        if(edge[node][i]&&!city[i])
        {
            city[i]=true;
            dfs(i);
        }
}

int main()
{
    while(~scanf("%d%d%d", &n, &m, &k))
    {
        memset(edge, 0, sizeof(edge));
        for(int i=0; i<m; i++)
        {
            int c1, c2;
            scanf("%d%d", &c1, &c2);
            edge[c1-1][c2-1]=edge[c2-1][c1-1]=true;
        }
        for(int i=0; i<k; i++)
        {
            int node;
            scanf("%d", &node);
            memset(city, 0, sizeof(city));
            city[node-1]=true;
            int cnt=0;   //连通分量
            for(int j=0; j<n; j++)
                if(!city[j])
                {
                    dfs(j);   //dfs将连通的城市都访问一遍
                    cnt++;
                }
            printf("%d\n", cnt-1);
        }
    }
    return 0;
}