๊ตฌ๋ฆ
์ด๋ผ๋ ๊ณณ์์ ๋ฌธ์ ํ์ด ์ฑ๋ฆฐ์ง(๊ตฌ๋ฆํค ์ฑ๋ฆฐ์ง)๋ฅผ ํ๋ค๊ณ ํด์ ์ฐธ์ฌ ์ค์ด๋ค. ์ด๋ฒคํธ ๊ธฐ๊ฐ ๋์ ๋ฌธ์ ๊ฐ ๊พธ์ค์ด ์ฌ๋ผ์ค๋ฉฐ, ์ฃผ์ 2ํ์ฉ (ํน์ ๊ทธ ์ด์) ์ฑ๋ฆฐ์ง ๋ฌธ์ ๋ค์ ๋ํด ํ์ด๊ฐ ๊ฐ๋ฅํ ๋ฌธ์ ๋ค์ ํ์ดํด๋ณด๊ณ , ํ๊ธฐ๋ฅผ ๋จ๊ฒจ๋ณด๋ ค๊ณ ํ๋ค.
๊ตฌ๋ฆํค ๋ธ๋ก๊น ์ด ์ข ๋ฐ๋ ค ์์๋๋ฐ, ๋ง์นจ ํต์ฆ 1 ๋ฌธ์ ์ ํต์ฆ 2 ๋ฌธ์ ๊ฐ ๊ฒฐ์ด ๊ฑฐ์ ๊ฐ์ ๋ฌธ์ ์ง๋ง ํ์ด๊ฐ ๋ฌ๋ผ์ ํ๋ฒ์ ํฌ์คํ ํ๊ฒ ๋์๋ค.
ํต์ฆ 1์ ๊ฒฝ์ฐ์๋, ๊ฐ ์์น๊ฐ ๋ฐฐ์ ๊ด๊ณ์ด๋ค. ์ด ๊ฒฝ์ฐ์๋ ์ ๋ช
ํ ๊ฑฐ์ค๋ฆ๋ ๋ฌธ์ ์ฒ๋ผ greedy
ํ๊ฒ ํ ์ ์๋ค. ์๋๋ฉด, ํฐ ๋์ ์ด ์ปค๋ฒํ ์ ์๋ ์์ ๋ ์ ์ ์์ ๋์ ์ผ๋ก๋ ํญ์ ์ปค๋ฒํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์, ๋จ์ํ๊ฒ ๊ทธ๋ฅ ๋๋จธ์ง๋ง ๊ตฌํ๋ฉด์ ๋ํด๋๊ฐ๋ฉด ์ ๋ต์ด ๋๋ค. ๊ตฌ๋ฆํค์ ๋ชจ๋ฒ๋ต์์ ๋ณด๋ฉด, ์ธ์ greedy
ํ๊ฒ ํ ์ ์๋์ง์ ๋ํด์ ์ ์์ ์ผ๋ก ์์ ํด ๋์๋๋ฐ, ํด๋น ํด์ค์ ์ฒจ๋ถํ๋ค.
greedy
๋ฌธ์ ์ ๊ฒฝ์ฐ ํ์๋ค๊ณ ์ข์ํ ๊ฒ ์๋๋ผ, ์ ํด๋น ์กฐ๊ฑด์ผ๋ก ํ์ด๊ฐ ๊ฐ๋ฅํ์ง์ ๋ํด์ ์ฆ๋ช
์ด ์ด๋ ดํ์ด ๊ฐ๋ฅํ ์ ๋๋ก ๋์ด์ผ ํด๋น ๋ฌธ์ ๋ฅผ ์ ๋๋ก ํ์๋ค ํ ๊ฒ์ด๋ค.
N=int(input())ans=0while N >= 14:ans+=N//14N=N%14while N >= 7:ans+=N//7N=N%7ans+=Nprint(ans)
์ด ๋ฌธ์ ์ ๊ฒฝ์ฐ ํต์ฆ 1๊ณผ ๋ค๋ฅด๊ฒ ๋๋๊ณ ๋ ๊ฐ์ง์ ์์ดํ ์ ํจ๊ณผ๊ฐ ๋ฐฐ์ ๊ด๊ณ๊ฐ ์๋๋ค. ์ด๋ด ๋๋ ๋ฅผ ๋จผ์ ์ฌ์ฉํ๊ณ ๋ฅผ ์ฌ์ฉํ๋ ์์ ์ ๊ทผ์ ์ต์ ์ ๋ณด์ฅํ์ง ๋ชปํ๋ค.
DP
๋ฌธ์ ์ค์ ์ ๋ช
ํ ๋ฐฐ๋ญ ์ฑ์ฐ๊ธฐ
๋ฌธ์ ๊ฐ ์๋๋ฐ, ํด๋น ๋ฌธ์ ํ์ด์์ ์ํ ์ ์ด๋ฅผ ๋ฐฐ๋ญ ๋ฌด๊ฒ
๊ธฐ์ค์ผ๋ก ํ๋ ๋ถ๋ถ์ด ์๋ค. ์ด ๋ฌธ์ ์์๋ ์ ์ฌํ ๋ฐฉ์์ ์ฌ์ฉํ ์ ์๋ค. ์ํ ์ ์ด๋ฅผ ์ฝ์ ์ฌ์ฉํ ํ์ ๊ธฐ์ค์ด ์๋๋ผ, ํ์ฌ ์ฌ์ฉํ ์์ดํ
์ ์ฉ๋ ๊ธฐ์ค์ผ๋ก ํ๋ฉด, ์๋์ ๊ฐ์ ๊น๋ํ DP
์์ ์ธ์ธ ์ ์๋ค.
๋ ๋งํผ์ ํต์ฆ์ ์ ํํ ์์จ ์ ์๋ ์์ดํ
์ ์ต์ ์ฌ์ฉ ๊ฐ์์ด๋ค. ๋ฌธ์ ์กฐ๊ฑด์์ ์ด๋ผ๊ณ ํ๋๋ฐ ์ด๊ฒ์ด ํต์ฆ ์์น ๊ธฐ์ค์ผ๋ก ๋ฅผ ์ฌ์ฉํ๋ผ๋ ์ผ์ข
์ ํํธ์ด๋ค. ๋๋ ์ด๊ฒ์ ์ผ์ข
์ DP Signal
๋ก ํ๋จํ๋ค. ์ด ๊ฐ์ด ๋ง์ฝ์ ํต์ฆ 1
๋ฌธ์ ์ฒ๋ผ ์ด์๋ค๋ฉด, ๋ฉ๋ชจ๋ฆฌ ์ ํ ์กฐ๊ฑด์ ๊ฑธ๋ ค์ ๋ค๋ฅธ ํ์ด๋ฅผ ์๊ฐํ์ด์ผ ํ ๊ฒ์ด๋ค.
์๋ฌดํผ ํด๋น ๋ฌธ์ ๋ ์ด๋ฌํ ์ด์๊ฐ ์๊ณ , ์ ์ ์๋ ์์ผ๋ก ๋ฎ์ ํจ๊ณผ ์์น์์ ๋์ ํจ๊ณผ ์์น ์์ผ๋ก ๋ฐฐ์ด์ ์ฑ์๋๊ฐ๋ฉด, == ์์์ ๊ฐ์ด ์ ๋ต์ด ๋๋ค. base condition
์ ์ด๋ค.
#include <bits/stdc++.h>using namespace std;int main() {int N; scanf("%d", &N);vector<int> DP(N+1);constexpr int INF = 987654321;fill(DP.begin(), DP.end(), INF);int a, b; scanf("%d %d", &a, &b);DP[0] = 0;for(int i = 1; i <= N; ++i) {if (i - a >= 0) DP[i] = min(DP[i], DP[i - a] + 1);if (i - b >= 0) DP[i] = min(DP[i], DP[i - b] + 1);}if (DP[N] == INF) printf("-1\n");else printf("%d\n", DP[N]);return 0;}