图的强连通问题

图的强连通问题

——求强连通分量个数，找出每个最大强连通子图。

 

三种算法，Tarjan、Kosaraju、Garbow。先说Tarjan。

 

Tarjan

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<stack>
using namespace std;
const int maxv= 110;
const int maxe= 5010;  //可能的最大值

struct ENode
{
    int to;
    int Next;
};
ENode edegs[maxe];
int Head[maxv], tnt;
void init()
{
    memset(Head, -1, sizeof(Head));
    tnt= -1;
}
void Add_ENode (int a, int b)
{
    ++ tnt;
    edegs[tnt].to= b;
    edegs[tnt].Next= Head[a];
    Head[a]= tnt;
}

int m;
int dfn[maxv];  //深度优先搜索中顶点被访问的时间
int low[maxv];  //顶点v 和它的邻接点中low[]的最小值
int temp[maxv];  //判断节点是否已被访问过(0-未访问 1-已访问未删除 2-已访问已删除)
int Stack[maxv];  //手动栈
int TarBfs (int v, int lay, int &scc_num)
{
    /*v: 新加入的点; lay: 时间戳; scc_num: 记录强连通分量的数量*/

    /*第2步：初始化dfn[v]和low[v]*/
    temp[v]= 1;
    low[v]= lay;
    dfn[v]= lay;
    Stack[++ m]= v;
    for (int k= Head[v]; k!= -1; k= edegs[k].Next)
    {
        /*对于v 的所有邻接节点u：*/
        int u= edegs[k].to;
        if (temp[u]== 0)
        {
            /*第2-1步：如果没有访问过，则跳转执行第2步，同时维护low[v]*/
            TarBfs(u, ++ lay, scc_num);
        }
        if (temp[u]== 1)
        {
            /*第2-2步：如果访问过，但没有删除，维护low[v]*/
            low[v]= min(low[v], low[u]);
        }
    }
    if (dfn[v]== low[v])
    {
        /*如果low[v]== dfn[v]，则当前节点是一个强连通分量的根，
        那么输出相应的强连通分量。*/
        ++ scc_num;
        do
        {
            low[Stack[m]]= scc_num;
            temp[Stack[m]]= 2;  //已删除的节点temp更新为2
        }while (Stack[m --]!= v);
    }
    return 0;
}

int Tarjan(int n)
{
    int scc_num= 0, lay= 1;
    m= 0;
    memset(temp, 0, sizeof(temp));
    memset(low, 0, sizeof(low));
    for (int i= 1; i<= n; i ++)
    {
        if (temp[i]== 0)
        {
            /*第1步：找一个没有被访问过的节点v，否则算法结束*/
            TarBfs(i, lay, scc_num);
        }
    }
    /*返回强连通分量的个数*/
    return scc_num;
}

int main()
{
    int n;
    /*建图*/
    int ans= Tarjan(n);
    return 0;
}

思路：

　　如果对于原图进行深度优先搜索，由强连通分量定义可知，任何一个强连通分量是原图的深度优先搜索树的子树。那么，只要确定每个极大强连通子图（强连通分量子树）的根，然后根据这些根从数的最底层开始，一个一个地取出强连通分量即可。

　　对于确定强连通分量的根，这里维护两个数组，一个是dfn[ ]，一个是low[ ]，其中dfn[v ] 表示顶点v 被访问的时间，low[v ]为与顶点v 邻接的未删除的顶点u 的low[u ]与low[v ]的最小值（low[v ]初始化为dfn[v ] ）。如果发现一个点，low[v ]== dfn[v ] ，则该点就是一个强连通分量的根。

伪代码：

1.找一个没有被访问过的节点v，否则算法结束

2.初始化dfn[v]和low[v]。对于v 的所有邻接节点u：

①如果没有访问过，则跳转执行第2步，同时维护low[v]；

②如果访问过，但没有删除，维护low[v]；

如果low[v]== dfn[v]，则当前节点是一个强连通分量的根，那么输出相应的强连通分量。