๋ค์ต์คํธ๋ผ vs ๋ฒจ๋ง-ํฌ๋ vs ํ๋ก์ด๋-์์ฌ
1.
ํ ๋
ธ๋์์ ๋ค๋ฅธ ๋
ธ๋๋ค๊น์ง์ ์ต๋จ๊ฒฝ๋ก (์์ ๊ฐ์ค์น ๋ถ๊ฐ) : ๋ค์ต์คํธ๋ผ
2.
ํ ๋
ธ๋์์ ๋ค๋ฅธ ๋
ธ๋๋ค๊น์ง์ ์ต๋จ๊ฒฝ๋ก (์์ ๊ฐ์ค์น ๊ฐ๋ฅ) : ๋ฒจ๋ง-ํฌ๋
3.
๋ชจ๋ ๋
ธ๋์์ ๋ค๋ฅธ ๋
ธ๋๋ค๊น์ง์ ์ต๋จ๊ฒฝ๋ก (์์ ๊ฐ์ค์น ๊ฐ๋ฅ) : ํ๋ก์ด๋-์์ฌ
๋ค์ต์คํธ๋ผ
1.
์ถ๋ฐ ๋
ธ๋๋ฅผ ์ค์ ํ๋ค.
2.
์ต๋จ ๊ฑฐ๋ฆฌ ํ
์ด๋ธ์ ์ด๊ธฐํํ๋ค.
3.
๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋๋ค ์ค, ์ต๋จ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋
ธ๋๋ฅผ ์ ํํ๋ค. (๊ทธ๋ฆฌ๋)
โ ์ฐ์ ์์ ํ(์ต์ํ) ๋ฅผ ์ฐ๋, ๋ฆฌ์คํธ๋ฅผ ์ฐ๋์ ๋ฐ๋ผ ๋ค๋ฆ
4.
์ ํํ ๋
ธ๋๋ฅผ ๊ฑฐ์ณ์ ๋ค๋ฅธ ๋
ธ๋๋ก ๊ฐ๋ ๋น์ฉ์ ๊ณ์ฐํ์ฌ ์ต๋จ ๊ฑฐ๋ฆฌ ํ
์ด๋ธ์ ๊ฐฑ์ ํ๋ค. (dp)
5.
3-4๋ฒ ๋ฐ๋ณตํ๋ค.
๋ค์ต์คํธ๋ผ์์ ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋๋ค ์ค, ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋
ธ๋๋ฅผ ์ ํํด์ผ ํ๋ค.
๋ฐฉ๋ฒ1. ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋
ธ๋๋ฅผ ์ต๋จ ๊ฑฐ๋ฆฌ ํ
์ด๋ธ(๋ฆฌ์คํธ)์์ ๋งค๋ฒ ์ฐพ์๋ :
๋ฐฉ๋ฒ2. ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋
ธ๋๋ฅผ ์ต์ ํ(์ฐ์ ์์ ํ)์์ ์ฐพ์๋ :
๋ฐฉ๋ฒ1 ๋ก ์ต์ข
๊ตฌํ ์ โ
๋ฐฉ๋ฒ2 ๋ก ์ต์ข
๊ตฌํ ์ โ ( E : ๊ฐ์ ๊ฐ์ , V : ๋
ธ๋๊ฐ์ )
๋น์ฐํ ๋ฐฉ๋ฒ2 ๊ฐ ์ข์ผ๋ฉฐ, ๊ตฌํ์ด ๋ฐฉ๋ฒ1 ๋ณด๋ค ์กฐ๊ธ ์ด๋ ค์์ง๊ธด ํ์ง๋ง ๋ฐฉ๋ฒ2๋ฅผ ์์์ผ ํ๋ค. ๋ฐ๋ผ์ ๋ฐฉ๋ฒ2 ์ฝ๋๋ง ์์ฑํ๋ค.
ํ์ํ ๋ณ์ ๋ฐ ๋ฆฌ์คํธ
โข
๊ทธ๋ํ (์์,๋์ฐฉ,๊ฐ์ค์น)
โข
์ต๋จ๊ฑฐ๋ฆฌ ํ
์ด๋ธ (1์ฐจ์ ๋ฆฌ์คํธ)
โข
ํํํ์์ (๊ฑฐ๋ฆฌ,๋
ธ๋) ๋ฅผ ์ ์ฅํ๋ ์ฐ์ ์์ ํ
import heapq as hq
import sys
read = sys.stdin.readline
v, e = map(int, read().split()) # ์ ์ ๊ฐ์, ๊ฐ์ ๊ฐ์
start = int(read()) # ์์ ์ ์
graph = dict()
for i in range(1, v + 1):
graph[i] = []
for _ in range(e):
a, b, w = map(int, read().split()) # ์์,๋์ฐฉ,๊ฐ์ค์น
graph[a].append((b, w))
MAX = int(1e9)
distance = [MAX] * (v + 1) # ์ต๋จ๊ฑฐ๋ฆฌ ํ
์ด๋ธ ๋ฌดํ๋๋ก ์ด๊ธฐํ
def dijkstra(start):
q = [] # (์์์ ์ ์ผ๋ก๋ถํฐ์ ๊ฑฐ๋ฆฌ, ๋
ธ๋๋ฒํธ) ๋ฅผ ์ ์ฅํ ์ต์ ํ
# pop ์ ๊ฑฐ๋ฆฌ๊ฐ ์์ ์์ผ๋ก pop ๋จ
# ์์์ ์ธํ
distance[start] = 0 # ์์์ ์ ๊ฑฐ๋ฆฌ๋ 0
hq.heappush(q, (0, start)) # ํ์ ์์์ push
while q:
dist, cur = hq.heappop(q) # ์ต์ ํ์์ (๊ฑฐ๋ฆฌ,๋
ธ๋๋ฒํธ) pop
# ํ์ฌ ๋
ธ๋๊ฐ ์ฒ๋ฆฌ๋์ง ์์ ๋
ธ๋์ฌ์ผํจ
if dist <= distance[cur]: # popํ ๋
ธ๋์ ๊ฑฐ๋ฆฌ <= ์ต๋จ๊ฑฐ๋ฆฌ ํ
์ด๋ธ ์์ ๊ธฐ๋ก๋ ๊ฑฐ๋ฆฌ
for i in graph[cur]: # i[0] : ์ธ์ ๋
ธ๋๋ฒํธ, i[1] : ๊ฑฐ๋ฆฌ
cost = dist + i[1] # ํ์ฌ๋
ธ๋๋ฅผ ๊ฑฐ์ณ๊ฐ ๊ฒฝ์ฐ์ ๊ฑฐ๋ฆฌ ๊ณ์ฐ
if cost < distance[i[0]]: # ์๋กญ๊ฒ ๊ณ์ฐํ ๊ฑฐ๋ฆฌ๊ฐ ์์๋๋ง ๊ฐฑ์
distance[i[0]] = cost # ๊ฑฐ๋ฆฌํ
์ด๋ธ ๊ฐฑ์
hq.heappush(q, (cost, i[0])) # ๊ฐฑ์ ๋
ธ๋์ ๊ฑฐ๋ฆฌ์ ๋
ธ๋๋ฒํธ๋ฅผ heap ์ push
dijkstra(start)
for i in range(1, v + 1):
if distance[i] == MAX:
print("INF")
else:
print(distance[i])
Python
๋ณต์ฌ