搜索之走迷宫问题

已于 2023-09-06 21:39:52 修改
阅读量147 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： c++ 算法 深度优先 广度优先
于 2023-09-03 16:54:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sblsf/article/details/132640657
版权
一个简单的迷宫

目录

介绍

概念

类型

判断是否可达

dfs实现

bfs实现

求最小步数

dfs实现

bfs实现

求一条可达路径

练习

 

介绍

在深搜和广搜中，有一类问题非常常见，就是走迷宫问题。

概念

迷宫问题是dfs和bfs的一种应用，一般形式为：一个主体（人，动物或者机器等）放在一个迷宫的入口处，迷宫里有许多墙，主体需要在不越过墙的前提下，走出迷宫

类型

迷宫问题一般有一下几种类型：

  1. 判断是否能到达终点
  2. 求最小步数
  3. 求一条可行路径

这类问题可以用dfs和bfs实现

判断是否可达

这类问题比较简单，可以枚举每一条路径，如果发现一条路径能到达终点，就可达。

如果没有路径能到终点，终点就是不可达的

dfs实现

伪代码：

read n,m
read maze[0...n-1][0...m-1]
flag <- false
read sx, sy, ex, ey
check(x, y){
  return x>=0 and x<n and y>=0 and y<m and maze[x][y]=0
}
dfs(x, y){
  if(flag=1) return
  maze[x][y] <- 1
  if(x=ex and y=ey){
    flag <- true
    return
  }
  nx[0...3]<-{x-1,x+1,x,x}
  ny[0...3]<-{y,y,y-1,y+1}
  for i <- 0 to 3 do{
    if call check(nx[i], ny[i]) = true then{
      call dfs(nx[i], ny[i])
  }
}
call dfs(x,y)
if flag=true then write "Yes"
else then write "No"

C++实现：

#include<iostream>
using namespace std;
int n, m;
const int N = 100;
int maze[N][N];  //迷宫，1代表墙，0代表空地
bool flag = false;
int ex, ey;  // 终点坐标
//检查(x,y)是否能走
bool check(int x, int y) {
	return x >= 0 && x < n&& y >= 0 && y < m&& maze[x][y] == 0;
}

// 当前已经走到(x,y)
void dfs(int x, int y) {
	if (flag) return;
	maze[x][y] = 1;  //已经走过，后面不能再走
	// 走到终点
	if (x == ex && y == ey) {
		flag = true;
		return;
	}
	// 所有可达点的坐标
	int nx[4] = { x - 1,x + 1,x,x };
	int ny[4] = { y,y,y - 1,y + 1 };
	for (int i = 0; i < 4; i++)
		if (check(nx[i], ny[i])) dfs(nx[i], ny[i]);
}


// 读入迷宫
void read() {
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++) cin >> maze[i][j];
}

int main() {
	int sx, sy;
	read();
	cin >> sx >> sy >> ex >> ey;
	dfs(sx, sy);
	cout << (flag ? "Yes" : "No") << endl;
	return 0;
}

bfs实现

用dfs实现的程序，数据一大，就可能栈溢出。

下面分享bfs的实现

伪代码:

read n,m
read maze[0..n-1][0...m-1]

q = new queue
push(x,y){
  q.push(x,y)
  maze[x][y] <- 1
}
check(x, y){
  return x>=0 and x<n and y>=0 and y<m and maze[x][y]=0
}
can_reach(sx,sy,ex,ey){
  push(x,y)
  repeat{
    t <- q.front
    q.pop
    next[0...3]={[t.x-1,t.y],[t.x+1,t.y],[t.x,t.y-1],[t.x,t.y+1]}
    for i = 0 to 3 do{
      if call check(next[i].x,next[i].y) call push(next[i].x,next[i].y)
      if(next[i].x=ex and next[i].y=ey) return true
    }
  }until q.empty
  return false
}
read sx,sy,ex,ey
if call can_reach(sx,sy,ex,ey) = true then write "Yes"
else then write "No"

C++实现:

