Acwing 1096. 地牢大师 BFS 细节满满 Java

⭐ 地牢大师


输入样例

3 4 5
S....
.###.
.##..
###.#

#####
#####
##.##
##...

#####
#####
#.###
####E

1 3 3
S##
#E#
###

0 0 0

输出样列

Escaped in 11 minute(s).
Trapped!

---

⭐ BFS: O(n)

⭐ 友情提示

🤬 pinrtf 和 println 的输出回车
🤬 好马不吃回头草，走过的路要做标记
🤬 多组数据 记得 初始化 重复使用的 数组

import java.io.*;
import java.util.*;

public class Main
{
	static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

	static int N = 120, l, r, c;
	static char[][][] a = new char[N][N][N];// 记录地图
	static int[][][] dist = new int[N][N][N];// 距离
	static Node[] q = new Node[N * N * N+100];
//	偏移量数组
	static int[] dx = { 1, -1, 0, 0, 0, 0 };
	static int[] dy = { 0, 0, 1, -1, 0, 0 };
	static int[] dz = { 0, 0, 0, 0, 1, -1 };

	static class Node
	{
		int x;
		int y;
		int z;

		public Node(int x, int y, int z)
		{
			super();
			this.x = x;
			this.y = y;
			this.z = z;
		}
	}

	public static void main(String[] args) throws IOException
	{
		while (true)
		{
			String[] ss = in.readLine().split(" ");
			l = Integer.parseInt(ss[0]);
			r = Integer.parseInt(ss[1]);
			c = Integer.parseInt(ss[2]);
//			结束标志
			if (l == 0 && r == 0 && c == 0)
				break;

//			每一次都初始化
			for (int i = 0; i < N; i++)
				for (int j = 0; j < N; j++)
					for (int k = 0; k < N; k++)
					{
						a[i][j][k] = '#';
						dist[i][j][k] = 0;
					}
			Node start = null;
			Node end = null;

			for (int i = 1; i <= l; i++)// 层
			{
				for (int j = 1; j <= r; j++)// 行
				{
					String s = in.readLine();// 每次读一行
					for (int k = 1; k <= c; k++)// 列
					{
						a[i][j][k] = s.charAt(k - 1);// 第 i 层 第 j 行 第 k 列
						if (a[i][j][k] == 'S')
							start = new Node(i, j, k);
						if (a[i][j][k] == 'E')
							end = new Node(i, j, k);
					}
				}
				in.readLine();// 吃掉换行
			}

			int res = bfs(start, end);
			if (res == -1)
				System.out.println("Trapped!");// 回车问题
			else
			{
				System.out.printf("Escaped in %d minute(s).\n", res);// 回车问题
			}

		}

	}

	private static int bfs(Node start, Node end)
	{

		int hh = 0;
		int tt = -1;
		q[++tt] = start;

//		因为只走  .  一种情况，所以起点 S 也不需要去重
//		int x = start.x;
//		int y = start.y;
//		int z = start.z;
//
//		dist[x][y][z] = '#'; 

		while (hh <= tt)
		{
			Node n = q[hh++];// 队头出队
			int x = n.x;
			int y = n.y;
			int z = n.z;

			for (int i = 0; i < 6; i++)
			{
				int xx = x + dx[i];
				int yy = y + dy[i];
				int zz = z + dz[i];
//				地图全部初始化成 墙 之后就不需要 特判了
				// if (xx < 1 || xx > l || yy < 1 || yy > r || zz < 1 || zz > c)
				// 	continue;
				if (a[xx][yy][zz] == '.')
				{
					q[++tt] = new Node(xx, yy, zz);
					dist[xx][yy][zz] = dist[x][y][z] + 1;
				// 	走完记得标记一下，好马不吃回头草
					a[xx][yy][zz] = '#';
				}
				if (a[xx][yy][zz] == 'E')
					return dist[x][y][z] + 1;
			}
		}
		return -1;
	}
}