蓝桥杯 JAVA 学霸的迷宫

问题描述

　　学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。

输入格式

　　第一行两个整数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。

思路

BFS宽搜。DFS和BFS没有好坏之分，只是在不同问题的背景的应用下可能有些差异。总体上来说DFS适合求连通性问题，而BFS由于是一层一层的探索点，更适合有目的地求最短路径问题。

本题中，求二维数组左上角和右上角之间的最短路径问题，所有采取BFS方法。题目中还要求，如果有多条最短路径，输出字典序最小的路径。

深入了解BFS可以知道，第一次到达终点的时候，也就是最短的路径！为了简便（因为BFS记录路径真的有点麻烦），把四个方向首先进行字典序排序{'D','L','R','U'}。这样子在第一次到达终点时的路径必然是字典序最小的路径。

代码

import java.util.*;
public class 学霸的迷宫 {
    static int n,m;
    static char[][] map;//存储迷宫数值
    static boolean[][] vis;//记录该点是否放入到队列中
    static char[] dir= new char[]{'D','L','R','U'};//四个方向的字典序
    static int[] dirx=new int[]{1,0,0,-1};
    static int[] diry=new int[]{0,-1,1,0};
    static String ans="";//记录答案
    static int length=Integer.MAX_VALUE;
    static Queue<node> q=new LinkedList<node>();
    
    public static void bfs(char[][] map) {
        while(!q.isEmpty()) {
            node top=q.poll();
            int nowx=top.x;
            int nowy=top.y;
            if(nowx==n-1 && nowy==m-1) {            
                ans=top.s;
                length=ans.length();
                return;
            }
            //对当前点进行四个方向的探索，如果符合条件存入队列中
            for(int i=0;i<4;i++) {
                int newx=nowx+dirx[i];
                int newy=nowy+diry[i];
                if(newx>=0 && newx<n && newy>=0 && newy<m && vis[newx][newy]==false && map[newx][newy]!='1') {
                    node temp=new node(newx,newy);
                    temp.s=top.s;
                    temp.s+=dir[i];
                    q.add(temp);
                    vis[newx][newy]=true;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scan=new Scanner(System.in);
        n=scan.nextInt();
        m=scan.nextInt();
        scan.nextLine();//吃掉第一行剩下的字符!
        map=new char[n+1][m+1];
        vis=new boolean[n+1][m+1];
        for(int i=0;i<n;i++) {
            map[i]=scan.nextLine().toCharArray(); 
        }
        vis[0][0]=true;
        q.add(new node(0,0));
        bfs(map);
        System.out.println(length);
        System.out.println(ans);
    }
    
    //结点类
    public static class node{
        public node(int i, int j) {
            x=i;
            y=j;
        }
        int x,y;
        String s="";
    }
}