#include<iostream>
#include<queue>
using namespace std;
int n, m;
const int N = 100;
int maze[N][N];  //迷宫，1代表墙，0代表空地
struct node {
	int x, y;
	node(int x, int y) :x(x), y(y) {}
};
queue<node> q;
// 点(x,y)入队
void push(int x, int y) {
	q.emplace(x, y);
	maze[x][y] = 1;
}
bool check(int x, int y) {
	return x >= 0 && x < n&& y >= 0 && y < m&& maze[x][y] == 0;
}
bool can_reach(int sx, int sy, int ex, int ey) {
	push(sx, sy);
	while (q.size()) {
		node t = q.front();
		q.pop();
		// 往四个方向扩展
		node next[4] = { node(t.x - 1,t.y),node(t.x + 1,t.y),node(t.x,t.y - 1),node(t.x,t.y + 1) };
		for (int i = 0; i < 4; i++)
			// 检查是否能到达
			if (check(next[i].x, next[i].y)) {
				push(next[i].x, next[i].y);  //入队
				//到达终点
				if (next[i].x == ex && next[i].y == ey) return true;
			}
	}
	return false;
}

int main() {
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++) cin >> maze[i][j];
	int ha, la, hb, lb;  //起点为(ha,la)，终点为(hb,lb)
	cin >> ha >> la >> hb >> lb;
	if (can_reach(ha, la, hb, lb)) cout << "yes" << endl;
	else cout << "no" << endl;
	return 0;
}

求最小步数

这类问题相当常见，输入n*m的迷宫，计算出给定两点的最小步数 

dfs实现

伪代码：

read n,m
read maze[0...n-1][0...m-1]
st[0...n-1][0...m-1] <- false
read sx, sy, ex, ey
ans <- inf
check(x, y){
  return x>=0 and x<n and y>=0 and y<m and maze[x][y]=0 and st[x][y]=false
}
dfs(x, y, step){
  if(x=ex and y=ey){
    ans = ans < step? ans: step
    return
  }
  nx[0...3]<-{x-1,x+1,x,x}
  ny[0...3]<-{y,y,y-1,y+1}
  for i <- 0 to 3 do{
    if call check(nx[i], ny[i]) = true then{
      st[nx[i]][ny[i]] <- true
      call dfs(nx[i], ny[i])
      st[nx[i]][ny[i]] <- false
  }
}
if maze[sx][sy]=1 then write "no path"
else then{
  call dfs(x,y)
  if ans=inf then write "no path"
  else write ans
}

c++:

#include<iostream>
#include<climits>
using namespace std;
int n, m;
const int N = 100;
int maze[N][N];  //迷宫，1代表墙，0代表空地
bool st[N][N];  // 标记数组
int sx, sy, ex, ey;
int ans = INT_MAX;
// 检查(x,y)是否能走
bool check(int x, int y) {
	return x >= 0 && x < n && y >= 0 && y < m&& maze[x][y] == 0 && !st[x][y];
}
// 当前在(x,y)上，已经走了step步
void dfs(int x, int y, int step) {
	if (x == ex && y == ey) ans = min(ans, step);
	else {
		int nx[4] = { x - 1,x + 1,x,x };
		int ny[4] = { y,y,y - 1,y + 1 };
		for (int i = 0; i < 4; i++)
			if (check(nx[i], ny[i])) {
				st[nx[i]][ny[i]] = true;
				dfs(nx[i], ny[i], step + 1);
				st[nx[i]][ny[i]] = false;
			}
	}
}

int main() {
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++) cin >> maze[i][j];
	cin >> sx >> sy >> ex >> ey;
    if(maze[sx][sy]==1) cout<<-1<<endl;
    else{
	    st[sx][sy] = true;  // 标记起点
	    dfs(sx, sy, 0);
	    if (ans != INT_MAX) cout << ans << endl;
	    else cout << -1 << endl;
    }
	return 0;
}

bfs实现

伪代码:

read n,m
read maze[0...n-1][0...m-1]
st[0...n-1][0...m-1] <- false

q = new queue
push(x,y,step){
  q.push(x,y,step)
  st[x][y] <- true
}
check(x, y){
  return x>=0 and x<n and y>=0 and y<m and maze[x][y]=0 and st[x][y]=false
}
min_step(sx,sy,ex,ey){
  if(maze[sx][sy]=1) return -1
  push(sx,sy,0)
  repeat{
    t <- q.front
    q.pop
    if(t.x=ex and t.y=ey) return t.step
    nx[0...3]<-{x-1,x+1,x,x}
    ny[0...3]<-{y,y,y-1,y+1}
    for i=0 to 3 do{
      if call check(nx[i],ny[i]) = true then push(nx[i],ny[i],t.step+1)
    }
  }until q.empty
}
read sx,sy,ex,ey;
write min_step(sx,sy,ex,ey)

c++:

