Search, Tree & Graph

Arvin Liu

內容	快速連結	APCS範圍
前言	Link
Disjoint Set	Link	❓
搜尋法	Link	⭕
- 廣度優先搜尋法 Breadth First Search (BFS)	Link	⭕
- 深度優先搜尋法 Depth First Search (DFS)	Link	⭕
- BFS 變種 - Uniform Cost Search	Link	❌
- DFS 變種 - 回溯法 (Backtracking)	Link	⭕
樹論 (Tree)	Link	⭕
- 二元搜尋樹 Binary Search Tree (BST)	Link	❓
圖論 (Graph)	Link	⭕
- 單源最短路徑 Dijkstra's Algorithm	Link	❌
- 環檢測 (Cycle Detection) + 拓樸排序 Topological Sort	Link	⭕

內容	快速連結
Disjoint Set 介紹 -	Link
優化 1: 路徑壓縮 (Path compression)	Link
優化 2: 啟發式合併 (Union by rank)	Link
例題 - Accounts Merge (Leetcode 721)	Link
Disjoint Set 小結	Link

內容	快速連結
搜尋法初探	Link
廣度優先搜尋 (Breadth-first Search, BFS) - I - 二維平面	Link
廣度優先搜尋 (Breadth-first Search, BFS) - II - 二維平面	Link
深度優先搜尋 (Depth-first Search, DFS) - 二維平面	Link
搜尋法小結 & 堆疊溢出問題	Link
枚舉與搜尋法	Link
單人解謎 / 找唯一解 - 回溯法 (Backtracking)	Link
單人解謎 / 找最優解 - Uniform Cost Search (UCS)	Link
搜尋法小結	Link

內容	快速連結
樹 Tree	Link
樹的各種樹語	Link
樹的建構法	Link
樹的遍歷 (BFS / DFS)	Link
找尋樹的各種性質	Link
二元搜尋樹 Binary Search Tree	Link
樹的小結	Link

內容	快速連結
圖 (Graph)	Link
圖的各種術語	Link
圖的建構法	Link
圖的遍歷 (BFS / DFS)	Link
二分圖 (Bipartite) 的判別	Link
單源最短路徑	Link
Dijkstra's Algorithm - 二維版本	Link
Dijkstra's Algorithm - heap 版本	Link
拓樸排序	Link
Kahn's Algorithm (BFS)	Link
White-Gray-Black Cycle Detection (DFS)	Link
練習題：邏輯電路	Link
圖的小結	Link

Disjoint Set

or Union Find Tree, 併查集

or 簡稱 DSU (Disjoint Set Union)

誰	1	2	3	4	5
初始	1	2	3	4	5
1-2	1	1	3	4	5
2-5	1	1	3	4	2
3-4	1	1	3	3	2

誰	1	2	3	4	5
老大	1	2	3	4	5
1-2	1	1	3	4	5
2-5	1	1	3	4	1
3-4	1	1	3	3	1
2-4	1	1	1	3	1

Disjoint Set

給定關係圖，接著詢問任兩人有沒有關係。

 int boss[N];
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return find_boss(boss[x]);
}
int merge(int x, int y) {
  boss[find_boss(y)] = find_boss(x);
}

 boss = list(range(n))
def find_boss(x):
  if x == boss[x]:
    return x
  return find_boss(boss[x])
 
def merge(x, y):
  boss[find_boss(y)] = find_boss(x)

最差複雜度？

Q \times O(N) = O(QN)

Q \times O(N) = O(QN)

1

2

5

3

4

Disjoint Set 優化 - 1

路徑壓縮 Path Compression

給定關係圖，接著詢問任兩人有沒有關係。

 int boss[N];
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return boss[x] = find_boss(boss[x]);
}
int merge(int x, int y) {
  boss[find_boss(y)] = find_boss(x);
}

 boss = list(range(n))
def find_boss(x):
  if x == boss[x]:
    return x
  boss[x] = find_boss(boss[x])
  return boss[x]
 
def merge(x, y):
  boss[find_boss(y)] = find_boss(x)

啊？這樣就可以比較快喔？

不只快，他的最差複雜度是：

O(\log n)

O(\log n)

(均攤複雜度)

Disjoint Set - Path Compression

Disjoint Set - Link Priority

1

2

在我們合併的時候，

其實應該是有個「輩分」在的。

．

？

那我們應該要誰當老大呢？

體感上來說：感覺小併大好一點。

那麼怎樣叫小，怎樣叫大呢？

Union by size: 看小弟有幾個
Union by rank: 看小弟最深在哪

兩個實作完的複雜度都是

O(\log n)

O(\log n)

Rank = 2

Rank = 1

Inverse Ackermann Function

O(\alpha(N))

O(\alpha(N))

WTF is ?

首先我們要介紹阿克曼函數 A(m, n)：

A(m, n) = \begin{cases} n + 1 \text{\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,if m = 0}\\ A(m-1, 1) \text{\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,if m > 0 \& n = 0} \\ A(m-1, A(m, n-1)) \text{\,\,\,\,\,\,\,otherwise} \end{cases}

A(m, n) = \begin{cases} n + 1 \text{\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,if m = 0}\\ A(m-1, 1) \text{\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,if m > 0 \& n = 0} \\ A(m-1, A(m, n-1)) \text{\,\,\,\,\,\,\,otherwise} \end{cases}

數字膨脹

非常誇張的函數！

~~跟手遊戰力一樣~~

Inverse Ackermann Function

O(\alpha(N))

O(\alpha(N))

WTF is ?

如果 A(n, n) = K，那我們說 \\ 阿克曼反函數\, \alpha(K) = n

如果 A(n, n) = K，那我們說 \\ 阿克曼反函數\, \alpha(K) = n

阿克曼函數：成長超級快速

阿克曼反函數：成長超級緩慢

A(4, 4) = 2^{(2^{(2^{(2^{16})})})} =2^{(2^{(2^{65536})})}

A(4, 4) = 2^{(2^{(2^{(2^{16})})})} =2^{(2^{(2^{65536})})}

\alpha(2^{(2^{(2^{65536})})}) = 4

\alpha(2^{(2^{(2^{65536})})}) = 4

一般來說，我們可以假設這個數字 < 5

人名	持有信箱
John	johnsmith@mail.com, john_newyork@mail.com, john00@mail.com
John	johnnybravo@mail.com

人名	持有信箱
John	johnsmith@mail.com, john_newyork@mail.com
John	johnsmith@mail.com, john00@mail.com
John	johnnybravo@mail.com

題目名稱	來源	備註
感染風險		CB / C 班圖論 II - 5
真假子圖	Zerojudge g598	APCS 2021 / 4 類似猜拳問題但再難一點。
11987 - Almost Union-Find	Zerojudge f292	Hint: 別真的刪點。
... Make Network Connected	Leetcode 1319

