DFS Tree

由一個點做 DFS 之後構成的樹
根據邊的在遍歷的過程中連接狀態有不同性質

DFS Tree

定義 $P(v)$ 表示點 $v$ 在 DFS Tree 的父節點

而 $P(\text{root})$ 是空節點

DFS Tree

Tree edge : DFS 過程中行走的邊

(下一個點是沒走過的)

void dfs(int v, int fa) {
    used[v] = true;
    
    for (auto u:V[v]) {
    	if (!used[u]) {
    	    dfs(u, v); // tree edge (v->u)
        }
    }
}

DFS Tree

Back edge : 接觸到目前祖先的邊

(因此這條邊與 Tree edge 會形成環)

Root

DFS Tree

如果 $G$ 是連通無向圖，則

$G$ 的 DFS Tree 只由下兩種邊構成

Tree edge
Back edge

Root

DFS Tree

$p$

Proof.

$v$ 是 $p$ 的子節點

設 $p$ 有一條邊走到了 $a$，而 $a$ 已被標記已走過，而且 $a$ 不是 $v$ 的祖先

根據 DFS 的演算法，表示 $a$ 為根的子樹已經被遍歷

考慮點 $v$

因為有路徑 $a\to v$，故 $v$ 也被遍歷了

故 $v$ 不再參與走訪

因此透過 $v$ 走訪 $a$ ，與目前狀態矛盾

$a$

$v$

DFS Tree

Root

Forward edge : 會到目前點先繼點的邊

(這條邊會到目前點的更深處)

Forward edge

DFS Tree

Root

Cross edge : 會到目前點無相關子樹的邊

(這條邊必不與 Tree edge 產生迴圈)

Cross edge

DFS Tree

圖論題目絕大多數演算法都跟 DFS / BFS 有關
而 DFS Tree 是一種有條理整理 case 的方法
將行走的邊分類，思考對應的決策

無向圖	有向圖
Tree edge	Tree edge
Back edge	Back edge
	Cross edge
	Forward edge

Forward edge (實作限制)

Connected Component

連通分量

設集合 $C$ 為無向圖 $G$ 的一個連通分量

若點 $x,y\in G$

$x,y \in C\Leftrightarrow x,y$ 之間有一條路徑

連通分量

鄰點：若存在邊 $e(v,w)$，則 $v$, $w$ 互為鄰點

因此 $v$ 的鄰居 $N(v)$ 是 $v$ 的邊可以到達的所有點集合。

路徑：若 $a,b$ 在同一個連通塊

$\operatorname{path}(a,b)$ 表示 a 到 b 的任意一種路徑。

連通分量

每一個點都位在一個連通分量
若有路徑 $\operatorname{path}(x,y)$，就有 $\operatorname{path}(y,x)$
若存在 $\operatorname{path}(x,y),\operatorname{path}(y,z)$，就存在 $\operatorname{path}(x,z)$

~~看起來就像disjoint set~~

連通分量

連通分量測試

定義函數 $C(g)$ 表示圖 $g$ 的連通分量數量，給定一張無向圖 $G$

求$C(G)=?$

DFS

根據連通分量的特性，DFS 任意一個點會走遍該點的連通分量

因此就看用了幾次 DFS 就能知道答案

AP & Bridge

關節點與橋

Articulation Points

有一張無向連通圖$G$

若點 $v$ 是關節點 (AP) $\Leftrightarrow$ $G$ 刪除 $v$ 後，$C(G)>1$

Bridge

有一張無向連通圖

若邊 $e$ 是橋 $\Leftrightarrow$ 從 $G$ 刪除 $e$ 後，$C(G)>1$

關節點與橋

給一張無向圖，請找出圖裡面所有的關節點 (與橋)。

DFS 爆搜

枚舉所有的點當關節點，模擬刪掉後，是否依然能遍歷所有的節點

橋亦同

DFS：$O(E+V)$

總複雜度：$O((E+V)^2)$

Tarjan's algo for AP

圖論大師 Tarjan 在1973年提出了在 $O(n)$ 時間找出AP的演算法

實際上同方法也可以用來找 Bridge

note. $O(n)$ 在圖論表示 $O(E+V)$

定義 $T$ 是 $G$ 的 DFS Tree

對於點 $v \in G$，定義函數如下

Depth $D(v)$：表示點 $v$ 在 $T$ 的深度

$$D=1$$

$$D=2$$

$$D=3$$

$$D=4$$

定義 $T$ 是 $G$ 的 DFS 搜索樹

對於點 $v \in G$，定義函數如下

Lowpoint $L(v)$ :
在不通過往 parent 的 tree edge 路徑上，

自己、

所有能透過 tree edge 走到的點，

以及前述所有點透過 back edge 連接的點中，

$D(x)$ 的最小值

parent

X

Quick Hint : 只有 "自己"、或 "Back edge" 連接點會是 L(x) 的答案

Low point

✔

自己

子樹

子樹的臨點

(紅色勾勾的鄰居)

$L(x)$ 是打勾部分 $D(x)$ 的最小值

✔

臨點

X

$D(x)$ 小 <--------------------------------> 大

Low point

可以利用子樹的答案來推出自己的 Lowpoint

a 是 v 的臨點，不包含 parent

b 是 v 子樹的根結點

$$L(v) = \min( D(v),D(a),L(b) )$$

