Dijkstra์ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ์ค ๊ทธ๋ํ์์ ์์ ๋ ธ๋์ ๋ค๋ฅธ ๋ชจ๋ ๋ ธ๋ ์ฌ์ด์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋ฐ ์ฌ์ฉ๋๋ ๊ทธ๋ํ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค
- ์์ ๋ ธ๋์ ๊ฑฐ๋ฆฌ๋ฅผ 0์ผ๋ก ์ค์ ํ๊ณ ๋ค๋ฅธ ๋ชจ๋ ๋ ธ๋์ ๊ฑฐ๋ฆฌ๋ฅผ ๋ฌดํ๋๋ก ์ค์ ํ์ฌ ์์ํฉ๋๋ค.
- ๊ทธ๋ฐ ๋ค์ ์ฐ์ ์์ ๋๊ธฐ์ด์ ์์ ๋ ธ๋๋ฅผ ์ถ๊ฐํฉ๋๋ค
- ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ๋ณตํ ๋๋ง๋ค ์ฐ์ ์์ ๋๊ธฐ์ด์์ ์ต์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐ์ง ๋ ธ๋๋ฅผ ์ ํํ๊ณ ์ธ์ ๋ ธ๋๋ฅผ ๋๊ธฐ์ด์ ์ถ๊ฐํ๊ณ ํ์ํ ๊ฒฝ์ฐ ๊ฑฐ๋ฆฌ๋ฅผ ์ ๋ฐ์ดํธํฉ๋๋ค.
- ๋ชจ๋ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ ๋๊น์ง ํ๋ก์ธ์ค๊ฐ ๊ณ์๋ฉ๋๋ค.
- DP๋ฅผ ํ์ฉํ๋ ์ต๋จ ๊ฒฝ๋ก ํ์ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
- ๊ฐ ๋ฐ๋ณต์์ ๊ณ์ฐ๋ ๊ฑฐ๋ฆฌ๊ฐ ์ต์ ์์ ๋ณด์ฅํฉ๋๋ค.
- ์ฆ, ์ง๊ธ๊น์ง ๋ฐฉ๋ฌธํ ๊ฐ ๋ ธ๋์ ๋ํ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๋ํ๋ ๋๋ค.
- ์๊ณ ๋ฆฌ์ฆ์ด ์๋ฃ๋๋ฉด ๊ทธ๋ํ์ ๋ชจ๋ ๋ ธ๋๊น์ง์ ๊ฑฐ๋ฆฌ๋ฅผ ์ฝ์ ์ ์์ผ๋ฉฐ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์์ ๋ ธ๋๋ฅผ ์ญ์ถ์ ํ์ฌ ๋ ๋ ธ๋ ์ฌ์ด์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.
์ปดํจํฐ ๋คํธ์ํฌ์ ๋ผ์ฐํ , ์ง๋์์ ๋์ ๊ฐ์ ์ต๋จ ๊ฒฝ๋ก ์ฐพ๊ธฐ, ์ ์กฐ ํ๋ก์ธ์ค์ ์ผ์ ์ต์ ํ์ ๊ฐ์ ๋ค์ํ ์์ฉ ํ๋ก๊ทธ๋จ์ ๋๋ฆฌ ์ฌ์ฉ๋ฉ๋๋ค.
- Dijkstra ์๊ณ ๋ฆฌ์ฆ์ O(E log V)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋๋ค.
์ ์ (V), ๊ฐ์ (E)
๋ฌธ์
ํ์ด
๋ค์ต์คํธ๋ผ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด ๋ ๊ฐ์ง๋ฅผ ์ ์ฅํด์ผ ํฉ๋๋ค.
-
ํด๋น ์ ์ ๊น์ง์ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅ
-
์ ์ ์ ๋ฐฉ๋ฌธํ๋ ์ง ์ ์ฅ
๋ฐฉํฅ ๊ทธ๋ํ๋ก ๋ฒ์ค ๋ ธ์ ์ ์ ๋ ฅํ๊ณ , ํจ์จ์ ์ธ ๋ค์ต์คํธ๋ผ ๊ตฌํ์ ์ํด ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
import sys
from heapq import heappush, heappop # ์ฐ์ ์์ ํ
input = sys.stdin.readline
inf = sys.maxsize
# ์
๋ ฅ
n = int(input())
m = int(input())
graph = [[] for _ in range(n + 1)]
dp = [inf] * (n + 1)
heap = []
def dijkstra(start):
dp[start] = 0
heappush(heap, [0, start]) # ์์ ๋
ธ๋๋ถํฐ ํ์ ์์
while heap:
w, n = heappop(heap)
if dp[n] < w: # ๊ธฐ์กด ์ต๋จ๊ฑฐ๋ฆฌ๋ณด๋ค ๋ฉ๋ค๋ฉด ๋ฌด์
continue
for n_n, wei in graph[n]:
n_w = wei + w # ์ธ์ ๋
ธ๋๊น์ง์ ๊ฑฐ๋ฆฌ
if n_w < dp[n_n]: # ๊ธฐ์กด ๊ฑฐ๋ฆฌ ๋ณด๋ค ์งง์ผ๋ฉด ๊ฐฑ์
dp[n_n] = n_w
heappush(heap, [n_w, n_n]) # ๋ค์ ์ธ์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐ ํ๊ธฐ ์ํด ํ์ ์ฝ์
for _ in range(m):
d, a, v = map(int, input().split())
graph[d].append([a, v])
d_c, a_c = map(int, input().split())
dijkstra(d_c)
print(dp[a_c])