[BOJ][๐ก4][๋ฐฑ์ค#09694] ๋ฌด์์ ์๋๋๊ฐ ์๋๋ผ ๋๊ตฌ๋ฅผ ์๋๋๊ฐ ๋ฌธ์ ๋ค
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold IV
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
ํ์ ์ด๋ ์ ๊ณ , ๋๋ํ๊ณ ๋งค์ฐ ์ ๋ช ํ ์ ์น์ธ์ด๋ค. ๊ทธ๋ผ์๋ ๊ทธ๋ ์ฌ์ ํ ์์ ์ ์ฑ๊ณต์ ์ํด์๋ ์ธ๊ฐ๊ด๊ณ๋ ์ค์ํ๊ฒ์ด๋ผ๊ณ ๋ฏฟ๊ณ ์๋ค. ๋ค์๋ฌ์ ์ด๋ฆด ๊ตญํ์์์ ๊ฑฐ์์ ํ์ ์ด๋ ์์ ์ ๋น์ด ๋ฐ๋์ ์ด๊ธฐ๊ธธ ํฌ๋งํ๋ค. ๊ทธ๋ฌ๊ธฐ ์ํด์ ์ต๊ณ ์์์ ์ง์ง๊ฐ ํ์ํ๋ค.
์ด ์ต๊ณ ์์์ ์ง์ง๋ฅผ ๋ฐ๊ธฐ์ํด ํ์ ์ด๋ ์ ๋ต์ ์ธ์ ๋ค. ๊ทธ๋ ๊ทธ ์ต๊ณ ์์์ ์ง์ ์ ์ผ๋ก ๋ง๋ ์ ์๋ค๋ฉด ๊ทธ๋ฅผ ์๊ณ ์๋ ์ธ๋งฅ์ ์ด์ฉํ์ฌ ๋ง๋ ๊ฒ์ด๋ค. ์ด๊ฒ์ ์ํด์ ์ฐ์ ์ ์น์ธ๋ค์ ์น๋ฐ๋๋ฅผ ์กฐ์ฌํ์๋๋ฐ ์น๋ฐ๋๋ฅผ ๋ค์ 4๋จ๊ณ๋ก ๋๋์ด์ ๊ธฐ๋กํด๋์๋ค. ์ต์ธก๊ทผ [1] / ์ธก๊ทผ [2] / ๋น์ฆ๋์ค๊ด๊ณ [3] / ์ง์ธ [4] [๋ ์ฌ๋์ ๊ด๊ณ๋ ์ด 4๊ฐ์ง ๊ฒฝ์ฐ์ค ๋ฐ๋์ ํด๋น๋๋ฉฐ, ์ (enemy)๋ ์กด์ฌํ์ง ์๋๋ค.] ํ์ ์ด๋ ์ง์ธ๋ณด๋ค๋ ์ต์ธก๊ทผ ์น๊ตฌ์๊ฒ ์๊ฐ๋ฐ๊ธฐ ์ํ๋ค. ๊ทธ๋์ ์ต๊ณ ์์์ ๋ง๋๊ธฐ๊น์ง์ ์ธ๋งฅ๊ฐ ์น๋ฐ๋์ ํฉ์ ์ต์ํํ๊ณ ์ถ์ดํ๋ค. N๋ช ์ ์ ์น์ธ ๋ช ๋จ์ผ๋ก๋ถํฐ ๊ทธ๋ค์ ์ธ๋งฅ ์น๋ฐ๋๊ฐ ์ฃผ์ด์ง๋ค. ์ ์น์ธ ๋ฆฌ์คํธ๋ฅผ ๋ณด๊ณ ํ์ ์ด๊ฐ ์ต๊ณ ์์์ ๋ง๋๊ธฐ๊น์ง์ ์น๋ฐ๋์ ํฉ ์ค์์ ๊ฐ์ฅ ์์ ๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค.
์ ๋ ฅ
๋งจ์ ์ฒซ ๋ฒ์งธ ์ค์ T(1 <T< 100)๋ ํ ์คํธ์ผ์ด์ค ์๋ฅผ ์๋ฏธํ๋ค. ์ด๊ฒ์ ๋ฐ๋ผ ๋ค์์ค์ ๊ฐ ํ ์คํธ ์ผ์ด์ค๊ฐ ์ฃผ์ด์ง๋๋ฐ, ์ฒซ ๋ฒ์งธ ์ค์๋ N๊ณผ M์ด ์ฃผ์ด์ง๋ค. N(N โค 20)์ ๊ด๊ณ์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ฉฐ, M(5 โคMโค 20)์ ์ ์น์ธ์ ์๋ฅผ ๋ํ๋ธ๋ค. ์ด ๋ค์ N์ค์๋ ์ ์น์ธ x, ๊ทธ์ ์น๊ตฌ y (0 โคx,y< M), ๋์ฌ๋๊ฐ์ ์น๋ฐ๋ z(1 โคzโค 4)๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค. ์ ์น์ธ 0๋ฒ์ ํ์ ์ด๋ฅผ ๋ํ๋ด๊ณ M-1์ ์ต๊ณ ์์์ ์๋ฏธํ๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค๋ โCase #x: โ์ ํ์์ผ๋ก ์ถ๋ ฅ๋๋ฉฐ x๋ ์ผ์ด์ค ๋ฒํธ(1๋ถํฐ ์์)์ ์๋ฏธํ๋ค. ์ฝ๋ก ๋ค์ ํ์ ์ด๊ฐ ์ต๊ณ ์์์ ๋ง๋ ์ ์๋ค๋ฉด 0๋ฒ ์ ์น์ธ(ํ์ ์ด)๋ฅผ ์์์ผ๋ก M-1๋ฒ ์ ์น์ธ(์ต๊ณ ์์)๊น์ง ๋ง๋ ์์๋๋ก ์ถ๋ ฅํ๋ฉด ๋๊ณ , ์ต๊ณ ์์์ ๋ง๋ ์ ์๋ ๊ฒฝ์ฐ์ -1์ ์ถ๋ ฅํ๋ฉด ๋๋ค.
์์
์ ๋ ฅ
2
7 5
0 1 2
1 3 4
0 2 1
0 4 3
3 2 3
3 4 4
2 4 1
3 5
0 1 2
1 3 4
4 2 1
์ถ๋ ฅ
Case #1: 0 2 4
Case #2: -1
My Sol
import sys
input = sys.stdin.readline
from collections import deque
T = int(input())
for t in range(T):
N, M = map(int, input().split())
G = [[] for _ in range(M+1)]
for _ in range(N):
u, v, w = map(int, input().split())
G[u].append((v, w))
G[v].append((u, w))
check = [[1e5, []] for _ in range(M+1)]
check[0] = [0, [0]]
Q = deque()
Q.append((0, 0))
while Q:
u, cost = Q.popleft()
for v, w in G[u]:
if not (cost + w < check[v][0]): continue
check[v] = [cost + w, check[u][1]+[v]]
Q.append((v, cost+w))
ret = [-1] if check[M-1][0] == 1e5 else check[M-1][1]
print(f'Case #{t+1}:', *ret)
๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํ๋ฉฐ ๋ฌธ์ ๋ฅผ ํ์๋ค. ๋จ์ง ์ต์๋น์ฉ์ด ์๋๋ผ ๊ฒฝ๋ก๋ฅผ ๊ตฌํด์ผํ๊ณ , ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ์ ์ต์๋น์ฉ์ ๋น๊ตํ์ฌ ๊ฐฑ์ ํ๋ ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์ ์ต์๋น์ฉ์ ๊ฐฑ์ ํ ์ ์๋ค๋ฉด ๊ฒฝ๋ก๊น์ง ๊ฐฑ์ ํ ์ ์๋๋ก ๊ธฐ๋ณธ ๋ฐฐ์ด์ ๋น์ฉ๊ณผ ๊ฒฝ๋ก๋ฅผ ๋ฃ์ด ์ด๊ธฐํํด์ฃผ์๋ค.
์ ๊ทผ ๋ฐฉ์
- ๋น์ฉ ์ฒดํฌ ๋ฐฐ์ด check๋ฅผ [1e5, []]๋ก ์ด๊ธฐํํ๋ค.
- ์์ ์ง์ ์ [0, [0]]์ผ๋ก ์ด๊ธฐํํ๋ค.
- ์ด๋ฅผ deque Q์ ๋ฃ๋๋ค. ์์ผ๋ก ์ต์๊ฒฝ๋ก๋ก ๊ฐฑ์ ๋๋ ์ง์ ์ deque์ ๋ฃ์ ๊ฒ์ด๋ค.
- ๋งค ๋ฐ๋ณต์ ์์์ u์ ์ฐ๊ฒฐ๋ G[u]์ ์ง์ ๋ค์ v, u์ v ์ฌ์ด์ ๋น์ฉ์ w๋ก ๋๋ค.
- ๋ง์ฝ cost, ์ฆ 0๋ฒ๋ถํฐ u๊น์ง์ ์ต์๋น์ฉ๊ณผ w๋ฅผ ๋ํ ๊ฐ์ด ํ์ฌ 0๋ฒ๋ถํฐ v๊น์ง์ ์ต์๋น์ฉ๋ณด๋ค ์ ์ ๊ฒฝ์ฐ, ์ต์๋น์ฉ๊ณผ ๊ฒฝ๋ก๋ฅผ ๊ฐฑ์ ํด์ค๋ค.
- ๊ฐฑ์ ํ์ผ๋ฏ๋ก Q์ ์ต์๋น์ฉ๊ณผ ๊ฒฝ๋ก๋ฅผ ์ถ๊ฐํด์ค๋ค. ์ด๊ฒ์ด ๋๋ค๋ฅธ ์์์ ์ด ๋ ๊ฒ์ด๋ค.
- ๊ฐ๋ฅํ ๋ชจ๋ ๊ฐฑ์ ์ ๋ง์น ๋ค, M-1์ง์ ์ ์ต์๋น์ฉ์ ์ฒดํฌํ๋ค.
- ์ด๊ฒ์ด 1e5๋ผ๋ฉด ๊ฐฑ์ ์ด ์ ๋ ๊ฒ์ด๋ฏ๋ก -1์ด๊ณ , ์๋๋ผ๋ฉด ๊ฐฑ์ ์ ํ ๊ฒ์ด๋ฏ๋ก path๋ฅผ ์ถ๋ ฅํด์ค๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋๊ธ๋จ๊ธฐ๊ธฐ