[HAOI2006]受欢迎的牛 tarjan缩点 + 拓扑排序

～～～题面～～～

题解：

首先tarjan缩点应该还是容易想到的，因为喜爱具有传递性，所以一个强联通分量里面的点实际上是全部等效的，所以我们可以缩成一个方便判断，

缩完点之后整张图就变成了一个有向无环图，这时我们的目标是要找到所有的可以被所有节点到达的节点（此处的节点已经是缩完后的了）

你可能会注意到“所有的”被划去了，为什么呢？

　　其实这是一个非常妙的性质，因为这样的节点最多只会有一个。

why?

这就是缩点的妙处所在了，我们注意到缩点之后是没有环的。

现在我们假设我们找到了一个合法的节点，我们称之为明星节点。

那么它将有什么性质？

我们已经知道，图上所有节点都可以到达它，这意味着什么？

一旦这个节点有出度，这个出度必然连向图上的某个点x，而这个点x可以到达这个明星节点，于是我们将得到一个环。

但这和我们的前提是不符的，因为我们已经缩过点了，这是一个有向无环图，因此这是不可能出现的。

于是我们就得到了一条非常妙的性质，即明星节点必然无出度。

因此我们要找明星节点，直接找图上没有出度的那个节点就OK了。

但还必须符合一个条件，那就是这个图必须联通，

为了方便判断这一点，我们缩点后的重新建图时，我们反向连边，

这样明星节点就是没有入度的那个节点，于是我们可以顺着这个节点遍历整张图，

最后我们枚举一个是不是每个节点都被遍历到就可以判断图是否联通了。

当然这时你有可能注意到我并没有解释为什么明星节点只会有一个，其实转化到这一步这个结论就很清晰了。

假设我们现在有两个明星节点，分别是x,y,那么这意味着什么？

x和y都没有入度，，，那请问x如何才能到y呢？那么显然这两个所谓的明星节点就都是不合法的了。

这种情况可以被包括在上一种情况当中（代码实现上），因为我们可以只从第一个遇到的入度为0的节点开始遍历，

遍历完就直接判断+输出了，因为这时遍历不完还有可能是有另一个入口（即两个都是伪明星节点），这就是第二种情况了

 #include<bits/stdc++.h>
 using namespace std;
 #define R register int
 #define getchar() *o++
 #define AC 101000
 #define ac 1200000
 char READ[],*o=READ;
 /*所有点可以到一个点，就是这个点可以到其他所有点，
 所以要反向建边？但是感觉DP的时候又不能是反向边，，，
 先缩点，然后拓扑排序，再按照拓扑序顺序更新，
 可以到达所有块的联通块，块内的奶牛就都是明星奶牛
 所以复杂度nm？？？
 开bitset记录f[i]的到达情况，

 好吧其实有一种非常妙的做法，
 因为缩完点之后，就变成了有向无环图，
 那么如果一个联通块是明星联通块的话，它必然没有出度，
 因为所有点都可以到它，如果它还可以到其他点，那就成环了，
 而且这样的点必然只有一个，因为如果有两个点（或以上）没有出度，
 假如这两个点是a，b，那既然a，b都没有出度，a，b必然不能互达，
 所以先缩点，然后拓扑排序统计出度（特判若图不连通 or 出度为0的点大于等于2那就不合法），
 不过貌似可以这样：
 缩点后反向建边，找到第一个入度为0的点开始拓扑，如果这次拓扑没有遇到所有的点，
 那就代表图不联通 or 入度为0的点不止一个
 */
 int n, m, cnt, tt;
 int dfn[AC], low[AC], belong[AC], point[AC], in[AC], num[AC];
 int date[ac], Next[ac], Head[AC], tot;
 int date1[ac], Next1[ac], Head1[AC], tot1;
 int q[AC], head, tail;
 int s[AC], top;
 bool z[AC], vis[AC];
 inline int read()
 {
     int x = ; char c = getchar();
     while(c > '' || c < '') c = getchar();
     while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
     return x;
 }

 inline void add(int f, int w)
 {
     date[++tot] = w, Next[tot] = Head[f], Head[f] = tot;
 }

 inline void add2(int f, int w)
 {
     date1[++tot1] = w, Next1[tot1] = Head1[f], Head1[f] = tot1;
     ++in[w];
 }

 void pre()
 {
     int a,b;
     n = read(), m = read();
     for(R i = ;i <= m; i++)
     {
         a = read(), b = read();
         add(a, b);
     }
 }

 void tarjan(int x)
 {
     int now;
     dfn[x] = low[x] = ++tt;
     s[++top] = x, z[x] = true;//标记入栈
     for(R i = Head[x]; i ; i = Next[i])
     {
         now = date[i];
         if(!dfn[now])
         {
             tarjan(now);
             low[x] = min(low[x], low[now]);
         }
         else if(z[now])//如果已经访问过而且还未出栈
             low[x] = min(low[x], low[now]);
     }
     if(dfn[x] == low[x])
     {
         int b = ++cnt;//新建联通块
         while(now = s[top--])
         {
             belong[now] = b;//貌似这里只需要标记就可以了
             ++num[b];//记录联通块中有几个点
             z[now]=false;//error要标记出栈啊啊啊啊啊啊啊啊
             if(now == x) break;//加完自己就退出
         }
     }
 }

 #define add add2
 void build()
 {
     int x;
     for(R i = ; i <= n; i++)
     {
         for(R j = Head[i]; j ; j = Next[j])
         {
             x = date[j];
             if(belong[i] != belong[x]) add(belong[x], belong[i]);
         }
     }
 }
 #undef add
 #define date date1
 #define Next Next1
 #define Head Head1
 #define tot tot1

 void topsort(int x)
 {
     int now;
     q[++tail] = x;
     while(head < tail)
     {
         x = q[++head];
         vis[x] = true;
         for(R i = Head[x]; i ; i = Next[i])
         {
             now = date[i];
             if(!(--in[now])) q[++tail] = now;
         }
     }
 }

 void work()
 {
     bool done = true;
     for(R i = ; i <= cnt; i++)
     {
         if(!in[i])
         {
             topsort(i);
             for(R j = ; j <= cnt; j++)
                 if(!vis[j]) done = false;//error！！！是vis[j]啊啊啊啊啊
             if(done) printf("%d\n", num[i]);
             else printf("0\n");
             break;
         }
     }
 }

 int main()
 {
 //    freopen("in.in","r",stdin);
     fread(READ,,,stdin);
     pre();
     for(R i=;i<=n;i++)
         if(!dfn[i]) tarjan(i);
     build();
     work();
 //    fclose(stdin);
     return ;
 }