[Java] 백준 19237번 어른 상어

시뮬레이션 문제입니다.
1번 상어만 남는데 걸리는 시간을 구해야 하며, 1000초가 넘어가면 -1을 출력합니다.

상어는 바라보고 있는 방향(동, 서, 남, 북)에 따라서 4가지 방향으로 우선순위를 각각 가집니다.
1. 현재 위치에 냄새를 남김
2 우선순위 순서대로 빈공간으로 이동
  - 상어가 겹치면 높은 숫자의 상어 제거
3 빈공간이 없을 경우 자신이 냄새를 남겼던 위치로 우선순위를 탐색하여 이동

문제는 많이 어렵지 않지만 예외가 발생했을 때 디버깅을 하는것이 어려운 문제입니다.

package com.ssafy.test2;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

public class test21 {
	static int n, m, k;
	static int[][] map;
	static int[][] time;
	static int[][][] sharkMove;
	static Shark[] shark;
	static int[] dy = { 0, -1, 1, 0, 0 };
	static int[] dx = { 0, 0, 0, -1, 1 };

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

		StringTokenizer st = new StringTokenizer(br.readLine());

		n = Integer.parseInt(st.nextToken());
		m = Integer.parseInt(st.nextToken());
		k = Integer.parseInt(st.nextToken());

		map = new int[n + 1][n + 1];
		time = new int[n + 1][n + 1];
		shark = new Shark[m + 1];
		sharkMove = new int[m + 1][5][4];

		for (int i = 1; i <= n; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 1; j <= n; j++) {
				int num = Integer.parseInt(st.nextToken());

				if (num > 0) {
					shark[num] = new Shark(i, j, 0);
					time[i][j] = k;
					map[i][j] = num;
				}
			}
		}
		st = new StringTokenizer(br.readLine());
		for (int i = 1; i <= m; i++)
			shark[i].d = Integer.parseInt(st.nextToken());

		for (int i = 1; i <= m; i++) {
			for (int j = 1; j <= 4; j++) {
				st = new StringTokenizer(br.readLine());
				for (int l = 0; l < 4; l++) {
					sharkMove[i][j][l] = Integer.parseInt(st.nextToken());
				}
			}
		}

		bw.write(solve() + "\n");
		bw.flush();

	}

	public static int solve() {

		int ans = 0;
		
		while (true) {
			int count = 0;
			for(int i=1; i<=m; ++i) {
				if(shark[i] != null) {
					++count;
				}
			}
			if(count == 1) {
				return ans;
			}
			
			if (ans >= 1000) {
				return -1;
			}

			int[][] tmp = new int[n + 1][n + 1];

			for (int i = 1; i <= m; i++) {

				if (shark[i] != null) {
					move(tmp, i);
				}
			}

			for (int i = 1; i <= n; i++) {
				for (int j = 1; j <= n; j++) {
					if (time[i][j] > 0)
						time[i][j]--;

					if (time[i][j] == 0)
						map[i][j] = 0;
				}
			}

			for (int i = 1; i <= n; i++) {
				for (int j = 1; j <= n; j++) {
					if (tmp[i][j] > 0) {
						time[i][j] = k;
						map[i][j] = tmp[i][j];
					}
				}
			}
			ans++;
		}
	}

	public static void move(int[][] tmp, int index) {

		int y = 0;
		int x = 0;
		int d = 0;
		boolean chk = false;

		for (int i = 0; i < 4; i++) {
			d = sharkMove[index][shark[index].d][i];
			y = shark[index].y + dy[d];
			x = shark[index].x + dx[d];

			if ((1 <= y && y <= n) && (1 <= x && x <= n) && map[y][x] == 0) {
				chk = true;
				break;
			}
		}

		if (!chk) {
			for (int i = 0; i < 4; i++) {
				d = sharkMove[index][shark[index].d][i];
				y = shark[index].y + dy[d];
				x = shark[index].x + dx[d];

				if ((1 <= y && y <= n) && (1 <= x && x <= n) && map[y][x] == index)
					break;
			}
		}

		if (tmp[y][x] == 0) {

			tmp[y][x] = index;
			shark[index].y = y;
			shark[index].x = x;
			shark[index].d = d;
		} else {
			shark[index] = null;
		}
	}
	static class Shark {

		int y, x, d;

		Shark(int y, int x, int d) {
			this.y = y;
			this.x = x;
			this.d = d;
		}
	}
}