๋ฌธ์  ์ค๋ช
๋คํธ์ํฌ๋ ์ปดํจํฐ ์ํธ ๊ฐ์ ์ ๋ณด๋ฅผ ๊ตํํ ์ ์๋๋ก ์ฐ๊ฒฐ๋ ํํ๋ฅผ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ปดํจํฐ A์ ์ปดํจํฐ B๊ฐ ์ง์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด์๊ณ , ์ปดํจํฐ B์ ์ปดํจํฐ C๊ฐ ์ง์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์์ ๋ ์ปดํจํฐ A์ ์ปดํจํฐ C๋ ๊ฐ์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์ ๋ณด๋ฅผ ๊ตํํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ปดํจํฐ A, B, C๋ ๋ชจ๋ ๊ฐ์ ๋คํธ์ํฌ ์์ ์๋ค๊ณ ํ ์ ์์ต๋๋ค.
์ปดํจํฐ์ ๊ฐ์ n, ์ฐ๊ฒฐ์ ๋ํ ์ ๋ณด๊ฐ ๋ด๊ธด 2์ฐจ์ ๋ฐฐ์ด computers๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋คํธ์ํฌ์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์์ค.
์ ํ์ฌํญ
์ปดํจํฐ์ ๊ฐ์ n์ 1 ์ด์ 200 ์ดํ์ธ ์์ฐ์์
๋๋ค.
๊ฐ ์ปดํจํฐ๋ 0๋ถํฐ n-1์ธ ์ ์๋ก ํํํฉ๋๋ค.
i๋ฒ ์ปดํจํฐ์ j๋ฒ ์ปดํจํฐ๊ฐ ์ฐ๊ฒฐ๋์ด ์์ผ๋ฉด computers[i][j]๋ฅผ 1๋ก ํํํฉ๋๋ค.
computer[i][i]๋ ํญ์ 1์
๋๋ค.

์ ์ถ๋ ฅ ์ ์ค๋ช
์์  #1
์๋์ ๊ฐ์ด 2๊ฐ์ ๋คํธ์ํฌ๊ฐ ์์ต๋๋ค.

์์  #2
์๋์ ๊ฐ์ด 1๊ฐ์ ๋คํธ์ํฌ๊ฐ ์์ต๋๋ค.

๋์ ํ์ด
function solution(n, computers) {
    // ๊ฐ์ ์ ์ ์ฅํ  Object
    const networks = {}
    
    // ์ ์ฒด ๋ฐ๋ณต
    computers.forEach((computer,computerIdx) => {
        computer.forEach((line,lineIdx) => {
            // ๊ฐ์ ์ด ์ฐ๊ฒฐ๋์ด์๋ค๋ฉด
            if(line) {
                // ๊ฐ์ ์ ๊ธฐ๋ณธ๊ฐ์ด ์๋ค๋ฉด
                if(networks[computerIdx] === undefined) {
                    networks[computerIdx] = []    
                }
                // ์ค๋ณต ๊ฐ์  ์ ๊ฑฐ
                if(computerIdx !== lineIdx) {
                    networks[computerIdx] = [...networks[computerIdx] , lineIdx]   
                }
            }
        })
    })
    
    // dfs ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ฐ์  ํ์
    function dfs(obj,root) {
        let count = 0
        const queue = Object.keys(obj)
        const visit = []
        visit[queue[queue.length-1]] = true
        while(queue.length) {
            const cur = queue.pop()
            visit[cur] = true
            obj[cur].forEach(now => {
                if(!visit[now]) {
                    queue.push(now)
                    visit[now] = true
                    count++
                }
            })
        }
        
        // ์ ์ฒด ๋
ธ๋์ ๊ฐ์ - ์ฐ๊ฒฐ๋ ๊ฐ์ ์ ๊ฐ์ = ๋ถ๋ฆฌ๋ ๋คํธ์ํฌ์ ๊ฐ์
        return Object.keys(obj).length - count
    }
    
    return dfs(networks,Object.entries(networks)[0][0])   
}
ํ์ธํ ์ค์ ํฌ์ธํธ๋
1. ๊ฐ์ ์ ๋ง๋ค ์ ์๋๊ฐ?

์์  1๋ฒ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ผ๋ฉฐ 0๋ฒ์งธ ๋ ธ๋์ 1๋ฒ์งธ ๋ ธ๋๊ฐ ์๋ก ์ฐ๊ฒฐ๋์ด์๋ ๊ทธ๋ฆผ์ ์๊ฐํ๋ฉด ๋๋ค.
2. DFS์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํ ์ ์๋๊ฐ?

3. ์ ์ฒด ๋ ธ๋์ ๊ฐ์ - ์ฐ๊ฒฐ๋ ๊ฐ์ ์ ๊ฐ์ = ๋ถ๋ฆฌ๋ ๋คํธ์ํฌ์ ๊ฐ์
์ด์ ๋ ์ธ ๊ฒ ๊ฐ๋ค.