Tarjan演算法講解的部落格網上找到三篇比較好的,現在都轉載了,個人只研究了第一篇,正如博主所說,講的標比較詳細,清晰,剩下兩篇也可以看一下.

卿學姐視訊講解 https://www.bilibili.com/video/av7330663/

以下內容轉自:http://www.cnblogs.com/uncle-lu/p/5876729.html

全網最詳細tarjan演算法講解，我不敢說別的。反正其他tarjan演算法講解，我看了半天才看懂。我寫的這個，讀完一遍，發現原來tarjan這麼簡單！

tarjan演算法，一個關於 圖的聯通性的神奇演算法。基於DFS（迪法師）演算法，深度優先搜尋一張有向圖。！注意！是有向圖。根據樹，堆疊，打標記等種種神（che）奇（dan）方法來完成剖析一個圖的工作。而圖的聯通性，就是任督二脈通不通。。的問題。
瞭解tarjan演算法之前你需要知道：
強連通，強連通圖，強連通分量，解答樹（解答樹只是一種形式。瞭解即可）
不知道怎麼辦！！！

神奇海螺～：嘟嚕嚕～！
強連通(strongly connected)： 在一個有向圖G裡，設兩個點 a b 發現，由a有一條路可以走到b，由b又有一條路可以走到a，我們就叫這兩個頂點（a，b）強連通。

強連通圖： 如果 在一個有向圖G中，每兩個點都強連通，我們就叫這個圖，強連通圖。

強連通分量strongly connected components)：在一個有向圖G中，有一個子圖，這個子圖每2個點都滿足強連通，我們就叫這個子圖叫做 強連通分量 ［分量：：把一個向量分解成幾個方向的向量的和，那些方向上的向量就叫做該向量（未分解前的向量）的分量］
舉個簡單的栗子：

比如說這個圖，在這個圖中呢，點1與點2互相都有路徑到達對方，所以它們強連通.

而在這個有向圖中，點1 2 3組成的這個子圖，是整個有向圖中的強連通分量。

解答樹：就是一個可以來表達出遞迴列舉的方式的樹（圖），其實也可以說是遞迴圖。。反正都是一個作用，一個展示從“什麼都沒有做”開始到“所有結求出來”逐步完成的過程。“過程！”

神奇海螺結束！！！

 

tarjan演算法，之所以用DFS就是因為它將每一個強連通分量作為搜尋樹上的一個子樹。而這個圖，就是一個完整的搜尋樹。
為了使這顆搜尋樹在遇到強連通分量的節點的時候能順利進行。每個點都有兩個引數。
1，DFN［］作為這個點搜尋的次序編號（時間戳），簡單來說就是 第幾個被搜尋到的。％每個點的時間戳都不一樣％。
2，LOW［］作為每個點在這顆樹中的，最小的子樹的根，每次保證最小，like它的父親結點的時間戳這種感覺。如果它自己的LOW［］最小，那這個點就應該從新分配，變成這個強連通分量子樹的根節點。
ps：每次找到一個新點，這個點LOW［］＝DFN［］。

而為了儲存整個強連通分量，這裡挑選的容器是，堆疊。每次一個新節點出現，就進站，如果這個點有 出度 就繼續往下找。直到找到底，每次返回上來都看一看子節點與這個節點的LOW值，誰小就取誰，保證最小的子樹根。如果找到DFN［］＝＝LOW［］就說明這個節點是這個強連通分量的根節點（畢竟這個LOW［］值是這個強連通分量裡最小的。）最後找到強連通分量的節點後，就將這個棧裡，比此節點後進來的節點全部出棧，它們就組成一個全新的強連通分量。

先來一段虛擬碼壓壓驚：

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) // 如果節點u還在棧內
　　　　　　　　Low[u] = min(Low[u], DFN[v])
　　if (DFN[u] == Low[u]) // 如果節點u是強連通分量的根
　　repeat v = S.pop  // 將v退棧，為該強連通分量中一個頂點
　　print v
　　until (u== v)
}

首先來一張有向圖。網上到處都是這個圖。我們就一點一點來模擬整個演算法。

從1進入 DFN［1］＝LOW［1］＝ ＋＋index －－－－1
入棧 1
由1進入2 DFN［2］＝LOW［2］＝ ＋＋index －－－－2
入棧 1 2
之後由2進入3 DFN［3］＝LOW［3］＝ ＋＋index －－－－3
入棧 1 2 3
之後由3進入 6 DFN［6］＝LOW［6］＝＋＋index －－－－4
入棧 1 2 3 6

