[์๊ณ ๋ฆฌ์ฆ] #04 ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ-๊ฐ๋ฏธ์ ์ฌ
๐ '๊ฐ๋ฏธ ์ ์ฌ '๋ฌธ์
๐ง ๋ฌธ์
๊ฐ๋ฏธ ์ ์ฌ๋ ๋ถ์กฑํ ์๋์ ์ถฉ๋นํ๊ณ ์ ๋ฉ๋๊ธฐ ๋ง์์ ์๋์ฐฝ๊ณ ๋ฅผ ๋ชฐ๋ ๊ณต๊ฒฉํ๋ ค๊ณ ํ๋ค. ๋ฉ๋๊ธฐ ๋ง์์๋ ์ฌ๋ฌ ๊ฐ์ ์๋์ฐฝ๊ณ ๊ฐ ์๋๋ฐ ์๋์ฐฝ๊ณ ๋ ์ผ์ง์ ์ผ๋ก ์ด์ด์ ธ ์๋ค. ๊ฐ ์๋์ฐฝ๊ณ ์๋ ์ ํด์ง ์์ ์๋์ ์ ์ฅํ๊ณ ์์ผ๋ฉฐ ๊ฐ๋ฏธ ์ ์ฌ๋ ์๋์ฐฝ๊ณ ๋ฅผ ์ ํ์ ์ผ๋ก ์ฝํํ์ฌ ์๋์ ๋นผ์์ ์์ ์ด๋ค. ์ด๋ ๋ฉ๋๊ธฐ ์ ์ฐฐ๋ณ๋ค์ ์ผ์ง์ ์์ ์กด์ฌํ๋ ์๋์ฐฝ๊ณ ์ค์์ ์๋ก ์ธ์ ํ ์๋์ฐฝ๊ณ ๊ฐ ๊ณต๊ฒฉ๋ฐ์ผ๋ฉด ๋ฐ๋ก ์์์ฑ ์ ์๋ค. ๋ฐ๋ผ์ ๊ฐ๋ฏธ ์ ์ฌ๊ฐ ์ ์ฐฐ๋ณ์๊ฒ ๋คํค์ง ์๊ณ ์๋์ฐฝ๊ณ ๋ฅผ ์ฝํํ๊ธฐ ์ํด์๋ ์ต์ํ ํ ์นธ ์ด์ ๋จ์ด์ง ์๋์ฐฝ๊ณ ๋ฅผ ์ฝํํด์ผ ํ๋ค. ์๋ฅผ ๋ค์ด ์๋์ฐฝ๊ณ 4๊ฐ๊ฐ ๋ค์๊ณผ ๊ฐ์ด ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํ์.
{1, 3, 1, 5}
์ด๋ ๊ฐ๋ฏธ ์ ์ฌ๋ ๋ ๋ฒ์งธ ์๋์ฐฝ๊ณ ์ ๋ค ๋ฒ์งธ ์๋์ฐฝ๊ณ ๋ฅผ ์ ํํ์ ๋ ์ต๋๊ฐ์ธ ์ด 8๊ฐ์ ์๋์ ๋นผ์์ ์ ์๋ค. ๊ฐ๋ฏธ ์ ์ฌ๋ ์๋์ฐฝ๊ณ ๊ฐ ์ด๋ ๊ฒ ์ผ์ง์ ์์ผ ๋ ์ต๋ํ ๋ง์ ์๋์ ์ป๊ธฐ๋ฅผ ์ํ๋ค.
๊ฐ๋ฏธ ์ ์ฌ๋ฅผ ์ํด ์๋์ฐฝ๊ณ N๊ฐ์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ก์ ๋ ์ป์ ์ ์๋ ์๋์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
- ์ ๋ ฅ์กฐ๊ฑด
: ์ฒซ์งธ ์ค์ ์๋์ฐฝ๊ณ ์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. (3 <= N <= 100)
: ๋์งธ ์ค์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ๊ฐ ์๋์ฐฝ๊ณ ์ ์ ์ฅ๋ ์๋์ ๊ฐ์ K๊ฐ ์ฃผ์ด์ง๋ค.(0 <= K <= 1,000)
- ์ถ๋ ฅ์กฐ๊ฑด
: ์ฒซ์งธ ์ค์ ๊ฐ๋ฏธ ์ ์ฌ๊ฐ ์ป์ ์ ์๋ ์๋์ ์ต๋๊ฐ์ ์ถ๋ ฅํ์์ค.
์ ๋ ฅ ์์ | ์ถ๋ ฅ ์์ |
4 1 3 1 5 |
8 |
๐ง ์์ด๋์ด
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์กฐ๊ฑด์ ๋ค์๊ณผ ๊ฐ๋ค.
1. ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์๋ค.
2. ์์ ๋ฌธ์ ์์ ๊ตฌํ ์ ๋ต์ ๊ทธ๊ฒ์ ํฌํจํ๋ ํฐ ๋ฌธ์ ์์๋ ๋์ผํ๋ค.
์ด ๋ฌธ์ ๋ ๋ ์กฐ๊ฑด ๋ชจ๋ ๋ง์กฑํ๋ฏ๋ก ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ bottom-up ๋ฐฉ๋ฒ์ ํตํด ๊ตฌํํด๋ณด๊ณ ์ ํ๋ค.
์ฐ์ํ ์๋์ฐฝ๊ณ ๋ ๊ณต๊ฒฉํ ์ ์์ผ๋ฏ๋ก
i๋ฒ์งธ ์๋์ฐฝ๊ณ ๋ฅผ ๊ณต๊ฒฉํ๊ฑฐ๋ / i๋ฒ์งธ ์๋์ฐฝ๊ณ ๋ ํฌ๊ธฐํ๊ณ ๋ฐ๋ก i-1๋ฒ์งธ ์๋์ฐฝ๊ณ ๋ฅผ ๊ณต๊ฒฉํ๊ฑฐ๋
์ด ๋ ๊ฒฝ์ฐ๋ฅผ ๋น๊ตํ๋ค.
1) f(1)์ผ ๊ฒฝ์ฐ
- 1๋ฒ์งธ ์๋์ฐฝ๊ณ ๊ณต๊ฒฉ
= 1
2) f(2)์ผ ๊ฒฝ์ฐ
- 1๋ฒ์งธ ์๋์ฐฝ๊ณ ๊ณต๊ฒฉ vs 2๋ฒ์งธ ์๋์ฐฝ๊ณ ๊ณต๊ฒฉ
= 3
3) f(3)์ผ ๊ฒฝ์ฐ
- 2๋ฒ์งธ ์๋์ฐฝ๊ณ ๊ณต๊ฒฉ vs 3๋ฒ์งธ ์๋์ฐฝ๊ณ + 1๋ฒ์งธ ์๋์ฐฝ๊ณ ๊ณต๊ฒฉ
= f(2) vs f(1) + 3๋ฒ์งธ ์ ์ฅ๋ ์๋(1)
= 3
4) f(4)์ผ ๊ฒฝ์ฐ
- 3๋ฒ์งธ ์๋์ฐฝ๊ณ ๊ณต๊ฒฉ vs 4๋ฒ์งธ ์๋์ฐฝ๊ณ + 2๋ฒ์งธ ์๋์ฐฝ๊ณ ๊ณต๊ฒฉ
= f(3) vs f(2) + 4๋ฒ์งธ ์ ์ฅ๋ ์๋(5)
= 8
๐ง ์ฝ๋ ์์ฑ
# ๊ฐ๋ฏธ์ ์ฌ ๋ฌธ์
# ์ฐฝ๊ณ ์ ๊ฐ์
n = int(input())
# ์ฐฝ๊ณ ๋น ์๋์ด ์ผ๋ง๋ ๋ค์๋์ง
li = list(map(int, input().split()))
# ์๋์ฐฝ๊ณ N์ ์ต๋๊ฐ์ด 100์ด๋ฏ๋ก * 100
re = [0] * 100
re[0] = li[0]
re[1] = max(re[0], li[1])
# i๋ฒ๊น์ง, ์ต๋๋ก ์ป์ ์ ์๋ ์๋์ ์
for i in range(2, n):
re[i] = max(re[i-1], re[i-2] + li[i])
print(max(re))
Soo-minJeon - Overview
Soo-minJeon has 12 repositories available. Follow their code on GitHub.
github.com