題目名稱	來源	備註	CodingBar
傳送點	Zerojudge f166	APCS 2019/10 - 4	C 班圖論 2-2
開啟寶盒	Zerojudge k734	APCS 2023/6 - 4 其實比較像 Kahn	C 班圖論 2-1
搬家	Zerojudge m372	APCS 2023/10 - 3
靈犬尋寶	Zerojudge b059	95年學科競賽 - 4	C 班圖論 1-5
Numbers of Islands	Leetcode 200		C 班圖論 1-1
最少障礙物	Leetcode 2290		0/1 最短路
暴雨降臨			C 班圖論 3-1
星際旅行			C 班圖論 3-4
Find a safe walk through a grid	Leetcode 787	二維圖最短路，但不太一樣

Search in a Binary Search Tree (Leetcode 700)

給你一個 struct / class 建構出來的二元搜尋樹，
給你一個值，請回傳擁有這個值的節點。

7

4

9

1

6

二元搜尋樹的定義：

對於每個點，滿足下列條件：

子樹 L 所有點 \\ < x \\ < 子樹 R 所有點

子樹 L 所有點 \\ < x \\ < 子樹 R 所有點

如果這個點改8，那麼這就不是BST

x

l

r

怎麼找到題目要求的值？

(Binary Search Tree, BST)

Search in a Binary Search Tree (Leetcode 700)

給你一個 struct / class 建構出來的二元搜尋樹，
給你一個值，請回傳擁有這個值的節點。

7

4

9

1

6

二元搜尋樹的定義：

子樹 L 所有點 < x < 子樹 R 所有點

子樹 L 所有點 < x < 子樹 R 所有點

(Binary Search Tree, BST)

如果現在要搜尋 2 這個數字

可以通過跟現在的
root.val 比較，

知道 2 會在哪裡。

find 2

7

<7

>7

Base Case:

找到沒東西 (NULL / None)，
就是不存在

Validate Binary Search Tree (Leetcode 98)

給你一個 struct / class 建構出來的二元樹，
判斷其是否為二元搜尋樹 (Binary Search Tree)

7

4

9

1

6

先來個無腦定義

rec(root) = 判斷這棵樹是不是BST

好像不好下手，
仔細想想看每個點的限制
(考慮祖先們的限制就好，為什麼？)

7: (-\infty, \infty)

7: (-\infty, \infty)

對於每個點，都有其上下界。

只要都遵循，就是BST

4: (-\infty, 7)

4: (-\infty, 7)

1 : (-\infty, 4)

1 : (-\infty, 4)

6 : (4, 7)

6 : (4, 7)

9 : (7, \infty)

9 : (7, \infty)

把上下界加入遞迴參數內！

Validate Binary Search Tree (Leetcode 98)

給你一個 struct / class 建構出來的二元樹，
判斷其是否為二元搜尋樹 (Binary Search Tree)

7

4

9

1

6

7: (-\infty, \infty)

7: (-\infty, \infty)

4: (-\infty, 7)

4: (-\infty, 7)

1 : (-\infty, 4)

1 : (-\infty, 4)

6 : (4, 7)

6 : (4, 7)

9 : (7, \infty)

9 : (7, \infty)

rec(root, L, R) = 判斷是不是BST，
並限定之後的數字只能 > L 且 < R

祖先的數字
會限制他的子孫們

怎麼個限制？

左小孩的限制是右界
右小孩的限制是左界

遞迴的時候順便
檢查自己的數值就好了！

練習題!

給你一個二元搜尋樹，詢問 x 存不存在的時間複雜度為何？
如果有一種魔法，可以確保一棵二元搜尋樹是平衡的，那麼時間複雜度為何？

平衡的定義：
任一棵節點 x 的

|Height(x.l) - Height(x.r)| \le 1

|Height(x.l) - Height(x.r)| \le 1

Hint:

考量數量最少但平衡的樹 f(height) = size。
1. f(0) = 1, f(1) = 2, f(2) = 4
嘗試寫出遞迴式，你會發現它比某個東西還要大
想想看這個遞迴式的複雜度大概是多少
(可以用查的！)

練習題!

一個無向的圖，|V| = n，|E|最大多少？
一個無向的簡單圖，|V| = n，|E|最大多少？
- 這樣的圖稱為 團 / 完全圖 Clique，寫作
如果一個圖的所有邊可以不相交，我們稱為
平面圖 (Planar Graph)。
- 請問分別是平面圖嗎？

Vertex 的個數

Edge 的個數

K_n

K_n

K_3, K_4, K_5

K_3, K_4, K_5

這也是一個平面圖

A

B

C

D

A

B

C

D

因為它可以
變成這樣

練習題!

在有向圖 G 中，|V| = n，請問 |E| 至少要多少才可以使
1. G 為弱連通圖
2. G 為強連通圖
所有 V 的入度加總，以及所有 V 的出度加總這兩個數字誰大誰小？
子圖 (subgraph) 的意思是從原本的圖選
些邊跟點構成的一個小圖，就叫做子圖。
這張圖有幾種子圖？
給定一個星狀圖，問中心是誰？
Find Center of Star Graph (Leetcode 1791)

\sum_{v \in V} |v_{in}|

\sum_{v \in V} |v_{in}|

\sum_{v \in V} |v_{out}|

\sum_{v \in V} |v_{out}|

A

B

C

Is Graph Bipartite? (Leetcode 785)

給你一個 簡單圖 G，

請判斷 G 是不是個二分圖 (Bipartite)

什麼是二分圖？

顧名思義就是可以把圖二分的意思

A

B

C

D

E

F

完全二分圖

K_{3, 3}

K_{3, 3}

A

B

C

非二分圖的
最小例子

可以把點分成兩群，

每群之間沒有邊，

就叫做二分圖

A

B

C

D

(無向)

練習題!

如果你把點分成 A 群跟 B 群，並且將 A 群跟 B 群互相連線，這就叫做完全二分圖。
- 如果|A| = n，|B| = m，我們可以用
  表示。請問的
如果可以將點分成 K 個群體，每個群體彼此都沒有邊，就稱之為 K 分圖 (K-partite)。其中，K 代入 2 就是二分圖。
- 能夠用原本的方法判別三分圖嗎？
其實這題完全可以用 Disjoint Set 來完成，你會寫嗎？
想想看現實世界上有什麼例子是二分圖？

K_{n, m}

K_{n, m}

K_{n, m}

K_{n, m}

|E|=?

|E|=?

Network Delay Time (Leetcode 743)

給你一個 帶邊權簡單圖 G，邊權 = 擴散所需時間

從第 k 點擴散，需要多久才可以擴散所有點？

1

3

2

4

5

2

1

3

t=2

t=4

t=3

t=5

答案 = 5

我們要怎麼存帶邊權圖 ?

(也有帶點權圖)

