学霸的迷宫
原创
问题描述
学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。
输入格式
第一行两个整数n， m，为迷宫的长宽。
接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。
接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。
输出格式
第一行一个数为需要的最少步数K。
第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。
第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。
样例输入
Input Sample 1:
3 3
001
100
110
Input Sample 2:
3 3
000
000
000
3 3
001
100
110
Input Sample 2:
3 3
000
000
000
样例输出
Output Sample 1:
4
RDRD
Output Sample 2:
4
DDRR
4
RDRD
Output Sample 2:
4
DDRR
数据规模和约定
有20%的数据满足：1<=n,m<=10
有50%的数据满足：1<=n,m<=50
有100%的数据满足：1<=n,m<=500。
有50%的数据满足：1<=n,m<=50
有100%的数据满足：1<=n,m<=500。
此题用BFS和DFS都能得出结果，但是用DFS会超时，用BFS一旦找到迷宫出口，即可确定最短路径，
而DFS搜索出每一条可达路径，然后需要比较步数才能确定最短路径，官网也明确提示用广搜解答。
下面说说BFS解答。
此题有两大难点：
一、字典序的比较，即使确定了最短路径的步数，像题目所说，也许存在多条同样步数的最短路径，
我们需要进行字典序比较，然后选出一条字典序最小的，实现并不困难，但是用BFS搜索存在一个重大的
隐患——隐藏了某些路径，我们知道BFS是不用回溯的，不能回溯就导致了某些路径不能被实现，下面我
用题目的第二个例子说明一下：
3 3
000
000
000
000
000
000
假如我们的搜索方向按顺时针右、下、左、上，我们的搜索顺序是这样的：
x.j表示第x步可以到达，在x步到达之内，按照顺时针顺序，此点是第j个被访问的。
最终我们可以有两条路径可以到达终点，即RRDD和RDDR(请大家按照进出顺时针进出队列的顺序自己查照)，
发现其他路径DDRR和RDRD等会被省略掉，这是因为那些点已经被访问过，不能重复访问，BFS只负责找到最
短路径，省略了某些最短路径后不可能得出每次都得出正确结果；题目要求字典序最小，其实按照DLRU的访
问顺序就能在到达终点时确定字典序最小的最短路径了。
二、路径的存储，路径的存储可以另外开辟一个迷宫大小的二维数组，到达每一个点，存储这个点的上
一个点到这个点的方向(UDRL其中一个)，这样当到达终点时，可以逆序输出最短路径，逆序排序后输出即可。
import java.util.*; public class Main { static int n; //行 static int m; //列 static char maze[][]; //迷宫 static int que_x[]; //横坐标 static int que_y[]; //纵坐标 static char udlr[][]; static int book[][]; //标记 static int dir[][]= { {1,0},{0,-1},{0,1},{-1,0} }; //方向数组DLRU static int step[][]; //存储步数 static int result_step; static int flag=0; static int head=0; //头指针 static int tail=0; //尾指针 static char way[]; //存储路径 static char d_way[]; //中转路径 static void judge_dir(int dx,int dy) { //判断上一步到这一步需要向哪个方向走 //右 if(dx-que_x[head]==0 && dy-que_y[head]==1) { udlr[dx][dy]='R'; } //左 if(dx-que_x[head]==0 && dy-que_y[head]==-1) { udlr[dx][dy]='L'; } //上 if(dx-que_x[head]==-1 && dy-que_y[head]==0) { udlr[dx][dy]='U'; } //下 if(dx-que_x[head]==1 && dy-que_y[head]==0) { udlr[dx][dy]='D'; } } static void find_way(int dx,int dy,int count) { //寻找路径 if(dx==0 && dy==0) { //数组逆序存放于dd_way for(int i=0;i<way.length;i++) { way[i]=d_way[ d_way.length-(i+1) ]; } return; } d_way[count]=udlr[dx][dy]; if(d_way[count]=='U') { //上 find_way(dx+1,dy,count+1); } if(d_way[count]=='R') { //右 find_way(dx,dy-1,count+1); } if(d_way[count]=='D') { //下 find_way(dx-1,dy,count+1); } if(d_way[count]=='L') { //左 find_way(dx,dy+1,count+1); } } public static void main(String[] args) { Scanner reader=new Scanner(System.in); n=reader.nextInt(); m=reader.nextInt(); maze=new char[n][m]; //编号从0开始 udlr=new char[n][m]; //记录四个方向 book=new int[n][m]; step=new int[n][m]; que_x=new int[n*m]; que_y=new int[n*m]; //迷宫赋值 for(int i=0;i<n;i++) { String ss=reader.next(); maze[i]=ss.toCharArray(); } for(int i=0;i<n;i++) { for(int j=0;j<m;j++) { book[i][j]=0; step[i][j]=0; } } book[0][0]=1; //起点 //初始位置入队列 que_x[tail]=0; que_y[tail]=0; tail++; while(head<tail) { for(int i=0;i<4;i++) { int dx=que_x[head]+dir[i][0]; int dy=que_y[head]+dir[i][1]; if(dx<0 || dx>n-1 || dy<0 || dy>m-1) { //越界判断 continue; } if(maze[dx][dy]=='0' && book[dx][dy]==0) { //入队列 que_x[tail]=dx; que_y[tail]=dy; book[dx][dy]=1; tail++; //计算步数 step[dx][dy]=step[ que_x[head] ][ que_y[head] ]+1; //存储方向信息 judge_dir(dx,dy); } //判断终点 if(dx==n-1 && dy==m-1) { //先到步数肯定最少，直接存储结果 result_step=step[dx][dy]; //开辟存放路径空间 way=new char[result_step]; d_way=new char[result_step]; find_way(dx,dy,0); flag=1; } } if(flag==1) { break; } head++; } System.out.println(step[n-1][m-1]); for(int i=0;i<result_step;i++) { System.out.print(way[i]); } } }
DFS(超时)
import java.util.*; public class 学霸的迷宫dfs { static int n; static int m; static char maze[][]; //迷宫 static int book[][]; //标记 static int dir[][]= { {1,0},{0,-1},{0,1},{-1,0} }; //方向 static int min_step=999999999; //最小步数 static char way[][]; //存储方向 static char result_way[]; //存储路径 static char d_way[]; //中转路径 static void find_way(int x,int y,int count) { //倒退寻找路径 //所有路径的首结点为(0,0) if(x==0 && y==0) { return; } d_way[count]=way[x][y]; if(way[x][y]=='R') { //右 find_way(x,y-1,count+1); } if(way[x][y]=='D') { //下 find_way(x-1,y,count+1); } if(way[x][y]=='L') { //左 find_way(x,y+1,count+1); } if(way[x][y]=='U') { //上 find_way(x+1,y,count+1); } } static void dfs(int x,int y,int step) { //step代表步数 //步数超越 if(step>min_step) { return; } //出口判断 if(x==n-1 && y==m-1) { if(step<min_step) { min_step=step; //更新步数 //存储路径 find_way(x,y,0); //结果存储 for(int i=0;i<min_step;i++) { result_way[i]=d_way[ min_step-(i+1) ]; } } } for(int i=0;i<4;i++) { int dx=x+dir[i][0]; int dy=y+dir[i][1]; //越界判断 if(dx<0 || dx>n-1 || dy<0 || dy>m-1) { continue; } //障碍点和访问判断 if(maze[dx][dy]=='1' || book[dx][dy]==1) { continue; } //(x,y)到(dx,dy)的方向判断 if(i==0) { way[dx][dy]='D'; } if(i==1) { way[dx][dy]='L'; } if(i==2) { way[dx][dy]='R'; } if(i==3) { way[dx][dy]='U'; } book[dx][dy]=1; dfs(dx,dy,step+1); book[dx][dy]=0; //回溯 } } public static void main(String[] args) { Scanner reader=new Scanner(System.in); n=reader.nextInt(); m=reader.nextInt(); maze=new char[n][m]; book=new int[n][m]; way=new char[n][m]; result_way=new char[n*m]; d_way=new char[n*m]; for(int i=0;i<n;i++) { String ss=reader.next(); maze[i]=ss.toCharArray(); } for(int i=0;i<n;i++) { for(int j=0;j<m;j++) { book[i][j]=0; } } book[0][0]=1; dfs(0,0,0); //起点(0,0) System.out.println(min_step); for(int i=0;i<min_step;i++) { System.out.print(result_way[i]); } } }
14:01:10
2018-08-02
