๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ (Dijkstra Algorithm)
-ํน์ ๋ ธ๋์์ ์ถ๋ฐํ์ฌ ๋ค๋ฅธ ๋ชจ๋ ๋ ธ๋๊น์ง ๊ฐ ์ ์๋ ์ต๋จ๊ฒฝ๋ก๋ฅผ ๊ณ์ฐ
-๋งค ์ํฉ์์ ๊ฐ์ฅ ๋น์ฉ์ด ์ ๊ฒ ๋๋ ๋ ธ๋๋ฅผ ์ ํํ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค (๊ทธ๋ฆฌ๋์)
-๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์์์ผ ๋ ์ ์์ ์ผ๋ก ๋์ํ๋ค
๊ตฌํ ๋ฐฉ๋ฒ
1) ์ต๋จ๊ฑฐ๋ฆฌ ํ ์ด๋ธ์ ์ด๊ธฐํํ๋ค. (์ถ๋ฐ๋ ธ๋๋ 0, ๋๋จธ์ง๋ INF)
2) ํ์ฌ ๋ ธ๋์ ์ธ์ ํ๊ณ ๋ฐฉ๋ฌธํ์ง ์์ ๋ ธ๋ ์ค ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋ ธ๋๋ฅผ ์ ํ
3) 2์์ ์ ํํ ๋ ธ๋๋ฅผ ๊ฑฐ์ณ ๋ค๋ฅธ ๋ ธ๋๋ก ๊ฐ๋ ๋น์ฉ์ ๊ณ์ฐ, ์ต๋จ๊ฑฐ๋ฆฌ ํ ์ด๋ธ์ ๊ฐฑ์
4) 2,3๋ฒ ๊ณผ์ ๋ฐ๋ณต
ํ์ฌ ๋ ธ๋๋ก๋ถํฐ ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋ ธ๋ ์ ํํ๊ธฐ
๊ฐ๋จํ๊ฒ ์ธ์ ํ ๋ ธ๋๋ฅผ ๋งค๋ฒ ๋ชจ๋ ์ํํ๋ ๋ฐฉ๋ฒ์ ๋ ์ฌ๋ฆด ์ ์๋ค.
๊ทธ๋ฌ๋ ์ ํํ์์ผ๋ก ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ์งง์ ๋ ธ๋๋ฅผ ์ ํํ๊ฒ ๋๋ฉด ์๊ฐ๋ณต์ก๋๊ฐ O(n^2)์ผ๋ก,
์ ๋ ฅ๋ฐ์ ๋ ธ๋ ๊ฐ์๊ฐ ๋งค์ฐ ๋ง๋ค๋ฉด(์๋ฅผ ๋ค๋ฉด, 1๋ง ๊ฐ ์ด์) ์๊ฐ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ ์ ํํ์ ๋์ , ์ฐ์ ์์ํ๋ฅผ ์ด์ฉํ๋๋ก ํ๋ค!
์ฐ์ ์์ํ ๊ตฌํ์ ์ฌ์ฉํ๋ ์๋ฃ๊ตฌ์กฐ ์ค ํ๋๋ ํ์ธ๋ฐ,
ํ์ ์ฝ์ ๋๋ ์ญ์ ์ O(logN)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๊ฒ ๋๋ฏ๋ก ์ฐ์ฐ์ํ์๊ฐ์ ํฌ๊ฒ ์ค์ผ ์ ์๋ค.
์ฐธ๊ณ ๋ก, ํ์ด์ฌ์์ ๊ธฐ๋ณธ์ผ๋ก ์ ๊ณตํ๋ heapq ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ต์ํ์ผ๋ก ๊ตฌํ๋๋ค.
ํ์ด์ฌ ์ฝ๋
import heapq
import sys
input = sys.stdin.readline
INF = int(1e9) #๋งค์ฐ ํฐ ์ซ์์ธ 10์ต์ ๋ฌดํ๋๋ก ์ ์ํ๋ค
#n(๋
ธ๋ ์), m(๊ฐ์ ์), x(์ถ๋ฐ๋
ธ๋) ์
๋ ฅ๋ฐ๊ธฐ
n,m = map(int,input().split())
x = int(input())
#๊ฐ์ ์ ๋ณด๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ
graph = [[] for i in range(n+1)]
#์ต๋จ๊ฑฐ๋ฆฌ ์ ๋ณด๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ (์ด๊ธฐ๊ฐ์ ์ ๋ถ ๋ฌดํ๋๋ก ์ด๊ธฐํ)
distance = [INF]*(n+1)
#๊ฐ์ ์ ๋ณด ์
๋ ฅ๋ฐ๊ธฐ (a์์ b ๋
ธ๋๋ก ๊ฐ๋ ๋น์ฉ์ด c)
for _ in range(m):
a,b,c = map(int,input().split())
graph[a].append((b,c))
def dijkstra(start):
q=[]
heapq.heappush(q,(0,start)) # ์ฐ์ ์์ํ์ ์์๋
ธ๋์ ๊ทธ ์ต๋จ๊ฒฝ๋ก ์ ๋ณด๋ฅผ ์ฝ์
distance[start]=0 #์ถ๋ฐ๋
ธ๋ ์๊ธฐ์์ ๊น์ง์ ๊ฑฐ๋ฆฌ๋ 0
#์ฐ์ ์์ํ๊ฐ ๋น ๋๊น์ง ํ๋์ฉ ๊บผ๋ด์ ์ฒดํฌ
while q:
dist, now = heapq.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(x)
#๊ฐ ๋
ธ๋๋ณ๋ก ์ต๋จ๊ฒฝ๋ก ์ถ๋ ฅ
for i in range(1,n+1):
if distance[i]==INF:
print("๋๋ฌํ ์ ์์")
else:
print(distance[i])
'์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด > Shortest Path' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค]1753๋ฒ: ์ต๋จ๊ฒฝ๋ก (0) | 2023.02.28 |
---|---|
[๋ฐฑ์ค]18352๋ฒ: ํน์ ๊ฑฐ๋ฆฌ์ ๋์ ์ฐพ๊ธฐ (0) | 2023.02.28 |
Floyd-Warshall ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ(python) (0) | 2023.02.28 |
[์ด์ฝํ ]๋ฏธ๋ ๋์ (0) | 2023.02.27 |
[์ด์ฝํ ]์ ๋ณด (0) | 2023.02.27 |