dynamic minimum spanning tree
TRANSCRIPT
Dynamic Minimum Spanning Tree
2018๋ 6์ 10์ผ ์ผ์์ผ
์ผ์ฑ์ํํธ์จ์ด๋ฉค๋ฒ์ฝ ๊ตฌ์ฌํ (koosaga.com)
Contents
1 ์๊ฐ 1
2 Special Case : Online Incremental 2
2.1 ์ฐ์ต ๋ฌธ์ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 General Case : Offline Algorithm 4
3.1 ์ฐ์ต ๋ฌธ์ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4 General Case : Online Algorithm 8
5 References 9
Dynamic Minimum Spanning Tree
1 ์๊ฐ
N๊ฐ์ ๋์๋ก ์ด๋ฃจ์ด์ง ๊ตญ๊ฐ๋ฅผ ์๊ฐํด ๋ณด์. ์ฐ๋ฆฌ๋ ์ด ๊ตญ๊ฐ์ ๊ณ ์์ฒ ๋๋ง์ ์ค์น
ํ ๊ณํ์ธ๋ฐ, ๊ณ ์์ฒ ๋๋ง์ ์ค์นํ ์ดํ์๋ ์ด๋ ํ ๋์์์ ์ถ๋ฐํด๋ ๊ณ ์์ฒ ๋๋ง์
์ฌ์ฉํด์ ๋ชจ๋ ๋์์ ๋๋ฌํ ์ ์์ด์ผ ํ๋ค. ์ฐ๋ฆฌ๋ M๊ฐ์ ์ฒ ๋๋ง ํ๋ณด๋ฅผ ๊ฐ์ง๊ณ
์๋๋ฐ, ๊ฐ ์ฒ ๋๋ง์ ์ค์น์ ์ผ์ ํ ๋น์ฉ์ด ๋ค๋ฉฐ, ๋ ๋์๋ฅผ ์๋๋ค. ์ต์ ๋น์ฉ์ผ๋ก
๊ตญํ ๋ฅผ ๊ฐ๋ก์ง๋ฅด๋ ๊ณ ์์ฒ ๋๋ง์ ๊ตฌ์ถํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น?
์ด ๋ฌธ์ ๋ ์ต์ ์คํจ๋ ํธ๋ฆฌ (Minimum Spanning Tree, MST) ๋ผ๊ณ ๋ถ๋ฆฌ๋, ์๊ณ ๋ฆฌ์ฆ
๋ถ์ผ์ ๊ธฐ์ด์ ์ธ ๋ฌธ์ ์ค ํ๋๋ค. ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ ์ต์์ ๋น์ฉ์ผ๋ก โ์ฐ๊ฒฐ์ฑโ์ด๋ผ
๊ณ ํ๋ ์ค์ํ ์ฑ์ง์ ์ด๋ฃจ๊ฒ ํ๋ค๋ ์ ์์ ๋งค์ฐ ์ ์ฉํ๋ค. ๊ทธ ์ฌ์ฉ ์ ์ค ์ผ๋ถ๋ฅผ
๋์ดํ์๋ฉด,
โข ์ ์์์ ๊ฐ์ด ์ต์ ๋น์ฉ์ ๋คํธ์ํฌ๋ฅผ ์ฐพ๋ ํํ์ ๋ฌธ์
โข MST์์ฑ์ง์ํ์ฉํด์๋ค๋ฅธ๋ฌธ์ ์ subroutine์ผ๋ก์ฌ์ฉํ๋๊ฒฝ์ฐ : Christofide
์ 1.5-factor TSP approximation์ด๋, Widest Path Problem ๋ฑ
โข ์ด๋ฏธ์ง ํ๋ก์ธ์ฑ, ํด๋ฌ์คํฐ๋ง, ํ๊ธฐ ๋ถ์ (์ฃผ์ด์ง ์ด๋ฏธ์ง๋ฅผ ๊ฒฉ์ ๊ทธ๋ํ๋ก ๋ณธ ํ,
์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ฌ์ฉํด์ ํด๋ฌ์คํฐ๋งํ๋ ๋ฅ์ ๋ฐฉ๋ฒ๋ค)
โข ๋ฑ๋ฑ...
์ด์๋ํ์์ธํ์ ๋ณด๋ https://en.wikipedia.org/wiki/Minimum_spanning_
tree#Applications ์์ ์ฐพ์ ์ ์๋ค.
MST๋ฅผ ๊ตฌํ๋ ๊ฒ์ Kruskal Algorithm ๋ฑ์ผ๋ก ํด๊ฒฐ๋๋ ์ ์๋ ค์ง ๋ฌธ์ ์ด๋ค. ํ์ง๋ง
์ค์ ๋ก๋ ์ด๋ณด๋ค ๋ ๋ณต์กํ ํํ์ ์์ฉ ์ํฉ์ด ๋ฐ์ํ๋ค : ์ด ์ค ํํ ๋ณด์ด๋ ๊ฒฝ์ฐ๋,
๋ฐ๋ก ๊ทธ๋ํ์ ๋ณ๊ฒฝ์ด ๊ฐํด์ง๋ ์ํฉ์์์ ์ต์ ์คํจ๋ ํธ๋ฆฌ์ ๋ณํ์ด๋ค. ๋คํธ์ํฌ
ํต์ ์ ์๋ฆฝํ ๋ ๋ ์ ์ ์ ์ค๊ฐ๋ ํจํท์ ํฌ๊ธฐ๊ฐ ๋ฌ๋ผ์ง๊ฑฐ๋, ์ด๋ฏธ์ง ํด๋ฌ์คํฐ๋ง์
ํ ๋์ฃผ์ด์ง์ด๋ฏธ์ง์๊ตญ์์ ์ธ๋ณํ๊ฐ๊ฐํด์ง๋๋ฑ,๊ธฐ์กด๊ทธ๋ํ์ MST๋ฅผ์๊ณ ์์
๋, โ์กฐ๊ธโ ๋ฌ๋ผ์ง ๊ทธ๋ํ์์์ MST์ ๋ณํ๋ฅผ ์์ธกํ๋ ํํ์ ์์ฉ์ด๋ค.
Dynamic Minimum Spanning Tree
๋จ์ํ์๊ณ ๋ฆฌ์ฆ์๋งค๋ณํ์ดํ์ฒ์๋ถํฐ๋ค์์ผ๋ฐ์ ์ธ์๊ณ ๋ฆฌ์ฆ์ผ๋กMST๋ฅผ๊ณ์ฐํ
๊ฒ์ด๋ค. ์ฃผ์ด์ง๋ ๋ณํ์ ๊ฐ์๋ฅผ O(Q)๊ฐ๋ผ๊ณ ํ๋ฉด, ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ํ ์๊ฐ์ ๋๋ต
O(QM) ๊ฐ๋์ด๋ฉฐ, ๊ทธ๋ํ์ ํฌ๊ธฐ๋ ๋ณํ์ ๊ฐ์๊ฐ ์ถฉ๋ถํ ํฐ ์ํฉ์์ ์ด๋ ์๋นํ
๋นํจ์จ์ ์ด๋ค (100MB๋จ์์์ ๋ ฅ์ด์ฃผ์ด์ง๋ค๋ฉด,์๋ง๋ช๋ฌ์ด๊ฑธ๋ฆด๊ฒ์ด๋ค.).๋๋น ๋ฅธ
ํด๊ฒฐ ๋ฐฉ๋ฒ์ด ์์๊น?
์์์ ์๊ฐํ, ๊ทธ๋ํ์ ์ค์๊ฐ์ผ๋ก ๋ณํ๊ฐ ์ฃผ์ด์ง ๋๋ง๋ค ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ํจ์จ
์ ์ผ๋ก ๊ณ์ฐํด์ผ ํ๋ ๋ฌธ์ ๋ฅผ Dynamic MST ๋ผ๊ณ ๋ถ๋ฅธ๋ค. [1] ๋น์ทํ ํํ์ ๋ฌธ์ ์ธ
Dynamic Shortest Path ๋ฌธ์ ๊ฐ ํจ์จ์ ์ธ ํด๊ฒฐ์ฑ ์ด ์ฝ๊ฒ ๋์ค์ง ์๋ ๋ฐ๋ฉด, Dynamic
MST์ ๊ฒฝ์ฐ์๋ ์ด๋ณด๋ค๋ ํจ์ฌ ๋ ๋ง์ ์ง์ ์ด ์งํ๋ ์ํ์ด๋ค. ์ด ๊ธ์์๋ ์ด๋ฌํ
ํจ์จ์ ์ธ ํด๊ฒฐ์ฑ ๋ช ๊ฐ์ง์ ๋ํด์ ์ดํด๋ณผ ๊ฒ์ด๋ค.
2 Special Case : Online Incremental
Dynamic MST ๋ฌธ์ ์ค์์๋, ๊ทธ๋ํ์ ์ฃผ์ด์ง๋ ๋ณํ์ ์ข ๋ฅ๊ฐ โ๊ฐ์ ์ถ๊ฐโ ๋ฐ์
์กด์ฌํ์ง ์๋ ํน์ํ ์ธ์คํด์ค๋ค์ด ์กด์ฌํ๋ค. ์ด๋ฅผ Incremental Dynamic MST ๋ผ๊ณ
๋ถ๋ฅด์.์ด๋๋ Link-Cut Tree๋ฅผ์ฌ์ฉํ๋ฉด์ฝ๊ฒ๋ฌธ์ ๋ฅผํด๊ฒฐํ ์์๋ค. Link-Cut Tree
๋ ๋ณต์กํ ์๋ฃ๊ตฌ์กฐ์ด์ง๋ง, ์๊ณ ๋ฆฌ์ฆ์ ๋ฐฉ๋ฒ ์์ฒด๋ MST์ ๊ธฐ์ด์ ์ธ ์ฑ์ง์ ๊ทธ๋๋ก
์ฌ์ฉํ๋ ๋จ์ํ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
์ด์๊ณ ๋ฆฌ์ฆ์๊ฐ๊ฐ์ ์ถ๊ฐ์ง์๋ฅผ amortized O(logN)์์ํํ ์์์ผ๋ฉฐ,์๋๋์จ
์๊ณ ๋ฆฌ์ฆ๋ค์ด ๋ชจ๋ ์ง์๋น O(log2N) ์ด์์ ์๊ฐ์ ์๋ชจํ๋ค๋ ์ ์ ๋น๊ตํด ๋ดค์ ๋
์ด ์ ์์ ํ์คํ ์ฐ์๋ฅผ ์ง๋๋ค. ์ค์ ๋ก N,Q = 100000 ๊ฐ๋์ ์ธ์คํด์ค์์ ๊ฐ๋จํ
ํ ์คํธํด๋ณธ๊ฒฐ๊ณผ,์๋์๊ฐํ Offline Algorithm์๋นํด์์ฝ 3๋ฐฐ์ ๋์์ฑ๋ฅ์ฐจ์ด๋ฅผ
๋ณด์๋ค. [2]
๋ํ, ์ด ์๊ณ ๋ฆฌ์ฆ์ ์จ๋ผ์ธ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ฌ๋ฌ ๊ฐ์ ์ง์๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ ์ค์์ ์ค
ํ๋ผ์ธ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ์๋ค์ด ์๋ ค์ ธ ์๋๋ฐ, ์ด ์ฒ๋ฆฌ ๋ฐฉ์์ ์ง์๋ฅผ ์ ๋ถ ๋ฐ์ ์ดํ
์ด ์ง์๋ค์ ํ๊บผ๋ฒ์ ์ฒ๋ฆฌ (Batch process) ํ๋ ์์ผ๋ก ์๊ฐ ๋ณต์ก๋๋ฅผ ์ค์ด๋ ๋ฐฉ์
์ด๋ค. ์คํ๋ผ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ ํด๊ฒฐํ ๊ฒฝ์ฐ ํจ์ฌ ๋ ๊ฐ๋จํ๊ฒ ํ๋ฆฌ๋ ๋ฌธ์ ๋ค์ด
Dynamic Minimum Spanning Tree
์ฌ๋ฟ ์๋ ค์ ธ ์์ผ๋, ์ด๋ค์ ๊ฐ๊ฐ์ ์ง์์ ๋ํด์ ์ฆ๊ฐ์ ์ธ ์๋ต์ ๋ด๋์ง ๋ชปํ๋ค๋
ํ๊ณ์ ์ ๊ฐ์ง๊ณ ์๋ค. ์ด ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๊ฐ์ ์ง์์ ๋ํด์ ๊ทธ๋ ๊ทธ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ด๋๋
์จ๋ผ์ธ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก, ์ด๋ฌํ ํ๊ณ์ ์์ ๋น๊ต์ ์์ ๋กญ๋ค.
์๊ณ ๋ฆฌ์ฆ์ ์๊ฐํ๊ธฐ ์์์, ์ Incremental Dynamic MST ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฐ๋จํ
์๊ณ ๋ฆฌ์ฆ์์ ์ํ๋ค.์ด์๊ณ ๋ฆฌ์ฆ์์ฆ๋ช ์,์ด๋ ํ๊ฐ์ e๊ฐMST์์ํ๋ฒ์ฌ๋ผ์ง๋
์ผ์ด ์๋ค๋ฉด ๋ค์ ์ถ๊ฐ๋์ง ์๋๋ค๋ ์ฑ์ง์ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ ํ ์ ์๋ค.
Algorithm 1 Incremental Dynamic MST, O(N) per query
1: procedure DMST1 Naive(S)
2: ์ด๊ธฐ ๊ทธ๋ํ G์ ์ต์ ์คํจ๋ ํธ๋ฆฌ T๋ฅผ ๊ตฌํจ.
3: for ๊ฐ๊ฐ์ ์ฟผ๋ฆฌ e = {ui, vi}, ui 6= vi ์ ๋ํ์ฌ do
4: f = (T ์์์ ui, vi ๋ฅผ ์๋ ๊ฒฝ๋ก ์์์ ๊ฐ์ค์น ์ต๋์ธ ๊ฐ์ )
5: if weight(f) > weight(e) then
6: T โ RemoveEdge(T, f)
7: T โ AddEdge(T, e)
8: end if
9: end for
10: end procedure
์ด์ Link-Cut Tree๋ฅผ ํตํด์ ์ด๋ฅผ ์ต์ ํ ํ๋ ๊ฒ์ด ๋จ์๋ค. Link-Cut Tree๋ ํฌ๋ ์ค
ํธ์์ ํจ์จ์ ์ผ๋ก ๊ฐ์ ์ถ๊ฐ / ์ญ์ ์ฐ์ฐ์ ์ํํ ์ ์์ผ๋ฉฐ, ๊ฐ๊ฐ์ ๊ฒฝ๋ก๋ฅผ Splay
Tree๋ผ ํ๋ ์ด์ง ํ์ ํธ๋ฆฌ๋ก ๊ด๋ฆฌํ๊ธฐ ๋๋ฌธ์, ์์์ ๊ฒฝ๋ก์ ๋ํด์ ๊ฒฐํฉ ๋ฒ์น์ด
์ ์ฉ๋๋ ์ฐ์ฐ (ํฉ, ์ต์๊ฐ, ์ต๋๊ฐ, gcd ๋ฑ๋ฑ) ์ ๊ฒฐ๊ณผ๋ฅผ amortized O(lgN) ์ ๊ด๋ฆฌํ
์ ์๋ค. Link-Cut Tree์ ๋ํด์๋ [3]๋ฒ ๋งํฌ์ ๋งค์ฐ ์น์ ํ๊ฒ ์ค๋ช ๋์ด ์์ผ๋ ์ด
๊ธ์ ์ฐธ๊ณ ํ๋ ๊ฒ์ด ์ข์ ๊ฒ์ด๋ค. ๊ณ ๋ก, RemoveEdge,AddEdge ์ฐ์ฐ๊ณผ f๋ฅผ ๊ตฌํ๋
์ฐ์ฐ์ ๋ชจ๋ amortized O(lgN) ์ ํด๊ฒฐํ ์ ์๋ค.
์ด ๋, Link-Cut Tree๋ ์ด ๊ฐ๋ค์ ๊ฐ์ ์ด ์๋ ์ ์ ์ ๊ฐ์ง๊ณ ๋ค๋๋ ๊ฒ์ ์ ์ํด์ผ
ํ๋ค. ์ด๋ ๊ฐ์ ์ ๊ฐ์ ๊ทธ๋๋ก ์ ์ฅํ ์ ์๊ธฐ ๋๋ฌธ์, ๊ฐ์ e = {u, v}๋ฅผ ๊ธธ์ด 2์ ๊ฒฝ
๋ก P = {u, eโฒ, v} ๋ก ์ชผ๊ฐ ํ (subdivide), ๊ฐ์ ์ ๊ฐ์ค์น๋ฅผ ์ฃผ๊ณ , ์ ์ ์๋ min ์ฐ์ฐ์
Dynamic Minimum Spanning Tree
ํญ๋ฑ์์ธ โ ๋ฅผ ์ ์ฅํ๋ ๊ฐ๋จํ ํธ๋ฆญ์ผ๋ก ํด๊ฒฐํ ์ ์๋ค.
2.1 ์ฐ์ต ๋ฌธ์
์ค์ ๊ตฌํ์ ํด ๋ณด๊ณ ์ถ์ ๊ฒฝ์ฐ๋ฅผ ์ํ ์ฐ์ต ๋ฌธ์ ์ด๋ค. ๋์ด๋ ์์ผ๋ก ์ ๋ ฌ๋์ด ์๋ค.
โข https://www.acmicpc.net/problem/10724
โข http://codeforces.com/gym/101047/problem/I
โข https://www.acmicpc.net/problem/15386
โข https://ijpc2012-3.contest.atcoder.jp/tasks/ijpc_animals2
โข http://acm.timus.ru/problem.aspx?space=1&num=2055
โข https://www.codechef.com/MARCH14/problems/GERALD07
3 General Case : Offline Algorithm
์์์๋ ์ธ๊ธํ๋ฏ์ด, ์ฌ๋ฌ ๊ฐ์ ์ง์๊ฐ ์ฃผ์ด์ง ๋ ์ด ์ง์๋ฅผ ํ๊บผ๋ฒ์ ๋ฐ์ ์ดํ ๊ฐ
์ด ์ฒ๋ฆฌ (Batch process) ํ๋ ์คํ๋ผ์ธ ํ์ด๋, ํ์ด์ ๋ฒ์ฉ์ฑ์ ์ค์ด์ง๋ง, ๋ฌธ์ ๋ฅผ
ํด๊ฒฐํ๋ ํจ์ฌ ๋ ๊ฐ๋ ฅํ ํด๊ฒฐ ๋ฐฉ์์ด ๋๋ค. Dynamic MST์์ ์คํ๋ผ์ธ ํ์ด ๋ฐฉ์
์ ์ ์ฉํ๋ฉด, ์ ์จ๋ผ์ธ ํ์ด์ ๋ณต์กํ ์๋ฃ๊ตฌ์กฐ (Link-Cut Tree) ๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋
O(Q log2N) ์ ๋น ๋ฅธ ์๊ฐ ๋ณต์ก๋์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค. [4]
์ด ์คํ๋ผ์ธ ์๊ณ ๋ฆฌ์ฆ์, ๊ฐ์ ์ ๊ฐ์ค์น๋ฅผ ๋ฐ๊พธ๋ ํํ์ ์ง์๊ฐ ๋ค์ด์์ ๋, ๊ฐ ์ง
์์ ๋ฐ๋ผ์ ๋ณ๊ฒฝ๋ MST๋ฅผ ๊ตฌํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ด๋ฐ ์์ผ๋ก ๊ฐ์ ์ ๊ฐ์ค์น๋ฅผ
๋ฐ๊พผ๋ค๋ ํํ์ ๋ชจ๋ธ๋ง์ ํจ์ฌ ๋ ๋ค์ํ ํํ์ ๊ทธ๋ํ ๋ณ๊ฒฝ์ ๋์ํ ์ ์๋ค. ์๋ฅผ
๋ค์ด ๊ฐ์ ์ถ๊ฐ / ์ ๊ฑฐ๋ ๊ฐ์ ์ ๊ฐ์ค์น๋ฅผโโ x, xโโ ๋ก ๋ฐ๊ฟ์ค์ผ๋ก์จ ๊ฐ๋ฅํ๋ฉฐ,
๊ฐ์ ์ ์ถ๊ฐ / ์ ๊ฑฐ๊ฐ ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์ ์ ์ถ๊ฐ / ์ ๊ฑฐ๋ ํด๋น ์ ์ ์ ์ธ์ ํ ๊ฐ์ ์
์ ๋ถ ์ถ๊ฐ / ์ ๊ฑฐํ๋ ์์ผ๋ก ํํ ๊ฐ๋ฅํ๋ค.
Dynamic Minimum Spanning Tree
์คํ๋ผ์ธ ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ์์ ๋ถํ ์ ๋ณต์ ๊ธฐ๋ฐํด ์๋ค. ์๊ณ ๋ฆฌ์ฆ์
์ฟผ๋ฆฌ ์์๋ฅผ ์๊ฐ ์์ผ๋ก ๋์ดํ ํ, ์ด ์์์ ๊ธฐ๋ฐํด์ ๋ถํ ์ ๋ณต์ ์ํํ๋๋ฐ,
solve(G, [L,R], T, E) ๋ผ๋ ํจ์๋ :
โข G๋ผ๋ ๊ทธ๋ํ์ ๋ํด์
โข [L,R] ๊ตฌ๊ฐ์ ์๋ ์ฟผ๋ฆฌ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๊ณ ํ๋ฉฐ,
โข MST์ ๋ค์ด๊ฐ๋ ๊ฒ์ด ํ์คํ ๊ฐ์ ์ ์งํฉ์ด T์ด๊ณ ,
โข MST์ ๋ค์ด๊ฐ ๊ฐ๋ฅ์ฑ์ด ์กด์ฌํ๋ ๊ฐ์ ์ ์งํฉ์ด E์ธ (๋ค๋ง T์ ๋ค์ด๊ฐ๋ ๊ฐ์
์ E์ ๋ค์ด๊ฐ์ง ์๋๋ค.)
์ฌ๊ทํจ์์ด๋ค.๋ง์ฝ์ L = R์ผ๊ฒฝ์ฐ,์ฐ๋ฆฌ๋MST์๋ค์ด๊ฐ๋๊ฒ์ดํ์คํ๊ฐ์ ์งํฉ
T๊ณผ ๊ฐ๋ฅ์ฑ์ด ์กด์ฌํ๋ ๊ฐ์ ์ ์งํฉ E๋ฅผ ์ ์ ์๊ณ , (๊ธฐ๋ํ๊ฑด๋ฐ) E์ ํฌ๊ธฐ๊ฐ ๊ฑฐ์
๋น์ด์์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์, T์์ ํ์ํ ์ ๋ณด๋ฅผ ๋ชจ๋ ์ ์ ์๋ค.
์ฌ์ค, ์๊ฐ ๋ณต์ก๋์ ๋ํ ๊ด์ฌ์ด ์๋ค๋ฉด, ๊ทธ๋ฅ ๋จ์ํ T = โ , E = E(G) (E(G) = G
์ ์์ง ์งํฉ) ๋ก ๋๊ณ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋ ์ ํ ์๊ด์ด ์๋ค. L = R์ผ ๊ฒฝ์ฐ ๋จ์ํ T
๋ก ์์๋ธ ๊ฒ ์์ผ๋ฉฐ, E์ ๋ค์ด๊ฐ ๊ฐ๋ฅ์ฑ์ด ์กด์ฌํ๋ ๊ฐ์ ๋ค์ด ๋น์ฐํ ์ ๋ถ ๋ค์ด๊ฐ
์๊ธฐ ๋๋ฌธ์, MST๋ฅผ ๊ทธ๋ ๊ทธ๋ ๊ตฌํด์ฃผ๋ฉด ๋๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๋ฅผ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํํํ๋ฉด
๋ค์๊ณผ ๊ฐ๋ค.
Algorithm 2 Poor Manโs Offline Dynamic MST, O(Mฮฑ(M)) per query
1: procedure solve(G, [L,R], T, E)
2: if L = R then
3: E๋ฅผ ํ ๋๋ก ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ๊ตฌํจ.
4: else
5: solve(G, [L, (L+R)/2], T, E)
6: solve(G, [(L+R)/2 + 1, R], T, E)
7: end if
8: end procedure
9: Call solve(G, [0, Qโ 1], โ , E(G))
Dynamic Minimum Spanning Tree
๋น์ฐํ์ง๋ง, ์ด ์๊ณ ๋ฆฌ์ฆ์ ๋๋ฆฌ๊ณ , ๋ถํ ์ ๋ณต์ ํ๋ ์๋ฏธ๋ ์๋ค. ๊ณ ๋ก ์ฐ๋ฆฌ๋ ์ฌ๊ท
๋ฅผ์งํํ๋๊ณผ์ ์์์ถฉ๋ถํ T๋ฅผํฌ๊ฒ์ ์ง์ํค๊ณ ,์ถฉ๋ถํ E๋ฅผ์๊ฒ์ ์ง์์ผ์ผํ๋ค.
ํํธ, [L,R]๊ตฌ๊ฐ์์๊ฐ์ค์น๊ฐ๋ฐ๋๋์์ง๋ค์๋ง์์ผ RโL+1๊ฐ์กด์ฌํ๋ค.์ด๋ค์
๊ฐ์ค์น์์๊ด์์ดํญ์์ต์์คํจ๋ํธ๋ฆฌ๋ฅผ์ด๋ฃจ๋์์ง๋ค์๊ตฌํ ์์์๊น?์๋๋ฉด,
์ด๋ค์ ๊ฐ์ค์น์ ์๊ด์์ด ํญ์ ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃจ์ง ์๋ ์์ง๋ค์ ๊ตฌํ ์ ์
์๊น? ๊ทธ๋ฆฌ๊ณ ์ด๋ค์ ๊ฐ์๋ ์ผ๋ง๋ ๋ ๊น? ํญ์ ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃจ๋ ์์ง๋ค์
T์ ๋ฃ์ด์ฃผ๋ฉด ๋๊ณ , ๊ทธ๋ ์ง ์์ ์์ง๋ค์ E์์ ์ ๊ฑฐํด ์ฃผ๋ฉด ๋๋ค.
์ด์ , S([L,R]) ์ ๊ตฌ๊ฐ [L,R] ์์ ๊ฐ์ค์น๊ฐ ๋ฐ๋๋ ์์ง๋ค์ ์งํฉ์ด๋ผ๊ณ ํ์. ๋ค์
Lemma๋ค์ ํตํด์ ์ ๊ด์ฐฐ๋ค์ ๊ตฌ์ฒดํ์ํฌ ์ ์๋ค.
Lemma 1. T โช E์์ S([L,R]) ์ ์ํ๋ ์์ง๋ค์ ๊ฐ์ค์น โโ ๋ฅผ ๋งค๊ธด ํ ์ต์ ์ค
ํจ๋ ํธ๋ฆฌ๋ฅผ ๊ตฌํ์ ๋, ์ด ์คํจ๋ ํธ๋ฆฌ์ ์ํ๋ ์์ง๋ค์ ์ด๋ ํ ์ฟผ๋ฆฌ์์๋ ๋ฌด์กฐ๊ฑด
์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃฌ๋ค.
Lemma 2. T โชE์์ S([L,R])์์ํ๋์์ง๋ค์๊ฐ์ค์นโ์๋งค๊ธดํ์ต์์คํจ๋
ํธ๋ฆฌ๋ฅผ ๊ตฌํ์ ๋, ์ด ์คํจ๋ ํธ๋ฆฌ์ ์ํ์ง ์๋ ์์ง๋ค์ ์ด๋ ํ ์ฟผ๋ฆฌ์์๋ ์ ๋
์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃจ์ง ์๋๋ค.
Lemma 3. ํธ์์ G๊ฐ ์ฐ๊ฒฐ ๊ทธ๋ํ๋ผ๊ณ ๊ฐ์ ํ์. Lemma 1๊ณผ 2๋ฅผ ์ ์ฉ์ํจ ์ดํ,
E์ ํ๋ณด๋ก ๋จ๋ ์์ง๋ ๋ง์์ผ O(Rโ L+ 1) ๊ฐ์ด๋ค.
Proof. E์์ ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃจ๋ ๊ฐ์ ๋ค ์ค, ๊ฐ์ค์น โโ์ ๊ฐ์ ์ ๋ง์์ผ
O(R โ L + 1) ๊ฐ ์๊ณ , ๋๋จธ์ง ๊ฐ์ ๋ค์ ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃธ์ด ํ์คํ ๊ฐ์ ๋ค์ด
๋ค.์ดํ์คํ๊ฐ์ ๋ค๋ก์ด๋ฃจ์ด์งํฌ๋ ์คํธ์์,๊ฐ์ปดํฌ๋ํธ๋ฅผํ๋์์ ์ ์ผ๋ก๋ฌถ์ด์
์๊ฐํ์. ๊ฐ์ ์ ๊ฐ์ค์น โ๋ฅผ ๋งค๊ฒผ๋ค๋ ๊ฒ์ ๊ทธ๋ํ์์ ์์ด๋ค๋ ๊ฒ๊ณผ ํฐ ์ฐจ์ด๊ฐ ์
์ผ๋, ์ด๋ ๊ฒ ์ปดํฌ๋ํธ๊ฐ ์์ถ๋ ๊ทธ๋ํ์์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃจ๋ ๊ฐ์ ๋ค๋ง์ด E์
ํ๋ณด๋ก ๋จ๊ฒ ๋๋ค. ์ปดํฌ๋ํธ๊ฐ ์์ถ๋ ๊ทธ๋ํ๋ ๋ง์์ผ RโL+ 1 ๊ฐ์ ์ ์ ์ ๊ฐ์ง๋,
์คํจ๋ ํธ๋ฆฌ๋ฅผ ์ด๋ฃจ๋ ๊ฐ์ ๋ R โ L+ 1๊ฐ์ด๋ค. ์ฌ๊ธฐ์ S([L,R]) ์ ์ํ๋ ์์ง๋ค์
๋ํด์ผ ํ์ง๋ง, ์ฌ์ ํ O(Rโ L+ 1) ์ ํฌ๊ธฐ๊ฐ ๋์จ๋ค.
Dynamic Minimum Spanning Tree
์ด์ , ๊ฐ๊ฐ์ ์ฌ๊ท ํจ์ ์ฝ์์ |E| โค O(R โ L + 1) ์ด๋ผ๋ ์ ์ฝ ์กฐ๊ฑด์ ๊ฐ์ ํ ์
์๊ฒ ๋์๋ค. ์ฆ, ์์์ ๋งํ ๊ณ์ฐ์ ๋น ๋ฅด๊ฒ ์ํํ ์ ์๋ค๋ฉด ๋ฌธ์ ๋ฅผ ์ถฉ๋ถํ ๋น ๋ฅด๊ฒ
ํด๊ฒฐํ ์ ์๋ ๊ฒ์ด๋ค. ํ์ง๋ง, T์ ํฌ๊ธฐ๊ฐ O(N) ์ ์ก๋ฐํ๊ธฐ ๋๋ฌธ์, ์ค์ ๋ก ์์
๊ณผ์ ์์ํํ๋๋ฐ๋ O(|T |+ |E|) โค O(N+RโL+1)์์๊ฐ์ด์๋ชจ๋๋ค. (์ค์ ๋ก๋
logarithmic factor๊ฐ ๋ ๋ถ์ ์๋ ์๋ค.)
Algorithm 3 Lesser Poor Manโs Offline Dynamic MST, O(N) per query
1: procedure solve(G, [L,R], T, E)
2: if L = R then
3: ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ๊ตฌํจ (|E| = 1์ด๊ธฐ ๋๋ฌธ์ ๋จ์ ์ผ์ด์ค ๋ถ์.)
4: else
5: T,E, S([L,R) ์ ์ฌ์ฉํด์ ๋ ํฐ T โฒ์ ๋ ์์ E โฒ๋ฅผ ํ์ฑ
6: solve(G, [L, (L+R)/2], T โฒ, E โฒ)
7: solve(G, [(L+R)/2 + 1, R], T โฒ, E โฒ)
8: end if
9: end procedure
10: Call solve(G, [0, Qโ 1], โ , E(G))
์ด๋ฅผ ์ต์ข ์ ์ผ๋ก ์ค์ด๊ธฐ ์ํด์๋, T์ ์ํ๋ ์์ง๋ค์ด ์ฌ์ค์ ์ปดํฌ๋ํธ๋ฅผ ํฉ์ณ์ฃผ๋
์ญํ ์ธ์๋ ์๊ณ ๋ฆฌ์ฆ ์์ฒด์์ ํฐ ์ญํ ์ ํ์ง ์๋๋ค๋ ๊ฒ์ ๊ด์ฐฐํ๋ฉด ๋๋ค. ์๊ณ
๋ฆฌ์ฆ์ ์ํ ๊ณผ์ ์์, T์ ์ํ๋ ์์ง๋ค์ด ์๋กญ๊ฒ ๋ฐ๊ฒฌ๋์๋ค๋ฉด, ์ด ์์ง๋ ๋ฌด์กฐ๊ฑด
์คํจ๋ ํธ๋ฆฌ ์์ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ์์ง๊ฐ ์๋ ๋ ์ ์ ์ ๋ค๋ฅด๊ฒ ๋ณด๋ ํจ๊ณผ๊ฐ ๊ฑฐ์ ์
๋ค. ์ฆ, T์ ์ํ๋ ์์ง๋ค์ด ์๋กญ๊ฒ ๋ฐ๊ฒฌ๋์๋ค๋ฉด, Union-Find ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด์
๊ทธ๋ํ ์์ ๋ ์ ์ ์ ํฉ์ณ์ค ์ ์๊ณ , ์ด๋ฌํ ํฉ์ณ์ง ์ ์ ๋ค์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ง
๋ค๋ฉด ์ด์ ๋ชจ๋ ๊ฒ์ด E์ S([L,R]) ์ ๋ํ ์ด์ผ๊ธฐ๋ก๋ง ๊ท๊ฒฐ๋๊ธฐ ๋๋ฌธ์, ์ ํฉ์ณ์ฃผ๋
๊ณผ์ ์ O((Rโ L+ 1) log(Rโ L+ 1) ์๊ฐ์ ํด๊ฒฐํ ์ ์๋ค.
์ด์ ์์ ํ์๊ณ ๋ฆฌ์ฆ์์ ๋ํ ์์๊ณ ,์ด์๊ณ ๋ฆฌ์ฆ์์๊ฐ๋ณต์ก๋๋ T (N) = T (N/2)ร
2 +O(N logN), ์ฆ O(Q log2Q)๊ฐ ๋๋ค.
Dynamic Minimum Spanning Tree
Algorithm 4 Offline Dynamic MST, O(log2Q) per query
1: procedure solve(G, [L,R], T, E)
2: if L = R then
3: ์ต์ ์คํจ๋ ํธ๋ฆฌ๋ฅผ ๊ตฌํจ (|E| = 1์ด๊ธฐ ๋๋ฌธ์ ๋จ์ ์ผ์ด์ค ๋ถ์.)
4: else
5: T,E, S([L,R) ์ ์ฌ์ฉํด์ ๋ ํฐ T โฒ์ ๋ ์์ E โฒ๋ฅผ ํ์ฑ
6: solve(G, [L, (L+R)/2], T โฒ, E โฒ)
7: solve(G, [(L+R)/2 + 1, R], T โฒ, E โฒ)
8: end if
9: end procedure
10: Call solve(G, [0, Qโ 1], โ , E(G))
3.1 ์ฐ์ต ๋ฌธ์
์ค์ ๊ตฌํ์ ํด ๋ณด๊ณ ์ถ์ ๊ฒฝ์ฐ๋ฅผ ์ํ ์ฐ์ต ๋ฌธ์ ์ด๋ค. ๋์ด๋ ์์ผ๋ก ์ ๋ ฌ๋์ด ์๋ค.
โข https://dmoj.ca/problem/ccoprep4p3
โข http://codeforces.com/gym/101246/problem/L
โข https://www.acmicpc.net/problem/7148
4 General Case : Online Algorithm
๊ฐ์ ์๊ฐ์ค์น๋ฅผ๋ฐ๊พธ๋ํํ์์ง์๊ฐ๋ค์ด์์๋์ด๋ฅผ์จ๋ผ์ธํํ๋กํด๊ฒฐํ๋์๊ณ
๋ฆฌ์ฆ๋ค์ ๋์ดํ๋ค. ์์ง๊น์ง ์๊ณ ๋ฆฌ์ฆ ๋ํ์ ๋ฒ์์ ๋ค์ด์จ ๋ฌธ์ ๋ค์ ์๋๋ฉฐ (๊ณ ๋ก
์ฐ์ต ๋ฌธ์ ๋ ์๋ค.) ๋ชจ๋ ์คํ๋ผ์ธ ์๊ณ ๋ฆฌ์ฆ์ ๋นํด์ ๋ณต์กํ๊ณ ์ํ ์๋๊ฐ ๋๋ฆฌ๋ค.
๊ณ ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์กด์ฌ์ฑ ์ ๋๋ง ์ฐธ๊ณ ํด ๋๋ ๊ฒ์ด ์ข์ ๊ฒ์ด๋ค.
โข ์ง์๋น O(โm) ์ ํด๊ฒฐ : Frederickson, Greg N. โData structures for on-line
updating of minimum spanning trees, with applications.โ SIAM Journal on
Computing 14.4 (1985): 781-798. [5]
Dynamic Minimum Spanning Tree
โข ์ง์๋น O(โn) ์ ํด๊ฒฐ : Eppstein, David, et al. โSparsificationโa technique
for speeding up dynamic graph algorithms.โ Journal of the ACM (JACM) 44.5
(1997): 669-696. [6]
โข ์ง์๋น O(log4 n) ์ ํด๊ฒฐ : Holm, Jacob, Kristian De Lichtenberg, and Mikkel
Thorup. โPoly-logarithmic deterministic fully-dynamic algorithms for connec-
tivity, minimum spanning tree, 2-edge, and biconnectivity.โ Journal of the ACM
(JACM) 48.4 (2001): 723-760. [7]
5 References
1. https://en.wikipedia.org/wiki/Minimum_spanning_tree#Related_
problems
2. https://www.acmicpc.net/problem/status/10724
3. http://topology-blog.tistory.com/5
4. Eppstein, David. โOffline algorithms for dynamic minimum spanning tree prob-
lems.โ Journal of Algorithms 17.2 (1994): 237-250. https://www.ics.uci.edu/
หeppstein/pubs/Epp-TR-92-04.pdf
5. Frederickson, Greg N. โData structures for on-line updating of minimum spanning
trees, with applications.โ SIAM Journal on Computing 14.4 (1985): 781-798. https:
//docs.lib.purdue.edu/cgi/viewcontent.cgi?referer=&httpsredir=
1&article=1367&context=cstech
6. Eppstein, David, et al. โSparsificationโa technique for speeding up dynamic graph
algorithms.โ Journal of the ACM (JACM) 44.5 (1997): 669-696. http://www.cs.
ust.hk/mjg_lib/bibs/qzhang_lib/Dynamic/p669-eppstein.pdf
7. Holm, Jacob, Kristian De Lichtenberg, and Mikkel Thorup. โPoly-logarithmic de-
terministic fully-dynamic algorithms for connectivity, minimum spanning tree, 2-edge,
and biconnectivity.โ Journal of the ACM (JACM) 48.4 (2001): 723-760. https://
www.cs.princeton.edu/courses/archive/fall03/cs528/handouts/Poly%
20logarithmic.pdf