POJ2186 Popular Cows

Description

Every cow's dream is to become the most popular cow in the herd. In a herd of N (1 <= N <= 10,000) cows, you are given up to M (1 <= M <= 50,000) ordered pairs of the form (A, B) that tell you that cow A thinks that cow B is popular. Since popularity is transitive, if A thinks B is popular and B thinks C is popular, then A will also think that C is 
popular, even if this is not explicitly specified by an ordered pair in the input. Your task is to compute the number of cows that are considered popular by every other cow. 

Input

* Line 1: Two space-separated integers, N and M 

* Lines 2..1+M: Two space-separated numbers A and B, meaning that A thinks B is popular. 

Output

* Line 1: A single integer that is the number of cows who are considered popular by every other cow. 

Sample Input

3 3
1 2
2 1
2 3

Sample Output

1

Hint

Cow 3 is the only cow of high popularity. 

 

『题解』

建立有向图，若牛a喜欢牛b，则图中节点a可达节点b，i.e.存在从a到b的一条有向边。于是问题就转化为，在有向图中求出有多少点是被所有其它点可达的。

 

事实上，在有向无环图DAG中，从任何点出发开始走，必定终止于一个出度为0的点。因此，如果有唯一的出度为0的点p，则一定由任意点出发可达p。

 

对于一般的有向图，若有向图中存在强连通分量，则在强连通分量中，每两点之间都相互可达。于是可以将强连通分量缩成一个点，重新建立图结构，就形成DAG。为便于去重，新图邻接表可采用数据结构vector<set<int>>；或者就像本代码示例中的方法，为强连通分量的点染色即可。正如上文所述，若DAG中存在唯一的出度为0的点，则该点代表的强连通分量中的所有点都满足条件，即被除自身以外所有点可达。若DAG中，出度为0的点不止一个，则原题无解，答案为0。

 

『C++』

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
#define maxn 10005

struct Edge
{
    int next;
    int to;
}e[maxn*5];

int ent, cnt, tnt, top;
int head[maxn], SCC[maxn], out[maxn], dfn[maxn], low[maxn];
int Stack[maxn];
bool inStack[maxn];

void Build(int u, int v)
{
    e[ent].to = v;
    e[ent].next = head[u];
    head[u] = ent++;
}

void Tarjan(int u)
{
    int v;

    dfn[u] = low[u] = ++tnt;
    Stack[top++] = u;
    inStack[u] = 1;

    for (int i = head[u]; i != -1; i = e[i].next) {
        v = e[i].to;
        if (!dfn[v]) {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if (inStack[v])
            low[u] = min(low[u], dfn[v]);
    }
    if (dfn[u] == low[u]) {
        do {
            v = Stack[--top];
            inStack[v] = 0;
            SCC[v] = cnt;
        } while (v != u);
        cnt++;
    }
}

int main()
{
    int N, M, A, B;
    int ans = 0, num = 0, index = -1;
    memset(head, -1, sizeof(head));
    memset(inStack, 0, sizeof(inStack));
    memset(SCC, 0, sizeof(SCC));
    memset(Stack, 0, sizeof(Stack));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    ent = cnt = tnt = top = 0;

    cin >> N >> M;

    for (int i = 0; i < M; i++) {
        cin >> A >> B;
        Build(A, B);
    }

    for (int u = 1; u <= N; u++)
        if (!dfn[u]) Tarjan(u);

    for (int u = 1; u <= N; u++) {
        for (int i = head[u]; i != -1; i = e[i].next) {
            int v = e[i].to;
            if (SCC[u] != SCC[v])out[SCC[u]]++;
        }
    }

    for (int i = 0; i < cnt; i++)
        if (out[i] == 0) {
            num++;
            index = i;
        }
    if (num == 1)
        for (int u = 1; u <= N; u++)
            if (SCC[u] == index)ans++;
    printf("%d
", ans);

    //system("pause");
    return 0;
}