๐ ๋ค์ด๊ฐ๋ฉฐ
DFS ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ ํ๋ก๊ทธ๋๋จธ์ค '๋คํธ์ํฌ' ๋ฌธ์ ํ์ด๋ฅผ ํด๋ณด๊ฒ ๋ค.
โ ๋ฌธ์
๋ฌธ์ ์ค๋ช
๋คํธ์ํฌ๋ ์ปดํจํฐ ์ํธ ๊ฐ์ ์ ๋ณด๋ฅผ ๊ตํํ ์ ์๋๋ก ์ฐ๊ฒฐ๋ ํํ๋ฅผ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ปดํจํฐ 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์ ๋๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ต๋ ์ฌ์ฉํ ์ ์๋ ํ์์ ์ต๋ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์ ์ถ๋ ฅ ์
n | computers | retrun |
3 | [[1, 1, 0], [1, 1, 0], [0, 0, 1]] | 2 |
3 | [[1, 1, 0], [1, 1, 1], [0, 1, 1]] | 1 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์์ #1
์๋์ ๊ฐ์ด 2๊ฐ์ ๋คํธ์ํฌ๊ฐ ์์ต๋๋ค.
์์ #2
์๋์ ๊ฐ์ด 1๊ฐ์ ๋คํธ์ํฌ๊ฐ ์์ต๋๋ค.
๐ก ํ์ด
DFS๋ฅผ ํ์ฉํ๋ ๋ฌธ์ ๋ค.
์ ๋ ฅ์ผ๋ก 2์ฐจ์ ๋ฐฐ์ด์ ๋ฐ๊ฒ ๋๋๋ฐ, ๋ฐ์ ๋ฐฐ์ด์ ์ํํ๋ฉด์ ํด๋น ์ธ๋ฑ์ค๋ฅผ ๋ฐฉ๋ฌธ์ ํ๋์ง ์ ํ๋์ง ์ฒดํฌ๋ฅผ ์ํ๊ฒ ๋๋ฉด ๋ฌดํ ๋ฃจํ์ ๋น ์ง๊ฒ ๋๊ธฐ ๋๋ฌธ์ ๋ฐฉ๋ฌธ ์ฌ๋ถ ์ฒดํฌ๊ฐ ์ ๋ง ์ค์ํ๋ค.
๊ทธ๋์ ๋จผ์ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ์ฒดํฌํ๊ธฐ ์ํ ๋ฐฐ์ด์ Array ๋ฉ์๋๋ฅผ ํ์ฉํด ๊ธธ์ด๋ ์ ๋ ฅ๋ฐ์ ๊ธธ์ด์ ๋์ผํ๊ณ ์ด๊ธฐ ๊ฐ์ ๊ฐ๊ฐ false๋ก ์ฃผ์๋ค.
๊ทธ๋์ ํด๋น ์ธ๋ฑ์ค(์ปดํจํฐ)์ ๋ฐฉ๋ฌธํ์ง ์์๋ค๋ฉด ๋ณธ๊ฒฉ์ ์ผ๋ก ํด๋น ์ธ๋ฑ์ค๋ฅผ ๋๊ฒจ์ฃผ๋ฉด์ dfsํจ์๋ฅผ ํธ์ถํ๊ฒ ๋๋ค.
dfsํจ์ ์์์๋ ์ฒซ ๋ฒ์งธ๋ก ๋ฐฉ๋ฌธ์ ํ์ผ๋ ํด๋น ์ธ๋ฑ์ค์ true ๊ฐ์ ์ฃผ์ด์ ๋ฐฉ๋ฌธ์ ํ๋ค๊ณ ์ฒดํฌ๋ฅผ ํ๊ณ ,
๋ค์ ๊ทธ ์์์ for๋ฌธ์ ๋๊ฒ ๋๋๋ฐ ํด๋น ์ปดํจํฐ์ ์ฐ๊ฒฐ๋์ด ์๊ณ (value === 1) ๋ฐฉ๋ฌธํ์ง ์์๋๋ผ๋ฉด
๋ค์ ์ฌ๊ท๋ก ๋ป์ด ๋๊ฐ๋ฉด์ ๋ฐฉ๋ฌธํ๋ ์ธ๋ฑ์ค(์ปดํจํฐ)์ true ๊ฐ์ ์ฃผ์ด ๋ฐฉ๋ฌธ ์ฒดํฌ๋ฅผ ํด์ค๋ค.
์ด์ dfsํจ์๊ฐ ๋์ด ๋๋ฉด ์ด๊ธฐ ํธ์ถ๋์๋ dfsํจ์๋ก ๋์๊ฐ์ answer์ ๊ฐ์ ์ฆ๊ฐ์์ผ์ค์ผ๋ก์จ ๋คํธ์ํฌ ๊ฐ์๋ฅผ ์ฆ๊ฐ์์ผ ์ค๋ค.
์ด ์ฝ๋์ ํต์ฌ์ ๋ฐฉ๋ฌธ ์ฌ๋ถ๋ฅผ ์ฒดํฌํ๋ฉฐ if๋ฌธ์ ํตํด ํด๋น ์ปดํจํฐ์ ์ฐ๊ฒฐ ๋์ด์๋์ง, ๋ฐฉ๋ฌธ์ ํ์๋์ง๋ฅผ ์ฌ๊ท ํจ์๋ก ๋ป์ด๋๊ฐ๋ฉด์ ํ์ธํ๊ณ answer์ ๊ฐ์ ์ฆ๊ฐ์์ผ ๋ต์ ๋ฆฌํดํ๋ค.
ํ์ด ์ฝ๋
function solution(n, computers) {
let answer = 0;
const length = computers.length;
const visited = Array.from({ length: n }, () => false);
function dfs(index) {
visited[index] = true;
for (let i = 0; i < length; i++) {
if (computers[index][i] && !visited[i]) {
dfs(i);
}
}
}
for (let i = 0; i < length; i++) {
if (!visited[i]) {
dfs(i);
answer++;
}
}
return answer;
}
โ ์ฑ์
๐ง ํ๊ธฐ
๋ง์ ํ์์ ๋๋ ์ด๋ ค์ด ๋ฌธ์ ๋ ์๋์๋ค. ์์ง DFS๋ฌธ์ ์ธ์ง ์๋์ง ์ด๋ค ์์ผ๋ก ํด๊ฒฐํด ๋์๊ฐ์ผ ํ๋์ง ๋ง์ด ๋ถ์กฑํ ๊ฒ ๊ฐ๋ค. ๋ฌธ์ ๋ฅผ ์ดํดํ ๋๋ ์ด๋ ค์์ด ์์ด์ ๊พธ์คํ ์ฌ๋ฌ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ฉด์ DFS/BFS ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์ ๋ฅ์ํด์ ธ์ผ๊ฒ ๋ค.