tanjan算法求强联通分量

转载地址：http://blog.renren.com/share/267993267/4028505439

算法分类：
图论

问题定义：
有向图强连通分量：
在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通（strongly connected）。
如果有向图G的每两个顶点都强连通，则称G是一个强连通图。
非强连通图有向图的极大强连通子图，成为强连通分量（strongly connected components）。
下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达，{5}，{6}也分别是两个强连通分量。

直接根据定义，用双向遍历取交际的方法求强连通分量，时间复杂度为O（N^2+M）。更好的方法是Kosaraju算法或者Tarjan算法。
两者的时间复杂度都是O（N+M）。本文介绍的是Tarjan算法。

算法原理：（Tarjan）
Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一颗子树。
搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以盘对栈顶到栈中的节点是否为一个强连通分量。

定义DFN（u）为节点u搜索的次序编号（时间戳）。Low（u）为u或者u的子树能够追溯到的最早的栈中的节点的次序号。
由定义可以得出：
Low（u）= Min { DFN（u）， Low（v）} （（u，v）为树枝边，u为v的父节点DFN（v），（u，v）为指向栈中节点的后向边（非横叉边））
当DFN（u）=Low（u）时，以u为根的搜索子树上所有节点是一个强连通分量。

算法时空复杂度：
O（N+M）

代码实现：（hdu1269）

#include <stdio.h>  
#include <string.h>  
#include <vector>  
#include <stack>  
using namespace std;  
#define MIN(a,b) ((a)<(b)?(a):(b))  
#define N 10005             // 题目中可能的最大点数   
stack<int>sta;                // 存储已遍历的结点   
vector<int>gra[N];            // 邻接表表示图   
int dfn[N];                 // 深度优先搜索访问次序   
int low[N];                 // 能追溯到的最早的次序   
int InStack[N];             // 检查是否在栈中(2为在栈中，1为已访问，且不在栈中，0为不在)   
vector<int> Component[N];     // 获得强连通分量结果  
int InComponent[N];         // 记录每个点在第几号强连通分量里  
int index,ComponentNumber;  // 索引号，强连通分量个数   
int n, m;                   // 点数，边数   

void init(void)  
{  
    memset(dfn, 0, sizeof(dfn));  
    memset(low, 0, sizeof(low));  
    memset(InStack, 0, sizeof(InStack));  
    index = ComponentNumber = 0;  
    for (int i = 1; i <= n; ++ i)  
    {  
        gra[i].clear();  
        Component[i].clear();  
    }  

    while(!sta.empty())  
        sta.pop();  
}  

void tarjan(int u)  
{  
    Instack[u] = 2;  
    low[u] = dfn[u] = ++ index;  
    sta.push(u);  

    for (int i = 0; i < gra[u].size(); ++ i)  
    {  
        int t = gra[u][i];  
        if (dfn[t] == 0)  
        {  
            tarjan(t);  
            low[u] = MIN(low[u], low[t]);  
        }   
        else if (InStack[t] == 2)  
        {  
            low[u] = MIN(low[u], dfn[t]);  
        }  
    }  

    if (low[u] == dfn[u])  
    {  
        ++ ComponentNumber;  
        while (!sta.empty())  
        {  
            int j = sta.top();  
            sta.pop();  
            InStack[j] = 1;  
            Component[ComponentNumber].push_back(j);  
            InComponent[j]=ComponentNumber;  
            if (j == u)  
                binputak;  
        }  
    }  
}  

void input(void)  
{  
    for(int i=1;i<=m;i++)  
    {  
        int a,b;  
        scanf("%d%d",&a,&b);  
        gra[a].push_back(b);  
    }  
}  

void solve(void)  
{  
    for(int i=1;i<=n;i++)  
        if(!dfn[i])  
            tarjan(i);  
    if(ComponentNumber>1)  
        puts("No");  
    else  
        puts("Yes");  
}  

int main()  
{  
    while(scanf("%d%d",&n,&m),n+m)  
    {  
        init();  
        input();  
        solve();  
    }  
}