~๋ชฉ์ฐจ~
์ต๋จ ๊ฒฝ๋ก ๋ฌธ์
์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ ๋ ๊ทธ๋ํ ๋ฌธ์ ๋ก ์ฐํ ์บ 6๊ธฐ ์ฝ๋ฉํ ์คํธ์๋ ๋์์๋ค
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ์ ํฌ๊ฒ ๋ ๊ฐ์ง๋ก ๋ค์ต์คํธ๋ผ(Dijkstra, ๋ฐ์ดํฌ์คํธ๋ผ) ์๊ณ ๋ฆฌ์ฆ๊ณผ ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ์ด ์๋ค
๊ธฐ๋ณธ์ ์ผ๋ก ๊ทธ๋ํ์ ๋ํ ์ดํด๋ฅผ ๋ฐํ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ด ์งํ๋๋ค
๋ ธ๋์์ ๋ค๋ฅธ ๋ ธ๋๋ก ์ ๊ทผ ๋ฐฉ๋ฒ์ด ์๋ค๋ฉด ๋ฌดํ์(int(1e9) in Python)๋ก ํ์ํ๋ค.
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ
์์ ๋ ธ๋๋ก๋ถํฐ ๊ฐ ๋ ธ๋๊น์ง ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๋ฌธ์ ํด๊ฒฐ์ ์ํ ๋ฐฉ๋ฒ์ 2๊ฐ์ง๊ฐ ์๋ค. ๋ฆฌ์คํธ(๋ฐฐ์ด)์ ์ฌ์ฉํ๊ฑฐ๋ ์ฐ์ ์์ ํ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ์ฝ์ง๋ง ์๊ฐ ๋ณต์ก๋์์ ์ฐจ์ด๊ฐ ๋ง์ด ๋๋ฏ๋ก
์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํธ๋ ๊ฒ์ ์ต์ํด์ง๋๋ก ํ์!
1. ๋ฆฌ์คํธ(๋ฐฐ์ด) ์ฌ์ฉ
O(V2) ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค.(V : ๋ ธ๋ ์)
ํด๋น ๊ธ์์๋ ์ฐ์ ์์ ํ์ ํ์ด ๋ฐฉ๋ฒ๋ง์ ๋ค๋ฃฌ๋ค
2. ์ฐ์ ์์ ํ ์ฌ์ฉ
O(ElogV)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค. ( E : ๊ฐ์ ์, V : ๋ ธ๋ ์)
์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์ Python์ heapq ๋ชจ๋์ ์ฌ์ฉํจ
1) ๊ฐ ๊ทธ๋ํ์ ์ธ์ ํ๋ ฌ์ด๋ ์ธ์ ๋ฆฌ์คํธ๋ ์ฃผ์ด์ง ์ ๋ณด์ ๋ฐ๋ผ ์์ฑํ๋ค.
2) ์์ ๋ ธ๋๋ก ๋ถํฐ ๊ฐ ๋ ธ๋์ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅํ 1์ฐจ์ ๋ฐฐ์ด์ ์ ์ธํ๊ณ ๋ฌดํ์๋ก ์ด๊ธฐํ (2์ฐจ์ ๋ฐฐ์ด๋ก ํ์ฅ๋๊ธฐ๋ ํจ)
3) ์ฐ์ ์์ ํ๋ฅผ ์ ์ธํ์ฌ ์์ ๋ ธ๋์ ๊ฑฐ๋ฆฌ๋ฅผ ์ฝ์ ํ๋ค.
3) ํ์ ๊ฐ์ด ์์ ๋๊น์ง ๋ฐ๋ณตํ๋ฉฐ ๊ฑฐ๋ฆฌ๊ฐ ์ต์๊ฐ ๋๋ ๋ ธ๋๋ฅผ ๊บผ๋ธ๋ค.
4) ์ฐ์ ์์ ํ์ ์ต์ ๋ ธ๋๊ฐ ๋ฐฉ๋ฌธ๋ ์ ์ด ์๋ค๋ฉด(์ด๋ฏธ ์ ์ฅ๋ ๊ฑฐ๋ฆฌ ์ ๋ณด๋ณด๋ค ํ์ฌ ๊ฑฐ๋ฆฌ๊ฐ ์๋ค๋ฉด) ๊ฑฐ๋ฆฌ ์ ๋ณด๋ฅผ ์ ๋ฐ์ดํธ
import sys
import heapq
input = sys.stdin.readline
INF = int(1e9)
n, m = map(int, input().split())
start = int(input())
graph = [[] for _ in range(n+1)]
distance = [INF] * (n+1)
for _ in range(m):
v1, v2, d = map(int, input().split())
graph[v1].append((v2, d))
def dijkstra(start):
q = []
heapq.heappush(q, (0, start)) # ์ฐ์ ์์ ํ, q์ (๊ฑฐ๋ฆฌ, ์์ ๋
ธ๋) ์ฝ์
distance[start] = 0
while q:
dist, now = q.heappop(q)
if distance[now] < dist:
continue
for i in graph[now]:
cost = dist + i[1]
if cost < distance[i[0]]:
distance[i[0]] = cost
heapq.heappush(q, (cost, i[0]))
dijkstra(start)
for i in range(1, n+1):
if distance[i] == INF:
print("INFINITY")
else:
print(distance[i])
# ์
๋ ฅ ์์
6 11
1
1 2 2
1 3 5
1 4 1
2 3 3
2 4 2
3 2 3
3 6 5
4 3 3
4 5 1
5 3 1
5 6 2
# ์ถ๋ ฅ ์์
0
2
3
1
2
4
๋ฌธ์ ํ์ด ๋ชจ์
ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ
๋ค์ต์คํธ๋ผ์ ๋น๊ตํ์ฌ ์ ํ์ ํ๋๋ง ๊ธฐ์ตํ๊ณ ์๋ค๋ฉด ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค.
๋ํ ๋ค๋ฅธ ์ ์ ์์ ๋ ธ๋ ๋ฟ๋ง ์๋๋ผ ๊ฐ ๋ ธ๋์์ ๋ค๋ฅธ ๋ ธ๋๊น์ง ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๋ชจ๋ ์ ์ ์๋ค.
๋ฌธ์ ํด๊ฒฐ์ ์ํ ํฌ์ธํธ๋ a -> b ๊ฒฝ๋ก์ a -> k -> b ๊ฒฝ๋ก ์ค ๋ ์์ ๊ฐ ์ ๋ฐ์ดํธ๋ฅผ ๋ฐ๋ณตํ์ฌ ๋ ธ๋ ๋ณ ๊ฐ์ฅ ์์ ๊ฑฐ๋ฆฌ๋ฅผ ์ฐพ๋๋ค
2์ฐจ์ ๋ฐฐ์ด๋ก ๊ฐ ๋ ธ๋ ๊ฑฐ๋ฆฌ๋ฅผ ํ์ํ๋ค
k๋ฅผ ๊ตฌํ๊ธฐ ์ํด Nํ, a๋ฅผ ๊ตฌํ๊ธฐ ์ํด Nํ, b๋ฅผ ๊ตฌํ๊ธฐ ์ํด Nํ๋ฅผ ์ํํ๋ฏ๋ก 3์ค for๋ฌธ์ด ์์ฑ๋๊ณ
์๊ฐ๋ณต์ก๋๋ O(N3)๊ฐ ๋๋ค
ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ์์ ๊ธฐ์ตํ ์ ํ์์
Dab = min( Dab , Dak + Dkb)
INF = int(1e9)
n = int(input()) # ๋
ธ๋
m = int(input()) # ๊ฐ์
graph = [[INF] * (n+1) for _ in range(n+1)]
for a in range(1, n+1):
for b in range(1, n+1):
if a == b:
graph[a][b] = 0
for _ in range(m):
a, b, c = map(int, input().split())
graph[a][b] = c
for k in range(1, n+1):
for a in range(1, n+1):
for b in range(1, n+1):
graph[a][b] = min(graph[a][b], graph[a][k] + graph[k][b])
for a in range(1, n+1):
for b in range(1, n+1):
if graph[a][b] == INF:
print("INFINITY", end=" ")
else:
print(graph[a][b], end=" ")
print()
# ์
๋ ฅ ์์
4
7
1 2 4
1 4 6
2 1 3
2 3 7
3 1 5
3 4 4
4 3 2
# ์ถ๋ ฅ ์์
0 4 8 6
3 0 7 9
5 9 0 4
7 11 2 0
ํ๋ก์ด๋ ์์ ๋ฌธ์ ํ์ด ๋ชจ์
๋์์ด ๋์ จ๋ค๋ฉด ์ข์์ ๋๋ฌ์ฃผ์ธ์๐
๐ก ๊ถ๊ธํ ์ ์ด ์๋ค๋ฉด ๋๊ธ ๋ฌ์์ฃผ์ธ์!
'๐งชComputer Science > ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ต์ ์คํจ๋ ํธ๋ฆฌ ์๊ณ ๋ฆฌ์ฆ | ํฌ๋ฃจ์ค์นผ/ํ๋ฆผ ์๊ณ ๋ฆฌ์ฆ (0) | 2023.05.29 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ์๊ฐ๋ณต์ก๋ ๊ตฌํ๊ธฐ (0) | 2023.04.04 |