Tarjan's algo for AP

定理1. 根節點 $r$ 是 AP $\Leftrightarrow \deg(r) > 1$

Proof

若移除 $r$ 會使原圖產生 $\deg(r)$ 個連通分量

根據AP的定義得證

DFS tree 中 根root 通常是特例 !!

Tarjan's algo for AP

定理2. $v$ 是非 root 的點，w 是 $v$ 的鄰點。

若 $v$ 是 AP $\Leftrightarrow \exists w :L(w)\geq D(v)$

$v$

$w$

$L(w)$

因為 w 無法走到比v 還要前面的點

移除 v 必然會至少分成 w 與 r 的兩個連通分量

$r$

Tarjan's algo for Bridge

定理3. $v$ 是非 root 的點，$w$ 是 $v$ 的鄰點。

若 $e(v,w)$ 是 Bridge $\Leftrightarrow \exists w :L(w) > D(v)$

$v$

$w$

$L(w)$

因為 w 無法走到比w 還要前面的點

移除 e 必然會至少分成 w 與 r 的兩個連通分量

$r$

$e(v,w)$

Tarjan's algo for AP

在 Tarjan 的原始論文中，D(x) 是定義為 DFS 遍歷順序的時間戳，也是較為常見的實作方法

實際上只需要保證 DFS 時每一條向下的通路 D(x) 遞增就行

Tarjan's algo for AP

void DFS(int v, int fa) //call DFS(v,v) at first
{
    D[v] = L[v] = timestamp++; //timestamp > 0
    int childCount = 0; //定理1 for root
    bool isAP = false;

    for (int w:adj[v])
    {
        if( w==fa ) continue;
        if ( !D[w] ) // D[w] = 0 if not visited
        {
            DFS(w,v);
            childCount++;
            if (D[v]<=L[w]) isAP = true; //定理2
            if (D[v]< L[w]) edgeBridge.emplace_back(v, w);//定理3
            L[v] = min(L[v], L[w]);
        }
        L[v] = min(L[v], D[w]);
    }
    if ( v == fa && childCount < 2 ) isAP = false; //定理1, v==fa只是確認root
    if ( isAP ) nodeAP.push_back(v);
    return ;
}

練習題

給圖找Cutting Point

UVa 315

有重邊版本 (注意Lowpoint定義)

hdu4612

Bridge &

Bridge-connected Component

橋與橋連通分量

橋連通分量

如果把一張圖所有的橋去除，我們稱這樣的區塊分割方法為橋連通分量

橋

橋連通分量

橋

橋連通分量

橋

橋連通分量的縮點

如果將一張圖同一個 BCC 所有點合併成一個點，會構成一棵樹

(顯然的，這樹上的每一條邊都是橋)

可以利用此性質將圖的問題轉換為樹的問題加以思考!

橋連通分量

要如何求橋連通分量 ?
方法1. 先求出橋，把橋砍掉，剩下的點再慢慢編號
方法2. 在 Tarjan 中順便做

橋連通分量

hint : 如果發現 $L[v] = D[v]$ ，表示發現了一個橋的端點
那顯然的這裡應該是橋連通分量的分界，這一個點只會與他的子樹形成橋連通分量

橋

$L[v]=D[v]$

橋連通分量

利用前序走訪把點放入 Stack ，就能知道自己的子樹有什麼點

void dfs (int v, int fa) {
    st.push(v);
    
    /* 繼續 dfs v 的子樹 */
    
    if (想看子樹有誰) {
    	int x;
        do {
            x = st.pop();  // 彈出子樹節點
        } while (x!=v);
    } 
}

橋連通分量

如果發現了一座橋，就把這個橋連接到的所有點砍掉
被砍掉的點會在同一個橋連通分量

橋

$D[v]=L[v]$

橋連通分量

如果發現了一座橋，就把這個橋連接到的所有點砍掉
被砍掉的點會在同一個橋連通分量

砍掉

stack 彈出來

橋連通分量

如果發現了一座橋，就把這個橋連接到的所有點砍掉
被砍掉的點會在同一個橋連通分量

橋

$D[v]=L[v]$

橋連通分量

如果發現了一座橋，就把這個橋連接到的所有點砍掉
被砍掉的點會在同一個橋連通分量

砍掉

stack 彈出來

橋連通分量

如果發現了一座橋，就把這個橋連接到的所有點砍掉
被砍掉的點會在同一個橋連通分量

橋

$D[v]=L[v]$

橋連通分量

如果發現了一座橋，就把這個橋連接到的所有點砍掉
被砍掉的點會在同一個橋連通分量

砍掉

stack 彈出來

橋連通分量

void DFS(int v, int fa) { //call DFS(v,v) at first
    D[v] = L[v] = timestamp++; //timestamp > 0
    st.emplace(v);

    for (int w:adj[v]) {
        if( w==fa ) continue;
        if ( !D[w] ) { // D[w] = 0 if not visited
            DFS(w,v);
            L[v] = min(L[v], L[w]);
        }
        L[v] = min(L[v], D[w]);
    }
    if (L[v]==D[v]) {
        bccid++;
        int x;
        do {
            x = st.top(); st.pop();
            bcc[x] = bccid;
        } while (x!=v);
    }
    return ;
}

剩下的部分與橋相同

橋連通分量

練習題