Adjacency List

< u, v >

< u, v >

< u, v, w >

< u, v, w >

G[u].push_back(v)

G[u].push_back({v, w})

G[u].append(v)

G[u].append((v, w))

Network Delay Time (Leetcode 743)

嘗試分析時間複雜度吧！

不重複會跑幾個點？

O(|V|)

O(|V|)

每個點都會擴散最多多少個點？

O(|V|)

O(|V|)

最多會有多少的 queue / vector ?

O(|V| \times w_{\max})

O(|V| \times w_{\max})

O(|V|^2 + |V|w_{\max})

O(|V|^2 + |V|w_{\max})

|E|

|E|

等等，呢？

Network Delay Time (Leetcode 743)

嘗試分析時間複雜度吧！

不重複會跑幾個點？

O(|V|)

O(|V|)

最多擴散多少次？

O(|E|)

O(|E|)

最多會有多少的 queue / vector ?

O(|V| \times w_{\max})

O(|V| \times w_{\max})

O(|V| + |E| + |V|w_{\max}) = O(|E| + |V|w_{\max})

O(|V| + |E| + |V|w_{\max}) = O(|E| + |V|w_{\max})

在這裡我們當作 |E| > |V|

Network Delay Time (Leetcode 743)

Python 實作細節：

使用 heapq 這個套件。

 heapify(Q) 		# 讓 Q 變成 heap
heappush(Q, x)	# 將 x 插入進 Q
heappop(Q)		# 將 Q pop 最小值
Q[0]			# 拿最小值

O(N)

O(N)

O(\log N)

O(\log N)

O(\log N)

O(\log N)

O(1)

O(1)

什麼是 heap？

heap是一種完全二元樹

但想知道更多請參見 heap 章節

 Q = [(0, k)]    # 一個點不用 heapify
while Q:
  cur_delay, cur = heappop(Q)
  if delay[cur] != -1:
    continue
  delay[cur] = cur_delay
  for nxt, w in G[cur]:
    heappush(Q, (cur_delay+w, nxt))

Network Delay Time (Leetcode 743)

嘗試分析時間複雜度吧！

不重複會跑幾個點？

O(|V|)

O(|V|)

每個點都會擴散最多多少個點？

O(|E|)

O(|E|)

O(|V| + |E| \log |E|) \simeq O(|V| + |E| \log |V|)

O(|V| + |E| \log |E|) \simeq O(|V| + |E| \log |V|)

等等，heapq / pq 的 push 複雜度呢？

O(\log |E|)

O(\log |E|)

還有更快的實作，目前是

O(|V| + |V| \log |V|)

O(|V| + |V| \log |V|)

在這裡我們當作 |E| > |V|

給你一個 有向簡單圖 G，每個節點表示一堂課，

<u, v> 表示 v 的擋修是 u (要完成 u 才可以修 v)。

請判斷你能不能夠修完所有課？

0

1

2

修 0 要先修1, 2
修 1 要先修2
2 沒有擋修

可以，2 -> 1 -> 0

很簡單的貪心策略：

把已經可以修的課
全部修完不就好了嗎？

沒有擋修的課
有什麼性質？

deg_{in} = 0

deg_{in} = 0

Course Schedule (Leetcode 207)

給你一個 有向簡單圖 G，每個節點表示一堂課，

<u, v> 表示 v 的擋修是 u (要完成 u 才可以修 v)。

請判斷你能不能夠修完所有課？

0

1

2

很簡單的貪心策略：

把已經可以修的課
全部修完不就好了嗎？

沒有擋修的課
有什麼性質？

deg_{in} = 0

deg_{in} = 0

in_deg = 2

in_deg = 1

in_deg = 0

2

修課順序：

-> 1

-> 0

/ 0

/ 1

/ 0

這個算法習慣用BFS做！

Course Schedule (Leetcode 207)

給你一個 有向簡單圖 G，每個節點表示一堂課，

<u, v> 表示 v 的擋修是 u (要完成 u 才可以修 v)。

請判斷你能不能夠修完所有課？

很簡單的貪心策略：

把已經可以修的課
全部修完不就好了嗎？

沒有擋修的課
有什麼性質？

deg_{in} = 0

deg_{in} = 0

這個算法習慣用BFS做！

Kahn's Algorithm 流程

找出入度 = 0 的點，放入 queue
對於 queue 內每個點：
- 現在可以修這個課
1. 刪掉點，更新鄰居的入度
2. 如果有入度變 0，放入 queue
如果整個 queue 空了：
- 還有課沒修，表示有環，死結
- 所有課修完了，Hooray!

Course Schedule (Leetcode 207)

7

4

2

1

3

Heap的定義：

對於每個點，滿足下列條件：

子樹 L 所有點 \le x \\ 子樹 R 所有點 \le x

子樹 L 所有點 \le x \\ 子樹 R 所有點 \le x

x

l

r

Search in a Binary Search Tree (Leetcode 700)

請實作一個完全二元樹，包含三種操作：
1. 查看最大值，2. 刪除最大值，3. 插入數值

(Complete Binary Tree)

Heap 不一定要是完全二元樹，
但完全二元樹比較好實作。

線段樹 (Segment Tree)

線段樹就是一個節點為「一個區間」的樹。

假設一開始有 8 個數字 (index 為 [0, 7])

[0, 7]

[0, 3]

[4, 7]

[0, 1]

[2, 3]

[4, 5]

[6, 7]

A0

A1

A2

A3

A4

A5

A6

A7

這有什麼用呢？

你會發現你想要計算一個區間，

都可以拆出若干個子區間。

舉例來說，你想要查詢 [0, 5]：

你訪問 [0, 3] + [4, 5] 的區間就可以了。
- 具體來說，最多只會拆成總計的區間
那麼在原題 (詢問區間加總)，我們在樹上的每個點紀錄該區間的總和就可以了！

2 \log_2(n)

2 \log_2(n)

線段樹 (Segment Tree) - 區間修改

線段樹如何做到區間修改？
rangeModify(qL, qR, val) = 修改 [qL, qR] 的數字變成 val

[0, 7]

[0, 3]

[4, 7]

[0, 1]

[2, 3]

[4, 5]

[6, 7]

A0

A1

A2

A3

A4

A5

A6

A7

Naive：
- 每修改一次需要
- 總共
- 爆了... 怎麼更好？
學習 heap 的 lazy 技巧！
Lazy Tag (懶人標記) 的精神：
- 在該點上標記：
  「這裡要修改成 val 喔！」
- 來想想看要怎麼利用
  「懶人的精神」吧！

O(\log n)

O(\log n)

O((qR-qL) \log n)

O((qR-qL) \log n)

Falling Squares (Leetcode 699)

現在有 n 個 (位置，邊長) 表示模擬 n 個正方形掉落在該位置上。

