https://programmers.co.kr/learn/courses/30/lessons/12905
์ฝ๋
class Solution
{
public int solution(int [][]board)
{
int answer = 0;
int[][] newBoard = new int[board.length+1][board[0].length+1];
// ์๋ก์ด ๋ฐฐ์ด ์์ฑ
for(int i=0; i<board.length; i++)
for(int j=0; j<board[i].length; j++)
newBoard[i+1][j+1] = board[i][j];
int max = 0;
// ๋ง๋ค ์ ์๋ ์ ์ฌ๊ฐํ ๊ฒ์ฌ
for(int i=1; i<newBoard.length; i++){
for(int j=1; j<newBoard[i].length; j++){
/* 2x2 ์ฌ๊ฐํ์ ์ฐ์ธกํ๋จ ๊ผญ์ง์ ์ ๊ธฐ์ค์ผ๋ก ์ ์ฌ๊ฐํ์ด ๋๋์ง ์ฒดํฌํ๋ค.
* ํ์ฌ ๊ฐ์ด 1์ธ๊ฒฝ์ฐ ์ข←, ์↑, ์ข์โ ์ฒดํฌ
* ←, ↑, โ ๊ฐ์ด ๋ชจ๋ 1์ธ๊ฒฝ์ฐ ์ ์ฌ๊ฐํ์ ๋ง๋ค ์ ์์
*/
if(newBoard[i][j] == 1){
int left = newBoard[i-1][j]; // ์ข์ธก ๊ฐ
int up = newBoard[i][j-1]; // ์๋จ ๊ฐ
int leftUp = newBoard[i-1][j-1];// ์ข์ธก์๋จ(๋๊ฐ์ ) ๊ฐ
int min = Math.min(left, Math.min(up, leftUp));
newBoard[i][j] = min+1;
max = Math.max(max, min+1);
}
}
}
answer = max * max;
return answer;
}
}
ํ์ด
๋ฌธ์ ๋ฅผ ์ฒ์ ๋ณด๊ณ ๋ ์ ๊ทผ๋ฐฉ์์ ๋ชจ๋ ๊ฐ๋ฅํ ์ ์ฌ๊ฐํ์ ํฌ๊ธฐ๋ฅผ ์ฐพ์์ฃผ๋ ์์ด์๋๋ฐ,
๊ทธ๋ด๊ฒฝ์ฐ for๋ฌธ์ด 4๊ฐ๋ก O(n^4)์ ์๊ฐ๋ณต์ก๋์ ์๊ฐ์ด๊ณผ๋๋ฌธ์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์๊ฐํด๋ดค์ง๋ง ๋ ์ค๋ฅด์ง ์์๋ค.
๋ค๋ฅธ ์ฌ๋๋ค์ ํ์ด๋ฅผ ์ฐธ๊ณ ํ๋ DP๋ก ํ์๋ค.
์ด๋ป๊ฒ ?
2x2 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ์ ๊ธฐ์ค์ผ๋ก ๊ฐ๋ฅํ ๋ชจ๋ ์ ์ฌ๊ฐํ์ ๊ฒ์ฌํ๋๋ฐ,
๋ฐฐ์ด์ ํ์์ →↓์ฐ์ธก์ผ๋ก, ํ๋จ์ผ๋ก ๊ฒ์ฌํ๊ธฐ ๋๋ฌธ์ ์ฐ์ธกํ๋จ์ ๊ผญ์ง์ ์ ๊ธฐ์ค์ผ๋ก ์ก๋๋ค.
๋ฌธ์ ์ ์์ ์ ์ถ๋ ฅ์ ๊ธฐ์ค์ผ๋ก ๋ณด๋ฉด ํ์์ ์ ์์น ํ (1,1) ๋ถํฐ ์์ํ๋ค.
(1,1)๋ถํฐ ์์ํด์ [์ข์ธก, ์๋จ, ์ข์ธก ์๋จ]์ ๊ฐ์ ํ์ธํด๊ฐ๋ฉฐ ํ์ฌ ๊ฐ์ ์ต์๊ฐ+1๋ก ์ค์ ํด์ค๋ค.
์ ํ์ฌ๊ฐ์ ์ต์๊ฐ+1๋ก ์ค์ ํ๋์ง ๋ณด์.
ํ์ฌ (1,1)์ ๊ธฐ์ค์ผ๋ก
์ข์ธก(1,0) = 1
์๋จ(0,1) = 1
์ข์ธก์๋จ(0,0) = 0
์ด๋ค. ๊ทธ๋ผ ์ ์ฌ๊ฐํ์ ๋ง๋ค ์ ์์ผ๋ฏ๋ก ํ์ฌ ๊ฐ์ ์ต์๊ฐ+1 (0+1) = 1๋ก ์ค์ ํ๋ค.
๊ทธ๋ผ (1,2)๋ฅผ ๋ณด๋ฉด [์ข์ธก, ์๋จ, ์ข์ธก ์๋จ]์ ๊ฐ๋ค์ด ์ ๋ถ 1์ด๋ฏ๋ก ํ์ฌ๊ฐ์ 2๋ก ๋ณ๊ฒฝ์ด ๋๋ค.
๋ฐฐ์ด์ ๋๊น์ง ์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด ์๋์ ๊ฐ์ด ๋๋ค.
๊ทธ๋ผ ์ ๊ณผ์ ์์ ๊ฐ์ฅ ํฐ ์ ์ฌ๊ฐํ์ ํฌ๊ธฐ๋ ํ์ฌ ๊ฐ(3)์ ์ ๊ณฑ์ด ๋๋ค.
ํ์ง๋ง ์ ๊ณผ์ ์์ ์๋ก์ด ๋ฐฐ์ด(newBoard)๋ฅผ ์์ฑํ๊ณ , ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ +1 ๋ํด์ค ๊ฒ์ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ๊ธฐ ๋๋ฌธ์ธ๋ฐ,
ํ์ด 1์ด๊ฑฐ๋ ์ด์ด 1์ธ ๋ฐฐ์ด์ ๊ฒฝ์ฐ, ์์ธ๊ฐ ๋ฐ์ํ๋ค.
์์ ๊ฐ์ด ํ์ด 1์ด๊ฑฐ๋, ์ด์ด 1์ผ๊ฒฝ์ฐ ๊ฐ์ด 1์ด ์์ผ๋ฉด ์ ์ฌ๊ฐํ์ ์ต๋ ํฌ๊ธฐ๋ 1์ด๋ค.
๋ฐ๋ผ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ +1๋ก ์ค์ ํด์ค์, ๋ฐฐ์ด์ด [0][n] ๊ฐ๊ณผ [n][0]์ ๊ฐ์ ๋ชจ๋ 0์ผ๋ก ์ฑ์์ ๊ฒ์ํด์ผํ๋ค.
๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ +1๋ก ์ก์์ ์ค์ ํด์ฃผ๋ฉด ์๋์ ๊ฐ์ด 0ํ, 0์ด ๊ธฐ์ค์ผ๋ก 0๊ฐ์ด ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์ ์์ธ๋ฅผ ์ฒ๋ฆฌํด์ค ์ ์๋ค.
๋น์ทํ ๋ฌธ์
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)์์ ๋์งํ (0) | 2020.03.16 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)์ฃผ์๊ฐ๊ฒฉ (0) | 2020.03.16 |
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)ํผ๋ณด๋์น ์(์ฌ๊ท , ๋น์ฌ๊ทDP) (0) | 2020.03.16 |
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)ํ (0) | 2020.03.16 |
[Codeforces] 1303A: Erasing Zeroes (0) | 2020.03.16 |
๋๊ธ