之後發現 嗯？ 6無出度，之後判斷 DFN［6］＝＝LOW［6］
說明6是個強連通分量的根節點：6及6以後的點 出棧。
棧： 1 2 3 
之後退回 節點3 Low[3] = min(Low[3], Low[6]) LOW［3］還是 3
節點3 也沒有再能延伸的邊了，判斷 DFN［3］＝＝LOW［3］
說明3是個強連通分量的根節點：3及3以後的點 出棧。
棧： 1 2 
之後退回 節點2 嗯？！往下到節點5
DFN［5］＝LOW［5］＝ ＋＋index －－－－－5
入棧 1 2 5

ps：你會發現在有向圖旁邊的那個醜的（劃掉）搜尋樹 用紅線剪掉的子樹，那個就是強連通分量子樹。每次找到一個。直接。一剪子下去。半個子樹就沒有了。。

結點5 往下找，發現節點6 DFN［6］有值，被訪問過。就不管它。
繼續 5往下找，找到了節點1 他爸爸的爸爸。。DFN［1］被訪問過並且還在棧中，說明1還在這個強連通分量中，值得發現。 Low[5] = min(Low[5], DFN[1]) 
確定關係，在這棵強連通分量樹中，5節點要比1節點出現的晚。所以5是1的子節點。so
LOW［5］＝ 1

由5繼續回到2 Low[2] = min(Low[2], Low[5])
LOW［2］＝1；
由2繼續回到1 判斷 Low[1] = min(Low[1], Low[2]) 
LOW［1］還是 1
1還有邊沒有走過。發現節點4，訪問節點4
DFN［4］＝LOW［4］＝＋＋index －－－－6
入棧 1 2 5 4 
由節點4，走到5，發現5被訪問過了，5還在棧裡，
Low[4] = min(Low[4], DFN[5]) LOW［4］＝5
說明4是5的一個子節點。

由4回到1.

回到1，判斷 Low[1] = min(Low[1], Low[4])
LOW［1］還是 1 。

判斷 LOW［1］ ＝＝ DFN［1］ 
誒？！相等了    說明以1為根節點的強連通分量已經找完了。
將棧中1以及1之後進棧的所有點，都出棧。
棧 ：（鬼都沒有了）

這個時候就完了嗎？！

你以為就完了嗎？！

然而並沒有完，萬一你只走了一遍tarjan整個圖沒有找完怎麼辦呢？！

所以。tarjan的呼叫最好在迴圈裡解決。

like    如果這個點沒有被訪問過，那麼就從這個點開始tarjan一遍。

因為這樣好讓每個點都被訪問到。

來一道裸程式碼。
輸入：
一個圖有向圖。
輸出：
它每個強連通分量。

這個圖就是剛才講的那個圖。一模一樣。

input:
6 8
1 3
1 2
2 4
3 4
3 5
4 6
4 1
5 6

output:
6
5
3 4 2 1

#include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
struct node {
    int v,next;
}edge[1001];
int DFN[1001],LOW[1001];
int stack[1001],heads[1001],visit[1001],cnt,tot,index;
void add(int x,int y)
{
    edge[++cnt].next=heads[x];
    edge[cnt].v = y;
    heads[x]=cnt;
    return ;
}
void tarjan(int x)//代表第幾個點在處理。遞迴的是點。
{
    DFN[x]=LOW[x]=++tot;// 新進點的初始化。
    stack[++index]=x;//進站
    visit[x]=1;//表示在棧裡
    for(int i=heads[x];i!=-1;i=edge[i].next)
    {
        if(!DFN[edge[i].v]) {//如果沒訪問過
            tarjan(edge[i].v);//往下進行延伸，開始遞迴
            LOW[x]=min(LOW[x],LOW[edge[i].v]);//遞迴出來，比較誰是誰的兒子／父親，就是樹的對應關係，涉及到強連通分量子樹最小根的事情。
        }
        else if(visit[edge[i].v ]){  //如果訪問過，並且還在棧裡。
            LOW[x]=min(LOW[x],DFN[edge[i].v]);//比較誰是誰的兒子／父親。就是連結對應關係
        }
    }
    if(LOW[x]==DFN[x]) //發現是整個強連通分量子樹裡的最小根。
    {
        do{
            printf("%d ",stack[index]);
            visit[stack[index]]=0;
            index--;
        }while(x!=stack[index+1]);//出棧，並且輸出。
        printf("\n");
    }
    return ;
}
int main()
{
    memset(heads,-1,sizeof(heads));
    int n,m;
    scanf("%d%d",&n,&m);
    int x,y;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    for(int i=1;i<=n;i++)
         if(!DFN[i])  tarjan(1);//當這個點沒有訪問過，就從此點開始。防止圖沒走完
    return 0;
}

