๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“Š Algorithm/BOJ

โœ… BOJ 1504 - ๋‹ค์ต์ŠคํŠธ๋ผ ์‘์šฉ

by huis_log 2025. 7. 4.

๋‹ค์ต์ŠคํŠธ๋ผ

๋ฐฑ์ค€ 1504๋ฒˆ: ํŠน์ •ํ•œ ์ตœ๋‹จ๊ฒฝ๋กœ

ALGORITHM

๋‹ค์ต์ŠคํŠธ๋ผ ์‚ฌ์šฉํ•จ

PROBLEM

์‹œ์ž‘์  1์—์„œ ๋์  N๊นŒ์ง€ ๊ฐ
v1, v2 ๋‘ ์ •์  ๋ฐ˜๋“œ์‹œ ์ง€๋‚˜์•ผ ํ•จ
์ˆœ์„œ๋Š” ์ž์œ , ๊ฐ„์„  ์žฌ์‚ฌ์šฉ ๊ฐ€๋Šฅ
ํ•ญ์ƒ ์ตœ๋‹จ๊ฒฝ๋กœ์—ฌ์•ผ ํ•จ

APPROACH

๋‹ค์ต์ŠคํŠธ๋ผ ์ด 3๋ฒˆ ๋Œ๋ฆผ
1 → v1 → v2 → N
1 → v2 → v1 → N
๋‘ ๊ฒฝ๋กœ ๊ณ„์‚ฐํ•ด์„œ ๋” ์งง์€ ์ชฝ ์”€

๋‹ค์ต์ŠคํŠธ๋ผ๋Š” ์‹œ์ž‘๋…ธ๋“œ ํ•˜๋‚˜์—์„œ ๋ชจ๋“  ๋…ธ๋“œ๊นŒ์ง€ ๊ฑฐ๋ฆฌ ๋ฐฐ์—ด ๋งŒ๋“ค๊ณ 
ํ•„์š”ํ•œ ๊ตฌ๊ฐ„๋งŒ ๊บผ๋‚ด์„œ ๋”ํ•จ
๋ชฉํ‘œ๋…ธ๋“œ๋Š” ํ•จ์ˆ˜ ์•ˆ์—์„œ ์•ˆ ์”€

IMPLEMENTATION

๊ทธ๋ž˜ํ”„๋Š” (๊ฐ€์ค‘์น˜, ๋‹ค์Œ๋…ธ๋“œ) ํ˜•ํƒœ๋กœ ์ €์žฅ
heapq์— (๋ˆ„์ ๊ฐ€์ค‘์น˜, ๋…ธ๋“œ)๋กœ ๋„ฃ๊ณ  ์ตœ์†Œ๊ฑฐ๋ฆฌ ๊ฐฑ์‹ 
์‹œ์ž‘๋…ธ๋“œ ๋ฐ”๋€Œ๋ฉด ํž™๊ณผ ๊ฑฐ๋ฆฌ๋ฐฐ์—ด ์ƒˆ๋กœ ๋งŒ๋“ฆ
๊ฒฝ๋กœ ์—†์œผ๋ฉด INF ๋‚จ์Œ → -1 ์ถœ๋ ฅ

SUMMARY

๊ฒฝ๋กœ ์ถœ๋ ฅ ์•ˆ ํ•จ, ๊ฐ€์ค‘์น˜๋งŒ ํ•„์š”
๋‹ค์ต์ŠคํŠธ๋ผ 3๋ฒˆ, ๋‘ ์ผ€์ด์Šค ๋น„๊ต๋กœ ๋๋ƒ„

 

#dijkstra,shortest_path
import sys,heapq
input=sys.stdin.readline

def dijkstra(start,n,graph):
    heap=[]
    heapq.heappush(heap,(0,start)) #(๊ฐ€์ค‘์น˜,์‹œ์ž‘๋…ธ๋“œ)
    INF=float('inf')
    distance=[INF]*(n+1)
    distance[start]=0
    
    while heap:
        current_weight,current_node=heapq.heappop(heap)
        for next_weight,next_node in graph[current_node]:    
            accumulated_weight=current_weight+next_weight
            if accumulated_weight<distance[next_node]:
                distance[next_node]=accumulated_weight
                heapq.heappush(heap,(accumulated_weight,next_node))
    
    return distance

n,e=map(int,input().split())
graph=[[] for _ in range(n+1)]

for _ in range(e):
    start,end,weight=map(int,input().split())
    graph[start].append((weight,end))
    graph[end].append((weight,start))

v1,v2=map(int,input().split())

distance_from_start=dijkstra(1,n,graph)
distance_from_v1=dijkstra(v1,n,graph)
distance_from_v2=dijkstra(v2,n,graph)

#1->v1->v2->n
shortest_path1=distance_from_start[v1]+distance_from_v1[v2]+distance_from_v2[n]
#1->v2->v1->n
shortest_path2=distance_from_start[v2]+distance_from_v2[v1]+distance_from_v1[n]
shorest_path=min(shortest_path1,shortest_path2)
print(shorest_path if shorest_path<float('inf') else -1)
๋ฐ˜์‘ํ˜•