如果掉落的時候會卡到以前的正方形，則會直接停在上面。

請輸出每個時間點，正方形們可以到達的最高高度。

想想看時間複雜度吧！

build:
push:
pull:
query:
modify:
rangeModify:

O(N)

O(N)

O(1)

O(1)

O(1)

O(1)

O(\log N)

O(\log N)

O(\log N)

O(\log N)

O(\log N)

O(\log N)

整體複雜度：

O(N + Q \log N)

O(N + Q \log N)

Binary Indexed Tree / Fenwick Tree

BIT 與線段樹的結構差異：

BIT 只用一個長度為 n 的陣列存數值，並且從 1 開始算

[1, 8]

[1, 4]

[5, 8]

[1, 2]

[3, 4]

[5, 6]

[7, 8]

A1

。

A3

A5

A7

(1-indexed)

Binary Indexed Tree / BIT

。

BIT 就只存這一個陣列。圓點表示一個區間的值

q(1): (1)
q(2): (2)
q(3): (3, 2)
q(4): (4)

q(5): (5, 4)
q(6): (6, 4)
q(7): (7, 6, 4)
q(8): (8)

用二進位制觀察一下性質：

第一層(最底層)都是奇數
- 第二層 % 2 = 0
- 第三層 % 4 = 0 ...
每一層最多只會有一個代表
q(n) = {n, q(n-x)}，例如
- q(7) -> 7, q(7-1 = 6)
- q(6) -> 6, q(6-2 = 4)
這裡的 x 要怎麼算出來呢？

= 1000_{2}

= 1000_{2}

= 0100_{2}

= 0100_{2}

= 0010_{2}

= 0010_{2}

= 0110_{2}

= 0110_{2}

= 0001_{2}

= 0001_{2}

= 0011_{2}

= 0011_{2}

= 0101_{2}

= 0101_{2}

= 0111_{2}

= 0111_{2}

Binary Indexed Tree - Query

Query

\begin{array}{l} 1_{10} & &&& 0001_{2} &&& [1]_{10} && [0001]_{2} \\ 2_{10} & &&& 0010_{2} &&& [2]_{10} && [0010]_{2} \\ 3_{10} & &&& 0011_{2} &&& [3, 2]_{10} && [0011, 0010]_{2} \\ 4_{10} & &&& 0100_{2} &&& [4]_{10} && [0100]_{2} \\ 5_{10} & &&& 0101_{2} &&& [5, 4]_{10} && [0101, 0100]_{2} \\ 6_{10} & &&& 0110_{2} &&& [6, 4]_{10} && [0110, 0100]_{2} \\ 7_{10} & &&& 0111_{2} &&& [7, 6, 4]_{10} && [0111, 0110, 0100]_{2} \\ \end{array}

\begin{array}{l} 1_{10} & &&& 0001_{2} &&& [1]_{10} && [0001]_{2} \\ 2_{10} & &&& 0010_{2} &&& [2]_{10} && [0010]_{2} \\ 3_{10} & &&& 0011_{2} &&& [3, 2]_{10} && [0011, 0010]_{2} \\ 4_{10} & &&& 0100_{2} &&& [4]_{10} && [0100]_{2} \\ 5_{10} & &&& 0101_{2} &&& [5, 4]_{10} && [0101, 0100]_{2} \\ 6_{10} & &&& 0110_{2} &&& [6, 4]_{10} && [0110, 0100]_{2} \\ 7_{10} & &&& 0111_{2} &&& [7, 6, 4]_{10} && [0111, 0110, 0100]_{2} \\ \end{array}

Needs

十進位

二進位

十進位

二進位

你想得出規律嗎？

在線 LCA - Naive 作法

A

B

C

D

E

F

G

H

I

LCA (最低共同祖先) 的定義：

每筆詢問給定兩個點，
請問它們共同的祖先中最低的是？

LCA(H, G) = C
LCA(D, I) = A

最簡單的做法就是：

幫每個點標深度 (跟 parent )
先讓比較深的點走到跟淺的點一樣的深度
兩邊同時往上走，碰到一起即為LCA
做一次的複雜度為多少呢？

O(N)

O(N)

H(A) = 0

H(B) = 1

H(C) = 1

H(D) = 2

H(E) = 2

H(F) = 2

H(G) = 2

H(H) = 3

H(I) = 3

D

I

E

B

C

A

在線 LCA - 倍增算法

binary lifting

A

B

C

D

E

F

G

H

I

Naive 在一次詢問的情況下是OK的。

不幸的是，大部分情況需要很多次。

要怎麼樣才可以降低詢問的複雜度？

一個簡單的想法：每次往上移的時候，跳多一點。
「多」具體來說是多少呢？
- 簡單上來說就是做二分搜尋的反向版，倍增搜尋。
- 每個點紀錄上個 parent 是誰

詢問 Q 次 \times O(N) = O(QN)

詢問 Q 次 \times O(N) = O(QN)

2^k

2^k

在線 LCA - 倍增算法

binary lifting

建的 parent 是誰 (建到就好了)
- 你會發現 X 的上個的 parents 就會等於...
- 「X 的上個的 parent = Y」的上個的 parent
- Base Case：k=0 就是該點的 parent。

2^k

2^k

2^{k}

2^{k}

2^{k-1}

2^{k-1}

2^{k-1}

2^{k-1}

Y

X

2^{k-1}

2^{k-1}

2^{k}

2^{k}

Z

2^{k-1}

2^{k-1}

k = log_2(N) + 1

k = log_2(N) + 1

在線 LCA - 倍增算法

binary lifting

 heights, parents = {}, {}
MAX_H = 17
def dfs(root, depth, parent):
  if not root: return
  heights[root] = depth
  parents[root, 0] = parent
  for k in range(1, MAX_H):
    Y = parents[root, k-1]
    parents[root, k] = parents[Y, k-1]
  
  dfs(root.left, depth+1, root)
  dfs(root.right, depth+1, root)
dfs(root, 0, root)

 const static int MAX_H = 17;
unordered_map<TreeNode*, int> height;
unordered_map<TreeNode*, TreeNode*> parents[MAX_H];
void dfs(TreeNode *root, int depth, TreeNode* parent) {
  if (!root) return;
  height[root] = depth;
  parents[0][root] = parent;
  for (int k=1; k<MAX_H; k++) {
    auto Y = parents[k-1][root];
    parents[k][root] = parents[k-1][Y];
  }
  dfs(root->left , depth+1, root);
  dfs(root->right, depth+1, root);
}
// When build first
dfs(root, 0, root);

Python

C++

建的 parent 是誰 (建到就好了)
- 你會發現 X 的上個的 parents 就會等於...
- 「X 的上個的 parent = Y」的上個的 parent
- Base Case：k=0 就是該點的 parent。

2^k

2^k

2^{k}

2^{k}

