迷宫的路径

已于 2023-05-24 16:52:42 修改
阅读量341 收藏
点赞数
分类专栏： 小白学算法 文章标签： 算法
于 2023-05-24 16:50:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56089122/article/details/130850278
版权

问题描述

给定一个迷宫，这个迷宫一定存在一条从起点到终点的路径，且起点和终点一定在迷宫的边缘且不在拐角，起点和终点不相邻。

根据迷宫的特性，如果选择左边或右边的墙并一直沿着墙走下去，就一定能走到终点。

请找出只沿着左边墙走、只沿着右边墙走走到终点的路径和到终点的最短路径。

算法思路

以沿着左墙走为例，沿着墙走的时候，判断现在走动的方向，不同的方向的“左手边”的优先顺序是不一样的，当现在是往上走过来的时候，改点的左边就是左，如果左边是墙，则优先走上面，如果上面也是墙，则走右边，如果右边是墙，则走下面（回去）。每走一步，都要更正当前走的方向，以判断哪边是左手边。

方向向右时：

左手边的顺序应为：上、右、下、左

右手边的顺序应为：下、右、上、左

方向向左时：

左手边的顺序应为：下、左、上、右

右手边的顺序应为：上、左、下、右

方向向下时：

左手边的顺序应为：右、下、左、上

右手边的顺序应为：左、下、右、上

方向向上时：

左手边的顺序应为：左、上、右、下

右手边的顺序应为：右、上、左、下

对于寻找最短路径，使用bfs寻找即可。

代码实现


#include <iostream>

using namespace std;

char maze[40][40];
const int M = 999;
int dir[4][2] = { {0,1},{0,-1},{1,0},{-1,0} }; //right, left, down, up

int left_right[4][2] = { {-1,0},{0,1},{1,0},{0,-1} }; //up, right, down, left
int left_left[4][2] = { {1,0},{0,-1},{-1,0},{0,1} }; //down, left, up, right
int left_down[4][2] = { {0,1},{1,0},{0,-1},{-1,0} }; //right, down, left, up
int left_up[4][2] = { {0,-1},{-1,0},{0,1},{1,0} }; //left, up, right, down

int right_right[4][2] = { {1,0},{0,1},{-1,0},{0,-1} }; //down, right, up, left
int right_left[4][2] = { {-1,0},{0,-1},{1,0},{0,1} }; //up, left, down, right
int right_down[4][2] = { {0,-1},{1,0},{0,1},{-1,0} }; //left, down, right, up
int right_up[4][2] = { {0,1},{-1,0},{0,-1},{1,0} }; //right, up, left, down
int flag;
int endnumber;
int lstep = 1;
int rstep = 1;
int mstep = 1;
int answer[3];
int start_x;
int start_y;

struct record
{
	int x;
	int y;
	int step;
};

typedef struct QueNode
{
	record data[M];
	int front, rear;
}*SeQue;

SeQue S;

void init()
{
	S->front = S->rear = 0;
}

bool empty()
{
	if (S->front == S->rear)
		return true;
	else
		return false;
}

void push(record val)
{
	S->data[S->rear] = val;
	S->rear = (S->rear + 1) % M;
}

void pop()
{
	S->front = (S->front + 1) % M;
}

void left(int i, int x, int y)
{
	if (endnumber > 0)
	{
		return;
	}
	//0:right, 1:left, 2:down, 3:up
	lstep++;
	int new_pos_x;
	int new_pos_y;
	if (i == 0)  //right
	{
		//0:up, 1:right, 2:down, 3:left
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + left_right[j][0];
			new_pos_y = y + left_right[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				endnumber++;
				lstep++;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 3;
				if (j == 1)
					flag = 0;
				if (j == 2)
					flag = 2;
				if (j == 3)
					flag = 1;
				left(flag, new_pos_x, new_pos_y);
			}
		}
	}
	if (i == 1) //left
	{
		//0:down, 1:left, 2:up, 3:right
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + left_left[j][0];
			new_pos_y = y + left_left[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				lstep++;
				endnumber++;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 2;
				if (j == 1)
					flag = 1;
				if (j == 2)
					flag = 3;
				if (j == 3)
					flag = 0;
				left(flag, new_pos_x, new_pos_y);
			}
		}
	}
	if (i == 2) //down
	{
		//0:right, 1:down, 2:left, 3:up
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + left_down[j][0];
			new_pos_y = y + left_down[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				lstep++;
				endnumber++;
				break;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 0;
				if (j == 1)
					flag = 2;
				if (j == 2)
					flag = 1;
				if (j == 3)
					flag = 3;
				left(flag, new_pos_x, new_pos_y);
			}
		}
	}
	if (i == 3) //up
	{
		//0:left, 1:up, 2:right, 3:down
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + left_up[j][0];
			new_pos_y = y + left_up[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				lstep++;
				endnumber++;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 1;
				if (j == 1)
					flag = 3;
				if (j == 2)
					flag = 0;
				if (j == 3)
					flag = 2;
				left(flag, new_pos_x, new_pos_y);
			}
		}
	}

}

