ํด๋น ๊ฒ์๋ฌผ์ ํ๋ก๊ทธ๋๋จธ์ค-LV.3-์ฌ-์ฐ๊ฒฐํ๊ธฐ-JS๋ฅผ ์ฐธ๊ณ ํ์ฌ ์์ฑ๋์์์ ๋ฏธ๋ฆฌ ๋ฐํ๋๋ค.
n๊ฐ์ ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ๋ฅผ ๊ฑด์คํ๋ ๋น์ฉ(costs)์ด ์ฃผ์ด์ง ๋, ์ต์์ ๋น์ฉ์ผ๋ก ๋ชจ๋ ์ฌ์ด ์๋ก ํตํ ๊ฐ๋ฅํ๋๋ก ๋ง๋ค ๋ ํ์ํ ์ต์ ๋น์ฉ์ return ํ๋๋ก solution์ ์์ฑํ์ธ์.
๋ค๋ฆฌ๋ฅผ ์ฌ๋ฌ ๋ฒ ๊ฑด๋๋๋ผ๋, ๋๋ฌํ ์๋ง ์์ผ๋ฉด ํตํ ๊ฐ๋ฅํ๋ค๊ณ ๋ด ๋๋ค. ์๋ฅผ ๋ค์ด A ์ฌ๊ณผ B ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ๊ฐ ์๊ณ , B ์ฌ๊ณผ C ์ฌ ์ฌ์ด์ ๋ค๋ฆฌ๊ฐ ์์ผ๋ฉด A ์ฌ๊ณผ C ์ฌ์ ์๋ก ํตํ ๊ฐ๋ฅํฉ๋๋ค.
((n-1) * n) / 2
์ดํ์
๋๋ค.n | costs | return |
---|---|---|
4 | [[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]] | 4 |
costs๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ผ๋ฉฐ, ์ด๋ ์ด๋ก์ ๊ฒฝ๋ก๋ก ์ฐ๊ฒฐํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ ์ ๋น์ฉ์ผ๋ก ๋ชจ๋๋ฅผ ํตํํ ์ ์๋๋ก ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋๋ค.
function solution(n, costs) {
// ์ต์์ ๋ถ๋ชจ๋ฅผ ์ฐพ๋ ์ฌ๊ทํจ์
function getParent(parent, to) {
// ์ต์์ ๋ถ๋ชจ๋ฅผ ๋ฐํ
if(parent[to] === to) return to
return parent[to] = getParent(parent, parent[to])
}
// ๊ฐ์ ๋ถ๋ชจ์ธ์ง ๋ฐํํ๋ ํจ์
function findParent(parent, a, b) {
// ์์ดํ
์ ๋ถ๋ฌ์ด
const n1 = getParent(parent, a)
const n2 = getParent(parent, b)
if(n1 === n2) return true
else return false
}
// ์ฐพ์ ๋ถ๋ชจ๋ผ๋ฆฌ ๋ณํฉ
function unionParent(parent, a, b) {
// ์์ดํ
์ ๋ถ๋ฌ์ด
const n1 = getParent(parent, a)
const n2 = getParent(parent, b)
// ๋ฒํธ๋ฅผ ๋น๊ตํด ์์ ์ชฝ์ด ๋ถ๋ชจ๊ฐ ๋๋๋ก ๊ฒฐ์ ํจ
if(n1 < n2) return parent[n2] = n1
else return parent[n1] = n2
}
// ๊ธฐํ๋น์ฉ ํฉ๊ณ
let costSum = 0
// ๊ฒฝ๋ก ๋ถ๋ชจ ๋ฐฐ์ด
const parent = []
// ๋ชจ๋ ์ต์์ ๊ธธ์ ๋ถ๋ชจ ๋ฐฐ์ด์ ์
๋ ฅ
for(let i = 0 ; i < n ; i ++) {
parent.push(i)
}
// ๋น์ฉ ๋ณ ์ค๋ฆ์ฐจ ์ ์ ๋ ฌ
costs.sort((a,b) => a[2] - b[2])
// costs ๋ฐฐ์ด ์ํ
costs.forEach((cost, idx) => {
const [from, to, val] = cost
// ๋ถ๋ชจ๊ฐ ๊ฐ์์ง ๋น๊ต
if(!findParent(parent, from, to)) {
// ๋ถ๋ชจ๊ฐ ๋ค๋ฅด๋ค๋ฉด ํ์ํ ๋น์ฉ์ ์ถ๊ฐํ๊ณ ๋ถ๋ชจ๋ฅผ ๋ณํฉํจ
costSum += val
unionParent(parent, from, to)
}
})
return costSum
}
์ด ๋ฌธ์ ๋ Greedy ์ Graph๊ฐ ๊ฐ์ด ์์ฌ ์๋ ๋ฌธ์ ๋ผ๋๋ฐ...
๋ชจ๋ ์ด์ด์ ธ์๋ ๊ฒฝ๋ก๋ฅผ ํ์ํ ๋๋ ๋ถ๋ชจ ๊ฒฝ๋ก๊ฐ ์ด์ด์ ธ์๋์ง ํ์ธํด๋ณธ๋ค๋ ์ ์ ๊ธฐ์ตํด์ผ๊ฒ ์