蓝桥杯 BFS 迷宫

最新推荐文章于 2025-12-04 22:00:44 发布
原创 最新推荐文章于 2025-12-04 22:00:44 发布 · 352 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #java #bfs #队列 #数据结构

蓝桥杯迷宫

本题为2019年省赛B组E题
要求按字典序 打印轨迹

问题描述
下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。
（如果你把以下文字复制到文本文件中，请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt， 内容与下面的文本相同）
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个字符串，包含四种字母 D、U、L、R，在提交答案时只填写这个字符串，填 写多余的内容将无法得分
运行结果

代码实现

//注意用DFS会爆栈
public class Main {
    //注意dir于d的对应关系
    //向下则行数加一，列数不变！！！！！
    static int[][] dir = { { 1, 0 }, { 0, -1 }, { 0, 1 }, { -1, 0 } };
    static char[] d = { 'D', 'L', 'R', 'U' };//题目要求字典序
    //数据为maze.txt中数据
    static int[][] map = {
            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
            { 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0,
                    0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0 },
            { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
                    1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1 },
            { 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0,
                    0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
            { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0,
                    1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1 },
            { 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0,
                    0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
            { 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                    1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
            { 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
                    0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 },
            { 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1,
                    1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0 },
            { 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
                    0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1 },
            { 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
                    0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0 },
            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0,
                    0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1 },
            { 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1,
                    0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0 },
            { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0,
                    0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1 },
            { 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1,
                    1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0 },
            { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0,
                    0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1 },
            { 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0,
                    1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
            { 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
                    0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1 },
            { 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0,
                    1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1 },
            { 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0,
                    0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0 },
            { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0,
                    1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1 },
            { 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1,
                    0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1 },
            { 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
                    1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1 },
            { 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1,
                    0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0 },
            { 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0,
                    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
            { 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0,
                    1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0 },
            { 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
                    1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1 },
            { 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0,
                    1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
            { 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0,
                    1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0 },
            { 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0,
                    0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1 },
            { 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
                    1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0 }

    };
    static boolean[][] vis = new boolean[35][55];

    public static void main(String[] args) {
        bfs(1, 1, 0, "");//从1，1开始（注意下标从零开始）
    }

    public static void bfs(int x, int y, int num, String s) {
        LinkedList<Node> q = new LinkedList<Node>();//创建队列
        q.addFirst(new Node(x, y, num, s));//加入该点
        vis[x][y] = true;//标记为真
        while (q.size() != 0) {
            Node tmp = q.getFirst();
            q.removeFirst();
            if (tmp.x == 30 && tmp.y == 50) {//到终点了，由于是队列，所以是最小步数
                System.out.println(tmp.step);//打印步数
                System.out.println(tmp.s);//打印轨迹
                return;//找到了就可以直接return了
            }
            for (int i = 0; i < dir.length; i++) {
                int dx = tmp.x + dir[i][0];
                int dy = tmp.y + dir[i][1];
                if (dx > 0 && dx <= 30 && dy > 0 && dy <= 50 && !vis[dx][dy] && map[dx][dy] == 0) {
                    vis[dx][dy] = true;
                    q.addLast(new Node(dx, dy, tmp.step + 1, tmp.s + d[i]));
                }
            }
        }
    }
}

class Node {
    int x;//x坐标
    int y;//y坐标
    int step;//步数
    String s;//轨迹
    Node(int x, int y, int step, String s) {
        this.step = step;
        this.x = x;
        this.y = y;
        this.s = s;
    }
}

代码思路，编辑格式不易，大家觉得还可以可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，https://motongxue.gitee.io

Motongxue
关注
第十届蓝桥杯 E走迷宫(BFS)
coral_1的博客
05-15 1348
思路 我相信能查到这儿的伙伴一定已经看过了题目了，那就开门见山，谈谈这题的思路。在考场上，我第一想法是用DFS，尝试了一下，没有跑出来，以为DFS用的隐式的栈，所以无法直接跑出答案。回来后，我用BFS尝试了一下，成功解出了答案。代码和注释如下。 #include<queue> #include<windows.h> #include<iostream> usin...
迷宫[蓝桥杯2019初赛]
qq_45738497的博客
04-07 1027
题目描述 下图给出了一个迷宫的平面图，其中标记为1 的为障碍，标记为0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共10 步。其中D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请
2014蓝桥杯:地宫取宝（DFS详解）
gl620321的博客
03-21 992
八、题目;地宫取宝 问题描述 　　X 国王有一个地宫宝库。是 n x m 个格子的矩阵。每个格子放一件宝贝。每个宝贝贴着价值标签。 地宫的入口在左上角，出口在右下角。 小明被带到地宫的入口，国王要求他只能向右或向下行走。 走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。 当小明走到出口时，如果他手中的宝贝恰好是k件，则这些宝贝就可以送给小明...
[蓝桥杯2019初赛]迷宫-DFS、BFS两种方法
lifehappy
02-02 7228
迷宫问题的最短路，加最小字典序 迷宫文件maze.txt传送门 . . . dfs的版本 #include<iostream> #include<cstring> using namespace std; const int ax[4]={0,0,1,-1}; const int ay[4]={1,-1,0,0}; const char dir[5]={'R','L','...
广度优先搜索 基础例题合集
dx666888999的博客
10-15 797
高桥买酒 #include<iostream> #include<queue> using namespace std; char map[501][501]; int n,m; int flag=1; int vis[501][501]={0}; int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; //上 下 左 右 struct node{ int x;int y; }; void bfs(int x,int y){ queue
蓝桥杯 BFS 迷宫寻宝
⭐君子以自强不息
03-07 401
问题描述 Problem Description 洪尼玛今天准备去寻宝，在一个n*n （n行, n列）的迷宫中，存在着一个入口、一些墙壁以及一个宝藏。由于迷宫是四连通的，即在迷宫中的一个位置，只能走到与它直接相邻的其他四个位置（上、下、左、右）。现洪尼玛在迷宫的入口处，问他最少需要走几步才能拿到宝藏？若永远无法拿到宝藏，则输出-1。 Input 多组测试数据。 每组数据输入第一行为正整数n，表示迷宫大小。 接下来n行，每行包括n个字符，其中字符'.'表示该位置为空地，字符'#'表示该位置为墙壁，
蓝桥杯——迷宫(BFS)
qq_33880925的博客
03-16 1031
【代码】蓝桥杯——迷宫(BFS)
bfs 蓝桥杯 迷宫 python
weixin_52596361的博客
04-05 500
蓝桥杯 经典bfs 迷宫
蓝桥杯—走迷宫(BFS算法)
2301_79724394的博客
03-09 712
G 的每个格子要么是道路，要么是障碍物（道路用 11表示，障碍物用 0 表示）。已知迷宫的入口位置为 (x1​,y1​)，出口位置为 (x2​,y2​)。问从入口走到出口，最少要走多少个格子。接下来输入一个 𝑁×𝑀N×M 的矩阵。若 Gi,j​=1 表示其为道路，否则表示其为障碍物。最后一行输入四个整数 𝑥1,𝑦1,𝑥2,𝑦2表示入口的位置和出口的位置。输入第 11 行包含两个正整数 N,M，分别表示迷宫的大小。输出仅一行，包含一个整数表示答案。若无法从入口到出口，则输出 −1；
蓝桥杯每日一题 走迷宫bfs 超超详细解释！！！
yf743909的博客
03-12 1628
昨天学习了bfs的基本概念，今天来做一道经典习题练练手吧！
蓝桥杯——一篇搞懂广度优先搜索（BFS）
m0_47963315的博客
03-21 4973
大家好，我是璐画 📒博客主页：璐画的个人主页 🎉欢迎关注🔎点赞👍收藏⭐️留言📝 📌本文由璐画原创，优快云首发！ 📆首发时间：🌴2022年3月21日🌴 ✉️坚持下去的，都是因为热爱吧！ 💭参考书籍：📚《labuladong的算法小抄》 💬参考在线编程网站：🌐牛客网🌐力扣 🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！ 特别声明：本文我是学习过labuladong大佬的书然后总结出来的文章，这位大佬在csdn上好像没有账号，想学习的小伙伴可以买大佬那本《labuladong的算法小抄》
蓝桥杯1216——走迷宫（python）
Gyy1314521的博客
02-07 1794
使用BFS算法（广度优先搜索）解决走迷宫问题（无权图的最短路径问题）
蓝桥杯真题 迷宫 c++代码实现 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、
七宫智音小天使的博客
01-23 2357
文章目录题目描述结果代码思路 题目描述 本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R分别表示向下、向上、向左、向右走。 对
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 146
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
【模式识别与机器学习（8）】主要算法与技术（下篇：高级模型与集成方法）之 元学习与集成方法：组合多个学习器来提高整体性能
hiliang521的博客
12-02 801
【模式识别与机器学习（8）】主要算法与技术（下篇：高级模型与集成方法）之 元学习
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 724
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
dfs|mask^翻转
一个人知道自己为什么而活，他就能够接收任何一种生活
11-30 165
注意到：灯泡状态周期是6。
2025年全国大学生统计科学与算法编程挑战赛——算法赛道（一）
qq_73044452的博客
12-01 290
摘要：本文包含三个编程问题的解决方案。1) 贪吃蛇问题：通过解析移动指令计算蛇最终所在格子的编号；2) 经济小鱼问题：计算前两局存钱、后两局花钱，最终剩余指定金币的方案数；3) 小理吃甜食问题：模拟多轮糖果挑选过程，计算小理获得的最大总糖果值。每个问题都给出了完整的C++实现代码，涉及字符串处理、数学计算和模拟算法等技术。
【剑斩OFFER】算法的暴力美学——数青蛙
最新发布
就业知识博客
12-04 266
力扣1419题：数青蛙
蓝桥杯 bfs python
03-25
### 关于蓝桥杯竞赛中的广度优先搜索（BFS） 在蓝桥杯竞赛中，广度优先搜索（BFS）是一种常用的方法用于解决最短路径问题。它通过逐层扩展的方式探索图结构，能够有效地找到从起始点到目标点的最短路径[^1]。 以下是基于 Python 的 BFS 实现方法及其解题思路： #### 解题思路 为了实现 BFS 来解决问题，通常需要以下几个核心部分： - **队列**：用来存储当前正在处理的节点以及其相关信息。 - **标记数组/集合**：防止重复访问已经遍历过的节点，从而提高效率并避免死循环。 - **距离记录**：保存每个节点到起点的距离信息，以便最终返回最短路径长度。 具体来说，可以通过以下方式构建解决方案： - 初始化一个队列并将初始状态加入其中； - 使用 while 循环不断取出队首元素进行分析直到达到目的地为止； - 对每一个弹出的状态尝试所有可行的操作，并把新产生的合法状态推入队尾继续考察； 下面给出一段通用版本的 Python 代码示例来展示如何利用 BFS 寻找迷宫类题目中最短行走步数的情况。 #### 示例代码 ```python from collections import deque def bfs(start, end, grid): rows, cols = len(grid), len(grid[0]) # Directions array representing possible moves (up, down, left, right). directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] visited = [[False]*cols for _ in range(rows)] # Visited matrix. queue = deque([(start[0], start[1], 0)]) # Queue with initial position and distance. while queue: x, y, dist = queue.popleft() if (x, y) == end: # If we reach the destination, return dist # Return current distance as shortest path length. for dx, dy in directions: # Explore all four neighbors of this cell. nx, ny = x + dx, y + dy if 0<=nx<rows and 0<=ny<cols and not visited[nx][ny] and grid[nx][ny]==0: visited[nx][ny]=True # Mark neighbor node as visited. queue.append((nx, ny, dist+1)) # Add it to our exploration list along with updated cost/distance value. return -1 # No valid route found between 'start' & 'end'. # Example usage: grid = [ [0, 1, 0], [0, 0, 1], [0, 0, 0] ] print(bfs((0, 0), (2, 2), grid)) ``` 此函数接受三个参数——`start`(源坐标)， `end`(目的坐标) 和 `grid`(表示地图布局的一个二维列表) 。 它首先定义了一个方向向量(directions)，该变量包含了四个基本移动操作(上、下、左、右); 接着创建了一个布尔型矩阵visited[][],用以跟踪哪些位置已经被探查过; 最后初始化好数据结构之后进入主要逻辑流程即while loop内部执行标准bfs过程直至满足条件退出或穷尽全部可能性仍无果则报错[-1]. #### 结论 上述例子展示了怎样运用 python 编程语言配合 bfs 技巧快速定位两点间最优通路方案之一。值得注意的是实际比赛当中可能会遇到更加复杂的情形比如障碍物形状不规则等等因此建议多加练习熟悉各种变形模式下的应对策略[^2]。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值