试题 算法训练 勇士和地雷阵 java实现

问题描述
　　勇士们不小心进入了敌人的地雷阵（用n行n列的矩阵表示，’*‘表示某个位置埋有地雷，’-'表示某个位置是安全的），他们各自需要在规定的步数（一步代表走到和当前位置相邻的位置）内绕开地雷到达出口（第一行第一格，即坐标为（0,0）的位置）才能完成任务，告诉你每个勇士的位置（x，y）和规定的步数s，请你判断每个勇士能否顺利完成任务（1代表“能”，-1代表“不能”）。
输入格式
　　输入数据的第一行为一个整数n；第二行至第n+1行是n行n列地雷阵的矩阵表示（见输入样例）；第n+2行至最后一行每行是一个勇士的位置x、y和到达出口规定的最大步数s，三个整数间用空格隔开。
输出格式
　　按顺序输出对每个勇士是否能顺利完成任务的判断（1代表“能”，-1代表“不能”），对每个勇士的判断占一行。
样例输入
5

–*--
-–
-–
-–
0 1 1
0 4 3
1 1 3
1 4 2
2 0 3
3 0 4
3 3 2
4 1 3
样例输出
1
-1
1
-1
1
1
-1
-1
数据规模和约定
　　1≤n≤500，0≤x≤n-1，0≤y≤n-1，1≤s≤500

---

解题思路：直接dfs计算每个位置到(0,0)的距离后，判断给的位置和步数是否满足条件即可。但是这道题数据量比较大，用递归的方法dfs，会栈溢出，如下图。

所以用队列迭代来实现dfs，还有Scanner读取数据效率比较低，改为用BufferdReader获取数据，最终提交两次才勉强压线过。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
	static int[][] change = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };// 顺时针4个方向
	static int[][] vis;// 存储位置的状态
	static int[][] map;// 存储每个点离(0,0)终点的位置
	static int n;

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// 数据量大，用Scanner会超时
		n = Integer.parseInt(br.readLine());
		vis = new int[n][n];
		map = new int[n][n];
		String str;
		char c;
		for (int i = 0; i < n; i++) {
			str = br.readLine();
			for (int j = 0; j < n; j++) {
				c = str.charAt(j);
				if (c == '*')
					vis[i][j] = 1;// 有地雷的地方位置状态直接置为1
			}
		}
		vis[0][0] = 1;
		dfs(0, 0);// 从(0,0)开始搜索
		String s;
		StringTokenizer t;
		while ((s = br.readLine()) != null) {
			t = new StringTokenizer(s);// 同一行数据分开获取
			int x = Integer.parseInt(t.nextToken());
			int y = Integer.parseInt(t.nextToken());
			int step = Integer.parseInt(t.nextToken());
			if (x == 0 && y == 0)// 一开始就在终点
				System.out.println("1");
			else if (map[x][y] > step || map[x][y] == 0 || vis[x][y] == 1) {// 1、步数不够 2、该位置被地雷围着，没有计算到，所以是0 3、在地雷上
				System.out.println("-1");
			} else {
				System.out.println("1");
			}
		}

	}

	public static void dfs(int a, int b) {
		/*
		 * for (int i = 0; i < 4; i++) { int a2 = a + change[i][0]; int b2 = b +
		 * change[i][1]; if ((a2 >= 0 && a2 < n) && (b2 >= 0 && b2 < n)) { if
		 * (vis[a2][b2] == 0) { if ((map[a2][b2] == 0) || (map[a2][b2] != 0 &&
		 * map[a2][b2] > map[a][b] + 1)) { vis[a2][b2] = 1; map[a2][b2] = map[a][b] + 1;
		 * dfs(a2, b2); vis[a2][b2] = 0; } } } }
		 */
		// 数据量太大，递归会使栈溢出，所以使用队列来做
		Queue<int[]> store = new LinkedList<>();
		int[] pair = { a, b };
		store.add(pair);// 添加起始点
		while (store.size() != 0) {
			int[] temp = store.remove();// 取出队尾并删除
			for (int i = 0; i < 4; i++) {
				// 计算下一个点的位置
				int a2 = temp[0] + change[i][0];
				int b2 = temp[1] + change[i][1];
				if (a2 < 0 || a2 > n - 1 || b2 < 0 || b2 > n - 1)// 判断越界
					continue;
				if (map[a2][b2] != 0)// 判断是否已经走过
					continue;
				if (vis[a2][b2] == 1)// 判断是不是地雷
					continue;
				map[a2][b2] = map[temp[0]][temp[1]] + 1;// 符合条件的话，该位置的步数就等于前一个位置步数+1
				int[] pair2 = { a2, b2 };
				store.add(pair2);// 把这个新的位置放入队列
			}
		}

	}
}

提交结果：

如果大佬有什么优化的方法，麻烦指教指教，蟹蟹！