强连通分量(tarjan求强连通分量)

双DFS方法就是正dfs扫一遍，然后将边反向dfs扫一遍。《挑战程序设计》上有说明。

双dfs代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;
const int MAXN = 1e4 + 5;
vector <int> G[MAXN]; //图的邻接表
vector <int> RG[MAXN]; //图的反向邻接表
vector <int> vs; //后序遍历的顶点顺序表
bool ok[MAXN]; //访问标记
int node[MAXN]; //所属强连通分量的序号
//第一次dfs
void dfs(int u) {
    ok[u] = true;
    for(int i = 0 ; i < G[u].size() ; i++) {
        if(!ok[G[u][i]]) 
            dfs(G[u][i]);
    }
    vs.push_back(u);
}
//第二次dfs
void rdfs(int u , int k) {
    node[u] = k;
    ok[u] = true;
    for(int i = 0 ; i < RG[u].size() ; i++) {
        if(!ok[RG[u][i]])
            rdfs(RG[u][i] , k);
    }
}

int main()
{
    int n , m , u , v;
    while(~scanf("%d %d" , &n , &m) && (n || m)) {
        for(int i = 1 ; i <= n ; i++) {
            G[i].clear();
            RG[i].clear();
            ok[i] = false;
            vs.clear();
        }
        for(int i = 0 ; i < m ; i++) {
            scanf("%d %d" , &u , &v);
            G[u].push_back(v);
            RG[v].push_back(u);
        }
        //第一次dfs 选取任意的顶点作为起点遍历 后序遍历 越接近图尾部(叶子)的顶点顺序越小
        for(int i = 1 ; i <= n ; i++) {
            if(!ok[i]) 
                dfs(i);
        }
        memset(ok , false , sizeof(ok));
        int k = 0;
        //第二次dfs 将边反向遍历 以标记最大的顶点作为起点遍历 这样便可以给强连通分量标号
        for(int i = vs.size() - 1 ; i >= 0 ; i--) {
            if(!ok[vs[i]])
                rdfs(vs[i] , ++k);
        }
        if(k > 1) {
            printf("No
");
        }
        else {
            printf("Yes
");
        }
    }
}

tarjan代码虽然比双dfs多，理解也稍微复杂，但是用处比较多，像求LCA 桥 scc之类的问题。

推荐一个学scc的blog，讲的很好。 https://www.byvoid.com/blog/tag/%E5%9C%96%E8%AB%96

代码如下：

//以hdu1269为例
//强连通分量 tarjan算法
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int MAXN = 1e4 + 5;
vector <int> G[MAXN]; //临接表
bool instack[MAXN];  //i是否还在在栈里
int sccnum , index; //连通分量数 和时间顺序
int top , st[MAXN]; //存储i的模拟栈
int block[MAXN];  //i所属的连通分量
int low[MAXN] , dfn[MAXN];  //i能最早访问到的点 和时间戳

void tarjan(int u) {
    st[++top] = u;
    instack[u] = true;
    low[u] = dfn[u] = ++index;
    for(int i = 0 ; i < G[u].size() ; i++) {
        int v = G[u][i];
        if(!dfn[v]) { //v点没访问过
            tarjan(v);
            if(low[v] < low[u]) { //回溯上来  low[v]表示的时间戳(连通分量的根)  u和v在一个连通分量里
                low[u] = low[v];
            }
        }
        else if(instack[v]) {  //v还在栈里 说明u和v在一个连通分量(形成环路) v相当于连通分量的一个根
            low[u] = min(low[u] , dfn[v]);
        }
    }
    int v;
    if(dfn[u] == low[u]) {  //是连通分量的根
        sccnum++;
        do {
            v = st[top--];
            block[v] = sccnum;
            instack[v] = false;
        }while(v != u); //连通分量的所有的点
    }
}

void init(int n) {
    for(int i = 1 ; i <= n ; i++) {
        G[i].clear();
        instack[i] = false;
        dfn[i] = 0;
    }
    sccnum = index = top = 0;
}

int main()
{
    int n , m , u , v;
    while(~scanf("%d %d" , &n , &m) && (n || m)) {
        init(n);
        for(int i = 0 ; i < m ; i++) {
            scanf("%d %d" , &u , &v);
            G[u].push_back(v);
        }
        for(int i = 1 ; i <= n ; i++) {
            if(!dfn[i]) {
                tarjan(i);
            }
        }
        if(sccnum > 1) {
            cout << "No
";
        }
        else {
            cout << "Yes
";
        }
    }
}