POJ 2186

题目大意：

给定一个含N个点、M条边的有向图，求其中有多少个点，可以由其他任意一点出发到达它？

N<=1e4，M<=5e4。

为了描述和编程简便，我们建立原图的反图，这样问题转化为：有多少个点满足从它出发可以到达其他任意一点。

若无特殊说明，以下所指的图均为反图。

引理1：满足条件的所有点必然在同一强连通分量内。

证明很简单，如果它们不在同一强连通分量内，那么其中必然有两点x，y使得x→y的路径不存在，与题目要求矛盾。

我们考虑求出该图的所有强连通分量，然后对于每个强连通分量，检验从其中任一点出发，能否到达其他所有的点。

我们可以采取缩点的方法，将每个强连通分量缩成一个点。

引理2：缩点后的图必然是一个有向无环图（DAG）。

证明：如果缩点后存在环，那么这个环可以合并成一个更大的强连通分量。这与强连通分量的极大性矛盾。

我们统计缩点后每个点的入度。如果有2个或以上的点入度为0，那么它们是互相不可达的，此时答案为0。

否则，如果只有一个点入度为0，答案就是该点所代表的强连通分量的大小。

实现时可以借助两个数组：sccId[x]表示点x所属的强连通分量的编号，sccSize[x]表示点x所属的强连通分量的大小。

参考：有向图强连通分量的Tarjan算法

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>

#define FILLARR(arr, ch) memset(arr, ch, sizeof(arr))

const int maxN = (int)1e4 + 5;
const int maxM = (int)5e4 + 5;

struct Edge
{
    int to, next;
    void assign(int t, int n)
    {
        to = t;
        next = n;
    }
};

Edge elist[maxM];
int head[maxN];
int ecnt;
int N, M;

void initElist()
{
    FILLARR(head, -1);
    ecnt = 0;
}

inline void addEdge(int from, int to)
{
    elist[ecnt].assign(to, head[from]);
    head[from] = (ecnt++);
}

void input()
{
    scanf("%d%d", &N, &M);
    initElist();
    for (int u, v, i = 0; i < M; i++)
    {
        scanf("%d%d", &u, &v);
        addEdge(v, u);
    }
}

int dfn[maxN];
int low[maxN];
bool inStk[maxN];
int sccId[maxN];
int sccSize[maxN];
int lastDfn = 0;
std::stack<int> stk;

inline void pushToStk(int v)
{
    stk.push(v);
    inStk[v] = true;
}

inline int popFromStk()
{
    int v = stk.top();
    stk.pop();
    inStk[v] = false;
    return v;
}

void dfs(int cur)
{
    dfn[cur] = low[cur] = (++lastDfn);
    pushToStk(cur);

    for (int e = head[cur]; e != -1; e = elist[e].next)
    {
        int to = elist[e].to;
        if (dfn[to] == 0)
        {
            dfs(to);
            low[cur] = std::min(low[cur], low[to]);
        }
        else if (inStk[to])
            low[cur] = std::min(low[cur], dfn[to]);
    }

    if (dfn[cur] == low[cur])
    {
        for (int v = popFromStk(); ; v = popFromStk())
        {
            sccId[v] = cur;
            sccSize[cur] += 1;
            if (v == cur)
                break;
        }
    }
}

int inDeg[maxN]; //compressed graph in which each SCC is compressed into one node

int solve()
{
    for (int i = 1; i <= N; i++)
        if (dfn[i] == 0)
            dfs(i);

    for (int i = 1; i <= N; i++)
        inDeg[i] = (sccId[i] == i ? 0 : -1);

    for (int i = 1; i <= N; i++)
        for (int e = head[i]; e != -1; e = elist[e].next)
        {
            int to = elist[e].to;
            if (sccId[i] != sccId[to])
                inDeg[sccId[to]] += 1; //link between two SCCs
        }

    int head = (int)(std::find(inDeg + 1, inDeg + N + 1, 0) - inDeg);
    return std::count(inDeg + head + 1, inDeg + N + 1, 0) > 0 ? 0 : sccSize[head];
}

int main()
{
    input();
    printf("%d", solve());
    return 0;
}