๋ฌธ์ ๋ฅผ ๋์ด์ผ๋ณด๋ฉฐ..
ํด๋น ๋ฌธ์ ๋ ๊ฐ์ ์ ์ฐ๊ฒฐํ๋ฉฐ ์๊ณ ๋ฆฌ์ฆ์ ์ง์ผ ํ ์ ์๋ ๋ด ๊ธฐ์ค ์๋นํ ์ด๋ ค์ด ๋์ด๋์ ๋ฌธ์ ์๋ค.. ์ง๋ฌธํ๊ธฐ๋ฅผ ์ฌ๋ฌ๋ฒ ๋ค๋ฝ๋ ๋ฝ ๊ฑฐ๋ฆฌ๋ฉฐ ํ๋ค๊ฒ ํ์ด์ ๋์ฑ ๊ธฐ์ต์ ๋จ๋๋ค.
๋ฌธ์ ์ค๋ช
n๊ฐ์ ์ก์ ํ์ด ์ ์ ์ ํตํด ํ๋์ ํธ๋ฆฌ ํํ๋ก ์ฐ๊ฒฐ๋์ด ์์ต๋๋ค. ๋น์ ์ ์ด ์ ์ ๋ค ์ค ํ๋๋ฅผ ๋์ด์ ํ์ฌ์ ์ ๋ ฅ๋ง ๋คํธ์ํฌ๋ฅผ 2๊ฐ๋ก ๋ถํ ํ๋ ค๊ณ ํฉ๋๋ค. ์ด๋, ๋ ์ ๋ ฅ๋ง์ด ๊ฐ๊ฒ ๋๋ ์ก์ ํ์ ๊ฐ์๋ฅผ ์ต๋ํ ๋น์ทํ๊ฒ ๋ง์ถ๊ณ ์ ํฉ๋๋ค.
์ก์ ํ์ ๊ฐ์ n, ๊ทธ๋ฆฌ๊ณ ์ ์ ์ ๋ณด wires๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ ์ ๋ค ์ค ํ๋๋ฅผ ๋์ด์ ์ก์ ํ ๊ฐ์๊ฐ ๊ฐ๋ฅํ ๋น์ทํ๋๋ก ๋ ์ ๋ ฅ๋ง์ผ๋ก ๋๋์์ ๋, ๋ ์ ๋ ฅ๋ง์ด ๊ฐ์ง๊ณ ์๋ ์ก์ ํ ๊ฐ์์ ์ฐจ์ด(์ ๋๊ฐ)๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
n์ 2 ์ด์ 100 ์ดํ์ธ ์์ฐ์์
๋๋ค.
wires๋ ๊ธธ์ด๊ฐ n-1์ธ ์ ์ํ 2์ฐจ์ ๋ฐฐ์ด์
๋๋ค.
wires์ ๊ฐ ์์๋ [v1, v2] 2๊ฐ์ ์์ฐ์๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ์ด๋ ์ ๋ ฅ๋ง์ v1๋ฒ ์ก์ ํ๊ณผ v2๋ฒ ์ก์ ํ์ด ์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
1 โค v1 < v2 โค n ์
๋๋ค.
์ ๋ ฅ๋ง ๋คํธ์ํฌ๊ฐ ํ๋์ ํธ๋ฆฌ ํํ๊ฐ ์๋ ๊ฒฝ์ฐ๋ ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
์
์ถ๋ ฅ ์
n wires result
9 [[1,3],[2,3],[3,4],[4,5],[4,6],[4,7],[7,8],[7,9]] 3
4 [[1,2],[2,3],[3,4]] 0
7 [[1,2],[2,7],[3,7],[3,4],[4,5],[6,7]] 1
4๋ฒ๊ณผ 7๋ฒ์ ์ฐ๊ฒฐํ๋ ์ ์ ์ ๋์ผ๋ฉด ๋ ์ ๋ ฅ๋ง์ ๊ฐ 6๊ฐ์ 3๊ฐ์ ์ก์ ํ์ ๊ฐ์ง๋ฉฐ, ์ด๋ณด๋ค ๋ ๋น์ทํ ๊ฐ์๋ก ์ ๋ ฅ๋ง์ ๋๋ ์ ์์ต๋๋ค.
๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก๋ 3๋ฒ๊ณผ 4๋ฒ์ ์ฐ๊ฒฐํ๋ ์ ์ ์ ๋์ด๋ ์ต์ ์ ์ ๋ต์ ๋์ถํ ์ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์ #2
๋ค์ ๊ทธ๋ฆผ์ ์ฃผ์ด์ง ์ ๋ ฅ์ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
2๋ฒ๊ณผ 3๋ฒ์ ์ฐ๊ฒฐํ๋ ์ ์ ์ ๋์ผ๋ฉด ๋ ์ ๋ ฅ๋ง์ด ๋ชจ๋ 2๊ฐ์ ์ก์ ํ์ ๊ฐ์ง๊ฒ ๋๋ฉฐ, ์ด ๋ฐฉ๋ฒ์ด ์ต์ ์ ๋๋ค.
์ ์ถ๋ ฅ ์ #3
๋ค์ ๊ทธ๋ฆผ์ ์ฃผ์ด์ง ์ ๋ ฅ์ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
3๋ฒ๊ณผ 7๋ฒ์ ์ฐ๊ฒฐํ๋ ์ ์ ์ ๋์ผ๋ฉด ๋ ์ ๋ ฅ๋ง์ด ๊ฐ๊ฐ 4๊ฐ์ 3๊ฐ์ ์ก์ ํ์ ๊ฐ์ง๊ฒ ๋๋ฉฐ, ์ด ๋ฐฉ๋ฒ์ด ์ต์ ์ ๋๋ค.
๋์ ํ์ด
function solution(n, wires) {
// ์ต๋ ๊ฐ์ผ๋ก ์ค์
let result = Number.MAX_SAFE_INTEGER
for(let i = 0 ; i < wires.length ; i ++) {
// ์ ๋ ฅ๋ง ํ๋๋ฅผ ๋๊ธฐ
const curExceptArr = wires.slice(0,i).concat(wires.slice(i+1))
// ์ ๋ ฅ๋ง ๊ตฌ์ถ
const curConnect = {}
curExceptArr.forEach(wire => {
const [to,from] = wire
if(!curConnect[to]) curConnect[to] = []
if(!curConnect[from]) curConnect[from] = []
curConnect[to].push(from)
curConnect[from].push(to)
})
// ๊ฐ ์ ๋ น๋ง์ ์ด์ด์ง ๊ฐ์ ์ธ๊ธฐ
const [root,tree] = Object.entries(curConnect)[0]
let count = findTree(curConnect,root)
const other = n-count
count = Math.abs(count-other)
if(result > count) {
result = count
}
}
return result
}
// ๋ป์ด๋๊ฐ ์ ๋ ฅ๋ง์ ์ ์นด์ดํธ
function findTree(obj,root) {
let count = 1
const queue = [root]
let visit = []
visit[root] = true
while(queue.length) {
const cur = queue.pop()
obj[cur].forEach(now => {
// ๋ฐฉ๋ฌธ ๊ธฐ๋ก์ด ์์ผ๋ฉด
if(!visit[now]) {
queue.push(now)
visit[now] = true
count++
}
})
}
return count
}