[BOJ][๐ŸŸก4][๋ฐฑ์ค€#01939] ์ค‘๋Ÿ‰์ œํ•œ

์ž‘์„ฑ:    

์—…๋ฐ์ดํŠธ:

์นดํ…Œ๊ณ ๋ฆฌ:

ํƒœ๊ทธ: , , ,

๋ฌธ์ œ ์ถœ์ฒ˜

BAEKJOON Online Judge #1939


๋ฌธ์ œ

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]๋ฅผ ์ถœ๋ ฅํ•˜๊ณ  ๋งˆ์นœ๋‹ค.

์ฝ”๋“œ๋ฅผ ๋ณด๋ฉด์„œ ๋†€๋ž๋Š”๋ฐ ๊ต‰์žฅํžˆ ๋˜‘๋˜‘ํ•œ ํ’€์ด์˜€๋‹ค๊ณ  ์ƒ๊ฐํ•œ๋‹ค.

๋Œ“๊ธ€๋‚จ๊ธฐ๊ธฐ