๋ฌธ์
- ๋คํธ์ํฌ๋ ์ปดํจํฐ ์ํธ ๊ฐ์ ์ ๋ณด๋ฅผ ๊ตํํ ์ ์๋๋ก ์ฐ๊ฒฐ๋ ํํ๋ฅผ ๋งํ๋ค.
- ์๋ฅผ๋ค์ด ์ปดํจํฐA๊ฐ ์ปดํจํฐB์ ์ง์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด์๊ณ , ์ปดํจํฐB๊ฐ ์ปดํจํฐC์ ์ง์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด์๋ค๋ฉด, ์ปดํจํฐA์ ์ปดํจํฐC๋ ๊ฐ์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์ ๋ณด๋ฅผ ์ฃผ๊ณ ๋ฐ์ ์ ์๋ค. ๋ฐ๋ผ์ ์ปดํจํฐA,B,C๋ ๋ชจ๋ ๊ฐ์ ๋คํธ์ํฌ ์์ ์๋ค๊ณ ๋งํ ์ ์๋ค.
- ์ปดํจํฐ์ ๊ฐฏ์ n๊ณผ ์ฐ๊ฒฐ์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ง ๋, ๋คํธ์ํฌ์ ๊ฐฏ์๋ฅผ ๋ฐํํ๋ผ.
์ ๋ ฅ๊ฐ
- n(int): ์ปดํจํฐ์ ๊ฐฏ์
- computers(int[][]): ์ปดํจํฐ๋ค์ด ์ฐ๊ฒฐ๋์ด์๋์ง ์๋์ง๋ฅผ ํํํ 2์ฐจ์๋ฐฐ์ด. ์ปดํจํฐi์ ์ปดํจํฐj๊ฐ ์ฐ๊ฒฐ๋์ด์๋ค๋ฉด computers[i][j]๋ 1์ด๊ณ ์ฐ๊ฒฐ๋์ด์์ง ์์ผ๋ฉด 0์ด๋ค.
์ ํ์ฌํญ
- 1 <= n <= 200
- computers[i][i]๋ ํญ์ 1 ์ด๋ค.
๋ฌธ์ ํ์ด
- ํ๋ฒ ๋ฐฉ๋ฌธํ ๋คํธ์ํฌ๋ ์งํฉ seen์ ๋ฃ์ด ๋ค์ ๋ฐฉ๋ฌธํ์ง ์๋๋ค. ์๋ก ์ฐ๊ฒฐ๋์ด์๋ ๋คํธ์ํฌ๋ฅผ ์ฐ๊ฒฐ๋์ด์์ง ์์ ๋คํธ์ํฌ๋ณด๋ค ๋จผ์ ๋ฐฉ๋ฌธํ๋ค. (DFS)
- seen ์งํฉ์ ์ถ๊ฐ๋์ด์์ง ์๋ ์ปดํจํฐ๋ฅผ ๋ฐฉ๋ฌธ์ ์ ๋คํธ์ํฌ์ ์ง์ ํ๋ค๋ ์๋ฏธ์ด๋ฏ๋ก ๋คํธ์ํฌ ๊ฐฏ์๋ฅผ ์นด์ดํธ ์ ํด์ค๋ค.
function solution(n, computers) {
const seen = new Set()
const dfs = i => {
seen.add(i)
for (const j in computers) {
if (!seen.has(j) && computers[i][j]) {
dfs(j)
}
}
}
let answer = 0
for (const i in computers) {
if (!seen.has(i)) {
answer++
dfs(i)
}
}
return answer
}
์๊ฐ๋ณต์ก๋: O(N)
๊ณต๊ฐ๋ณต์ก๋: O(N)