poj 2186 强连通分量个数

题意：

每头牛都想成为牛群中的红牛。

给n（1e4）头牛，m（5e4）条边，（A, B）表示A牛认为B牛是红牛(●ˇ∀ˇ●)。

该关系具有传递性，A认为B是红牛，B认为C是红牛，则A认为C是红牛。

（小明喜欢小红，小红喜欢小刚） ->   ........(/▽＼=)

求被其他牛都认为是红牛的牛的总数。

解析：

被其他牛都认为是红牛的牛对应的顶点，也就是从其他所有顶点都可达的顶点。

假设有两头牛A和B都被其他牛认为是红牛。那么显然，A被B认为是红牛，B也被A这样认为，所以AB数以同一个强连通分量。

反之，如果一头牛被其他所有牛都认为是红牛，则其所属的强连通分形内的所有牛都被其他所有牛认为是红牛。

因此，我们把图尽心强连通分量分解之后，至多有一个强连通分量满足题目的条件。

而进行强连通分量分解的时候，我们还能够得到各个强连通分量拓扑排序后的顺序，唯一可能成为解的只有拓扑排序最末尾的强连通分量。

因为，他的入度是最大的。

最后，只要检查这个强连通分量是否从所有的顶点可达就行了。

代码：

#pragma comment(linker, "/STACK:1677721600")
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <cassert>
#include <iostream>
#include <algorithm>
#define pb push_back
#define mp make_pair
#define LL long long
#define lson lo,mi,rt<<1
#define rson mi+1,hi,rt<<1|1
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a,b) memset(a,b,sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)

using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double ee = exp(1.0);
const int inf = 0x3f3f3f3f;
const int maxn = 1e4 + 10;
const double pi = acos(-1.0);
const LL iinf = 0x3f3f3f3f3f3f3f3f;

int readT()
{
    char c;
    int ret = 0,flg = 0;
    while(c = getchar(), (c < '0' || c > '9') && c != '-');
    if(c == '-') flg = 1; else ret = c ^ 48;
    while( c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c ^ 48);
    return flg ? - ret : ret;
}

int V;                  //顶点数
vector<int> g[maxn];    //图的邻接表
vector<int> rg[maxn];   //把边反向后的图
vector<int> vs;         //后续遍历顺序的顶点列表
bool used[maxn];        //访问标记
int cmp[maxn];          //所属强连通分量的拓扑序 即入度大连通分量的在后

void init()
{
    for (int i = 0; i <= V; i++)
    {
        g[i].clear();
        rg[i].clear();
    }
}

void addEdge(int fr, int to)
{
    g[fr].pb(to);
    rg[to].pb(fr);
}

//正向dfs
void dfs(int v)
{
    used[v] = true;
    int sz = g[v].size();
    for (int i = 0; i < sz; i++)
    {
        if (!used[g[v][i]])
        {
            dfs(g[v][i]);
        }
    }
    vs.pb(v);
}

//反向dfs
void rdfs(int v, int k)
{
    used[v] = true;
    cmp[v] = k;
    int sz = rg[v].size();
    for (int i = 0; i < sz; i++)
    {
        if (!used[rg[v][i]])
        {
            rdfs(rg[v][i], k);
        }
    }
}

//返回强连通分量个数
int scc()
{
    mem0(used);
    vs.clear();
    for (int v = 0; v < V; v++)
    {
        if (!used[v])
        {
            dfs(v);
        }
    }
    mem0(used);
    int k = 0;
    int sz = vs.size();
    for (int i = sz - 1; i >= 0; i--)
    {
        if (!used[vs[i]])
        {
            rdfs(vs[i], k++);
        }
    }
    return k;
}

int main()
{
    #ifdef LOCAL
    FIN;
    #endif // LOCAL
    int n, m;
    while (~scanf("%d%d", &n, &m))
    {
        V = n;
        init();

        while (m--)
        {
            int A = readT();
            int B = readT();
            A--, B--;
            addEdge(A, B);
        }
        int cnt = scc();

        int st = 0;
        int num = 0;
        for (int v = 0; v < V; v++)
        {
            if (cmp[v] == cnt - 1)
            {
                st = v;
                num++;
            }
        }

        //检查是否从所有点都可达到此连通分量
        mem0(used);
        //从最后的连通分量开始 反向遍历 ( •̀ ω •́ )y 只能从这点开始反向遍历
        rdfs(st, 0);
        for (int v = 0; v < V; v++)
        {
            //不可达
            if (!used[v])
            {
                num = 0;
                break;
            }
        }

        printf("%d\n", num);
    }

    return 0;
}