[BOJ] 1937 ์์ฌ์์ด ํ๋ค
๋ฌธ์
๋ฌธ์ ์ค๋ช
Baekjoon Online Judge - 1937๋ฒ ์์ฌ์์ด ํ๋ค
n ร n์ ํฌ๊ธฐ์ ๋๋๋ฌด ์ฒ์ด ์๋ค. ์์ฌ์์ด ํ๋ค๋ ์ด๋ค ์ง์ญ์์ ๋๋๋ฌด๋ฅผ ๋จน๊ธฐ ์์ํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ๊ณณ์ ๋๋๋ฌด๋ฅผ ๋ค ๋จน์ด ์น์ฐ๋ฉด ์, ํ, ์ข, ์ฐ ์ค ํ ๊ณณ์ผ๋ก ์ด๋์ ํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ ๊ทธ๊ณณ์์ ๋๋๋ฌด๋ฅผ ๋จน๋๋ค. ๊ทธ๋ฐ๋ฐ ๋จ ์กฐ๊ฑด์ด ์๋ค. ์ด ํ๋ค๋ ๋งค์ฐ ์์ฌ์ด ๋ง์์ ๋๋๋ฌด๋ฅผ ๋จน๊ณ ์๋ฆฌ๋ฅผ ์ฎ๊ธฐ๋ฉด ๊ทธ ์ฎ๊ธด ์ง์ญ์ ๊ทธ ์ ์ง์ญ๋ณด๋ค ๋๋๋ฌด๊ฐ ๋ง์ด ์์ด์ผ ํ๋ค.
์ด ํ๋ค์ ์ฌ์ก์ฌ๋ ์ด๋ฐ ํ๋ค๋ฅผ ๋๋๋ฌด ์ฒ์ ํ์ด ๋์์ผ ํ๋๋ฐ, ์ด๋ค ์ง์ ์ ์ฒ์์ ํ์ด ๋์์ผ ํ๊ณ , ์ด๋ค ๊ณณ์ผ๋ก ์ด๋์ ์์ผ์ผ ํ๋ค๊ฐ ์ต๋ํ ๋ง์ ์นธ์ ๋ฐฉ๋ฌธํ ์ ์๋์ง ๊ณ ๋ฏผ์ ๋น ์ ธ ์๋ค. ์ฐ๋ฆฌ์ ์๋ฌด๋ ์ด ์ฌ์ก์ฌ๋ฅผ ๋์์ฃผ๋ ๊ฒ์ด๋ค. n ร n ํฌ๊ธฐ์ ๋๋๋ฌด ์ฒ์ด ์ฃผ์ด์ ธ ์์ ๋, ์ด ํ๋ค๊ฐ ์ต๋ํ ๋ง์ ์นธ์ ์ด๋ํ๋ ค๋ฉด ์ด๋ค ๊ฒฝ๋ก๋ฅผ ํตํ์ฌ ์์ง์ฌ์ผ ํ๋์ง ๊ตฌํ์ฌ
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋๋๋ฌด ์ฒ์ ํฌ๊ธฐ n(1 โค n โค 500)์ด ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ๋์งธ ์ค๋ถํฐ n+1๋ฒ์งธ ์ค๊น์ง ๋๋๋ฌด ์ฒ์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๋๋๋ฌด ์ฒ์ ์ ๋ณด๋ ๊ณต๋ฐฑ์ ์ฌ์ด๋ก ๋๊ณ ๊ฐ ์ง์ญ์ ๋๋๋ฌด์ ์์ด ์ ์ ๊ฐ์ผ๋ก ์ฃผ์ด์ง๋ค. ๋๋๋ฌด์ ์์ 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์๋ ํ๋ค๊ฐ ์ด๋ํ ์ ์๋ ์นธ์ ์์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
ํ์ด
ํด์ค
DP, DFS, ์ฌ๊ท, Top-Down
nxn ๋ชจ๋ ์ขํ์ ๋ํด DP ๊ฐ์ด ๊ฐฑ์ ๋์ง ์์ ์ํ์ด๋ฉด ํ์์ ์๋ํ๋ค. ์, ํ, ์ข, ์ฐ ์ค ์์ ๋ณด๋ค ๋๋๋ฌด ๊ฐ์๊ฐ ์ ์ ์ขํ๋ ํ์ํ ์ ์๋ค.
์ธ์ ์ขํ ์ค ํ์ ๊ฐ๋ฅํ ์ขํ์ผ ๋ ํจ์๋ฅผ ์ฌ๊ท์ ์ผ๋ก ํธ์ถํ์ฌ ํด๋น ์ธ์ ์ขํ์ ์ ์ฅ๋ dp๊ฐ์ ๊ตฌํ๊ณ , (์ธ์ ์ขํ dp๊ฐ + 1) ํ ๊ฐ์ด ์์ ์ dp ๊ฐ์ด ๋๋ค.(ํด๋น ์ธ์ ์ขํ๊น์ง ๊น์ด์ ์๊ธฐ ์์ ์ ๋ํจ)
์ฌ๊ท์ ์ผ๋ก ๋์ด์ ํ๊ณ ๋ค์ด๊ฐ ์ ์๋ ๊ฒฝ์ฐ(๊ธฐ์ ์กฐ๊ฑด)๋ ์๊ธฐ ์์ ์ด ์ธ์ ํ 4๋ฐฉ๊ณผ ๋น๊ตํ์ ๋ ๋๋๋ฌด ๊ฐ์๊ฐ ๊ฐ์ฅ ์ ์ ๋์ด๊ณ , ์ด๋๋ dp ๊ฐ์ 1๋ก ์ค์ ํ๋ค.
์ฝ๋
import java.io.*;
import java.util.*;
public class BOJ_1937_์์ฌ์์ดํ๋ค {
static int n, maxBamboo;
static int[][] map;
static int[][] dp;
static int[] dx = {-1, 1, 0, 0};
static int[] dy = {0, 0, -1, 1};
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
n = Integer.parseInt(br.readLine());
// ์ด๊ธฐ ์ง๋ ์ค์ ๋ฐ DP ํ
์ด๋ธ ์ด๊ธฐํ
map = new int[n][n];
dp = new int[n][n];
for (int i=0; i<n; i++) {
Arrays.fill(dp[i], -1); // ๋ฐฉ๋ฌธ์ฌ๋ถ ์ฒดํฌ๋ฅผ ์ํด -1๋ก ์ด๊ธฐํ
StringTokenizer st = new StringTokenizer(br.readLine());
for (int j=0; j<n; j++) map[i][j] = Integer.parseInt(st.nextToken());
}
// DP ํ
์ด๋ธ ๋ง๋ค๋ฉฐ ์ต๋๊ฐ ์ฐพ๊ณ ์ถ๋ ฅ
makeDPTable();
System.out.println(maxBamboo);
}
// ๋ชจ๋ ์ขํ์ ๋ํด DP ํ
์ด๋ธ ๊ตฌ์ฑ
private static void makeDPTable() {
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
// ์์ง ๋ฐฉ๋ฌธํ์ง ์์ DP ํ
์ด๋ธ์ด ๋น ๊ฒฝ์ฐ๋ง DP ํ
์ด๋ธ์ ์ฑ์
if (dp[i][j]==-1) {
countBamboo(i, j);
maxBamboo = Math.max(maxBamboo, dp[i][j]); // ์ต๋๊ฐ ๊ฐฑ์
}
}
}
}
// ํ์ฌ ์ขํ์ DP ๊ฐ ๊ตฌํ๊ธฐ
private static int countBamboo(int i, int j) {
// ์ด๋ฏธ ๋ฐฉ๋ฌธํ ์ ์ด ์์ด DP ํ
์ด๋ธ์ด ์ฑ์์ ธ์์ผ๋ฉด ํด๋น ๊ฐ + 1์ ๋ฐํ
if (dp[i][j]!=-1) return dp[i][j] + 1;
// ๋ฐฉ๋ฌธํ ์ ์์ผ๋ฉด 4๋ฐฉ ํ์์ผ๋ก DP ํ
์ด๋ธ ์ฑ์
dp[i][j] = 0;
for (int d=0; d<4; d++) {
int nx = i + dx[d];
int ny = j + dy[d];
// ๊ฒฝ๊ณ ๋ด๋ถ์ด๊ณ ์์ ๋ณด๋ค ์ ์ ๊ฐ์์ ๋๋๋ฌด๊ฐ ์๋ ๊ฒฝ์ฐ๋ง ํ์
if (isInside(nx, ny) && map[nx][ny]<map[i][j]) dp[i][j] = Math.max(dp[i][j], countBamboo(nx, ny));
}
// 4๋ฐฉ ํ์ ์ดํ์๋ DP ํ
์ด๋ธ์ด ๊ฐฑ์ ๋์ง ์์ ์ํ, ์ฆ 4๋ฐฉ๊ณผ ๋น๊ตํ์ ๋ ์๊ธฐ ์์ ์ ๋๋๋ฌด๊ฐ ๊ฐ์ฅ ์ ์ผ๋ฉด 1์นธ(์๊ธฐ์์ )์ผ๋ก ์ค์
if (dp[i][j]==0) dp[i][j] = 1;
return dp[i][j] + 1; // ์ธ์ ํ ์ขํ๊น์ง์ DP ๊ฐ + 1(์๊ธฐ์์ ) ๋ฐํ
}
// ๊ฒฝ๊ณ์ฒดํฌ
private static boolean isInside(int x, int y) {
return (x>=0 && x<n && y>=0 && y<n);
}
}