2^{k-1}

2^{k-1}

2^{k-1}

2^{k-1}

k = log_2(N) + 1

k = log_2(N) + 1

在線 LCA - 倍增算法

binary lifting

建的 parent 是誰 (建到就好了)
先讓比較深的點走到跟淺的點一樣的深度

2^k

2^k

假設 height[p] > height[q]：

假設 p 跟 q 的深度差為 x，那麼 x 可以寫成二進位制。

x = \begin{cases} 1_{10} & = 001_{2} & \rightarrow 移動 1 + 0 + 0 步 & \rightarrow k=\{0~~~~~~~~\} \\ 5_{10} & = 101_{2} & \rightarrow 移動 1 + 0 + 4 步 & \rightarrow k=\{0 ~~~~, 2\} \\ 7_{10} & = 111_{2} & \rightarrow 移動 1 + 2 + 4 步 & \rightarrow k=\{0, 1, 2\} \\ \end{cases}

x = \begin{cases} 1_{10} & = 001_{2} & \rightarrow 移動 1 + 0 + 0 步 & \rightarrow k=\{0~~~~~~~~\} \\ 5_{10} & = 101_{2} & \rightarrow 移動 1 + 0 + 4 步 & \rightarrow k=\{0 ~~~~, 2\} \\ 7_{10} & = 111_{2} & \rightarrow 移動 1 + 2 + 4 步 & \rightarrow k=\{0, 1, 2\} \\ \end{cases}

 TreeNode* query(TreeNode *p, TreeNode *q) {
  if (height[p] < height[q])
    return query(q, p);
  // Let h[p] = h[q]
  for (int k=0; k<MAX_H; k++)
    if ((height[p] - height[q]) & (1 << k))
      p = parents[k][p];
  // ...

 def LCA(p, q):
  if heights[p] < heights[q]:
    return LCA(q, p)
  # Let h[p] = h[q]
  for k in range(MAX_H):
    if (heights[p] - heights[q]) & (1 << k):
      p = parents[p, k]
  # ...

Python

C++

只需移動 log N 次！

k = log_2(N) + 1

k = log_2(N) + 1

在線 LCA - 倍增算法

binary lifting

建的 parent 是誰 (建到就好了)
先讓比較深的點走到跟淺的點一樣的深度
二分搜 p 和 q 要跨多少步

2^k

2^k

體感上會是這樣：

P

Q

X

步伐從最大步開始測，也就是
假設現在正在考慮從 P / Q 走步
- 如果相等，表示太過。
  - 步伐下次小一點，變步

2^h

2^h

2^h

2^h

2^h

2^h

2^{h-1}

2^{h-1}

k = log_2(N) + 1

k = log_2(N) + 1

2^{H_{MAX}-1}

2^{H_{MAX}-1}

在線 LCA - 倍增算法

binary lifting

體感上會是這樣：

P

Q

步伐從最大步開始測，也就是
假設現在正在考慮從 P / Q 走步
- 如果相等，表示太過。
  - 步伐下次小一點，變步
- 如果不相等，表示可以直接跳。
  - 下次跳一定會太過，所以步伐下次也會變成步
跳完後，P / Q 的下一步 ( = 它們的 parent ) 就會等於 LCA(P, Q)

2^h

2^h

2^{h-1}

2^{h-1}

2^{H_{MAX}-1}

2^{H_{MAX}-1}

2^h

2^h

2^{h-1}

2^{h-1}

X

Y

2^h

2^h

2^h

2^h

Z

?

?

?

?

建的 parent 是誰 (建到就好了)
先讓比較深的點走到跟淺的點一樣的深度
二分搜 p 和 q 要跨多少步

2^k

2^k

k = log_2(N) + 1

k = log_2(N) + 1

在線 LCA - 倍增算法

binary lifting

建的 parent 是誰 (建到就好了)
先讓比較深的點走到跟淺的點一樣的深度
二分搜 p 和 q 要跨多少步

2^k

2^k

步伐從最大步開始測，也就是
假設現在正在考慮從 P / Q 走步，每次縮減一半
- 如果不相等，表示可以直接跳。
跳完後，P / Q 的 parent 就會等於 LCA(P, Q)

2^h

2^h

2^{H_{MAX}-1}

2^{H_{MAX}-1}

   // ...
  // Special Case: No move
  if (p == q)
    return p;
 
  for (int h=MAX_H-1; h>=0; h--)
    if (parents[h][p] != parents[h][q])
      p = parents[h][p], q = parents[h][q];
  return parents[0][p];
}

   # ...
  # Special Case: No Move
  if p == q:
    return p
  
  for h in range(MAX_H-1, -1, -1):
    if parents[p, h] != parents[q, h]:
      p = parents[p, h]
      q = parents[q, h]
  return parents[p, 0]

Python

C++

k = log_2(N) + 1

k = log_2(N) + 1

在線 LCA - 倍增算法

binary lifting

 class Solution {
public:
  const static int MAX_H = 17;
  unordered_map<TreeNode*, int> height;
  unordered_map<TreeNode*, TreeNode*> parents[MAX_H];
  void dfs(TreeNode *root, int depth, TreeNode* parent) {
    if (!root) return;
    height[root] = depth;
    parents[0][root] = parent;
    for (int log_h=1; log_h<MAX_H; log_h++) {
      auto hop = parents[log_h-1][root];
      parents[log_h][root] = parents[log_h-1][hop];
    }
    dfs(root->left , depth+1, root);
    dfs(root->right, depth+1, root);
  }
  TreeNode* query(TreeNode *p, TreeNode *q) {
    if (height[p] < height[q])
      return query(q, p);
    for (int i=0; i<MAX_H; i++)
      if ((height[p] - height[q]) & (1 << i))
        p = parents[i][p];
    if (p == q)
      return p;
    for (int i=MAX_H-1; i>=0; i--)
      if (parents[i][p] != parents[i][q])
        p = parents[i][p], q = parents[i][q];
    return parents[0][p];
  }
  TreeNode* lowestCommonAncestor(
  		TreeNode* root, TreeNode* p, TreeNode* q) {
    dfs(root, 0, root);
    return query(p, q);
  }
};

C++

重點整理：

建 2^h 的 parent 表
- 2^h = 2^{h-1} 兩次
查詢 p, q
- 先讓 p 比較深
- 讓 p, q 深度一樣。
  - 用深度差算出每次移動多少步
- 用二分搜尋找 p, q 可以跳到哪裡還沒一樣
整體複雜度：

O((N+Q) \log N)

O((N+Q) \log N)

在線 LCA - 倍增算法

