11726๋ฒ - 2*N ํ์ผ๋ง
์ด๋ฐ ๋ฌธ์ ์
๋๋ค.
2xn์ด๋ผ๋ ์ด ๊ณต๊ฐ์ด ์ฃผ์ด์ก์ ๋ 1x2ํ์ผ๊ณผ 2x1ํ์ผ์ ์ด์ฉํด์ ์ด ๊ณต๊ฐ์ ์ฑ์ธ ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ฉด ๋๋ ๋ฌธ์ ์ ๋๋ค.
์ด๋ฐ ๊ฒฝ์ฐ ๋ ๊ฐ์ง ์ ํ์ผ๋ก ๋๋ ์ ์๋๋ฐ
๋จผ์ ํ์ผ์ด 1x2ํ์ผ๋ก ๋๋๋ ๊ฒฝ์ฐ ์ ํ์ผ์ด 2x1 ํ์ผ๋ก ๋๋๋ ๊ฒฝ์ฐ์
๋๋ค.
๋ฐ๋ผ์ ์ ํ์์ DP(N) = DP(N-1) + DP(N-2)๋ผ๋ ํํ๋ก ์์ฑํ ์ ์์ต๋๋ค.
N = int(input())
print(dp(N)%10007)
์ ๋ ฅ์ ๋ฐ๊ณ ํฐ๊ฐ์ด ๋์ค๋๊น ํด๋ฅผ 10007๋ก ๋๋๋ผ ํ์ผ๋ฏ๋ก ๋ฌธ์ ๋๋ก ๋ฐ๋ผ์ค๋๋ค.
memo = [0] * 1001
def dp(n):
if n == 1:
return 1
if n == 2:
return 2
์ต๋ ๊ฐ์ด 1000์ด๋ฏ๋ก ๋ฉ๋ชจ์ด์ ์ด์
ํฌ๊ธฐ๋ 1001๋ก ์ค์ ํด์ฃผ๊ฒ ์ต๋๋ค.
1์ธ ๊ฒฝ์ฐ 1๊ฐ์ง ๊ฒฝ์ฐ๋ฐ์ ์๋๋ฏ๋ก 1 return, 2์ธ๊ฒฝ์ฐ 2๊ฐ์ง ๊ฒฝ์ฐ๋ฐ์ ์๋๋ฏ๋ก 2 return ํ๊ณ
if memo[n]:
return memo[n]
๋ฉ๋ชจ์ด์ ์ด์ ์ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ ๊ฒฝ์ฐ ํด๋น ๋ฐ์ดํฐ๋ฅผ return
memo[n] = dp(n-1) + dp(n-2)
return memo[n]
์๊น ๋์ถํ ์ ํ์์ return ํด์ฃผ๋ฉด ์ต์ข ์ ์ผ๋ก DP๋ฅผ ํ์ฉํด ๋ฌธ์ ํ์ด๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
11727๋ฒ - 2*N ํ์ผ๋ง 2
์ ๋ฌธ์ ๋ฅผ ์์ฉํ ๋ฌธ์ ์
๋๋ค.
์ด๋ฒ์ 2x2 ํ์ผ์ด ํ๋ ์ถ๊ฐ๋ฌ๋ค์.
์ด๊ธฐ๊ฐํ๊ณ ์ ํ์๋ง ์กฐ๊ธ ๋ฐ๊ฟ์ฃผ๋ฉด ๋ ๋ฏ ์ถ์ต๋๋ค.
N = int(input())
print(dp(N)%10007)
N์ ์ ๋ ฅ๋ฐ๊ณ
memo = [0] * 1001
def dp(n):
if n == 1:
return 1
if n == 2:
return 3
๊ธธ์ด๊ฐ 2์ผ๋ 2x2ํ์ผ ํ๋, 1x2ํ์ผ 2๋ฒ, 2x1ํ์ผ 2๋ฒ ์ด 3๋ฒ์ผ๋ก ๋ง๋ค์ ์๊ธฐ ๋๋ฌธ์ 3์ผ๋ก ์ด๊ธฐํ๋ฅผ ์งํํด์ค์๋ค.
if memo[n]:
return memo[n]
memo[n] = dp(n-1) + dp(n-2) + dp(n-2)
return memo[n]
๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง ๋ถ๋ถ์ 2x2ํ์ผ๋ ์ฌ ์ ์์ผ๋ฏ๋ก dp(n-2)๋ฅผ ํ๋ ๋ ์ถ๊ฐํ๋ฉด ์ ๋ต์ ๋์ถํ ์ ์์ต๋๋ค.
2133๋ฒ - ํ์ผ ์ฑ์ฐ๊ธฐ
ํ์ผ ์ฑ์ฐ๊ธฐ ๋ํ์ ๋ฌธ์ ์
๋๋ค.
์ด๋ฒ์๋ ํฌ๊ธฐ๊ฐ 3xN์ธ ๋ฒฝ์ 1x2, 2x1 ํ์ผ๋ก ์ฑ์ฐ๋ ๋ฐฉ๋ฒ์ ๊ณ์ฐํด์ผ ํฉ๋๋ค.
1. ํ์ผ ๊ฐ ์ ์ธ
ํ์ผ์ ์ฑ์ฐ๊ธฐ ์์ํ๋ ๋ถ๋ถ(์ด๊ธฐํ๊ฐ)๋ถํฐ ํ๋ฒ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
์ผ๋จ ๊ณต๊ฐ์ด 1์ธ ๊ฒฝ์ฐ์๋ ํ์ผ์ ์ธ์์ ๊ณต๊ฐ์ ๋ชป๋ง๋ญ๋๋ค!
๊ทธ๋ฆฌ๊ณ ๊ณต๊ฐ์ด 2์ธ ๊ฒฝ์ฐ์๋
์ด๋ ๊ฒ 3๊ฐ์ ๊ฒฝ์ฐ๋ก ์คํํธ๋ฅผ ๋์ ์ ์๊ฒ ์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ ๊ฐ ํ๋ ๊ฐ๊ณผํ๋ ์ ์ด ์๋๋ฐ GPTํํ
๋ฌผ์ด๋ณด๋ ๋ช
์พํ ํด๋ต์ ๋ด๋๋๊ตฐ์.
๊ทธ๊ฑด ๋ฐ๋ก ๊ณต๊ฐ์ด 0์ธ ๊ฒฝ์ฐ๋ ํ๋์ ๊ฒฝ์ฐ์ ์๋ก ์ทจ๊ธ๋์ด 1๋ก ์คํํธ๋ฅผ ๋์ ์ ์๋ค๋ ๊ฒ๋๋ค!
์ด์ ์ด๊ฑธ ์ฝ๋๋ก ํํํ๋ฉด
if n == 0:
return 1
if n == 1:
return 0
if n == 2:
return 3
์ด๋ฐ ๋๋์ผ๋ก ์ด๊ธฐ๊ฐ์ ์ ์ธํ๊ณ ์์ํ ์ ์์ต๋๋ค.
2. ํ์ผ์ ๋๋งบ์ ๋ ๊ฒฝ์ฐ์ ์
์ด๊ฒ ์ข ๋ณต์กํฉ๋๋ค.
์ผ๋จ ์์ ์์์ฒ๋ผ 2์นธ๋ง ๋จ์์ ๋๋ 3 X DP(N-2) ๊ฐ์ผ๋ก ์ ํ์์ ์ธ์ฐ๋ ๊ฒ ๊ฐ๋ฅํฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ์ด์ ์ ๊ฐ ๊ทธ๋ ค๋ ์ค๋ฅธ์ชฝ ์์๋ฅผ ๋ณด์๋ฉด 2XDP(N-์ง์) ๋งํผ ๊ณ์ํด์ ์ ํ์์ ์ธ์ฐ๋ ๊ฒ ๊ฐ๋ฅํ์ฌ ๊ฒฐ๊ณผ์ ์ผ๋ก N-i๊ฐ 0์ด ๋ ๋๊น์ง ์ ํ์์ ์ธ์ฐ๋ ๊ฒ ๊ฐ๋ฅํด์ง๋๋ค...
For๋ฌธ์ ์ฌ์ฉํ์ฌ N-i๊ฐ 0์ด ๋ ๋๊น์ง ์ ํ์์ ์ธ์ฐ๊ณ ๋ฉ๋ชจ์ด์ ์ด์ ์ ์ถ๊ฐํด์ฃผ๋ ๋ฐฉ์์ผ๋ก ์ฝ๋ฉํด์ผ ๋ฌธ์ ํ์ด๊ฐ ๊ฐ๋ฅํ๊ฒ ์ต๋๋ค.
N = int(input())
print(dp(N))
N ์ ๋ ฅ์ ๋ฐ์์ฃผ๊ณ dp(N)์ ์คํ์์ผ์ค๋๋ค.
memo = [0] * 1001
def dp(n):
tmp = 0
if n == 0:
return 1
if n == 1:
return 0
if n == 2:
return 3
๋ฉ๋ชจ์ด์ ์ด์ ์ ํ๋ ๋ง๋ค์ด์ฃผ๊ณ ์์ ๋ถ์์ฒ๋ผ ์์ ํฌ๊ธฐ์ ์๋ง๊ฒ return ๊ฐ์ ๋์ ํด์ค์๋ค.
if memo[n]:
return memo[n]
๋ฉ๋ชจ์ด์ ์ด์ ์ ์๋ ๊ฐ์ด๋ฉด ํด๋น ๋ฉ๋ชจ๋ก ๊ฐ์ return ํด์ฃผ๊ณ
tmp = 3 * dp(n-2)
์๋ ๊ฐ์ด๋ฉด ์ผ๋จ 2์นธ ๋จ์์ ๊ฒฝ์ฐ์ ์ ํ์์ ์ธ์ฐ๊ณ ํด๋น ๊ฐ์ tmp์ ์ถ๊ฐ์ํค๊ฒ ์ต๋๋ค.
for i in range(3,n+1):
if i%2 == 0:
memo[n] += 2 * dp(n-i)
ํต์ฌ ๋ถ๋ถ์ ๋๋ค.
4์นธ ์ด์์ ์ง์์นธ์ด ๋จ์์ ๊ฒฝ์ฐ์๋ 2 X DP( N - ๋ฐ๋ณต๋ฌธ๋ณ์)๋ผ๋ ์ ํ์์ 0์ด ๋๊ธฐ ์ ๊น์ง ๊ณ์ํด์ ๋๋ ค์ค๋๋ค.
ํด๋น ๋ถ๋ถ์ 4์นธ,6์นธ,8์นธ...๊ณ์ํด์ N ์ ๊น์ง ๊ฒฝ์ฐ์ ์๊ฐ ๋์ด๋ ์ฌ์ง๊ฐ ์๊ธฐ ๋๋ฌธ์ for๋ฌธ์์ ์ ํ์์ ๋ฃ์ด ์ฒ๋ฆฌํด์ฃผ๋๋ก ํฉ์๋ค.
return memo[n]
๋ง์ง๋ง์ผ๋ก return ๋ฉ๋ชจ์ด์ ์ด์ ์ ํ๋ฉด ์ ๋ต์ ๋์ถํ ์ ์์ต๋๋ค.