POJ 3177 = POJ 3352

給一個連通無向圖，問至少加入幾條邊使得無向圖中沒有橋

(點)雙連通分量

Biconnected Component (BCC)

BCC

如果一個連通分量沒有割點 (表示也沒有橋)
則該分量為雙連通分量

BCC

一個圖的雙連通分量分塊是將圖中同一個雙連通分量的點標記起來
與橋連通分量相似的地方是，雙連通分量以割點為分界
不一樣的地方是，相鄰的雙連通分量共用頂點 (割點)

割點

橋

割點

BCC

要如何求雙連通分量 ?
方法1. 先求出割點，把割點標記，從割點邊界 dfs 找出來
方法2. 在 Tarjan 中順便做

割點

橋

割點

BCC

方法與邊連通分量很像，但是收縮時不是把整個子樹砍掉，要留下自己 (割點)！
很明顯的，這方法最後會留下一個 root (多測資輸入小心)

割點

$L[u]\geq D[v]$

割點

BCC

stack<tuple<int,int>> st; // 以紀錄邊為主的堆疊 !!
void DFS(int v, int fa) { // call DFS(v,v) at first
    D[v] = L[v] = timestamp++; //timestamp > 0

    for (int w:adj[v]) {
        if( w==fa ) continue;
        if ( !D[w] ) { // D[w] = 0 if not visited
            st.emplace(v, w); // 堆疊上壓入的是邊 !
            DFS(w,v);
            L[v] = min(L[v], L[w]);
            if (L[w] >= D[v]) { // 找到割點!
                // 收縮
            }
        }
        L[v] = min(L[v], D[w]);
    }

    return ;
} // 用完我 stack 要記得清乾淨!!

stack<tuple<int,int>> st;
void DFS(int v, int fa) { //call DFS(v,v) at first
    D[v] = L[v] = timestamp++; //timestamp > 0

    for (int w:adj[v]) {
        if( w==fa ) continue;
        if ( !D[w] ) { // D[w] = 0 if not visited
            st.emplace(v, w);
            DFS(w,v);
            L[v] = min(L[v], L[w]);
            if (L[w] >= D[v]) { // 找到割點!
                int x, y;
                bcc.push_back({});
                do {
                    tie(x, y) = st.top(); st.pop();
                    bcc.back().emplace_back(y);
                } while (tie(x, y) != tie(v, w));
                bcc.back().emplace_back(v);
            }
        }
        L[v] = min(L[v], D[w]);
    }

    return ;
} // 用完我 stack 要記得清乾淨!!

BCC 的縮點

雙連通分量同樣也可以縮點變成一個 Tree
縮點時，把圖轉成 BCC 與割點的連接關係，產生的 Tree 稱之為 Block-cut tree

割點

橋

割點

BCC 的縮點

雙連通分量同樣也可以縮點變成一個 Tree
縮點時，把圖轉成 BCC 與割點的連接關係，產生的 Tree 稱之為 Block-cut tree

割點

Block Cut Tree 是區塊-割點交錯組成的

BCC

練習題

HDU 3749 Financial Crisis

問任兩個點之間有幾條互斥通路 (0/1/2+)

BCC

補充雙連通分量的一些性質

1. 雙連通分量如果是 2 - connnect 的，至少要三個點

特例!

BCC

補充雙連通分量的一些性質

2. 雙連通分量如果是 2 - connnect 的

表示任兩點間存在兩條互斥路徑 (環)

且

任兩邊可以找到一個環，包含該兩邊

BCC

補充雙連通分量的一些性質

3. 雙連通分量如果是 2 - connnect 的
如果該連通分量有一個奇環

雙連通分量的任一點都被至少一個奇環覆蓋

Strongly Connected Component

強連通分量

SCC定義

令 G 是有向圖，$v,w$ 是 G 上的兩點，$S$ 是 G 的一個 SCC，

$$v,w \in S \Leftrightarrow \exists \operatorname{path}(v,w),\operatorname{path}(w,v)$$

SCC 由數個有向環構成!

SCC與縮點

縮點操作

將同一個強連通分量內的所有節點合併為一個點，構成一張新圖。

SCC與縮點

定理4.設 $G'$ 是 $G$ 經由縮點操作生成的圖

$G'$ 是有向無環圖 (DAG)

SCC與縮點

Proof.

若 $G'$ 有環，那這一個環構成一個 SCC，根據縮點操作，這個環必須合併成一個點，故 $G'$ 不存在環

SCC

有兩個線性方法可以求 SCC

Tarjan's SCC Algorithm
Kosaraju's Algorithm

Tarjan's SCC Algorithm

圖論大師 Tarjan 在連通分量有許多著作，這也是其中一個

方法沿用了前一個演算法的 $L(x),D(x)$ 函數

Tarjan's SCC Algorithm

定理5. 若點 $v$ 有 $L(v)=D(v)$，$v$ 子樹所有未縮點的點構成 SCC

Tarjan's SCC Algorithm

定理5. 若點 $v$ 有 $L(v)=D(v)$，$v$ 子樹所有未縮點的點構成 SCC

小心再有向圖上算 Low point 時，會有 Cross edge !

Tarjan's SCC Algorithm

