Tarjan求有向圖強連通詳解

Tarjan求有向圖強連通詳解

注*該文章為轉發，原文出處已經不得而知

全網最!詳!細!tarjan算法講解。

 

全網最詳細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://www.cnblogs.com/uncle-lu/p/5876729.html

 

 

但是看完這個感覺還是有一點點雲里霧里的，就是low[]數組的內涵，感覺還是有一些模糊，於是又多看了幾篇其他文章，結合了具體實例才更加清晰。

 

下面這篇也是講的相當不錯的

↓

↓

【圖論】求無向連通圖的割點

 

1. 割點與連通度

在無向連通圖中，刪除一個頂點v及其相連的邊后，原圖從一個連通分量變成了兩個或多個連通分量，則稱頂點v為割點，同時也稱關節點(Articulation Point)。一個沒有關節點的連通圖稱為重連通圖(biconnected graph)。若在連通圖上至少刪去k 個頂點才能破壞圖的連通性，則稱此圖的連通度為k。

關節點和重連通圖在實際中較多應用。顯然，一個表示通信網絡的圖的連通度越高，其系統越可靠，無論是哪一個站點出現故障或遭到外界破壞，都不影響系統的正常工作；又如，一個航空網若是重連通的，則當某條航線因天氣等某種原因關閉時，旅客仍可從別的航線繞道而行；再如，若將大規模的集成電路的關鍵線路設計成重連通的話，則在某些元件失效的情況下，整個片子的功能不受影響，反之，在戰爭中，若要摧毀敵方的運輸線，僅需破壞其運輸網中的關節點即可。

簡單的例子

(a)中G7 是連通圖，但不是重連通圖。圖中有三個關節點A、B 和G 。若刪去頂點B 以及所有依附頂點B 的邊，G7 就被分割成三個連通分量{A、C、F、L、M、J}、{G、H、I、K}和{D、E}。類似地，若刪去頂點A 或G 以及所依附於它們的邊，則G7 被分割成兩個連通分量。

 

2. 求割點的方法

暴力的方法：

• 依次刪除每一個節點v
• 用DFS（或BFS）判斷還是否連通
• 再把節點v加入圖中

若用鄰接表（adjacency list），需要做VV次DFS，時間復雜度為O(V∗(V+E))O(V∗(V+E))。（題外話：我在面試實習的時候，只想到暴力方法；面試官提示只要一次DFS就就可以找到割點，當時死活都沒想出來）。

有關DFS搜索樹的概念

在介紹算法之前，先介紹幾個基本概念

• DFS搜索樹：用DFS對圖進行遍歷時，按照遍歷次序的不同，我們可以得到一棵DFS搜索樹，如圖(b)所示。
• 樹邊：（在[2]中稱為父子邊），在搜索樹中的實線所示，可理解為在DFS過程中訪問未訪問節點時所經過的邊。
• 回邊：（在[2]中稱為返祖邊、后向邊），在搜索樹中的虛線所示，可理解為在DFS過程中遇到已訪問節點時所經過的邊。

基於DFS的算法

該算法是R.Tarjan發明的。觀察DFS搜索樹，我們可以發現有兩類節點可以成為割點：

1. 對根節點u，若其有兩棵或兩棵以上的子樹，則該根結點u為割點；
2. 對非葉子節點u（非根節點），若其子樹的節點均沒有指向u的祖先節點的回邊，說明刪除u之后，根結點與u的子樹的節點不再連通；則節點u為割點。

對於根結點，顯然很好處理；但是對於非葉子節點，怎么去判斷有沒有回邊是一個值得深思的問題。

我們用dfn[u]記錄節點u在DFS過程中被遍歷到的次序號，low[u]記錄節點u或u的子樹通過非父子邊追溯到最早的祖先節點（即DFS次序號最小），那么low[u]的計算過程如下：

 

low[u]={min{low[u], low[v]}min{low[u], dfn[v]}(u,v)為樹邊(u,v)為回邊且v不為u的父親節點low[u]={min{low[u], low[v]}(u,v)為樹邊min{low[u], dfn[v]}(u,v)為回邊且v不為u的父親節點

 

下表給出圖(a)對應的dfn與low數組值。

i	0	1	2	3	4	5	6	7	8	9	10	11	12
vertex	A	B	C	D	E	F	G	H	I	J	K	L	M
dfn[i]	1	5	12	10	11	13	8	6	9	4	7	2	3
low[i]	1	1	1	5	5	1	5	5	8	2	5	1	1

對於情況2，當(u,v)為樹邊且low[v] >= dfn[u]時，節點u才為割點。該式子的含義：以節點v為根的子樹所能追溯到最早的祖先節點要么為v要么為u。

代碼實現

void dfs(int u) {
    //記錄dfs遍歷次序
    static int counter = 0; 
    
    //記錄節點u的子樹數
    int children = 0;
    
    ArcNode *p = graph[u].firstArc;
    visit[u] = 1;

    //初始化dfn與low
    dfn[u] = low[u] = ++counter;

    for(; p != NULL; p = p->next) {
        int v = p->adjvex;
        
        //節點v未被訪問，則(u,v)為樹邊
        if(!visit[v]) {
            children++;
            parent[v] = u;
            dfs(v);
            low[u] = min(low[u], low[v]);
            //case (1)
            if(parent[u] == NIL && children > 1) {
                printf("articulation point: %d\n", u);
            }
            //case (2)
            if(parent[u] != NIL && low[v] >= dfn[u]) {
                printf("articulation point: %d\n", u);
            }
        }

        //節點v已訪問，則(u,v)為回邊
        else if(v != parent[u]) {
            low[u] = min(low[u], dfn[v]);
        }
    }
}

采用鄰接表存儲圖，該算法的時間復雜度應與DFS相同，為O(V+E)O(V+E)。

3. 參考資料

[1] see xidian, 圖的連通性—關節點和重連通分量.
[2] byvoid, 圖的割點、橋與雙連通分支.
[3] GeeksforGeeks, Articulation Points (or Cut Vertices) in a Graph.


如需轉載，請注明作者及出處.

作者： Treant

出處： http://www.cnblogs.com/en-heng/

 

分類:  算法

來源：  http://www.cnblogs.com/en-heng/p/4002658.html

 

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">