有向圖強連通分量的Tarjan演算法 [有向圖強連通分量]

在有向圖G中，如果兩個頂點間至少存在一條路徑，稱兩個頂點強連通(strongly connected)。如果有向圖G的每兩個頂點都強連通，稱G是一個強連通圖。非強連通圖有向圖的極大強連通子圖，稱為強連通分量(strongly connected components)。

下圖中，子圖{1,2,3,4}為一個強連通分量，因為頂點1,2,3,4兩兩可達。{5},{6}也分別是兩個強連通分量。

直接根據定義，用雙向遍歷取交集的方法求強連通分量，時間複雜度為O(N^2+M)。更好的方法是Kosaraju演算法或Tarjan演算法，兩者的時間複雜度都是O(N+M)。本文介紹的是Tarjan演算法。 [Tarjan演算法]

Tarjan演算法是基於對圖深度優先搜尋的演算法，每個強連通分量為搜尋樹中的一棵子樹。搜尋時，把當前搜尋樹中未處理的節點加入一個堆疊，回溯時可以判斷棧頂到棧中的節點是否為一個強連通分量。

定義DFN(u)為節點u搜尋被搜尋到時的次序編號(時間戳)，Low(u)為u或u的子樹能夠追溯到的最早的棧中節點的次序號。由定義可以得出，

Low(u)=Min{   DFN(u),（第一次被搜尋到）   Low(v),(u,v)為樹枝邊，u為v的父節點   DFN(v),(u,v)為指向棧中節點的後向邊(非橫叉邊)（即沿著u搜到v時，發現v已經被搜過了，也就是說形成了一個環）}

當DFN(u)=Low(u)時，以u為根的搜尋子樹上所有節點是一個強連通分量

接下來是對演算法流程的演示。

從節點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，3，4的low都是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)。

求有向圖的強連通分量還有一個強有力的演算法，為Kosaraju演算法。Kosaraju是基於對有向圖及其逆圖兩次DFS的方法，其時間複雜度也是 O(N+M)。與Trajan演算法相比，Kosaraju演算法可能會稍微更直觀一些。但是Tarjan只用對原圖進行一次DFS，不用建立逆圖，更簡潔。在實際的測試中，Tarjan演算法的執行效率也比Kosaraju演算法高30%左右。此外，該Tarjan演算法與求無向圖的雙連通分量(割點、橋)的Tarjan演算法也有著很深的聯絡。學習該Tarjan演算法，也有助於深入理解求雙連通分量的Tarjan演算法，兩者可以類比、組合理解。

求有向圖的強連通分量的Tarjan演算法是以其發明者Robert Tarjan命名的。Robert Tarjan還發明瞭求雙連通分量的Tarjan演算法，以及求最近公共祖先的離線Tarjan演算法，在此對Tarjan表示崇高的敬意。

附：tarjan演算法的C++程式

