9095๋ฒ - 1,2,3 ๋ํ๊ธฐ
DP๋ฌธ์ ์ธ๋ฐ ๊ทธ๋ฅ ์ฌ๊ท๋ก ํ์ด๋ฒ๋ ธ์ต๋๋ค ํํ...
N = int(input())
์ ๋ ฅ๋ฐ์ ํ์๋ฅผ ๋ฐ๊ณ
for _ in range(N):
cnt = 0
ans = []
a = int(input())
dp(0,a)
print(cnt)
๋ณ์๋ฅผ ๋ฐ์ ์ฌ๊ท๋ฅผ ๋๋ ค์ค๋๋ค.
def dp(start,end):
global cnt
if start >= end:
cnt += 1
return
๋ง์ฝ start๋ณ์๊ฐ end์ ๊ฐ์์ง๊ฑฐ๋ ๋ ์ปค์ง๋ค๋ฉด cnt๋ฅผ ํ๋ ์ฌ๋ฆฌ๊ณ ํจ์๋ฅผ ์ข ๋ฃํฉ๋๋ค.
for i in range(1,4):
if sum(ans) + i > end:
continue
1,2,3์ ์ฌ์ฉํ์ฌ ํด๋น ์ซ์๋ฅผ ์ด๋ป๊ฒ ๋ง๋๋์ง๊ฐ ๊ด๊ฑด์ด๋ฏ๋ก 1~3๊น์ง for๋ฌธ ์ฌ๊ท๋ฅผ ํตํด ๊ตฌํํ๊ฒ ์ต๋๋ค. ๋๋ฆฌ๋ค๊ฐ ๋ง์ฝ ์ ์ฅํด๋ ์ซ์(1,1,1...) + i(1or2or3) ์ด end๋ณด๋ค ์ปค์ง๋ค๋ฉด continue๋ฅผ ์จ์ ํด๋น for๋ฌธ์ ์คํตํ๊ฒ ์ต๋๋ค.
ans.append(i)
๋ง์ฝ ๋ํด์ ์ปค์ง์ง ์๋๋ค๋ฉด ํด๋น ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด i๋ฅผ ans๋ฐฐ์ด์ ์ถ๊ฐํ๊ณ
dp(start+i,end)
์ฌ๊ท๋ก ๋ค์ ๋ค์ด๊ฐ์ ์๋ฅผ ๋ค์ด ํฉ์ด 4๋ผ๋ฉด 1111 ๊ตฌํ๊ณ
ans.pop()
pop ํด์ 1112,1113,1114 ๋ค continue์ ๋งํ๊ณ 111์ ๋๋ฌ์ผ๋ 112์คํ => ํฉ์ฐ 4๋๊น cnt+1 ์ด๋ฐ์ฉ์ผ๋ก ์๋๋ฉ๋๋ค.
2579 - ๊ณ๋จ ์ค๋ฅด๊ธฐ
์ ๋๋ก ๋ DP ๋ฌธ์ ์
๋๋ค.
DP๋ ์ ํ์์ ์ธ์ฐ๋๊ฒ ์ ์ผ ์ค์ํ๋ ๋งํผ ๋ฌธ์ ๋ถ์๋ ์ ํด์ผ ์ฌ์ฉ์ด ๊ฐ๋ฅํฉ๋๋ค.
ํด๋น ๋ฌธ์ ๋ ์ต๋๊ฐ์ผ๋ก ๊ณ๋จ์ ์ค๋ฅด๋ฉด ์ ์๊ฐ ๋ช์ ์ธ๊ฐ ๋ฌป๋ ๋ฌธ์ ์
๋๋ค.
์ต๋๊ฐ์ผ๋ก ์ค๋ฅผ ์ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ ๊ฐ์ง๊ฐ ์๋๋ฐ,
์ด ๋๊ฐ์ง ๊ฒฝ์ฐ์ ๋๋ค.
๋ง์ง๋ง ๊ณ๋จ์ ๊ธฐ์ค์ ์ผ๋ก ์ผ์ ์ด์ ๋ N๋ฒ์งธ ๊ณ๋จ์ ๋ฐ์์ผ๋ง ๋๋๋ค๋ ์ ์ฝ์ด ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
1๋ฒ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ๋ ๊ณ๋จ์ ์ฐ์์ผ๋ก ์ต๋ ๋ ๋ฒ๋ง ๋ฐ์ ์ ์๋ค๋ ์ ์ฝ์ด ์์ผ๋ฏ๋ก, ์์ ๊ทธ๋ฆผ์ ๊ทธ๋ ค๋ ๊ฒ๊ณผ ๊ฐ์ด N-3๋ฒ์งธ ๊ณ๋จ์ ๋ฐ๊ณ N-1๋ฒ์งธ ๊ณ๋จ์ ๋ฐ์์ผ ๋ง์ง๋ง ๊ณ๋จ์ธ N๋ฒ์งธ ๊ณ๋จ์ ๋ฐ์ ์ ์์ต๋๋ค.
๋ฐ๋ฉด, 2๋ฒ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ๋ ์ ์ฝ์ด ์์ผ๋ฏ๋ก N-2๋ฒ์งธ ๊ณ๋จ์ ๋ฐ๊ณ ๋ฐ๋ก ๋ง์ง๋ง ๊ณ๋จ์ธ N๋ฒ์งธ ๊ณ๋จ์ ๋ฐ๋ ๊ฒ ๊ฐ๋ฅํฉ๋๋ค.
์ด๋ฅผ ์์ผ๋ก ์ธ์๋๋ฉด
1. DP(N-3)(N-3๊น์ง์ ์ต๋๊ฐ) + stair(N-1)(N-1์ ๊ณ๋จ ์ ์) + stair(N)(N์ ๊ณ๋จ ์ ์)
2. DP(N-2)(N-2๊น์ง์ ์ต๋๊ฐ) + stair(N)(N์ ๊ณ๋จ ์ ์)
๋ผ๋ ํ์์ผ๋ก ์ธ์ธ ์ ์์ต๋๋ค.
N = int(input())
stair = []
for _ in range(N):
a = int(input())
stair.append(a)
์ผ๋จ ๊ณ๋จ์ ๊ฐ์ํ๊ณ ๊ณ๋จ์ ์ ํ ๊ฐ๋ค์ ์ ๋ ฅ๋ฐ์์ค์๋ค.
if N == 1:
print(stair[0])
elif N == 2:
print(stair[0]+stair[1])
1์ ์ ๋ ฅ๋ฐ์์๋์ 2๋ฅผ ์ ๋ ฅ๋ฐ์์๋๋ ์ ํ์ ์คํํธ๊ฐ N-3๋ถํฐ์ด๊ธฐ ๋๋ฌธ์ ์์ธ๋ก ์ ๋ ๊ฒ ์ฒ๋ฆฌํด์ค๋๋ค.
else:
#dp ์ด๊ธฐํ
dp = [0]*301
dp[0] = stair[0]
dp[1] = stair[0]+stair[1]
dp[2] = max(stair[0] + stair[2], stair[1] + stair[2])
dp ์์๋ถ๋ถ์ ๋๋ค. 0๊ณผ 1, 2๋ ์ด๊ธฐ๊ฐ์ ์ง์ ํด์ค์๋ค. ์ด๊ฒ ๋ํ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ํ์์์ ๋์ค๋ ์ต์ ๋ณ์๊ฐ N-3๋ถํฐ์ด๊ธฐ ๋๋ฌธ์ 4๋ฒ์งธ ๊ณ๋จ๋ถํฐ ์ค์ง์ ์ผ๋ก ์ ํ์ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
#dp ์ ํ์
for i in range(3,N):
dp[i] = max(dp[i-3]+stair[i-1]+stair[i],dp[i-2]+stair[i])
์์ ๋ฌธ์ ๋ถ์์ ์ค์ํ๋๋ก
N-3,์ง์ ๊ณ๋จ,๋ง์ง๋ง๊ณ๋จ์ ๊ฑฐ์ณ์ ์ค๋๊ฐ
์ง์ ๊ณ๋จ,๋ง์ง๋ง๊ณ๋จ์ ๊ฑฐ์ณ์ ์ค๋๊ฐ
๋ฅผ ํ๋จํด์ฃผ์ด ๊ทธ์ค ๋ ํฐ ๊ฐ์ ๊ฐ๋ ๊ฐ์ dp๋ฆฌ์คํธ์ ๋ด์์ฃผ๋๋ก ํฉ์๋ค.
๊ทธ๋ฌ๋ฉด dp๊ฐ์ ๊ฒฐ๊ตญ ํด๋น ๊ณ๋จ ์์น์์ ๊ฐ์ง ์ ์๋ ์ต๋๊ฐ์ ๋ชจ์์ด ๋๊ณ
๊ทธ์ค ์ ์ผ ๋ง์ง๋ง ๊ณ๋จ์ ์ต๋๊ฐ => ๊ฒฐ๊ตญ ์ ๋ต์ด๋๊น
print(dp[N-1])
์ ํด์ฃผ๋ฉด ์ฑ๊ณต์ ์ผ๋ก ์ ๋ต์ ๋์ถํ ์ ์์ต๋๋ค.