๋ฌธ์ ์ค๋ช
2×n ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ์ 1×2, 2×1 ํ์ผ๋ก ์ฑ์ฐ๋ ๋ฐฉ๋ฒ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์๋ ๊ทธ๋ฆผ์ 2×5 ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ์ ์ฑ์ด ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ n์ด ์ฃผ์ด์ง๋ค. (1 ≤ n ≤ 1,000)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ 2×n ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ์ ์ฑ์ฐ๋ ๋ฐฉ๋ฒ์ ์๋ฅผ 10,007๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ถ๋ ฅํ๋ค.
์ ์ถ๋ ฅ ์์
์ ๋ ฅ
9
์ถ๋ ฅ
55
๋ด ๋ฌธ์ ํ์ด
let N = Int(readLine()!)!
var dp = Array(repeating: 0, count: 1001)
func solution(_ n: Int) -> Int {
if n == 1 { return 1 }
if n == 2 { return 2 }
if dp[n] > 0 { return dp[n] } // ์ค๋ณต์ ํผํ๊ธฐ ์ํจ
dp[n] = (solution(n-2) + solution(n-1)) % 10007
return dp[n]
}
print(solution(N))
๐ DP ๋ฌธ์ ๋ก, ์ ํ์์ ๊ตฌํด์ฃผ๋๊ฒ ํฌ์ธํธ!
[์ ํ์]
- n์ด 1์ผ ๊ฒฝ์ฐ ๋ต์ 1
- n์ด 2์ผ ๊ฒฝ์ฐ ๋ต์ 2
- n์ด 3์ผ ๊ฒฝ์ฐ ๋ต์ 3
- n์ด 4์ผ ๊ฒฝ์ฐ ๋ต์ 5
- n์ด 5์ผ ๊ฒฝ์ฐ ๋ต์ 8
=> ์ด์ ๋ ์์ ๋ต์ ๊ตฌํ ๊ฐ์ด ํ์ฌ์ ๋ต์ด ๋๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
=> dp[n] = dp[n-1] + dp[n-2]
[์ฝ๋ ์ค๋ช ]
- n์ด 1, 2์ผ ๊ฒฝ์ฐ์๋ ์ด์ ๋ ์๊ฐ ์กด์ฌํ์ง ์์ผ๋ฏ๋ก ๋ฐ๋ก ํด๋นํ๋ ๋ต์ returnํ๋ค.
- dp[n]์ด 0๋ณด๋ค ํด ๊ฒฝ์ฐ(0์ด ์๋ ๊ฒฝ์ฐ) dp[n] ๊ฐ์ ๊ทธ๋๋ก returnํ๋ค.
=> dp[n]์ 0์ด ์๋ ์ด๋ค ๊ฐ์ด ์ ์ฅ๋์ด์๋ค๋ ๊ฒ์ ์ด๋ฏธ dp[n]์ ๊ณ์ฐ๋์ ์ด ์๋ค๋ ์๋ฏธ์ด๋ค.
๊ตณ์ด ์ค๋ณต๋ ๊ณ์ฐ์ ๋ ํด์ค ํ์๋ ์๊ธฐ ๋๋ฌธ์ ์ฐ์ฐ ์์ด ๊ทธ๋๋ก์ ๊ฐ์ ๋ฆฌํดํ๋ค.
(dp์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ๊ณผ๋ ๊ฐ์ ๋ถ๋ถ์ด๊ธฐ๋ ํจ. ๐์ด์ ๊ฒ์๊ธ ์ฐธ๊ณ !)
2021.08.28 - [๐ Algorithm Note/๐ with Swift] - [Swift Algorithm Note] ๋์ ๊ณํ๋ฒ (feat. Fibonacci) - ์์ ์์ธ์ ๊ฑธ๋ฆฌ์ง ์์ ๊ฒฝ์ฐ์๋ ์ฌ๊ท ํธ์ถ๋ก ์ ํ์์ ๊ตฌํํด์ฃผ์๋ค.
๐ก ํผ๋๋ฐฑ
- ์ฒ์์ ์ค๋ณต์ ํผํด์ฃผ๋ ์ฝ๋๋ฅผ ์์ฑํ์ง ์์์ ๊ณ์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ์๋๋ฐ,
๋๋ฒ๊น ํ๋ฉด์ ํ์ธํด๋ณด๋๊น ๊ณ์ ์ค๋ณต๋ ๊ณ์ฐ์ ํ๊ณ ์๋ค๋ ๊ฒ์ ์ ์ ์์๋ค.
DP์ธ๋งํผ, ์ค๋ณต์ ๋ํด์ ๋ ์ ๊ฒฝ์จ์ฃผ์ด์ผ ํ ๊ฒ ๊ฐ๋ค.
๋ฌธ์
'3๏ธโฃ Swift > Problem Solving' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Swift Algorithm] ์ด์ค์ฐ์ ์์ํ Programmers(Lv.3) (0) | 2021.12.21 |
---|---|
[Swift Algorithm] ๊ตฌ๊ฐ ํฉ ๊ตฌํ๊ธฐ 4 BOJ #11659 (2) | 2021.10.20 |
[Swift Algorithm] RGB๊ฑฐ๋ฆฌ BOJ #1149 (0) | 2021.10.20 |
[Swift Algorithm] ๊ณ๋จ ์ค๋ฅด๊ธฐ BOJ #2579 (0) | 2021.10.19 |
[Swift Algorithm] 1, 2, 3 ๋ํ๊ธฐ BOJ #9095 (0) | 2021.10.19 |
๋๊ธ