When the depth-first search reaches a vertex v, the algorithm performs the following steps:
- Set the preorder number of v to C, and increment C.
- Push v onto S and also onto P.
- For each edge from v to a neighboring vertex w:
- If the preorder number of w has not yet been assigned, recursively search w;
- Otherwise, if w has not yet been assigned to a strongly connected component:
- Repeatedly pop vertices from P until the top element of P has a preorder number less than or equal to the preorder number of w.
- If v is the top element of P:
- Pop vertices from S until v has been popped, and assign the popped vertices to a new component.
- Pop v from P.
Gabow_Algorithm伪代码:
step1:
找一个没有被访问过的节点v，goto step2(v)。否则，算法结束。
step2(v):
将v压入堆栈stk1[]和stk2[]
对于v所有的邻接顶点u：
1) 如果没有访问过，则step2(u)
2) 如果访问过，但没有删除，维护stk2[](处理环的过程，在stk2 中删除构成环的节点)
如果stk2[]的顶元素==v，那么输出相应的强连通分量
这个算法其实就是Tarjan算法的变异体，我们观察一下，只是它用第二个堆栈来辅助求出强连通分量的根，而不是Tarjan算法里面的DFN[]和Low[]数组。那么，我们说一下如何使用第二个堆栈来辅助求出强连通分量的根。
我们使用类比方法，在Tarjan算法中，每次Low[i]的修改都是由于环的出现(不然，Low[i]的值不可能变小)，每次出现环，在这个环里面只剩下一个Low[i]没有被改变(深度最低的那个)，或者全部被改变，因为那个深度最低的节点在另一个环内。那么Gabow算 法中的第二堆栈变化就是删除构成环的节点，只剩深度最低的节点，或者全部删除，这个过程是通过出栈来实现，因为深度最低的那个顶点一定比前面的先访问，那 么只要出栈一直到栈顶那个顶点的访问时间不大于深度最低的那个顶点。其中每个被弹出的节点属于同一个强连通分量。那有人会问：为什么弹出的都是同一个强连 通分量？因为在这个节点访问之前，能够构成强连通分量的那些节点已经被弹出了，这个对Tarjan算法有了解的都应该清楚，那么Tarjan算法中的判断根我们用什么来代替呢？想想，其实就是看看第二个堆栈的顶元素是不是当前顶点就可以了。
现在，你应该明白其实Tarjan算法和Gabow算法其实是同一个思想的不同实现，但是，Gabow算法更精妙，时间更少(不用频繁更新Low[])。
代码：
#include "cstdlib"
#include "cctype"
#include "cstring"
#include "cstdio"
#include "cmath"
#include "algorithm"
#include "vector"
#include "string"
#include "iostream"
#include "sstream"
#include "set"
#include "queue"
#include "stack"
#include "fstream"
#include "strstream"
using namespace std;
#define M 2000 //题目中可能的最大点数
int STACK[M],top=0; //Gabow 算法中的辅助栈
int STACK2[M],top2=0; //
int DFN[M]; //深度优先搜索访问次序
int ComponetNumber=0; //有向图强连通分量个数
int Index=0; //索引号
int Belong[M]; //某个点属于哪个连通分支
vector <int> Edge[M]; //邻接表表示
vector <int> Component[M]; //获得强连通分量结果
void Gabow(int i)
{
int j;
DFN[i]=Index++;
STACK[++top]=i;
STACK2[++top2]=i;
for (int e=0;e<Edge[i].size();e++)
{
j=Edge[i][e];
if (DFN[j]==-1) Gabow(j);
else if (Belong[j]==-1) //如果访问过，但没有删除，维护STACK2
{
while(DFN[STACK2[top2]]>DFN[j]) //删除构成环的顶点
top2--;
}
}
if(i==STACK2[top2]) //如果Stack2 的顶元素等于i，输出相应的强连通分量
{
--top2; ++ComponetNumber;
do
{
Belong[STACK[top]]=ComponetNumber;
Component[ComponetNumber].push_back(STACK[top]);
}while ( STACK[top--]!=i);
}
}
void solve(int N) //此图中点的个数，注意是0-indexed！
{
memset(STACK,-1,sizeof(STACK));
memset(STACK2,-1,sizeof(STACK2));
memset(Belong,-1,sizeof(Belong));
memset(DFN,-1,sizeof(DFN));
for(int i=0;i<N;i++)
if(DFN[i]==-1)
Gabow(i);
}
/*
此算法正常工作的基础是图是0-indexed的。但是获得的结果Component数组和Belong数组是1-indexed
*/
int main()
{
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);
int N=6;
solve(N);
cout<<"ComponetNumber is "<<ComponetNumber<<endl;
for(int i=0;i<N;i++)
cout<<Belong[i]<<" ";
cout<<endl;
for(int i=0;i<N;i++)
{
for(int j=0;j<Component[i].size();j++)
cout<<Component[i][j];
cout<<endl;
}
return 0;
}
Reference：
http://rchardx.is-programmer.com/posts/14898.html
wiki
终于搞完了SCC问题的3大算法：
小总结一下：
三种算法的时间复杂度都是O(M+N) （N为图的点数，M为边数）
Tarjan 算法和Gabow算法思想类似，在Tarjan算法中用Low[]数组来记录所能达到的最小时间戳，而Gabow算法则是用Stack2[]辅助获得了强连通分量的根！
二者实质是一样的！
Kosaraju 算法则是两次DFS，所以在时间复杂度常数因子的比拼上，肯定拼不过 Tarjan Gabow，但是额外的常数带来了良好的拓扑性质！它得到的节点是按照拓扑序组织好的，在求解2-SAT的过程中十分方便。
下面是题目来总结或者来一个求无向图双连通分量Tarjan算法 和求最近公共祖先的离线Tarjan算法！
再引用一次：
Tarjan算法与求无向图的双连通分量(割点、桥)的Tarjan算法也有着很深的联系。学习该Tarjan算法，也有助于深入理解求双连通分量的Tarjan算法，两者可以类比、组合理解。
求有向图的强连通分量的Tarjan算法是以其发明者Robert Tarjan命名的。Robert Tarjan还发明了求双连通分量的Tarjan算法，以及求最近公共祖先的离线Tarjan算法，在此对Tarjan表示崇高的敬意。