improved_dijkstra
๊ฐ๋จํ ๋ค์ต์คํธ๋ผ๋ O(v^2)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ ธ ๋
ธ๋์ ๊ฐ์๊ฐ 10000๊ฐ๋ฅผ ๋์ด๊ฐ๋ฉด ํ์๊ฐ ์๋ค.
ํ์ง๋ง ๊ฐ์ ๋ ๋ค์ต์คํธ๋ผ๋ ์ต์
์ ๊ฒฝ์ฐ์๋ O(ElogV)๋ฅผ ๋ณด์ฅํ์ฌ ํด๊ฒฐํ ์ ์๋ค. (V๋ ๋
ธ๋์ ๊ฐ์, E๋ ๊ฐ์ ์ ๊ฐ์)
๊ธฐ์กด ๊ฐ๋จํ ๋ค์ต์คํธ๋ผ๋ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ์์์๋ถํฐ ํ๋์ฉ ํ์ธํ๋๋ฐ ์ด๋ฅผ ๋์ฑ ๋น ๋ฅด๊ฒ heap๊ตฌ์กฐ์ ์ฐ์ ์์ ํ๋ก ์ฐพ๋๋ค๋๊ฒ์ด ํต์ฌ ํฌ์ธํธ์ด๋ค.
- ์ฐ์ ์์ ํ๋ ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ์ญ์ ํ๋ค๋ ํน์ง์ด ์๊ณ heapq ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํตํด ์ฌ์ฉํ๋ค.
- ์ฐ์ ์์ ํ๋ ์ผ๋ฐ์ ์ผ๋ก ์ ์ํ ์๋ฃํ์ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ฉฐ (๊ฐ์น, ๋ฌด๊ฒ)๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๋ฅผ ์ฐ์ ์์ ํ์ ์ง์ด๋ฃ์ผ๋ฉด ํญ์ ๊ฐ์น๊ฐ ๋์ ๋ฌผ๊ฑด๋ถํฐ ๋จผ์ ๋์ค๊ฒ๋๋ค.(๋ง์ฝ (๋ฌด๊ฒ, ๊ฐ์น)๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๋ผ๋ฉด ๋ฌด๊ฒ๊ฐ ๋์ ์์ผ๋ก ๋์ค๊ฒ ๋๋ค.)(์ต๋ํ์ ์ฌ์ฉํ๋ค๊ณ ๊ฐ์ )
- ํ์ด์ฌ์์๋ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ต์ํ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋๋ฐ, ๋ค์ต์คํธ๋ผ๋ ์ต๋จ๊ฑฐ๋ฆฌ๋ ๊ตฌํ๋๊ฒ์ด๋ฏ๋ก ์ต์ํ์ ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด๋๋ค.
๊ฐ๋จํ ๋ค์ต์คํธ๋ผ์์ '์ต๋จ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์งง์ ๋ ธ๋๋ฅผ ์ ํํ๋ ํจ์'๋ฅผ ์ฐ์ ์์ ํ๋ก ๋์ฒด
import heapq
import sys
input = sys.stdin.readline # ์
๋ ฅ๋ฐ์ดํฐ๊ฐ ๋ง๋ค๋ ๊ฐ์ ํ์ ๋น ๋ฅธ ์
๋ ฅ์ ๋ฐ๋ ๋ด์ฅํจ์ ์ฌ์ฉ
INF = int(1e9) #๋ฌดํ์ ๋ํ๋ด๋ ๊ฐ์ผ๋ก 10์ต ์ค์
n, m = map(int, input().split()) #๋
ธ๋์ ๊ฐ์, ๊ฐ์ ์ ๊ฐ์
start = int(input()) # ์์ ๋
ธ๋๋ฒํธ
graph = [[] for i in range(n + 1)] # ๊ฐ ๋
ธ๋์ ์ฐ๊ฒฐ๋์ด ์๋ ๋
ธ๋์ ๋ํ ์ ๋ณด๋ฅผ ๋ด๋ ๋ฆฌ์คํธ
distance = [INF] * (n + 1) # ์ต๋จ ๊ฑฐ๋ฆฌ ํ
์ด๋ธ์ ๋ชจ๋ ๋ฌดํ๋๋ก ์ด๊ธฐํ
for _ in range(m): # ๋
ธ๋๋ค ๊ฐ ์ฐ๊ฒฐ ์ ๋ฌด์ ๊ฐ์ ์ ๋น์ฉ ์
๋ ฅ
a, b, c = map(int, input().split())
graph[a].append((b,c)) # a๋ฒ ๋
ธ๋์์ b๋ฒ ๋
ธ๋๋ก ๊ฐ๋๋น์ฉ์ด c๋ผ๋ ์๋ฏธ
def dijkstra(start):
q = []
heapq.heappush(q, (0, start)) # ์์๋
ธ๋๋ก ๊ฐ๊ธฐ ์ํ ์ต๋จ ๊ฒฝ๋ก๋ 0์ผ๋ก ์ค์ ํ์ฌ ํ์ ์ฝ์
(๋
ธ๋์ ๊ฒฝ๋ก์ ํฌ๊ธฐ๊ฐ ๋ฐ๋(heap์ ์์ ์ธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ต์๋ฅผ ์ฐพ๊ธฐ ๋๋ฌธ์))
distance[start] = 0
while q: # ํ(q)๊ฐ ๋น์ด์์ง ์๋ค๋ฉด
dist, now = heapq.heappop(q) # ๊ฐ์ฅ ์ต๋จ๊ฑฐ๋ฆฌ๊ฐ ์งง์ (๊ฐ์ฅ์์์๋) ๋
ธ๋์ ๋ํ ์ ๋ณด๋ฅผ ๊บผ๋ด์ด dist, now์ ์ ์ฅ(๊ฒฝ๋กํฌ๊ธฐ, ๋
ธ๋)
if distance[now] < dist: # ํ์ฌ ๋
ธ๋๊ฐ ์ด๋ฏธ ์ฒ๋ฆฌ๋์ ์๋ ๋
ธ๋๋ผ๋ฉด ๋ฌด์
continue
for i in graph[now]: # ํ์ฌ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋ค๋ฅธ ์ธ์ ํ ๋
ธ๋๋ค์ ํ์ธ
cost = dist + i[1]
if cost < distance[i[0]]: # ๋ง์ฝ ํ์ฌ ๋
ธ๋๋ฅผ ๊ฑฐ์ณ ๋ค๋ฅธ ๋
ธ๋๋ก ์ด๋ํ๋ ๊ฑฐ๋ฆฌ(dist + graph(1))๊ฐ ๋ ์งง์ ๊ฒฝ์ฐ ์
๋ฐ์ดํธ
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])
'์ฝ๋ฉํ ์คํธ > ๊ธฐ๋ณธ ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ต๋จ ๊ฒฝ๋ก (simple_dijkstra) (0) | 2022.02.24 |
---|---|
์ต๋จ๊ฑฐ๋ฆฌ (Floyd_Warshall) (0) | 2022.02.23 |
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ(Dynamic_Programming) (0) | 2022.02.20 |
์์ฐจํ์(Sequential_Search) (0) | 2022.02.20 |
์ด์งํ์(Binary_Search) (0) | 2022.02.20 |