๐ ๋ฌธ์
https://www.acmicpc.net/problem/14500
๋ฌธ์
ํด๋ฆฌ์ค๋ฏธ๋ ธ๋ ํฌ๊ธฐ๊ฐ 1×1์ธ ์ ์ฌ๊ฐํ์ ์ฌ๋ฌ ๊ฐ ์ด์ด์ ๋ถ์ธ ๋ํ์ด๋ฉฐ, ๋ค์๊ณผ ๊ฐ์ ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํ๋ค.
- ์ ์ฌ๊ฐํ์ ์๋ก ๊ฒน์น๋ฉด ์ ๋๋ค.
- ๋ํ์ ๋ชจ๋ ์ฐ๊ฒฐ๋์ด ์์ด์ผ ํ๋ค.
- ์ ์ฌ๊ฐํ์ ๋ณ๋ผ๋ฆฌ ์ฐ๊ฒฐ๋์ด ์์ด์ผ ํ๋ค. ์ฆ, ๊ผญ์ง์ ๊ณผ ๊ผญ์ง์ ๋ง ๋ง๋ฟ์ ์์ผ๋ฉด ์ ๋๋ค.
์ ์ฌ๊ฐํ 4๊ฐ๋ฅผ ์ด์ด ๋ถ์ธ ํด๋ฆฌ์ค๋ฏธ๋ ธ๋ ํ ํธ๋ก๋ฏธ๋ ธ๋ผ๊ณ ํ๋ฉฐ, ๋ค์๊ณผ ๊ฐ์ 5๊ฐ์ง๊ฐ ์๋ค.
์๋ฆ์ด๋ ํฌ๊ธฐ๊ฐ N×M์ธ ์ข ์ด ์์ ํ ํธ๋ก๋ฏธ๋ ธ ํ๋๋ฅผ ๋์ผ๋ ค๊ณ ํ๋ค. ์ข ์ด๋ 1×1 ํฌ๊ธฐ์ ์นธ์ผ๋ก ๋๋์ด์ ธ ์์ผ๋ฉฐ, ๊ฐ๊ฐ์ ์นธ์๋ ์ ์๊ฐ ํ๋ ์ฐ์ฌ ์๋ค.
ํ ํธ๋ก๋ฏธ๋ ธ ํ๋๋ฅผ ์ ์ ํ ๋์์ ํ ํธ๋ก๋ฏธ๋ ธ๊ฐ ๋์ธ ์นธ์ ์ฐ์ฌ ์๋ ์๋ค์ ํฉ์ ์ต๋๋ก ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํ ํธ๋ก๋ฏธ๋ ธ๋ ๋ฐ๋์ ํ ์ ์ฌ๊ฐํ์ด ์ ํํ ํ๋์ ์นธ์ ํฌํจํ๋๋ก ๋์์ผ ํ๋ฉฐ, ํ์ ์ด๋ ๋์นญ์ ์์ผ๋ ๋๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ข ์ด์ ์ธ๋ก ํฌ๊ธฐ N๊ณผ ๊ฐ๋ก ํฌ๊ธฐ M์ด ์ฃผ์ด์ง๋ค. (4 ≤ N, M ≤ 500)
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ข ์ด์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. i๋ฒ์งธ ์ค์ j๋ฒ์งธ ์๋ ์์์๋ถํฐ i๋ฒ์งธ ์นธ, ์ผ์ชฝ์์๋ถํฐ j๋ฒ์งธ ์นธ์ ์ฐ์ฌ ์๋ ์์ด๋ค. ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ์๋ 1,000์ ๋์ง ์๋ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ํ ํธ๋ก๋ฏธ๋ ธ๊ฐ ๋์ธ ์นธ์ ์ฐ์ธ ์๋ค์ ํฉ์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
โ๏ธ ํ์ด
์ด ๋ฌธ์ ๋ ๋ค๋ฅธ ํ์ด๋ฅผ ์ฐธ๊ณ ๋ฅผ ์กฐ๊ธ ํ๋ค ใ ใ
์์ ํ์์ผ๋ก ๊ฐ์ผํ๋์ง ๊ณ ๋ฏผ์ด ๋ง์๋๋ฐ ๊ฒฐ๊ตญ์ ๋ง์๋ค. ๋จ ์์ด๋์ด๊ฐ ํ๋ ์์ด์ผ ํ๋ค.
๐ก "ใ "์ ์ ์ธํ ๋ชจ๋ ๋ชจ์์ ๊น์ด๊ฐ 4์ธ DFS๋ก ๋ง๋ค์ด์ง๋ ๋ชจ์์ด๋ค.
์ด ์์ด๋์ด๋ง ์ฐธ๊ณ ํ๋ฉด ์ฝ๊ฒ ๋ฌธ์ ๋ฅผ ํ ์ ์๋ค. ํน์ ์์น์์ ๊ฐ ์ ์๋ ๊น์ด 4์ธ ๋ชจ๋ DFS ๋ฃจํธ๋ฅผ ํ์ธํ ํ, ๊ทธ ์ค์์๋ ๊ฐ์ค์น๊ฐ ์ต๊ณ ์ธ ๊ฐ์ ์ฐพ์ผ๋ฉด ๋๋ค.
์ดํ ์์ธ์ฌํญ์ธ "ใ " ๋ชจ์๋ง ๋ฐ๋ก ์ฒดํฌํด์ค๋ค. "ใ " ๋ชจ์์ ๊ฒฝ์ฐ ์ฌ๋ฐฉํ์์์ ์ด๊ฐ ํ๋ ๋น ์ง ๊ฒ์ผ๋ก ํ ์ ์๋ค.
๐ป ์์ค์ฝ๋: ์๋ฐ(Java)
public class Main_๋ฐฑ์ค_14500_ํ
ํธ๋ก๋ฏธ๋
ธ_๊ณจ๋V {
static int N, M, result=Integer.MIN_VALUE;
static int[] dx = {1,-1,0,0};
static int[] dy = {0,0,1,-1};
static boolean[][] visited;
static int[][] map;
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
M = Integer.parseInt(st.nextToken());
map = new int[N][M];
visited = new boolean[N][M];
for (int i = 0; i < N; i++) {
st = new StringTokenizer(br.readLine());
for (int j = 0; j < M; j++) {
map[i][j] = Integer.parseInt(st.nextToken());
}
}//input
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
dfs(i,j,0,0);
exception(i, j);
}
}
System.out.println(result);
}//end of main
private static void dfs(int x, int y, int cnt, int sum) {
if(cnt==4) {
result = Math.max(result, sum);
return;
}
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if(nx<0||ny<0||nx>=N||ny>=M||visited[nx][ny]) continue;
visited[nx][ny] = true;
dfs(nx, ny, cnt+1, sum+map[nx][ny]);
visited[nx][ny] = false;
}
}//end of dfs
private static void exception(int x, int y) {
int nx, ny, wing = 0, sum = map[x][y];
for (int i = 0; i < 4; i++) {
nx = x + dx[i];
ny = y + dy[i];
if(nx<0||ny<0||nx>=N||ny>=M) continue;
sum += map[nx][ny];
wing++;
}
if(wing==3) result = Math.max(result, sum);
else if(wing==4) {
for (int i = 0; i < 4; i++) {
nx = x + dx[i];
ny = y + dy[i];
result = Math.max(result, sum-map[nx][ny]);
}
}
}//end of exception
}//end of class
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