Gabow算法

有向图强连通分量的定义：在有向图G中，如果两个顶点vi,vj间（vi!= vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(stronglyconnected components)。

 

对于一幅无向图来说，只要2个顶点相连在同一路径上，那么这两个顶点就是连通的，从其中一个顶点可以到达另一顶点，求出哪些顶点是连通的也并不难。而对于有向图，受方向限制，两个连通的顶点并不一定能互相到达。如果两个连通的顶点可以相互到达，那么这两个顶点是强连通的。如果将图中所有的互相强连通的顶点划为一组，那么这组顶点就是强连通分量。高效求出强连通分量的算法有Kosaraju算法，Tarjan算法，Gabow算法。我表示我只能看懂Gabow算法。

据说Gabow算法和Tarjan算法的思想是一样的。每个强连通分量都有一个“根”，根是强连通分量中最先被检查的顶点。在一组强连通分量中，沿着根不断深度优先搜索，最终将会回到根，路上经过的顶点则属于这个强连通分量。

 

准备工作：

因为是演示，假定只有6个顶点，而且序号是连续的。#define MAXVERTEX 6

首先需要一个数组，用来保存当前顶点被检测的顺序。intOrder[MAXVERTEX];在这里将-1定为初始值，即没有被检测。Order[v]表示顶点v是第几个被检测的。除了这个数组，还需要一个变量，用来表示当前的顺序。intOrderNum=0;初始化为0表示还没开始检测。

结果也以数组的形式表示，为每个强连通分量分配一个不同的编号，而一个强连通分量中的所有顶点编号相同。int Part[MAXVERTEX];开始这个数组应该被初始化为-1，表示还不确定其中的顶点属于哪个强连通分量。同样还需要一个变量表示当前处理到第几个强连通分量。int PartNum=0;表示还没开始处理。

另外还需要2个辅助栈。第一个用来保存在一次深度优先搜索过程中遇到的顶点。stack<int> Path;这些顶点还没有被确定属于哪个强连通分量，在确定顶点属于某个强连通分量之后，就记录结果，将顶点弹出堆栈。第二个用来保存在一次深度优先搜索过程中遇到的根。stack<int>Root;

 

步骤1:

在所有顶点中，找一个没有被访问过的节点v，以v为参数执行步骤2。否则完成。

步骤2:

记录v的访问顺序。

将v压入堆栈Path和Root。

如果v指向其它的邻接顶点，那么对于每个邻接顶点next：

1) 如果没有访问过，则以next为参数，递归执行步骤2。

2) 如果访问过，而且没有确定它属于哪个强连通分量，弹出Root栈中next之后所有的顶点。

如果Root栈的顶元素等于v，那么在Part中记录顶点对应的的强连通分量。

最后递归返回。

 

代码：

#include <Windows.h>

#include <stack>

#include <vector>

using namespace std;

 

#define MAXVERTEX 6  //the number ofvertex

vector<int> Edge[MAXVERTEX]; //gragh

int Order[MAXVERTEX];//被检测顺序

int OrderNum=0;

int Part[MAXVERTEX]; // 连通变量的标号；

int PartNum=0;

stack<int> Path; //record dfs path;

stack<int> Root;//

 

void Gabow(int v)

{

    Order[v]=++OrderNum; //v  the order of visiting ;

    Path.push(v);

    Root.push(v);

 

    for (inte=0;e<Edge[v].size();e++)

    {

        int next=Edge[v][e]; //neighbor

        if (Order[next]==-1) //whether to visited

            Gabow(next);

        else if (Part[next]==-1)//visited and not label the connectivity;

        {

            while(Order[Root.top()]>Order[next])

                Root.pop();

        }

    }

 

    if (v==Root.top())

    {

        Root.pop();

        PartNum++;

        int Top;

        do

        {

            Top=Path.top();

            Part[Top]=PartNum;

            Path.pop();

        } while (Top!=v);

    }

}

 

int _stdcall WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTRlpCmdLine,int nShowCmd)

