搜索之走迷宫问题

已于 2023-09-06 21:39:52 修改
阅读量220 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： c++ 算法 深度优先 广度优先
于 2023-09-03 16:54:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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：迷宫问题

人工智能大作业——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到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范
【简单搜索】迷宫问题
Mark_Eleven的学习笔记
04-12 385
迷宫问题 问题描述 定义一个二维数组： 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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 Input ...
搜索与回溯：迷宫问题(migong)
absWC的博客
02-06 4866
【题目描述】 设有一个 N*N(2<=N<10)方格的迷宫，入口和出口分别在左上角和右上角。迷宫格子中分别放 0 和 1，0 表示可通，1 表示不能，入口和出口处肯定是 0。迷宫走的规则如下所示：即从某点开始，有八个方向可走，前进方格中数字为 0 时表示可通过，为 1 时表示不可通过，要另找路径。找出所有从入口（左上角）到出口（右上角）的路径(不能重复)，输出路径总数，如果无法到达，则输出 0。 样例 输入 3 0 0 0 0 1 1 1 0 0 输出 2 //路径总
【算法题】机器人走迷宫
张紫娃的博客
01-31 548
统计的时多少种方法，而不是一共走了多少步，不要被最后一步给干扰了。
搜索进阶——迷宫问题（带路径的搜索）
naiue的博客
02-16 895
原题： 定义一个二维数组： 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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左...
Python解决走迷宫问题算法示例
09-20
在Python编程中，解决走迷宫问题是一种常见的算法挑战，主要涉及到路径搜索和图遍历。本示例介绍了一种基于二维数组的深度优先遍历（DFS）算法来解决此类问题。下面将详细阐述该算法及其实现过程。 首先，我们要...
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
C语言使用广度优先搜索算法解决迷宫问题（队列） 本文主要介绍了C语言使用广度优先搜索算法解决迷宫问题的相关知识点，详细解释了C语言队列广度优先搜索算法的使用技巧和实现细节。 一、广度优先搜索算法的基本...
基于Python实现的机器人自动走迷宫.zip
06-13
使用基础搜索算法完成机器人走迷宫。 使用 Deep QLearning 算法完成机器人走迷宫。 使用 Maze(maze_size=size) 来随机生成一个 size * size 大小的迷宫。 使用 print() 函数可以输出迷宫的 size 以及画出迷宫图 红色...
java课程设计-走迷宫
最新发布
08-27
4. **游戏逻辑与算法**：实现走迷宫的核心算法是关键，可以采用深度优先搜索(DFS)或广度优先搜索(BFS)等路径查找算法。玩家在迷宫中移动，需要检测当前位置是否合法，以及如何找到下一个可移动的位置。 5. **数据...
基于Python实现机器人自动走迷宫【100011016】
02-27
这个项目的核心目标是通过两种不同的方法——基础搜索算法和Deep Q-Learning（DQN）算法，使机器人能够自主地解决迷宫问题。以下是关于这两个主题的详细讲解。 一、基础搜索算法 基础搜索算法是人工智能领域中解决...
c++ 深搜 迷宫
10-26
c++ 深度搜索 迷宫问题 在一个n*n的方格中，1表示墙，0表示通路。利用深度搜索遍历。
深搜迷宫算法
05-20
C++算法资源 一只小狗在寻找肉骨头的时候不小心进入了一个古迷宫当中，迷宫中机关重重，当它捡起骨头的时候，机关被触发了。想要活命，小狗必须在规定时间到达出口。
机器人走迷宫 描述 有一个n*m格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示不可以走，0表示可以走，现 要求从第一行第一-列[0，0]走到最后- 行最后一列[n-1, m-...
weixin_42611177的博客
02-16 530
这是一个求解迷宫路径的问题，以下是一个可能的解法： 首先，读入输入数据，将迷宫转化为一个由 1 和 0 组成的矩阵。 使用深度优先搜索(DFS)算法来寻找迷宫路径。从起点开始，按照上下左右的顺序依次尝试移动，如果某个方向可以走，则标记这个点已经被访问过，继续在这个方向上搜索。如果在某个方向上走到了终点，则记录这条路径并返回。 通过不断尝试不同的路径，可以找到所有可行的道路，并输出这些路径以及每条...
数据结构算法设计——深搜DFS(走迷宫)
给你糖ya的博客
12-03 2670
数据结构算法设计——深搜DFS(走迷宫)
机器人走迷宫
h91er的博客
12-29 2099
机器人走迷宫 在解题时应注意题目问的为可以到达的且列
c++深搜1-迷宫类问题
Mark1277的博客
06-11 4581
深搜-迷宫类问题
搜索算法（迷宫问题）
VinciB的博客
03-08 2615
搜索算法 盼来盼去终于又要开始学习算法了！ 笔者自学算法，所以学习顺序以个人舒服的形式！ 一，DFS（深搜） 用例子来看： 问题： 有一个迷宫，以1 2形式来表示————1表示是空地，即可以行走，2表示是障碍物，即无法通行。该迷宫由一个矩阵形式表示。 即 1  1  2  1 1  1  1  1 1  1  2  1 1  2  1  1 1  1  1  2 有终点和起点，我们需要计算从起点到达终点的最短路径！ 准备代码为 int q,p,step;//（p，q）为终点坐标 int mmin=9
走迷宫(深搜做法+)
I_O_fly的博客
04-13 2415
走迷宫Time Limit: 1 Sec  Memory Limit: 128 MBSubmit: 85  Solved: 77[Submit][Status][Web Board]DescriptionX身在一个M*N大小的迷宫中，迷宫中的障碍物是不能通行的。迷宫中用S代表X，用E代表出口，#代表障碍物，*代表可以通行的道路。X只可以向上、下、左、右四个方向行走，并且每一步只能走一个单位的长度。...
深度搜索算法——走迷宫
wangchuha的博客
06-30 244
题目要求：输入一个数n。接着输入一个n行n列的迷宫。0代表可以走，1代表不能走，2代表唐僧的位置。如果悟空能碰到唐僧，输出yes，否则输出no。这道题的解题关键就是要抓清深搜的精髓——回溯，然后就十分好解了。
利用算法破解走迷宫最少步数问题
总结以上知识点，解决走迷宫问题的关键在于迷宫的正确建模、合适的搜索算法选择、传送门的特殊处理以及状态空间的有效管理。通过这些知识点的综合应用，可以编写出有效的程序来解决给定的迷宫问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值