1. #include<cstring>
2. #include<cstdio>
3. usingnamespace std;  
4. #define N 100
5. #define M 100
6. struct Edge  
7. {  
8.     int v;  
9.     int next;  
10. };  
11. Edge edge[M];//邊的集合
12. int node[N];//頂點集合
13. int instack[N];//標記是否在stack中
14. int stack[N];  
15. int Belong[N];//各頂點屬於哪個強連通分量
16. int DFN[N];//節點u搜尋的序號(時間戳)
17. int LOW[N];//u或u的子樹能夠追溯到的最早的棧中節點的序號(時間戳)
18. int n, m;//n：點的個數；m：邊的條數
19. int cnt_edge;//邊的計數器
20. int Index;//序號(時間戳)
21. int top;  
22. int Bcnt;//有多少個強連通分量
23. void add_edge(int u, int v)//鄰接表儲存
24. {  
25.     edge[cnt_edge].next = node[u];  
26.     edge[cnt_edge].v = v;  
27.     node[u] = cnt_edge++;  
28. }  
29. void tarjan(int u)  
30. {  
31.     int i,j;  
32.     int v;  
33.     DFN[u]=LOW[u]=++Index;  
34.     instack[u]=true;  
35.     stack[++top]=u;  
36.     for (i = node[u]; i != -1; i = edge[i].next)  
37.     {  
38.         v=edge[i].v;  
39.         if (!DFN[v])//如果點v沒被訪問
40.         {  
41.             tarjan(v);  
42.             if (LOW[v]<LOW[u])  
43.                 LOW[u]=LOW[v];  
44.         }  
45.         else//如果點v已經被訪問過
46.             if (instack[v] && DFN[v]<LOW[u])  
47.                 LOW[u]=DFN[v];  
48.     }  
49.     if (DFN[u]==LOW[u])  
50.     {  
51.         Bcnt++;  
52.         do
53.         {  
54.             j=stack[top--];  
55.             instack[j]=false;  
56.             Belong[j]=Bcnt;  
57.         }  
58.         while (j!=u);  
59.     }  
60. }  
61. void solve()  
62. {  
63.     int i;  
64.     top=Bcnt=Index=0;  
65.     memset(DFN,0,sizeof(DFN));  
66.     memset(LOW,0,sizeof(LOW));  
67.     for (i=1;i<=n;i++)  
68.         if (!DFN[i])  
69.             tarjan(i);  
70. }  
71. int main()  
72. {  
73.     freopen("in.txt","r",stdin);  
74.     int i,j,k;  
75.     cnt_edge=0;  
76.     memset(node,-1,sizeof(node));  
77.     scanf("%d%d",&n,&m);  
78.     for(i=1;i<=m;i++)  
79.     {  
80.         scanf("%d%d",&j,&k);  
81.         add_edge(j,k);  
82.     }  
83.     solve();  
84.     for(i=1;i<=n;i++)  
85.         printf("%d ",Belong[i]);  
86. }  
87. </pre><br>  

Write a program to find the strongly connected components in a digraph.

Format of functions:

void StronglyConnectedComponents( Graph G, void (*visit)(Vertex V) );

where Graph is defined as the following:

typedef struct VNode *PtrToVNode;struct VNode {    Vertex Vert;    PtrToVNode Next;};typedef struct GNode *Graph;struct GNode {    int NumOfVertices;    int NumOfEdges;    PtrToVNode *Array;};

Here void (*visit)(Vertex V) is a function parameter that is passed into StronglyConnectedComponents to handle (print with a certain format) each vertex that is visited. The function StronglyConnectedComponents is supposed to print a return after each component is found.

Sample program of judge:

#include <stdio.h>#include <stdlib.h>#define MaxVertices 10  /* maximum number of vertices */typedef int Vertex;     /* vertices are numbered from 0 to MaxVertices-1 */typedef struct VNode *PtrToVNode;struct VNode {    Vertex Vert;    PtrToVNode Next;};typedef struct GNode *Graph;struct GNode {    int NumOfVertices;    int NumOfEdges;    PtrToVNode *Array;};Graph ReadG(); /* details omitted */void PrintV( Vertex V ){   printf("%d ", V);}void StronglyConnectedComponents( Graph G, void (*visit)(Vertex V) );int main(){    Graph G = ReadG();    StronglyConnectedComponents( G, PrintV );    return 0;}/* Your function will be put here */

Sample Input (for the graph shown in the figure):

4 50 11 22 03 13 2

Sample Output:

3 1 2 0

Note: The output order does not matter. That is, a solution like

0 1 2 3

is also considered correct.

int instack[100];int index;int DFN[100];int low[100];int stack[100];int top;void DFS(int u,Graph G,void (*visit)(Vertex V)){ DFN[u] = ++index; low[u] = DFN[u]; PtrToVNode temphead = G->Array[u]; stack[++top] = u; instack[u]=1; while(temphead){  int cur = temphead->Vert;  if(!DFN[cur]) {   DFS(cur,G,visit);   if(low[cur]<low[u]) low[u]=low[cur];  }  else{   if(instack[cur] && DFN[cur]<low[u])    low[u]=DFN[cur];  }  temphead = temphead -> Next; } if(DFN[u] == low[u]){  int temp;  do{   temp = stack[top--];   visit(temp);   instack[temp]=0;  }while(temp != u);  printf("\n"); }}StronglyConnectedComponents( Graph G,void (*visit)(Vertex V)){ int V = G->NumOfVertices; for(int i=0;i<V;i++) low[i]=0; for(int i=0;i<V;i++){  if(!DFN[i]) DFS(i,G,visit); }}