蓝桥杯_迷宫与陷阱 java

题目描述

小明在玩一款迷宫游戏，在游戏中他要控制自己的角色离开一间由 N×N 个格子组成的 2D 迷宫。

小明的起始位置在左上角，他需要到达右下角的格子才能离开迷宫。

每一步，他可以移动到上下左右相邻的格子中（前提是目标格子可以经过）。

迷宫中有些格子小明可以经过，我们用 '.' 表示。

有些格子是墙壁，小明不能经过，我们用 '#' 表示。

此外，有些格子上有陷阱，我们用 'X' 表示。除非小明处于无敌状态，否则不能经过。

有些格子上有无敌道具，我们用 '%' 表示。

当小明第一次到达该格子时，自动获得无敌状态，无敌状态会持续 K 步。

之后如果再次到达该格子不会获得无敌状态了。

处于无敌状态时，可以经过有陷阱的格子，但是不会拆除/毁坏陷阱，即陷阱仍会阻止没有无敌状态的角色经过。

给定迷宫，请你计算小明最少经过几步可以离开迷宫?

输入描述

输入描述

第一行包含两个整数 N,K (1≤N≤1000,1≤K≤10)。

以下 N 行包含一个 N×N 的矩阵。

矩阵保证左上角和右下角是 '.'。

输出描述

一个整数表示答案。如果小明不能离开迷宫，输出 -1。

输入输出样例

示例

输入

5 3
...XX
##%#.
...#.
.###.
.....

输出

10

运行限制

• 最大运行时间：3s

• 最大运行内存: 256M

代码:

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class 迷宫与陷阱 {

    static int n;
    static int k;
    static char[][] map;
    static boolean[][][] vis;//第三维表示道具状态
    static int[][] dir = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        k = scanner.nextInt();
        map = new char[n][n];
        vis = new boolean[n][n][k + 1];//包括 k
        for (int i = 0; i < n; i++) {
            map[i] = scanner.next().toCharArray();
        }
        bfs();
    }

    public static void bfs() {
        Queue<walk> queue = new LinkedList<>();
        queue.offer(new walk(0, 0, 0, 0));
        vis[0][0][0] = true;
        while (!queue.isEmpty()) {
            walk now = queue.poll();//取队首
            //出口
            if (now.x == n - 1 && now.y == n - 1) {
                System.out.println(now.step);
                return;
            }
            for (int i = 0; i < 4; i++) {
                int x = now.x + dir[i][0];
                int y = now.y + dir[i][1];
                int z = now.k;//当前道具所剩余的步数
                
                //判断边界和墙
                if (x < 0 || x > n - 1 || y < 0 || y > n - 1 || vis[x][y][z] == true || map[x][y] == '#'
                        || (map[x][y] == 'X' && z == 0)) {
                    continue;
                }
                if (map[x][y] == 'X') {
                    if (z > 0) {
                        vis[x][y][z] = true;
                        queue.offer(new walk(x, y, now.step + 1, z - 1));
                    }
                } else if (map[x][y] == '%') {
                    vis[x][y][z] = true;
                    queue.offer(new walk(x, y, now.step + 1, k));
                    map[x][y] = '.';
                } else {
                    vis[x][y][z] = true;
                    queue.offer(new walk(x, y, now.step + 1, z > 0 ? z - 1 : 0));
                }
            }
        }
    }
}

class walk {
    int x;
    int y;
    int step;
    int k;

    public walk(int x, int y, int step, int k) {
        super();
        this.x = x;
        this.y = y;
        this.step = step;
        this.k = k;
    }
}