๋ฌธ์ ์ค๋ช
https://school.programmers.co.kr/learn/courses/30/lessons/12913?language=java
๋ ๋ฐ๋จน๊ธฐ ๊ฒ์์ ํ๋ ค๊ณ ํฉ๋๋ค. ๋ ๋ฐ๋จน๊ธฐ ๊ฒ์์ ๋ (land)์ ์ด Nํ 4์ด๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , ๋ชจ๋ ์นธ์๋ ์ ์๊ฐ ์ฐ์ฌ ์์ต๋๋ค. 1ํ๋ถํฐ ๋ ์ ๋ฐ์ผ๋ฉฐ ํ ํ์ฉ ๋ด๋ ค์ฌ ๋, ๊ฐ ํ์ 4์นธ ์ค ํ ์นธ๋ง ๋ฐ์ผ๋ฉด์ ๋ด๋ ค์์ผ ํฉ๋๋ค. ๋จ, ๋ ๋ฐ๋จน๊ธฐ ๊ฒ์์๋ ํ ํ์ฉ ๋ด๋ ค์ฌ ๋, ๊ฐ์ ์ด์ ์ฐ์ํด์ ๋ฐ์ ์ ์๋ ํน์ ๊ท์น์ด ์์ต๋๋ค.
์๋ฅผ ๋ค๋ฉด,
| 1 | 2 | 3 | 5 |
| 5 | 6 | 7 | 8 |
| 4 | 3 | 2 | 1 |
๋ก ๋ ์ด ์ฃผ์ด์ก๋ค๋ฉด, 1ํ์์ ๋ค ๋ฒ์งธ ์นธ (5)๋ฅผ ๋ฐ์์ผ๋ฉด, 2ํ์ ๋ค ๋ฒ์งธ ์นธ (8)์ ๋ฐ์ ์ ์์ต๋๋ค.
๋ง์ง๋ง ํ๊น์ง ๋ชจ๋ ๋ด๋ ค์์ ๋, ์ป์ ์ ์๋ ์ ์์ ์ต๋๊ฐ์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ์ ์์ ๊ฒฝ์ฐ, 1ํ์ ๋ค ๋ฒ์งธ ์นธ (5), 2ํ์ ์ธ ๋ฒ์งธ ์นธ (7), 3ํ์ ์ฒซ ๋ฒ์งธ ์นธ (4) ๋ ์ ๋ฐ์ 16์ ์ด ์ต๊ณ ์ ์ด ๋๋ฏ๋ก 16์ return ํ๋ฉด ๋ฉ๋๋ค.
์ ํ ์ฌํญ
- ํ์ ๊ฐ์ N : 100,000 ์ดํ์ ์์ฐ์
- ์ด์ ๊ฐ์๋ 4๊ฐ์ด๊ณ , ๋ (land)์ 2์ฐจ์ ๋ฐฐ์ด๋ก ์ฃผ์ด์ง๋๋ค.
- ์ ์ : 100 ์ดํ์ ์์ฐ์
์ ์ถ๋ ฅ ์
| land | answer |
| [[1, 2, 3, 5], [5, 6, 7, 8], [4, 3, 2, 1]] | 16 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ฌธ์ ์ ์์์ ๊ฐ์ต๋๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
class Solution {
int solution(int[][] land) {
// ์ต์ข
์ ์๋ฅผ ์ ์ฅํ ๋ณ์ ์์ฑ
int answer = 0;
// ๋ฐฐ์ด์ ๊ธธ์ด ์ ์ฅ
int len = land.length;
// ๋ฐ๋ณต๋ฌธ ์งํํ๋ฉด์ ์ต๋๊ฐ ๊ตฌํ๊ธฐ, ๋์ ์ต๋๊ฐ ๊ตฌํ๊ธฐ
for (int i = 1; i < len; i++) {
land[i][0] += Math.max(Math.max(land[i-1][1], land[i-1][2]), land[i-1][3]);
land[i][1] += Math.max(Math.max(land[i-1][0], land[i-1][2]), land[i-1][3]);
land[i][2] += Math.max(Math.max(land[i-1][0], land[i-1][1]), land[i-1][3]);
land[i][3] += Math.max(Math.max(land[i-1][0], land[i-1][1]), land[i-1][2]);
}
// ๋ง์ง๋ง ํ ๋ณ์
int lastRow = len -1;
// ๋ง์ง๋ง ํ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ด ์ ๋ต
for (int j = 0; j < 4; j++) {
answer = Math.max(answer, land[lastRow][j]);
}
// ์ ๋ต ๋ฐํ
return answer;
}
}
๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์๊ฐํ ๋ฐฉํฅ
์ฒ์ ๋ฌธ์ ๋ฅผ ๋ดค์ ๋๋ ๊ฐ ํ์์ ์ด์ ์ด๋ง ๋ฐ์ง ์์ผ๋ฉด ๋๋๊น, ๋จ์ํ ๋งค ํ๋ง๋ค ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ณ ๋ฅด๋ฉด ๋๋ค๊ณ ์๊ฐํ๋ค. ๊ทธ๋์ ์ด์ ์ ์ ํํ ์ด์ oldColumn ๋ณ์๋ก ์ ์ฅํด๋๊ณ , ํ์ฌ ํ์์ ๊ทธ ์ด์ ์ ์ธํ ๊ฐ๋ค ์ค ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ํด ๋๊ฐ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ค. ์ฆ, ๋งค ์๊ฐ์ ์ต๋๊ฐ์ ์ ํํ๋ ๊ทธ๋ฆฌ๋(ํ์์ ) ์ ๊ทผ์ด์๋ค.
ํ์ง๋ง ์ฝ๋๋ฅผ ์์ฑํ๊ณ ๊ณฐ๊ณฐ์ด ์๊ฐํด๋ณด๋, “์ด ๋ฐฉ์์ด ํญ์ ์ต์ ์ผ๊น?” ํ๋ ์๋ฌธ์ด ๋ค์๋ค. ๋ง์ฝ ํ ํ์์ ํฐ ๊ฐ์ ์ ํํ ํ์, ๋ค์ ํ์์ ํจ์ฌ ๋ ํฐ ๊ฐ์ ๋์น๋ ์ํฉ์ด ๋ฐ์ํ๋ค๋ฉด ์ ์ฒด ํฉ์ ์ต๋๊ฐ์ด ์๋ ์๋ ์๋ค๋ ์ ์ ๊นจ๋ฌ์๋ค. ์ค์ ๋ก ๋ฐ๋ก๋ฅผ ๋ง๋ค์ด๋ณด๋, ์ฒซ ๋ฒ์งธ ํ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ณ ๋ฅด๋ ๊ฒ์ด ์คํ๋ ค ๋ค์ ํ์ ์ ํ ํญ์ ์ค์ฌ ์ ์ฒด ํฉ์ด ์์์ง๋ ๊ฒฝ์ฐ๊ฐ ์์๋ค. ์ด ์ง์ ์์ ๊ทธ๋ฆฌ๋ ๋ฐฉ์์ ๊ตญ์ ์ต์ ํด(local optimum)์ ๋จธ๋ฌผ ๋ฟ, ์ ์ญ ์ต์ ํด(global optimum)๋ฅผ ๋ณด์ฅํ์ง ๋ชปํ๋ค๋ ์ฌ์ค์ ํ์ธํ๋ค.
์ด ๋ฌธ์ ๋ ๊ฒฐ๊ตญ “ํ์ฌ์ ์ ํ์ด ๋ค์ ์ ํ์ ์ํฅ์ ์ค๋ค”๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์์๋ค. ๊ทธ๋ ๋ค๋ฉด ๋จ์ํ ํ ํ๋ง ๋ณด๋ ๊ฒ์ด ์๋๋ผ, ์ด์ ํ์์์ ๊ฒฐ๊ณผ๋ฅผ ๋์ ํด์ ๊ณ ๋ คํด์ผ ํ๋ค. ์ฌ๊ธฐ์ ๋ฐ๋ก ๋์ ๊ณํ๋ฒ(DP, Dynamic Programming) ์ด ํ์ํ๋ค๋ ๊ฒฐ๋ก ์ ๋๋ฌํ๋ค.
DP๋ก ์ ๊ทผํ๊ธฐ ์ํด ๋จผ์ ์ํ๋ฅผ ์ ์ํ๋ค. dp[i][j]๋ฅผ “i๋ฒ์งธ ํ์ j์ด์ ๋ฐ์์ ๋ ์ป์ ์ ์๋ ์ต๋ ์ ์”๋ก ๋์๋ค. ๊ทธ๋ฆฌ๊ณ ํ์ฌ ์์น๊น์ง ์ฌ ์ ์๋ ๋ชจ๋ ๊ฒฝ๋ก ์ค, ๋ฐ๋ก ์ํ์์ ๊ฐ์ ์ด์ ์ ์ธํ ๊ณณ ์ค ์ต๋๊ฐ์ ๋ํด์ฃผ๋ ์ ํ์์ ์ธ์ ๋ค.
dp[i][j] = land[i][j] + max(dp[i-1][k]) (๋จ, k ≠ j)
์ด ์์ ๊ธฐ๋ฐ์ผ๋ก 2ํ๋ถํฐ ๋ง์ง๋ง ํ๊น์ง ์ฐจ๋ก๋ก ๋์ ๊ณ์ฐ์ ์งํํ๋ฉด, ๋ง์ง๋ง ํ์๋ ๊ฐ ๊ฒฝ๋ก๋ณ๋ก ๊ฐ๋ฅํ ์ต๋๊ฐ์ด ์ ์ฅ๋๋ค. ๋ฐ๋ผ์ ๋ง์ง๋ง ํ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ์ผ๋ฉด ๊ทธ๊ฒ์ด ๊ณง ์ ๋ต์ด ๋๋ค.
์ด ๋ฐฉ์์ ๊ทธ๋ฆฌ๋ ์ ๊ทผ์ ํ๊ณ๋ฅผ ๋ณด์ํ๋ฉฐ, ๋งค ํ์ ๊ฐ๋ฅํ ์ ํ์ ๋ชจ๋ ๊ณ ๋ คํด ์ต์ ํด๋ฅผ ์ฐพ์ ์ ์๋ค. ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด์ “ํญ์ ๊ฐ์ฅ ์ปค ๋ณด์ด๋ ๊ฐ์ ๊ณ ๋ฅธ๋ค๊ณ ํด์ ์ต์ ์ ๊ฒฐ๊ณผ๊ฐ ๋์ง๋ ์๋๋ค”๋ ์ ์ ๋ฐฐ์ ๊ณ , ํ์ฌ ์ ํ์ด ๋ฏธ๋์ ๊ฐ๋ฅ์ฑ์ ์ด๋ค ์ ์ฝ์ ์ฃผ๋์ง๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค๋ ๊ฑธ ๋ค์ ํ๋ฒ ๋๊ผ๋ค.
์์ผ๋ก ๋น์ทํ ์ ํ์ ๋ฌธ์ ๋ฅผ ๋ง๋๋ฉด, ๋จ์ํ ์ต๋๊ฐ ์ ํ๋ณด๋ค ์ด์ ์ํ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ๋์ ์ต์ ํ(DP ์ฌ๊ณ ) ๋ฅผ ๋จผ์ ๋ ์ฌ๋ฆด ์ ์๋๋ก ํ๋ ๊ฒ์ด ์ด๋ฒ ํ์ต์ ํต์ฌ์ด์๋ค.
'๐ฆ ํ๋ก๊ทธ๋๋จธ์ค > ๐๏ธ ์๊ณ ๋ฆฌ์ฆ ํ์ด(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ์ฃผ์ฐจ ์๊ธ ๊ณ์ฐ (0) | 2025.10.17 |
|---|---|
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ํ๋ฐฐ์์ (0) | 2025.10.16 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋คํธ ๊ฒ์ (0) | 2025.10.02 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ํ๋ฒ๊ฑฐ ๋ง๋ค๊ธฐ (0) | 2025.10.01 |
| [ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋ฌธ์์ด ๋๋๊ธฐ (0) | 2025.09.26 |