๐ง ๋ฌธ์
๐ก๋ฌธ์
์์ ๊ฐ์ ์ผ๊ฐํ์ ๊ผญ๋๊ธฐ์์ ๋ฐ๋ฅ๊น์ง ์ด์ด์ง๋ ๊ฒฝ๋ก ์ค, ๊ฑฐ์ณ๊ฐ ์ซ์์ ํฉ์ด ๊ฐ์ฅ ํฐ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์๋ณด๋ ค๊ณ ํฉ๋๋ค. ์๋ ์นธ์ผ๋ก ์ด๋ํ ๋๋ ๋๊ฐ์ ๋ฐฉํฅ์ผ๋ก ํ ์นธ ์ค๋ฅธ์ชฝ ๋๋ ์ผ์ชฝ์ผ๋ก๋ง ์ด๋ ๊ฐ๋ฅํฉ๋๋ค. ์๋ฅผ ๋ค์ด 3์์๋ ๊ทธ ์๋์นธ์ 8 ๋๋ 1๋ก๋ง ์ด๋์ด ๊ฐ๋ฅํฉ๋๋ค.
์ผ๊ฐํ์ ์ ๋ณด๊ฐ ๋ด๊ธด ๋ฐฐ์ด triangle์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๊ฑฐ์ณ๊ฐ ์ซ์์ ์ต๋๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
<์ ํ์ฌํญ>
์ผ๊ฐํ์ ๋์ด๋ 1 ์ด์ 500 ์ดํ์ ๋๋ค.
์ผ๊ฐํ์ ์ด๋ฃจ๊ณ ์๋ ์ซ์๋ 0 ์ด์ 9,999 ์ดํ์ ์ ์์ ๋๋ค.
<์ ์ถ๋ ฅ ์>
triangle : [[7], [3, 8], [8, 1, 0], [2, 7, 4, 4], [4, 5, 2, 6, 5]] 30
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
โ ์ ๊ทผ ๋ฐฉ์
1๏ธโฃ Top Down (์ํ์ฐฉ์ค)
๋ฌธ์ ์์ ์๊ตฌํ๋ฏ์ด ์์์๋ถํฐ ์๋๋ก ์ฐจ๋ก๋ก ์ซ์๋ฅผ ๋ํด๊ฐ๋ฉฐ ์ต๋์ ์ซ์๋ฅผ ์ฐพ๊ณ ์ ํ์๋ค.
ํ์ง๋ง ์์์ ์๋๋ก ๋ด๋ ค๊ฐ๋ฉฐ ์ต๋๊ฐ์ ์ฐพ๋ ๋ฐฉ์์ ๋ฐ๋ก ๋๊ด์ ๋ถ๋ชํ๋ค.
์ฒซ๋ฒ์งธ์ index๋ 7์ด ๊ณ ์ ์ด๊ณ ,
๊ทธ ๋ค์์ ๊ฐ์ ์ ํ์ง๋ 3 ๋๋ 8์ด๋ค.
ํ์ง๋ง ์ฐ๋ฆฌ๋ ์ต๋๊ฐ์ ๊ตฌํ๋ ๊ฒ์ด ๋ชฉํ์ด๊ธฐ ๋๋ฌธ์ ์์ฐ์ค๋ฝ๊ฒ ํฐ ๊ฐ์ธ 8์ ์ ํํ๊ฒ ๋๋ค.
ํ์ง๋ง 3๋ฒ์งธ์ index์ ๋ค๋ค๋ฅด๊ฒ ๋๋ฉด ์ด์ผ๊ธฐ๊ฐ ๋ฌ๋ผ์ง๋ค.
3๋ฒ์งธ์ index์์๋ ์ต๋๊ฐ์ธ 1์ ์ ํํ๊ฒ ๋๋ค ๊ทธ๋ฌ๋ฉด ํ์ฌ์ ์ดํฉ ๊ฐ์ 16์ด๋ค.
ํ์ง๋ง ์ค์ ๋ก 3๋ฒ์งธ ์ธ๋ฑ์ค๊น์ง์ ์ต๋๊ฐ์ 7 + 3 + 8์ธ 18์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด๋ป๊ฒ ๋ก์ง์ ์งค ์ ์์๊น?
int index = 0;
for (int i = 3; i <= height; i ++){
int a = Math.max(dp[i-2] + triangle[i-2][index] + triangle[i-1][index],
dp[i-2] + triangle[i-2][index] + triangle[i-1][index+1]);
int b = Math.max(dp[i-2] + triangle[i-2][index+1] + triangle[i-1][index+1],
dp[i-2] + triangle[i-2][index+1] + triangle[i-1][index+2]);
if (a < b){
dp[i] = b;
index ++;
}else{
dp[i] = a;
}
dp[i-1] = dp[i-2] + triangle[i-2][index];
}
์ฒซ๋ฒ์งธ๋ก ์๊ฐํ๋ ๋ฐฉ์์ ์์ ์ฝ๋์ ๊ฐ์๋ค.
3๊ฐ์ ์ธต์ ๋ชจ๋ ๊ณ ๋ คํ์ฌ ๊ฐ์ฅ ์ต๋ ๊ฐ์ด ๋์จ ๊ฒฝ๋ก๋ฅผ ์ฐพ์์ ๋์ ์ํค๋ ๋ฐฉ์์ด๋ค.
ํ์ง๋ง ์ด๋ฌํ ๋ฐฉ์๋ ๋ฌธ์ ๊ฐ ์์๋ค
์์ ๊ฐ์ด 3๊ฐ์ ์ธต๋๋ก ์ต๋๊ฐ์ ๊ตฌํ๋ฌ ๊ฐ๋ ๊ฒฝ๋ก์ ๋ค๋ฅธ ๊ณณ์ ๊ฐ์๊ธฐ ํฐ ๊ฐ์ด ๋ํ๋ ๋์ด๋ค.
์ด๋ฌํ ๊ฒฝ์ฐ๋ ๊ณ ๋ คํ์ง ๋ชปํ๋ค.
๊ทธ๋ ๋ค๋ฉด ์์ ํ์์ผ๋ก ๋ชจ๋ ๊ฒฝ๋ก๋ฅผ ํ์ํ์ฌ ์ต๋๊ฐ์ธ ๊ฒฝ๋ก๋ฅผ ์ฐพ์์ผํ๋๋ฐ,
์ด๋ ์ผ๊ฐํ์ ๋์ด๊ฐ 500์ธ ๊ฒฝ์ฐ์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ ํ๋ฅ ์ด ๋งค์ฐ ํฌ๋ค...
๋ฐ๋ผ์ ๋ฐฉ๋ฒ์ ๋ค๋ฅด๊ฒ ์๊ฐํด์ผํ๋ค.
2๏ธโฃ Bottom Up (์ ๋ต)
์์์ ์๋๋ก ์งํํ๋ ๊ฒ๊ณผ๋ ๋ฐ๋๋ก ์๋์์ ์๋ก bottom up์ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ๋ ๊ฒ์ด๋ค.
bottom up์ ์๊ฐํ๋ฉด ๋ฐ๋ก dp๊ฐ ๋ ์ค๋ฅธ๋ค.
์๋์์๋ถํฐ ํ ์ธต ํ ์ธต ์ฌ๋ผ๊ฐ๋ฉด์ 2์ ์ธ์ ํ index์ค ๋ ํฐ ๊ฐ์ ๋ํ์ฌ dp ๋ฐฐ์ด์ ์ ๋ฐ์ดํธ ํด๋๊ฐ๋ ๋ฐฉ๋ฒ์ด๋ค.
dp[i][j] = triangle[i][j] + Math.max(dp[i+1][j], dp[i+1][j+1]);
์์ ๊ฐ์ด dp ๋ฐฐ์ด๋ triangle์ ๋ฐฐ์ด์ฒ๋ผ 2์ฐจ์ ๋ฐฐ์ด๋ก ์ค์ ํ๊ณ ๊ฐ๊ฐ์ ๋ฐฐ์ด๊ฐ์๋ ์๋์ ๋ ๊ฐ ์ค ์ต๋๊ฐ + ํ์ฌ index์ ๊ฐ์ ๋ํ๋ฉด ๊ณ์ํด์ ์ต๋๊ฐ์ผ๋ก ์ ๋ฐ์ดํธํ ์ ์๊ณ ์ฐ๋ฆฌ๋ ์ต์ข ์ ์ผ๋ก dp[0][0]์ ๋ฐํํ๋ฉด ๋๋ค.
โ ์ฝ๋
import java.util.*;
class Solution {
public int solution(int[][] triangle) {
int height = triangle.length;
int[][] dp = new int[height][height];
// DP ๋ฐฐ์ด ์ด๊ธฐํ (๋งจ ์๋ ์ค ๊ทธ๋๋ก ๋ณต์ฌ)
for (int i = 0; i < height; i++) {
dp[height-1][i] = triangle[height-1][i];
}
// Bottom-Up ๋ฐฉ์์ผ๋ก ์๋ก ์ฌ๋ผ๊ฐ๋ฉด์ ์ต๋๊ฐ ๊ณ์ฐ
for (int i = height - 2; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
dp[i][j] = triangle[i][j] + Math.max(dp[i+1][j], dp[i+1][j+1]);
}
}
return dp[0][0];
}
}