圖論[1]
Graph Theory[1]
INFOR 36th. @小海_夢想特急_夢城前
Index
講師
- 225 賴柏宇
- 海之音、小海或其他類似的
- 美術能力見底
- 表達能力差，不懂要問
- INFOR 36th 學術長
這頁是偷來的- 不會圖論所以來當圖論講師
Reference
- 本次的講師很弱
- 本次提供的範例 Code 可能有誤，請見諒
- 為了提高可讀性，拆成很多函式以及回傳值處理，有時會導致常數較大，請自行修改
- 表達能力很差，所以聽不懂 一定 一定 要問
- 講師永遠不會放棄你
啊對 保有最終解釋權 人很ㄐㄅ不在此範圍 - 簡報或我的觀念可能有誤，歡迎隨時糾正
- 有些奇怪的連結是我推薦的歌.jpg (不是 Rickroll...)
聲明
拓撲 排序
Topological Sort.
ㄆ
ㄨ
- Topology
- 「特定物件經過連續映射後不變性質的研究」
- 較經典的例子像是「甜甜圈和馬克杯是同胚的」
- 以比較視覺化的方式來說
- 物體經過不包括黏合的變形後視為同個物體
- 在圖論裡，類似地，我們不關心權重 (邊長)，只關心連接關係
拓撲
- Topology
- 「特定物件經過連續映射後不變性質的研究」
- 較經典的例子像是「甜甜圈和馬克杯是同胚的」
- 以比較視覺化的方式來說
- 物體經過不包括黏合的變形後視為同個物體
- 在圖論裡，類似地，我們不關心權重 (邊長)，只關心連接關係
拓撲
- 你會發現在有向圖裡常存在一種狀況：
- A 可以走到 B，但 B 不能走到 A
- 以下圖舉例， 0 可以走到 2，但 2 無論如何都走不回 0
- 1 可以走到 2，但 2 不能走到 1
有向圖的特性
0
1
2
- 定義這樣的狀況叫 「 A 的輩分比 B 高」
- 實際上應該沒有正式名稱
- 如果對於一張圖的每個點對都符合這樣的關係，就可以做排序
- 不一定是唯一的
有向圖的特性
1
2
0
- 簡單的例外：存在環的時候不行 (顯然)
- 只要無環都可行
- 如果 A 能走到 B，B 不能走到 A
- B 能走到 C ，C 不能走到 B
- 如果 C 能走到 A 表示有環，所以 C 一定不能走到 A，因此這三點能被排序
- 考慮更多點也會正確
唯一的例外
- 對於一個排序後的點序列 ，圖裡面每個有向邊 ，滿足
- 每個有向邊都是往後面 (輩分較小) 指
形式化表述
\{p_1, p_2, ..., p_{|V|}\}
(p_i, p_j)
i < j
- 我們排序完之後，在關心輩分較小的點時可以不用關心輩分大的點
- 有時候在做事時，真的就得關心點的順序
- 從起點一路推到終點
- 從終點反推起點狀態
- 很多時候，這東西和 DP 會扯上關係
- 轉移時可以確保不會有前面的點的問題！
- 等等講最短路就會遇到 (非常快)
為什麼要拓撲排序
- 注意到排序中輩分最大的那個點一定不會有邊連到它，也就是入度為 0
- 輩分比它低但最大的點 (也就是第二大的) 一定只會被比它大的點連到(也就是最大點)
- 如果去除最大點的影響，第二大的入度一定是 0
- 視為新的圖處理！
演算法概念
- 找到入度為 0 的點
- 把那個點還有相關的邊拔掉，更新入度
- 找到新的入度為 0 的點，放在原本的點後面
- 重複執行以上流程，直到沒有入度為 0 的點
- 如果這時還有點沒被拔掉，說明此圖有有向環！
執行流程
- 類似 BFS ，你會發現如果暴力找點會跑很慢
- 入度為 0 只會在被更新時發生！
- 一樣用 queue 把那些入度為 0 的點推入！
- 所以
- 計算所有點的入度
- 找到入度為 0 的點，推入 queue
- 取出 queue 的前端，放入排序結果
- 拔掉這個點，更新入度
- 如果被拔掉後入度為 0，則推入 queue
- 重複直到 queue 為空
BFS 做法
BFS 做法
0
1
2
3
4
Queue: {}
Result: {}
BFS 做法
0
1
2
3
4
Queue: {0, 4}
Result: {}
BFS 做法
1
2
3
4
Queue: {4, 1}
Result: {0}
BFS 做法
1
2
3
Queue: {1}
Result: {0, 4}
BFS 做法
2
3
Queue: {2}
Result: {0, 4, 1}
BFS 做法
3
Queue: {3}
Result: {0, 4, 1, 2}
BFS 做法
Queue: {}
Result: {0, 4, 1, 2, 3}
vector<vector<int>> graph;
vector<int> topological_sort() {
int n = graph.size();
vector<int> result;
vector<int> indegree(n, 0);
queue<int> nexts;
// count indegree
for (int i = 0; i < n; i++)
for (int j = 0; j < graph[i].size(); j++)
indegree[graph[i][j]]++;
for (int i = 0; i < n; i++)
if (indegree[i] == 0) nexts.push(i);
while (!nexts.empty()) {
int cur = nexts.front();
nexts.pop();
result.push(cur);
for (int i = 0; i < graph[cur].size(); i++) {
int nxt = graph[cur][i];
indegree[nxt]--;
if (indegree[nxt] == 0) nexts.push(nxt);
}
}
return result;
}ult;
}扣
- 如果序列結果 有 ，依據之前的結論可知道此圖有環
- 反之此圖無有向環，稱為有向無環圖 (DAG)
正確性
P
|P| < |V|
- 有 BFS 做法當然有 DFS 做法
- 會一種做法就好了，為什麼要學這個做法？
- 時間戳記 (time stamp) 的概念以後會用到
DFS 做法
- 在遍歷的過程中碰到點 / 離開點的時間順序
Time Stamp
struct Node {
int in_time, out_time;
bool visited = false;
vector<int> neighbor;
};
void dfs(int cur, vector<Node> &graph) {
static int time_stamp = 0;
graph[cur].in_time = time_stamp++;
graph[cur].visited = true;
for (const auto &nxt : graph[cur].neighbor)
if (!graph[nxt].visited) dfs(nxt, graph);
graph[cur].out_time = time_stamp++;
}- 實際上在幹嘛
Time Stamp
0
(*, *)
1
(*, *)
2
(*, *)
4
(*, *)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, *)
1
(*, *)
2
(*, *)
4
(*, *)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, *)
1
(1, *)
2
(*, *)
4
(*, *)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, *)
1
(1, *)
2
(*, *)
4
(2, *)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, *)
1
(1, *)
2
(*, *)
4
(2, 3)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, *)
1
(1, 4)
2
(*, *)
4
(2, 3)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, *)
1
(1, 4)
2
(5, *)
4
(2, 3)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, *)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(*, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, *)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(*, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(10, *)
6
(*, *)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(10, *)
6
(11, *)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(10, *)
6
(11, 12)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(10, 13)
6
(11, 12)
- 實際上在幹嘛
Time Stamp
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(10, 13)
6
(11, 12)
- 值得觀察的是離開戳記
- 如果 u 輩分比 v 大
- 先到 u：u 的離開戳記較大
- 先到 v：因為無法馬上到 u，u 的離開戳記較大
- 如果有環
- 注意到遇到「有進入戳記但無離開戳記」表示還沒離開但卻可以到
- 這種情況下有環
- 如果 u 輩分比 v 大
DFS 做法
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(10, 13)
6
(11, 12)
- 結論：離開戳記比較大則輩分較大！
- 在 DFS 時一邊偵測是否有環，一邊在離開時記錄排序結果
- 其實可以利用「是否是同一次 DFS」來判斷是否有環
DFS 做法
0
(0, 7)
1
(1, 4)
2
(5, 6)
4
(2, 3)
3
(8, 9)
5
(10, 13)
6
(11, 12)
vector<int> topological_sort(const vector<vector<int>> &graph) {
vector<int> result;
result.reserve(graph.size());
vector<int> in_time(graph.size(), 0), out_time(graph.size(), 0);
auto dfs = [&](int cur, auto &&dfs) -> bool {
static int time_stamp = 0;
in_time[cur] = ++time_stamp;
for (const auto &nxt : graph[cur]) {
if (!in_time[nxt]) {
if (!dfs(nxt, dfs)) return false;
}
else if (!out_time[nxt]) {
return false;
}
}
result.push_back(cur);
out_time[cur] = ++time_stamp;
return true;
};
for (int origin = 0; origin < graph.size(); origin++)
if (!in_time[origin])
if (!dfs(origin, dfs)) return vector<int>(0);
return result;
}注意如果是用 vector 直接 push_back 排出來的結果是由輩分小到大
bool dfs(int cur, const vector<vector<int>> &graph, vector<int> &result, vector<int> &in_time, vector<int> &out_time) {
static int time_stamp = 0;
in_time[cur] = ++time_stamp;
for (const auto &nxt : graph[cur]) {
if (!in_time[nxt]) {
if (!dfs(nxt, graph, result, in_time, out_time)) return false;
} else if (!out_time[nxt])
return false;
}
result.push_back(cur);
out_time[cur] = ++time_stamp;
return true;
}
vector<int> topological_sort(const vector<vector<int>> &graph) {
vector<int> result;
result.reserve(graph.size());
vector<int> in_time(graph.size(), 0), out_time(graph.size(), 0);
for (int origin = 0; origin < graph.size(); origin++)
if (!in_time[origin])
if (!dfs(origin, graph, result, in_time, out_time)) return vector<int>(0);
return result;
}給看不懂 lambda 函式的人
最短路算法
Shortest Path.
- 欸 非常直觀 最短路就是最短路
- 你可以拿來算你家到學校的最短路啊 我不反對(
- 主要分成幾種：
- 單點源/全點對
- 帶權/不帶權
- 有負邊/無負邊
- 有負環/無負環
- 依照條件不同，有不同的演算法
最短路
- 單點源：選定一個源點，看源點到其他點最短是多少
- 就是 BFS
- 如果是樹 DFS 就夠了，通常我們會叫它深度
單點源 + 不帶權
- 單點源帶權最短路的基礎
- 如果存在一個中繼邊 使得源點到 的距離 可以縮短（也就是 ）就要更新
- 叫鬆弛不叫繃緊的原因是因為採用了更多的邊（大概）
鬆弛 (relaxation)
e(u, v)
u
d_u
d_v + w_{e} < d_u
7122
O
v
u
2
d_u = 7122
- 單點源帶權最短路的基礎
- 如果存在一個中繼邊 使得源點到 的距離 可以縮短（也就是 ）就要更新
- 叫鬆弛不叫繃緊的原因是因為採用了更多的邊（大概）
鬆弛 (relaxation)
e(u, v)
u
d_u
d_v + w_{e} < d_u
7122
O
v
u
2
2
d_u = 7122
d_v + w_{uv} = 2 + 2< 7122
- 單點源帶權最短路的基礎
- 如果存在一個中繼邊 使得源點到 的距離 可以縮短（也就是 ）就要更新
- 叫鬆弛不叫繃緊的原因是因為採用了更多的邊（大概）
鬆弛 (relaxation)
e(u, v)
u
d_u
d_v + w_{e} < d_u
7122
O
v
u
2
2
d_u = 4
- 沿用定義 指當前從源點到點 的最短距離
- 暴力一點想想看
- 一開始將源點到所有點的距離設成無限大
- 一直跑過邊集，有得更新就更新
- 沒得更新就結束
- 時間複雜度？
Bellman-Ford
d_i
i
- 不管怎麼說，在程式裡我們都不希望看到 while(true) 這種東西
- 具體來說更新幾次後會是好的？
- 不考慮負環，簡單路徑最多有 條邊
- 更新 次可以確保所有邊都產生影響了
- 時間複雜度
- 有負環(權重加總為負的環)會卡死，可以一直卡在裡面不出來權重就會越來越小
- 如果更新完 仍可以更新，表示存在負環
O(while(true))?
|V|-1
|V|-1
O(|V||E|)
|V|-1
- 只有上一輪被鬆弛過的點會鬆弛到旁邊的點
- 可以用 BFS 的想法，把有鬆弛到的點推進去 queue 裡面，具體來說：
- 取出一個點
- 用這個點鬆弛附近的點
- 把成功鬆弛的點放回去 queue
- queue 空的時候就做完了
- 因為要用到「附近的點」，所以得用鄰接串列
優化
- 這作法叫 SPFA (Shortest Path Faster Algorithm)
- 時間複雜度？
- 這樣沒有變好啊？
- 注意到對於隨機生成的圖可以做到
- 注意，是對於「隨機生成」的圖，比賽要卡也是可以卡成
- 因此，如果比賽的解可能會用到 SPFA ，則它的測資範圍應該要是 Bellman-Ford 可以過的
優化
O(|V||E|)
O(|V|+|E|)
O(|V||E|)
vector<int> Bellman_Ford(int origin, int n, const vector<vector<pair<int, int>>> &graph) {
vector<int> d(graph.size(), INF); // 從源點到各個點的答案
for (int i = 0; i < graph.size(); i++)
for (int v = 0; v < graph.size(); v++)
for (const pair<int, int> &edge: graph[v])
#define edge.second w
#define edge.first u
if (d[v] + w < d[u]) d[u] = d[v] + w;
return d;
}vector<int> SPFA(int origin, const vector<vector<pair<int, int>>> &graph;) {
vector<int> d(graph.size(), INF);
vector<bool> inQueue(graph.size(), false);
queue<int> nexts;
nexts.push(origin);
inQueue[origin] = true;
while (!nexts.empty()) {
int v = nexts.front();
nexts.pop();
inQueue[v] = false;
for (const pair<int, int> &edge : graph[v]) {
#define w edge.second
#define u edge.first
if (d[v] + w < d[u] && !inQueue[u]) {
d[u] = d[v] + w;
nexts.push(u);
inQueue[u] = true;
}
}
}
return d;
}- 在日常生活中，兩點距離不為負比較正常吧
- 如果不帶負權可以做哪些優化
- 注意到如果 已經最小了，用 鬆弛別人得到 都會大等 ，
- 並且，如果用比較大的 來鬆弛 ，怎麼樣都不會鬆弛成功
- 我們可以證明如果每次都選最小的點去鬆弛其他人會是好的！
- 這樣每條邊只會被用到一次
不帶負權
d_u
u
d_v'
d_u
d_u + w = d_v' \geq d_u
d_v, d_v \geq d_u
d_u
- 證明每次選擇當前距離最小的點 u 總是好的
- 注意到如果用其他點鬆弛 u 並不會比較好，因為距離更長
- 用 u 鬆弛其他人的距離也會更長，無法反過來鬆弛 u
- u 是最短路，得證
證明(?
- 剛剛講的東西如何實作？
- 把 BFS 的 queue 換成 priority queue 就可以了
- 在 priority queue 裡面記錄更新後的 d、點 v
- 將一個點取出並標記 visited
- 鬆弛附近的點 v，得到新的 d ，如果有鬆弛把 (d, v) 丟進 priority queue 裡面
- 以沒有被使用過的、距離最小的點繼續
Dijkstra
struct Edge {
int v, w;
friend bool operator<(const Edge& a, const Edge& b) {
return a.w > b.w;
}
};
vector<int> Dijkstra(int origin) {
vector<int> d(graph.size(), INF);
vector<bool> visited(graph.size(), false);
d[origin] = 0;
priority_queue<Edge> nexts;
nexts.push({origin, 0});
while (!nexts.empty()) {
Edge cur = nexts.top();
nexts.pop();
if (visited[cur.v]) continue;
visited[cur.v] = true;
for (const Edge& e : graph[cur.v]) {
if (d[cur.v] + e.w >= d[e.v]) continue;
d[e.v] = d[cur.v] + e.w;
nexts.push({e.v, d[e.v]});
}
}
return d;
}吃點毒
- 兩個部分
- 選當前距離最小點
- 修改點
- 依據實作的不同，有不同的複雜度
- 陣列暴力搜尋最小值：
- binary heap:
- 一些奇怪的堆：
時間複雜度
O(|V| + |E|^2)
O(|V| + |E|\ log\ |E|)
O(|V|\ log\ |V| + |E|)
O(|V|T_{getmin} + |E|T_{modify})
單點源最短路算法比較
Bellman-Ford
處理負環
處理負權
帶環
時間複雜度
Dijkstra
處理負環
處理負權
帶環
時間複雜度
DAG 上最短路
處理負環
處理負權
帶環
時間複雜度
帶負權/負環時用
O(|V||E|)
一般情況最常用
補充
O(|E|\ log\ |E|)
O(|V|+|E|)
- Floyd-Warshall
- 開二維陣列記錄每個點對 之間的最短路
- 不要懷疑，DP
- 令 是 用前 個點作中繼點的最短距離
- 複雜度
- 可以滾動
全點對最短路
dp[u][v][i+1] = min(dp[u][v][i], dp[u][i][i] + dp[i][v][i])
dp[u][v][i]
(u, v)
(u, v)
O(|V|^3)
i
一樣，處理不了負環
但是負權會是好的
vector<vector<int>> Floyd_Warshall(const vector<vector<pair<int, int>>> &graph) {
vector<vector<int>> result(graph.size(), vector<int>(graph.size(), INF));
for (int i = 0; i < graph.size(); i++) result[i][i] = 0;
for (int u = 0; u < graph.size(); u++)
for (const auto &[v, w] : graph[u])
result[u][v] = w;
for (int k = 0; k < graph.size(); k++)
for (int u = 0; u < graph.size(); u++)
for (int v = 0; v < graph.size(); v++)
result[u][v] = min(result[u][v], result[u][k] + result[k][v]);
return result;
}併查集
Disjoint Set Union Algorithm, DSU
「我是你今晚的噩夢。」
「參加資讀就別想逃過我的魔爪。」
Tarjan
– Robert Endre Tarjan,
沒有說過
「不少他發明的算法都以他的名字命名，以至於有時會讓人混淆幾種不同的算法。」
– 維基百科
Dis - 不, Joint - 共同, Set - 集合
"Dis" "joint" "set"
有交集
Dis - 不, Joint - 共同, Set - 集合
"Dis" "joint" "set"
不交集
簡單來說，各集合彼此之間沒有交集
- 一個資料結構，專門處理這種集合的問題
- 各集合沒有共同元素
- 一個元素必定屬於其中一個集合
- 有哪些性質你希望可以套用在這種資料結構上的？
- 它應該支援哪些操作？
併查集
- 一個標準的併查集，應該支援
- 查詢
- 查詢一個元素所在的集合，回傳一個集合的代表元素
- 合併
- 合併兩個集合
- 查詢
- 其他可以支援的操作
- 查詢目前有幾個集合
- 每個集合有幾個元素
併查集
- 話是這麼說沒錯，但為什麼不是在資結教？
因為這和圖論關係大啊廢話
- 如果我們將有邊連在一起的點視在同一個集合
- 查詢：回傳一個點作為代表元素
- 合併：加入一條邊
- 可以查詢兩個點是否連通
- 連通分量
圖論上
- 令 為 所在集合的代表元素
- 我們假設一開始有 n 個集合
- 每個集合內都只有一個元素，即
實作
1
q(i)
i
q(i) = i
2
0
3
4
- 令 為 所在集合的代表元素
- 我們假設一開始有 n 個集合
- 每個集合內都只有一個元素，即
- 合併兩集合時要怎麼選擇代表元素？
實作
1
q(i)
i
q(i) = i
2
0
3
4
- 令 為 所在集合的代表元素
- 我們假設一開始有 n 個集合
- 每個集合內都只有一個元素，即
合併兩集合時要怎麼選擇代表元素？- 合併兩個點要怎麼選擇代表元素？
實作
1
q(i)
i
q(i) = i
2
0
3
4
- 令 為 所在集合的代表元素
- 我們假設一開始有 n 個集合
- 每個集合內都只有一個元素，即
- 合併兩個點要怎麼選擇代表元素？
- 不如令 ？
實作
1
q(i)
i
q(i) = i
2
0
3
4
q(v) = u
- 令 為 所在集合的代表元素
- 我們假設一開始有 n 個集合
- 每個集合內都只有一個元素，即
- 合併兩個點要怎麼選擇代表元素？
- 不如令 ？
實作
1
q(i)
i
q(i) = i
2
0
3
4
q(v) = u
q(1) = 0
- 令 為 所在集合的代表元素
- 我們假設一開始有 n 個集合
- 每個集合內都只有一個元素，即
- 合併兩個點要怎麼選擇代表元素？
- 不如令 ？
實作
1
q(i)
i
q(i) = i
2
0
3
4
q(v) = u
q(1) = 0
q(2) = 1
- 令 為 所在集合的代表元素
- 我們假設一開始有 n 個集合
- 每個集合內都只有一個元素，即
- 合併兩個點要怎麼選擇代表元素？
- 不如令 ？
實作
1
q(i)
i
q(i) = i
2
0
3
4
q(v) = u
q(1) = 0
q(2) = 1
啊啊爛了，1 和 2 回傳的代表元素不同
- 令 是 指向它的代表元素的「過程」？
- 什麼意思？
- 如果目前的元素還指向其他點，就要繼續追查下去！
- 這樣代表元素唯一嗎？
修改 q(i) 定義
1
q(i)
i
2
0
3
4
q(1) = 0
q(2) = 1
查詢
struct DSU {
vector<int> master;
DSU(int n) {
master.resize(n);
for (int i = 0; i < n; i++) master[i] = i;
}
int find(int i) {
if (master[i] == i) return i;
return find(master[i]);
}
};- 如果有人特別麻煩，弄出了以下的東西：
一些奇怪例外
1
2
0
q(1) = 2
q(2) = 0
q(0) = 1
- 如果有人特別麻煩，弄出了以下的東西：
- 你可以照 的想法走，一律把數字小接往數字大
- 有必要嗎？
- 如果在每次合併時就看看兩個點是否在同一集合就沒這問題了
- 或者，利用源頭合併就沒問題了
一些奇怪例外
1
2
0
q(1) = 2
q(2) = 0
q(0) = 1
struct DSU {
void combine(int a, int b) {
master[find(a)] = find(b);
}
};合併
看起來的樣子
0
1
2
4
3
1
3
看起來的樣子
0
1
2
4
3
Merge(2, 3)
1
- 類似二元搜尋樹，這東西也會退化：
- 查詢變成 了
問題
0
1
2
3
O(n)
- 類似二元搜尋樹，這東西因為沒有環所以其實是很多棵樹(森林)
- 所以如果能修正樹高，搜尋的複雜度就可以降低
修正樹高
0
1
2
3
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 1
q(3) = 2
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 1
q(3) = 2
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 1
q(3) = 2
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 1
q(3) = 2
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 1
q(3) = 2
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 1
q(3) = 2
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 0
q(3) = 2
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 0
q(3) = 0
查詢完後有效降低樹高了！
- 最簡單的想法：既然查詢同一條路徑會有同樣的答案，那每次查完就把整條路徑更新成答案
壓縮路徑
0
1
2
3
q(0) = 0
q(1) = 0
q(2) = 0
q(3) = 0
查詢完後有效降低樹高了！
但這樣單次查詢還是 O(n) 耶...
- 不只看「單次」操作複雜度，而是操作好幾次後平均
- 聚集法：T(n)/操作次數
- 記帳法：Credit
- 位能法：位能函數
- 一般是考慮最壞情況
- 併查集使用路徑壓縮後單次操作降為
- 我不會證明
均攤分析
O(log_{(1+\frac {Q}{|V|})}|V|)
- 啟發式算法：把奇怪的東西依照經驗用在一起，唬爛一下感覺複雜度不會爛就是了(?
- 在不需要精確解的情況下，不需要那麼多時間空間的算法
- 如果你覺得我講了和沒講一樣，恭喜你理解了它的精髓
啟發式合併
- 我們想要讓樹的高度降低，其實可以從合併時下手
- 怎麼合併是好的？
啟發式合併
樹高：根到最遠點路徑長
h_1
h_2
- 我們想要讓樹的高度降低，其實可以從合併時下手
- 怎麼合併是好的？
啟發式合併
樹高：根到最遠點路徑長
h_1
h_2
- 我們想要讓樹的高度降低，其實可以從合併時下手
- 怎麼合併是好的？
啟發式合併
樹高：根到最遠點路徑長
新樹高：
h_1
h_2
max(h_1, h_2 + 1)
- 我們想要讓樹的高度降低，其實可以從合併時下手
- 怎麼合併是好的？
- ：讓 比 大，樹高就不會增加
- 在樹根記錄那棵樹目前的高度
- 複雜度？
啟發式合併
h_2
max(h_1, h_2 + 1)
h_2
h_1
h_1
- 假設達到高度 最少要經過 次合併
- 觀察前幾項，0, 1, 3, 7, 15, 31...
- 樹高不超過 ，因此查詢複雜度
複雜度分析
h
f(h)
f(h + 1) = 2f(h) + 1
f(1) = 0
f(h) = 2^h - 1,\ h = log(f(h) + 1) = log\ |V|
\lceil log(|V|) \rceil
O(log\ |V|)
- 把兩種優化套在一起
- 時間複雜度？
- 我說過了，我不會證明
- 什麼是
- 阿克曼函數的反函數
- 阿克曼函數： ，共 x 個 2
- 反函數： ，也就是說，這東西很小
- 阿克曼函數的反函數
もっと速く
O(\alpha (|V|))
\alpha (|V|)
\Alpha (x) = 2^{2^{2^{...}}}
\alpha (\Alpha(x)) = x
struct DisjointSet {
vector<int> master, depth;
DisjointSet(int n) {
master.resize(n);
depth.resize(n, 0);
for (int i = 0; i < n; i++) master[i] = i;
}
int find(int n) {
if (n == master[n]) return n;
return (master[n] = find(master[n]));
}
void combine(int a, int b) {
a = find(a), b = find(b);
if (a == b) return;
if (depth[a] < depth[b]) swap(a, b);
else if (depth[a] == depth[b]) depth[a]++;
master[b] = a;
}
};綜合
APCS 2023 十月場 P3 / ZJ m372
最小生成樹
Minimum Spanning Tree, MST.
- 考慮以下問題：
- 有 n 個地點需要(有線)網路，其中可以連接 m 條可能的邊，每條邊有價格 ，求總價格最小的做法
- 這個問題有哪些限制？
- 這個問題的解是原圖的一個子圖，並且點集與原圖相等
- n 個點都需要被至少一條邊連通
- 顯然，在正常情況( )下，它會是一棵樹
- 解是唯一的嗎？
最小生成子圖
w_i
w_i > 0
- 環性質
- 對於圖上任一個環 C 中最大的邊 e 一定不在最小生成樹中
- 反證法
- 如果 e 在最小生成樹 T 中，刪除 e 將會使 T 分裂成兩個子樹
- 必定存在 C 中另一邊 e' 使得兩個子樹連通
- 兩子樹權重和不變，但 e 被換成更小的 e'
- 新的生成樹 T' 權重和更小，矛盾
Cycle Property
- 如果最大權不只一個？
- MST 不是唯一的，最大權邊一定不在某個 MST 中
Cycle Property
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
- 如果在加入邊時，就偵測是否會形成環？
- 在原圖無環的情況下，加入一條邊最多可能會形成幾個環？
- 怎麼判斷加入的邊會不會形成環？
- 利用剛剛學的併查集，看看兩個點是不是原本就連通！
- 如何尋找環中最大的邊？
Kruskal
- 我們不如保證加入的邊一定是最大的
- 怎麼做？
- 排序！
- 依照邊權由小到大加入，如果會形成環就不採用這個邊
- 正確性
- 保證生成出的圖會是無環的 (樹)
- 不採用的邊都是保證不在某個 MST 中的
- 所以保證生成出的是某個 MST
Kruskal
- 複雜度
- 對邊排序：
- 對每個邊使用併查集：
- 總複雜度：
Kruskal
O(|E|\ log\ |E|)
O(|E|\ \alpha (|V|))
O(|E|\ log\ |E|)
0
1
2
3
4
5
0
1
2
3
4
5
1
0
1
2
3
4
5
1
2
0
1
2
3
4
5
1
2
3
0
1
2
3
4
5
1
2
3
4
0
1
2
3
4
5
1
2
3
4
5
0
1
2
3
4
5
1
2
3
4
5
6
0
1
2
3
4
5
1
2
3
4
5
6
7
0
1
2
3
4
5
1
2
3
4
5
6
7
8
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
namespace MST {
struct DSU {
vector<int> master, depth;
DSU(int n) {
master.resize(n);
depth.resize(n, 0);
for (int i = 0; i < n; i++) master[i] = i;
}
int find(int n) {
return (n == master[n]) ? n : (master[n] = find(master[n]));
}
void combine(int a, int b) {
a = find(a), b = find(b);
if (a == b) return;
if (depth[a] < depth[b]) swap(a, b);
else if (depth[a] == depth[b]) depth[a]++;
master[b] = a;
}
};
vector<vector<pair<int, int>>> Kruskal(const vector<vector<pair<int, int>>> &graph) {
DSU components(graph.size());
vector<pair<int, pair<int, int>>> edges; // {w, {u, v}}
vector<vector<pair<int, int>>> result(graph.size());
for (int u = 0; u < graph.size(); u++)
for (const auto &[v, w] : graph[u])
edges.push_back({w, {u, v}});
sort(edges.begin(), edges.end());
for (const auto &[w, e] : edges) {
#define u e.first
#define v e.second
if (components.find(u) != components.find(v)) {
components.combine(u, v);
result[u].push_back({v, w}), result[v].push_back({u, w});
}
}
#undef u
#undef v
return result;
}
}事實上如果原本圖就用邊串列存會方便很多
如果用鄰接串列存圖建議用下一個寫法
- 割性質
- 什麼是割？
- 點集分為二子點集
- 割集（也就是跨越兩個點集的邊的集合）中邊權最小的一定在 MST 裡
- 反證法
left as an exercise for the reader
Cut Property
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
- 我們可以枚舉一個點集的子集，這樣割集是唯一的
- 是沒錯，但聽起來就很爛
- 有沒有什麼改良的方法？
- 觀察小的割集長怎樣
- 當其中一個點集 V' 只有一個點？
- 連出去的最小邊一定沒問題
Prim's Algorithm
0
1
2
3
4
5
1
2
3
4
6
7
8
9
5
- 接著我們要避免之後的割集考慮到這條邊
- 那我們將這條邊連到的點加入 V' 吧
- 這樣我們又有一個新的點集
- 如此迭代就可以了
- 要怎麼找割集？
- 每次迭代都暴力找？
- 老方法了，有新的邊都記錄下來
- 每次都要求最小值
- priority queue
Prim's Algorithm
0
1
2
3
4
5
1
2
3
4
6
7
8
9
5
- 時間複雜度？
- 剛剛那樣的實作是
- 用其他堆可以
Prim's Algorithm
0
1
2
3
4
5
1
2
3
4
6
7
8
9
5
O(|E|\ log\ |E|)
O(|E| + |V|\ log\ |V|)
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
1
2
3
4
5
6
7
8
9
typedef pair<int, int> pii;
typedef pair<int, pii> pipii;
typedef vector<vector<pair<int, int>>> Graph;
Graph Prim(const Graph &graph) {
// edge: {w, v}
Graph result(graph.size());
vector<bool> visited(graph.size(), false);
priority_queue<pipii, vector<pipii>, greater<pipii>> nexts;
#define w first
#define u second.first
#define v second.second
visited[0] = true;
for (const auto &[nxt_w, nxt_v] : graph[0])
nexts.push({nxt_w, {0, nxt_v}});
while (!nexts.empty()) {
auto cur_edge = nexts.top();
nexts.pop();
if (visited[cur_edge.v]) continue;
visited[cur_edge.v] = true;
result[cur_edge.u].push_back({cur_edge.w, cur_edge.v});
result[cur_edge.v].push_back({cur_edge.w, cur_edge.u});
for (const auto &[nxt_w, nxt_v] : graph[cur_edge.v])
nexts.push({nxt_w, {cur_edge.v, nxt_v}});
}
#undef u
#undef v
#undef w
return result;
}