POJ 2186 popular cows (tarjan + 缩点)

思路：

1. 有向图，边具有传递性。我们要找的是这样的点：这个点被其他所有的点所直接或传递指向，即这个点是所有牛所崇拜的。
2. 通过对数据的观察，直接否决了暴力的可能性。因为要暴力传递性，所以至少要 $n^3$ 的复杂度。
3. 首先我们考虑图中存在的强联通分量，对于强联通分量中的点，每个点都能通过传递性到达此联通分量中的任何一点，即可以将这个强联通分量视为一个点（缩点），而这个点的出边即连向其他的缩点。
4. 考虑经过tarjan求强联通分量缩点之后的图，我们可以发现，这个图一定是有向无环图(如果其中的点大于1个)，如果有环的话那么环中的点在trajan时肯定会被包括进去。
5. 对于新图，所以我们现在需要做的就是统计出度为0的点，如果只有一个，那么这个点即是其他所有点所能到达的，我们输出这个点中包含的原来的点的个数就行了。如果有两个或以上出度为0的点，那么互相不可达，输出0。
6. 考虑特殊情况，即缩点之后的图不能构成有向无环图的情况。即联通分量个数为1，所以就是一个联通图。输出n。

AC代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;

int ans;//代表着强联通分量的个数
//链式前向星
const int maxn = 10100;//最大的点的个数
int head[maxn];
struct edge{
    int to,v,next;
} edg[50100];
int cnte;
void addedge(int x,int y,int v){
    edg[++cnte].to = y;
    edg[cnte].v = v;
    edg[cnte].next = head[x];
    head[x] = cnte;
}
int cntn[maxn];//此强联通里点的个数

int dfn[maxn];
int low[maxn];
int stak[maxn];
int visstak[maxn];
int cntstak = 0;
int belong[maxn];
int out[maxn];//出度
int index;
void tarjan(int u){
    dfn[u] = low[u] = ++index;
    stak[cntstak++] = u;
    visstak[u] = 1;
    for(int i = head[u]; i != -1;){
        int v = edg[i].to;
        if(!dfn[v]){
            tarjan(v);
            low[u] = min(low[u],low[v]);
        }
        else if(visstak[v]){
            low[u] = min(low[u],dfn[v]);
        }//第三种情况则是已经找完的点，对于这些点我们不再访问
        i = edg[i].next;
    }
    if(dfn[u] == low[u]){
        ans++;
        int v;
        do{
            v = stak[--cntstak];
            visstak[v] = 0;
            belong[v] = ans;
            cntn[ans]++;
        }
        while(v != u);
    }
}
void ini(){
    ans = 0;
    cnte = 0;
    index = 0;
    cntstak = 0;
    memset(head,-1,sizeof(head));
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(cntn,0,sizeof(cntn));
}

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    ini();
    int a,b;
    for(int i = 1; i <= m; i++){
        scanf("%d%d",&a,&b);
        addedge(a,b,1);
    }
    for(int i = 1; i <= n; i++){
        if(dfn[i] == 0){
            tarjan(i);
        }
    }
    for(int i = 1;i <= n;i++){
        for(int j = head[i];j != -1;j=edg[j].next){
            if(belong[i] != belong[edg[j].to]){
                out[belong[i]]++;
            }
        }
    }
    int flag,cnt = 0;
    for(int i = 1;i <= ans;i++){
        if(out[i] == 0){
            cnt++;flag = i;
        }
    }
    if(ans == 1){
        printf("%d\n",n);
    }
    else if(cnt == 1){
        printf("%d\n",cntn[flag]);
    }
    else{
        puts("0");
    }
    return 0;
}