可达性统计（拓扑排序逆推）

给定一张N个点M条边的有向无环图，分别统计从每个点出发能够到达的点的数量。

输入格式

第一行两个整数N,M，接下来M行每行两个整数x,y，表示从x到y的一条有向边。

输出格式

输出共N行，表示每个点能够到达的点的数量。

数据范围

1≤N,M≤300001≤N,M≤30000

输入样例：

10 10
3 8
2 3
2 5
5 9
5 9
2 3
3 9
4 8
2 10
4 9

输出样例：

1
6
3
3
2
1
1
1
1
1

思路：每一个节点可到达的节点总数等于其所有子节点可达到的节点之和，利用bitset降低空间复杂度以及或运算求可达节点数。 

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <cstdio>
#include <bitset>
using namespace std;
const int N=30010,M=N*2;
//std::ios::sync_with_stdio(false); 读入优化
struct node{
  int a,b,w;
  bool operator <(const node &W){
   return w<W.w;
  }
}E[N];



int n,m,ans,res;
int e[N],h[N],ne[N],idx;
int d[N],seq[N];
bitset<N> f[N];


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

void topsort()
{
    int k=0;
    queue<int> q;
    for(int i=1;i<=n;i++)
        if(!d[i])
          q.push(i);
    while(q.size())
    {
        int t=q.front();
        q.pop();
        seq[k++]=t;
        for(int i=h[t];~i;i=ne[i])
        {
            int j=e[i];
            d[j]--;
            if(!d[j])
                q.push(j);
        }
    }
}

int main(){
 std::ios::sync_with_stdio(false);
 memset(h,-1,sizeof(h));
 cin>>n>>m;
 for(int i=1;i<=m;i++)
 {
     int a,b;
     cin>>a>>b;
     add(a,b);
     d[b]++;
 }
 topsort();
 for(int i=n-1;i>=0;i--){
    int j=seq[i];
    f[j][j]=1;
    for(int k=h[j];~k;k=ne[k])
    {
        f[j]|=f[e[k]];
    }
 }
 for(int i=1;i<=n;i++) cout<<f[i].count()<<endl;
 return 0;
}