void DFS(int v, int fa) { //call DFS(v,v) at first
    D[v] = L[v] = timestamp++; //timestamp > 0
    st.push(v);
    inSt[v] = true;

    for (int w:adj[v]) {
        if ( !D[w] ) { // D[w] = 0 if not visited
            DFS(w,v);
            L[v] = min(L[v], L[w]);
        } else if (inSt[w]) { // it is different!
            L[v] = min(L[v], D[w]);
        }
    }
    if( D[v] == L[v] ) {
        int x;
        do {
            x = st.top();
            st.pop();
            scc[x] = SCCID;
            inSt[x] = false;
        } while( x != v );
        SCCID++;
    }
}

Kosaraju's Algorithm

兩次 DFS 的方法

用後序走訪走過整張圖放入 stack

由 stack 一個一個拿出來在反圖 DFS，走到的都是該點的 SCC

Kosaraju's Algorithm

void DFS(vector<int> *dG, int v, int k=-1){
    visited[v] = true;
    scc[v] = k;
    for (int w:dG[v])
        if (!visited[w])
            DFS(dG,w,k);
    if(dG==G) st.push(v);
}

int Kosaraju(int N){
    memset(visited,0,sizeof(visited));
    for(int i=0; i<N; ++i) if(!visited[i]) DFS(G,i);

    memset(visited,0,sizeof(visited));
    while(!st.empty()){
        if (!visited[st.top()]) DFS(GT, st.top(), sccID++);
        st.pop();
    }
    return sccID;
}

練習題

給定一些骨牌，且已知推倒每張骨牌會連動哪一些骨牌，問至少需推倒幾張骨牌才能使所有骨牌都倒下。

UVa 11504

https://codeforces.com/contest/1547/problem/G

CF #731 (Div. 3) G. How Many Paths?

CF #545 (Div. 1) C. Museums Tour

2-SAT

滿足性問題

SAT問題

以 AND 運算將許多 OR 運算式合併成的算式

$$(a \lor b \lor c )\land (c \lor \neg b \lor d )\land (e)=1?$$

如果在最多 OR 的子運算式中，最多只有 $K$ 個變數，
那麼我們稱這一個問題為 K-SAT 問題。

SAT問題

定理 7. 所有 SAT 問題都能轉換成 3-SAT 問題

定理 6. 所有 NPC 問題都能轉換成 SAT 問題

定理 8. 3-SAT 問題是 NPC 問題

2-SAT

如果 3-SAT 問題可以被進一步化簡為 2-SAT 問題

定理 9. 2-SAT 問題是 P 問題

Krom's Algorithm

可以在 $O(n)$ 的時間判定 2-SAT 問題

$$(a \lor b)\land (c \lor \neg b )\land (e)=1?$$

運用 SSC 的概念

依賴關係

考慮布林式 $a \lor b$，若要讓此式子為 true

若 a 選擇 false，b 一定要選 true

若 b 選擇 false，a 一定要選 true

依賴關係

將 2SAT 依賴關係表示成一張圖 $G_r$

有向邊 (A,B) 表示若選擇 A，就要選擇 B

$$B'$$

$$A'$$

$$A$$

$$B$$

$X'$表示X使用false的狀態

依賴關係

怎麼連 ?

( not a or b )

( a )

( not a )

( a xor b )

Krom's Algorithm

定理10. 若 2-SAT 問題無解，則存在 X 使

$X,X'$位在同一個 SCC

反之，可以構造一組可行的解

( 對於每一個變數選擇拓譜排序後順位較後者 )

X = true

X = false

練習題

hdu 3062

Tree

樹

定根

除了資料結構的二元樹之外，更多的狀況下會以圖的方式表示樹。
沒有根的樹不好討論，選一個點當作 $\text{root}$ 來轉成有根樹。

除了用 0 或 1 來當作根之外，還有沒有一些特別的點 ?

一個樹，至少存在一個重心 $c$
重心的 最大子樹大小 是最小的
- 所有子樹大小 $\leq n/2$

樹重心

最多可能有兩個重心

樹重心的特點

樹重心到所有點距離總和最短 (歸納法證明)
最大最大子樹大小 $\leq n/2$
- 每次遞迴資料量減半
- 因此遞迴處理資料只要 $O(\log n)$ 層就會結束
這個性質保證利用這個點分割複雜度通常不錯，因此有了樹分治的解題策略
若合併資料的複雜度不超過 $O(n)$，總複雜度通常為 $O(n\log n)$
若合併資料的複雜度不超過 $O(n\log n)$，總複雜度通常為 $O(n\log^2 n)$

@主定理


int sz[100001];
int center, csize; // csize = INT_MAX; for init
int _N; // ensure _N is how many node of the tree

void dfs(int v, int fa) {
    int maxsub = 0;
    sz[v] = 1;

    for (int u:E[v]) {
        if (u==fa) continue;
        dfs(u, v);
        maxsub = max(maxsub, sz[u]);
        sz[v] += sz[u];
    }
    maxsub = max(maxsub, _N-sz[v]);

    if (maxsub<csize) {
        center = v;
        csize = maxsub;
    }
}

_N-size[v]

v

注意 !

記得初始化
樹的總點數 _N 要小心，樹重心題目經常會嘗試把樹拆開或拼起來，很多時候都要重算！
sz 陣列可以視題目需要來決定是否使用，否則可以改成使用迴傳值

練習題

hdu6567 Cotree
- 類似 TOJ 256 (有點破梗)

