PATA 1013 Battle Over Cities（25 分）解题报告

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 Knumbers, 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

作者: CHEN, Yue

单位: 浙江大学

时间限制: 400 ms

内存限制: 64 MB

代码长度限制: 16 KB

 

题目大意：城市与城市之间依靠高速公路连接，在战争中，如果一个城市受到攻击，那么与这个城市相连的所有道路，都会无法连通，题目要求你求出当指定的城市被攻击之后，剩下的城市需要修多少条路才能全部连通。首行输入n,m,k分别代表城市数量，道路数量，和待检测城市数量，在之后的m行中，通过给出道路两端城市的方式给出道路，最后一行给出待检测城市的编号。

解题思路：本题的实质是，在一个连通分量中抹去一个点和他的所有边，要求你求出还至少需要多少条边能让整个图重新变成一个连通分量，也就是连通分量的个数-1；注意，每检测一个城市之前，需要对visit数组进行一次初始化。我们调用BFS去遍历整个图，看需要多少次BFS才能把整个图中的所有点遍历完，调用BFS的次数就是连通分量的个数。

 

AC代码：

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int maxn=1010;
bool inq[maxn]={false};
int G[maxn][maxn]={0};
int query[maxn];
int n,m,k,nowpoint;
void BFS(int u); 
int main()
{
	scanf("%d%d%d",&n,&m,&k);
	int c1,c2;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&c1,&c2);
		G[c1][c2]=777;
		G[c2][c1]=777;
	}
	for(int i=0;i<k;i++)
	{
		cin>>nowpoint;
		memset(inq,false,sizeof(inq));
		int block=0;
		inq[nowpoint]=true;
		for(int j=1;j<=n;j++)
		{
			if(j!=nowpoint&&inq[j]==false)
			{
				BFS(j);
				block++;
			}
		}
		printf("%d\n",block-1);
	}
	return 0;
}

void BFS(int u)
{
	//cout<<"coming again"<<endl;
	queue<int> q;
	q.push(u);
	inq[u]=true;
	while(!q.empty())
	{
		int u=q.front();
		//cout<<"now node is "<<u<<endl;
		if(u==nowpoint)//遇到被攻击点，直接返回，当做该点不存在 
			return;
		q.pop();
		for(int i=1;i<=n;i++)
		{
			if(G[u][i]==777&&inq[i]==false&&i!=nowpoint)
			{//边存在，点未访问，且点不是当前要删除的点 
				inq[i]=true;
				q.push(i);
			}
		}
	}
}

//删除一个点以及和这个点相邻的所有边
//试问最少需要连接多少条边才能使剩下的点依然是一个连通分量
//其实就是删除一点和其边之后，求连通分量的数量，-1就得到了答案