Tarjan算法【閱讀筆記】

應用：線性時間內求出無向圖的割點與橋，雙連通分量。有向圖的強連通分量，必經點和必經邊。

主要是求兩個東西，dfn和low

時間戳dfn：就是dfs序，也就是每個節點在dfs遍歷的過程中第一次被訪問的時間順序。

追溯值low：$low[x]$定義為$min(dfn[subtree(x)中的節點], dfn[通過1條不再搜索樹上的邊能到達subtree(x)的節點]）$，其中$subtree(x)$是搜索樹中以$x$為根的節點。

其實這個值表示的就是這個點所在子樹的最先被訪問到的節點，作為這個子樹的根。

搜索樹：在無向連通圖中任選一個節點出發進行深度搜索遍歷，每個點只訪問一次，所有發生遞歸的邊$(x,y)$構成一棵樹，稱為無向連通圖的搜索樹。

 

low計算方法：

先令$low[x] = dfn[x]$， 考慮從$x$出發的每條邊$(x,y)$

若在搜索樹上$x$是$y$的父節點，令$low[x]=min(low[x], low[y])$

若無向邊$(x,y)$不是搜索樹上的邊，則令$low[x] = min(low[x], dfn[y])$

 

割邊判定法則：

無向邊$(x,y)$是橋，當且僅當搜索樹上存在$x$的一個子節點$y$，滿足：$dfn[x] < low[y]$

這說明從$subtree(y)$出發，在不經過$(x,y)$的前提下，不管走哪條邊都無法到達$x$或比$x$更早訪問的節點。若把$(x,y)$刪除，$subtree(y)$就形成了一個封閉的環境。

橋一定是搜索樹中的邊，並且一個簡單環中的邊一定不是橋。

void tarjan(int x, int in_edge)
{
    dfn[x] = low[x] = ++num;
    int flag = 0;
    for(int i = head[x]; i; i = Next[i]){
        int y = ver[i];
        if(!dfn[y]){
            tarjan(y);
            low[x] = min(low[x], low[y]);
            if(low[y] > dfn[x]){
                bridge[i] = bridge[i ^ 1] = true;
            }
        }
        else if(i != (in_edge ^ 1)) 
            low[x] = min(low[x], dfn[y]);
    }
}

int main()
{
    cin>>n>>m;
    tot = 1;
    for(int i = 1; i <= m; i++){
        int x, y;
        scanf("%d%d", &x, &y);
        if(x == y)continue;
        add(x, y);
        add(y, x);
    }
    for(int i = 1; i <= n; i++){
        if(!dfn[i]){
            tarjan(i, 0);
        }
    }
    for(int i = 2; i < tot; i += 2){
        if(bridge[i])
            printf("%d %d\n", ver[i ^ 1], ver[i]);
    }
}

 

割點判定法則：

若$x$不是搜索樹的根節點，則$x$是割點當且僅當搜索樹上存在$x$的一個子節點$y$，滿足：$dfn[x]\leq low[y]$

特別地，若$x$是搜索樹地根節點，則$x$是割點當且僅當搜索樹上存在至少兩個子節點$y_1,y_2$滿足上述條件。

#include<cstdio>
#include<cstdlib>
#include<map>
#include<set>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath> 
#include<stack>
#include<queue>
#include<iostream>

#define inf 0x7fffffff
using namespace std;
typedef long long LL;
typedef pair<int, int> pr;

const int SIZE = 100010;
int head[SIZE], ver[SIZE * 2], Next[SIZE * 2];
int dfn[SIZE], low[SIZE], n, m, tot, num;
bool bridge[SIZE * 2];

void add(int x, int y)
{
    ver[++tot] = y, Next[tot] = head[x], head[x] = tot;
}

void tarjan(int x)
{
    dfn[x] = low[x] = ++num;
    int flag = 0;
    for(int i = head[x]; i; i = Next[i]){
        int y = ver[i];
        if(!dfn[y]){
            tarjan(y);
            low[x] = min(low[x], low[y]);
            if(low[y] >= dfn[x]){
                flag++;
                if(x != root || flag > 1)cut[x] = true;
            }
        }
        else low[x] = min(low[x], dfn[y]);
    }
}

int main()
{
    cin>>n>>m;
    tot = 1;
    for(int i = 1; i <= m; i++){
        int x, y;
        scanf("%d%d", &x, &y);
        if(x == y)continue;
        add(x, y);
        add(y, x);
    }
    for(int i = 1; i <= n; i++){
        if(!dfn[i]){
            root = i;
            tarjan(i);
        }
    }
    for(int i = 1; i <= n; i++){
        if(cut[i])printf("%d", i);
    }
    puts("are cut-vertexes");
}

 

雙連通分量

若一張無向連通圖不存在割點，則稱它為“點雙連通圖”。若一張無向連通圖不存在橋，則稱他為“邊雙連通圖”。

無向圖的極大點雙連通子圖被稱為“點雙連通分量”，簡記為v-DCC。無向連通圖的極大邊雙連通子圖被稱為“邊雙連通分量”，簡記為e-DCC。

定理1一張無向連通圖是點雙連通圖，當且僅當滿足下列兩個條件之一：

1.圖的頂點數不超過2.

2.圖中任意兩點都同時包含在至少一個簡單環中。

定理2一張無向連通圖是邊雙連通圖，當且僅當任意一條邊都包含在至少一個簡單環中。

邊雙連通分量求法

求出無向圖中所有的橋，刪除橋后，每個連通塊就是一個邊雙連通分量。

用Tarjan標記所有的橋邊，然后對整個無向圖執行一次深度優先遍歷（不訪問橋邊），划分出每個連通塊。

int c[SIZE], dcc;

void dfs(int x){
    c[x] = dcc;
    for(int i = head[x]; i; i = Next[i]){
        int y = ver[i];
        if(c[y] || bridge[i])continue;
        dfs(y);
    }
}

//main()
for(int i = 1; i <= n; i++){
    if(!c[i]){
        ++dcc;
        dfs(i);
    }
}
printf("There are %d e-DCCs.\n", dcc);
for(int i = 1; i <= n; i++){
    printf("%d belongs to DCC %d.\n", i, c[i]);
}

e-DCC的縮點

把e-DCC收縮為一個節點，構成一個新的樹，存儲在另一個鄰接表中。

int hc[SIZE], vc[SIZE * 2], nc[SIZE * 2], tc;
void add_c(int x, int y){
    vc[++tc] = y;
    nc[tc] = hc[x];
    hc[x] = tc;
}

//main()
tc = 1;
for(int i = 2; i <= tot; i++){
    int x = ver[i ^ 1];
    y = ver[i];
    if(c[x] == c[y])continue;
    add_c(c[x], c[y]);
}
printf("縮點之后的森林， 點數%d, 邊數%d(可能有重邊)\n", dcc, tc / 2);
for(int i = 2; i < tc; i++){
    printf("%d %d\n", vc[i ^ 1], vc[i]);
}

點雙連通分量的求法

橋不屬於任何e-DCC，割點可能屬於多個v-DCC

在Tarjan算法過程中維護一個棧，按照如下方法維護棧中的元素：

1.當一個節點第一次被訪問時，該節點入棧。

2.當割點判定方法則中的條件$dfn[x]\leq low[y]$成立時，無論$x$是否為根，都要：

　　（1）從棧頂不斷彈出節點，直至節點$y$被彈出

　　（2）剛才彈出的所有節點與節點$x$一起構成一個v-DCC

void tarjan(int x){
    dfn[x] = low[x] = ++num;
    stack[++top] = x;
    iff(x == root && head[x] == 0){
        dcc[++cnt].push_back(x);
        return;
    }
    int flag = 0;
    for(int i = head[x]; i; i = Next[i]){
        int y = ver[i];
        if(!dfn[y]){
            tarjan(y);
            low[x] = min(low[x], low[y]);
            if(low[y] >= dfn[x]){
                flag++;
                if(x != root || flag > 1)cut[x] = true;
                cnt++;
                int z;
                do{
                    z = stack[top--];
                    dcc[cnt].push_back(z);

                }while(z != y);
                dcc[cnt].push_back(x);
            }
        }
        else low[x] = min(low[x], dfn[y]);
    }
}

//main()
for(int i = 1; i <= cnt; i++){
    printf("e-DCC #%d:", i);
    for(int j = 0; j < dcc[i].size(); j++){
        printf(" %d", dcc[i][j]);
    }
    puts("");
}

v-DCC的縮點

 設圖中共有$p$個割點和$t$個v-DCC，新圖將包含$p+t$個節點。

//main
num = cnt;
for(int i = 1; i <= n; i++){
    if(cnt[i])new_id[i] = ++num;
}
tc = 1;
for(int i = 1; i <= cnt; i++){
    for(int j = 0; j < dcc[i].size(); j++){
        int x = dcc[i][j];
        if(cut[x]){
            add_c(i, new_id[x]);
            add_c(new_id[x], i);
        }
        else c[x] = i;
    }
}
printf("縮點之后的森林， 點數%d, 邊數%d\n", num, tc / 2);
printf("編號1~%d的為原圖的v-DCC， 編號>%d的為原圖割點\n", cnt, cnt);
for(int i = 2; i < tc; i += 2){
    printf("%d %d\n", vc[i ^ 1], vc[i]);
}

 

有向圖的強連通分量

一張有向圖，若對於圖中任意兩個節點$x,y$，既存在$x$到$y$的路徑，也存在$y$到$x$的路徑，則稱該有向圖是強連通圖。

有向圖的極大強連通子圖被稱為強連通分量，簡記為SCC。

一個環一定是強連通圖，Tarjan算法的基本思路就是對每個點，盡量找到與它能構成環的所有節點。

Tarjan在深度優先遍歷的同時維護了一個棧，當訪問到節點$x$時，棧中需要保存一下兩類節點：

1.搜索樹上$x$的祖先節點，記為$anc(x)$

2.已經訪問過，並且存在一條路徑到達$anc(x)$的節點

實際上棧中的節點就是能與從$x$出發的“后向邊”和“橫叉邊”形成環的節點。

追溯值：

定義為滿足一下條件的節點的最小時間戳：

1.該點在棧中。

2.存在一條存subtree(x)出發的有向邊，以該點為終點。

計算步驟：

1.當節點$x$第一次被訪問時，把$x$入棧，初始化$low[x]=dfn[x]$

2.掃描從$x$出發的每條邊$(x,y)$

　　(1)若$y$沒被訪問過，則說明$(x,y)$是樹枝邊，遞歸訪問$y$,從$y$回溯后，令$low[x] = min(low[x], low[y])$

　　(2)若$y$被訪問過且$y$在棧中，令$low[x] = min(low[x], dfn[y])$

3.從$x$回溯之前，判斷是否有$low[x] = dfn[x]$。若成立，則不斷從棧中彈出節點直至$x$出棧。

強連通分量判定法則

追溯值計算過程中，若從$x$回溯前，有$low[x] = dfn[x]$成立，則棧中從$x$到棧頂的所有節點構成一個強連通分量。

如果$low[x]=dfn[x]$，說明$subtree(x)$中的節點不能與棧中其他節點一起構成環。另外，因為橫叉邊的終點時間戳必定小於起點時間戳，所以$subtree(x)$中的節點也不可能直接到達尚未訪問的節點（時間戳更大）

const int N = 100010, M = 1000010;
int ver[M], Next[M], head[N], dfn[N], low[N];
int stack[N], ins[N], c[N];
vector<int>scc[N];
int n, m, tot, num, top, cnt;

void add(int x, int y){
    ver[++tot] = y, Next[tot] = head[x], head[x] = tot;
}

void tarjan(int x){
    dfn[x] = low[x] = ++num;
    stack[++top] = x, ins[x] - 1;
    for(int i = head[x]; i; i = Next[i]){
        if(!dfn[ver[i]]){
            tarjan(ver[i]);
            low[x] = min(low[x], low[ver[i]]);
        }else if(ins[ver[i]]){
            low[x] = min(low[x], dfn[ver[i]]);
        }
    }
    if(dfn[x] == low[x]){
        cnt++;
        int y;
        do{
            y = stack[top--], ins[y] = 0;
            c[y] = cnt, scc[cnt].push_back(y);
        }while(x != y);
    }
}

int main(){
    cin>>n>>m;
    for(int i = 1; i <= m; i++){
        int x, y;
        scanf("%d%d", &x, &y);
        add(x, y);
    }
    for(int i = 1; i <= n; i++){
        if(!dfn[i])tarjan(i);
    }
}

縮點

void add_c(int x, int y){
    vc[++tc] = y, nc[tc] = hc[x], hc[x] = tc;
}

//main
for(int x = 1; x <= n; x++){
    for(int i = head[x]; i; i = Next[i]){
        int y = ver[i];
        if(c[x] == c[y])continue;
        add_c(c[x], c[y]);
    }
}

 

 

李煜東的《圖連通性若干擴展問題探討》，有點難。