深度优先搜索（DFS）求解迷宫问题

最新推荐文章于 2024-09-28 23:00:16 发布

原创

最新推荐文章于 2024-09-28 23:00:16 发布 · 1.4k 阅读

7 ·

CC 4.0 BY-SA版权

本文介绍了如何运用深度优先搜索（DFS）算法来解决迷宫问题，并提供了相关代码实现。对于不熟悉DFS的读者，文章提供了讨论的机会。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目来源：计蒜客递归课程基础题
题目描述:

        给一个n行m列的2维的迷宫，'S'表示迷宫的起点，'T'表示迷宫的终点，'#'表示不能通过的点，'.' 表示可以通过的点。
你需要从'S'出发走到'T'，每次只能上下左右走动，并且只能进入能通过的点，每个点只能通过一次。现在要求你求出有多少种通过迷宫的的方案。
输入格式
    第一行输入n,m(1≤n,m≤10)表示迷宫大小。接下来输入n 行字符串表示迷宫。
输出格式
    输出通过迷宫的方法数。

样例输入
    2 3
    S.#
    ..T
样例输出
    2

比较典型的DFS题目，直接上代码。有不懂的地方欢迎讨论。

#include<iostream>
#include<cstdio>
using namespace std;
int n,m;
char Maze[10][10];
int Flag[10][10];
int ways;
void find_enter(int &x,int &

最低0.47元/天解锁文章

200万优质内容无限畅学

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

Neo_kh

关注关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

DFS：关于迷宫问题的深搜解法

qq_51412063的博客

12-09

468

DFS：关于迷宫问题的深搜解法 DFS初入门（） 深度优先搜索（缩写DFS）有点类似广度优先搜索，也是对一个连通图进行遍历的算法。它的思想是从一个顶点V0开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。（重要的是要有边界条件，递归前进段和递归返回段。边界条件不满足则递归前进，反之被返回） 2.深度优先搜索VS广度优先搜索 2.1演示深度优先搜索的过程还是引用上篇文章的样例图，起点仍然是V0，我们修改一下题目意思，

【算法＋城堡问题、迷宫问题】BFS（广度优先）和DFS（深度优先）

2302_82116250的博客

12-22

2050

判断顶点1是否被访问，如未访问过，就见标记数组中顶点1对应的值改为true，将顶点1入队，再判断顶点2是否被访问，重复上述操作，将2入队。再通过矩阵找到顶点1的邻接顶点0、3，顶点0的访问标记数组为true，说明被访问则不再重复访问，继续判断3是否被访问过，未访问就将标记数组的值改为true，将3入队，队列不为空则将队头元素2出队。首先访问节点0，将数组0对应的位置改为true，表示已经访问过，再将顶点0进行入队操作，再判断队列是否为空（当前有顶点0不为空），将队列的对头元素0进行出队。

参与评论您还未登录，请先登录后发表或查看评论

DFS深搜解决迷宫问题

我写写哈的博客

04-02

413

/* 读入一个m行n列的数组，其中1表示空地，2表示障碍物； //从起始点走到终点距离最短是多少，要求给出起始点和终点坐标。 5 4 1 1 2 1 1 1 1 1 1 1 2 1 1 2 1 1 1 1 1 2 1 1 4 3 */ // (x-1,y) // (x,y-1) (x,y) (x,y+1) // (x+1,y) #include<iostream> using namespace std; int m,n,p,q,mins=999999999..

深度优先搜索（DFS)解决迷宫问题

m0_52759155的博客

03-27

918

深度优先搜索解决迷宫问题定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 #include<stdio.h> int a[1

利用图的深度优先搜索解决迷宫问题

qq_41409120的博客

12-07

3446

总体思路是：从（1，1）出发，分四个方向深度优先搜索，将访问过的点的访问标志置为3，如果从当前点出发无法找到出口，则将该点的访问标志置为2。输出结果是如果标志为3的就输出L，其他标志的就输出2，这样就能很清楚的看到从入口到出口的路径了完整代码如下： /* 利用图的深度优先搜索解决迷宫问题 */ #define N 10 int maze[N][N] = {{0}, {0, 0, 0, 0,...

【算法详解 | DFS算法】深度优先搜索解走迷宫问题 | 深度优先图遍历

热门推荐

来都来了，点篇看看吧（=

11-09

1万+

