๐ ๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/42861
๐ ๋์ ํ์ด
์๋,, ์ ํ ์๊ฐํด๋ด์ง ๋ชปํ๋ค. ์ฒ์์๋ bfs๋ก ๋๋ ค์ ๋ฐฉ๋ฌธ ์ฒดํฌ๋ฅผ ํ๋ฉด์ ์ต์ ๋น์ฉ์ ์ฐพ์๋ด๊ณ ์ถ์๋ค. ๊ทผ๋ฐ ์๊ฐํ๋ค๊ฐ ๋งํ๊ฒ,,, "์ฌ์ดํด ๋ง๋ค์ด์ง๋ ๊ฒ์ ์ด๋ป๊ฒ ํ๋จํ์ง?"์๋ค. ๋จ์ํ 1,2,3 ๋ง ์ฐ๊ฒฐ๋์ด์๋ค๋ฉด ์ธ๊ฐ๊ฐ ์ฐ๊ฒฐ๋ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์๋ผ ์ ์๋ค. 2์ฐจ์ ๋ฐฐ์ด์ ์ด์ฉํด์ [1,2] [2,3] [1.3] ๋จธ ์ด๋ฐ์์ผ๋ก ํ์ธํด๋ณผ ์๋ ์๊ฒ ์ง,, ๊ทผ๋ฐ ์ด๊ฒ ๋ง์ฝ 8๊ฐ ๊ทธ ์ด์์ด ์ฌ์ดํด์ ๋๊ฒ ๋๋ฉด? 1-2-3-4-5-6-7-8 ์ด๋ ๊ฒ ์ฐ๊ฒฐ๋์ด์๋๋ฐ, ๋ฌธ์ ์ ์ํ๋ฉด 1๊ณผ 8์ ์ฐ๊ฒฐ๋์ด์๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํ๋ค. ์ด๋ฐ๊ฒฝ์ฐ,,, ์ด๋ป๊ฒ ์ 2์ฐจ์ ๋ฐฐ์ด์์ ์ฐพ์ ์ ์๋๊ฐ??? ์๋ค!!!!!!!!!! ์์ค,, ๋ณต์กํด ๊ทธ๋์ ๊ฒฐ๊ตญ ์ธํฐ๋ท ์ฐฌ์ค๋ฅผ ์ผ๋ค...
๊ฐ๋,, ๋ด ๋ธ๋ก๊ทธ์ ์์ ์๋ถ๋ ๋จ๊ฒจ์ฃผ์ จ๊ณ , ๋๋ ์์ฃผ ๋ฐฉ๋ฌธํ๋ formagran๋์ ๋ธ๋ก๊ทธ์ ์ ๋ง ๋๋ด์ฃผ๊ฒ ์ค๋ช ์ด ๋์ด์์๋ค. ์ง์ง ๊ธ ํ๋ฒ์ฝ๊ณ ์ดํด ์๋ฃ ใ ใ ใ ใ ใ
์ด ๊ธ์ ์ฐธ๊ณ ํด์ ํ์ด๋ฅผ ์๊ฐํด๋ณด๊ธธ,, ์๋ ๊ทธ๋ฅ ์ ๊ธฐ ๋์์๋ ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ ๊ทธ ์์ฒด๊ฐ, ์ด ๋ฌธ์ ์ ๋ต์ด๊ธฐ๋ ํ๋ค!
์ฒ์๋ค์ด๋ดค๋๋ฐ, ,, ์์ฃผ ๊ฐ๋จํ๊ฒ ๋งํด๋ณด์๋ฉด
๐ ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ
์ต์ ๋น์ฉ์ ๊ฐ์ง ๊ทธ๋ํ ๋ ธ์ ๋ค์ ์์ฃผ๋ก ๋ํด๋๊ฐ๋ค๊ฐ ์ํ ์ฌ์ดํด (๋ฐ๋ณต) ์ด ๋ฐ์ํ๋ฉด ๊ทธ ๋ ธ์ ์ ๋น์ฉ์์ ์ ์ธํด์ฃผ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ฌ๊ธฐ์ ์ํ์ด๋, ์๋ ๊ทธ๋ฆผ์์ ๋ ธ๋์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์์๋, ๊ทธ๋ํ๊ฐ ์ฌ์ดํด์ ํ์ฑํ๋ ๊ฒฝ์ฐ๋ฅผ ์๋ฏธํ๋ค.
์ด ๊ฒฝ์ฐ๋ฅผ ๊ทธ๋ผ ์ด๋ป๊ฒ ํ๋จํด์ค๊น? ์ฌ๊ธฐ ์๊ณ ๋ฆฌ์ฆ์์๋ ๋ถ๋ชจ๋ฅผ ์์ฑํด์ฃผ๋ ๋ฐฉ์์ ์ฌ์ฉํ๋ค. ๊ทธ๋ฆผ์ผ๋ก ๊ฐ๋จํ๊ฒ ๊ทธ๋ ค๋ณด๊ฒ ๋ค.
์ ๊ทธ๋ฆผ์ ๋ณด๋ฉด, ๋นจ๊ฐ๊ธ์จ๋ก ์ซ์๊ฐ ์จ์๋ค. ๊ทธ๊ฒ ๋ฐ๋ก ์ฌ๊ธฐ์ ์์ฑํ ๋ถ๋ชจ์ด๋ค. ์ฃผํฉ์ ์ ์ ์ฐ๊ฒฐํ์ ๊ฒฝ์ฐ, 1๊ณผ 3์ค์ ๋ ์์์ (์ผ์ชฝ์ ์๋์)๋ฅผ ๋ถ๋ชจ๋ก ์ผ๋๋ค. ๊ทธ๋ผ ๋
ธ๋1์ ๋ถ๋ชจ๋ 1, ๋
ธ๋3์ ๋ถ๋ชจ๋ 1์ด ๋๋ค.
์ฐ๋์ ์ ์ ๋ณด์. ์ฒ์์ ๋
ธ๋4์ ๋
ธ๋5๊ฐ ์ฐ๊ฒฐ๋๋ค๊ณ ์น์. ๊ทธ๋ผ ๋ ์ผ์ชฝ์ ์๋ ์, 4๊ฐ ๋ถ๋ชจ๊ฐ ๋๋ค. ๊ทธ๋ผ, ๋
ธ๋4์ ๋
ธ๋5์ ๋ถ๋ชจ๋ ์ ๋ถ 4๊ฐ ๋๋ค.
์ด์ ๋
ธ๋5์ ๋
ธ๋6์ ์ฐ๊ฒฐํด๋ณด์. ๋
ธ๋5์ ๋
ธ๋6์ค์ ๋
ธ๋5๊ฐ ๋ ์ผ์ชฝ์ ์๋ค. ๋
ธ๋5์ ๋ถ๋ชจ๋ฅผ ํจ๊ป ๊ณต์ ํด์ ๋
ธ๋6์๊ฒ๋ 4๋ฅผ ๋ถ์ฌํ๋ค. ์ด๋ฐ์์ผ๋ก, ๋ ์ผ์ชฝ์ ์๋ ๋
ธ๋์ ๋ถ๋ชจ ๋ฒํธ๋ฅผ ๊ฐ์ ธ๋๊ฐ๋๋ก ์ค๊ณํด์ค์ผํ๋ค.
๊ทธ๋ผ ์ด์ ๋ณด๋ผ์์ด ์ฐ๊ฒฐ๋๋ค๋ฉด?
๋ณด๋ผ์์ด ์ฐ๊ฒฐ๋ ๊ฒ์ ๋ณด๋ฉด, ์ฐ๊ฒฐ๋ ๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ์ ๋ถ 4์ด๋ค. ์ด๋ ๊ฒ ๋ง์ฃผ์น๋ ๋ ๋ ธ๋์ ๋ถ๋ชจ๋ฒํธ๊ฐ ๊ฐ๋ค๋ฉด, ๊ฒฐ๊ตญ ์ฌ์ดํด์ ์์ฑํ๋ค๋ ์๋ฏธ๊ฐ ๋๋ค! ๊ทธ๋ฌ๋ฏ๋ก, ๋ณด๋ผ์ ๋ถ๋ถ์ ์ฐ๊ฒฐ์์ ์ ์ธ์ํจ๋ค.
์ด๋ฐ์์ผ๋ก ์ํ์ ์ฐพ์๋๊ฐ๊ณ , ์ํ์ด ๋ง๋ค์ด์ง๋ ์๊ฐ! ๋น์ฉ ์ถ๊ฐ์์ ์ ์ธ์์ผ๋๊ฐ๋ฉด ๋๋ค!! ์๊ฐ๋ณด๋ค ๋๋ฌด๋๋ฌด ๊ฐ๋จํ๋ค.
๊ทธ๋ผ!! ์ด๋ค ์์๋๋ก ์ฐ๊ฒฐํ๋๊ณ ?? ์ ์ฐ๋์, ์ฃผํฉ์, ๋ณด๋ผ์ ํ๊ดํ์ ๊ทธ๋ฅ ์์๋ก ๋ง ์ฐ๊ฒฐ์ง์ ๊ฒ์ธ๋ฐ, ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์์๋ ๋น์ฉ์ด ๊ฐ์ฅ ์ ์!! ์์๋๋ก ์ฐ๊ฒฐํ๋ค. ๊ทธ๋์ผ ์ต์๋น์ฉ์ด ๋์ค๋๊น! ์ด๊ฒ์ ๊ทธ๋๋ก ์ฝ๋๋ก ๊ตฌํํ๋ฉด, ๋ฐ๋ก ์ฌ ์ฐ๊ฒฐํ๊ธฐ์ ์ ๋ต์ด ๋๋ค.
๐ ์ ๋ต์ฝ๋
import Foundation
func solution(_ n:Int, _ costs:[[Int]]) -> Int {
let sortedCosts = costs.sorted{ $0[2] < $1[2] }
var parentIdx = (0..<n).map{ $0 }
var answer = 0
for cost in sortedCosts {
if !isCycle(parentArr: parentIdx, left: cost[0], right: cost[1]) {
// ์ฌ์ดํด ํ์ฑ ์๋๋ฉด, ๋ถ๋ชจ ๋ฐ๊ฟ์ฃผ๊ณ
// ์์ node ๋ฒํธ๋ฅผ ๊ฐ์ง ์ ์ ๋ถ๋ชจ ๋ฒํธ๋ฅผ ๊ฐ๊ฒ ๋๋ค.
var newParent = 0
var oldParent = 0
if cost[0] > cost[1] {
newParent = parentIdx[cost[1]]
oldParent = parentIdx[cost[0]]
} else {
newParent = parentIdx[cost[0]]
oldParent = parentIdx[cost[1]]
}
// left right ๋ฟ๋ง ์๋๋ผ ๋ค๋ฅธ ์ฐ๊ฒฐ๋ ์ ๋ค๋ ๋ชจ์กฐ๋ฆฌ ์ฐพ์์ ๋ฐ๊ฟ์ค์ผํด
parentIdx.indices.filter{ parentIdx[$0] == oldParent }.forEach{ parentIdx[$0] = newParent }
// ๋ค๋ฆฌ ๊ฑด์ค ํ์ผ๋๊น cost ๋ํด์ฃผ๊ธฐ
answer += cost[2]
}
}
return answer
}
private func isCycle(parentArr: [Int], left: Int, right: Int) -> Bool {
// ์์ชฝ ๋ถ๋ชจ๊ฐ ๊ฐ์์ง ํ์ธ
return parentArr[left] == parentArr[right] ? true : false
}
print(solution(4, [[0,1,1],[0,2,2],[1,2,5],[1,3,1],[2,3,8]]))