๋ฌธ์ ๋ฅผ ๋์ด์ผ๋ณด๋ฉฐ..
ํด๋น ๋ฌธ์ ๋ ๊ฐ์ ์ ์ฐ๊ฒฐํ๋ฉฐ ์๊ณ ๋ฆฌ์ฆ์ ์ง์ผ ํ ์ ์๋ ๋ด ๊ธฐ์ค ์๋นํ ์ด๋ ค์ด ๋์ด๋์ ๋ฌธ์ ์๋ค.. ์ง๋ฌธํ๊ธฐ๋ฅผ ์ฌ๋ฌ๋ฒ ๋ค๋ฝ๋ ๋ฝ ๊ฑฐ๋ฆฌ๋ฉฐ ํ๋ค๊ฒ ํ์ด์ ๋์ฑ ๊ธฐ์ต์ ๋จ๋๋ค.
๋ฌธ์  ์ค๋ช
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
}