#include<iostream>
#include<queue>
using namespace std;
int n, m;
const int N = 100;
int maze[N][N];  //迷宫，1代表墙，0代表空地
bool st[N][N];  // 标记数组
struct node {
	int x, y, step;
	node(int x, int y, int step) :x(x), y(y), step(step) {}
};
queue<node> q;
// 点(x,y)入队
void push(int x, int y, int step) {
	q.emplace(x, y, step);
	st[x][y] = true;
}
// 检查(x,y)是否能走
bool check(int x, int y) {
	return x >= 0 && x < n&& y >= 0 && y < m&& maze[x][y] == 0 && !st[x][y];
}
// 最小步数，无法到达返回-1
int min_step(int sx, int sy, int ex, int ey) {
	// 起点是障碍
	if (maze[sx][sy] == 1) return -1;
	push(sx, sy, 0); //起点入队
	while (q.size()) {
		node t = q.front();
		q.pop();
		// 到达终点，返回最小步数
		if (t.x == ex && t.y == ey) return t.step;
		// 向四个方向扩展
		int nx[4] = { t.x - 1,t.x + 1,t.x,t.x };
		int ny[4] = { t.y,t.y,t.y - 1,t.y + 1 };
		for (int i = 0; i < 4; i++)
			if (check(nx[i], ny[i])) push(nx[i], ny[i], t.step + 1);
	}
	return -1;
}
int main() {
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++) cin >> maze[i][j];
	int ha, la, hb, lb;  //起点为(ha,la)，终点为(hb,lb)
	cin >> ha >> la >> hb >> lb;
	cout << min_step(ha, la, hb, lb) << endl;
	return 0;
}

求一条可达路径

这类问题的形式是：输入n*m的迷宫，给定一个起点和终点，求一条可行路径（一般为最短路径）

这类问题用dfs实现不容易，只分享bfs做法

伪代码：

read n,m
read maze[0...n-1][0...m-1]
st[0...n-1][0...m-1] <- false
pre[0...n-1][0...m-1] <- (0,0)
q = new queue
push(x,y,tx,ty){
  q.push(x,y)
  st[x][y] <- true
  pre[x][y]=(tx,ty)
}
check(x, y){
  return x>=0 and x<n and y>=0 and y<m and maze[x][y]=0 and st[x][y]=false
}
shortest_path(sx,sy,ex,ey){
  if(maze[sx][sy]=1) return false
  push(sx,sy,-1,-1)
  repeat{
    t <- q.front
    q.pop
    if(t.x=ex and t.y=ey) return true
    nx[0...3]<-{x-1,x+1,x,x}
    ny[0...3]<-{y,y,y-1,y+1}
    for i=0 to 3 do{
      if call check(nx[i],ny[i]) = true then push(nx[i],ny[i],t.x,t.y)
    }
  }until q.empty
  return false
}
print(x,y){
  if(x=-1 and y=-1) return
  print(pre[x][y].x,pre[x][y].y)
  write (x,y)
}
read sx,sy,ex,ey;
if call shortest_path(sx,sy,ex,ey) = true then print(ex,ey)
else write "no path"

C++:

#include<iostream>
#include<queue>
using namespace std;
int n, m;
const int N = 100;
int maze[N][N];  //迷宫，1代表墙，0代表空地
bool st[N][N];  // 标记数组
struct node {
	int x, y, step;
	node(int x, int y) :x(x), y(y){}
	node() { node(0, 0); }
};
queue<node> q;
node pre[N][N];  //记录(x,y)的前驱
// 点(x,y)入队,记录前驱
void push(int x, int y, int px, int py) {
	q.emplace(x, y);
	st[x][y] = true;
	pre[x][y] = node(px, py);
}
// 检查(x,y)是否能走
bool check(int x, int y) {
	return x >= 0 && x < n&& y >= 0 && y < m&& maze[x][y] == 0 && !st[x][y];
}
// 输出路径
void print(int x, int y) {
	if (x == -1 && y == -1) return;
	print(pre[x][y].x, pre[x][y].y);
	cout << "(" << x << "," << y << ")" << endl;
}
// 计算(sx,sy)到(ex,ey)的最短路径，返回值代表是否可达
bool shortest_path(int sx, int sy, int ex, int ey) {
	if (maze[sx][sy] == 1) return false;
	push(sx, sy, -1, -1);
	while (q.size()) {
		node t = q.front();
		q.pop();
		// 可以到达
		if (t.x == ex && t.y == ey) return true;
		// 扩展
		int nx[4] = { t.x - 1,t.x + 1,t.x,t.x };
		int ny[4] = { t.y,t.y,t.y - 1,t.y + 1 };
		for (int i = 0; i < 4; i++)
			if (check(nx[i], ny[i])) push(nx[i], ny[i], t.x, t.y);
	}
	return false;
}
int main() {
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++) cin >> maze[i][j];
	int ha, la, hb, lb;  //起点为(ha,la)，终点为(hb,lb)
	cin >> ha >> la >> hb >> lb;
	if (shortest_path(ha, la, hb, lb)) print(hb, lb);
	else cout << "no path" << endl;   //走不通
	return 0;
}