void right(int i, int x, int y)
{
	if (endnumber > 0)
		return;
	//0:right, 1:left, 2:down, 3:up
	rstep++;
	int new_pos_x;
	int new_pos_y;
	if (i == 0)  //right
	{
		//0:down, 1:right, 2:up, 3:left
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + right_right[j][0];
			new_pos_y = y + right_right[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				endnumber++;
				rstep++;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 2;
				if (j == 1)
					flag = 0;
				if (j == 2)
					flag = 3;
				if (j == 3)
					flag = 1;
				right(flag, new_pos_x, new_pos_y);
			}
		}
	}
	if (i == 1) //left
	{
		//0:up, 1:left, 2:down, 3:right
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + right_left[j][0];
			new_pos_y = y + right_left[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				rstep++;
				endnumber++;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 3;
				if (j == 1)
					flag = 1;
				if (j == 2)
					flag = 2;
				if (j == 3)
					flag = 0;
				right(flag, new_pos_x, new_pos_y);
			}
		}
	}
	if (i == 2) //down
	{
		//0:left, 1:down, 2:right, 3:up
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + right_down[j][0];
			new_pos_y = y + right_down[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				rstep++;
				endnumber++;
				break;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 1;
				if (j == 1)
					flag = 2;
				if (j == 2)
					flag = 0;
				if (j == 3)
					flag = 3;
				right(flag, new_pos_x, new_pos_y);
			}
		}
	}
	if (i == 3) //up
	{
		//0:right, 1:up, 2:left, 3:down
		for (int j = 0; j < 4 && endnumber == 0; j++)
		{
			new_pos_x = x + right_up[j][0];
			new_pos_y = y + right_up[j][1];
			if (maze[new_pos_x][new_pos_y] == 'E')
			{
				rstep++;
				endnumber++;
			}
			if (maze[new_pos_x][new_pos_y] == '#')
				continue;
			if (maze[new_pos_x][new_pos_y] == '.')
			{
				if (j == 0)
					flag = 0;
				if (j == 1)
					flag = 3;
				if (j == 2)
					flag = 1;
				if (j == 3)
					flag = 2;
				right(flag, new_pos_x, new_pos_y);
			}
		}
	}
}

void bfs()
{
	record pos{};
	record newpos{};
	while (!empty())
	{
		pos.x = S->data[S->front].x;
		pos.y = S->data[S->front].y;
		pos.step = S->data[S->front].step;
		pop();
		if (endnumber > 0)
			continue;
		for (int i = 0; i < 4 && endnumber == 0; i++)
		{
			newpos.x = pos.x + dir[i][0];
			newpos.y = pos.y + dir[i][1];
			if (maze[newpos.x][newpos.y] == 'E')
			{
				newpos.step = pos.step + 1;
				mstep = newpos.step;
				endnumber++;
			}
			if (maze[newpos.x][newpos.y] == '#')
				continue;
			if (maze[newpos.x][newpos.y] == '.')
			{
				newpos.step = pos.step + 1;
				push(newpos);
			}
		}
	}
}

int main()
{
	int T;
	int W, H;
	cout << "please input the number of maze" << endl;
	cin >> T;
	for (int i = 0; i < T; i++)
	{
		cout << "please input the width and the height of the maze" << endl;
		cin >> W >> H;
		for (int j = 0; j < H; j++)
		{
			for (int k = 0; k < W; k++)
			{
				cin >> maze[j][k];
				if (maze[j][k] == 'S')
				{
					start_x = j;
					start_y = k;
				}
			}
		}
		//left
		for (int i = 0; i < 4; i++)
		{
			int new_x = start_x + dir[i][0];
			int new_y = start_y + dir[i][1];
			if (maze[new_x][new_y] == '.')
			{
				left(i, new_x, new_y);
			}
		}
		//right
		endnumber = 0;
		for (int i = 0; i < 4; i++)
		{
			int new_x = start_x + dir[i][0];
			int new_y = start_y + dir[i][1];
			if (maze[new_x][new_y] == '.')
			{
				right(i, new_x, new_y);
			}
		}
		//min
		endnumber = 0;
		S = new QueNode;
		init();
		record start{};
		start.x = start_x;
		start.y = start_y;
		start.step = 1;
		push(start);
		bfs();
		//output
		cout << "lstep: " << lstep << "  rstep: " << rstep << "  mstep: " << mstep << endl;
		for (int i = 0; i < 40; i++)
			for (int j = 0; j < 40; j++)
				maze[i][j] = ' ';
		endnumber = 0;
		lstep = 1;
		rstep = 1;
		mstep = 1;
	}
}

