【模板】强连通分量和tarjan算法

　　看了好久才终于明白了这个算法。。复杂度是O(n+m)。

　　我觉得这个算法不是很好理解，但是看懂了以后还是觉得听巧妙的。

　　下面给出模板代码和三组简单数据帮助理解。

　　代码如下：

#include <stdio.h>
#include <stack>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;

const int N = 100+5;

stack<int> S;
int scc_cnt;  //强连通分量的个数
int dfs_clock;    //访问到该节点的时间戳
int belong[N];  //belong[i]表示i节点所属于第几个强连通分量
int dfn[N];     //表示第i个节点被访问的时间
int low[N];    //表示第i个节点的子节点所能访问到的最小的dfn值
vector<int> G[N];

void dfs(int u)
{
    dfn[u] = low[u] = ++dfs_clock;
    S.push(u);
    for(int i=0;i<G[u].size();i++)
    {
        int v = G[u][i];
        if(!dfn[v])
        {
            dfs(v);
            low[u] = min(low[u],low[v]);
        }
        else if(!belong[v]) //这句话等价于v在栈内
        {
            low[u] = min(low[u],low[v]);
            //low[u] = min(low[u],dfn[v]);
            //上面两种写法似乎都是没有问题的，但是如果仔细斟酌第三组数据和low的定义的话
            //似乎是上面的写法更好，这里不敢确定，留个疑问。
        }
    }
    if(low[u]==dfn[u])
    {
        scc_cnt++;
        for(;;)
        {
            //因为元素x只有在出栈了以后才被赋予归属，所以这就是上面等价的原因
            //同时，因为所有元素都有归属，则栈S中最后没有元素，因此不需要清空S
            int x = S.top();S.pop();
            belong[x] = scc_cnt;
            if(x==u) break;
        }
    }
}

void scc(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(belong,0,sizeof(belong));
    dfs_clock = scc_cnt = 0;
    for(int i=0;i<n;i++) //注意这里是0~n-1!
    {
        if(!dfn[i]) dfs(i);
    }
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        G[a].push_back(b);
    }
    scc(n);
    puts("");
    for(int i=0;i<n;i++) printf("%d %d %d %d
",i,belong[i],dfn[i],low[i]);
    printf("%d
",scc_cnt);
    return 0;
}

　　三组数据如下：

6 6
0 1
1 2
2 5
0 3
3 4
4 5
 
4 4
0 1
1 2
2 3 
3 0

6 8
0 1
0 2
2 3 
1 3
3 0
2 4
4 5
3 5