POJ2186--Popular Cows（Tarjan+缩点）

题目大意：有N头牛，他们都喜欢膜拜其他牛，有M种膜拜关系，问有多少头牛被其他所有的牛膜拜。

分析：这个问题的模型就是，给出一个有向图，有多少个顶点可以被其他所有顶点达到。在DAG（有向无环图）中，只有出度为0的

点，才能被其他所有点到达。由于无环，所以从任何点出发，都将终止于出度为0的点。

首先，我们用Tarjan算法求解所有的强连通分量。

所谓Tarjan算法，就是在dfs过程不断利用两个数组来求解强连通分量。

dfn[i]表示编号为i的节点在DFS过程中的访问序号(也可以叫做开始时间）。在DFS过程中会形成一搜索树。在搜索树上越先遍历

到的节点，显然dfn的值就越小。dfn值越小的节点，就称为越“早” 。

用low[i]表示从i节点出发DFS过程中i下方节点(开始时间大于dfn[i]，且由i可达的节点）所能到达的最早的节点的开始时间。初始时low[i]=dfn[i]。

DFS过程中，碰到哪个节点，就将哪个节点入栈。栈中节点只有在其所属的强连通分量已经全部求出时，才会出栈。

如果节点u有边连到一个尚未被访问的节点v，那么在从v出发进行的DFS结束回到u时，使得 low[u] = min(low[u],low[v])。因为u可

达v,所以v可达的最早的节点，也是u可达的。

if(!vis[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
}

如果节点u有边连到栈里的节点v，则更新u的low 值为min(low[u],dfn[v]) ，若low[u]被更新为dfn[v],则表明目前发现u可达的最

早的节点是v。

else if(in[v])
            low[u] = min(low[u], dfn[v]);

如果一个节点u，从其出发进行的DFS已经全部完成并回到u，而且此时其low值等于dfn值，则说明u可达的所有节点，都不能到达

任何比u早的节点 ---- 那么该节点u就是一个强连通分量在DFS搜索树中的根。

此时，显然栈中u上方的节点，都是不能到达比u早的节点的。将栈中节点弹出，一直弹到u(包括u),弹出的节点就构成了一个强连

通分量。

if(dfn[u] == low[u]) {
        while(true) {
            color[st[t]] = cnt;
            if(u == st[t])  {
                in[st[t--]] = 0;
                break;
            }
            in[st[t--]] = 0;
        }
        cnt++;
}

我们在求解所有强连通分量的过程中，其实就可以缩点了，缩点并不一定要构建新图，直接给不同的强连通分量染色即可。

然后，我们只需要统计DAG中各个点的出度，只有出度为0的点才可能是最终的答案。当多于一个出度为0的顶点，则无解。

代码：

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 111111;

int n, m;
vector<int> e[maxn];
int dfn[maxn], low[maxn];
int vis[maxn];
int st[maxn], in[maxn];
int color[maxn], du[maxn];
int t, cnt, index;

void tarjan(int u) {
    vis[u] = 1;
    dfn[u] = low[u] = ++index;
    st[++t] = u;        //顶点u入栈
    in[u] = 1;          
    int len = e[u].size();
    for(int i = 0; i < len; i++) {
        int v = e[u][i];
        if(!vis[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(in[v])
            low[u] = min(low[u], dfn[v]);
    }

    if(dfn[u] == low[u]) {
        while(true) {
            color[st[t]] = cnt;     //缩点
            if(u == st[t])  {       //当栈顶元素为u时，当前强连通分量求解完毕
                in[st[t--]] = 0;
                break;
            }
            in[st[t--]] = 0;    //顶点u出栈
        }
        cnt++;
    }
}


int main() {
    while(~scanf("%d%d", &n, &m)) {
        for(int i = 1; i <= n; i++)
            e[i].clear();
        for(int i = 0; i < m; i++) {
            int x, y;
            scanf("%d%d", &x, &y);
            e[x].push_back(y);
        }
        cnt = 0;
        memset(in, 0, sizeof(in));
        memset(color, 0, sizeof(color));
        memset(vis, 0, sizeof(vis));

        index = 0;
        for(int i = 1; i <= n; i++) {
            if(!vis[i]) {
                t = 0;
                tarjan(i);
            }
        }
        memset(du, 0, sizeof(du));
        for(int i = 1; i <= n; i++) {   //统计DAG上各点的出度
            int len = e[i].size();
            for(int j = 0; j < len; j++) {
                if(color[i] != color[e[i][j]]) 
                    du[color[i]]++;    
            }
        }
        int flag = 0, ans = 0, tt;
        for(int i = 0; i < cnt; i++)
            if(du[i] == 0) flag++, tt = i;
        if(flag != 1) ans = 0;
        else {
            for(int i = 1; i <= n; i++)
                if(color[i] == tt) ans++;
        }
        printf("%d\n", ans);
    }
    return 0;
}