有向图强连通分量

部分转自

[有向图强连通分量]

有向图中，如果一个子图内任意两点都可达这这个子图为强连通子图

如图所示{1, 2，3，4}，{5}，{6} 为一个强连通子图

求连通分量

1.用Kosaraju算法（PS：个人感觉Kosaraju算法比较好理解，但是适用范围不如Tarjan算法广）

如果在原图中点 i 可达 点 j

如果图逆向之后，i 依然可以达到 j ，这么可以认为 i 和 j 在同一个强连通分量里

具体算法是

1.先对图进行一次DFS进行标号确定逆向图进行搜索的次序，越接近图的尾部（搜索树的叶子），顶点标号越小

2.逆向搜索从标号最大的进行搜索，再次进行DFS，把每次DFS可达的点进行相同的标记，那么标记相同的点就在一个强连通子图中。

int n; //结点个数
vector<int>graph[MAXN]; //用邻接表表示图
vector<int>rgraph[MAXN]; //图的反向
vector<int>vs;  //用来记录进行逆向图搜索的次序
bool vis[MAXN]; //标记是否访问
int cmp[MAXN]; //记录联通图

void add_edge(int v,int u){ //向图中加边
    graph[v].push_back(u);  //正向图
    rgraph[u].push_back(v); // 逆向图
    return;
}
void dfs(int v){ //进行正向图的第一次搜索
    vis[v] = 1;
    int s = graph[v].size();
    for(int i = 0;i < s;i++){
        int u = graph[v][i];
        if(!vis[u]){
            dfs(u);
        }
    }
    vs.push_back(v); //确定次序
}
void rdfs(int v,int k){  //第二次对逆向图搜索
    vis[v] = 1;
    cmp[v] = k; //记录可达的点
    int s = rgraph[v].size();
    for(int i = 0;i < s;i++){
        int u = rgraph[v][i];
        if(!vis[u]){
            rdfs(u,k);
        }
    }
}
int scc(){
    memset(vis,0,sizeof(vis)); //初始化
    vs.clear();
    for(int i = 0;i < n;i++){
        if(!vis[i]){
            dfs(i);
        }
    }
    memset(vis,0,sizeof(vis));
    int k = 0;
    int s = vs.size(); //从最大的标号搜素
    for(int i = s-1;i > -1;i--){
        if(!vis[ vs[i] ]){
            rdfs(vs[i],k++);
        }
    }
    return k; //连通分量个数
}

2. Tarjan算法 （之前的链接已经很棒了）

只写一下个人理解

搬图……！！！！

DFN 为 搜索次序，LOW[u] 是 u 可达的点中 最小的 DFN 值 当 DFN[u] == LOW[u]（意味着它通过某条路回到了曾走过的点，说明这两点任意可达） 时 以u 为根的搜索子树上所有节点是一个强连通分量

所以如图 点 6 是一个强连通分量

而这张图 点 4 可达 点 1 所以 LOW[4] = 1 ，而 点3 是点 4 的父节点 所以 LOW[3] = LOW[4] = 1; LOW[1] = DFN[1]

所以目前{1，3，4}在一个强连通图中，下一阶段就是进行 1 → 2的搜索 点 2 也在该连通子图中

代码（抄的维基）

