学霸的迷宫（BFS）（路径存储）

问题描述
　　学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。
输入格式
　　第一行两个整数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。
　　
　　这个是一个经典的宽搜（Broad Frist Search）题目，宽搜的常见的稍微高一点要求的就有保留路径，这道题便是如此，宽搜的标配是队列（queue）这个数据结构，路径的保留则还需要栈（stack），因为需要从尾部（tail）开始，一直得到头部信息，根据题目的不同需求自己也需要设计一个类（结构），来存储（指向）上一个位置的信息，这里题目还要求从最小字典顺序，那么对于一个位置搜索到周围的位置也是需要一点点细节（只要注意顺序就行）
　

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

public class Main 
{   static int a[][];
    static int b[][]={{-1,0},{1,0},{0,-1},{0,1}};//这个顺序是不能随便调换的，是为了满足字典顺序的需求
    public static void main(String[]agrs)
    {       
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        a=new int[n][m];
        for(int i=0;i        {
            String s=sc.next();
            for(int j=0;j                a[i][j]=s.charAt(j)-'0';
        }//输入细节就不多讲了
        Queue
 queue=new LinkedList<>();//创建队列
        queue.add(new P(0,0,null,'n'));//加入起点，P这个类的信息见最下面
        a[0][0]=1;//置1说明不可访问；
        boolean sign=true;
        P tail=null;//指向终点
        while(!queue.isEmpty()&&sign)
        {
            P p=queue.poll();//出一个头节点
            int x=p.x;
            int y=p.y;
            for(int i=0;i<4;i++)
            {
                int x1=x+b[i][0];
                int y1=y+b[i][1];
                if(x1<0||x1>=n||y1<0||y1>=m||a[x1][y1]==1)
                    continue;//排除所有不合法的搜索位置
                a[x1][y1]=1;//这个要注意
                queue.add(new P(x1,y1,p,get(i)));
                //x1，y1即为这点的位置信息，p即指向上一个节点，get(i)即为由p到当前点的方向
                if(x1==n-1&&y1==m-1)//如果找到终点点，则终止搜索
                {
                    tail=new P(x1,y1,p,get(i));//tail的作用
                    sign=false;//终止标志
                    break;退出子循环
                }

            }
        }
        queue=null;
        Stack
 stack=new Stack<>();
        P p=tail;
        while(p.last!=null)//从tail开始一个一个开始入栈；如果p.last为null则说明已经到了起点
        {
            stack.push(p);
            p=p.last;
        }
        System.out.println(stack.size());
        while(!stack.isEmpty())
        {
            System.out.print(stack.pop().d);//依次出栈即可
        }
    }
    static char get(int index)//满足字典顺序要求
    {
        switch(index)
        {
        case 0:return 'U';
        case 1:return 'D';
        case 2:return 'L';
        case 3:return 'R';
        }
        return ' ';
    }
}
class P//实质上就是一个链表的node
{
    int x;
    int y;
    P last;//指向上一个位置，学c的可以看成是指针
    char d;//记录由上一个为到到当前位置的转向
    P(int x,int y,P last,char d)
    {
        this.x=x;
        this.y=y;
        this.last=last;
        this.d=d;
    }
}