

์์ ๊ฐ์ ์ผ๊ฐํ์ ๊ผญ๋๊ธฐ์์ ๋ฐ๋ฅ๊น์ง ์ด์ด์ง๋ ๊ฒฝ๋ก ์ค, ๊ฑฐ์ณ๊ฐ ์ซ์์ ํฉ์ด ๊ฐ์ฅ ํฐ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์๋ณด๋ ค๊ณ ํฉ๋๋ค. ์๋ ์นธ์ผ๋ก ์ด๋ํ ๋๋ ๋๊ฐ์ ๋ฐฉํฅ์ผ๋ก ํ ์นธ ์ค๋ฅธ์ชฝ ๋๋ ์ผ์ชฝ์ผ๋ก๋ง ์ด๋ ๊ฐ๋ฅํฉ๋๋ค. ์๋ฅผ ๋ค์ด 3์์๋ ๊ทธ ์๋์นธ์ 8 ๋๋ 1๋ก๋ง ์ด๋์ด ๊ฐ๋ฅํฉ๋๋ค.
์ผ๊ฐํ์ ์ ๋ณด๊ฐ ๋ด๊ธด ๋ฐฐ์ด triangle์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๊ฑฐ์ณ๊ฐ ์ซ์์ ์ต๋๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
| triangle | result |
|---|---|
| [[7], [3, 8], [8, 1, 0], [2, 7, 4, 4], [4, 5, 2, 6, 5]] | 30 |
์ฃผ์ด์ง ์ผ๊ฐํ์ ๊ผญ๋๊ธฐ๋ถํฐ ์๋๋ก ๋ด๋ ค๊ฐ๋ฉด์ ์ผ์ชฝ ์๋ ๋๋ ์ค๋ฅธ์ชฝ ์๋๋ก๋ง ์ด๋ํฉ๋๋ค. ๋งจ ์๋์ชฝ๊น์ง ๋ด๋ ค๊ฐ์ ๋ ์ป์ ์ ์๋ ์ต๋๊ฐ์ ๊ตฌํ๋ ๊ฒ์ ๋๋ค.
์ด ๋ฌธ์ ์ ๊ฒฝ์ฐ์๋ Bottom-up ๋ฐฉ์์ผ๋ก ๊ณ์ฐํ๋ ๊ฒ์ด ํจ์จ์ ์ ๋๋ค. ์ด ๊ฒฝ์ฐ์๋ ํ ๋ฒ์ฉ๋ง ๊ณ์ฐํ๋ฉด์ ๊ฐ์ ๊ฐฑ์ ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
Top-down ๋ฐฉ์์ผ๋ก ํ๋ ค๋ฉด ๊ฐ ๊ฒฝ๋ก๋ง๋ค ์ฌ๊ท ํจ์๊ฐ ํธ์ถ๋๋ฉด์ ์ฌ๋ฌ ๋ฒ ์ค๋ณตํด์ ๊ณ์ฐํ๊ฒ ๋๊ณ , ๋ฉ๋ชจ์ด์ ์ด์ ์ ์ฌ์ฉํ๋ ค๋ฉด ๊ตฌํ์ด ๋ ๋ณต์กํด์ง๋๋ค.
DP๋ฅผ ์ฌ์ฉํด Bottom-up์ผ๋ก ํ๊ฒ ์ต๋๋ค. dp ๋ฐฐ์ด์ ์ฃผ์ด์ง ์ผ๊ฐํ์ ๋ณต์ฌํด์ ์ฌ์ฉํ๊ฒ ์ต๋๋ค. ๊ฐ์ ๊ฐฑ์ ํ๋ ์์ผ๋ก ๊ตฌํ๋ฉด ์ถ๊ฐ ๋ฐฐ์ด ์์ด ํด๊ฒฐํ ์ ์์ต๋๋ค.
const dp = triangle.map(row => [...row]);
์ด ๋ dp[i]๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
dp[i][j] = triangle[i][j] + Math.max(dp[i + 1][j], dp[i + 1][j + 1]);
๋งจ ์๋ซ์ค์ ๊ทธ๋๋ก ์ฌ์ฉํ๊ณ ์๋์์ ๋ ๋ฒ์งธ ์ค๋ถํฐ ์๋ก ์ฌ๋ผ์ค๋ฉฐ ๊ฐ์ ๊ฐฑ์ ํด ๋๊ฐ๋๋ค.

for(let i = dp.length - 2; i >= 0; i--){
for(let j = 0; j < dp[i].length; j++){
dp[i][j] += Math.max(dp[i + 1][j], dp[i + 1][j + 1]);
}
}
์ด๋ ๊ฒ ํ๋ฉด ๊ผญ๋๊ธฐ์ ์ต๋๊ฐ์ด ์ ์ฅ๋ฉ๋๋ค.
return dp[0][0]
ํ์ง๋ง, ์ ์ถํ๋ฉด ํจ์จ์ฑ ํ ์คํธ 1๋ฒ์์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฉ๋๋ค.

ํด๋น ์ฝ๋์์ ๋ถํ์ํ๋ฉด์๋ ์๊ฐ์ ๋ค์ด๋ ๋ถ๋ถ์ด ๋ญ๊น ํ๋ค๊ฐ, triangle๋ฐฐ์ด์ด ํฌ๋ค๋ฉด dp๋ฐฐ์ด์ ๋ง๋ค๋ฉด์ map์ผ๋ก ๋ณต์ฌํ๋ ๊ณผ์ ์์ ์๊ฐ์ด ๋ง์ด ๊ฑธ๋ฆด ์๋ ์๋ค๊ณ ์๊ฐํ์ต๋๋ค.
๋ฐ๋ผ์ triangle๋ฐฐ์ด ์์ฒด๋ฅผ ์์ ํ๋ ๋ฐฉ์์ผ๋ก ์์ ํด๋ณด์๊ณ , ํต๊ณผํ์์ต๋๋ค. ์๋ฌด๋๋ ์๋ฐ์คํฌ๋ฆฝํธ์ ์ธ์ด ํน์ฑ์ map ์ฐ์ฐ์ ๋ด๋ถ์ ์ผ๋ก ๋น์ฉ์ด ํฌ๊ฒ ๋ค๊ณ ์๋์ ์ผ๋ก ๋ค๋ฅธ ์ธ์ด๋ณด๋ค ๋๋ ค์ ๊ทธ๋ฐ ๊ฒ ๊ฐ์ต๋๋ค.
function solution(triangle) {
for (let i = triangle.length - 2; i >= 0; i--) {
for (let j = 0; j < triangle[i].length; j++) {
triangle[i][j] += Math.max(triangle[i + 1][j], triangle[i + 1][j + 1]);
}
}
return triangle[0][0];
}