๐คDynamic Programming
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ด๋ ํฐ ๋ฌธ์ ๋ฅผ ์์๋ฌธ์ ๋ก ๋๋์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ ๋งํฉ๋๋ค.
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ๋ ๋ค์ํ ์๊ณ ๋ฆฌ์ฆ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
์ด๋ฒ ํฌ์คํ ์์๋ All-pairs shortest Paths์ ๋ํด ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
๊ฐ์ฅ ๋ํ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ธ ํ๋ก์ด๋ ์์ฌ ์๊ณ ๋ฆฌ์ฆ์ ํตํด ํด๋น ์๊ณ ๋ฆฌ์ฆ์ ํด๊ฒฐํ๊ฒ ์ต๋๋ค.
๐ All-pairs Shortest Path
์ด์ ์ ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ ๋๋ ๋ฒจ๋งํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฒฝ์ฐ์๋ ํ๋์ ์์ ์ ์ source์์ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ๋ค ๊ฐ์ ์ต์ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
์ด์ ๊ฐ์ ๋ฌธ์ ๋ฅผ single-source ์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ ๋ผ๊ณ ํฉ๋๋ค.
๊ทธ์ ๋ฐํด ๋จ์ผ source๊ฐ ์๋ ์์์ ๋ชจ๋ ๋ ์ ์ u, v์ ๋ํด u์์ v๋ก์ ์ต๋จ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ฅผ All-pairs ์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ ๋ผ๊ณ ํฉ๋๋ค.
โ๏ธ๋ฒจ๋งํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ All-pairs shortest path๋ฌธ์ ํด๊ฒฐ
Directed Graph G = (V, E)๊ฐ negative cycle์ด ์๋ ๊ฒฝ์ฐ, G์์ All-pairs shortest path ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.(์ด๋ G๊ฐ undirected graph์ธ ๊ฒฝ์ฐ์๋ ๋ฒจ๋งํฌ๋ ์๊ณ ๋ฆฌ์ฆ๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก directed graph๋ก ๋ณํํ๋ฉด ๋ฉ๋๋ค.)
"G์ ๊ฐ ์ ์ ์ source๋ก ๋ ๋ค์, ํด๋น source์ ๋ํด ๋ฒจ๋งํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ํํฉ๋๋ค."
์ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ๋ณต์ก๋๋ $O(n x nm) = O(n^2m)$์ด ๋ฉ๋๋ค.
์์ ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค ๋ ๋น ๋ฅธ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ์ฌ ํด๋น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ์ฐพ๊ธฐ ์ํด ํ๋ก์ด๋ ์์ฌ ์๊ณ ๋ฆฌ์ฆ์ด ๊ฐ๋ฐ๋์์ต๋๋ค.
๐ ํ๋ก์ด๋ ์์ฌ ์๊ณ ๋ฆฌ์ฆ(Floyd-Warshall Algorithm)
Dynamic programming ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ํด๋น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋ณด๊ฒ ์ต๋๋ค.
โ๏ธRecurrence relation ์ ์
V = { 1, 2, ..., n }์ผ๋ก ๋๊ณ , G์ ์์์ ๋ ์ ์ i, j์ ๋ํด dist(i, j, k)๋ฅผ ์ ์ {1, 2, ..., k}๋ง์ path์ ์ค๊ฐ ๊ฑฐ์ ์ ์ (intermediate vetex)๋ก ํฌํจ์ํฌ ์ ์์ ๋, i์์ j์ shortest path์ ๊ธธ์ด๋ผ ํ์.
์์ intermediat vertex๋ ์๋์ ๊ฐ์ด ์ดํดํ๋ฉด ๋ฉ๋๋ค.
์ฆ, dist(i, j, k)๋ผ๋ ๊ฒ์ ์ ์ i ์์ ์ ์ j ๊น์ง ๋๋ฌํ๊ธฐ ์ํด intermediate vetex๋ง์ ์ฌ์ฉํ์ฌ ๋๋ฌํ๋ค๋ ๊ฒ์ ๋๋ค.
base case) k = 0์ธ ๊ฒฝ์ฐ
dist(i, j, 0) = 0 ( i = j ์ธ ๊ฒฝ์ฐ )
dist(i, j, 0) = w(i, j) ( edge(i, j)๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ )
dist(i, j, 0) = ๋ฌดํ๋ ( edge(i, j)๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ )
Inductive step) dist(i, j, k)์ ๊ธธ์ด๋ฅผ ๊ฐ์ง path๋ฅผ ๊ฐ์ง ๋ case๋ก ๋๋์ด ๋ณด์
case1) ์ ์ k๋ฅผ ์ง๋์น์ง ์๋ ๊ฒฝ์ฐ ( ์ฆ, ์ ์ k๋ฅผ ์ค๊ฐ ๊ธฐ์ ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅํ๋๋ผ๋ ์ ์ {1, ..., k-1}์ ์ค๊ฐ ๊ธฐ์ ์ผ๋ก ์ฌ์ฉํ ๋์ ๋น๊ตํด์ ์ต๋จ ๊ฒฝ๋ก์ ๊ธธ์ด๊ฐ ์ค์ด๋ค ์ง ์์ ๋๋ฅผ ๋งํฉ๋๋ค.)
dist(i, j, k) = dist(i, j, k-1)
case2) ์ ์ k๋ฅผ ์ง๋๊ฐ๋ ๊ฒฝ์ฐ (์ฆ, ์ ์ k๋ฅผ ์ค๊ฐ ๊ธฐ์ ์ผ๋ก ์ฌ์ฉํ์ ๋ ์ต๋จ ๊ฒฝ๋ก์ ๊ธธ์ด๊ฐ ์ค์ด๋ค์์ ๋๋ฅผ ๋งํฉ๋๋ค.)
dist(i, j, k) = dist(i, k, k-1) + dist(k, j, k-1)
์ด๋ฅผ ๊ทธ๋ฆผ์ ํตํด ์ดํด๋ฅผ ํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
์ฃผ์ํ ์ ์ ๊ทธ๋ํ G๋ negative cycle์ ํฌํจํ์ง ์๊ธฐ ๋๋ฌธ์ ์ ์ i์์ k๊น์ง์ path์ ์ ์ k์์ j๊น์ง์ path์์ ์กด์ฌํ๋ ์ ์ ์ ๊ณต์ ๋์ง ์๋๋ค๋ ๊ฒ์ ๋๋ค.
๋ง์ฝ ํด๋น ์ ์ ์ด ๊ณต์ ๋๋ค๊ณ ํ๋ค๋ฉด ์ต๋จ ๊ฒฝ๋ก๋ ๊ณต์ ํ๋ ์ ์ ์ ์ง๋์ณ i์์ j๋ก ์ง๋์น๋ path๊ฐ ํ์ฑ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ k๋ฅผ ์ค๊ฐ ๊ธฐ์ ์ผ๋ก ์ฌ์ฉํ๋ค๊ณ ํ ๊ฐ์ ์ ๋ชจ์์ด ๋ฉ๋๋ค.
์ต์ข ) case1๊ณผ case2๋ฅผ ๋น๊ตํ์ฌ ๋ ์์ ๊ฒฝ์ฐ๋ฅผ dist(i, j k)๋ก ์ค์
dist(i, j, k) = min( dist(i, k, k-1) + dist(k, j, k-1), dist(i, j, k-1))
์ต์ข ์ ์ผ๋ก ์ ์ i์์ j๊น์ง์ shortest path์ ๊ธธ์ด๋ dist(i, j, n)์ด ๋ฉ๋๋ค.
โ๏ธ Floyd-Warshall Algorithm outline
1. ์๊ณ ๋ฆฌ์ฆ์ ์ด 0 ~ n์ stage(iteration)์ผ๋ก ๊ตฌ์ฑ๋๋ฉฐ, k ๋ฒ์งธ stage๊ฐ ๋๋ ๋๋ง๋ค G์ ๋ชจ๋ ์ ์ i, j์ ๋ํด dist(i, j, k)๊ฐ dist(i, j)์ ์ ์ฅ๋ฉ๋๋ค. (invariant)
2. 0๋ฒ์งธ stage์์๋ ์์ base case์ ๋ง๊ฒ dist๊ฐ์ ์ ํด์ค๋๋ค.
3. ์ดํ k๋ฒ์งธ stage๋ง๋ค ๋ชจ๋ ์ ์ i,j ์ ๋ํด ๋ค์ ์์ ์ ๋ฐ๋ณตํฉ๋๋ค.
→ dist(i, k, k-1) + dist(k, j, k-1) < dist(i, j, k-1)์ธ ๊ฒฝ์ฐ dist(i, j)๋ฅผ dist(i, k, k-1) + dist(k, j, k-1)๋ก ์ ๋ฐ์ดํธ ํฉ๋๋ค.
๐ Floyd-Warshall Algorithm Example
์์ ๋ฅผ ํตํด ์๊ณ ๋ฆฌ์ฆ์ ํด๊ฒฐ ํ๋ฆ์ ๋ฐ๋ผ๊ฐ๋ณด๊ฒ ์ต๋๋ค.
โ๏ธ ์๋์ฝ๋
์ด๋ฅผ ์๋์ฝ๋๋ก ๋ํ๋ด๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
โ๏ธTime Complexity
๊ฐ stage๋ง๋ค ๋ชจ๋ 1 ≤ i, j ≤ n์ ๋ํด์ dist(i, j)๋ฅผ ์ ๋ฐ์ดํธํฉ๋๋ค.
stage๊ฐ ์ด n+1๋ฒ ์กด์ฌํ๋ฏ๋ก ํด๋น ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ๋ณต์ก๋๋ ์๋์ ๊ฐ์ต๋๋ค.
$$O(n^2 * (n+1)) = O(n^3)$$
'Computer Science > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm] Sort(Selection, Insertion, Bubble) (0) | 2024.03.08 |
---|---|
[Algorithm] Dynamic Programming(4) - ๋ฒจ๋งํฌ๋(Bellman-Ford) (0) | 2022.11.19 |
[Algorithm] Dynamic Programming(3) - Edit Distance(ํธ์ง๊ฑฐ๋ฆฌ) (0) | 2022.11.19 |
[Algorithm] Dynamic Programming(2) - LIS(Longest Increasing Subsequence) (0) | 2022.11.17 |
[Algorithm] Dynamic Programming(1) - Warm Up (0) | 2022.11.15 |