[BOJ][๐ก4][๋ฐฑ์ค#01939] ์ค๋์ ํ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold IV
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
N(2 โค N โค 10,000)๊ฐ์ ์ฌ์ผ๋ก ์ด๋ฃจ์ด์ง ๋๋ผ๊ฐ ์๋ค. ์ด๋ค ์ค ๋ช ๊ฐ์ ์ฌ ์ฌ์ด์๋ ๋ค๋ฆฌ๊ฐ ์ค์น๋์ด ์์ด์ ์ฐจ๋ค์ด ๋ค๋ ์ ์๋ค. ์์ ์ค๊ณต์ ์์๋ ๋ ๊ฐ์ ์ฌ์ ๊ณต์ฅ์ ์ธ์ ๋๊ณ ๋ฌผํ์ ์์ฐํ๋ ์ผ์ ํ๊ณ ์๋ค. ๋ฌผํ์ ์์ฐํ๋ค ๋ณด๋ฉด ๊ณต์ฅ์์ ๋ค๋ฅธ ๊ณต์ฅ์ผ๋ก ์์ฐ ์ค์ด๋ ๋ฌผํ์ ์์กํด์ผ ํ ์ผ์ด ์๊ธฐ๊ณค ํ๋ค. ๊ทธ๋ฐ๋ฐ ๊ฐ๊ฐ์ ๋ค๋ฆฌ๋ง๋ค ์ค๋์ ํ์ด ์๊ธฐ ๋๋ฌธ์ ๋ฌดํฑ๋๊ณ ๋ฌผํ์ ์ฎ๊ธธ ์ ์๋ค. ๋ง์ฝ ์ค๋์ ํ์ ์ด๊ณผํ๋ ์์ ๋ฌผํ์ด ๋ค๋ฆฌ๋ฅผ ์ง๋๊ฒ ๋๋ฉด ๋ค๋ฆฌ๊ฐ ๋ฌด๋์ง๊ฒ ๋๋ค. ํ ๋ฒ์ ์ด๋์์ ์ฎ๊ธธ ์ ์๋ ๋ฌผํ๋ค์ ์ค๋์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N, M(1 โค M โค 100,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ M๊ฐ์ ์ค์๋ ๋ค๋ฆฌ์ ๋ํ ์ ๋ณด๋ฅผ ๋ํ๋ด๋ ์ธ ์ ์ A, B(1 โค A, B โค N), C(1 โค C โค 1,000,000,000)๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ A๋ฒ ์ฌ๊ณผ B๋ฒ ์ฌ ์ฌ์ด์ ์ค๋์ ํ์ด C์ธ ๋ค๋ฆฌ๊ฐ ์กด์ฌํ๋ค๋ ์๋ฏธ์ด๋ค. ์๋ก ๊ฐ์ ๋ ์ฌ ์ฌ์ด์ ์ฌ๋ฌ ๊ฐ์ ๋ค๋ฆฌ๊ฐ ์์ ์๋ ์์ผ๋ฉฐ, ๋ชจ๋ ๋ค๋ฆฌ๋ ์๋ฐฉํฅ์ด๋ค. ๋ง์ง๋ง ์ค์๋ ๊ณต์ฅ์ด ์์นํด ์๋ ์ฌ์ ๋ฒํธ๋ฅผ ๋ํ๋ด๋ ์๋ก ๋ค๋ฅธ ๋ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ๊ณต์ฅ์ด ์๋ ๋ ์ฌ์ ์ฐ๊ฒฐํ๋ ๊ฒฝ๋ก๋ ํญ์ ์กด์ฌํ๋ ๋ฐ์ดํฐ๋ง ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ต์ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
3 3
1 2 2
3 1 3
2 3 2
1 3
์ถ๋ ฅ
3
My Sol
import sys
input = sys.stdin.readline
V, E = map(int, input().split())
G = [[] for _ in range(V+1)]
D = [0]*(V+1)
for _ in range(E):
u, v, w = map(int, input().split())
G[u].append((v, w))
G[v].append((u, w))
S, T = map(int, input().split())
Q = set()
D[S] = 0xffffffff
Q.add(S)
while Q:
u = Q.pop()
for v, w in G[u]:
minV = min(D[u], w)
if D[v] >= minV: continue
D[v] = minV
Q.add(v)
print(D[T])
๋ค์ต์คํธ๋ผ์ฒ๋ผ ์ ๊ทผํด๋ณด๋ ค ํ์ผ๋ ์ต๋๊ฐ์ ์ฐพ๋ ๊ฒ์ด์ด์ set์ ์ด์ฉํด ๊ฐ ์ ์๋ ๋ ธ๋๋ฅผ ๋ชจ๋ ๊ฐ๋ณด๋ฉฐ ๋ชฉ์ ์ง์ธ T๊น์ง ๊ฐ๋ ๊ฒฝ๋ก๋ฅผ ์ต๋ ์ค๋์ผ๋ก ์ ์งํ์๋ค. ๋ค์ ๋์๊ฐ๋ ๊ฒ์ D[v] >= min(D[u], w) ์ธ ๊ฒฝ์ฐ continueํ์๊ธฐ ๋๋ฌธ์ ์๋์ผ๋ก visit ์ฒ๋ฆฌ๋๋ค.
๋ ธ๋์ ์ค๋ณต์ด ์์ ์ ์์ด set์ ์ฌ์ฉํ์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
import sys
input = sys.stdin.readline
def find(x):
if x != parent[x]:
parent[x] = find(parent[x])
return parent[x]
def union_(a, b):
a = find(a)
b = find(b)
if a == b:
return
parent[a] = b
N, M = map(int, input().split())
graph = []
for i in range(M):
a, b, cost = map(int, input().split())
graph.append([a, b, cost])
graph.sort(key=lambda x: -x[2])
parent = [i for i in range(N + 1)]
v1, v2 = map(int, input().split())
for i in range(M):
union_(graph[i][0], graph[i][1])
if find(v1) == find(v2):
print(graph[i][2])
break
์ฐ์ฐ์๊ฐ์ด 30%์ ๋ ๋๋ ํ์ด๋ฅผ ๋ฐ๊ฒฌํด ๋ถ์ํด๋ณด๋ ค ํ๋ค. ์ ๋์จ ํ์ธ๋๋ฅผ ์ด์ฉํด ์๋ก์ ์งํฉ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์๋ค. ๊ฐ์ ์ ๋ ฅ์ ๋ชจ๋ ๋ฆฌ์คํธ์ ๋ด์ cost๊ฐ ํฐ ์์๋๋ก ์ ๋ ฌํ๊ณ , M๊ฐ์ ๋ชจ๋ ๊ฐ์ ์ ๋ํด ์ ๋์จ์ ์ค์ํ๋ค. ๋ง์ฝ ์ถ๋ฐ์ v1๊ณผ ๋์ฐฉ์ v2๊ฐ ๊ฐ์ ๋ฃจํธ ๋ ธ๋๋ฅผ ๊ณต์ , ์ฆ ์ฐ๊ฒฐ๋์ด ์๋ค๋ฉด ๊ทธ ์ฌ์ด์๋ ๊ฐ๋ฅํ ํฐ ์ค๋๋ค๋ก๋ง ์ด์์ ๊ฒ์ด๊ณ , ํ์ฌ ๊ฐ์ ์ ์ด์์ผ๋ก์ ๋ ์ฌ์ด๊ฐ ์ฐ๊ฒฐ๋ ๊ฒ์ด๋ค. ๋๋ฌธ์ ํ์ฌ์ cost์ธ graph[i][2]๋ฅผ ์ถ๋ ฅํ๊ณ ๋ง์น๋ค.
์ฝ๋๋ฅผ ๋ณด๋ฉด์ ๋๋๋๋ฐ ๊ต์ฅํ ๋๋ํ ํ์ด์๋ค๊ณ ์๊ฐํ๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