算法提高 学霸的迷宫

  算法提高 学霸的迷宫  

时间限制：1.0s   内存限制：256.0MB

    

问题描述

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

输入格式

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

借用原创作者思路，经典dfs算法+路径记录

#include<iostream>
#include<queue>
using namespace std;
struct Node{
	int x,y;
	int step;
}pre[501][501];
int ans=0;
int a[501][501];
int v[501][501]={0};

int n,m;
int dir[4][2]={1,0,0,-1,0,1,-1,0};//D-L-R-U 规律去探索最短路径.(因为最短路径要是字典最小的)
//这里已经用了贪心思维。每次在当前位置找下一个位置的去向，往往都从D开始然后到L-R-U，入队是从D入队，
//如果当前位置有多个地方可走，那么肯定是最小方向先入队，先入队的先探索原则，后入队的后探索，
//当前位置探索完之后，到下一个位置即队首，队首记录的是先入队的，所以先入队的位置先探索！
/*例1:	0011
        0001	
        0100
      	0000
	  最佳路径:DDDRRR,可相信简单的想一下，有一个水龙头在(1,1)的位置扭开，水首先充满下面，然后左右，再到上.
	  第二条路径也有但是它只进行到终点之前便因为最佳路径已经先快一步到达而结束.
	  RDRDR(D)在到达终点之前结束(D)是未完成的一步，如果这步先完成，那么这个路径比起最佳路径字典大！
  例2:	  0011
	  0001
	  0100
	  0010
	  最佳路径:DRRDRD 可便于理解分叉路思路，若当前位置可走有2个位置，即二分叉路口，先考虑可使得路径字典最小的走法
	  然后到达下一个位置之后依然存在分叉路，依然这样思考，直到遇到不存在分叉路，就返回前一个位置，直至到有分叉路的地方继续这样循环。
	  ps:当前位置可走情况为1~4,分叉路口即为可走情况。
*/     

bool check(int x,int y){
	if(x<1||x>n||y<1||y>m||a[x][y]||v[x][y])
		return false;
	return true;
}
void dfs(int bx,int by)
{
	queue<Node> Q;
	Node p;//当前位置
	Node next;//下一个位置
	p.x=bx;
	p.y=by;
	p.step=0;
	v[bx][by]=1;
	Q.push(p);
	while(!Q.empty()){
		p=Q.front();//取队首
		Q.pop();//队首出队
		int i;
		for(i=0;i<4;i++)//下左右上DLRU
		{
			next=p;
			next.x +=dir[i][0];
			next.y +=dir[i][1];
			next.step +=1;
			if(next.x ==n && next.y==m)
			{
				ans=next.step;
				pre[next.x][next.y].x=p.x;//记录路径 意思：pre[x][y]=当前位置(x,y)的前一个地方的位置.
				pre[next.x][next.y].y=p.y;
				return ;
			}
			if(check(next.x,next.y))//每一次判断下一个点是否可以进入
			{
				Q.push(next);		//将下一个点入队-(队尾)
				pre[next.x][next.y].x=p.x;//记录路径
				pre[next.x][next.y].y=p.y;
				v[next.x][next.y]=1;//将该点可访问标识变为1，表示不可访问.
			}
		}
	}
	ans = -1;//处理无法到达(n,m)的情况为-1 
}
void print_road(int x,int y)//递归找根，找到根的第二个点，进行当前位置与前一个位置比较判断是如何走! 然后输出
{
	if(pre[x][y].x==-1)//找到根之后，return,因为根没有前一个位置，无法进行比较而且不需要再向前探索.
		return ;		//return之后，到达第二个结点，与前一结点比较，逐渐到最后一个与前一结点比较得出路径.
	print_road(pre[x][y].x,pre[x][y].y);

	if(x==pre[x][y].x && y>pre[x][y].y)//前一个位置向右走动得到当前位置
	{
		cout<<"R";	
	}
	else if(x==pre[x][y].x && y<pre[x][y].y)//左
	{
		cout<<"L";	
	}
	else if(x>pre[x][y].x && y==pre[x][y].y)//下
	{
		cout<<"D";	
	}
	else if(x<pre[x][y].x && y==pre[x][y].y)//上
	{
		cout<<"U";	
	}
}
int main()
{
	cin>>n>>m;
	int i,j;
	char c[501][501];
	for(i=1;i<=n;i++)//先用char 二维数组c去保存输入数制
		cin>>c[i];
	for(i=1;i<=n;i++)//将c 转化为int 二维数组a
		for(j=1;j<=m;j++)
			a[i][j]=c[i][j-1]-'0';
	pre[1][1].x=pre[1][1].y=-1;
	dfs(1,1);
	cout<<ans<<endl;
	print_road(n,m);
	cout<<endl;
	return 0;
}