๐ ์ต์๋น์ฉ ๊ตฌํ๊ธฐ 2
๋ฐฑ์ค Gold3
๋ฌธ์
n(1โคnโค1,000)๊ฐ์ ๋์๊ฐ ์๋ค. ๊ทธ๋ฆฌ๊ณ ํ ๋์์์ ์ถ๋ฐํ์ฌ ๋ค๋ฅธ ๋์์ ๋์ฐฉํ๋ m(1โคmโค100,000)๊ฐ์ ๋ฒ์ค๊ฐ ์๋ค. ์ฐ๋ฆฌ๋ A๋ฒ์งธ ๋์์์ B๋ฒ์งธ ๋์๊น์ง ๊ฐ๋๋ฐ ๋๋ ๋ฒ์ค ๋น์ฉ์ ์ต์ํ ์ํค๋ ค๊ณ ํ๋ค. ๊ทธ๋ฌ๋ฉด A๋ฒ์งธ ๋์์์ B๋ฒ์งธ ๋์ ๊น์ง ๊ฐ๋๋ฐ ๋๋ ์ต์๋น์ฉ๊ณผ ๊ฒฝ๋ก๋ฅผ ์ถ๋ ฅํ์ฌ๋ผ. ํญ์ ์์์ ์์ ๋์ฐฉ์ ์ผ๋ก์ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋์์ ๊ฐ์ n(1โคnโค1,000)์ด ์ฃผ์ด์ง๊ณ ๋์งธ ์ค์๋ ๋ฒ์ค์ ๊ฐ์ m(1โคmโค100,000)์ด ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ์ ์งธ ์ค๋ถํฐ m+2์ค๊น์ง ๋ค์๊ณผ ๊ฐ์ ๋ฒ์ค์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๋จผ์ ์ฒ์์๋ ๊ทธ ๋ฒ์ค์ ์ถ๋ฐ ๋์์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ค์์๋ ๋์ฐฉ์ง์ ๋์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๊ณ ๋ ๊ทธ ๋ฒ์ค ๋น์ฉ์ด ์ฃผ์ด์ง๋ค. ๋ฒ์ค ๋น์ฉ์ 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100,000๋ณด๋ค ์์ ์ ์์ด๋ค.
๊ทธ๋ฆฌ๊ณ m+3์งธ ์ค์๋ ์ฐ๋ฆฌ๊ฐ ๊ตฌํ๊ณ ์ ํ๋ ๊ตฌ๊ฐ ์ถ๋ฐ์ ์ ๋์๋ฒํธ์ ๋์ฐฉ์ ์ ๋์๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ถ๋ฐ ๋์์์ ๋์ฐฉ ๋์๊น์ง ๊ฐ๋๋ฐ ๋๋ ์ต์ ๋น์ฉ์ ์ถ๋ ฅํ๋ค.
๋์งธ ์ค์๋ ๊ทธ๋ฌํ ์ต์ ๋น์ฉ์ ๊ฐ๋ ๊ฒฝ๋ก์ ํฌํจ๋์ด์๋ ๋์์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค. ์ถ๋ฐ ๋์์ ๋์ฐฉ ๋์๋ ํฌํจํ๋ค.
์ ์งธ ์ค์๋ ์ต์ ๋น์ฉ์ ๊ฐ๋ ๊ฒฝ๋ก๋ฅผ ๋ฐฉ๋ฌธํ๋ ๋์ ์์๋๋ก ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
5
8
1 2 2
1 3 3
1 4 1
1 5 10
2 4 2
3 4 1
3 5 1
4 5 3
1 5
์์ ์ถ๋ ฅ 1
4
3
1 3 5
๐ ์๊ณ ๋ฆฌ์ฆ
์์ ๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ํํํด๋ณด๋ฉด ์์ ๊ฐ๋ค.
๋ฒ์ค ๋น์ฉ์ด ์กด์ฌํ๋ ๋ ธ์ ๋์์ A ๋์์์ B ๋์๋ก ๊ฐ๋ ์ต์ ๋น์ฉ์ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค.
์ด๋ฅผ ์ผ๋ฐํ ํ๋ฉด [Weight๊ฐ ์กด์ฌํ๋ ๊ทธ๋ํ์์ ํน์ ๋ ธ๋์์ ํน์ ๋ ธ๋๋ก ๊ฐ๋ ์ต์ ๋น์ฉ์ ๋ฌป๋] ๋ฌธ์ ๋ก ๋ฐ๋ผ๋ณผ ์ ์๋ค. ๋ฐ๋ก ๋ค์ต์คํธ๋ผ๋ฅผ ๊ฐ๋ค ์จ์ฃผ๋ฉด ๋๋ค.
๋ค์ต์คํธ๋ผ ๊ธฐ๋ณธ ๋ฌธ์ ์์ ๊ฒฝ๋ก๋ฅผ ์ ์ฅํ์ฌ ์ถ๋ ฅํด์ค๋ค๋ ์กฐ๊ฑด๋ง ์ถ๊ฐํ๋ฉด ๋๋ค.
๐จ๐ปโ๐ป CODE
import heapq as h
import sys
input = sys.stdin.readline
INF = int(1e9)
city = int(input())
bus = int(input())
graph = [[] for _ in range(city+1)]
for i in range(bus):
a,b,c = map(int,input().split())
graph[a].append((b,c))
start,end = map(int,input().split())
####
def dijkstra(start):
distance = [INF]*(city+1)
heap = []
h.heappush(heap,(0,start))
distance[start] = 0
path = [[] for _ in range(city+1)] # ๊ฒฝ๋ก
path[start].append(start)
while heap:
dist,now = h.heappop(heap)
if distance[now] < dist:
continue
for i in graph[now]:
cost = dist + i[1]
if cost < distance[i[0]]:
distance[i[0]] = cost
h.heappush(heap,(cost,i[0]))
path[i[0]] = []
for j in path[now]:
path[i[0]].append(j)
path[i[0]].append(i[0])
return distance,path
distance,path = dijkstra(start)
print(distance[end])
print(len(path[end]))
print(" ".join(map(str,path[end])))