binary lifting

 class Solution:
  def lowestCommonAncestor(self, root, p, q):
    heights, parents = {}, {}
    MAX_H = 17
    
    def dfs(root, depth, parent):
      if not root: return
      heights[root] = depth
      parents[root, 0] = parent
      for log_h in range(1, MAX_H):
        hop = parents[root, log_h-1]
        parents[root, log_h] = parents[hop, log_h-1]
      
      dfs(root.left, depth+1, root)
      dfs(root.right, depth+1, root)
    dfs(root, 0, root)
 
    def LCA(p, q):
      if heights[p] < heights[q]:
        return LCA(q, p)
      # Let h[p] = h[q]
      for i in range(MAX_H):
        if (heights[p] - heights[q]) & (1 << i):
          p = parents[p, i]
      if p == q:
        return p
      for log_h in range(MAX_H-1, -1, -1):
        if parents[p, log_h] != parents[q, log_h]:
          p = parents[p, log_h]
          q = parents[q, log_h]
      return parents[p, 0]
 
    return LCA(p, q)

Python

重點整理：

建 2^h 的 parent 表
- 2^h = 2^{h-1} 兩次
查詢 p, q
- 先讓 p 比較深
- 讓 p, q 深度一樣。
  - 用深度差算出每次移動多少步
- 用二分搜尋找 p, q 可以跳到哪裡還沒一樣
整體複雜度：

O((N+Q) \log N)

O((N+Q) \log N)

在線 LCA - 尤拉導覽

Euler Tour Technique (ETT)

建構 ETT，並且記錄深度以及該點，以及進出的位置
尋找 LCA 時，尋找先進的位置 <-> 最後出的位置
把這段 ETT 中最低深度的找出來，回傳。

這段好像怪怪的...?

你會發現 LCA 通過 ETT 後會變成 RMQ 問題！

接著我們可以套任何一個 RMQ 模板，就可以降到 log 等級了！

例如你可能剛學過的線段樹。
或比較快的 Sparse Table (離線RMQ，Query O(1))

整體複雜度：

Q \times O(N) = O(QN)

Q \times O(N) = O(QN)

