题目描述

某国的军队由 N 个部门组成，为了提高安全性，部门之间建立了 M 条通路，
每条通路只能单向传递信息，即一条从部门 a 到部门 b 的通路只能由 a 向 b 传递信息。

信息可以通过中转的方式进行传递，即如果 a 能将信息传递到 b，b 又能将信息传递到 c，则 a 能将信息传递到 c 。

一条信息可能通过多次中转最终到达目的地。

由于保密工作做得很好，并不是所有部门之间都互相知道彼此的存在。

只有当两个部门之间可以直接或间接传递信息时，他们才彼此知道对方的存在。

部门之间不会把自己知道哪些部门告诉其他部门。
图中的单向边表示通路。

部门 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。

//建立正向图和反向图，分别沿着两个方向遍历，中途不改变方向，
//然后查看每个点是否能够走到n个点，能够走到说明此节点直到所有
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 1010,M = 20010;

int e[M],ne[M],h1[N],h2[N],idx;
int n,m;
int st1[N],st2[N];

void add(int h[],int a,int b)
{
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}

void dfs(int u,int h[],int st[])
{
    st[u] = true;
    for(int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if(!st[j]) dfs(j,h,st);
    }
}

int main()
{
    cin>>n>>m;
    memset(h1,-1,sizeof h1);
    memset(h2,-1,sizeof h2);
    while(m--)
    {
        int a,b;
        cin>>a>>b;
        add(h1,a,b),add(h2,b,a);
    }
    int res = 0;
    //枚举一下所有点看是否满足要求
    for(int i = 1; i<=n; i++)
    {
        memset(st1,0,sizeof st1);
        memset(st2,0,sizeof st2);
        //沿着正向边和反向边遍历一下
        dfs(i,h1,st1);
        dfs(i,h2,st2);
        //如果正向或者反向遍历，这个点可以遍历到n个点，即知道所有部门的数量
        int s = 0;
        for(int j = 1; j<=n; j++)
            if(st1[j] || st2[j]) 
                s++;
        if(s==n) res++;
    }
    cout<<res;
    return 0;
}