2024. 1. 29. 19:55ใCS - Roadmap.sh/3. Common Algorithms
CS - 3. Common Algorithms - 3.5 Graph - 3.5.3 Bellman Ford’s Algorithm
Bellman Ford’s Algorithm
๐กBellman ford’s algorithm is a graph algorithm that finds the shortest path from a source vertex to all other vertices in a graph. It is a dynamic programming algorithm that uses a bottom-up approach to find the shortest path. It is similar to Dijkstra’s algorithm but it can handle negative weights. It is also similar to Floyd-Warshall’s algorithm but it can handle negative weights and it is faster than Floyd-Warshall’s algorithm.
๋ฒจ๋ง ํฌ๋์ ์๊ณ ๋ฆฌ์ฆ์ ๊ทธ๋ํ์์ ์์ค ์ ์ ์์ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ๊น์ง ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๊ทธ๋ํ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ์ํฅ์ ์ ๊ทผ ๋ฐฉ์์ ์ฌ์ฉํ์ฌ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋์ ํ๋ก๊ทธ๋๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ ์ฌํ์ง๋ง ์์ ๊ฐ์ค์น๋ฅผ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. ๋ํ ํ๋ก์ด๋-์์ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ ์ฌํ์ง๋ง ์์ ๊ฐ์ค์น๋ฅผ ์ฒ๋ฆฌํ ์ ์์ผ๋ฉฐ ํ๋ก์ด๋-์์ ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค ๋น ๋ฆ ๋๋ค.
์ ๊ธ๊น์ง DFS ์ BFS๋ฅผ ๋ค๋ฃจ์๋๋ฐ, ์ด์ ๋ ์ฝ๊ฐ ๋ฐ์ ๋ ์๊ณ ๋ฆฌ์ฆ
๋ฒจ๋งํฌ๋ ์๊ณ ๋ฆฌ์ฆ
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ
A* ์๊ณ ๋ฆฌ์ฆ (A ์คํ ์๊ณ ๋ฆฌ์ฆ)
3๊ฐ์ง๋ฅผ ๋ค๋ค ๋ณผ ๊ฒ์ ๋๋ค.
๋จผ์ 3.5.3 ๋ฒจ๋ง ํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ํด์ ์์๋ด ์๋ค.
์ด ์๊ณ ๋ฆฌ์ฆ์ ๊ทธ๋ํ ๋ด์ ๋ชจ๋ ์ ์ ๊ฐ์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋์ ๋๋ค.
๊ทธ๋ํ ๋ด์ ํ ์ ์ ์์ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ๊น์ง์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋๋ฐ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
๋ฒจ๋ง ํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ธฐ๋ณธ ์๋ฆฌ๋
"Relaxation" ์ด๋ผ๋ ๊ฐ๋ ์ ๊ธฐ๋ฐํฉ๋๋ค.
๋จ์ด์ ์๋ฏธ๋ ํด์, ๊ฒฝ๊ฐ, ์ํ ์ธ๋ฐ, ์ด ๊ธ์์๋ ์ํ๊ฐ ์ ๋นํด ๋ณด์ ๋๋ค.
(์๋ ๋งํฌ์ Lagrangian Relaxation(๋ผ๊ทธ๋์ฃผ ์ํ๋ฒ)์ ๋ํ ์ค๋ช ์ด ์ ๋์์๋ค.
https://charstring.tistory.com/481)
์ด ๊ธ์์ Relaxation์ ๊ฐ์ ์ ๊ฐ์ค์น๋ฅผ ๊ณ ๋ คํ์ฌ ํ ์ ์ ์์ ๋ค๋ฅธ ์ ์ ๊น์ง์ ํ์ฌ๊น์ง ์๋ ค์ง ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ์ ๋ฐ์ดํธ ํ๋ ๊ณผ์ ์ ์๋ฏธํฉ๋๋ค.
๊ทธ๋์ ๋ฐธ๋ง-ํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ด๋ฐ ์์๋ก ์งํ๋ฉ๋๋ค.
1. ์์ ์ ์ ์ ์ ์ธํ ๋ชจ๋ ์ ์ ์ ๊ฑฐ๋ฆฌ ๊ฐ์ ๋ฌดํ๋๋ก ์ค์ ํฉ๋๋ค.
2. ๋ชจ๋ ๊ฐ์ ์ ๋ํด, ๋ง์ฝ ์์ ์ ์ ์์ ํด๋น ๊ฐ์ ์ ์์ ์ ์ ๊น์ง์ ๊ฑฐ๋ฆฌ์ ํด๋น ๊ฐ์ ์ ๊ฐ์ค์น์ ํฉ์ด ํด๋น ๊ฐ์ ์ ๋ ์ ์ ๊น์ง์ ํ์ฌ ๊ฑฐ๋ฆฌ๋ณด๋ค ์๋ค๋ฉด, ๋ ์ ์ ๊น์ง์ ๊ฑฐ๋ฆฌ ๊ฐ์ ์ ๋ฐ์ดํธ ํฉ๋๋ค.
3. ์ด ๊ณผ์ ์ ์ ์ ์ ์ -1๋ฒ ๋ฐ๋ณตํฉ๋๋ค.
4. ๋ง์ง๋ง์ผ๋ก, ์์ ์ฌ์ดํด์ด ์๋์ง ํ์ธํฉ๋๋ค.
์์ ์ฌ์ดํด์ด ์๋ค๋ฉด, ์์ ์ฌ์ดํด์ด ์กด์ฌํ๋ค๊ณ ๋ฆฌํดํ๋ค.
In Python
def BellmanFord(graph, V, E, src):
# 1๋จ๊ณ : src๋ถํฐ ๋ชจ๋ ๋ฒํ
์ค๊น์ง์ ๊ฑฐ๋ฆฌ๋ฅผ ๋ฌดํ๋๋ก ์ด๊ธฐํํฉ๋๋ค.
dis = [float("Inf")] * V
dis[src] = 0
# 2๋จ๊ณ: ๋ชจ๋ ๊ฐ์ฅ์๋ฆฌ V - 1๋ฐฐ ์ํํ๊ธฐ
for i in range(V - 1):
for j in range(E):
if dis[graph[j][0]] != float("Inf") and dis[graph[j][0]] + graph[j][2] < dis[graph[j][1]]:
dis[graph[j][1]] = dis[graph[j][0]] + graph[j][2]
# 3๋จ๊ณ: ์์ ์ฌ์ดํด ํ์ธ
for i in range(E):
x = graph[i][0]
y = graph[i][1]
weight = graph[i][2]
if dis[x] != float("Inf") and dis[x] + weight < dis[y]:
print("์์ ๊ฐ์ค์น ์ฌ์ดํด ์์ผ์!")
return
# ์์ ๋ฌด๊ฒ ์ฃผ๊ธฐ๋ฅผ ์ฐพ์ ์ ์๋ค๋ฉด ๊ฑฐ๋ฆฌ์ ์ด์ ๋ฐฐ์ด์ ์ถ๋ ฅ
print("์์ ์ ์ ์ผ๋ก ๋ถํฐ ์ต๋จ๊ฑฐ๋ฆฌ")
for i in range(V):
print("%d\t\t%d" % (i, dis[i]))
0 - 0 ์์ ์ ์ ์ธ 0์์ 0๊น์ง์ ์ต๋จ๊ฑฐ๋ฆฌ 0
1 -1 ์์ ์ ์ 0 ์์ 1๊น์ง์ ์ต๋จ๊ฑฐ๋ฆฌ -1
๊ทธ๋ํ๋ฅผ ์๊ฐํ ํ๋ค๋ฉด ์ด๋ ์ต๋๋ค.
์์ ์ ์ ์ด 0, ๋์ฐฉ ์ ์ ์ด 2์ผ๋ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํด๋ณด์.
์ ์ 0 ์์ ์ ์ 1์ ๊ฑฐ์ณ ์ ์ 2๋ก ์ด๋ํ๋ ๊ฒฝ๋ก์ ์ด ๊ฐ์ค์น๋ -1 +3 = 2 ๊ฐ๋๋ค.
๊ทธ๋ฐ๋ฐ, ์ ์ 0 ์์ ๋ฐ๋ก ์ ์ใ 2๋ก ์ด๋ํ๋ ๊ฐ์ ์ ๊ฐ์ค์น๋ 4์ด๋ค.
๋ฐ๋ผ์, 0-2 ๋ณด๋ค 0-1-2 ๋ก ์ด๋ํ๋ ๊ฒฝ๋ก๊ฐ ๋ ์งง์ผ๋ฏ๋ก, ์์ ์ ์ 0์์ ์ ์ 2๊น์ง์ ์ต๋จ ๊ฑฐ๋ฆฌ๋ 2๊ฐ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์์ ๊ฐ์ค์น ์ฌ์ดํด์ด ๋ํ๋๋ค๋ฉด ์ด๋ป๊ฒ ๋ ๊น์?
edges = [(0, 1, -1), (1, 2, -3), (2, 3, 2), (3, 1, -1)]
์ด๋ฐ ๊ทธ๋ํ๊ฐ ์๋ค๊ณ ๊ฐ์ ํฉ์๋ค.
์ ๊ทธ๋ํ์์๋
์ ์ 1์์ ์์ํ์ฌ ์ ์ 2, ์ ์ 3์ ๊ฑฐ์ณ ๋ค์ ์ ์ 1๋ก ๋์์ค๋ ์ฌ์ดํด์ด ์กด์ฌํ๋ฉฐ, ์ด ์ฌ์ดํด์ ๊ฐ์ค์น ํฉ์ -1 + 2 - 3 = -2๋ก ์์์ ๋๋ค.
๊ณ์ 1-2-3-1-2-3-... ์ด๋ฐ์์ผ๋ก ๊ฐ๋ฉด ๊ณ์ ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ์งง์์ง๋ฏ๋ก ์ค๋ฅ์ ๋น ์ง๊ฒ ๋ฉ๋๋ค.
ํ์ฉ
์ด ๋ฒจ๋ง-ํฌ๋ ์๊ณ ๋ฆฌ์ฆ์ด ์ ์ฉํ์ ์ '์์ ๊ฐ์ค์น๋ฅผ ๊ณ์ฐํ ์ ์๋ค' ์
๋๋ค.
๋ค์๋งํด, ์์ ๊ฐ์ค์น๋ฅผ ๊ฐ์ง ๊ฐ์ ์ด ํฌํจ๋ ๊ทธ๋ํ์์๋ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ์์ ์ฌ์ดํด์ ๊ฐ์งํ ์ ์๋ค๋ ์ ์ ๋๋ค.
์ด ์๊ณ ๋ฆฌ์ฆ์ ๋คํธ์ํฌ ๋ผ์ฐํ , ํตํ ๊ฑฐ๋, ๊ฒฝ๋ก ์ฐพ๊ธฐ ๋ฑ ๋ค์ํ ์ํฉ์์ ํ์ฉํ ์ ์์ต๋๋ค.
'CS - Roadmap.sh > 3. Common Algorithms' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
3.5 Graph - 3.5.5 A* Algorithm (0) | 2024.01.31 |
---|---|
3.5 Graph - 3.5.4 Dijkstraโs Algorithm (2) | 2024.01.30 |
3.5 Graph - 3.5.2 Depth First Search(DFS) (1) | 2024.01.29 |
3.5 Graph - 3.5.1 Breadth First Search(BFS) (0) | 2024.01.28 |
3.5 Graph & 3.6 Tree (0) | 2024.01.27 |