😭

	int boss[N], rank[N]={};
	void init() {
	for (int i=0; i<N; i++)
	boss[i] = i;
	}
	int find_boss(int x) {
	if (x == boss[x])
	return x;
	return find_boss(boss[x]);
	}
	void merge(int x, int y) {
	int boss_x = find_boss(x);
	int boss_y = find_boss(y);
	if (boss_x == boss_y)
	return ;
	if (rank[boss_x] > rank[boss_y]) {
	boss[boss_y] = boss_x;
	} else {
	boss[boss_x] = boss_y;
	if (rank[boss_x] == rank[boss_y])
	rank[boss_y] ++;
	}
	}

	boss = list(range(N))
	rank = [0] * N
	def find_boss(x):
	if x == boss[x]:
	return x
	return find_boss(boss[x])

	def merge(x, y):
	boss_x = find_boss(x)
	boss_y = find_boss(y)
	if boss_x == boss_y:
	return
	if rank[boss_x] > rank[boss_y]:
	boss[boss_y] = boss_x
	else:
	boss[boss_x] = boss_y
	if rank[boss_x] == rank[boss_y]:
	rank[boss_y] += 1

	int boss[N], rank[N]={};
	void init() {
	for (int i=0; i<N; i++)
	boss[i] = i;
	}
	int find_boss(int x) {
	if (x == boss[x])
	return x;
	return boss[x] = find_boss(boss[x]);
	}
	void merge(int x, int y) {
	int boss_x = find_boss(x);
	int boss_y = find_boss(y);
	if (boss_x == boss_y)
	return ;
	if (rank[boss_x] > rank[boss_y]) {
	boss[boss_y] = boss_x;
	} else {
	boss[boss_x] = boss_y;
	if (rank[boss_x] == rank[boss_y])
	rank[boss_y] ++;
	}
	}

	boss = list(range(N))
	rank = [0] * N
	def find_boss(x):
	if x != boss[x]:
	boss[x] = find_boss(boss[x])
	return boss[x]

	def merge(x, y):
	boss_x = find_boss(x)
	boss_y = find_boss(y)
	if boss_x == boss_y:
	return
	if rank[boss_x] > rank[boss_y]:
	boss[boss_y] = boss_x
	else:
	boss[boss_x] = boss_y
	if rank[boss_x] == rank[boss_y]:
	rank[boss_y] += 1

	#include <stdio.h>
	#define N 10001
	int boss[N], rank[N] = {};
	// DSU 模板 code
	int main()
	{
	int n, m, q, x, y;
	scanf("%d%d%d", &n, &m, &q);
	init();
	while (m--) {
	scanf("%d%d", &x, &y);
	merge(x, y);
	}
	while (q--) {
	scanf("%d%d", &x, &y);
	printf(":%c\n", "()"[find_boss(x) == find_boss(y)]);
	}
	return 0;
	}

	int boss[N];
	void init() {
	for (int i=0; i<N; i++)
	boss[i] = i;
	}
	int find_boss(int x) {
	if (x == boss[x])
	return x;
	return find_boss(boss[x]);
	}
	int merge(int x, int y) {
	boss[find_boss(y)] = find_boss(x);
	}

	N, m, q = map(int, input().split())
	boss = list(range(N+1))
	rank = [0] * (N+1)
	# DSU 模板 code
	for _ in range(m):
	x, y = map(int, input().split())
	merge(x, y)

	for _ in range(q):
	x, y = map(int, input().split())
	if find_boss(x) == find_boss(y):
	print(":)")
	else:
	print(":(")

	class Solution {
	public:
	unordered_map<string, string> boss;
	unordered_map<string, int> rank;
	unordered_map<string, int> account_to_idx;

	// DSU 模板
	string find_boss(string x) {
	if (boss[x] == x)
	return x;
	return boss[x] = find_boss(boss[x]);
	}

	void merge(string x, string y) {
	string bossX = find_boss(x);
	string bossY = find_boss(y);
	if (bossX != bossY) {
	if (rank[bossX] > rank[bossY]) {
	boss[bossY] = bossX;
	} else{
	boss[bossX] = bossY;
	if (rank[bossX] == rank[bossY])
	rank[bossY]++;
	}
	}
	}
	// .....

	vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
	// 初始化，以及開始合併
	for (int i = 0; i < accounts.size(); i++) {
	auto &account_list = accounts[i];
	for (int j = 1; j < account_list.size(); j++) {
	string &account = account_list[j];
	if (boss.find(account) == boss.end()) {
	boss[account] = account;
	rank[account] = 0;
	}
	account_to_idx[account] = i;
	merge(account, account_list[1]);
	}
	}

	// 蒐集答案
	unordered_map<string, set<string>> pre_answer;
	for (int i = 0; i < accounts.size(); i++) {
	auto &account_list = accounts[i];
	for (int j = 1; j < account_list.size(); j++) {
	string &account = account_list[j];
	pre_answer[find_boss(account)].insert(account);
	}
	}

	// 輸出答案
	vector<vector<string>> answer;
	for (auto &[root, account_set] : pre_answer) {
	vector<string> merged_account;
	merged_account.push_back(accounts[account_to_idx[root]][0]);
	// Set 會自己排序。
	merged_account.insert(merged_account.end(), account_set.begin(), account_set.end());
	answer.push_back(merged_account);
	}

	return answer;
	}
	};

	# email 對應到第幾個資料
	account_to_idx = {}
	boss = {}
	rank = defaultdict(lambda: 0)
	# 這裡插入 DSU 模板 code
	# 開始合併。
	for i, account_list in enumerate(accounts):
	for account in account_list[1:]:
	account_to_idx[account] = i
	if account not in boss:
	boss[account] = account
	merge(account_list[1], account)

	pre_answer = defaultdict(lambda: set())
	# 開始統整答案
	for i, account_list in enumerate(accounts):
	for account in account_list[1:]:
	boss_name_idx = account_to_idx[find_boss(account)]
	pre_answer[boss_name_idx].add(account)

	return [ [accounts[i][0]] + sorted(list(l)) for i, l in pre_answer.items()]

	#########
	#.......#
	#.#####.#
	#.......#
	##.#.####
	#..#.#..#
	#.##.##.#
	#.......#
	#########

	#########
	#1......#
	#2#####.#
	#3456...#
	##.#7####
	#..#8#..#
	#.##9##.#
	#...ABCD#
	#########

	#########
	#.......#
	#.#.###.#
	#...###.#
	#######.#
	#######.#
	#######.#
	#######.#
	#########

	#include <iostream>
	#include <vector>
	using namespace std;
	char table[101][101];
	int ix[] = {1, 0, -1, 0};
	int iy[] = {0, 1, 0, -1};
	vector<pair<int, int>> Q[10000];
	int main(){
	int n, ans=-1;
	scanf("%d", &n);
	for(int i=0; i<n; i++)
	scanf("%s", table[i]);

	Q[0].push_back({1, 1});
	for(int cur_cost=0; !Q[cur_cost].empty(); cur_cost++){
	for (auto &[x, y] : Q[cur_cost]) {
	if(x == n-2 && y == n-2) {
	printf("%d\n", cur_cost+1);
	return 0;
	}
	for(int k=0; k<4; k++){
	int nx = x + ix[k], ny = y + iy[k];
	if(table[nx][ny] == '.'){
	Q[cur_cost+1].push_back({nx, ny});
	table[nx][ny] = '#';
	}
	}
	}
	}
	printf("No solution!");
	return 0;
	}

	from collections import defaultdict
	DIRS = [[0, 1], [0, -1], [1, 0], [-1, 0]]
	n = int(input())
	maze = [input() for _ in range(n)]
	Q = defaultdict(list)
	Q[0].append((1, 1))

	cur_cost = 0
	visit = set()
	answer = None
	while Q[cur_cost] and answer is None:
	for x, y in Q[cur_cost]:
	# If it's answer, break
	if x == n-2 and y == n-2:
	answer = cur_cost
	break
	# If visit, skip
	if (x, y) in visit:
	continue
	visit.add((x, y))
	# Search next states
	for dx, dy in DIRS:
	nx, ny = x + dx, y + dy
	if maze[nx][ny] == '.':
	Q[cur_cost+1].append((nx, ny))
	cur_cost += 1
	if answer is None:
	print("No solution!")
	else:
	print(answer + 1)

	class Solution {
	public:
	vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
	int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
	int original_color = image[sr][sc];
	if (color == original_color)
	return image;
	image[sr][sc] = color;
	for (int k=0; k<4; k++) {
	int nx = sr + dx[k], ny = sc + dy[k];
	if (nx < 0 \|\| nx >= image.size() \|\| ny < 0 \|\| ny >= image[nx].size())
	continue;
	if (image[nx][ny] == original_color)
	floodFill(image, nx, ny, color);
	}
	return image;
	}
	};

	class Solution:
	def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:

	original_color = image[sr][sc]
	if color == original_color:
	return image
	image[sr][sc] = color

	for dx, dy in [[1, 0], [0, 1], [-1, 0], [0, -1]]:
	nx, ny = sr + dx, sc + dy
	if not (0 <= nx < len(image) and 0 <= ny < len(image[nx])):
	continue
	if image[nx][ny] == original_color:
	self.floodFill(image, nx, ny, color)

	return image

	import sys
	sys.setrecursionlimit(1000000)

	vector<char> getPossibilities(vector<vector<char>>& board, int x, int y) {
	bool visit[256] = {};
	for (int i=0; i<9; i++) {
	visit[board[i][y]] = true;
	visit[board[x][i]] = true;
	visit[board[x/33 + i/3][y/33 + i%3]] = true;
	}
	vector<char> V;
	for (char c='1'; c<='9'; c++)
	if (!visit[c])
	V.push_back(c);
	return V;
	}

	#include <iostream>
	#include <queue>
	using namespace std;
	char table[101][101];
	int cost[101][101];
	int ix[] = {1, 0, -1, 0};
	int iy[] = {0, 1, 0, -1};
	int main(){
	int n, ans=-1;
	scanf("%d", &n);
	for(int i=0; i<n; i++)
	scanf("%s", table[i]);

	queue<pair<int, int> > Q({{1, 1}});
	while(!Q.empty()){
	auto now = Q.front();
	Q.pop();
	if(now.first == n-2 && now.second == n-2){
	printf("%d\n", cost[n-2][n-2]+1);
	return 0;
	}
	for(int k=0; k<4; k++){
	int nx = now.first + ix[k];
	int ny = now.second + iy[k];
	if(table[nx][ny] == '.'){
	cost[nx][ny] = cost[now.first][now.second] + 1;
	Q.push({nx, ny});
	table[nx][ny] = '#';
	}
	}
	}
	printf("No solution!");
	return 0;
	}

	from collections import deque
	DIRS = [[0, 1], [0, -1], [1, 0], [-1, 0]]
	n = int(input())
	maze = [input() for _ in range(n)]
	# Starts at (1, 1) with cost 1
	Q = deque([(1, 1, 1)])

	visit = set()
	answer = None
	while Q:
	x, y, cost = Q.popleft()
	# If gets answer, break
	if x == n-2 and y == n-2:
	answer = cost
	break
	# If visit, skip
	if (x, y) in visit:
	continue
	visit.add((x, y))
	# Search next states
	for dx, dy in DIRS:
	nx, ny = x + dx, y + dy
	if maze[nx][ny] == '.':
	Q.append((nx, ny, cost+1))
	if answer is None:
	print("No solution!")
	else:
	print(answer)

	def getPossibilities(self, board: List[List[str]], x: int, y: int) -> bool:
	possibles = set('123456789')
	for i in range(9):
	possibles.discard(board[i][y])
	possibles.discard(board[x][i])
	possibles.discard(board[x//33 + i//3][y//33 + i%3])
	return possibles

	bool solveSudoku(vector<vector<char>>& board, int start=0) {
	if (start == 81)
	return true;
	int x = start / 9, y = start % 9;
	if (board[x][y] != '.')
	return solveSudoku(board, start+1);
	for (char guess : getPossibilities(board, x, y)) {
	board[x][y] = guess;
	if (solveSudoku(board, start+1))
	return true;
	board[x][y] = '.';
	}
	return false;
	}

	def solveSudoku(self, board: List[List[str]], start=0) -> None:
	if start == 81:
	return True
	x, y = start // 9, start % 9
	if board[x][y] != '.':
	return self.solveSudoku(board, start+1)
	else:
	for guess in self.getPossibilities(board, x, y):
	board[x][y] = guess
	if self.solveSudoku(board, start+1):
	return True
	board[x][y] = '.'
	return False

	vector<vector<int>> endBoard{{1, 2, 3}, {4, 5, 0}};
	bool isEnd(vector<vector<int>> &board) {
	return board == endBoard;
	}
	vector<vector<vector<int>>> getPossibilites(vector<vector<int>> &board) {
	vector<vector<vector<int>>> possibilities;
	// Find zero
	int x, y;
	for (int i = 0; i < 2; i++)
	for (int j = 0; j < 3; j++)
	if (board[i][j] == 0)
	x = i, y = j;
	// Get Possibilities
	int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
	for (int k = 0; k < 4; k++) {
	int nx = x + dx[k], ny = y + dy[k];
	if (nx < 0 \|\| nx > 1 \|\| ny < 0 \|\| ny > 2)
	continue;
	vector<vector<int>> nxt_board(board);
	swap(nxt_board[nx][ny], nxt_board[x][y]);
	possibilities.push_back(nxt_board);
	}
	return possibilities;
	}

	def isEnd(self, board):
	return board == [[1, 2, 3], [4, 5, 0]]

	def getPossibilities(self, board):
	# Find Zero
	x, y = [(i, j) for i in range(2) for j in range(3) if board[i][j] == 0][0]
	possibilities = []
	for dx, dy in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
	nx, ny = x + dx, y + dy
	if not (0 <= nx <= 1 and 0 <= ny <= 2):
	continue
	nxt_board = deepcopy(board)
	nxt_board[x][y], nxt_board[nx][ny] = nxt_board[nx][ny], nxt_board[x][y]
	possibilities.append(nxt_board)
	return possibilities

	int slidingPuzzle(vector<vector<int>>& board) {
	queue<pair<vector<vector<int>>, int>> Q;
	Q.push({board, 0});
	unordered_set<string> visit;

	while (!Q.empty()) {
	auto [cur_board, cost] = Q.front();
	Q.pop();
	if (isEnd(cur_board))
	return cost;
	auto key = compress(cur_board);
	if (visit.find(key) != visit.end())
	continue;
	visit.insert(key);
	for (auto nxt_board : getPossibilites(cur_board))
	Q.push({nxt_board, cost + 1});
	}
	return -1;
	}

	string compress(
	vector<vector<int>>& board) {

	string result;
	for (const auto& row : board)
	for (int val : row)
	result += to_string(val);
	return result;
	}

	def slidingPuzzle(self, board: List[List[int]]) -> int:
	Q = deque([(board, 0)])
	visit = set()
	while Q:
	cur_board, cost = Q.popleft()
	if self.isEnd(cur_board):
	return cost
	key = str(cur_board)
	if key in visit:
	continue
	visit.add(key)
	for nxt_board in self.getPossibilities(cur_board):
	Q.append((nxt_board, cost+1))
	return -1

	#include <iostream>
	#include <unordered_set>
	#include <set>
	using namespace std;

	struct A {
	int x;
	bool operator <(const A &other) const {
	return x < other.x;
	}
	};

	struct B {
	int x;
	bool operator ==(const B &other) const {
	return x == other.x;
	}
	};

	namespace std {
	template<> struct hash<B> {
	size_t operator()(const B& p) const noexcept {
	return p.x;
	}
	};
	}

	int main() {
	set<A> S1;
	S1.insert(A());

	unordered_set<B> S2;
	S2.insert(B());

	}

	class A:
	def __init__(self):
	self.x = 0

	def __eq__(self, value: object) -> bool:
	return self.x == value.x

	def __hash__(self) -> int:
	return self.x


	print(len({A(), A()}))

中文	英文	意思
樹根	Root Node	沒有父節點的點 (孤兒)
樹葉 / 葉節點	Leaf / Outer / Terminal Node	沒有小孩的節點
父節點	Parent Node	上游的那個點
子節點	Children Node	下游的點們
兄弟節點	Sibling Node	父節點的子節點扣掉自己
祖先	Ancestors	上游的所有點
子孫	Descendants	下游的所有點
鄰居	Neighbor	父節點+子節點 (= 距離為 1 的點)
節點的度	Degree of Node	有幾個子節點
樹的度	Degree of Tree	樹中所有節點中最大的度
樹的大小	Size	總共有幾個節點
樹的高度	Height	從樹根到樹葉的最大距離
二元樹	Binary Tree	樹的度為 2
完全二元樹	Complete Binary Tree	排列緊湊的二元樹
完美 / 滿二元樹	Full / Perfect Binary Tree	樹葉都在同深度的完全二元樹

	char tree[] = "ABEDFCG";

	int x = 1;
	printf("Node %d: %c", x, tree[x]);

	int x_l = 2*x+1;
	printf("L %d: %c", x_l, tree[x_l]);

	int x_r = 2*x+2;
	printf("R %d: %c", x_r, tree[x_r]);

	tree = "ABEDFCG"

	x = 1
	print(f"Node {x}: {tree[x]}")

	x_l = 2*x+1
	print(f"L {x_l}: {tree[x_l]}")

	x_r = 2*x+2
	print(f"R {x_r}: {tree[x_r]}")

	struct Tree {
	char data;
	Tree l, r;
	Tree (char d, Tree l, Tree r):
	data(d), l(l), r(r) {}
	};

	class Tree:
	def __init__(self, d, l, r):
	self.data = d
	self.l = l
	self.r = r

	struct Tree {
	char data;
	Tree l, r;
	Tree (char d, Tree l, Tree r):
	data(d), l(l), r(r) {}
	};

	struct Tree {
	char data;
	int l, r;
	Tree (char d, int l, int r):
	data(d), l(l), r(r) {}
	};

	queue<Tree *> Q({root});
	while (!Q.empty()) {
	Tree *cur = Q.front();
	Q.pop();
	printf("-> %c ", cur->data);
	if (cur->l) Q.push(cur->l);
	if (cur->r) Q.push(cur->r);
	}