学霸的迷宫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题，但其中有几个小点需要注意：
1.输入的每行没有空格，所以要使用String读入，然后进行转化；
2.对于排序，只需要在bfs搜索过程中确定DLRU方向即可排序成功；
3.pre[][] 数组用来记录前驱路径，此处用方向表示，如D即代表当前节点是由前驱节点向下走形成的；
4.最后使用回溯法找寻记录的路径，这里注意先调用回溯函数，再记录pre[][]所代表的方向，否则就是倒着记录了；**

以下是java代码：

package bfs;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class 地图 {
    public static void main(String[] args) {
        Ts ts = new Ts();
    }
}
class Ts{
    int m;
    int n;
    int xount = 0;
    boolean[][] visited;
    StringBuffer sBuffer = new StringBuffer();
    int[][] pre;//记录前驱节点
    public Ts(){
        Scanner sca = new Scanner(System.in);
        m = sca.nextInt();
        n = sca.nextInt();
        visited = new boolean[m][n];
        pre = new int[m][n];
        for(int i=0;i<m;i++){//存墙,因为输入的数据之间没有空格
            String a = sca.next();
            for(int j=0;j<n;j++){
                visited[i][j] = a.charAt(j)=='1'?true:false;
            }
        }
        Queue<Integer> x = new LinkedList<Integer>();
        Queue<Integer> y = new LinkedList<Integer>();
        x.offer(0);
        y.offer(0);
        visited[0][0] = true;
        pre[0][0] = -1;
        while(!x.isEmpty()){
            int tx = x.poll();
            int ty = y.poll();
            int[][] d = {//设置好走的方向的顺序，下左右上DLRU,以达到排序的目的
                            {1, 0,0,-1},
                            {0,-1,1, 0}
                         };
            for(int i=0;i<4;i++){
                int dx = tx+d[0][i];
                int dy = ty+d[1][i];
                if(dx>=0&&dx<m&&dy>=0&&dy<n&&!visited[dx][dy]){
                    x.offer(dx);
                    y.offer(dy);
                    pre[dx][dy] = i;
                    visited[dx][dy] = true;
                }
            }
        }
        huisu(m-1, n-1);
        System.out.println(xount);
        System.out.println(sBuffer);
    }
    public void huisu(int x,int y){//回溯方法
        if(x==0&&y==0){
            return;
        }else{
            switch (pre[x][y]) {
            case 0:
                huisu(x-1, y);
                xount++;
                sBuffer.append("D");
                break;
            case 1:
                huisu(x, y+1);
                xount++;
                sBuffer.append("L");
                break;
            case 2:
                huisu(x, y-1);
                xount++;
                sBuffer.append("R");
                break;
            case 3:
                huisu(x+1, y);
                xount++;
                sBuffer.append("U");
                break;
            default:
                break;
            }
        }
    }
}