算法提高 学霸的迷宫（经典 Bfs）

试题 算法提高 学霸的迷宫

资源限制
时间限制：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。

AC代码如下

注意pre[] 数组存储结点的前驱信息，只记录前驱到达该结点是URDL的哪一个，这样我们就可以从终点一步一步找到起点了。
为了满足字典序最小的，每次bfs扩展的方向是DLRU即可。

#include<bits/stdc++.h>
using namespace std;

const int MAXN = 501;
const int dir[4][2] = { {1,0},{0,-1},{0,1},{-1,0} };
const char alp[5] = "DLRU";
char G[MAXN][MAXN];			//存储图的信息
bool vis[MAXN][MAXN];		//是否访问
int pre[MAXN][MAXN];		//点的前驱
int dis[MAXN][MAXN];		//到起点的距离
int n, m;
typedef pair<int, int> P;

void bfs() {
	queue<P> Q;
	Q.push(P(1, 1));
	dis[1][1] = 0;
	vis[1][1] = 1;

	while (!Q.empty()) {
		int r, c;
		r = Q.front().first;
		c = Q.front().second;
		Q.pop();
		if (r == n && c == m)		//到达终点
			break;
		for (int i = 0; i < 4; i++) {
			int newr, newc;
			newr = r + dir[i][0];
			newc = c + dir[i][1];
			if (G[newr][newc] == '1')	//不可走
				continue;
			if (newc<1 || newc>m || newr<1 || newr>n)	//出界
				continue;
			if (!vis[newr][newc]) {
				vis[newr][newc] = 1;
				dis[newr][newc] = dis[r][c] + 1;
				pre[newr][newc] = i;
				Q.push(P(newr, newc));
			}
		}
	}

}

void get_ans(int r,int c) {		//递归求解
	if (r == 1 && c == 1)
		return;
	get_ans(r - dir[pre[r][c]][0], c - dir[pre[r][c]][1]);
	printf("%c", alp[pre[r][c]]);
}
int main() {
	for (int i = 0; i < MAXN; i++)
		for(int j=0;j<MAXN;j++)
			dis[i][j] = 1e8;
	memset(vis, 0, sizeof(vis));

	scanf("%d%d", &n, &m);
	getchar();
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++)
			scanf("%c", &G[i][j]);
		getchar();
	}

	bfs();

	printf("%d\n", dis[n][m]);
	get_ans(n,m);
	return 0;
}

…可以做一个struct，把dis，vis等数组省去，如下：

struct node{
	char c;
	int dis;
	bool vis;
	int pre;
};

还有一个思路
从终点往起点bfs，然后不用pre记录前驱，bfs之后，只要从起点开始，往四个方向找，如果满足新的dis是之前的dis减1，那么就重新以这个结点为当前结点，直到终点。

PS. 编者曾为了省去pair<int,int>，把二维数组利用哈希函数映射到一维，也就是

int hash(int r,intc){	//因为n最大为500
	return r*501+c;
}
	使用时只需要
	v=hash(r,c);
	r=v/501; c=v%501;

但是，这样哈希映射需要耗时，一来一去，导致只能通过80%。