[Java] 蓝桥杯ADV-147 算法提高学霸的迷宫

问题描述
学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。
输入格式
第一行两个整数n， m，为迷宫的长宽。
接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。
输出格式
第一行一个数为需要的最少步数K。
第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。
样例输入
Input Sample 1:
3 3
001
100
110
Input Sample 2:
3 3
000
000
000
样例输出
Output Sample 1:
4
RDRD
Output Sample 2:
4
DDRR
数据规模和约定
有20%的数据满足：1<=n,m<=10
有50%的数据满足：1<=n,m<=50
有100%的数据满足：1<=n,m<=500。

package adv147;

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

public class Main {

    public static int isVisited[][];

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        char[][] maze = new char[n][m];
        isVisited = new int[n][m];
        for (int i = 0; i < n; i++) {
            maze[i] = in.next().toCharArray();
        }
        in.close();

        Queue queue = new LinkedList<>();
        queue.add(new Index(0, 0));
        Index e = new Index(n-1, m-1);
        isVisited[0][0] = 1;
        bfs(maze, queue, e);
        printPath(n-1, m-1, n, m);
    }

    public static void bfs(char[][] maze, Queue q, Index e) {
        Queue queue = new LinkedList<>();

        while (!q.isEmpty()) {
            Index s = q.poll();

            if (s.equals(e)) {
                System.out.println(isVisited[s.r][s.l] - 1);
                return;
            }

            // Down
            if (s.r + 1 <= e.r && isVisited[s.r + 1][s.l] == 0 && maze[s.r+1][s.l] == '0') { queue.add(new Index(s.r + 1, s.l)); isVisited[s.r+1][s.l] = isVisited[s.r][s.l] + 1; } // Left if (s.l >= 1 && isVisited[s.r][s.l - 1] == 0 && maze[s.r][s.l - 1] == '0') {
                queue.add(new Index(s.r, s.l - 1));
                isVisited[s.r][s.l - 1] = isVisited[s.r][s.l] + 1;
            }

            // Right
            if (s.l + 1 <= e.l && isVisited[s.r][s.l + 1] == 0 && maze[s.r][s.l + 1] == '0') { queue.add(new Index(s.r, s.l+1)); isVisited[s.r][s.l + 1] = isVisited[s.r][s.l] + 1; } // Up if (s.r >= 1 && isVisited[s.r - 1][s.l] == 0 && maze[s.r - 1][s.l] == '0') {
                queue.add(new Index(s.r - 1, s.l));
                isVisited[s.r - 1][s.l] = isVisited[s.r][s.l] + 1;
            }
        }

        bfs(maze, queue, e);
    }

    public static void printPath(int r, int l, int n, int m) {
        if (r == 0 && l == 0) {
            return;
        }

        if (r+1 < n && isVisited[r][l] - 1 == isVisited[r+1][l]) { // Down printPath(r+1, l, n, m); System.out.print("U"); } else if (l>=1 && isVisited[r][l] - 1 == isVisited[r][l-1]) {
            // Left
            printPath(r,l-1, n, m);
            System.out.print("R");
        } else if (l +1 < m && isVisited[r][l] - 1 == isVisited[r][l+1]) { // Right printPath(r, l+1, n, m); System.out.print("L"); } else if (r >= 1 && isVisited[r][l] - 1 == isVisited[r-1][l]) {
            // Up
            printPath(r-1, l, n, m);
            System.out.print("D");
        }
    }


}

class Index {
    int r;
    int l;

    public Index (int r, int l) {
        this.r = r;
        this.l = l;
    }

    public boolean equals(Index e) {
        return r == e.r && l == e.l;
    }

}

package adv147;

import java.util.LinkedList;

import java.util.Queue;

import java.util.Scanner;

public class Main {

public static int isVisited[][];

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

int m = in.nextInt();

char[][] maze = new char[n][m];

isVisited = new int[n][m];

for (int i = 0; i < n; i++) {

maze[i] = in.next().toCharArray();

}

in.close();

Queue queue = new LinkedList<>();

queue.add(new Index(0, 0));

Index e = new Index(n-1, m-1);

isVisited[0][0] = 1;

bfs(maze, queue, e);

printPath(n-1, m-1, n, m);

}

public static void bfs(char[][] maze, Queue q, Index e) {

Queue queue = new LinkedList<>();

while (!q.isEmpty()) {

Index s = q.poll();

if (s.equals(e)) {

System.out.println(isVisited[s.r][s.l] - 1);

return;

}

// Down

if (s.r + 1 <= e.r && isVisited[s.r + 1][s.l] == 0 && maze[s.r+1][s.l] == '0') { queue.add(new Index(s.r + 1, s.l)); isVisited[s.r+1][s.l] = isVisited[s.r][s.l] + 1; } // Left if (s.l >= 1 && isVisited[s.r][s.l - 1] == 0 && maze[s.r][s.l - 1] == '0') {

queue.add(new Index(s.r, s.l - 1));

isVisited[s.r][s.l - 1] = isVisited[s.r][s.l] + 1;

}

// Right

if (s.l + 1 <= e.l && isVisited[s.r][s.l + 1] == 0 && maze[s.r][s.l + 1] == '0') { queue.add(new Index(s.r, s.l+1)); isVisited[s.r][s.l + 1] = isVisited[s.r][s.l] + 1; } // Up if (s.r >= 1 && isVisited[s.r - 1][s.l] == 0 && maze[s.r - 1][s.l] == '0') {

queue.add(new Index(s.r - 1, s.l));

isVisited[s.r - 1][s.l] = isVisited[s.r][s.l] + 1;

}

bfs(maze, queue, e);

}

public static void printPath(int r, int l, int n, int m) {

if (r == 0 && l == 0) {

return;

}

if (r+1 < n && isVisited[r][l] - 1 == isVisited[r+1][l]) { // Down printPath(r+1, l, n, m); System.out.print("U"); } else if (l>=1 && isVisited[r][l] - 1 == isVisited[r][l-1]) {

// Left

printPath(r,l-1, n, m);

System.out.print("R");

} else if (l +1 < m && isVisited[r][l] - 1 == isVisited[r][l+1]) { // Right printPath(r, l+1, n, m); System.out.print("L"); } else if (r >= 1 && isVisited[r][l] - 1 == isVisited[r-1][l]) {

// Up

printPath(r-1, l, n, m);

System.out.print("D");

}

class Index {

int r;

int l;

public Index (int r, int l) {

this.r = r;

this.l = l;

}

public boolean equals(Index e) {

return r == e.r && l == e.l;

}

❤ 点击这里 -> 订阅《PAT | 蓝桥 | LeetCode学习路径 & 刷题经验》by 柳婼

❤ 点击这里 -> 订阅《从放弃C语言到使用C++刷算法的简明教程》by 柳婼

❤ 点击这里 -> 订阅PAT甲级乙级、蓝桥杯、GPLT天梯赛、LeetCode题解离线版