๋ฌธ์
์ ์ถ๋ ฅ ์์
์ ๊ทผ ๋ฐฉ๋ฒ
์กฐ๊ฑด
๋ฌธ์ ์ ์กฐ๊ฑด์ ๋ด๋ณด์.
- 1๋ฒ ์ง์ ์์ 2๋ฒ ์ง์ ์๊ณผ ๊ฐ์ง ์์์ผ ํ๋ค.
- N๋ฒ ์ง์ ์์ N-1๋ฒ ์ง์ ์๊ณผ ๊ฐ์ง ์์์ผ ํ๋ค.
- i(2 ≤ i ≤ N-1)๋ฒ ์ง์ ์์ i-1๋ฒ, i+1๋ฒ ์ง์ ์๊ณผ ๊ฐ์ง ์์์ผ ํ๋ค.
๊ฒฐ๊ตญ ์ด ๋ง์ ์ง์ ์์ด ์ค๋ณต์ด ๋๋ฉด ์๋๋ค๋ ๋ป์ด๋ค. ๊ทธ๋ผ ์ง์ ์์ด ์ค๋ณต์ด ๋์ง ์๊ฒ ๋๊ธฐ ์ํด์๋ ์ด๋ป๊ฒ ๋์ํ ํ ๊น?๊ฐ ์ด ๋ฌธ์ ์ ํต์ฌ์ค ํ๋์ด๋ค.
์ต์ข ๋ชฉ์
์ฐ๋ฆฌ๋ ์ด์ ์กฐ๊ฑด์ ๋ํด์ ์์์ผ๋๊น ์ ๋ต์ผ๋ก ๊ฐ๊ธฐ์ํ ๋น์ฉ์ ๋ํด์ ์์๋ณด์.
๊ฐ ์ง์๋ ํ์ธํธ์ ๊ฐ๊ฒฉ์ด ์๊ณ , ํด๋น ๊ฐ๊ฒฉ์ ์ต์๊ฐ ๋๋ ์๋ง ์น ํด์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋๊ฒ์ด ์ด ๋ฌธ์ ์ ์ต์ข
๋ชฉ์ ์ด๋ค.
์ด์ DP์ ํน์ฑ์ธ ํ์ฌ์ ๊ฒฐ๊ณผ๊ฐ ๋ค์ ๊ฒฐ๊ณผ์ ์ํฅ์ ๋ฏธ์น๋ ๊ตฌ์กฐ์ ๋ํด์ ์์๋ณด์.
DP ๋ถ๋ถ ํด ์ฐพ๊ธฐ
์ง์ด ํ๋ ์ผ ๋ :: N = 1
๋ง์ฝ ์ง์ด ํ๋๋ผ๊ณ ํ์ ๋๋ฅผ ์๊ฐํด๋ณด์.
26 (์ต์) | 40 | 83 |
๊ทธ๋ผ ๋น์ฐํ ๊ฐ์ฅ ์ต์์ธ ๊ฐ์ ์ ํํ๋ฉด ๋์ด๋ค.
์ง์ด ๋ ์ผ ๋ :: N = 2
26 | 40 | 83 |
49 | 60 (ํ๋ณด) | 57 (ํ๋ณด) |
์ด์ ์ง์ด ๋์ด๋ฉด ์กฐ๊ธ ์๊ฐ์ ํด๋ด์ผ ํ๋ค.
์ง์ด ๋์ด๋ผ๋ฉด ๊ทธ ์ ๊ฒฐ๊ณผ(์ง์ด ํ๋์ผ ๋)์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์ง๋ค(2๋ฒ, 3๋ฒ)์ค ์ต์ ๊ฐ์ ์ฐพ์ผ๋ฉด ๋์ง ์์๊น?
๊ทธ๋ผ Math.min(color[1], color[2])
์ด๋ ๊ฒ ๋ํ๋ ๊ฒ์ด๋ค.
์ญ์ ์ง์ด ์ฆ๊ฐํด์ i๋ฒ์งธ ๊น์ง ๊ฐ๋ค๊ณ ํด๋ ๋ง์ฐฌ๊ฐ์ง์ผ ๊ฒ์ด๋ค.
์ด์ ๋ถ๋ถ ํด๋ฅผ ์ฐพ์์ผ๋ฏ๋ก ์ฝ๋๋ก ํํํด๋ณด์.
์ฝ๋๋ก ํํํ๊ธฐ
์์ ํ๋ฅผ ์ฝ๋๋ก ๋ณํํ๋ ค๋ฉด ์ด์ฐจ์ ๋ฐฐ์ด์ด ํ์ํ๋ค.
๊ทธ๋ฆฌ๊ณ ์
๋ ฅ๋ ๊ฐ ๋ฐฐ์ด๊ณผ i๋ฒ์งธ์ ๋ถ๋ถ ํด์ ๋ฐฐ์ด์ ๋ฐ๋ก ๋๋๊ธฐ ์ํด์ ๋ ๊ฐ์ ๋ฐฐ์ด์ ์์ฑํ๋ค.
package algorithm.class11_dynamic_programming;
import java.io.*;
public class Prob03_RGB {
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());
int[][] arr = new int[n+1][3]; // ์
๋ ฅ ๋ฐฐ์ด
int[][] dp = new int[n+1][3]; // ๊ณ์ฐ ๊ฒฐ๊ณผ ๋ฐฐ์ด
for (int i = 1; i < n + 1; i++) {
String input = br.readLine();
String[] str = input.split(" ");
for (int j = 0; j < 3; j++) {
arr[i][j] = Integer.parseInt(str[j]);
}
}
dp[0][0] = dp[0][1] = dp[0][2] = arr[0][0] = arr[0][1] = arr[0][2] = 0;
for (int i = 1; i < n + 1; i++) {
dp[i][0] = Math.min(dp[i-1][1], dp[i-1][2]) + arr[i][0]; // red ์ผ ๋ : green๊ณผ blue์ค ์ต์ ๋น์ฉ์ ํ์ฌ red ๋น์ฉ์ ๋ํ๋ค.
dp[i][1] = Math.min(dp[i-1][0], dp[i-1][2]) + arr[i][1]; // green ์ผ ๋ : red์ blue์ค ์ต์ ๋น์ฉ
dp[i][2] = Math.min(dp[i-1][0], dp[i-1][1]) + arr[i][2]; // blue ์ผ ๋ : red์ green์ ์ต์ ๋น์ฉ
}
bw.write(Math.min(Math.min(dp[n][0], dp[n][1]), dp[n][2])+""); // ๋ถ๋ถ ํด์ ๊ฒฐ๊ณผ RGB์ค ์ต์ ๊ฐ์ ์ถ๋ ฅํ๋ค.
bw.flush();
bw.close();
}
}
๋๊ธ