本文将会详细讲解如何使用DFS算法解决走迷宫问题，一篇文章秒杀所有难点！内容简单直观，我家盆栽看完都学会了！

C语言使用深度优先搜索算法解决迷宫问题(堆栈)

08-29

深度优先搜索（Depth-First Search，DFS）是一种常用的搜索算法，它可以解决迷宫问题。在迷宫问题中，我们需要从起点出发，找到到达终点的路径。C语言可以使用堆栈来实现深度优先搜索算法，以解决迷宫问题。深度...

广度优先搜索构建迷宫（BFS算法）动态构建过程_深度优先算法时间复杂度

11-23

**深度优先搜索（DFS）**是另一种搜索策略，与BFS不同的是，它深入探索每一个分支直至尽头，然后再回溯。DFS在迷宫生成中也有应用，特别是在解决迷宫问题时，但其不保证生成的路径是最短的。在时间复杂度方面，BFS...

《数据结构与算法》《经典算法的设计与实现》成都信息工程大学dfs深度优先迷宫求解静态迷宫动态生成迷宫图形界面可视化c++

01-03

开发语言：C++ ...核心算法：1.DFS深度优先算法 2.递归算法数据结构：栈文件包含内容：1.开题报告 2.设计报告 3.结题报告 4..cpp文件 5..exe文件 6.开题ppet 7.结题ppt 8.程序运行需要加载的图片

【图计算算法‌】深度优先搜索（DFS）算法

大雨的博客

09-28

4682

深度优先搜索算法（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。该算法沿着树的深度遍历树的节点，尽可能深地搜索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点，这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为新的源节点并重复以上过程，直到所有节点都被访问为止。

深度优先搜索（dfs）以迷宫为例

weixin_73118927的博客

12-26

522

面对一个多分支多选择的问题时，如果你要找出所有的可能性，所有的解法，所有的路径，你就需要把每一个分支每一个选择都尝试一遍。这种情况，就可以考虑使用dfs。给定一个 N \times MN×M 方格的迷宫，迷宫里有 TT 处障碍，障碍处不可通过。在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方案。第一行为三个正整数 N,M,TN,M,T，分别表示迷宫的长宽和障碍总数。

深度优先搜索DFS——迷宫解救

Jayphone17的博客

10-23

446

1.问题分析有一天同学B到独自一人到迷宫玩，方向感不好的B同学果不其然在迷宫中迷路，现在同学A要去解救B同学。迷宫由n行m列的单元格组成，每个单元格要么是空地，要么是障碍物。任务就是帮助同学A找到一条从迷宫起点通往同学B的最短路径。注意，障碍物是不可以移走的，当然同学A也是不能走到地图之外。 2.算法设计（1）：首先我们可以用一个二维数组来存储这个迷宫，刚开始迷宫的入口在（...

深度优先迷宫求解实例(C)

zhouyifeng98的博客

11-16

792

//maze.h #define RIGHT 0 #define DOWN 1 #define LEFT 2 #define UP 3 typedef struct Position{ //位置 int x; //行 int y; //列 }Position; //顺时针从右开始寻找临近位置，返回该临近位置 Position NextPos(Position now, i

迷宫问题的DFS

jhjjhj的AC之梦

09-09

655

这道题我还是觉得bfs简单，可是这货居然DFS也能解，Orz之余，学习学习...... 文章转自http://www.2cto.com/kf/201308/235681.html POJ 3984 迷宫问题 (DFS(深度优先搜索)) 迷宫问题 Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 6322

迷宫问题dfs

qq_52172364的博客

02-04

363

J. 迷宫问题(migong) [ Problem 1737 ] [ Discussion ] Description 设有一个N∗N(2≤N<10)方格的迷宫，入口和出口分别在左上角和右上角。迷宫格子中分别放0和1，0表示可通，1表示不能，入口和出口处肯定是0。迷宫走的规则如下所示：即从某点开始，有八个方向可走，前进方格中数字为0时表示可通过，为1时表示不可通过，要另找路径。找出所有从入口（左上角）到出口（右上角）的路径(不能重复)，输出路径总数，如果无法到达，则输出0。 Samples Inpu

迷宫问题（dfs）

CXHAO1的博客

02-17

847

给出一个n*m的迷宫，其中标记为1的为障碍，标记为0的为可以通行的地方。迷宫的入口为左上角，出口为右下角，只能从一个位置走到这个它的上、下、左、右四个方向之一。如果能顺利走出迷宫就输出YES，否则输出NO 输入输出 YES 2 2 0 1 1 0 #include <iostream> using namespace std; int n,m; int a[505][505]; bool f=false; int fx[5]={0,0,1,0,-1}; int f...

