蓝桥杯学霸的迷宫

题目描述

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

输入描述

第一行两个整数n， m，为迷宫的行与列。
接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在（n,m）。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。

输出描述

第一行一个数为需要的最少步数K。
第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。

样例

输入

3 3
001
100
110

输出

4
RDRD

题解

此题用BFS和DFS都能得出结果，但是用DFS会超时，用BFS一旦找到迷宫出口，即可确定最短路径，

而DFS搜索出每一条可达路径，然后需要比较步数才能确定最短路径，官网也明确提示用广搜解答。

　　下面说说BFS解答。

　　此题有两大难点：

　　一、字典序的比较，即使确定了最短路径的步数，像题目所说，也许存在多条同样步数的最短路径，

我们需要进行字典序比较，然后选出一条字典序最小的，实现并不困难，但是用BFS搜索存在一个重大的

隐患——隐藏了某些路径，我们知道BFS是不用回溯的，不能回溯就导致了某些路径不能被实现，下面我

用题目的第二个例子说明一下：

3 3
000
000
000

假如我们的搜索方向按顺时针右、下、左、上，我们的搜索顺序是这样的：

x.j表示第x步可以到达，在x步到达之内，按照顺时针顺序，此点是第j个被访问的。

最终我们可以有两条路径可以到达终点，即RRDD和RDDR(请大家按照进出顺时针进出队列的顺序自己查照)，

发现其他路径DDRR和RDRD等会被省略掉，这是因为那些点已经被访问过，不能重复访问，BFS只负责找到最

短路径，省略了某些最短路径后不可能得出每次都得出正确结果；题目要求字典序最小，其实按照DLRU的访

问顺序就能在到达终点时确定字典序最小的最短路径了。

　　二、路径的存储，路径的存储可以另外开辟一个迷宫大小的二维数组，到达每一个点，存储这个点的上

一个点到这个点的方向(UDRL其中一个)，这样当到达终点时，可以逆序输出最短路径，逆序排序后输出即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define NUM 505
int arr[NUM][NUM];
int m,n;
char dir_c[5] = {'U','D','L','R'};
int dir[5][2] = {
    {-1,0},  
    {1,0}, 
    {0,-1}, 
    {0,1}   
};
struct Node
{
    int x;
    int y;
    int num_step;
    string step;
    Node(int i,int j){
        x = i;
        y = j;
        num_step = 0;
        step = "";
    }
};
string ans;
int num_ans;
int is_finish = 0;
int check(Node tmp)
{
    int i = tmp.x;
    int j = tmp.y;
    if(i < 1 || j < 1){
        return 0;
    }
    if(i > m || j > n){
        return 0;
    }
    if(1 == arr[i][j]){
        return 0;
    }
    return 1;
}
int bfs()
{
    queue<Node> Q_node;
    Node start(1,1);
    Node tmp(0,0);
    Q_node.push(start);
    while(false == Q_node.empty()){
        Node now = Q_node.front();
        Q_node.pop();
        if(now.x == m && now.y == n){
            is_finish = 1;
            num_ans = now.num_step;
            if("" == ans){
                ans = now.step;
            }else{
                if(ans > now.step){
                    ans = now.step;
                }
            }
            continue;
        }
         if(is_finish){
            if(now.num_step > num_ans){
                continue;
            }
        }
 
        for(int i = 0; i < 4; i++){
            tmp.x = now.x+dir[i][0];
            tmp.y = now.y+dir[i][1];
            tmp.step = now.step + dir_c[i];
            tmp.num_step = now.num_step + 1;
 
            if(check(tmp)){
                Q_node.push(tmp);
                arr[tmp.x][tmp.y] = 1;
            }
        }
    }
    return 0;
}
int main()
{
    scanf("%d%d",&m,&n);
    for(int i = 1; i <= m; i++){
        for(int j = 1; j <= n; j++){
            scanf("%1d",&arr[i][j]);
        }
    }
 
    bfs();
 
    printf("%d\n%s\n",num_ans,ans.c_str());
    return 0;
}

　　最后，请大家一定要

蓝桥杯 学霸的迷宫

猜你喜欢

蓝桥杯学霸的迷宫