- DP
- golang
- ์นด์นด์ค ์ฝํ
- ํ๋ก๊ทธ๋๋จธ์ค
- ๋นํธ๋งต
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- ์ด๋ถํ์
- ์นด์นด์ค2021
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- ํธ๋ฆฌ
- Python
- ์ํฐ๋
- Union-Find
- C++
- nestjs
- ์๊ณ ๋ฆฌ์ฆ
- ๋นํธ๋ง์คํน
- ๋ฐฑ์ค
- BFS
- LCs
- js
- ํ๋ฆฌ์จ๋ณด๋ฉ
- ์น๋ฆฐ์ด
- ๋ค์ต์คํธ๋ผ
- ์์ฝ๋
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- DFS
- go
- ์ฌ๊ท
- Today
- Total
Hello Ocean! ๐ผ
[go/ํ๋ก๊ทธ๋๋จธ์ค] ์ฌ ์ฐ๊ฒฐํ๊ธฐ ๋ณธ๋ฌธ
๋ฌธ์
https://programmers.co.kr/learn/courses/30/lessons/42861?language=go
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์ ๋น์ฉ์ด ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ๋ชจ๋ ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ ๊ฑด์ค ๋น์ฉ์ด ์ฃผ์ด์ง์ง ์์ต๋๋ค. ์ด ๊ฒฝ์ฐ, ๋ ์ฌ ์ฌ์ด์ ๊ฑด์ค์ด ๋ถ๊ฐ๋ฅํ ๊ฒ์ผ๋ก ๋ด ๋๋ค.
- ์ฐ๊ฒฐํ ์ ์๋ ์ฌ์ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
n | costs | return |
4 | [[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]] | 4 |
์ ์ถ๋ ฅ ์ ์ค๋ช
costs๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ผ๋ฉฐ,
์ด๋ก์ ๊ฒฝ๋ก๋ก ์ฐ๊ฒฐํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ ์ ๋น์ฉ์ผ๋ก ๋ชจ๋๋ฅผ ํตํํ ์ ์๋ ๊ฒฝ์ฐ์ ์ ์ด๋ค.
ํ์ด
costs๋ฅผ ๊ฑด์ค๋น์ฉ(costs[2])๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ ํ,
loop๋ฅผ ๋๋ฉด์ ๋ค๋ฆฌ๋ฅผ ํ๋์ฉ ์ ํํด ๋๊ฐ๋๋ฐ,
์ฌ์ดํด์ด ์๊ธฐ๋ ๊ฒฝ์ฐ๋ฅผ ์ ์ธํ๊ณ ์ ํํ๋ฉด ๋๋ค.
์ฌ์ดํด์ด ์๊ธฐ๋ ๊ฒฝ์ฐ๋ฅผ ํ๋จํ๊ธฐ ์ํด, Union-Find ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ์๋ค.
๋งค ๊ฒฝ์ฐ์, find๋ฅผ ์ด์ฉํด ๋ ๋ ธ๋์ ๋ถ๋ชจ๊ฐ ๊ฐ์์ง ํ์ธํด์ฃผ์๋ค.
๋ถ๋ชจ๊ฐ ๊ฐ์ผ๋ฉด ์ฌ์ดํด์ด ์๊ธฐ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ํจ์ค,
๊ฐ์ง ์์ผ๋ฉด ํด๋น ๋ค๋ฆฌ๋ฅผ ๊ฑด์คํ๊ณ , ๋ ๋ ธ๋๋ฅผ ์ฐ๊ฒฐํด์ฃผ์๋ค.
์ฝ๋
import "sort"
var parents []int
func solution(n int, costs [][]int) int {
answer := 0
parents = make([]int, n+1)
for i:=0;i<n;i++ {
parents[i] = i;
}
// costs ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
sort.Slice(costs, func (i, j int) bool {
return costs[i][2] < costs[j][2]
})
for _, route:= range(costs) {
if union(route[0], route[1]) {
answer += route[2]
}
}
return answer
}
// ์ต์์ ๋ถ๋ชจ ์ฐพ๊ธฐ
func find(a int) int {
if a == parents[a] {
return a
}
parents[a] = find(parents[a])
return parents[a]
}
func union(a, b int) bool {
a = find(a)
b = find(b)
// ์ฌ์ดํด์ด ์๊ธฐ๋ ๊ฒฝ์ฐ ํจ์ค
if (a == b) {
return false
}
// ๋ ๋
ธ๋๋ฅผ ์ฐ๊ฒฐํด์ฃผ๊ธฐ
if (a > b) {
parents[a] = b // ์์์ ๋ฅผ ํฐ ์ ํํ
๋ฌ๊ธฐ
} else {
parents[b] = a
}
return true
}
๊ฒฐ๊ณผ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ํ๊ดด๋์ง ์์ ๊ฑด๋ฌผ (0) | 2022.03.01 |
---|---|
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ์ด์ค์ฐ์ ์์ํ (0) | 2022.03.01 |
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๊ฒฝ์ฃผ๋ก ๊ฑด์ค (2020 ์นด์นด์ค ์ธํด์ญ) (0) | 2022.01.18 |
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๋จ์ด ๋ณํ (0) | 2022.01.12 |
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ๋ณด์ ์ผํ (2020 ์นด์นด์ค ์ธํด์ญ) (0) | 2021.12.30 |