๋ฌธ์ ๋งํฌ
๊ตฌ๋ฆLEVEL
๋์ด๋๋ณ ๋ค์ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํจ์ผ๋ก์จ SW ์ญ๋์ ํฅ์์ํฌ ์ ์์ต๋๋ค.
level.goorm.io
๋ฌธ์ ์ค๋ช
8์ผ ์ฐจ์ ๋ฌธ์ ์ ์ ์ฌํ์ง๋ง, ์ด๋ฒ์ ์์ดํ ์ ๊ฐ์ ์์น๊ฐ ์ ํด์ ธ ์์ง ์๋ค.
์ ๋ ฅ
- N์ ๋ฒ์๋ 2๋ถํฐ 10์ 6 ์ ๊ณฑ๊น์ง์ด๋ค.
- ์์ดํ A, B์ ๋ฒ์๋ 2 <= A < B <= 13์ด๋ค.
์ถ๋ ฅ
ํต์ฆ์ 0์ผ๋ก ๋ง๋ค์ด์ฃผ๋ ์์ดํ ์ ์ต์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
๋ฌธ์ ์ดํด
์ฒ์์ ์ด์ ํต์ฆ ๋ฌธ์ ๊ณผ ๊ฐ์ด ๋จ์ ๋นผ๊ธฐ ์ฐ์ฐ์ ์ด์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์์๋ค. ๊ทธ๋ฐ๋ฐ ๋นผ๊ธฐ ์ฐ์ฐ๋ง์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ๋ฌธ์ ์ ์๋ ์์ ์ค 10000, 4, 13๊ณผ ๊ฐ์ด 0์ด ๋์ฌ ์ ์๋ ๊ฒฐ๊ณผ๊ฐ ์์์๋ ๋ถ๊ตฌํ๊ณ ๋จ์ ๊ณ์ฐ์ผ๋ก 0์ด ๋์ค์ง ์๋ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋ ๊ฒ์ ํ์ธํ์๋ค. ๋ฐ๋ผ์ ๋ฌธ์ ์ ํ์ด ๋ฐฉ์์ ๋ฐ๊ฟ์ผ ํ ํ์๊ฐ ์๋ค.
1. ์ฒ์์ ์ฃผ์ด์ง๋ ์ซ์๋ฅผ 2 x n + 7 x m๋ก ๋๋์ด ๋ณธ๋ค.
2. ํด๋น ๋ฐฉ์์ผ๋ก ๋ฐ๊ฟจ์ ๋, ์์ดํ ์ ์ต์๋ n + m์ด ๋ ๊ฒ์ด๋ค.
n๊ณผ m์ ๊ฐ๊ฐ 0๋ถํฐ ๋์ ํด์ ๋ต์ ๋์ถํด๋ณด๋ฉด ์ด๋ฐ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค.
์ด ๋ถ๋ถ์์ ์ ์ถํด ๋ณผ ์ ์๋ ๋ด์ฉ์ผ๋ก๋
- ์ซ์๊ฐ 2์ฉ ์ฌ๋ผ๊ฐ ๋๋ง๋ค N์ 1์ฉ ๋ํด์ง๋ค.
- ์ซ์๊ฐ 7์ฉ ์ฌ๋ผ๊ฐ ๋๋ง๋ค M์ 1์ฉ ๋ํด์ง๋ค.
- ๋ฐ๋๋ก ์ซ์๊ฐ 2๋งํผ ๋ด๋ ค๊ฐ๋ฉด N์ 1์ ๋นผ์ผ ํ๋ค. (M์ ๊ฒฝ์ฐ๋ ๋์ผ)
- ๊ทธ๋ ๋ค๋ฉด ์ํ๋ ์ซ์ i์ ๊ฐ์ i -2 ๋ i - 7์ ๊ฐ์ 1์ ๋ํ๋ฉด ๋์ฌ ๊ฒ์ด๋ค.
- ์ํ๋ ์ซ์๋ฅผ ๋ฝ๊ธฐ ์ํด ์์ ์ซ์๋ค์ ํฉ์ผ๋ก ๋๋๊ณ ( ์๋ฌธ์ ), ์ด์ ์ ์ต์ ์ ๋ต์ด ๋ค์์ ์ต์ ์ ๋ต์ ์ํฅ์ ์ค๋ค. => DP๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํ ์ ์๋ค.
ํด๋น ์กฐ๊ฑด๋ค๋ก ์์ ๋ง๋ค์ด๋ณด๋ฉด
pain(i) = pain(i - 2) + 1
or
pain(i) = pain(i - 7) + 1
์ด๋ผ๋ ์์ด ๋์ถ๋๊ณ ์ด๋ฅผ ์ ๋ฆฌํ๋ฉด
pain(i - A) + 1 (i – A์ ์ด์ ์ฐ์ฐ์ด 0 ์ด ์๋ ๋)
pain(i) = or
pain(i - B) + 1 (i – B์ ์ด์ ์ฐ์ฐ์ด 0 ์ด ์๋ ๋)
์ ํ์์ผ๋ก ์ ๋ฆฌํด ๋ณผ ์ ์๋ค.
๋ฌธ์ ํด๊ฒฐ
์ ํ์์ ์์ฑํ ๋ค๋ถํฐ๋ ๋ฌธ์ ๊ฐ ํฌ๊ฒ ์ด๋ ต์ง ์๋ค.
์ํ๋ ์ซ์ n์ด ๋์ฌ ๋๊น์ง A ์์ดํ ๊ณผ B ์์ดํ ์ ๋ํด ์ฐ์ฐํด ์ฃผ๋ฉด ๋๋ค.
๋ฌธ์ ํ๊ธฐ
๋์ ํ๋ก๊ทธ๋๋ฐ์ ๋ ์ฌ๋ฆฌ๊ธฐ๊น์ง๋ ์๊ฐ์ด ๋ง์ด ์์๋์ง ์์๋๋ฐ, ์ ํ์์ ์ง๋ ๊ณผ์ ์์ ๋ฌธ์ ์ ํด๋นํ๋ ์กฐ๊ฑด์ ์ค์ ํ๋ ๋ถ๋ถ์์ ๋ง์ด ์ค๋ ๊ฑธ๋ ธ๋ ๊ฒ ๊ฐ๋ค. ์ธ์๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ๋ณ์ ์ด๋ฆ ์ค์ ๊ฐ์ ์ฌ์ํ ์ด์๋ค๋ก ํ ์คํธ๋ฅผ ๊ณ์ ํต๊ณผํ์ง ๋ชปํ์ฌ ํผ๋ํ์๋ ๊ฒ ๊ฐ๋ค.
์ ์ฒด ์ฝ๋
#include <iostream>
#include <vector>
#define MAX 1000002
int item[MAX];
int A_item;
int B_item;
using namespace std;
void DP(int n){
item[0] = 0;
for(int i = A_item; i <= n; i++){
if(item[i - A_item] != -1){
item[i] = item[i-A_item] + 1;
//cout << i << ", " << item[i] << endl;
}
if(i >= B_item){
if(item[i - B_item] != -1){
item[i] = item[i-B_item] + 1;
//cout << i << ", " << item[i] << endl;
}
}
}
}
int main() {
int n;
int count = 0;
cin >> n;
cin >> A_item >> B_item;
fill_n(item, n + 1, -1);
DP(n);
cout << item[n] << endl;
}
'Algorithm > ๊ตฌ๋ฆ ์ฑ๋ฆฐ์ง' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๊ตฌ๋ฆํค ์ฑ๋ฆฐ์ง] 4์ฃผ์ฐจ ํ์ต ์ผ๊ธฐ #1 (16์ผ์ฐจ) (0) | 2023.09.05 |
---|---|
[๊ตฌ๋ฆํค ์ฑ๋ฆฐ์ง] 3์ฃผ์ฐจ ํ์ต ์ผ๊ธฐ #2 (14์ผ์ฐจ) (0) | 2023.09.01 |
[๊ตฌ๋ฆํค ์ฑ๋ฆฐ์ง] 2์ฃผ์ฐจ ํ์ต ์ผ๊ธฐ #2 (8์ผ์ฐจ) (0) | 2023.08.24 |
[๊ตฌ๋ฆํค ์ฑ๋ฆฐ์ง] 2์ฃผ์ฐจ ํ์ต ์ผ๊ธฐ #1 (6์ผ์ฐจ) (0) | 2023.08.22 |
[๊ตฌ๋ฆํค ์ฑ๋ฆฐ์ง] 1์ฃผ์ฐจ ํ์ต ์ผ๊ธฐ #2 (0) | 2023.08.17 |