728x90
[๋ฌธ์ ]
[์ค๋ช ]
โ ์ด ๋ฌธ์ ๊ฐ DP ์ธ ์ด์ : ํ์ฌ ๊ฐ์ ๊ตฌํ ๋ ์ด์ ๊ฒฐ๊ณผ๊ฐ์ ์ด์ฉํ ์ ์๋ ๋ชจ์์ด ๋์ค๊ธฐ ๋๋ฌธ
- ํฌ๋์ฃผ๊ฐ 1์ ์ผ ๋,
1์ ๋ชจ๋๋ฅผ ์ ํํด์ผ ์ต๋์ด๋ค.
- ํฌ๋์ฃผ๊ฐ 2์ ์ผ ๋,
2์ ๋ชจ๋๋ฅผ ์ ํํด์ผ ์ต๋์ด๋ค.
- ํฌ๋์ฃผ๊ฐ 3์ ์ผ ๋,
3๋ฒ์งธ ์์ ์ ํํ ๊ฒฝ์ฐ์ ์ ํํ์ง ์์ ๊ฒฝ์ฐ๋ก ๋๋ ์ ์๋ค.
์ด ๋, 3๋ฒ์งธ ์์ ์ ํํ์ง ์์ ๊ฒฝ์ฐ๋ ํฌ๋์ฃผ๊ฐ 2์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ๊ณผ ๊ฐ๋ค.
3๋ฒ์งธ ์์ ์ ํํ๋ค๋ฉด, 2๋ฒ์งธ ์์ ์ ํํ๊ณ 1๋ฒ์งธ ์์ ์ ํํ์ง ์๋ ๊ฒฝ์ฐ์ โก โ โ , 2๋ฒ์งธ ์์ ์ ํํ์ง ์๊ณ 1๋ฒ์งธ ์์ ์ ํํ๋ ๊ฒฝ์ฐ 2๊ฐ์ง๊ฐ ์๋ค. โ โก โ
- ํฌ๋์ฃผ๊ฐ 4์ ์ผ ๋,
4๋ฒ์จฐ ์์ ์ ํํ ๊ฒฝ์ฐ์ ์ ํํ์ง ์์ ๊ฒฝ์ฐ๋ก ๋๋ ์ ์๋ค.
4๋ฒ์งธ ์์ ์ ํํ์ง ์๋ ๊ฒฝ์ฐ๋ ํฌ๋์ฃผ๊ฐ 3์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ๊ณผ ๊ฐ๋ค.
4๋ฒ์งธ ์์ ์ ํํ๋ ๊ฒฝ์ฐ๋ 3๋ฒ์งธ ์์ ์ ํํ๊ณ 1๋ฒ์งธ ์์ ์ ํํ๋ ๊ฒฝ์ฐ์(=ํฌ๋์ฃผ๊ฐ 1์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ) โ โก โ โ , 3๋ฒ์งธ ์์ ์ ํํ์ง ์๊ณ ํฌ๋์ฃผ๊ฐ 2์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ์ ์ด์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. โ โ โก โ
- ํฌ๋์ฃผ๊ฐ 5์ ์ผ ๋,
5๋ฒ์จฐ ์์ ์ ํํ ๊ฒฝ์ฐ์ ์ ํํ์ง ์์ ๊ฒฝ์ฐ๋ก ๋๋ ์ ์๋ค.
5๋ฒ์งธ ์์ ์ ํํ์ง ์๋ ๊ฒฝ์ฐ๋ ํฌ๋์ฃผ๊ฐ 4์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ๊ณผ ๊ฐ๋ค.
5๋ฒ์งธ ์์ ์ ํํ๋ ๊ฒฝ์ฐ๋ 4๋ฒ์งธ ์์ ์ ํํ๊ณ 2๋ฒ์งธ ์์ ์ ํํ๋ ๊ฒฝ์ฐ์(=ํฌ๋์ฃผ๊ฐ 2์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ) โก โ โก โ โ , 4๋ฒ์งธ ์์ ์ ํํ์ง ์๊ณ ํฌ๋์ฃผ๊ฐ 3์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ์ ์ด์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. (โก โ โ โก โ ), (โ โ โก โก โ ), (โ โก โ โก โ )
์ฆ, ํ์ฌ ๊ฐ์ ๊ตฌํ ๋ ์ด์ ๊ฒฐ๊ณผ๊ฐ์ ์ด์ฉํ ์ ์๋ ๋ชจ์์ด ๋์จ๋ค.
๊ทธ๋ฆฌ๊ณ ์์ ๊ณผ์ ์ ์ ํ์์ผ๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
- ํฌ๋์ฃผ๊ฐ N์ ์ผ ๋,
N๋ฒ์จฐ ์์ ์ ํํ ๊ฒฝ์ฐ์ ์ ํํ์ง ์์ ๊ฒฝ์ฐ๋ก ๋๋ ์ ์๋ค.
N๋ฒ์งธ ์์ ์ ํํ์ง ์๋ ๊ฒฝ์ฐ๋ ํฌ๋์ฃผ๊ฐ N-1์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ๊ณผ ๊ฐ๋ค.
N๋ฒ์งธ ์์ ์ ํํ๋ ๊ฒฝ์ฐ๋ N-1๋ฒ์งธ ์์ ์ ํํ๊ณ N-3๋ฒ์งธ ์์ ์ ํํ๋ ๊ฒฝ์ฐ์(=ํฌ๋์ฃผ๊ฐ N-3์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ), N-1๋ฒ์งธ ์์ ์ ํํ์ง ์๊ณ ํฌ๋์ฃผ๊ฐ N-2์ ์ด์์ ๋ ๊ตฌํ ์ต๋๊ฐ์ ํ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค.
D[N] = max(D[N-1], A[N] + A[N-1] + D[N-3],A [N] + D[N-2])
[์ฝ๋]
#include <iostream>
#include <vector>
using namespace std;
void DrinkGrapeJuice(int*, int);
int Max(int, int, int);
int main() {
int num = 0;
int grape_juice[10001] = {0,};
cin >> num;
for (int i = 1; i <= num; i++) {
cin >> grape_juice[i];
}
DrinkGrapeJuice(grape_juice, num);
return 0;
}
void DrinkGrapeJuice(int *grape_juice, int num) {
int dp[10001] = {0,};
dp[1] = grape_juice[1];
if (num >= 2) dp[2] = dp[1] + grape_juice[2];
for (int i = 3; i <= num; i++) {
dp[i] = Max(dp[i - 1], dp[i - 2] + grape_juice[i], dp[i - 3] + grape_juice[i - 1] + grape_juice[i]);
}
cout << dp[num];
}
int Max(int a, int b, int c) {
return a > b ? (a > c ? a : c) : (b > c ? b : c);
}
728x90