{

    Edge[0].push_back(1);Edge[0].push_back(2);

    Edge[1].push_back(3);

    Edge[2].push_back(3);Edge[2].push_back(4);

    Edge[3].push_back(0);Edge[3].push_back(5);

    Edge[4].push_back(5);

    //-1的十六进制表示为0xFFFFFFFF，所以memset没错

    memset(Order,-1,sizeof(Order));

    memset(Part,-1,sizeof(Part));

 

    for (int v=0;v<MAXVERTEX;v++)

        if (Order[v]==-1)

            Gabow(v);

 

    WCHAR Tmp[100]={0};

    WCHAR Result[200]={0};

    for (int i=1;i<PartNum+1;i++)

    {

        wsprintf(Tmp,TEXT("第%d组强连通分量："),i);

        wcscat(Result,Tmp);

        for (intv=0;v<MAXVERTEX;v++)

        {

            if (Part[v]==i)

            {

                wsprintf(Tmp,TEXT("%d"),v);

                wcscat(Result,Tmp);

            }

        }

        wcscat(Result,TEXT("\n"));

    }

    MessageBox(NULL,Result,TEXT("Title"),MB_OK);

    return 0;

}

 

 

vector型数组Edge表示图的邻接表形式。图是这个样子的：

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

 

WinMain函数中的循环逐个检查未被检查过的顶点，调用Gabow函数。

Gabow函数检测一个顶点v，将顶点v标记，并分别放入栈Path和Root中。

如果顶点v指向其它顶点，则对于每个指向的顶点next：

如果next是没有检测过的顶点（Order[next]不为-1），递归地调用Gabow函数，继续进行深度优先搜索检测。

如果next已经检测过，而且已经确定它所属的强连通分量（Part[next]!=-1），说明对它的检测已完成，且只能由v到next，不能由next到v。它现在不在栈中，忽略。

如果next已经检测过，但没有确定其所属的强连通分量（Part[next]==-1），说明现在发现了一个有向环。由next出发，到vi，到vj，到vk……到v，又到next。这些顶点都是强连通的。其中next是这个强连通分量的根，它最早进入Root栈，现在还在栈中。根据保存的顶点检查次序，将Root栈中next之后进入的顶点全部删除，仅保留根next。

其实每一次将顶点放入Root，都可以理解为每个检查到的顶点是一个单独的强连通分量，根就是它自己。直到发现下一个顶点在不久前检查过，确定了从那个顶点到这个顶点之间是一个环，才把这些顶点串了起来，此时最早检查的那个顶点就是它们的根。

对v所有指向的next进行同样的步骤继续检测，直到一个顶点没有邻接顶点，或一个顶点指向的所有顶点都已被检测。

现在已经能确定Path中的顶点所属的强连通分量了。获得Root最顶部的根顶点，这是最近的根顶点。Path中栈顶到这个根顶点之间的顶点为一个强连通分量。对比当前顶点v是否是这个根顶点，如果不是，直接返回，回到上一个检查的顶点进行对比。如果是，就删除Root顶部的根顶点，将强连通分量编号PartNum+1，同时将Path中栈顶到这个根顶点之间的顶点不断弹出，记录进Part数组中。

在递归的返回途中，如果发现某个顶点的下一个顶点没有被检测过，还会继续DFS，执行相同的步骤。不过，这些顶点就不一定与这个顶点强连通了。

这一系列深度优先搜索的递归完成之后，会检测图中的下一个顶点，如果下一顶点未被检测，将以同样的方式处理这个顶点。

 

流程图：

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	-1	-1	-1	-1	-1
Part	-1	-1	-1	-1	-1	-1
Path	0
Root	0

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	-1	-1	-1	-1
Part	-1	-1	-1	-1	-1	-1
Path	0	1
Root	0	1

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	-1	3	-1	-1
Part	-1	-1	-1	-1	-1	-1
Path	0	1	3
Root	0	1	3

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	-1	3	-1	-1
Part	-1	-1	-1	-1	-1	-1
Path	0	1	3
Root	0

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	-1	3	-1	4
Part	-1	-1	-1	-1	-1	-1
Path	0	1	3	5
Root	0	5

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	-1	3	-1	4
Part	-1	-1	-1	-1	-1	1
Path	0	1	3
Root	0

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	5	3	-1	4
Part	-1	-1	-1	-1	-1	1
Path	0	1	3	2
Root	0	2

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	5	3	-1	4
Part	-1	-1	-1	-1	-1	1
Path	0	1	3	2
Root	0

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	5	3	6	4
Part	-1	-1	-1	-1	-1	1
Path	0	1	3	2	4
Root	0	4

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	5	3	6	4
Part	-1	-1	-1	-1	-1	1
Path	0	1	3	2	4
Root	0	4

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	5	3	6	4
Part	-1	-1	-1	-1	2	1
Path	0	1	3	2
Root	0

 

0 → 1 

↓↖ ↓

2 → 3 

↓   ↓

4 → 5 

Order	1	2	5	3	6	4
Part	3	3	3	3	2	1
Path
Root

 

Written By Wolfspirit(1152401936)

2013年4月25日6:30