๐ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ๋งํฌ
โ๐ป ๋ฌธ์ ํ์ด Github ๋งํฌ
๋ฌธ์ ์ค๋ช
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 ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ์ฃผ์ด์ง๋ ์ซ์์ ๊ฐ์๋ 2๊ฐ ์ด์ 20๊ฐ ์ดํ์ ๋๋ค.
- ๊ฐ ์ซ์๋ 1 ์ด์ 50 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
- ํ๊ฒ ๋๋ฒ๋ 1 ์ด์ 1000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
numbers | target | return |
[1, 1, 1, 1, 1] | 3 | 5 |
[4, 1, 2, 1] | 4 | 2 |
๋ฌธ์ ํ์ด
๋์ ํ์ด
import Foundation
func solution(_ numbers:[Int], _ target:Int) -> Int {
var answer = 0
func dfs(now: Int, i: Int){
if i == numbers.count && now == target {
answer += 1
}
if numbers.count > i {
dfs(now: now-numbers[i], i: i+1)
dfs(now: now+numbers[i], i: i+1)
}
}
dfs(now: 0, i: 0)
return answer
}
๋ฐ๋ก ์ด์ ์ ํผ๋ก๋๋ฅผ ๊ณต๋ถํ๋ฉด์ DFS์ ํ์ด ๋ฐฉ๋ฒ์ ๋ํด์ ๊ณต๋ถํ์๊ณ , ์์นจ์ ํด๋น ๋ฌธ์ ๋ฅผ ๋ค์ ํ๋ฒ ํ์ด๋ณด์์ ์ด๋ฒ ๋ฌธ์ ๋ ๋ณต์ตํ๋ ๋ฏ ํ์๋ค.
๋ฑ ๋ณด์๋ง์ ์ฌ๊ทํจ์ DFS๋ก ํธ๋ ๊ฒ์ด๋ผ๊ณ ๊นจ๋ฌ์๊ณ , ํผ๋ก๋์ ์กฐ๊ธ๋ง ๋ฐ๊พผ ์ํ์์ ํ์๋ค!
ํ๋ฒ๋ง์ ํ๋ฆฌ๋ ๊ฒ์ ๋ณด๊ณ ์์ฃผ ์พ๊ฐ์ด.. ํฌ..
๋ค๋ฅธ ์ฌ๋ ํ์ด
import Foundation
func searchTarget(number: [Int], depth: Int, target: Int, value: Int, answer: inout Int) {
// MARK: - ์ฌ์ฉํ ์ ์๋ ์ซ์๊ฐ ๋ด๊ธด ๋ฐฐ์ด numbers, ํ๊ฒ ๋๋ฒ target์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ ์ซ์๋ฅผ ์ ์ ํ ๋ํ๊ณ ๋นผ์ ํ๊ฒ ๋๋ฒ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
if depth >= number.count {
if target == value { answer = answer + 1 }
return
}
// MARK: - ์ด ์๋ฅผ ์ ์ ํ ๋ํ๊ฑฐ๋ ๋นผ์ ํ๊ฒ ๋๋ฒ๋ฅผ ๋ง๋ค๋ ค๊ณ ํฉ๋๋ค.
searchTarget(number: number, depth: depth + 1, target: target, value: value + number[depth], answer: &answer)
searchTarget(number: number, depth: depth + 1, target: target, value: value - number[depth], answer: &answer)
}
func solution(_ numbers:[Int], _ target:Int) -> Int {
var answer = 0
searchTarget(number: numbers, depth: 0, target: target, value: 0, answer: &answer)
return answer
}
dfs ํจ์๋ฅผ ๋ฐ๋ก ๋ง๋ค์ด์ ํจ์์ ๋งค๊ฐ๋ณ์์ depth์ value ๋ฟ๋ง ์๋๋ผ ์ถ๊ฐํด์ผ๋ ๊ฒ ๋ง์์ง ๋ฏ ํ๋ค!
๋๋ dfs ํจ์๋ฅผ ๋ฐ๋ก ๋ง๋๋ ์ฐ์ต์ ํด๋ด์ผ๊ฒ ๋ค.
๊ทธ๋ฆฌ๊ณ answer์ ๊ฐํ์์ ์ฌ์ฉํ์ฌ answer ๊ฐ์ ์ถ๋ ฅํ๋ return ํํ๊ฐ ์๋ inout ํค์๋๋ฅผ ์จ์ ํจ์๋ฅผ ๋ง๋ค์๋ค.
์ค๋๋ ๋ ํ๋ ๋ฐฐ์ด๋ค.
import Foundation
func caculation(numbers: [Int], target: Int, index: Int, sum: Int) -> Int {
if index == numbers.count {
return sum == target ? 1 : 0
}
return caculation(numbers: numbers, target: target, index: index + 1, sum: sum + numbers[index]) + caculation(numbers: numbers, target: target, index: index + 1, sum: sum - numbers[index])
}
func solution(_ numbers: [Int], _ target: Int) -> Int {
return caculation(numbers: numbers, target: target, index: 0, sum: 0)
}
์ด ๋ถ์ ๋ต์ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ๋์ถํ์๋ค.
ํจ์ ์์ฒด์ return ๊ฐ์ ์ฃผ์ด์ ๋ฐ๋ณต๋ฌธ์ด ๋๋ ํฉ์ด target๊ณผ ๊ฐ๋ค๋ฉด 1๋ฅผ ์ถ๋ ฅํ๋๋ฐ, ํด๋น 1์ ๋ค๋ฅธ ๋ณ์์ ๋ํ์ง ์๊ณ ,
์ฌ๊ทํจ์๋ผ๋ฆฌ ๋ํ์ฌ ๋ต์ ๋์ถํ์๋ค.