【PAT】【割点】1013 Battle Over Cities

 

1013 Battle Over Cities (25 分)

It is vitally important to have all the cities connected by highways in a war. If a city is occupied by the enemy, all the highways from/toward that city are closed. We must know immediately if we need to repair any other highways to keep the rest of the cities connected. Given the map of cities which have all the remaining highways marked, you are supposed to tell the number of highways need to be repaired, quickly.

For example, if we have 3 cities and 2 highways connecting city​1​​-city​2​​ and city​1​​-city​3​​. Then if city​1​​ is occupied by the enemy, we must have 1 highway repaired, that is the highway city​2​​-city​3​​.

Input Specification:

Each input file contains one test case. Each case starts with a line containing 3 numbers N (<1000), M and K, which are the total number of cities, the number of remaining highways, and the number of cities to be checked, respectively. Then M lines follow, each describes a highway by 2 integers, which are the numbers of the cities the highway connects. The cities are numbered from 1 to N. Finally there is a line containing K numbers, which represent the cities we concern.

Output Specification:

For each of the K cities, output in a line the number of highways need to be repaired if that city is lost.

Sample Input:

3 2 3
1 2
1 3
1 2 3

Sample Output:

1
0
0

1013城市之战（25分）

大致题意：

在战争中，所有城市都必须通过高速公路连接起来，这一点至关重要。如果一个城市被敌人占领，则从该城市/往该城市的所有高速公路都将关闭。我们必须立即知道是否需要维修其他高速公路以保持其余城市的连通性。给出了标有所有剩余高速公路的城市地图，您应该告诉我们需要快速修复的高速公路数量。

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;

//解题思路：
//tarjan解法，求割点以及对应的连通分量数
//需要修建的路则是连通分量数-1，时间复杂度O(n + m);
//也可以暴力，对于每次查询循环dfs到访问全部节点，dfs次数则是连通分量数
//坑点，测试点3：有可能图一开始就不是连通的，分成了多个图
inline void read(int &x)
{
    register int f = 1; x = 0;
    register char c = getchar();
    while(c > '9' || c < '0')
    {
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9')
    {
        x = (x << 3) + (x << 1) + (c ^ 48);
        c = getchar();
    }
    x *= f;
}

const int maxn = 2e3 + 5;
vector<int> mp[maxn];
int num[maxn], low[maxn];
int cut[maxn];

//时间戳
int dfn;
void dfs(int u, int fa)
{
    low[u] = num[u] = ++dfn;
    for(int i = 0; i< mp[u].size(); i++)
    {
        int v = mp[u][i];
        if(!num[v])
        {
            dfs(v, u);
            low[u] = min(low[v], num[u]);
//            得到割点及其对应的连通分量数，除根节点外这里的结果已经是减一的了
            if(low[v] >= num[u])
            {
                cut[u]++;
            }
        }
//        父节点已经访问过，不算在内
        else if(num[v] < num[u] && v != fa)
        {
            low[u] = min(num[v], low[u]);
        }
    }
}

int main()
{
    int n, m, q; read(n); read(m); read(q);
    for(int u, v, i = 1; i <= m; i++)
    {
        read(u); read(v);
        mp[u].push_back(v);
        mp[v].push_back(u);
    }
//    对每个没访问过的点跑dfs，一共跑的次数则是一开始的连通分量数
    int cnt(0);
    for(int i = 1; i <= n; i++)
    {
        if(!num[i])
        {
            dfs(i, -1);
            cnt++;
//            对根节点减一
            cut[i]--;
        }
    }
//    每次查询输出结果就可以了
    for(int t, i = 1; i <= q; i++)
    {
        read(t);
        printf("%d\n", cut[t] + cnt - 1);
    }
    return 0;
}