๐กsolutions )
๐ฌ '์ต์ ๋น์ฉ์ผ๋ก ๋ชจ๋ ๋ ธ๋(์ฌ) ์ฐ๊ฒฐ' -> ์ต์ ์ ์ฅ ํธ๋ฆฌ(MST)๋ฅผ ์ฌ์ฉํ๋ ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ ํ์ฉ ๋ฌธ์ ๋ค.
์ ์ฅ ํธ๋ฆฌ(Spanning Tree)๋? ๊ทธ๋ํ ๋ด์ ๋ชจ๋ ์ ์ ์ ์ฐ๊ฒฐํ๋ ํธ๋ฆฌ๋ก ๊ฐ์ ์ ๊ฐ์๊ฐ n-1๊ฐ๋ก ์ต์ ์ฐ๊ฒฐ ๋ถ๋ถ ๊ทธ๋ํ์ด๋ค. ์ต์ ์ ์ฅ ํธ๋ฆฌ(Minimum Spanning Tree )๋? ์ ์ฅ ํธ๋ฆฌ์์ ์ฌ์ฉ๋ ๊ฐ์ ๋ค์ ๊ฐ์ค์น์ ํฉ์ด ์ต์์ธ ํธ๋ฆฌ ์ฆ, ์ต์ ๋น์ฉ์ผ๋ก ๋ชจ๋ ๋ ธ๋ ์ฐ๊ฒฐํ๋ ๊ทธ๋ํ์ด๋ค. ์ฐธ๊ณ ๋ธ๋ก๊ทธ |
๐ฌ ๋จผ์ ๋ค๋ฆฌ ๊ฑด์ค ๋น์ฉ ๊ธฐ์ค์ผ๋ก costs๋ฅผ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ค. -> ์ ์ ๋น์ฉ์ ๋ ธ๋๋ถํฐ ๊บผ๋ด์์ ์ฐ๊ฒฐํ๋ค.
๐ฌ ๋
ธ๋์ ๋ถ๋ชจ๋ฅผ ์ฐพ๋ find_parent๋ฅผ ํตํด ๊บผ๋ด์จ ๋ ๋
ธ๋์ ๋ถ๋ชจ๋ฅผ ๋น๊ตํ๋ค. ->์ฌ์ดํด์ด ์๊ธฐ์ง ์๊ฒ ํ๊ธฐ ์ํด ๋ถ๋ชจ๊ฐ ๋ค๋ฅธ ๊ฒฝ์ฐ์๋ง union_parent()ํจ์๋ก ๋ ๋
ธ๋๋ฅผ ์ฐ๊ฒฐํ๋ค.
๐ฌ ๋
ธ๋ ์ฐ๊ฒฐ ํ ๋ฐ์ํ ๋น์ฉ๋งํผ answer์ ๋ํด์ค๋ค.
ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ์ดํดํ๊ธฐ ์ํด ์ฐธ๊ณ ํ ์๋ฃ ๐
๋๋น๋๋์ ์๊ณ ๋ฆฌ์ฆ ๊ฐ์์ ๋ธ๋ก๊ทธ
๐จ๐ปcode )
๐ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ ํ์ด
def solution(n, costs):
def find_parent(parent, n):
if parent[n] != n:
parent[n] = find_parent(parent, parent[n])
return parent[n]
def union_parent(parent, a, b):
a = find_parent(parent, a)
b = find_parent(parent, b)
if a > b:
parent[a] = b
else:
parent[b] = a
answer = 0
costs.sort(key=lambda x:x[2]) # ๋น์ฉ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
parent = [i for i in range(n)]
for node_a, node_b, cost in costs:
if find_parent(parent, node_a) != find_parent(parent, node_b):
union_parent(parent, node_a, node_b)
answer += cost
return answer
๐ฅ๋ค๋ฅธ ํ์ด
def solution(n, costs):
costs = sorted(costs, key=lambda x:x[2])
node = set([costs[0][0], costs[0][1]])
answer = costs[0][2]
while len(node) != n:
for i in range(1, len(costs)):
if costs[i][0] in node and costs[i][1] in node:
continue
if costs[i][0] in node or costs[i][1] in node:
node.update([costs[i][0], costs[i][1]])
answer += costs[i][2]
break
return answer
๐description )
๋ฌธ์ ์ค๋ช
n๊ฐ์ ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ๋ฅผ ๊ฑด์คํ๋ ๋น์ฉ(costs)์ด ์ฃผ์ด์ง ๋, ์ต์์ ๋น์ฉ์ผ๋ก ๋ชจ๋ ์ฌ์ด ์๋ก ํตํ ๊ฐ๋ฅํ๋๋ก ๋ง๋ค ๋ ํ์ํ ์ต์ ๋น์ฉ์ return ํ๋๋ก solution์ ์์ฑํ์ธ์.
๋ค๋ฆฌ๋ฅผ ์ฌ๋ฌ ๋ฒ ๊ฑด๋๋๋ผ๋, ๋๋ฌํ ์๋ง ์์ผ๋ฉด ํตํ ๊ฐ๋ฅํ๋ค๊ณ ๋ด ๋๋ค. ์๋ฅผ ๋ค์ด A ์ฌ๊ณผ B ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ๊ฐ ์๊ณ , B ์ฌ๊ณผ C ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ๊ฐ ์์ผ๋ฉด A ์ฌ๊ณผ C ์ฌ์ ์๋ก ํตํ ๊ฐ๋ฅํฉ๋๋ค.
์ ํ์ฌํญ
- ์ฌ์ ๊ฐ์ n์ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- costs์ ๊ธธ์ด๋ ((n-1) * n) / 2์ดํ์ ๋๋ค.
- ์์์ i์ ๋ํด, costs[i][0] ์ costs[i] [1]์๋ ๋ค๋ฆฌ๊ฐ ์ฐ๊ฒฐ๋๋ ๋ ์ฌ์ ๋ฒํธ๊ฐ ๋ค์ด์๊ณ , costs[i] [2]์๋ ์ด ๋ ์ฌ์ ์ฐ๊ฒฐํ๋ ๋ค๋ฆฌ๋ฅผ ๊ฑด์คํ ๋ ๋๋ ๋น์ฉ์ ๋๋ค.
- ๊ฐ์ ์ฐ๊ฒฐ์ ๋ ๋ฒ ์ฃผ์ด์ง์ง ์์ต๋๋ค. ๋ํ ์์๊ฐ ๋ฐ๋๋๋ผ๋ ๊ฐ์ ์ฐ๊ฒฐ๋ก ๋ด ๋๋ค. ์ฆ 0๊ณผ 1 ์ฌ์ด๋ฅผ ์ฐ๊ฒฐํ๋ ๋น์ฉ์ด ์ฃผ์ด์ก์ ๋, 1๊ณผ 0์ ๋น์ฉ์ด ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ๋ชจ๋ ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ ๊ฑด์ค ๋น์ฉ์ด ์ฃผ์ด์ง์ง ์์ต๋๋ค. ์ด ๊ฒฝ์ฐ, ๋ ์ฌ ์ฌ์ด์ ๊ฑด์ค์ด ๋ถ๊ฐ๋ฅํ ๊ฒ์ผ๋ก ๋ด ๋๋ค.
- ์ฐ๊ฒฐํ ์ ์๋ ์ฌ์ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
ncostsreturn
4 | [[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]] | 4 |
์ ์ถ๋ ฅ ์ ์ค๋ช
costs๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ผ๋ฉฐ, ์ด๋ ์ด๋ก์ ๊ฒฝ๋ก๋ก ์ฐ๊ฒฐํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ ์ ๋น์ฉ์ผ๋ก ๋ชจ๋๋ฅผ ํตํํ ์ ์๋๋ก ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋๋ค.