[๋ฐฑ์ค] 11052๋ฒ - ์นด๋ ๊ตฌ๋งคํ๊ธฐ (C++)
11052๋ฒ: ์นด๋ ๊ตฌ๋งคํ๊ธฐ
์ฒซ์งธ ์ค์ ๋ฏผ๊ท๊ฐ ๊ตฌ๋งคํ๋ ค๊ณ ํ๋ ์นด๋์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 1,000) ๋์งธ ์ค์๋ Pi๊ฐ P1๋ถํฐ PN๊น์ง ์์๋๋ก ์ฃผ์ด์ง๋ค. (1 ≤ Pi ≤ 10,000)
www.acmicpc.net
๋ฌธ์
์์ฆ ๋ฏผ๊ท๋ค ๋๋ค์์๋ ์คํํธ๋งํฌ์์ ๋ง๋ PS์นด๋๋ฅผ ๋ชจ์ผ๋ ๊ฒ์ด ์ ํ์ด๋ค.
PS์นด๋๋ PS(Problem Solving)๋ถ์ผ์์ ์ ๋ช ํ ์ฌ๋๋ค์ ์์ด๋์ ์ผ๊ตด์ด ์ ํ์๋ ์นด๋์ด๋ค. ๊ฐ๊ฐ์ ์นด๋์๋ ๋ฑ๊ธ์ ๋ํ๋ด๋ ์์ด ์น ํด์ ธ ์๊ณ , ๋ค์๊ณผ ๊ฐ์ด 8๊ฐ์ง๊ฐ ์๋ค.
- ์ ์ค์นด๋
- ๋ ๋์นด๋
- ์ค๋ ์ง์นด๋
- ํผํ์นด๋
- ๋ธ๋ฃจ์นด๋
- ์ฒญ๋ก์นด๋
- ๊ทธ๋ฆฐ์นด๋
- ๊ทธ๋ ์ด์นด๋
์นด๋๋ ์นด๋ํฉ์ ํํ๋ก๋ง ๊ตฌ๋งคํ ์ ์๊ณ , ์นด๋ํฉ์ ์ข ๋ฅ๋ ์นด๋ 1๊ฐ๊ฐ ํฌํจ๋ ์นด๋ํฉ, ์นด๋ 2๊ฐ๊ฐ ํฌํจ๋ ์นด๋ํฉ, ... ์นด๋ N๊ฐ๊ฐ ํฌํจ๋ ์นด๋ํฉ๊ณผ ๊ฐ์ด ์ด N๊ฐ์ง๊ฐ ์กด์ฌํ๋ค.
๋ฏผ๊ท๋ ์นด๋์ ๊ฐ์๊ฐ ์ ์ ํฉ์ด๋๋ผ๋ ๊ฐ๊ฒฉ์ด ๋น์ธ๋ฉด ๋์ ๋ฑ๊ธ์ ์นด๋๊ฐ ๋ง์ด ๋ค์ด์์ ๊ฒ์ด๋ผ๋ ๋ฏธ์ ์ ๋ฏฟ๊ณ ์๋ค. ๋ฐ๋ผ์, ๋ฏผ๊ท๋ ๋์ ์ต๋ํ ๋ง์ด ์ง๋ถํด์ ์นด๋ N๊ฐ ๊ตฌ๋งคํ๋ ค๊ณ ํ๋ค. ์นด๋๊ฐ i๊ฐ ํฌํจ๋ ์นด๋ํฉ์ ๊ฐ๊ฒฉ์ Pi์์ด๋ค.
์๋ฅผ ๋ค์ด, ์นด๋ํฉ์ด ์ด 4๊ฐ์ง ์ข ๋ฅ๊ฐ ์๊ณ , P1 = 1, P2 = 5, P3 = 6, P4 = 7์ธ ๊ฒฝ์ฐ์ ๋ฏผ๊ท๊ฐ ์นด๋ 4๊ฐ๋ฅผ ๊ฐ๊ธฐ ์ํด ์ง๋ถํด์ผ ํ๋ ๊ธ์ก์ ์ต๋๊ฐ์ 10์์ด๋ค. 2๊ฐ ๋ค์ด์๋ ์นด๋ํฉ์ 2๋ฒ ์ฌ๋ฉด ๋๋ค.
P1 = 5, P2 = 2, P3 = 8, P4 = 10์ธ ๊ฒฝ์ฐ์๋ ์นด๋๊ฐ 1๊ฐ ๋ค์ด์๋ ์นด๋ํฉ์ 4๋ฒ ์ฌ๋ฉด 20์์ด๊ณ , ์ด ๊ฒฝ์ฐ๊ฐ ๋ฏผ๊ท๊ฐ ์ง๋ถํด์ผ ํ๋ ๊ธ์ก์ ์ต๋๊ฐ์ด๋ค.
๋ง์ง๋ง์ผ๋ก, P1 = 3, P2 = 5, P3 = 15, P4 = 16์ธ ๊ฒฝ์ฐ์๋ 3๊ฐ ๋ค์ด์๋ ์นด๋ํฉ๊ณผ 1๊ฐ ๋ค์ด์๋ ์นด๋ํฉ์ ๊ตฌ๋งคํด 18์์ ์ง๋ถํ๋ ๊ฒ์ด ์ต๋๊ฐ์ด๋ค.
์นด๋ ํฉ์ ๊ฐ๊ฒฉ์ด ์ฃผ์ด์ก์ ๋, N๊ฐ์ ์นด๋๋ฅผ ๊ตฌ๋งคํ๊ธฐ ์ํด ๋ฏผ๊ท๊ฐ ์ง๋ถํด์ผ ํ๋ ๊ธ์ก์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. N๊ฐ๋ณด๋ค ๋ง์ ๊ฐ์์ ์นด๋๋ฅผ ์ฐ ๋ค์, ๋๋จธ์ง ์นด๋๋ฅผ ๋ฒ๋ ค์ N๊ฐ๋ฅผ ๋ง๋๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ค. ์ฆ, ๊ตฌ๋งคํ ์นด๋ํฉ์ ํฌํจ๋์ด ์๋ ์นด๋ ๊ฐ์์ ํฉ์ N๊ณผ ๊ฐ์์ผ ํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฏผ๊ท๊ฐ ๊ตฌ๋งคํ๋ ค๊ณ ํ๋ ์นด๋์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 1,000)
๋์งธ ์ค์๋ Pi๊ฐ P1๋ถํฐ PN๊น์ง ์์๋๋ก ์ฃผ์ด์ง๋ค. (1 ≤ Pi ≤ 10,000)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฏผ๊ท๊ฐ ์นด๋ N๊ฐ๋ฅผ ๊ฐ๊ธฐ ์ํด ์ง๋ถํด์ผ ํ๋ ๊ธ์ก์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
ํ์ด๊ณผ์
๋ฌธ์ ์์ ๋ฏผ๊ท๊ฐ ๊ฐ์ฅ ๋ง์ ๋น์ฉ์ผ๋ก ์นด๋๋ฅผ ์ฌ๊ณ ์ถ์ ์ํฉ์ด๋ค.
dp[n] = std:max(dp[i - j] + p[j] , dp[i]); ํ์์ ๋ก์ง์ ๊ตฌ์ฑํ์ฌ
dp[n]์ ์ต๋๊ฐ์ผ๋ก ๊ตฌํ๊ธฐ์ํด ์ง๋์จ ๊ฐ๋ค์ ํ์ธํ์ฌ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋์ ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ตฌํ๋ ๊ณผ์ ์ ๊ฑฐ์น๋ฉด์ ๋ก์ง์ด ๊ตฌ์ฑ์ด ๋๋ค.
dp[i - j] + p[j] ์ด ๋ถ๋ถ์ด ํต์ฌ๋ก์ง์ผ๋ก (n-1, 1 ), (n-2, 2) (n-3, 3) ํ์์ผ๋ก ๊ณ์ ๋์ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ์ ํ์ธํ๋ ๊ณผ์ ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค.
code
#include <iostream>
#include <algorithm>
int dp[1001];
int p[1001];
int main(void)
{
int n;
std::cin >> n;
for (int i = 1; i <= n; i++)
{
std::cin >> p[i];
}
dp[1] = p[1];
for (int i = 2; i <= n; i++)
{
for (int j = 1; j <= i; j++) {
dp[i] = std::max(dp[i - j] + p[j], dp[i]);
}
}
std::cout << dp[n];
return (0);
}
ํ๊ธฐ
์์ํ dp์ ์ค๋ฉฐ๋ค์ด๊ฐ๋ค. ์ผ์ด์ด ์ ์์ด ๋์ด๊ฐ๊ณ ์์ด์