迷宫问题（dfs）

05-07

1183

定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。输入：一个5...

深度优先搜索求解迷宫问题

最新发布

06-27

### 实现深度优先搜索算法解决迷宫问题的方法 #### 迷宫问题的表示在计算机科学中，迷宫问题通常被建模为一个二维网格，其中某些单元格是可通行的（例如用 `0` 表示），而另一些单元格是障碍物或墙壁（例如用 `1` 表示）。目标是从起点出发，找到一条通往终点的路径。一般情况下，起点设为左上角 `(0, 0)`，终点设为右下角 `(n-1, m-1)`，其中 `n` 和 `m` 分别表示迷宫的行数和列数 [^4]。 #### 深度优先搜索算法（DFS）的基本思路 深度优先搜索是一种递归算法，它从起始节点开始，沿着某一个方向尽可能深入地探索，直到无法继续前进（如遇到墙壁或已访问过的路径）时回溯，并尝试其他方向。该过程会持续到找到目标节点或者所有可能的路径都被尝试过为止 [^2]。在迷宫问题中，DFS 的实现步骤如下： 1. **定义方向**：通常有四个方向可供移动——上、下、左、右。 2. **标记已访问的位置**：为了避免重复访问同一个位置，需要维护一个二维数组来记录每个单元格是否已经被访问过。 3. **递归探索**：对于当前位置 `(x, y)`，依次尝试向四个方向移动。如果新位置 `(new_x, new_y)` 在迷宫范围内且未被访问过，则进入该位置并继续递归搜索。 4. **终止条件**：当到达终点时返回成功；如果所有方向都无法继续前进，则回溯至上一位置 [^3]。 #### Python 实现代码以下是一个使用深度优先搜索算法解决迷宫问题的 Python 示例代码： ```python def is_valid(x, y, maze, visited): """ 检查 (x, y) 是否在迷宫范围内且可以通行。 """ n = len(maze) m = len(maze[0]) return 0 <= x < n and 0 <= y < m and maze[x][y] == 0 and not visited[x][y] def dfs_maze_solver(maze, start_x, start_y, end_x, end_y, visited, path): """ 使用 DFS 解决迷宫问题。 """ # 如果当前位置是终点，返回 True 表示找到路径 if start_x == end_x and start_y == end_y: path.append((start_x, start_y)) return True # 标记当前单元格为已访问 visited[start_x][start_y] = True path.append((start_x, start_y)) # 定义四个方向：上、右、下、左 directions = [(-1, 0), (0, 1), (1, 0), (0, -1)] for dx, dy in directions: new_x = start_x + dx new_y = start_y + dy if is_valid(new_x, new_y, maze, visited): if dfs_maze_solver(maze, new_x, new_y, end_x, end_y, visited, path): return True # 如果没有找到有效路径，回溯 path.pop() return False def solve_maze(maze, start=(0, 0), end=None): """ 主函数：调用 DFS 并输出路径。 """ n = len(maze) m = len(maze[0]) if n > 0 else 0 if end is None: end = (n - 1, m - 1) visited = [[False for _ in range(m)] for _ in range(n)] path = [] if dfs_maze_solver(maze, start[0], start[1], end[0], end[1], visited, path): print("找到路径:", path) else: print("无法找到路径") # 示例迷宫 maze = [ [0, 1, 0, 0, 0], [0, 1, 0, 1, 0], [0, 0, 0, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0] ] solve_maze(maze) ``` #### 代码说明 - `is_valid()` 函数用于检查新的坐标是否合法且可通行。 - `dfs_maze_solver()` 是核心递归函数，负责进行深度优先搜索。 - `path` 列表用于存储最终的路径。 - `visited` 数组用于防止重复访问。 - 最终通过 `solve_maze()` 调用整个流程，并输出结果 [^4]。 #### 时间复杂度与空间复杂度 - **时间复杂度**：最坏情况下，DFS 需要遍历整个迷宫的所有单元格，因此时间复杂度为 O(n × m)，其中 `n` 和 `m` 分别是迷宫的行数和列数。 - **空间复杂度**：由于需要额外的空间来保存 `visited` 数组以及递归栈，空间复杂度也为 O(n × m) [^2]。 ---