n๊ฐ์ ์์ด ์๋ ์ ์๋ค์ด ์์ต๋๋ค. ์ด ์ ์๋ค์ ์์๋ฅผ ๋ฐ๊พธ์ง ์๊ณ ์ ์ ํ ๋ํ๊ฑฐ๋ ๋นผ์ ํ๊ฒ ๋๋ฒ๋ฅผ ๋ง๋ค๋ ค๊ณ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด [1, 1, 1, 1, 1]๋ก ์ซ์ 3์ ๋ง๋ค๋ ค๋ฉด ๋ค์ ๋ค์ฏ ๋ฐฉ๋ฒ์ ์ธ ์ ์์ต๋๋ค.
-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3
์ฌ์ฉํ ์ ์๋ ์ซ์๊ฐ ๋ด๊ธด ๋ฐฐ์ด numbers
, ํ๊ฒ ๋๋ฒ target
์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ ์ซ์๋ฅผ ์ ์ ํ ๋ํ๊ณ ๋นผ์ ํ๊ฒ ๋๋ฒ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์๋ฅผ return ํ๋๋ก solution
ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
numbers | target | return |
---|---|---|
[1,1,1,1,1] | 3 | 5 |
[4,1,2,1] | 4 | 2 |
๋ฌธ์ ์์์ ๊ฐ์ต๋๋ค.
+4+1-2+1 = 4
+4-1+2-1 = 4
๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํจ์จ์ ์ผ๋ก ํ์ํ๊ธฐ ์ํด DFS๋ฅผ ์ฌ์ฉํ์๋ค.
numbers
๋ฐฐ์ด์ 0๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ ๋ง์ง๋ง ์ธ๋ฑ์ค๊น์ง ์ํํ๋ฉด์,
ํ์ฌ ์ซ์๋ฅผ ๋ํ๋ ๊ฒฝ์ฐ์, ๋นผ๋ ๊ฒฝ์ฐ ๊ฐ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ฌ๊ท๋ฅผ ํตํด ๊ตฌํ๋ค.
class Solution {
public static int solution(int[] numbers, int target) {
return dfs(numbers, target, 0, 0);
}
public static int dfs(int[] numbers, int target, int index, int currSum) {
// ๋ชจ๋ ์ซ์๋ฅผ ์กฐํฉํ ๊ฒฝ์ฐ
if (index == numbers.length) {
if (currSum == target) {
return 1; // target๊ณผ ์ผ์นํ ๊ฒฝ์ฐ
}
else {
return 0; // target๊ณผ ์ผ์นํ์ง ์๋ ๊ฒฝ์ฐ
}
}
// ํ์ฌ ์ซ์๋ฅผ ๋ํ๋ ๊ฒฝ์ฐ
int add = dfs(numbers, target, index + 1, currSum + numbers[index]);
// ํ์ฌ ์ซ์๋ฅผ ๋นผ๋ ๊ฒฝ์ฐ
int sub = dfs(numbers, target, index + 1, currSum - numbers[index]);
return add + sub;
}
}
numbers
, target
, ํ์ฌ ์ธ๋ฑ์ค(index
), ํ์ฌ๊น์ง์ ๊ฒฐ๊ณผ(currSum
)๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ๊ฐ์ง๋ dfs ๋ฉ์๋๋ฅผ ํธ์ถํ๋ค.
dfs๋ฅผ ์งํํ๋ค ๋ชจ๋ ์ซ์๋ฅผ ์กฐํฉํ ๊ฒฝ์ฐ ์ฆ, ํ์ฌ ์ธ๋ฑ์ค๊ฐ numbers
๋ฐฐ์ด์ ๊ธธ์ด๋ ๊ฐ์์ง ๊ฒฝ์ฐ, ํ์ฌ๊น์ง์ ๊ฒฐ๊ณผ currSum
์ target
์ด๋ ๋น๊ตํ๋ค.
currSum
๊ณผ target
์ด ์ผ์นํ ๊ฒฝ์ฐ, ์ฐ๋ฆฌ๊ฐ ๊ตฌํด์ผ ํ๋ ๊ฒฝ์ฐ์ ์์ด๊ธฐ ๋๋ฌธ์ 1์ ๋ฆฌํดํด ์ค๋ค.
currSum
๊ณผ target
์ด ์ผ์นํ ๊ฒฝ์ฐ, ์ํ๋ ๊ฒฝ์ฐ์ ์๊ฐ ์๋๊ธฐ ๋๋ฌธ์ 0์ ๋ฆฌํดํด ์ค๋ค.
currSum
์ ํ์ฌ ์ธ๋ฑ์ค์ ์์๋ฅผ ๋ํ ๊ฐ์ผ๋ก ๋ค์ ์ธ๋ฑ์ค์ ๋ํ dfs๋ฅผ ์ฌ๊ท ํธ์ถํ๋ค.
currSum
์ ํ์ฌ ์ธ๋ฑ์ค์ ์์๋ฅผ ๋บ ๊ฐ์ผ๋ก ๋ค์ ์ธ๋ฑ์ค์ ๋ํ dfs๋ฅผ ์ฌ๊ท ํธ์ถํ๋ค.
์ผ์ฐ์ผ์ฐ ํ์ดํ ์ ๋๋น๐๐ฅ๐๐ฅ