以下內容轉自:http://blog.csdn.net/jeryjeryjery/article/details/52829142

在有向圖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++實現程式碼如下，可以配合上面的圖加以理解：

#include<iostream>
using namespace std;
int DFN[105];                                  //記錄在做dfs時節點的搜尋次序
int low[105];                                  //記錄節點能夠找到的最先訪問的祖先的記號
int count=1;                                   //標記訪問次序，時間戳
int stack[105];                                //壓入棧中
int top=-1;
int flag[105];                                 //標記節點是否已經在棧中
int number=0;
int j;
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}};
int length;                                    //圖的長度
void tarjan(int u){
    DFN[u]=low[u]=count++;                     //初始化兩個值，自己為能找到的最先訪問的祖先
    stack[++top]=u;
    flag[u]=1;                                 //標記為已經在棧中

    for(int v=0;v<length;v++){
	if(matrix[u][v]){
	    if(!DFN[v]){                       //如果點i沒有被訪問過
		tarjan(v);                     //遞迴訪問
		if(low[v]<low[u])
		    low[u]=low[v];             //更新能找的到祖先
	    }
	    else{                              //如果訪問過了，並且該點的DFN更小，則
		if(DFN[v]<low[u]&&flag[v])     //flag[v]這個判斷條件很重要，這樣可以避免已經確定在其他聯通圖的v,因為u到v的單向邊而影響到u的low
		low[u]=DFN[v];                 //也就是已經確定了的聯通圖要剔除掉，剔除的辦法就是判斷其還在棧中，因為已經確定了的連通圖的點
	    }                                  //flag在下面的do while中已經設為0了(即已經從棧中剔除了)
	}
    }

    //往後回溯的時候，如果發現DFN和low相同的節點，就可以把這個節點之後的節點全部彈棧，構成連通圖
    if(DFN[u]==low[u]){
	number++;                               //記錄連通圖的數量
	do{
	    j=stack[top--];                     //依次取出，直到u
	    cout<<j<<" ";
	    flag[j]=0;                          //設定為不在棧中
	}while(j!=u);
	    cout<<endl;
    }
}
int main(){
	
    memset(DFN,0,sizeof(DFN));                  //資料的初始化
    memset(low,0,sizeof(low));
    memset(flag,0,sizeof(flag));
	
    length=6;
    tarjan(0);

    cout<<endl;
    for(int i=0;i<6;i++){
	cout<<"DFN["<<i<<"]:"<<DFN[i]<<" low["<<i<<"]:"<<low[i]<<endl;
    }
    return 0;
}

以下內用轉自:http://blog.csdn.net/wsniyufang/article/details/6604458

[有向圖強連通分量]

在有向圖G中，如果兩個頂點間至少存在一條路徑，稱兩個頂點強連通(stronglyconnected)。如果有向圖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)為指向棧中節點的後向邊(非橫叉邊)}

當DFN(u)=Low(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)            // 如果節點u還在棧內
            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已經出棧，不再訪問6，返回3，(3,4)為樹枝邊，所以LOW[3]=LOW[4]=1。

繼續回到節點1，最後訪問節點2。訪問邊(2,4)，4還在棧中，所以LOW[2]=4。返回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表示崇高的敬意。

程式碼:

void tarjan(int i)
{
    int j;
    DFN[i]=LOW[i]=++Dindex;
    instack[i]=true;
    Stap[++Stop]=i;
    for (edge *e=V[i]; e; e=e->next)
    {
        j=e->t;
        if (!DFN[j])
        {
            tarjan(j);
            if (LOW[j]<LOW[i])
                LOW[i]=LOW[j];
        }
        else if (instack[j] && DFN[j]<LOW[i])
            LOW[i]=DFN[j];
    }
    if (DFN[i]==LOW[i])
    {
        Bcnt++;
        do
        {
            j=Stap[Stop--];
            instack[j]=false;
            Belong[j]=Bcnt;
        }
        while (j!=i);
    }
}
void solve()
{
    int i;
    Stop=Bcnt=Dindex=0;
    memset(DFN,0,sizeof(DFN));
    for (i=1; i<=N; i++)
        if (!DFN[i])
            tarjan(i);
}