const int MAXN = 100000 + 10; //最大结点的个数
int STACK[MAXN]; //用来记录一次搜索中，把搜索过的元素入栈
int top; //栈顶指针
bool InStack[MAXN];//用来标记元素是否在栈中
int DFN[MAXN];  //搜索次序
int LOW[MAXN];  //该节点所能到达的最小次序
int Index; //次序编号
int componentnumber; //连通分量个数
vector<int>edge[MAXN]; //图邻接表
vector<int>component[MAXN]; //每个连通分量中所包含的点
int incomponent[MAXN]; //在一个强连通子图中的标记是一样的
int n;
void Tarjan(int i){ //算法
    int j; 
    DFN[i] = LOW[i] = Index++; //首先默认本身为一个强连通分量
    STACK[++top] = i; // i 点被搜索过入栈
    InStack[i] = 1; //入栈元素标记
    int s = edge[i].size();
    for(int e = 0;e < s;e++){
        j = edge[i][e];
        if(DFN[j] == -1){ //如果没有被搜索过
            Tarjan(j); //进行搜索
            LOW[i] = min(LOW[i],LOW[j]); //LOW[i] 对其可达的最小编号进行更新
        }
        else if(InStack[j]){ //如果已经搜索过
            LOW[i] = min(LOW[i],DFN[j]); //对LOW[i]进行更新
        }
    }
    if(DFN[i] == LOW[i]){ //如果最后 i 点通过某条路又回到了自身，说明走过的路是一个强连通子图
        componentnumber++; //连通分量的个数加1
        do{
            j = STACK[top--];  //栈中是访问的点
            InStack[j] = 0;//清零
            component[componentnumber].push_back(j); //记录
            incomponent[j] = componentnumber; //记录
        }
        while(j != i);
    }
    return;
}
void solve(){
    memset(STACK,-1,sizeof(STACK)); //初始化
    memset(InStack,0,sizeof(InStack));
    memset(DFN,-1,sizeof(DFN));
    memset(LOW,-1,sizeof(LOW));
    ans = -1;
    top = 0;
    Index = 0;
    componentnumber = 0;
    for(int i = 0;i <= n;i++){
        component[i].clear();
    }
    for(int i = 0;i < n;i++){
        if(DFN[i] == -1){
            Tarjan(i);
        }
    }
    return;
}

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

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <map>
#include <set>

const int MAXN = 10000 + 10;
const int MOD = 10000007;
const int INF = 0x7fffffff;
const double Pi = acos(-1.0);
const double ESP = 10e-8;

using namespace std;
int n;
vector<int>graph[MAXN];
vector<int>rgraph[MAXN];
vector<int>vs;
bool vis[MAXN];
int cmp[MAXN];
void add_edge(int v,int u){
    graph[v].push_back(u);
    rgraph[u].push_back(v);
    return;
}
void dfs(int v){
    vis[v] = 1;
    int s = graph[v].size();
    for(int i = 0;i < s;i++){
        int u = graph[v][i];
        if(!vis[u]){
            dfs(u);
        }
    }
    vs.push_back(v);
}
void rdfs(int v,int k){
    vis[v] = 1;
    cmp[v] = k;
    int s = rgraph[v].size();
    for(int i = 0;i < s;i++){
        int u = rgraph[v][i];
        if(!vis[u]){
            rdfs(u,k);
        }
    }
}
int scc(){
    memset(vis,0,sizeof(vis));
    vs.clear();
    for(int i = 0;i < n;i++){
        if(!vis[i]){
            dfs(i);
        }
    }
    memset(vis,0,sizeof(vis));
    int k = 0;
    int s = vs.size();
    for(int i = s-1;i > -1;i--){
        if(!vis[ vs[i] ]){
            rdfs(vs[i],k++);
        }
    }
    return k;
}
void solve(int m){
    for(int i = 0;i <= n;i++){
        graph[i].clear();
        rgraph[i].clear();
    }
    while(m--){
        int a,b;
        scanf("%d%d",&a,&b);
        add_edge(a-1,b-1);
    }
    int x = scc();
    int num = 0;
    int u = 0;
    for(int i = 0;i < n;i++){
        if(cmp[i] == x-1){
            u = i;
            num++;
        }
    }
    memset(vis,0,sizeof(vis));
    rdfs(u,0);
    for(int i = 0;i < n;i++){
        if(!vis[i]){
            num = 0;
            break;
        }
    }
    printf("%d
",num);
}
int main(){
//    freopen("input.txt","r",stdin);
    int m;
    while(~scanf("%d%d",&n,&m)){
        solve(m);
    }
    return 0;
}