测试用例

2
8 8
########
#......#
#.####.#
#.####.#
#.####.#
#.####.#
#...#..#
#S#E####
9 5
#########
#.#.#.#.#
S.......E
#.#.#.#.#
#########

运行结果

馍得脑呆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
wall_follower:向前行驶，同时与左侧或右侧的墙壁保持恒定的距离
03-09
实验3：赛车上的墙跟随（亲自） 可交付成果 到期日 简报（8分钟的演示文稿+ 3分钟的问答时间）（幻灯片在上应有） 3月17日，星期三，美国东部标准时间下午1:00 报告（在） 3月19日，星期五，美国东部标准时间晚上11:59 3月19日，星期五，美国东部标准时间晚上11:59 实验3将由三个面对面的实验会议提供支持： 实验课 日期 远程准备 目标 3.1 美国东部时间3月9日，星期二，8：00-11：00 没有 熟悉赛车平台。 通过SSH访问板载计算机并连接到RViz。 用操纵杆驾驶汽车（遥控操作）。 记录远程操作中的bagfile并将其传输到本地计算机。 3.2 3月10日，星期三，美国东部标准时间8：00-11：00 完成实验2（在模拟中工作的墙跟随器）。 在下面阅读有关安全控制器的信息，并创建实施该团队的团队计划。 在赛车上安装墙壁随动件并调整其在现实世界
经典算法----迷宫问题（找出所有路径）
m0_73633088的博客
10-07 3092
经典算法-----迷宫问题（栈的应用）-CSDN博客），但是这个方法只可以找到一条路径，那么今天我们就进一步去讲解迷宫问题，通过回溯算法来找到全部的路径，下面就一起来看看吧！同样的，每走到一个位置就要想该往哪一个方向去走，所以有东南西北这4个方向，每次往一个方向走之后就标记好当前方向和当前位置，然后同样的去进行分享的试探，当走到没路走的时候就进行原路返回。//试探方向存储结构int xx, yy;}Direction;//东南西北。
1411: 【提高】迷宫的路径？
weixin_44337267的博客
08-26 399
#include <bits/stdc++.h> using namespace std; int n,m,p; char c[50][50]; bool a[50][50]; int r[50][3]; int fx[5]={0,0,1,0,-1}; int fy[5]={0,1,0,-1,0}; bool direct=false; void print(int k) { direct=true; p++; cout<<p<<":";
迷宫求解 (所有路径)
DiDongDongDi的博客
10-26 8302
原文地址 迷宫问题 对于如下所示的迷宫，如何找到所有路径？（ # 为墙，* 为出口，0 为入口）（注意：要找到所有的路径必须保证一条路径不能在同一个位置走两次及两次以上，反之，一方面，这样没有意义；另一方面，这样可能会造成在一个地方一直转圈） 大致思路（试错法） 先将迷宫用二维数组表示，0代表围墙，1代表通路，2代表出口，而入口通过坐标指定 定义位置类LocDir，成员X（列坐标）和Y...
迷宫路径（纵情探索版）JAVA
Narnat的博客
12-04 266
迷宫路径问题八个方向纵情探索java实现
matlab-迷宫路径
03-30
matlab代码，有标注，题目源自牛客网华为机试。 定义一个二维数组N*M（其中2;2），如5 × 5数组下所示： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, ...输出为左上角到右下角的最短路径。
寻找迷宫路径
01-08
寻找迷宫路径，给出了非递归和递归两种解决办法
最短迷宫路径求解
04-13
这个是数据结构的最短迷宫求解路径,通过广义搜索求解.
数据网渗透攻击中的拓展的迷宫路径算法
10-18
为了解决传统网络渗透方法在异构网络上适应性较差的问题，采用计算机算法与设计中的迷宫路径算法、图论中的相关理论，将传统的迷宫路径算法进行了拓展。在此基础上，利用拓展的迷宫路径算法对网络渗透进行了全新探索...
迷宫路径求解
06-06
在一个迷宫中，给定一个入口和出口，如果存在一条从入口到出口的通路就存起来，否则提示不存在从入口到出口的通路
【迷宫问题】找出迷宫所有可能的路径C++
六根胡子
05-13 1470
用栈实现迷宫问题，找出所有可达的路径。
【算法】（BFS/DFS）迷宫路径问题（C语言）
weixin_51450101的博客
05-01 7156
题目：现有一迷宫如下图所示，蓝色部分为墙壁，白色部分为通路，入口在左上角（1,1）处，出口在右下角（8,8）处，试找出一条路径以通过该迷宫（路径不能重叠）。
迷宫问题的所有路径，递归解法，不用栈，极精简56行，c/c++描述
zhangzhangkeji的博客
06-13 2502
  如图的一个迷宫，是一个10 X 10的矩阵，以 H 表示墙壁障碍物，以空格表示可以走的路径。起点是坐标（1，1），字符 ‘I’,表示in，终点是坐标（8，8），以字符‘O’表示，out。总共有几条路径可以从起点到终点呢？，而且，我们必然可以从所有路径中找到最短路径。   测试结果如下，同咱们的肉眼观察，只有三条路径。   全部代码如下，只有这一个源文件，极为精简。充分应用了递归。充分发挥编译器提供的递归功能。 #include<iostream> using namespace std;
