tarjan 强连通分量

一、强连通分量定义

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

以上是摘自百科的一段对有向图强连通图分量的形式化定义。其实不难理解，举个例子

如上图，{a,b,c,d}为一个强连通分量，{e}为一个强连通分量，{f}为一个强连通分量。

二、SCC求解算法

给定一个有向图，如何求它的强连通分量呢？

一般有两种算法：

1、kosaraju算法：该算法分别对图G和其转置G^T做dfs，第一次对G做dfs确定出各个强连通分量之间的拓扑序，第二按照拓扑逆序对G(T)做dfs，这样每次dfs都得到一个强连通分量。算法复杂度为O(V+E)。

2、tarjan算法：tarjan算法也是基于dfs求解SCC，与kosaraju通过拓扑序做dfs使得各个SCC“互不干涉”的思想不同，tarjan算法只对原图做一次dfs，运行各个SCC在dfs过程中“交织在一起”，并且在dfs过程中记录一些节点信息，通过这些信息识别出一个个SCC。算法复杂度为O(V+E)。

相比而言，tarjan算法不需要对图做转置，而且只做一次dfs，所以执行效率更高。

本文主要梳理tarjan 强连通分量算法。

三、dfs相关概念

tarjan算法本身是一个dfs算法，用到了dfs的一些性质,所以具体展开tarjan SCC算法之前，先来梳理一些相关的基础。

1、搜索树（森林）：对一个图做dfs搜索，搜索过程形成一颗搜索树。

2、节点访问次序d[i]: dfs过程中，按照节点访问到的顺序个每个节点记录一个值d[i]。另外，也可以对每个节点记录访问完成的次序f[i]。

3、dfs对边的分类：

　　树边：搜索过程中自然形成的边。如果通过节点i dfs搜索其邻居节点j时，发现j之前还未被访问，在dfs搜索j，这时边<i,j>形成搜索树种一条搜索经过的边，称作树边

反向边：搜索过程中后裔指向祖先的边。如果通过节点i dfs搜索其邻居节点j时，发现j在搜索树中是i的祖先（j已经被dfs搜索到，但是还没递归返回），这时边<i,j>是反向边。

　　正向边：搜索过程中祖先指向后裔的边。

　　交叉表：搜索过程中不同子树之间的边。

　　一条性质：在dfs过程中，通过节点i遍历邻居j时候，如果j已经被之前访问到（不一定递归访问完成）且d[i]>d[j]则边<i，j>是一条反向边或交叉边。这条性质在tarjan算法中会用到。

注：关于dfs及dfs对边的分类等知识，《算法导论》中有详细的描述，这里只列出对本文讲解tarjan算法相关的内容。

下图是对以上概念的一个解释：

图中左边是原图，右边是一棵dfs搜索树，标注了节点d[i]值和都边的分类。根据dfs访问节点顺序不同，搜索树、d[i]已经边的分类也会不同，但并不影响相关的性质。

四、tarjan SCC算法

理解了一些基础概念，现在还看看tarjan求解强连通分量的算法。水平有限，关于算法的形式化证明不会涉及，只会阐述算法的思想和过程。

算法基本思想

tarjan算法的思想基于以下性质

a）如果节点i和节点j在同一个强连通分类中，那么它们在搜索树中会有共同的祖先

b) 强连通分量在搜索树中形成一棵子树。

先上图直观理解下:

对于性质a）我们可以看到，{a,b,c,d}是一个SCC，在搜索树中，它们之中任意两个节点都是有共同祖先的。

性质b)是性质a)的自然推论，可以看到，三个SCC {a,b,c,d} {e} {f} 都对应搜索树中的一个子树，用虚线框了起来。

其实不难理解性质的正确性，想象一下dfs的过程，一旦dfs访问到SCC中的一个节点，这个SCC中的所有节点后续都会都访问到，应为它们是相互可达的。这样的话，一个SCC中任意两个节点拥有一个共同祖先就是肯定的了，因为最坏的情况下，它们的共同祖先可以是这个SCC中第一个被访问到的节点。以上图为例，c和b有个公共祖先b，c和d用公共祖先a，a作为该SCC中第一个被dfs访问到的节点，可以作为任意两个节点的公共祖先。这样的话性质a)就是正确的，至于性质b),就是性质a)的自然推论了，同一SSC中的节点都有一个共同的祖先（第一个比访问到的节点），不就是一个子树嘛。

上图中红色节点标志了一个子树的根，称为scc root,它是所在的SCC中第一个被dfs遍历到的节点。

理解了上面两条性质，已经基本上可以看出tarjan算法求解SCC的基本思想了：既然每个SCC都是一个搜索树的一个子树，那么找到子树的根，从搜索树中“摘下”一个子树，不就是一个SCC吗？问题是，怎么找到子树根呢？

求解

定义以下变量：

d[i]:节点i的访问顺序，上文已提到；

low[i]: 节点i 通过零或多条树边 之后，再经过至多一条反向边或交叉边 所能到达的同一个SCC中的最早访问的节点k的访问次序d[k]。

根据low[i]的定义，其计算过程如下：

low[i] = min{low[i],low[j]} : 如果<i,j>是树边，根据定义j能到达那个节点，i通过树边<i,j>之后也可以到达

low[i] = min[low[i],d[j]]: 如果<i,j>是反向边或交叉边，根据定义，i只能到达j值，因为路径上只允许有最多一条反向边或交叉边，而且是以该边结束的。

