【无标题】

问题描述

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

输入格式

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

广搜 加字典序，考虑到字典序，UP/DOWN/LEFT/RIGHT，上下左右，依次遍历访问的顺序是DLRU，否则会输出的不是字典序最小的结果

下面代码是我参考了这个链接改的蓝桥杯-学霸的迷宫（BFS+记录操作） - 叶梨子 - 博客园算法提高 学霸的迷宫 时间限制：1.0s 内存限制：256.0MB 问题描述 学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二https://www.cnblogs.com/pearfl/p/10733166.html（该链接中的代码没有按照字典序最小输出）

#include
using namespace std;

struct node {
    int x;
    int y;
    int cnt;//记录当前已行走数 
    int dir;//记录 到达 此位置走的方向 
    int far;//记录父亲的值 

}que[2501];

int nextt[4][3] = { //字典序DLRU
    {1, 0, 'D'},//下D  
    {0, -1, 'L'},//左L  
    {0, 1, 'R'},//右R  
    {-1, 0, 'U'}//上U  
};
char mapp[501][501], path[2500] = "";//mapp输入的数据，path路径
int book[501][501] = { 0 };//标记数组
int n, m, head = 1, tail = 1, flag = 0, tx, ty, i, j;

int main()
{
    cin >> n >> m;
    for (i = 0; i < n; i++) {
        cin >> mapp[i];
    }

    //初始化
    que[tail].x = 1;
    que[tail].y = 1;
    que[tail].cnt = 0;
    que[tail].far = 0;
    tail++;//加1
    book[1][1] = 1;//标记
    //

    while (head < tail) {
        if (flag) {
            break;
        }

        for (i = 0; i < 4; i++) {
            //模板
            tx = que[head].x + nextt[i][0];//走的方向依次是上下左右
            ty = que[head].y + nextt[i][1];

            if (tx < 1 || ty < 1 || tx > n || ty > m) {//越界了
                continue;
            }
            //

            if (book[tx][ty] == 0 && mapp[tx - 1][ty - 1] == '0') {//没走过，且，可以走
                book[tx][ty] = 1;//标记

                que[tail].x = tx;//更新
                que[tail].y = ty;

                que[tail].cnt = que[head].cnt + 1;//计数加1
                que[tail].dir = nextt[i][2];//方向
                que[tail].far = head;//父节点的序号是head- -根据head可以得到父节点的信息
                tail++;
            }

            if (tx == n && ty == m) {//到达终点
                flag = 1;
                break;
            }
        }
        head++;//更新head
    }

    i = tail - 1;
    j = 0;
    while (que[i].far != 0) {
        path[j++] = que[i].dir;
        i = que[i].far;
    }

    //输出结果   --倒序输出path才是我们要的结果
    printf("%d\n", que[tail - 1].cnt);
    for (j--; j >= 0; j--) {
        printf("%c", path[j]);
    }

    return 0;
}

 

当控制输入迷宫数据的数组行下标从1开始，列下标从1开始，代码如下

#include 
using namespace std;
struct node {
	int x;
	int y;//坐标
	int far;//记录前一个点序号
	int dir;//记录走到该(x,y)点的方向
	int cnt;//记录走到当前点(x,y)一共走了多少步
}que[2505];
int dir[6][4] = {//DLRU
	{1,0,'D'},//D
	{0,-1,'L'},//L
	{0,1,'R'},//R
	{-1,0,'U'}//U
};
char mapp[505][505], path[2505] = "";
int book[505][505];
int n, m, tx, ty, flag = 0, head = 1, tail = 1, i, j;
int main() {
	cin >> n >> m;
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			cin >> mapp[i][j];
		}
		
	}
	que[tail].x = 1;
	que[tail].y = 1;
	que[tail].far = 0;
	que[tail].cnt = 0;
	tail++;
	book[1][1] = 1;
	while (head < tail) {
		if (flag) {
			break;
		}
		for (i = 0; i < 4; i++) {//依次DLRU走
			tx = que[head].x + dir[i][0];
			ty = que[head].y + dir[i][1];
			if (tx<1 || tx>n || ty<1 || ty>m) {
				continue;
			}
			if (book[tx][ty] == 0 && mapp[tx][ty] == '0') {//没走过且可以走
				que[tail].x = tx;
				que[tail].y = ty;
				que[tail].far = head;
				que[tail].dir = dir[i][2];
				que[tail].cnt = que[head].cnt + 1;
				book[tx][ty] = 1;
				tail++;
			}
			if (tx == n && ty == m) {
				flag = 1;
				break;
			}
		}
		head++;
	}
	//路径
	i = tail - 1;
	j = 1;
	while (que[i].far != 0) {
		path[j++] = que[i].dir;
		i = que[i].far;
	}
	//result
	cout << que[tail - 1].cnt << endl;
	for (j--; j > 0; j--) {
		cout << path[j];
	}
	return 0;
}

  当控制输入的迷宫数据的行下标和列下标都从1开始，代码如下

 

#include 
using namespace std;
struct node {
	int x;
	int y;//坐标
	int far;//记录前一个点序号
	int dir;//记录走到该(x,y)点的方向
	int cnt;//记录走到当前点(x,y)一共走了多少步
}que[2505];
int dir[6][4] = {//DLRU
	{1,0,'D'},//D
	{0,-1,'L'},//L
	{0,1,'R'},//R
	{-1,0,'U'}//U
};
char mapp[505][505], path[2505] = "";
int book[505][505];
int n, m, tx, ty, flag = 0, head = 1, tail = 1, i, j;
int main() {
	cin >> n >> m;
	for (i = 1; i <= n; i++) {
		cin >> mapp[i];
	}
	que[tail].x = 1;
	que[tail].y = 1;
	que[tail].far = 0;
	que[tail].cnt = 0;
	tail++;
	book[1][1] = 1;
	while (head < tail) {
		if (flag) {
			break;
		}
		for (i = 0; i < 4; i++) {//依次DLRU走
			tx = que[head].x + dir[i][0];
			ty = que[head].y + dir[i][1];
			if (tx<1 || tx>n || ty<1 || ty>m) {
				continue;
			}
			if (book[tx][ty] == 0 && mapp[tx][ty - 1] == '0') {//没走过且可以走
				que[tail].x = tx;
				que[tail].y = ty;
				que[tail].far = head;
				que[tail].dir = dir[i][2];
				que[tail].cnt = que[head].cnt + 1;
				book[tx][ty] = 1;
				tail++;
			}
			if (tx == n && ty == m) {
				flag = 1;
				break;
			}
		}
		head++;
	}
	//路径
	i = tail - 1;
	j = 1;
	while (que[i].far != 0) {
		path[j++] = que[i].dir;
		i = que[i].far;
	}
	//result
	cout << que[tail - 1].cnt << endl;
	for (j--; j > 0; j--) {
		cout << path[j];
	}
	return 0;
}