๊ทธ๋์ ์ฌ์ด ์๊ณ ๋ฆฌ์ฆ๋ง ํ๋ค๊ฐ ์ค๋๋ง์ ๊ธฐ๋ฒ์ ์ฐ๋ ์๊ณ ๋ฆฌ์ฆ์ ํธ๋ ๊ฐ๋ฌผ๊ฐ๋ฌผํ๋ค. ๋งค์ผ๋งค์ผ ํ ๊ฑฐ๋ ํ์คํ๊ฒ ์ ๋ฆฌํ๊ณ ๊ฐ์! ๐
number ๋ฐฐ์ด์์ 3๋ช
์ ํ์์ ์ ํํ์ ๋, ํฉ์ด 0์ด ๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.
for ๋ฃจํ(O(Nยณ))๋ก ํ ์๋ ์์ง๋ง, DFS๋ฅผ ํ์ฉํ์ฌ 3๋ช ์ ํ์์ ์กฐํฉ์ ํ์ํ๊ณ , ํฉ์ด 0์ธ์ง ์ฒดํฌํ๋ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
count == 3์ด๋ฉด ์ข
๋ฃ)class Solution {
int answer = 0; // ์ ๋ต ๊ฐ์ ์ ์ฅ
public int solution(int[] number) {
dfs(number, 0, 0, 0); // ์ด๊ธฐ DFS ํธ์ถ (์ธ๋ฑ์ค 0๋ถํฐ ์์)
return answer;
}
public void dfs(int[] number, int index, int count, int sum) {
if (count == 3) { // ํ์ 3๋ช
์ ์ ํํ ๊ฒฝ์ฐ
if (sum == 0) answer++; // ํฉ์ด 0์ด๋ฉด ์ ๋ต ์ฆ๊ฐ
return;
}
for (int i = index; i < number.length; i++) { // ํ์ฌ ์ธ๋ฑ์ค๋ถํฐ ํ์
dfs(number, i + 1, count + 1, sum + number[i]); // ๋ค์ ์กฐํฉ ํ์
}
}
}
number = {-2, 3, 0, 2, -5} ๊ฐ ์ฃผ์ด์ก์ ๋, DFS๊ฐ ํ์ํ๋ ๋ฐฉ์์ ๋ค์๊ณผ ๊ฐ๋ค.
DFS(0, 0, 0)
โโ DFS(1, 1, -2)
โ โโ DFS(2, 2, 1)
โ โ โโ DFS(3, 3, 1) โ X (sum != 0)
โ โ โโ DFS(4, 3, -4) โ X (sum != 0)
โ โ
โ โโ DFS(3, 2, -2)
โ โ โโ DFS(4, 3, 0) โ โ
์ ๋ต 1
โ โ
โ โโ DFS(4, 2, -7)
โ
โโ DFS(2, 1, 3)
โ โโ DFS(3, 2, 3)
โ โ โโ DFS(4, 3, 0) โ โ
์ ๋ต 2
๐ก ์ ๋ต: (์ฒซ ๋ฒ์งธ, ์ธ ๋ฒ์งธ, ๋ค ๋ฒ์งธ) / (๋ ๋ฒ์งธ, ๋ค ๋ฒ์งธ, ๋ค์ฏ ๋ฒ์งธ) ์กฐํฉ 2๊ฐ ๋ฐ๊ฒฌ!
๋ค๋ฅธ ์ฌ๋๋ค์ ํ์ด๋ฅผ ๋ณด๋ 3์ค for๋ฌธ์ด ์๋์ ์ผ๋ก ๋ง๊ณ ,
bfs & combination์ ๊ตฌํํ ์ฌ๋๋ ์์๋ค.
์กฐ๊ฑด์ด ์๋ ๊ฒฝ์ฐ & ์ํ ํ์๊ฐ ์ ์ ๊ฒฝ์ฐ์๋ 3์ค for๋ฌธ์ด ํจ์จ์ ์ธ๊ฒ ์ด์ง ์ถฉ๊ฒฉ์ด์๋ค.
| ๋ฐฉ๋ฒ | ์๊ฐ ๋ณต์ก๋ | ์ฅ์ | ๋จ์ |
|---|---|---|---|
| DFS (ํ์ฌ ์ฝ๋) | O(2^N) โ O(Nยณ) | ์ ์ฐํ ํ์ ๊ฐ๋ฅ | ์คํ ์ค๋ฒํค๋ ๋ฐ์ ๊ฐ๋ฅ |
์ผ์ค for ๋ฃจํ | O(Nยณ) | ๊ฐ์ฅ ๋น ๋ฆ, ๋จ์ํจ | ํ์ฅ์ฑ์ด ๋ฎ์ |
1๏ธโฃ ์ด ๋ฌธ์ ์์๋ for ๋ฃจํ๊ฐ ๋ ๋น ๋ฅด์ง๋ง,
2๏ธโฃ DFS๋ ์กฐํฉ์ ์ฐพ์ ๋ ํ์ฉํ ์ ์๋ ์ค์ํ ๊ธฐ๋ฒ์ด๋ฏ๋ก ํ์คํ ์ตํ์ผ ํ๋ค!
โ
DFS๋ก ์กฐํฉ์ ์ฐพ์ ๋๋ index๋ฅผ ์ฆ๊ฐ์ํค๋ฉด์ ์ค๋ณต ์ ํ์ ๋ฐฉ์งํด์ผ ํ๋ค.
โ
๋ฐฑํธ๋ํน์ ํ์ฉํ๋ฉด ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ํ์ํ๋ ๋ฌธ์ ๊ฐ ์ฝ๊ฒ ํด๊ฒฐ๋๋ค.
โ
์ผ์ค for ๋ฃจํ๊ฐ ๊ฐ๋ฅํ ๋๋ for๋ฅผ ์ฐ๋ ๊ฒ์ด ๋ ๋น ๋ฅด๋ค.
๐ฏ ๋ด์ผ์ DFS + ๋ฐฑํธ๋ํน์ ํ์ฉํ ๋ค๋ฅธ ์กฐํฉ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์! ๐