[๋ฐฑ์ค] ๐ฅ 7576 ํ ๋งํ
๐ ๋์ด๋
๐ฅ Gold 5
๐ ๋ฌธ์
https://www.acmicpc.net/problem/7576
๐ ํ์ด
์ ์ง๊ธ๊น์ง์ BFS
๋ ๊ฒฐ์ด ๋ค๋ฅธ ๋ฌธ์ ์๋ค.
ํ์คํ ๋์ด๋๊ฐ ๊ณจ๋๊ธ ๋๋ ๋ฌธ์ ๋ฅผ ํธ๋๊น, ์ง๊ธ๊น์ง์ BFS
์ ์ ๊ทผ ๋ฐฉ๋ฒ๊ณผ๋ ๋ค๋ฅด๊ฒ ์ ๊ทผํ๋ ๋ฌธ์ ๊ฐ ๋์๋ค.
์ง๊ธ๊น์ง๋ ๋จ์ํ start
์ง์ ์์ end
์ง์ ๊น์ง์ ๊ฑธ๋ฆฌ๋ ์๊ฐ๊ฐ์ ํ์
์ ๋ฌธ์ ์๋๋ฐ, ์ด๋ฒ์๋ start
๊ฐ ์ฌ๋ฌ๊ฐ์ด๊ณ , end
๊ฐ ๋ฐ๋ก ์์ด ์ข
๋ฃ ์์ ์ ์ ํด์ค์ผํ๋ ๋ฌธ์ ์๋ค.
๊ทธ๋์ ์ฒ์ ๊ตฌํ์ ํ ๋๋ ์ด์ ๊ณผ ๋๊ฐ์ด ๊ตฌํ์ ํ๋ค๊ฐ ์ค๋ฅ๊ฐ ์๊ฒผ๋ค.
๋ฐ๋ก 1์ด ์ฌ๋ฌ๊ฐ ์์ผ๋ฉด ๋์์ ํผ์ ธ๋๊ฐ์ผํ๋๋ฐ, ์์ ์ฃผ์๊ฐ์ ์๋ 1์์ ๋ค ํผ์ ธ๋๊ฐํ ๋ค์๋ฅผ ๊ฒ์ฌํ๋ ์์ผ๋ก ์๋์ ํ๋ค.
๋ฐ๋ผ์ ๋์ฒด ์ด๋ป๊ฒ ๊ตฌํํด์ผํ ๊น ๊ณ ๋ฏผ์ ํ๋ค๊ฐ, ์ฒ์์๋ ์ด BFS
์ ๋ฐ๋ก curtime
์ด๋ผ๋ ๋ณ์๋ฅผ ๋ฃ์ด์ฃผ์ด์, box[i][j] == curtime
์ผ ๋๋ง ํผ์ ธ๋๊ฐ๋ ์์ผ๋ก ๊ตฌํ์ ํ์๋ค.
ํ์ง๋ง ๊ทธ๋ฐ์์ผ๋ก ํ๋๊น ์๊ฐ๋ณต์ก๋๊ฐ o(n^3)์ด๋ผ๋ ๋ง๋ ์๋๊ฒ ๋๋ฆฐ ์๊ณ ๋ฆฌ์ฆ์ด ๋์ด๋ฒ๋ ธ๋ค.
๊ฒฐ๊ตญ ๊ณ ์ฌํ ๋์, ๋น๊ณต๊ฐ์ ํ ๋งํ ๊ฐ ๊ฑธ๋ฆฌ๋ ์ต๋์๊ฐ์ธ 1000000
๋ณด๋ค ๋ง๊ฒ empty
๋ผ๋ ์์๋ฅผ ๋ง๋ค์ด์ ๋ฐ๊พธ์ด์ฃผ๊ณ , Math.min
์ผ๋ก ๋น๊ณต๊ฐ๊ณผ ์ฑ์ฐ๋๋ฐ ๊ฑธ๋ฆฐ์๊ฐ์ ๋น๊ตํด์ ๋ฃ์ด์ฃผ์๋ค.
์ด๋ฐ์์ผ๋กํ๋ฉด ์ด๋ฏธ ๊ฐ์ด ๋ค์ด์์ด๋ ๋ ์์ ์๊ฐ์ด ๋ค์ด๊ฐ๊ฒ ๋๋ฏ๋ก, ์ฝ๋๊ฐ ๊ฒฐ๊ณผ์ ์ผ๋ก๋ ์ ์์ ์ผ๋ก ํผ์ง ๊ฒ๊ณผ ๋์ผํ๊ฒ ๋๋ค.
์ด์ ์ฌ์ฌ ์์ ๊ณจ๋๋ฌธ์ ๋ฅผ ํ ์๊ธฐ๊ฐ ์จ ๊ฒ ๊ฐ๋ค. ๐
๐ Code
package BOJ.BFS;
import java.io.*;
import java.util.*;
public class N7576 {
static int[][] box;
static Queue<Integer[]> q;
static int M;
static int N;
static int[] DR = new int[]{-1, 0, 1, 0};
static int[] DC = new int[]{0, 1, 0, -1};
static final int empty = 1000002;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
M = Integer.parseInt(st.nextToken());
N = Integer.parseInt(st.nextToken());
box = new int[N][M];
q = new LinkedList<>();
for (int i = 0; i < N; i++) {
st = new StringTokenizer(br.readLine());
for (int j = 0; j < M; j++) {
box[i][j] = Integer.parseInt(st.nextToken());
if (box[i][j] == 1) {
q.add(new Integer[]{i, j});
} else if (box[i][j] == 0) {
box[i][j] = empty;
}
}
}
BFS();
FindTomato();
}
static void FindTomato() {
int max = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
max = Math.max(max, box[i][j]);
}
}
if (max == empty) {
System.out.println(-1);
} else {
System.out.println(max - 1);
}
}
static void BFS() {
Integer[] cur;
int nextRow;
int nextCol;
int curtime;
while (!q.isEmpty()) {
cur = q.poll();
curtime = box[cur[0]][cur[1]] + 1;
for (int i = 0; i < DC.length; i++) {
nextRow = cur[0] + DR[i];
nextCol = cur[1] + DC[i];
if (nextRow < 0 || nextRow >= N || nextCol < 0 || nextCol >= M || box[nextRow][nextCol] != empty) {
continue;
}
q.add(new Integer[]{nextRow, nextCol});
box[nextRow][nextCol] = Math.min(box[nextRow][nextCol], curtime);
}
}
}
}
package (์ด๋ฆ); ๋ฅผ ๋๊ณ , class ์ด๋ฆ์ Main
์ผ๋ก ๋ณ๊ฒฝํ๋ฉด ๋๋ค.
๊ฐ์ธ ๊ณต๋ถ ๊ธฐ๋ก์ฉ ๋ธ๋ก๊ทธ์
๋๋ค.
ํ๋ฆฌ๊ฑฐ๋ ์ค๋ฅ๊ฐ ์์ ๊ฒฝ์ฐ ์ ๋ณดํด์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.๐