输入:

3 3

0 0 0

1 1 0

1 1 0

输出:

(0,0)

(0,1)

(0,2)

(1,2)

(2,2)

pre数组情况：

012
0(-1,-1)(0,0)(0,1)
1(0,0)(0,0)(0,2)
2(0,0)(0,0)(1,2)

练习

1215：迷宫

1248：Dungeon Master

1252：走迷宫

1255：迷宫问题

pystraf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
人工智能大作业——A*算法迷宫寻路问题
weixin_46037153的博客
07-05 2万+
项目设计的目的 利用A*算法实现迷宫寻路功能，利用启发式函数的编写以及各类启发式函数效果的比较。 相关原理知识介绍 A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。公式表示为：f(n)=g(n)+h(n)，其中f(n)是节点n从初始点到目标点的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：估价值h(n)小于等于n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范
Python解决走迷宫问题算法示例
09-20
在Python编程中，解决走迷宫问题是一种常见的算法挑战，主要涉及到路径搜索和图遍历。本示例介绍了一种基于二维数组的深度优先遍历（DFS）算法来解决此类问题。下面将详细阐述该算法及其实现过程。 首先，我们要...
【算法题】机器人走迷宫
张紫娃的博客
01-31 471
统计的时多少种方法，而不是一共走了多少步，不要被最后一步给干扰了。
机器人走迷宫 描述 有一个n*m格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示不可以走，0表示可以走，现 要求从第一行第一-列[0，0]走到最后- 行最后一列[n-1, m-...
weixin_42611177的博客
02-16 439
这是一个求解迷宫路径的问题，以下是一个可能的解法： 首先，读入输入数据，将迷宫转化为一个由 1 和 0 组成的矩阵。 使用深度优先搜索(DFS)算法来寻找迷宫路径。从起点开始，按照上下左右的顺序依次尝试移动，如果某个方向可以走，则标记这个点已经被访问过，继续在这个方向上搜索。如果在某个方向上走到了终点，则记录这条路径并返回。 通过不断尝试不同的路径，可以找到所有可行的道路，并输出这些路径以及每条...
数据结构算法设计——深搜DFS(走迷宫)
给你糖ya的博客
12-03 2228
数据结构算法设计——深搜DFS(走迷宫)
c++深搜1-迷宫类问题
Mark1277的博客
06-11 3898
深搜-迷宫类问题
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
C语言使用广度优先搜索算法解决迷宫问题（队列） 本文主要介绍了C语言使用广度优先搜索算法解决迷宫问题的相关知识点，详细解释了C语言队列广度优先搜索算法的使用技巧和实现细节。 一、广度优先搜索算法的基本...
基于Python实现的机器人自动走迷宫.zip
06-13
使用基础搜索算法完成机器人走迷宫。 使用 Deep QLearning 算法完成机器人走迷宫。 使用 Maze(maze_size=size) 来随机生成一个 size * size 大小的迷宫。 使用 print() 函数可以输出迷宫的 size 以及画出迷宫图 红色...
C语言实现走迷宫
08-18
C语言实现走迷宫 C语言实现走迷宫是计算机科学中一个经典的问题，目的是在一个迷宫中找到从起点到终点的路径。...C语言实现走迷宫问题可以使用DFS和BFS两种方法解决，都是使用递归函数或队列来实现搜索算法。
DQN实现走迷宫（tkinter编写环境）
07-30
Python实现走迷宫，迷宫环境可视化，代码参考莫烦python，可以直接运行，DQN网络使用tensorflow搭建，代码注释非常全，基本每一句都有，而且可以使用tensorboard查看日志，需要将log_out参数设置为true
c++ 深搜 迷宫
10-26
c++ 深度搜索 迷宫问题 在一个n*n的方格中，1表示墙，0表示通路。利用深度搜索遍历。
深搜迷宫算法
05-20
C++算法资源 一只小狗在寻找肉骨头的时候不小心进入了一个古迷宫当中，迷宫中机关重重，当它捡起骨头的时候，机关被触发了。想要活命，小狗必须在规定时间到达出口。
走迷宫(深搜做法+)
I_O_fly的博客
04-13 2330
走迷宫Time Limit: 1 Sec  Memory Limit: 128 MBSubmit: 85  Solved: 77[Submit][Status][Web Board]DescriptionX身在一个M*N大小的迷宫中，迷宫中的障碍物是不能通行的。迷宫中用S代表X，用E代表出口，#代表障碍物，*代表可以通行的道路。X只可以向上、下、左、右四个方向行走，并且每一步只能走一个单位的长度。...
DFS（深搜）例题 解题与心得
Crazy_Frog的专栏
03-23 7838
走迷宫 【问题描述】 有一个m*n格的迷宫(表示有m行、n列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这m*n个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你分别编程4个程序解决以下4个问题。 问题1：找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相
深度搜索算法——走迷宫
wangchuha的博客
06-30 189
题目要求：输入一个数n。接着输入一个n行n列的迷宫。0代表可以走，1代表不能走，2代表唐僧的位置。如果悟空能碰到唐僧，输出yes，否则输出no。这道题的解题关键就是要抓清深搜的精髓——回溯，然后就十分好解了。
电脑鼠走迷宫（DFS+BFS）
最新发布
maisui12138的博客
08-11 3692
IEEE国际标准电脑鼠走迷宫竞赛，简单来说是使用微控制器、传感器和机电运动部件构成的一种智能行走机器人，本文仅对”到达迷宫终点"，这一问题进行算法上的思索与解决。
走迷宫求最短距离——深搜
lishifu_的博客
03-24 629
1、问题描述 输入n和m表示迷宫的行数和列数，接下俩输入迷宫的状态，使用深度优先搜寻即可求出最短距离 5 4 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 2、代码实现 import java.util.Scanner; public class 走迷宫 { static int n; static int m; static int[][] map; static int min = Integer.MAX_VALUE; public static.
洛谷：P1238 走迷宫(dfs)
hhyer的博客
02-22 588
洛谷：P1238 走迷宫 https://www.luogu.com.cn/problem/P1238 描述： 有一个 m×n 格的迷宫(表示有 m 行、n 列)，其中有可走的也有不可走的，如果用 1 表示可以走，0 表示不可以走，文件读入这 m×n 个数据和起始点、结束点（起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号）。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息（用−1 表示无路）。 优先顺序：左上右下。数
深度优先搜索经典实例：走迷宫
qq_53626555的博客
06-03 702
深度优先搜索经典实例：走迷宫 C语言实现 题目描述 给定一个迷宫（用二维数组存放），需要从一个起点走到终点，0代表可走，1代表障碍物不可走，请找出从起点走到终点的最短路径。 样例解释 第一行输入n和m分别为二维数组（迷宫）的行和列，接着n行m列的迷宫，最后一给出两个坐标，起点和终点。（坐标中（x，y）为第x行第y列，而不是数学坐标系中的坐标）。 输入样例： 5 4 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 1 4 3 输出样例： min=7 #include &
走迷宫问题c++
05-28
好的，走迷宫问题可以用深度优先搜索（DFS）或广度优先搜索（BFS）来解决。下面是一个用DFS解决走迷宫问题的C++代码示例： ```c++ #include <bits/stdc++.h> using namespace std; const int maxn = 100; int n, m; int maze[maxn][maxn]; // 迷宫 bool vis[maxn][maxn]; // 标记是否走过 int dir[4][2] = {{1,0}, {-1,0}, {0,1}, {0,-1}}; // 上下左右四个方向 void dfs(int x, int y) { vis[x][y] = true; // 标记为已经走过 if (x == n && y == m) { // 到达终点 return; } for (int i = 0; i < 4; i++) { // 依次尝试上下左右四个方向 int nx = x + dir[i][0]; int ny = y + dir[i][1]; if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && maze[nx][ny] == 0 && !vis[nx][ny]) { dfs(nx, ny); // 可以走则继续往下走 } } } int main() { cin >> n >> m; for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { cin >> maze[i][j]; } } dfs(1, 1); // 从起点开始搜索 if (vis[n][m]) { // 判断是否到达终点 cout << "YES" << endl; } else { cout << "NO" << endl; } return 0; } ``` 其中 `maze` 数组表示迷宫，0表示可以通过的空地，1表示障碍物。`vis` 数组表示该点是否已经走过。`dir` 数组表示上下左右四个方向。从起点(1, 1)开始深度优先搜索，如果搜索到终点(n, m)，则输出YES，否则输出NO。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值