★★★★Tarjan算法详解

http://blog.csdn.net/jeryjeryjery/article/details/52829142?locationNum=4&fps=1

在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。

如下图中，强连通分量有：{1,2,3,4}，{5}，{6}

Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。Tarjan算法有点类似于基于后序的深度遍历搜索和并查集的组合，充分利用回溯来解决问题。
在Tarjan算法中为每个节点i维护了以下几个变量：
DFN[i]：深度优先搜索遍历时节点i被搜索的次序。
low[i]：节点i能够回溯到的最早位于栈中的节点。
flag[i]：标记几点i是否在栈中。

Tarjan算法的运行过程：
1.首先就是按照深度优先搜索算法搜索的次序对图中所有的节点进行搜索。
2.在搜索过程中，对于任意节点u和与其相连的节点v，根据节点v是否在栈中来进行不同的操作：
*节点v不在栈中，即节点v还没有被访问过，则继续对v进行深度搜索。
*节点v已经在栈中，即已经被访问过，则判断节点v的DFN值和节点u的low值的大小来更新节点u的low值。如果节点v的 DFN值要小于节点u的low值，根据low值的定义（能够回溯到的最早的已经在栈中的节点），我们需要用DFN值来更新u 的low值。
3.在回溯过程中，对于任意节点u与其子节点v(其实不能算是子节点，只是在深度遍历的过程中，v是在u之后紧挨着u的节点)的   low值来更新节点u的low值。因为节点v能够回溯到的已经在栈中的节点，节点u也一定能够回溯到。因为存在从u到v的直接路   径，所以v能够到的节点u也一定能够到。
4.对于一个连通图，我们很容易想到，在该连通图中有且仅有一个节点u的DFN值和low值相等。该节点一定是在深度遍历的过   程中，该连通图中第一个被访问过的节点，因为它的DFN值和low值最小，不会被该连通图中的其他节点所影响。下面我们证   明为什么仅有一个节点的DFN和low值相等。假设有两个节点的DFN值和low值相等，由于这两个节点的DFN值一定不相同 （DFN值的定义就是深度遍历时被访问的先后
   次序），所以两个的low值也绝对不相等。由于位于同一个连通图中，所以两个节点必定相互可达，那么两者的low值一定会   被另外一个所影响（要看谁的low值更小），所以不可能存在两对DFN值和low值相等的节点。

   所以我们在回溯的过程中就能够通过判断节点的low值和DFN值是否相等来判断是否已经找到一个子连通图。由于该连通图中   的DFN值和low值相等的节点是该连通图中第一个被访问到的节点，又根据栈的特性，则该节点在最里面。所以能够通过不停   的弹栈，直到弹出该DFN值和low值相同的节点来弹出该连通图中所有的节点。

Tarjan算法的C++实现代码如下，可以配合上面的图加以理解：

[cpp] view plain copy

1. #include<iostream>  
2. using namespace std;  
3. int DFN[105];                                  //记录在做dfs时节点的搜索次序  
4. int low[105];                                  //记录节点能够找到的最先访问的祖先的记号  
5. int count=1;                                   //标记访问次序，时间戳  
6. int stack[105];                                //压入栈中  
7. int top=-1;  
8. int flag[105];                                 //标记节点是否已经在栈中  
9. int number=0;  
10. int j;  
11. int matrix[105][105]={{0,1,1,0,0,0},{0,0,0,1,0,0},{0,0,0,1,1,0},{1,0,0,0,0,1},{0,0,0,0,0,1},{0,0,0,0,0,0}};  
12. int length;                                    //图的长度  
13. void tarjan(int u){  
14.     DFN[u]=low[u]=count++;                     //初始化两个值，自己为能找到的最先访问的祖先  
15.     stack[++top]=u;  
16.     flag[u]=1;                                 //标记为已经在栈中  
17.   
18.     for(int v=0;v<length;v++){  
19.     if(matrix[u][v]){  
20.         if(!DFN[v]){                       //如果点i没有被访问过  
21.         tarjan(v);                     //递归访问  
22.         if(low[v]<low[u])  
23.             low[u]=low[v];             //更新能找的到祖先  
24.         }  
25.         else{                              //如果访问过了，并且该点的DFN更小，则  
26.         if(DFN[v]<low[u]&&flag[v])     //flag[v]这个判断条件很重要，这样可以避免已经确定在其他联通图的v,因为u到v的单向边而影响到u的low  
27.         low[u]=DFN[v];                 //也就是已经确定了的联通图要剔除掉，剔除的办法就是判断其还在栈中，因为已经确定了的连通图的点  
28.         }                                  //flag在下面的do while中已经设为0了(即已经从栈中剔除了)  
29.     }  
30.     }  
31.   
32.     //往后回溯的时候，如果发现DFN和low相同的节点，就可以把这个节点之后的节点全部弹栈，构成连通图  
33.     if(DFN[u]==low[u]){  
34.     number++;                               //记录连通图的数量  
35.     do{  
36.         j=stack[top--];                     //依次取出，直到u  
37.         cout<<j<<" ";  
38.         flag[j]=0;                          //设置为不在栈中  
39.     }while(j!=u);  
40.         cout<<endl;  
41.     }  
42. }  
43. int main(){  
44.       
45.     memset(DFN,0,sizeof(DFN));                  //数据的初始化  
46.     memset(low,0,sizeof(low));  
47.     memset(flag,0,sizeof(flag));  
48.       
49.     length=6;  
50.     tarjan(0);  
51.   
52.     cout<<endl;  
53.     for(int i=0;i<6;i++){  
54.     cout<<"DFN["<<i<<"]:"<<DFN[i]<<" low["<<i<<"]:"<<low[i]<<endl;  
55.     }  
56.     return 0;  
57. }