CSP 201709-4 通信网络（DFS，BFS）两种解法

201709-4

问题描述

某国的军队由N个部门组成，为了提高安全性，部门之间建立了M条通路，每条通路只能单向传递信息，即一条从部门a到部门b的通路只能由a向b传递信息。信息可以通过中转的方式进行传递，即如果a能将信息传递到b，b又能将信息传递到c，则a能将信息传递到c。一条信息可能通过多次中转最终到达目的地。
　　　　由于保密工作做得很好，并不是所有部门之间都互相知道彼此的存在。只有当两个部门之间可以直接或间接传递信息时，他们才彼此知道对方的存在。部门之间不会把自己知道哪些部门告诉其他部门。
　
　　　　上图中给了一个4个部门的例子，图中的单向边表示通路。部门1可以将消息发送给所有部门，部门4可以接收所有部门的消息，所以部门1和部门4知道所有其他部门的存在。部门2和部门3之间没有任何方式可以发送消息，所以部门2和部门3互相不知道彼此的存在。
　　　　现在请问，有多少个部门知道所有N个部门的存在。或者说，有多少个部门所知道的部门数量（包括自己）正好是N。

输入格式

输入的第一行包含两个整数N, M，分别表示部门的数量和单向通路的数量。所有部门从1到N标号。
　　　　接下来M行，每行两个整数a, b，表示部门a到部门b有一条单向通路。

输出格式

输出一行，包含一个整数，表示答案。

样例输入

4 4
1 2
1 3
2 4
3 4

样例输出

2

样例说明

部门1和部门4知道所有其他部门的存在。

数据规模

对于30%的评测用例，1 ≤ N ≤ 10，1 ≤ M ≤ 20；
　　　　对于60%的评测用例，1 ≤ N ≤ 100，1 ≤ M ≤ 1000；
　　　　对于100%的评测用例，1 ≤ N ≤ 1000，1 ≤ M ≤ 10000。

分析

题目要求

“知道所有N个部门都存在的部门的数量”

解题思路

题中所描述的是两个部门的单向关系（即a向b传递信息）。但实际上a与b的关系是双向关系（即相互知晓对方的存在）。

由此我们不难想到建立一个二维数组储存各个点（部门）的关系。若某个点（部门）与其他所有点（部门）都有关系即是所求点。

数据结构

对于图的数据结构，我们最熟悉的就是邻接矩阵。但在此题中，一个点（部门）可能与多个点（部门）有联系。链接矩阵难以处理这样的问题。所以我们选择邻接表，邻接表通常用链表实现，但对于这道算法题显然有些小题大做。好在c++的stl的vector可以有效的解决这个问题。（具体实现见代码）

算法分析

我们需要遍历所有的点（部门）来储存它们的关系，可以使用DFS或BFS来实现。

此题提供了两种实现（BFS，DFS）的代码。

AC代码

BFS

//BFS
#include<bits/stdc++.h>
using namespace std;
void clearq(queue<int>& q) {
	queue<int> empty;
	swap(empty, q);
}
int main() {
	int n, m;
	cin >> n >> m;
	
	vector<vector<int> > G(n+1, vector<int>());
	vector<vector<bool> > matrix(n + 1, vector<bool>(n + 1, false));
	
	int a, b;
	for (int i = 0; i < m; i++) {//输入
		cin >> a >> b;
		G[a].push_back(b);
	}

	vector<bool> vis;
	queue<int> q;
	for (int i = 1; i <= n; i++) {//对每一个点都进行BFS
		clearq(q);
		vis = vector<bool>(n + 1, false);
		q.push(i);
		vis[i] = true;
		while (!q.empty()) {//BFS主体
			int v = q.front();
			matrix[i][v] = true;//储存
			matrix[v][i] = true;//关系
			q.pop();

			vis[v] = true;
			int size = G[v].size();
			for (int j = 0; j < size; j++) {
				if (!vis[G[v][j]]) {
					q.push(G[v][j]);
					vis[G[v][j]] = true;
				}
			}
		}
	}
	int count = 0;

	for (int i = 1; i <= n; i++) {
		int sum = 0;
		for (int j = 1; j <= n; j++) {
			sum += matrix[i][j];
		}
		if (sum == n)//若与所有点都有关系，计数器加1；
			count++;
	}
	cout << count;
	return 0;
}

DFS

//DFS
#include<bits/stdc++.h>
using namespace std;
void dfs(int i);
int n, m, ths;
vector<vector<bool> > matrix;//此代码的DFS以递归实现，所以变量大多使用全局变量
vector<vector<int> > G;
vector<bool> vis;

int main() {
	cin >> n >> m;
	G = vector<vector<int> >(n + 1, vector<int>());
	matrix = vector<vector<bool> >(n + 1, vector<bool>(n + 1, false));

	int a, b;
	for (int i = 0; i < m; i++) {
		cin >> a >> b;
		G[a].push_back(b);
	}
	
	for (int i = 1; i <= n; i++) {
		vis = vector<bool>(n + 1, false);//新一轮的遍历，初始化vis数组
		ths = i;
		dfs(i);
	}

	int count = 0;
	for (int i = 1; i <= n; i++) {
		int sum = 0;
		for (int j = 1; j <= n; j++) {
			sum += matrix[i][j];
		}
		if (sum == n)
			count++;
	}
	cout << count;
	return 0;
}
void dfs(int i) {
	if (vis[i]) { return; }
	vis[i] = true;
	int size = G[i].size();
	matrix[i][ths] = true;// 储存
	matrix[ths][i] = true;// 关系

	for (int j = 0; j < size; j++) {//向子节点深入
		int u = G[i][j];
		dfs(u);
	}
}