๐ ๏ธ ๋ฌธ์ ๐ ๏ธ
๐๏ธ ์ค๋ช ๐๏ธ
๊ณ์ ํ์ด๋ณด์์ง๋ง ์คํจํด์ ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ์ฐธ๊ณ ํ ๋ด์ฉ์ ๋ฐํ์ผ๋ก ๋ด๊ฐ ์ดํดํ ๋ด์ฉ์ ์ ๋ฆฌํ๋ค.
์ฒ์์๋ ์ฌ๋ ์, ์นํจ ์์ ํผ๋ณด๋์น ์์ด์ ๋ถ๋ฆฌํด์ ์๊ฐํ์ฌ ์ด์ ๋ํ ์ฐ๊ด์ฑ์ ์๊ฐํ์ง ๋ชปํ๋ค.
๊ทธ๋ฌ๋ ์์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๋ ๋ณ์ a์ b๊ฐ ์๋ค๊ณ ์๊ฐํด๋ณด์.
์ฒ์ a์ b๊ฐ 1๋ญ 2์ธ์ ๋ํ๋ด๊ณ ์์ผ๋ฉด ๋ค์ a์ b์ ๊ฐ์ 2๋ญ 3์ธ์ด ๋์ด์ผํ๋ค.
์ฆ, a = b, b = a+b ๋ก ๊ฐ์ด ๋ณํ๋ค๋ ๊ฒ์ด๋ค.
์ฌ๊ธฐ์ ์ฐ๋ฆฌ๊ฐ ๊ตฌํด์ผํ ๊ฒ์ ์ต์ ์นํจ ์์ ์ต๋ ์นํจ ์์ด๋ค.
- min ๋ฐฐ์ด : min[i] ๋ i์ธ๋ถ ์์ผฐ์ ๋ ์ต์ ์นํจ ์
- max ๋ฐฐ์ด : max[i] ๋ i์ธ๋ถ ์์ผฐ์ ๋ ์ต๋ ์นํจ ์
๋จ, ์ด ๋ฐฐ์ด์ ํญ์ ๊ธธ์ด๊ฐ 3์ด์์ผ ๊ฒ์ด๋ค. ๋ํ [0, 1๋ฒ ์ธ๋ฑ์ค : 0๋ช , 1๋ช ]๋ ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅํ๋ค. → N >= 2
๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ๊ณ์ฐ์ ์ํด์ 0๋ช ์ผ ๊ฒฝ์ฐ ์นํจ์ ์ 0์ผ๋ก ์ค์ ํด๋๋ค.
์ฃผ์ํ ์ ์ min ๋ฐฐ์ด์ 1๋ช ์ ์ธ๋ฑ์ค๋ ํฐ ๊ฐ์ผ๋ก ์ ์ฅํด๋๋๋ฐ ์ด๋ ํ์๋ช ์ผ๋ ์๋ชป๋ ๊ณ์ฐ์ ํ์ง ๋ชปํ๋๋ก ํ๊ธฐ ์ํจ์ด๋ค.
์๋ฅผ ๋ค์ด 3๋ช ์ผ ๊ฒฝ์ฐ 3์ธ 2๋ญ๋ง ๊ฐ๋ฅํ๋ฐ 2์ธ1๋ญ + 1์ธ 0๋ญ ์ผ๋ก ์๋ชป๋ ๊ณ์ฐ์ด ์ด๋ฃจ์ด์ง ์ ์๋ค.
max์ ๊ฒฝ์ฐ๋ ์ด์ฐจํผ ๊ฐ๋ฅํ ํฐ ์๋ก ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์ ๋ฐ๋ก ์ฒ๋ฆฌํด์ค ํ์๊ฐ ์๋ค.
์ด์ ๊ฐ์ ์ฑ์ง์ ์ด์ฉํ์ฌ b = 2์ผ ๋ (→ 2์ธ 1๋ญ์ผ๋ก ์ํฌ ๊ฒฝ์ฐ) ๋ถํฐ ์ฐจ๋ก์ฐจ๋ก ๊ณ์ฐํด๋ณด๋ ๊ฒ์ด๋ค.
while(b <= n) {
for(int i = b; i <= n; i++) {
min[i] = Math.min(min[i], min[i-b] + a);
max[i] = Math.max(max[i], max[i-b] + a);
}
int tmp = b;
b += a;
a = tmp;
}
DP๋ฅผ ์ด์ฉํ์ฌ ํ์ฌ b์ธ a๋ญ์ผ๋ก ์ฐ๋ฆฌ๊ฐ ๊ตฌํด์ผํ n์ธ๋ถ์ ์นํจ ๋ง๋ฆฌ์๋ฅผ ๊ตฌํ๋ ๊ฒ์ด๋ค.
- b = ํ์ฌ ๋ช๋ช ๋ถ์ ์ธํธ์ธ์ง ๋ํ๋ด๋ ๋ณ์
- a = ๊ทธ ์ธํธ์ ๋ค์ด์๋ ๋ญ์ ์๋ฅผ ๋ํ๋ด๋ ๋ณ์
- i = ๋ช ์ธ๋ถ์ ์์ผ์ผํ ์ง ๋ํ๋ด๋ ๋ณ์, ์ด๋ ํญ์ b <= i <= n ์กฐ๊ฑด์ ๋ง์กฑํ๋ค.
- i-b = i์ธ๋ถ ์ค b์ธ๋ถ์ ์ ์ธํ ์ธ๋ถ = b์ธ a๋ญ์ ์ํค๋ฉด i์ธ๋ถ์ ๋ง์กฑ = m[i-b] + a
์ด๋ฒ์๋ ๊ฑฐ์ ํด์ํ๋ ์๊ฐ์ด ๋์๋ ๊ฒ ๊ฐ๋ค.
์ฝ๋๋ฅผ ์ฝ๊ณ ๋์ ์๋ฆฌ๋ ๋ฌด์์ด๊ณ ์ ์ด๋ ๊ฒ ํด์ผํ์ง? ๋ผ๋ ๊ณ ๋ฏผ์ ํ๊ฒ ๋ง๋ ๋ฌธ์ ์๋ค.
๋ค์์๋ ์ง์ ํ ์ ์๋๋ก ๋ ธ๋ ฅํด์ผ๊ฒ ๋ค.
๐ ํ์ด ๐
package Baekjoon;
import java.io.*;
public class DP13270 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int n = Integer.parseInt(br.readLine()); //์ฌ๋ ์ (n >= 2)
int a = 1; //1๋ญ -> ํผ๋ณด๋์น ์์ด์ ์ฒซ๋ฒ์งธ ํญ
int b = 2; //2์ธ - > ํผ๋ณด๋์น ์์ด์ ๋๋ฒ์งธ ํญ
int[] min = new int[n+1]; //min[i] : i๋ช
์ผ ๋ ์ต์์ ์นํจ ์
int[] max = new int[n+1]; //max[i] : i๋ช
์ผ ๋ ์ต๋์ ์นํจ ์
for(int i = 1; i <= n; i++) {
min[i] = 987654321;
}
while(b <= n) {
for(int i = b; i <= n; i++) {
min[i] = Math.min(min[i], min[i-b] + a);
max[i] = Math.max(max[i], max[i-b] + a);
}
int tmp = b;
b += a;
a = tmp;
}
bw.write(min[n] + " " + max[n]);
bw.flush();
bw.close();
}
}
'ProgramSolve > Baekjoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] 1806๋ฒ - ๋ถ๋ถํฉ (Java) (1) | 2023.12.12 |
---|---|
[BOJ] 11779๋ฒ - ์ต์๋น์ฉ ๊ตฌํ๊ธฐ2 (Java) (2) | 2023.12.08 |
[BOJ] 12851๋ฒ - ์จ๋ฐ๊ผญ์ง2 (Java) (0) | 2023.12.04 |
[BOJ] 2437๋ฒ - ์ ์ธ (Python) (0) | 2023.10.27 |
[BOJ] 15657๋ฒ - N๊ณผM(8) (Python) (1) | 2023.10.05 |