注：正向边不影响SCC连通性tarjan算法不考虑正向边。

绕口的一B是吧，看个例子：

如图: 节点上标注了d[i]/low[i]。{a,b,c,d}是一个SCC，节点b经过一条树边和一条反向边可以到达同一个SCC中的最早访问节点a，节点d[i]值为1，所以low[b]=1; 节点d经过0条树边，一条交叉边后可以到达达同一个SCC中的最早访问节点c，节点c的d[i]值d[c]=3,所以low[d]=3。

有了以上定义之后，tarjan算法有一条关键的定理：

定理： d[i]=low[i] <=> 节点 i 是一个scc root

该定理的严格形式化证明可以参考下论文原文。其实简单理解就是，同一个SCC中的节点只有scc root 满足d[i]=low[i],为什么呢?

考虑同一个SCC中的节点，分两个情况：

1、对于scc root节点，显然满足d[i]=low[i]

2、对于其他节点，一定low[i]<d[i]。再分成两种情况考虑：

　　2.1、节点i通过反向边（无论是直接一条反向边或通过它的子节点）访问到了自己的祖先k，则low[i]=d[k], k值i的祖先，所以d[i]<low[i]。如上图中的c或d，它们都通过反向边(包含树边)可以到达祖先a；

　　2.2、节点i通过交叉边到达同一个scc中的节点：通过交叉边到达节点k，有low[i]=d[k],最好的情况下k是scc root，或者一个情况下k值ssc中其他节点，无论哪种情况，由于k之前已经被访问到，所以low[i]=d[k]<d[i]。如上图中的节点d，通过交叉边到达c。

通过以上两点，就可以证明在一个SCC中，只有scc root满足 d[i] = low[i] 。

上文说过了，tarjan算求解SSC已经转换为求解scc root的问题，而这条定理给出了scc root的求解方法，至此，整个流程就通了: dfs遍历原图，递归计算low[i],节点i递归遍历完成后，如果发现d[i]=low[i]则，找到了一个SCC，当然，这其中还涉及到找到scc root之后，如何根据scc root 得到一个scc的问题，其实tarjan算法dfs过程中，用栈来记录访问到的节点，找到scc root之后，从栈顶一次弹出节点，直到遇到scc root节点，便可构成一个scc，下面的算法实现描述了这一过程。

实现

1、首先看一下tarjan论文中的伪代码实现，个人加了相关注释：

原文的 NUMBER对应本文中d[i], LOWLINK对应本文中low

2、java实现：

//dfs过程中节点状态

1 1 public enum Status {
2 2     NOT_VISIT,VISITING,VISITED;
3 3 }

View Code

//SCC 数据结构

 1 1 public class SccMeta {
 2  2     private int sccCount;
 3  3     private List<List<Node>> sccList;
 4  4 
 5  5     public SccMeta(){
 6  6         this.sccCount = 0;
 7  7         this.sccList = new ArrayList<>();
 8  8     }
 9  9 
10 10     public int getSccCount(){
11 11         return sccCount;
12 12     }
13 13 
14 14     public List<List<Node>> getSccList(){
15 15         return sccList;
16 16     }
17 17 
18 18     public void addScc(List<Node> scc){
19 19         this.sccList.add(scc);
20 20         this.sccCount++;
21 21     }
22 22 
23 23     @Override
24 24     public String toString(){
25 25         StringBuilder s = new StringBuilder();
26 26         s.append("Strongly Connected Componnet:").append("\n");
27 27         for(int i=0; i< sccCount; i++){
28 28             s.append("scc " + i+":");
29 29             s.append(sccList.get(i).toString());
30 30             s.append("\n");
31 31         }
32 32         return s.toString();
33 33     }
34 34 }

View Code

//tarjan scc 主函数，依次遍历每一个未访问的节点

 1 1 public SccMeta scc() {
 2  2         initScc();
 3  3         SccMeta sccMeta = new SccMeta();
 4  4         int nodeNum = size();
 5  5         for(int i=0; i<nodeNum;i++){
 6  6             if(status[i] == Status.NOT_VISIT){
 7  7                 tarjan(i, sccMeta);
 8  8             }
 9  9         }
10 10         return sccMeta;
11 11     }

View Code

//tarjan 递归过程

 1 private void tarjan(int i,SccMeta sccMeta){
 2         low[i] = d[i] = timer++;
 3         stack.push(i);
 4         status[i] = Status.VISITING;
 5         List<Integer> neighbors = adjacencyList.get(i);
 6         for(int j : neighbors){
 7             if(status[j] == Status.NOT_VISIT){ // 节点j未访问，边<i,j>是树边
 8                 tarjan(j, sccMeta);
 9                 low[i] = Math.min(low[i],low[j]);
10             }else if(d[i] > d[j]){ // 节点j节点j已经被访问过，<i,j>是反向边或交叉边
11                 if(stack.contains(j)){
12                     low[i] = Math.min(low[i],d[j]);
13                 }
14             }else{
15                 //节点j已经被访问过，而且<i,j>是前向边,忽略
16             }
17         }
18         status[i] = Status.VISITED;
19 
20         if(d[i] == low[i]){ // node i is a ssc root
21             List<Node> scc = new LinkedList<>();
22             int k;
23             do{
24                 k = stack.pop();
25                 scc.add(getNode(k));
26             }while(k != i);
27             sccMeta.addScc(scc);
28         }
29     }