最全迷宫最短路径问题（BFS、DFS）
隔壁老陈的博客
06-02 6545
给你一个m*n的迷宫，迷宫中有障碍物（1表示障碍物），你可以上下左右移动，但不能走走过的迷宫，给出指定的起点（x,y）和指定的终点（x_l,y_l）,求最短路径长度是多少，或者打印其中一个最短路径，最段路径为： 1 0，2 0，3 0，4 0，4 1，4 2，4 3，4 4。2.使用BFS层序遍历，一层一层往外扩张，使用结构体简化操作。思路：1.使用DFS深度优先遍历来到达终点的所有路径，选择最短的路径。输出：最短路径长度：8。
viple模拟器使用（二）：Web 2D模拟器中实现沿右墙迷宫算法
以秘
11-27 2013
Web 2D沿右墙迷宫算法
算法题之迷宫中任意位置走任意长度的所有路径查询【原创题，非官方题目】
zygswo的博客
02-03 593
迷宫大家都知道是可以用通过dfs（深度优先算法）进行解决，现在问题如下：小明参加了一个迷宫游戏，这个游戏有这样一个规则：小明只能向上下左右方向任意走n步（可以走回头路），现在需要知道这任意的n步所能覆盖的点的范围和这n步所有的路径 基本原理 经过推理，任意走n步（可以走回头路）有一个规律，那就是所有点构成的图形是一个旋转45度的正方形，如下图所示 并且从图上可以发现一个规律就是不管从哪个点走，走n步后走到的点的个数为（n+1）^2, 经过测试这个规律是正确的。 那么现在问题又来了，如何去获取这些点的坐.
动态规划－迷宫算法最优路径
weixin_40540362的博客
03-08 902
我们先观察一下迷宫的规律。 $moze = [ [1,1,1,1,1,1,1,1,1,1], [1,0,0,1,0,0,0,1,0,1], [1,0,0,1,0,0,0,1,0,1], [1,0,0,0,0,1,1,0,0,1], [1,0,1,1,1,0,0,0,0,1], [1,0,0,0,1,0,0,0,0,1], [1,0,1,0,0,0,1,0,0,1], [1,0,1,1,1,0,1,1,0,1], [1,1,0,0,0,0,0,1,0,1], [1,1,1,1,1,1,
【蓝桥杯】3.迷宫的所有路径——DFS改进（回溯法）
m0_49755093的博客
01-17 2901
回溯法: 也称“试探法”。基本思想是︰为了求得问题的解，先选择一种可能情况,向前探索，在探索过程中，一旦发现原来的选择是错误的，就退回一步重新选择，继续向前搜索，如此反复进行，直至得到解或证明无解;回溯法实际上是深度优先搜索的一种改进。 dfs出的第一条路 进行回溯（撤销3,3点状态，回到2,3点）： 因为2，3点右下侧已经访问，所以现在访问2，3点左侧的2,2点。之后继续向下dfs 例题： 1739 - 【基础】迷宫的所有路径 题目描述 已知一N×N的迷宫，允许往上、下、左、右四个方向行走，且迷宫中
【详解】求解迷宫所有路径（递归实现）----直接打穿迷宫
最新发布
2301_80035594的博客
01-06 895
介绍了递归算法的模型和栈帧的一些基本概念，和递归算法的一个应用求解迷宫所有路径（递归实现）超详细。
求解迷宫路径功能设计
12-28
迷宫路径功能设计是一个经典的计算机科学问题，通常使用搜索算法来解决。这些算法包括深度优先搜索、广度优先搜索、A*算法等。在设计迷宫路径功能时，需要考虑以下几个方面： 1. 迷宫的创建：可以使用绘图软件或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值