給兩個樹，然後在這兩個樹中間加一條邊變成一棵樹 $T$

請找出怎麼加邊，會使樹 $T$ 的點距離總和最小

樹點距離總和

定義樹 $T$ 兩點 $u,v$ 的距離為 $d(u,v)$

樹距離總和 $S$ 為

$$S=\frac{1}{2}\sum\limits_{u,v\in T}d(u,v)$$

要怎麼計算這東西 ?

樹點距離總和

Hint : 計算每一條邊會被經過幾次

對於每一條邊 = 左邊有多少點 x 右邊有多少點

樹點距離總和

定義 $s_r(v)$ 為以 $r$ 為根時， $v$ 子樹的大小

樹距離總和 $S$ 有

$$S=\frac{1}{2}\sum\limits_{u,v\in T}d(u,v)=\sum\limits_{v \in T} s_r(v) \times (n-s_r(v))$$

long long ans = 0;
long long sol(int v, int fa) {
    long long sum = 1;
    for (int u:E[v])
        if (u!=fa)
            sum += sol(u, v);
    ans += sum * (N-sum);
    return sum;
}

回到題目

加一條邊連接兩樹，這一個新的樹距離總和怎麼算

總和 = 原來樹裡面的兩兩總和 + 跨過連接線的兩兩總和

$S$

$T$

(左邊所有點-S) - 連接線 - (T-右邊所有點)

每條新的配對新增

起點到 S 的距離 + $1$ + 終點到 T 的距離

$S$

$T$

$S$

$T$

總距離 = 左樹到S的總距離 x 右樹到T的總距離 + 左樹大小 x 右樹大小

重心到所有點距離總和最短 !

$S,T$ 是(在原來樹上的)重心時，答案最小 !

#include <bits/stdc++.h>
using namespace std;

int N;
vector<int> E[100001];

int count(int v, int fa) {
    int sum = 1;
    for(int u:E[v])
        if (u!=fa)
            sum += count(u, v);
    return sum;
}

int sz[100001];
int center, csize; // csize = INT_MAX; for init
// ensure _N is how many node of the tree
void dfs(int v, int fa, int _N) {
    int maxsub = 0;
    sz[v] = 1;

    for (int u:E[v]) {
        if (u==fa) continue;
        dfs(u, v, _N);
        maxsub = max(maxsub, sz[u]);
        sz[v] += sz[u];
    }
    maxsub = max(maxsub, _N-sz[v]);

    if (maxsub<csize) {
        center = v;
        csize = maxsub;
    }
}

long long ans = 0;
long long sol(int v, int fa) {
    long long sum = 1;
    for (int u:E[v])
        if (u!=fa)
            sum += sol(u, v);
    ans += sum * (N-sum);
    return sum;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    cin >> N;
    for(int i=0;i<N-2;++i) {
        int x, y;
        cin >> x >> y;
        E[x].emplace_back(y);
        E[y].emplace_back(x);
    }

    vector<int> centers;
    memset(sz, -1, sizeof(sz));
    for(int i=1;i<=N;++i) {
        if (sz[i] == -1) {
            csize = INT_MAX;
            dfs(i,i, count(i,i));
            centers.emplace_back(center);
        }
    }

    assert(centers.size() == 2);
    E[centers[0]].emplace_back(centers[1]);
    E[centers[1]].emplace_back(centers[0]);

    ans = 0;
    sol(1,1);
    cout << ans << '\n';
    return 0;
}

Centroid Decomposition

(樹)重心分解

圖很難畫，轉貼網路資料

A Simple Introduction to Centroid Decomposition | A Simple Blog (robert1003.github.io)

重心剖分（Centroid Decomposition）简介及例题 | 张慕晖的博客 (zhanghuimeng.github.io)

樹重心分解 - 將一個樹重新組裝 !

重心分解樹 $T_{CD}$ 定義如下

樹根是原來樹的重心
兒子是子樹的重心分解樹樹根

樹重心分解 - 性質 1

重心分解樹 $T_{CD}$ 樹高為 $O(\log n)$

樹重心分解 - 性質 2

重心分解樹 $T_{CD}$ 如果移除樹根

子樹的組成成員與原樹一樣

樹重心分解 - 性質 3

如果 $c$ 是 $a,b$ 在 $T_{CD}$ 的最近共同祖先 (LCA) ，則

在原樹上 $a$ 到 $b$ 必通過 $c$

CF 342E. Xenia and Tree

給一個藍色的樹，有兩個操作

```
update(a) 把 a 塗成紅色
```

query(a)  問離 a 最近的紅色點距離是多少

重心分解樹

解決 一對全 的樹問題
根據性質 3 ，一個點 $a$ 到任意點 $b$ 必經過
$c=\operatorname{lca}_{T_{CD}}(a,b)$

如果 $c$ 是 $a,b$ 在 $T_{CD}$ 的最近共同祖先 (LCA) ，則

在原樹上 $a$ 到 $b$ 必通過 $c$

我們可以把問題變成

$a$ 到 $c$ 再到 $c$ 子樹其他點

重心分解樹

把 $a$ 到所有點變成

$a$ 到 $c$ 再到 $c$ 子樹其他點

對於 $T_{CD}$ 上的每個點，紀錄他到到他子樹的答案是多少

對於每一個查詢枚舉中繼點 $c$ 組合答案

