poj 2186 Popular Cows 强连通分量分解

题目：http://poj.org/problem?id=2186

题意：有N(N<=10000)头牛，每头牛都想成为most poluler的牛，给出M(M<=50000)个关系，如(1,2)代表1欢迎2，关系可以传递，但是不可以相互，即1欢迎2不代表2欢迎1，但是如果2也欢迎3那么1也欢迎3.给出N,M和M个欢迎关系，求被所有牛都欢迎的牛的数量。

思路：用强连通分量分解，分解后判断图是不是连通图，不是连通图，答案为0，若是连通图，定有一个强连通分量内所有的点是满足要求的。关于连通图的判断，用tarjan算法时，统计出度0的强连通分量个数，为1时有解，即出度为0的强连通分量，大于1无解。用kosaraju算法时，若有解，则定是拓扑序最后的强连通分量，直接从拓扑序最后的强连通分量内任意一点用rdfs函数搜索一遍图，若图连通，则所有点都能被访问到。这道题我用tarjan和kosaraju各做了一遍，下面是tarjan算法和kosaraju算法代码

tarjan算法

Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。
DFN(u)为节点u搜索的次序编号(时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号
当DFN(u)=Low(u)时，以u为根的搜索子树上所有节点是一个强连通分量
运行Tarjan算法的过程中，每个顶点都被访问了一次，且只进出了一次堆栈，每条边也只被访问了一次，所以该算法的时间复杂度为O(N+M)

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

const int N = 10010;
vector<int> G[N];
stack<int> st;
bool vis[N];
int dfn[N], low[N], scc[N]; /*scc数组记录每个点所属的强连通分量*/
int outdegree[N], ans[N];/*outdegree数组记录强连通分量的出度，ans数组记录每个强连通分量内的点数*/
int index, cnt; /*cnt是当前强连通分量的编号*/
int n, m;

void tarjan(int v)
{
    int u;
    dfn[v] = low[v] = index++; /*开始时dfn[v] == low[v]*/
    vis[v] = true;
    st.push(v);
    for(int i = 0; i < G[v].size(); i++)
    {
        u = G[v][i];
        if(dfn[u] == -1) /*如果v点还未遍历，向下遍历，同时确保low[v]最小*/
        {
            tarjan(u);
            low[v] = min(low[v], low[u]);
        }
        else if(vis[u]) /*v在栈中，修改low[v]*/
            low[v] = min(low[v], dfn[u]);
    }

    if(dfn[v] == low[v]) /*v为该强连通分量中遍历所成树的根*/
    {
        cnt++;
        do
        { /*栈中所有到v的点都属于该强连通分量，退栈*/
            u = st.top(); st.pop();
            vis[u] = false;
            scc[u] = cnt;
            ans[cnt]++;
        }while(u != v);
    }
}

void slove()
{
    memset(dfn, -1, sizeof dfn);
    memset(vis, 0, sizeof vis);
    memset(ans, 0, sizeof ans);
    for(int i = 1; i <= n; i++)
        if(dfn[i] == -1) /*可能不是连通图，所以要逐个扫描*/
            tarjan(i);
}

int main()
{
    int a, b;
    while(~ scanf("%d%d", &n, &m))
    {
        index = 0;
        cnt = 0;
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
        }
        slove();

        memset(outdegree, 0, sizeof outdegree);
        for(int i = 1; i <= n; i++)
            for(int j = 0; j < G[i].size(); j++)
                if(scc[i] != scc[G[i][j]])
                    outdegree[scc[i]] = 1;

        int tmp = 0, f;
        for(int i = 1; i <= cnt; i++)
        {
            if(outdegree[i] == 0)
            {
                tmp++;
                f = i;
            }
        }
        if(tmp == 1) printf("%d\n", ans[f]);
        else printf("0\n");
    }

    return 0;
}

kosaraju算法

复杂度也是O(N+M)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <cmath>
#include <queue>
#include <functional>
#include <map>
#include <string>
using namespace std;

const int N = 10100;
int n, m;
vector <int> G[N];
vector <int> RG[N];
vector <int> vs;
bool used[N];
int cmp[N];

void add_edge(int from, int to)
{
    G[from].push_back(to);
    RG[to].push_back(from); /*反向图*/
}

void dfs(int v)
{
    used[v] = true;
    for(int i = 0; i < G[v].size(); i++)
        if(! used[G[v][i]])
            dfs(G[v][i]);
    vs.push_back(v);/*vs数组从后往前是拓扑序*/
}

void rdfs(int v, int k)
{
    used[v] = true;
    cmp[v] = k;
    for(int i = 0; i < RG[v].size(); i++)
        if(! used[RG[v][i]])
            rdfs(RG[v][i], k);
}

int kosaraju()
{
    memset(used, 0, sizeof used);
    vs.clear();
    for(int i = 1; i <= n; i++)
        if(! used[i])
            dfs(i);

    memset(used, 0, sizeof used);
    int k = 0;
    for(int i = vs.size() - 1; i >= 0; i--)
        if(! used[vs[i]])
            rdfs(vs[i], k++);
    
    return k;
}

int main()
{
    int a, b;

    while(~ scanf("%d%d", &n, &m))
    {
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d", &a, &b);
            add_edge(a, b);
        }

        int cnt = scc() - 1, v, num = 0;
        for(int i = 1; i <= n; i++)
            if(cmp[i] == cnt)
                v = i, num++;
        memset(used, 0, sizeof used);
        rdfs(v, 0);
        for(int i = 1; i <= n; i++)
            if(! used[i])
            {
                num = 0; break;
            }
        printf("%d\n", num);
    }

    return 0;
}