Tarjan 算法
一.算法简介
Tarjan 算法一种由Robert Tarjan提出的求解有向图强连通分量的算法,它能做到线性时间的复杂度。
我们定义:
如果两个顶点可以相互通达,则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通,称G是一个强连通图。有向图的极大强连通子图,称为强连通分量(strongly connected components)。
例如:在上图中,{1 , 2 , 3 , 4 } , { 5 } , { 6 } 三个区域可以相互连通,称为这个图的强连通分量。
Tarjan算法是基于对图深度优先搜索的算法,每个强连通分量为搜索树中的一棵子树。搜索时,把当前搜索树中未处理的节点加入一个堆栈,回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。
再Tarjan算法中,有如下定义。
DFN[ i ] : 在DFS中该节点被搜索的次序(时间戳)
LOW[ i ] : 为i或i的子树能够追溯到的最早的栈中节点的次序号
当DFN[ i ]==LOW[ i ]时,为i或i的子树可以构成一个强连通分量。
二.算法图示
以1为Tarjan 算法的起始点,如图
顺次DFS搜到节点6
回溯时发现LOW[ 5 ]==DFN[ 5 ] , LOW[ 6 ]==DFN[ 6 ] ,则{ 5 } , { 6 } 为两个强连通分量。回溯至3节点,拓展节点4.
拓展节点1 , 发现1再栈中更新LOW[ 4 ],LOW[ 3 ] 的值为1
回溯节点1,拓展节点2
自此,Tarjan Algorithm 结束,{1 , 2 , 3 , 4 } , { 5 } , { 6 } 为图中的三个强连通分量。
不难发现,Tarjan Algorithm 的时间复杂度为O(E+V).
三.算法模板
1 void Tarjan ( int x ) { 2 dfn[ x ] = ++dfs_num ; 3 low[ x ] = dfs_num ; 4 vis [ x ] = true ;//是否在栈中 5 stack [ ++top ] = x ; 6 for ( int i=head[ x ] ; i!=0 ; i=e[i].next ){ 7 int temp = e[ i ].to ; 8 if ( !dfn[ temp ] ){ 9 Tarjan ( temp ) ; 10 low[ x ] = gmin ( low[ x ] , low[ temp ] ) ; 11 } 12 else if ( vis[ temp ])low[ x ] = gmin ( low[ x ] , dfn[ temp ] ) ; 13 } 14 if ( dfn[ x ]==low[ x ] ) {//构成强连通分量 15 vis[ x ] = false ; 16 color[ x ] = ++col_num ;//染色 17 while ( stack[ top ] != x ) {//清空 18 color [stack[ top ]] = col_num ; 19 vis [ stack[ top-- ] ] = false ; 20 } 21 top -- ; 22 } 23 }
注:本文章上部分内容转载自http://www.cppblog.com/sosi/archive/2010/09/26/127797.html;一方面是网上有很多关于tarjan算法的介绍,我觉得都没有这个他的文章介绍的简明易懂或者没有具体的实现。另一方面,自己也顺便用java实现了一下,所以发表出来和大家分享分享!
[有向图强连通分量]
在有向图G中,如果两个顶点间至少存在一条路径,称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通,称G是一个强连通图。非强连通图有向图的极大强连通子图,称为强连通分量(strongly connected components)。
下图中,子图{1,2,3,4}为一个强连通分量,因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量。
[Tarjan算法]
Tarjan算法是基于对图深度优
定义DFN(u)D记录搜索到该u的时间,也就是第几个搜索u的。Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。
算法伪代码如下
tarjan(u)
{
DFN[u]=Low[u]=++Index // 为节点u设定次序编号和Low初值
Stack.push(u) // 将节点u压入栈中
for each (u, v) in E // 枚举每一条边
if (v is not visted) // 如果节点v未被访问过
tarjan(v) // 继续向下找
Low[u] = min(Low[u], Low[v])
else if (v in S) // 如果节点v还在栈内
Low[u] = min(Low[u], DFN[v])
if (DFN[u] == Low[u]) // 如果节点u是强连通分量的根
repeat
v = S.pop // 将v退栈,为该强连通分量中一个顶点
print v
until (u== v)
}
接下来是对算法流程的演示。
从节点1开始DFS,把遍历到的节点加入栈中。搜索到节点u=6时,DFN[6]=LOW[6],找到了一个强连通分量。退栈到u=v为止,{6}为一个强连通分量。
返回节点5,发现DFN[5]=LOW[5],退栈后{5}为一个强连通分量。
返回节点3,继续搜索到节点4,把4加入堆栈。发现节点4向节点1有后向边,节点1还在栈中,所以LOW[4]=1。节点6已经出栈,(4,6)是横叉边,返回3,(3,4)为树枝边,所以LOW[3]=LOW[4]=1。
继续回到节点1,最后访问节点2。访问边(2,4),4还在栈中,所以LOW[2]=DFN[4]=5。返回1后,发现DFN[1]=LOW[1],把栈中节点全部取出,组成一个连通分量{1,3,4,2}。
至此,算法结束。经过该算法,求出了图中全部的三个强连通分量{1,3,4,2},{5},{6}。
可以发现,运行Tarjan算法的过程中,每个顶点都被访问了一次,且只进出了一次堆栈,每条边也只被访问了一次,所以该算法的时间复杂度为O(N+M)。
算法java实现如下:
Tarjan类:
-
import java.util.ArrayList;
-
import java.util.Arrays;
-
import java.util.List;
-
import java.util.Stack;
-
public class Tarjan {
-
private int numOfNode;
-
private List< ArrayList<Integer> > graph;//图
-
private List< ArrayList<Integer> > result;//保存极大强连通图
-
private boolean[] inStack;//节点是否在栈内,因为在stack中寻找一个节点不方便。这种方式查找快
-
private Stack<Integer> stack;
-
private int[] dfn;
-
private int[] low;
-
private int time;//
-
public Tarjan(List< ArrayList<Integer> > graph,int numOfNode){
-
this.graph = graph;
-
this.numOfNode = numOfNode;
-
this.inStack = new boolean[numOfNode];
-
this.stack = new Stack<Integer>();
-
dfn = new int[numOfNode];
-
low = new int[numOfNode];
-
Arrays.fill(dfn, -1);//将dfn所有元素都置为-1,其中dfn[i]=-1代表i还有没被访问过。
-
Arrays.fill(low, -1);
-
result = new ArrayList<ArrayList<Integer>>();
-
}
-
public List< ArrayList<Integer> > run(){
-
for(int i=0;i<numOfNode;i++){
-
if(dfn[i]==-1){
-
tarjan(i);
-
}
-
}
-
return result;
-
}
-
public void tarjan(int current){
-
dfn[current]=low[current]=time++;
-
inStack[current]=true;
-
stack.push(current);
-
for(int i=0;i<graph.get(current).size();i++){
-
int next = graph.get(current).get(i);
-
if(dfn[next]==-1){//-1代表没有被访问
-
tarjan(next);
-
low[current]=Math.min(low[current], low[next]);
-
}else if(inStack[next]){
-
low[current]=Math.min(low[current], dfn[next]);
-
}
-
}
-
if(low[current]==dfn[current]){
-
ArrayList<Integer> temp =new ArrayList<Integer>();
-
int j = -1;
-
while(current!=j){
-
j = stack.pop();
-
inStack[j]=false;
-
temp.add(j);
-
}
-
result.add(temp);
-
}
-
}
-
}
测试类:
-
import java.util.ArrayList;
-
import java.util.List;
-
import java.util.Stack;
-
public class Main {
-
public static void main(String[] args) {
-
//创建图
-
int numOfNode = 6;
-
List< ArrayList<Integer> > graph = new ArrayList<ArrayList<Integer>>();
-
for(int i=0;i<numOfNode;i++){
-
graph.add(new ArrayList<Integer>());
-
}
-
graph.get(0).add(1);
-
graph.get(0).add(2);
-
graph.get(1).add(3);
-
graph.get(2).add(3);
-
graph.get(2).add(4);
-
graph.get(3).add(0);
-
graph.get(3).add(5);
-
graph.get(4).add(5);
-
//调用Tarjan算法求极大连通子图
-
Tarjan t = new Tarjan(graph, numOfNode);
-
List< ArrayList<Integer> > result = t.run();
-
//打印结果
-
for(int i=0;i<result.size();i++){
-
for(int j=0;j<result.get(i).size();j++){
-
System.out.print(result.get(i).get(j)+" ");
-
}
-
System.out.println();
-
}
-
}
-
}
先搜索的算法,每个强连通分量为搜索树中的一棵子树。搜索时,把当前搜索树中未处理的节点加入一个堆栈,回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。