因為 $T_{CD}$ 的高度只有 $O(\log n)$

因此只需要檢查$O(\log n)$ 個中繼點 !

Try it !

別搞錯你現在再使用什麼樹 ! 是原來的，還是分解完的

Tree Diameter

樹直徑

直徑

圖的直徑，為圖上最長的最短距離

因為樹的最短距離唯一

因此樹的直徑就是最遠兩個點的距離

$\operatorname{diam}(G)=\max\limits_{u, v \in G} \operatorname{dist}(u, v)$

樹直徑演算法

如果邊長皆為正數：構造法 (兩次 DFS)
如果邊長沒有限制正負：動態規劃

構造法

定理

若樹邊權皆非負整數，

從任意點出發，所能到達的最遠點為直徑的某一端點。

證明 - 反證法

設出發點為 $x$，最遠點為 $r$，直徑端點是 $d, d'$
當中 $\operatorname{dist}(x,r)>\operatorname{dist}(x,d)\geq \operatorname{dist}(x,d')$

Case 1. x 交於 d-d' 連線

x

r

d

d'

很明顯的， $r$ 比 $d'$ 更適合當直徑端點

$\operatorname{dist}(d,d') < \operatorname{dist}(r,d') $

或

$\operatorname{dist}(d,d') < \operatorname{dist}(r,d) $

x

r

d

d'

Case 2-1. x,r 不交於 d-d' 連線

x

r

d

d'

$r$ 比 $d'$ 更適合當直徑端點

$\operatorname{dist}(d,d') < \operatorname{dist}(r,d') $

$\operatorname{dist}(x,d) < \operatorname{dist}(x,r) $
$\because$ 綠 > 紅 + 黃
$\therefore$ 綠 + 紅 > 黃

Case 2-2. x 不交於 d-d' 連線

x

r

d

d'

$r$ 比 $d'$ 更適合當直徑端點

$\operatorname{dist}(d,d') < \operatorname{dist}(r,d') $

$\operatorname{dist}(x,d) < \operatorname{dist}(x,r) $

$\because$ 綠 > 紅 + 黃
$\therefore$ 綠 + 紅 > 紅 + 黃

樹直徑構造法

根據定理，從任意點出法找最遠點即為直徑端點 $d$
再從找到的端點 $d$ 找最遠點，經過的路徑即為直徑。

int fv, fd;
void dfs(int v, int pa, int d) {
    if (d > fd) {
        fd = d;
        fv = v;
    }

    for (int u:V[v])
        if (u!=pa)
            dfs(u, v, d+1);
}

int diam() {
    fd = -1;
    dfs(0, 0, 0);
    fd = -1;
    dfs(fv, fv, 0);
    return fd;
}

動態規劃法

構造法的缺陷是邊長需為非負整數，否則證明是錯的
- 紅色線長度要大於 0
使用動態規劃可以直接求無限制條件下的解

設 $d[x]$ 表示以 $x$ 為根子樹的最深深度

$d[x] = \max\limits_{u \in \text{child of } x} 1 + d[u]$

動態規劃法

設 $d[x]$ 表示以 $x$ 為根子樹的最深深度

$d[x] = \max\limits_{u \in \text{child of } x} 1 + d[u]$

一個樹的直徑長就是枚舉 $x$ ，取最長深度 + 次長深度 (若存在) 的最大值

x

d

d'

int dp[100000][2]; // dp 維護前兩大的深度
void push(int *a, int v) { // 單純的插入排序
    if (v > a[1]) a[1] = v;
    if (a[1] > a[0]) swap(a[1], a[0]);
}

int ans;
void dfs(int v, int pa) {
    dp[v][0] = dp[v][1] = 0;

    for (int u:V[v]) {
        if (u == pa) continue;
        dfs(u, v);
        push(dp[v], 1 + dp[u][0]);
    }
    ans = max(ans, dp[v][0] + dp[v][1]);
}

int diam() {
    ans = 0;
    dfs(0, 0);
    return ans;
}

直徑的性質

以直徑中點為根的樹，樹高最小
- 以重心為根的樹，最大子樹最小
所有直徑共用中點
- 反證法
- 否則就可以透過新交點構造比直徑更長的路

一般而言，直徑常用於在樹上構造路徑

練習題

ZJ b967: 第 4 題血緣關係 (裸題)

練習題

URAL 1752 Tree 2

Tree 2 - URAL 1752 - Virtual Judge (vjudge.net)

給一個大小為 $n$ 的樹，有 $Q$ 次詢問

每次詢問點 $v$ ，輸出任意一個與 $v$ 距離為 $d$ 的點。

Hint : $v$ 能到的最遠點為樹直徑的端點

練習題

URAL 1752 Tree 2

Tree 2 - URAL 1752 - Virtual Judge (vjudge.net)

給一個大小為 $n$ 的樹，有 $Q$ 次詢問

每次詢問點 $v$ ，輸出任意一個與 $v$ 距離為 $d$ 的點。

Hint : $v$ 能到的最遠點為樹直徑的端點

答案比然出現在 $v$ 往樹直徑端點的路上，

因此求往樹直徑端點恰 $d$ 步的點是什麼就好

紅字作法於 LCA 篇章提到

練習題

Problem : 101 - 捷運路線

http://140.136.148.26/judge/problem/view/101

Zadanie Metro (met) - Problemset - SZKOpuł (szkopul.edu.pl)

Hint

圖 (樹) 上任兩最長路徑，必交一點 / 邊
- 反證法，否則就能構造更長的路徑

x

d

d'

y

d

d'

捷運路線 - 題解

很顯然的，$L=1$ 時，答案就是樹直徑。
透過前面性質，構造 $L=2$ 的答案，第二條線穿越直徑達案不會比較差
- 把直線拆解成兩段到達樹直徑的線段。
以次類推，把樹按深度剖分，選擇較長的鏈使用即可。

一般的樹鏈剖分是按子樹大小剖分

Lowest Common Ancestor

定根

給一個隨便的無根樹很麻煩，所以我們隨便挑一個點當作根

最近共同祖先 LCA

定義：在有根樹上，點 $x,y$ 往 root 的最短路徑上，第一個相遇的點

$\operatorname{lca}(x,y)$

$x$

$y$

樹上兩點間詢問

如果詢問的答案可以透過扣除來調整，可以考慮用 LCA

ex 兩點間最短路徑長

$$\operatorname{dist}(x,y) = \operatorname{dist}(r,x)+\operatorname{dist}(r,y)-2\times \operatorname{dist}(r,\operatorname{lca}(x,y))$$

倍增法

求一個點的$2^k$祖先是哪一點，使用DP來完成

定義dp[i][j]表示點i的第$2^j$個祖先節點是誰

$$dp[i][j]=\begin{cases}-1 & \text{not exist} \\ fa(i)&j=0\\dp[dp[i][j-1]][j-1]&dp[i][j-1]\neq -1\end{cases}$$

LCA DP

for (int i=0; i<lgN; ++i)
    for (int x=0; x<n; ++x)
    {
        if (P[x][i]==-1) P[x][i+1] = -1;
        else P[x][i+1] = P[P[x][i]][i];
    }

要先用 dfs 求 dp[i][0] 的答案

Jump

使用動態規劃，可以在 $O(\log |V|)$ 的時間求出 $v$ 的任意遠祖先

把移動距離二進位分解

再移動即可

int jump(int x,int d)
{
    for(int i=0;i<lgN;++i)
        if( (d>>i)&1 )
            x=dp[x][i];
    return x;
}

LCA

使用 DP 表格 + Jump 求 LCA

int find_lca(int a,int b){
    if(dep[a]>dep[b])
        swap(a,b);
    b=jump(b,dep[b]-dep[a]);
    if(a==b)
        return a;
}

Step 1. 調整深度

把a,b移動到相同深度的位置去

如果移動完a=b就完成

LCA

使用 DP 表格 + Jump 求 LCA

int find_lca(int a,int b){
    if(dep[a]>dep[b])
        swap(a,b);
    b=jump(b,dep[b]-dep[a]);
    if(a==b)
        return a;
    for(int i=MAX_LOG;i>=0;--i)
    {
        if(dp[a][i]!=dp[b][i])
        {
            a=dp[a][i];
            b=dp[b][i];
        }
    }
 
}

Step 2. 二分搜

k 由大到小跳 $2^k$ 步

如果是同樣的點，就不動，不然就跳上去

LCA

使用 DP 表格 + Jump 求 LCA

int find_lca(int a,int b){
    if(dep[a]>dep[b])
        swap(a,b);
    b=jump(b,dep[b]-dep[a]);
    if(a==b)
        return a;
    for(int i=MAX_LOG;i>=0;--i)
    {
        if(dp[a][i]!=dp[b][i])
        {
            a=dp[a][i];
            b=dp[b][i];
        }
    }
    return dp[a][0];
}

Step 3.完成

最後會停再 LCA 下方

丟回 dp 的答案即可

練習題

ZJ c495: 四、次小生成樹(SBMST)

一些定理 @

倍增法的優點

可以簡單的在樹上往 root 移動任意步
可以順便做 dp

樹上詢問

你得到了一棵 N 個節點的樹!! (頂點編號 1~N)

你選定了一個起點 S 跟一個終點 T，

現在你從 S 走到 T，請求出走第 K 步時走到的點。

( K=0 表示還待在 S )。

TIOJ 1687

Tarjan 的離線 LCA 演算法

$O(n+Q)$ 一次算完

預備工具：路徑壓縮的 disjoint set

Tarjan 的離線 LCA 演算法

把詢問放在節點上，在 DFS 的過程中，維護可能的 LCA 找出答案

int x, y, N, Q;
vector<tuple<int,int>> query[100]; // (另一點, 答案放置位置)
vector<int> V[100];
int ans[100];

cin >> N >> Q;
for (int i = 0; i < N; ++i) {
  cin >> x >> y;
  V[x].emplace_back(y);
  V[y].emplace_back(x);
}

for (int i = 0; i < Q; ++i) {
  cin >> x >> y;
  query[x].emplace_back(y, i);
  query[y].emplace_back(x, i);
}

Tarjan 的離線 LCA 演算法

如果 $r$ 是點 $a,b$ 的 lca，則此樹的中序走訪會依序走過 $a, r, b$
- 當然的 $a, b$ 順序未知，設 $a$ 先走

r

a

b

Tarjan 的離線 LCA 演算法

r

a

b

採用前序走訪 (進入就先標記該點)

Tarjan 的離線 LCA 演算法

r

a

b

採用前序走訪 (進入就先標記該點)

dfs 某一子樹 $a$，把該子樹合併到 $r$

Tarjan 的離線 LCA 演算法

r

a

b

採用前序走訪 (進入就先標記該點)

dfs 某一子樹 $a$，把該子樹合併到 $r$

如果要查詢的另一點沒被看過，就不做事

Tarjan 的離線 LCA 演算法

r

a

b

採用前序走訪 (進入就先標記該點)

dfs 某一子樹 $a$，把該子樹合併到 $r$

如果要查詢的另一點沒被看過，就不做事

dfs 某一子樹 $b$，把該子樹合併到 $r$

Tarjan 的離線 LCA 演算法

r

a

b

採用前序走訪 (進入就先標記該點)

dfs 某一子樹 $a$，把該子樹合併到 $r$

如果要查詢的另一點沒被看過，就不做事

dfs 某一子樹 $b$，把該子樹合併到 $r$

如果要查詢的另一點看過了，LCA 就是他的 disjoint set 的頭

void dfs(int v, int pa) {
    used[v] = true;

    for (int u : V[v]) {
        if (u == pa)
            continue;

        dfs(u, v);
        // 這裡的合併要保證 head 就是 lca
        head[find(u)] = v;
    }

    for (auto [u, i] : query[v])
        if (used[u])
            ans[i] = find(u);
}

r

a

b

void dfs(int v, int pa) {
    used[v] = true;

    for (int u : V[v]) {
        if (u == pa)
            continue;

        dfs(u, v);
        // 這裡的合併要保證 head 就是 lca
        head[find(u)] = v;
    }

    for (auto [u, i] : query[v])
        if (used[u])
            ans[i] = find(u);
}

int head[100]; // disjoint set

int find(int x) {
    if (head[x] == x)
        return x;
    return head[x] = find(head[x]);
}

這裡的 find 因合併較特殊

分析後是平攤 $O(1)$

整體複雜度 $O(n+Q)$

樹序列化

又稱作樹壓平
在進階資料結構中，有提到很多處理一維序列的方法
如果不知道Tree的問題怎麼解，是否有辦法把樹轉成一維序列？

歐拉走訪

沿著樹的邊緣走一圈
DFS進去與出來都看一次

走訪結果

$\{1,2,5,2,6,2,7,2,1,3,1,4,1\}$

重要性質

一個點進去與出來構成的區間，包含子樹的所有點

能把問題轉換成 RMQ 問題!

歐拉走訪

Lowest Common Ancestor

LCA與樹序列化

點	1	2	5	2	6	2	7	2	1
深度	0	1	2	1	2	1	2	1	0

LCA與樹序列化

點	1	2	5	2	6	2	7	2	1
深度	0	1	2	1	2	1	2	1	0

A與B的LCA是：

第一個A與最後一個B構成的區間中，深度最小的點

區間最小值

點	1	2	5	2	6	2	7	2	1
深度	0	1	2	1	2	1	2	1	0

觀察到剛剛的特性後，就能把LCA問題變成RMQ問題

不過有學過$O(n)$預處裡$O(1)$查詢的資料結構嗎？

Sparse Table

可以在$O(n\log n)$預處理，$O(1)$查詢的資料結構

st[x][y] = $a_x$到$a_{x+2^y-1}$的答案(共$2^y$個元素)

查詢任意範圍a~b，只要查詢

$$\min\begin{cases} st[a][c] \\ st[b-2^c][c]\end{cases} ,c=\lfloor\log_2(b-a+1)\rfloor$$

c=std::__lg(b-a+1);

騙我!

這方法沒有$O(n)$預處裡阿!
別急，還有其他方法

建表法

因為數列相鄰的數字只有$+1,-1$兩種可能
可以考慮數列的差分序列

點	1	2	5	2	6	2	7	2	1
深度	0	1	2	1	2	1	2	1	0
		+1	+1	-1	+1	-1	+1	-1	-1

建表法

對於一個差分序列還原出來的原始數列，最小值的位置是固定的！結果與原數列無關

若$a,b,c,d,e$的差分序列是

$<1,-1,-1,-1,>$

最小值一定是$e$

建表法

預先把所有可能的差分序列最小值的位置建表
因為差分序列只有兩種數字，可以用二進位表示

$O(n2^n)預處裡$

$O(1)查詢$

看起來超級爛?

分塊大法

如果把數列每$K$個資料切一塊，預先算出每一塊的最小值

$O(\frac{n}{K}+K)$找出最小值

$O(n)$預處裡

點	1	2	5	2	6	2	7	2	1
深度	0	1	2	1	2	1	2	1	0

0	1	1	1	0

分塊大法+Sparse Table

把大塊的資料做Sparse Table，就能在$O(1)$時間算大塊最小值

$O(1+K)$找出最小值

$O(\frac{K}{n}\log \frac{K}{n} +n)$預處裡

0	1	1	1	0

分塊大法+Sparse Table+建表法

把小塊的資料做建表法，就能在$O(1)$時間算小塊最小值

$O(1+1)$找出最小值

$O(\frac{K}{n}\log \frac{K}{n} + K2^K+ n)$預處裡

點	1	2	5	2	6	2	7	2	1
深度	0	1	2	1	2	1	2	1	0