๐กsolutions
๐ฌ ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
๐ฌ ํ๋์ ๋ง์์ ๋ถ๋ฆฌํ์ฌ ๋๊ฐ์ ๋ง์๋ก ๋ถํํ๋ฉด -> ๊ฐ ๋ง์ ์์ ์๋ ์ง๋ค์ ์๋ก ์ฐ๊ฒฐ๋ผ ์์ด์ผ ํ๋ฉฐ ์ด๋ ๊ธธ์ ์ ์ง๋น์ ํฉ์ ์ต์๊ฐ ๋ผ์ผ ํ๋ค
๐ฌ ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํ์ฌ N-1๊ฐ์ ์ง๋ค์ ์ฐ๊ฒฐํ๊ณ ๋ง์ง๋ง ์ ์ง๋น๊ฐ ์ต๋์ธ ๊ฒฝ๋ก๋ ๋์ผ๋ฉด (์ฆ, ์ฐ๊ฒฐํ์ง ์์ผ๋ฉด) ์ด๊ฒ ๋ฐ๋ก ์ ์ง๋น๊ฐ ์ต์๊ฐ ๋๋๋ก ๋ง์์ ๋๊ฐ๋ก ๋ถํํ๋ ๋ฐฉ๋ฒ์ด๋ค. -> ๊ฐ ์ง์ ์ฐ๊ฒฐํ ๋๋ง๋ค edge_cnt๋ฅผ ์ธ์ ๊ฐ์ ์ ๊ฐ์๊ฐ n-2๊ฐ ๋๋ฉด breakํ๋ค. (*์ฐธ๊ณ ๋ก MST์์ ๋ชจ๋ ๊ฐ์ ์ ์ฐ๊ฒฐํ ๋ ์ต์ ๊ฐ์ ์ ๊ฐ์๋ n-1์ด๋ค.)
๐ฌ ์ฒ์์ ํ์ด์ฌ์ผ๋ก ์ฝ๋๋ฅผ ์ ์ถํ์ ๋ ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ๊ณ , sys ๋ชจ๋์ ๋ถ๋ฌ์์ input = sys.stdin.readline์ผ๋ก ์ ๋ ฅ ๋ฐ์ผ๋ ํต๊ณผํ์๋ค. (๋๋ pypy๋ก ํต๊ณผํ ์๋ ์๋ค.)
๐จ๐ปcode
import sys
def find_parent(x):
if parent[x] != x:
return find_parent(parent[x])
return parent[x]
def union_parent(parent_a, parent_b):
if parent_a < parent_b:
parent[parent_b] = parent_a
else:
parent[parent_a] = parent_b
input = sys.stdin.readline
n, m = map(int, input().split())
arr = []
for _ in range(m):
a, b, c = map(int, input().split())
arr.append([a, b, c])
arr.sort(key=lambda x:x[2])
edge_cnt = 0
answer = 0
parent = [i for i in range(n+1)]
for node_a, node_b, cost in arr:
parent_a, parent_b = find_parent(node_a), find_parent(node_b)
if parent_a != parent_b:
union_parent(parent_a, parent_b)
answer += cost
edge_cnt += 1
if edge_cnt == n-2:
break
print(answer)
๐description
๋ฌธ์
๋๋ฌผ์์์ ๋ง ํ์ถํ ์์ญ์ด ํ ๋ง๋ฆฌ๊ฐ ์ธ์๊ตฌ๊ฒฝ์ ํ๊ณ ์๋ค. ๊ทธ๋ฌ๋ค๊ฐ ํํ๋ก์ด ๋ง์์ ๊ฐ๊ฒ ๋์๋๋ฐ, ๊ทธ๊ณณ์์๋ ์ ์ ์๋ ์ผ์ด ๋ฒ์ด์ง๊ณ ์์๋ค.
๋ง์์ N๊ฐ์ ์ง๊ณผ ๊ทธ ์ง๋ค์ ์ฐ๊ฒฐํ๋ M๊ฐ์ ๊ธธ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ๊ธธ์ ์ด๋ ๋ฐฉํฅ์ผ๋ก๋ ์ง ๋ค๋ ์ ์๋ ํธ๋ฆฌํ ๊ธธ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ ๊ธธ๋ง๋ค ๊ธธ์ ์ ์งํ๋๋ฐ ๋๋ ์ ์ง๋น๊ฐ ์๋ค.
๋ง์์ ์ด์ฅ์ ๋ง์์ ๋ ๊ฐ์ ๋ถ๋ฆฌ๋ ๋ง์๋ก ๋ถํ ํ ๊ณํ์ ๊ฐ์ง๊ณ ์๋ค. ๋ง์์ด ๋๋ฌด ์ปค์ ํผ์์๋ ๊ด๋ฆฌํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ง์์ ๋ถํ ํ ๋๋ ๊ฐ ๋ถ๋ฆฌ๋ ๋ง์ ์์ ์ง๋ค์ด ์๋ก ์ฐ๊ฒฐ๋๋๋ก ๋ถํ ํด์ผ ํ๋ค. ๊ฐ ๋ถ๋ฆฌ๋ ๋ง์ ์์ ์๋ ์์์ ๋ ์ง ์ฌ์ด์ ๊ฒฝ๋ก๊ฐ ํญ์ ์กด์ฌํด์ผ ํ๋ค๋ ๋ป์ด๋ค. ๋ง์์๋ ์ง์ด ํ๋ ์ด์ ์์ด์ผ ํ๋ค.
๊ทธ๋ ๊ฒ ๋ง์์ ์ด์ฅ์ ๊ณํ์ ์ธ์ฐ๋ค๊ฐ ๋ง์ ์์ ๊ธธ์ด ๋๋ฌด ๋ง๋ค๋ ์๊ฐ์ ํ๊ฒ ๋์๋ค. ์ผ๋จ ๋ถ๋ฆฌ๋ ๋ ๋ง์ ์ฌ์ด์ ์๋ ๊ธธ๋ค์ ํ์๊ฐ ์์ผ๋ฏ๋ก ์์จ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ ๋ถ๋ฆฌ๋ ๋ง์ ์์์๋ ์์์ ๋ ์ง ์ฌ์ด์ ๊ฒฝ๋ก๊ฐ ํญ์ ์กด์ฌํ๊ฒ ํ๋ฉด์ ๊ธธ์ ๋ ์์จ ์ ์๋ค. ๋ง์์ ์ด์ฅ์ ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋๋ก ๊ธธ๋ค์ ๋ชจ๋ ์์ ๊ณ ๋๋จธ์ง ๊ธธ์ ์ ์ง๋น์ ํฉ์ ์ต์๋ก ํ๊ณ ์ถ๋ค. ์ด๊ฒ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ง์ ๊ฐ์ N, ๊ธธ์ ๊ฐ์ M์ด ์ฃผ์ด์ง๋ค. N์ 2์ด์ 100,000์ดํ์ธ ์ ์์ด๊ณ , M์ 1์ด์ 1,000,000์ดํ์ธ ์ ์์ด๋ค. ๊ทธ ๋ค์ ์ค๋ถํฐ M์ค์ ๊ฑธ์ณ ๊ธธ์ ์ ๋ณด๊ฐ A B C ์ธ ๊ฐ์ ์ ์๋ก ์ฃผ์ด์ง๋๋ฐ A๋ฒ ์ง๊ณผ B๋ฒ ์ง์ ์ฐ๊ฒฐํ๋ ๊ธธ์ ์ ์ง๋น๊ฐ C (1 ≤ C ≤ 1,000)๋ผ๋ ๋ป์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์์ ๊ณ ๋จ์ ๊ธธ ์ ์ง๋น์ ํฉ์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.