AcWing 3250. 通信网络（枚举 + BFS + DFS）

题目链接

某国的军队由 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 有一条单向通路。

输出格式

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

数据范围

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

输入样例：

4 4
1 2
1 3
2 4
3 4

输出样例：

2

样例解释

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

思路：

建立正向图和反向图，分别沿着两个方向遍历，中途不改变方向，然后查看每个点是否能被其中一个方向遍历的过程中走到

答案：

#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define inf 0x3f3f3f3f3f3f3f3f
#define rep(i,a,b) for(auto i=a;i<=b;++i)
#define bep(i,a,b) for(auto i=a;i>=b;--i)
#define lowbit(x) x&(-x)
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define PI acos(-1)
#define pb push_back
#define eps 1e-6
const int mod = 1e9 + 7;
const int MOD = 1e4+7;
const int N = 2e6 + 10;
const int M = 1111;
int dx[]={-1, 0, 1, 0};
int dy[]={0, 1, 0, -1};
int dxy[][2]={{0,1},{1,0},{1,1},{-1,1}};
using namespace std;

int hp[M][2];
int dp[MOD][2];
int mp[MOD][2];
int tot[2];
int vis[M][2];

void add(int u,int v,int k){
    dp[++tot[k]][k]=v;
    mp[tot[k]][k]=hp[u][k];
    hp[u][k]=tot[k];
}

void DFS(int u,int k){
    for(int i=hp[u][k];i;i=mp[i][k]){
        int v=dp[i][k];
        if(!vis[v][k]){
            vis[v][k]=1;
            DFS(v,k);
        }
    }
}

bool judge(int n){
    rep(i,1,n){
        if(!vis[i][0]&&!vis[i][1]) return 0;
    }
    return 1;
}

void solve(){
    int n,m;
    cin>>n>>m;
    while(m--){
        int u,v;
        cin>>u>>v;
        add(u,v,0);
        add(v,u,1);
    }
    int ans=0;
    rep(i,1,n){
        memset(vis,0,sizeof(vis));
        vis[i][0]=vis[i][1]=1;
        DFS(i,0);
        DFS(i,1);
        if(judge(n)) ans++;
    }
    cout<<ans<<endl;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    solve();
	return 0;
}