蓝桥杯13届真题-回忆迷宫（模拟、BFS）

前言

本题为蓝桥杯第13届JavaB组省赛真题，分值为20分。

标签：模拟、BFS

• 模拟：模拟构建地图。
• BFS：数组队列来bfs二维矩阵。

蓝桥杯第13届JavaB组省赛真题及题解可见博客：第十三届蓝桥杯省赛JavaB组真题（Java题解解析）

本题在线OJ平台：蓝桥杯官网在线OJ-回忆迷宫

题目

题解

思路

解法1思路：

其中模拟是根据走迷宫的过程来构建出最佳的一个行进路线，bfs则是对墙进行消除。

流程：

1、根据行进路线规划出最佳的矩阵宽高，并进行填充*。

2、确定出发位置来去模拟走一遍，走的过程中将矩阵四周边上的非墙点填充为空字符并进行扫描入队。

3、使用bfs将所有的空白点来进行消除墙体。

难点：对于想到模拟规划出最佳的矩阵宽度(提前先填充墙体)，在利用BFS去消除墙体。

解法1：模拟、BFS

复杂度分析：时间复杂度O(n²)；空间复杂度O(n²)

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    
    
    static final BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));
    static final int N = 110;
    static int n;
    static char[] arr;
    //确定矩阵的宽、高
    static int h, w;
    //定义方向
    static int[] dx = {
    
    0, 1, -1, 0};
    static int[] dy = {
    
    1, 0, 0, -1};
    //迷宫矩阵
    static char[][] g = new char[N][N];
    //墙标记矩阵，false表示不是，true表示是
    static boolean[][] isWall = new boolean[N][N];
    //队列
    static int[] q = new int[N * N];
    static int hh, tt;//队列头指针(出队)、队尾指针

    //标记目标点的上下左右都是墙
    public static void mark (int x, int y) {
    
    
        for (int d = 0; d < 4; d ++) {
    
    
            int xx = x + dx[d];
            int yy = y + dy[d];
            if (xx >= 1 && yy >= 1 && xx <= h && yy <= w) {
    
    
                isWall[xx][yy] = true;
            }
        }
    }

    //将二维点转为一个数字
    public static int get (int x, int y) {
    
    
        return x * (w + 1) + y;
    }

    public static void main(String[] args) throws Exception{
    
    
        n = Integer.parseInt(cin.readLine());
        arr = cin.readLine().toCharArray();
        //初始化矩阵(默认都是墙)
        for (int i = 1; i <= n + 3; i ++) {
    
    
            for (int j = 1; j <= n + 3; j ++) {
    
    
                g[i][j] = '*';
            }
        }
        //确定起始点（u nx-1  d nx+1  l ny-1  r ny+1）
        int nx = 0, ny = 0;
        //最大、最小宽高
        int maxX = 0, maxY = 0, minX = 0, minY = 0;
        for (int i = 0; i < n; i ++) {
    
    
            if (arr[i] == 'U') nx--;
            else if (arr[i] == 'L') ny--;
            else if (arr[i] == 'R') ny++;
            else nx++;
            maxX = Math.max(maxX, nx);
            minX = Math.min(minX, nx);
            maxY = Math.max(maxY, ny);
            minY = Math.min(minY, ny);
        }
        //确定矩阵大小（3表示最顶部、最底部有一个墙以及是从(1,1)开始的）
        h = maxX - minX + 3;
        w = maxY - minY + 3;
        //确定起始点
        nx = 2 - minX;
        ny = 2 - minY;

        //起点默认是为平地
        g[nx][ny] = ' ';
        mark(nx, ny);
        //开始进行绘制图
        for (int i = 0; i < n; i ++) {
    
    
            if (arr[i] == 'U') nx--;
            else if (arr[i] == 'D') nx ++;
            else if (arr[i] == 'L') ny --;
            else ny ++;
            //该地为空地
            g[nx][ny] = ' ';
            mark(nx, ny);
        }
        //开始从矩阵的最外围开始来进行消除元素
        for (int i = 1; i <= h; i ++) {
    
    
            for (int j = 1; j <= w; j ++) {
    
    
                //寻找四周非墙的
                if (isWall[i][j] == false && (i == 1 || j == 1 || i == h || j == w)) {
    
    
                    g[i][j] = ' ';
                    q[tt ++] = get(i, j);
                }
            }
        }
        //bfs
        while (hh < tt) {
    
    
            //出队
            int top = q[hh ++];
            //确定x、y点
            int x = top / (w + 1);
            int y = top % (w + 1);
            //四个方向
            for (int d = 0; d < 4; d ++) {
    
    
                int xx = x + dx[d];
                int yy = y + dy[d];
                if (xx >= 1 && yy >= 1 && xx <= h && yy <= w && g[xx][yy] =='*' && isWall[xx][yy] == false) {
    
    
                    g[xx][yy] = ' ';
                    q[tt ++] = get(xx, yy);
                }
            }
        }

        //最终去打印整个矩阵
        for (int i = 1; i <= h; i ++) {
    
    
            for (int j = 1; j <= w; j ++) {
    
    
                System.out.printf("%c", g[i][j]);
            }
            System.out.println();
        }
    }
}

参考资料

[1]. 蓝桥杯官网真题视频+文字解析