迷宫求解 (所有路径)

最新推荐文章于 2024-08-06 12:06:34 发布
最新推荐文章于 2024-08-06 12:06:34 发布
阅读量8.4k 收藏 30
点赞数 3
分类专栏： 数据结构 文章标签： C++
原文链接：https://wangqy.cc/2018/10/16/%E8%BF%B7%E5%AE%AB%E6%B1%82%E8%A7%A3%E6%89%80%E6%9C%89%E8%B7%AF%E5%BE%84/
版权

原文地址

迷宫问题

对于如下所示的迷宫，如何找到所有路径？（ # 为墙，* 为出口，0 为入口）（注意：要找到所有的路径必须保证一条路径不能在同一个位置走两次及两次以上，反之，一方面，这样没有意义；另一方面，这样可能会造成在一个地方一直转圈）

迷宫示例

大致思路（试错法）

  1. 先将迷宫用二维数组表示，0代表围墙，1代表通路，2代表出口，而入口通过坐标指定

  2. 定义位置类LocDir，成员X（列坐标）和Y（行坐标）代表在迷宫某个位置的坐标,成员dir代表在这个位置后下一步要走的方向（1代表向上，2代表向右，3代表向下，4代表向左）

  3. 先定义一个入口的位置对象；而后创建一个栈（存放位置对象），用于记录走过的路径，并将入口进栈。

  4. 从入口开始，根据位置对象中的方向，在向该方向移动前先判断：若为0，说明前方是墙，此时将方向+1，即调整方向；若为1，说明前方是通路，则将现在位置在二维数组中的值置0，表示走过的路已经变成了墙，不能走回头路（避免出现文章开头提出的现象），向前方移动，并将到达的位置X和Y记录下来，dir置1，表示先试着向上走，将该位置对象入栈；若为2，说明找到了出口，这个时候将路径以坐标的形式输出即可。

  5. 若4中调整方向后，直到方向变成4，即向左走也不行，则此时应该将方向+1，变为5，但这样就找不到方向了，说明在该位置四周都是墙，此时将栈顶元素退栈，同时将其变为现在的位置，即沿原路径返回了一步；再将现在位置在二维数组中的值置1，即将这个位置变为通路；最后将方向+1。

  6. 还可以将每次找到的正确路径的长度记录下来，通过比较，输出最长路径（之一）和最短路径（之一）

总结

总的来说，迷宫求解试错法的关键在于，在迷宫的每个位置，我们都有四个方向可以选择，那么，只需要在每个位置将这四个方向依次试过，就可以确保走过迷宫的每一个位置，且单条路径不会重复走过同一个位置。

实现代码

注：由于代码中使用的栈是我自定义的，故栈中的一个函数Exchangge(top)（用来替换栈顶元素），在标准栈中可能并没有，但其本质是将原栈顶元素出栈后再将新的元素进栈，即可分成两步写。

main.cpp

#include<Windows.h>
#include"MazeSolve.h"
#include"LocDir.h"

int main() {
	//0代表围墙，1代表通路，2代表出口
	int map[10][10] = {
		{0,0,0,0,0,0,0,0,0,0},
		{0,1,1,0,1,1,1,0,1,0},
		{0,1,1,0,1,1,1,0,1,0},
		{0,1,1,1,1,0,0,1,1,0},
		{0,1,0,0,0,1,1,1,1,0},
		{0,1,1,1,0,1,1,1,1,0},
		{0,1,0,1,1,1,0,1,1,0},
		{0,1,0,0,0,1,0,0,1,0},
		{0,0,1,1,1,1,1,1,2,0},
		{0,0,0,0,0,0,0,0,0,0} 
	};
	//入口初始化
	LocDir in;
	in.X = 1;
	in.Y = 1;
	in.dir = 1;

	MazeSolve(map, in);

	system("pause");
	return 0;
}

MazeSolve.h

#ifndef _MAZESOLVE_H
#define _MAZESOLVE_H

#include"LinkStack.h"
#include"LocDir.h"
#include<iostream>

using namespace std;

void MazeSolve(int map[][10], const LocDir & in) {
	int roadNum = 0;
	int roadLen[200] = { 0 };

	LinkStack<LocDir> LocDirStack;
	
	LocDirStack.Push(in);

	LocDir top, temp;
	LocDirStack.Top(top);

	while (!(top.X==1&&top.Y==1&&top.dir==5)) {
		//Move
		switch (top.dir)
		{
		case 1://turn up
			if (map[top.Y-1][top.X]) {
				if (map[top.Y - 1][top.X] == 2) {
					cout << "Road" << roadNum << ':';
					cout << '(' << top.X << ',' << top.Y-1 << ')' << '\t';
					roadLen[roadNum] = 1 + LocDirStack.GetSize();
					roadNum++;
					LocDirStack.Show();
					cout << endl;
					top.dir++;
					LocDirStack.Exchange(top);
					break;
				}
				map[top.Y][top.X] = 0;
				temp = { top.X,top.Y - 1,1 };
				LocDirStack.Push(temp);
			}
			else {
				top.dir++;
				LocDirStack.Exchange(top);
			}
			break;
		case 2://turn right
			if (map[top.Y][top.X + 1]) {
				if (map[top.Y][top.X + 1] == 2) {
					cout << "Road" << roadNum << ':';
					cout << '(' << top.X+1 << ',' << top.Y << ')' << '\t';
					roadLen[roadNum] = 1 + LocDirStack.GetSize();
					roadNum++;
					LocDirStack.Show();
					cout << endl;
					top.dir++;
					LocDirStack.Exchange(top);
					break;
				}
				map[top.Y][top.X] = 0;
				temp = { top.X+1,top.Y,1 };
				LocDirStack.Push(temp);
			}
			else {
				top.dir++;
				LocDirStack.Exchange(top);
			}
			break;
		case 3://turn down
			if (map[top.Y+1][top.X]) {
				if (map[top.Y + 1][top.X] == 2) {
					cout << "Road" << roadNum << ':';
					cout << '(' << top.X << ',' << top.Y + 1 << ')' << '\t';
					roadLen[roadNum] = 1 + LocDirStack.GetSize();
					roadNum++;
					LocDirStack.Show();
					cout << endl;
					top.dir++;
					LocDirStack.Exchange(top);
					break;
				}
				map[top.Y][top.X] = 0;
				temp = { top.X,top.Y + 1,1 };
				LocDirStack.Push(temp);
			}
			else {
				top.dir++;
				LocDirStack.Exchange(top);
			}
			break;
		case 4://turn left
			if (map[top.Y][top.X - 1]) {
				if (map[top.Y][top.X - 1] == 2) {
					cout << "Road" << roadNum << ':';
					cout << '(' << top.X -1<< ',' << top.Y<< ')' << '\t';
					roadLen[roadNum] = 1 + LocDirStack.GetSize();
					roadNum++;
					LocDirStack.Show();
					cout << endl;
					top.dir++;
					LocDirStack.Exchange(top);
					break;
				}
				map[top.Y][top.X] = 0;
				temp = { top.X - 1,top.Y,1 };
				LocDirStack.Push(temp);
			}
			else {
				top.dir++;
				LocDirStack.Exchange(top);
			}
			break;
		default://no choice
			LocDirStack.Pop(temp);

			LocDirStack.Top(top);
			top.dir++;
			LocDirStack.Exchange(top);

			map[top.Y][top.X] = 1;

			break;
		}

		LocDirStack.Top(top);
	}

	roadNum = 0;
	int minRoad = roadLen[roadNum],maxRoad = roadLen[roadNum];
	int minRoadPos =0, maxRoadPos = 0;
	while (roadLen[roadNum]) {
		if (minRoad > roadLen[roadNum]) {
			minRoad = roadLen[roadNum];
			minRoadPos = roadNum;
		}
		if (maxRoad < roadLen[roadNum]) {
			maxRoad = roadLen[roadNum];
			maxRoadPos = roadNum;
		}
		++roadNum;
	}
	cout << "Min RoadNum:" << minRoadPos << '\t' << "Min RoadLength:" << minRoad << endl;
	cout << "Max RoadNum:" << maxRoadPos << '\t' << "Max RoadLength:" << maxRoad << endl;
}

#endif // !_MAZESOLVE_H

LocDir.h

#ifndef _LOCDIR_H
#define _LOCDIR_H

#include<iostream>

using namespace std;

class LocDir
{
public:
	LocDir(int X=0, int Y=0, int dir=0);
	friend ostream& operator<<(ostream& out,const LocDir& loc_dir);
	~LocDir();
	int X;
	int Y;
	int dir;
private:

};

LocDir::LocDir(int X,int Y,int dir):X(X),Y(Y),dir(dir)
{
}

LocDir::~LocDir()
{
}


ostream& operator<<(ostream& out, const LocDir& loc_dir)
{
	out << '(' << loc_dir.X << ',' << loc_dir.Y << ')' << '\t';
	return out;
}

#endif // !_LOCDIR_H
DiDongDongDi
关注
专栏目录
求解迷宫问题的所有路径以及最短路径程序
xiezhi123456的博客
07-19 3366
/** * 实验题目: * 求解迷宫问题的所有路径以及最短路径程序 * 实验要求: * 输出如下图3.9所示的迷宫的所有路径,并求最短路径长度以及最短路径 */ #include <stdio.h> #define M 4 // 行数 #define N 4 ...
DFS求解迷宫问题(输出所有的路径)
热门推荐
tensory的博客
03-27 2万+
问题：给出一个n*n的迷宫，起点为(0,0)，终点为(n-1,n-1).可以向上、下、左、右四个方向走. 任务：1.判断是否有可行路径            2.如果有可行路径，输出所有的可行路径. ———————————————————————————————————————————————————— 如下图所示，当前位置为中间点，如果中间点不是终点，那么会从4个方向进行下一步探测，进入
迷宫 最短路径及所有路径的问题
12-06
迷宫问题，完成的是一个现实中的迷宫游戏求最短路径及所有路径的问题，本程序相对于航班信息查询系统比较简单，主要包含使用系统迷宫（可以选择迷宫的入口和出口，并输出所有路径和最短路径），使用新建迷宫（可以自己设计迷宫的大小，及所有通路，可以选择迷宫的入口和出口，并输出所有路径和最短路径），用到了栈的使用，如栈的创建、入栈、出栈等函数功能。
C语言队列解决迷宫问题（所有路径）
2301_80163948的博客
03-24 922
if (i0 >= 1 && j0 >= 1 && i0
【数据结构与算法】迷宫求解------回溯法
最新发布
qq_74047911的博客
08-06 481
当我们想要找到迷宫的出口,那我们在计算机中,然后操作,可以将每个位置都人栈,然后进行上下左右的路的判断,能否通过,若是死路,就将这个点出栈,回退到刚刚的栈,再判断其他的道路.在同行同列且相邻且在二维数组范围内,值为1就是通道就可以下一步.就当前入口点入栈,然后做标记改为2,就是我们走过的地方.就出栈,进行判断上一个路口,是否可以其他的下一步.地图的结构就是一个二维数组,初始化就是进行赋值.只有我们的栈不为空或者找不到出口,那么就一直找.初始化栈就可以进入到我们的迷宫判断了.能下一步就做标记,入栈.
求解迷宫全部路径问题
10-07
问题描述： 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出从入口（0，0）到出口（m-1，n-1）的通路和通路总数，或得出没有通路的结论。例如下图， 0（入口） 1 0 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0（出口） 从入口到出口有6条不同的通路。 而下图： 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 1 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 1 1 1 0 0 1 1 1 0 0 0 1 0 1 1 1 0 0 0 0 0 0 从入口到出口则没有通路。 算法设计： 给定一个m*n的长方阵表示迷宫，设计算法输出入口到出口的通路和通路总数，或得出没有通路的结论。 算法提示： 和皇后问题与分书问题类似。可以用二维数组存储迷宫数据，对于迷宫中任一位置，均可约定有东、南、西、北四个方向可通。从当前位置a（用（x，y）表示一个位置，假定它是以向右的x轴和向下的y轴组成的平面上的一个点）出发依次尝试四个方向是否有路，若某个方向的位置b可通，则按照同样的方法继续从b出发寻找。若到达出口，则找到一条通路。 数据输入： 由文件input.txt 提供输入数据。第一行是m和n的值，空格分隔，其后共m行。每行有n个数字，数和数之间用空格分隔。 结果输出： 将计算出的所有从入口到出口的通路输出到文件output.txt 中。若没有通路，则将0写入文件中。
经典算法----迷宫问题（找出所有路径）
m0_73633088的博客
10-07 4126
经典算法-----迷宫问题（栈的应用）-CSDN博客），但是这个方法只可以找到一条路径，那么今天我们就进一步去讲解迷宫问题，通过回溯算法来找到全部的路径，下面就一起来看看吧！同样的，每走到一个位置就要想该往哪一个方向去走，所以有东南西北这4个方向，每次往一个方向走之后就标记好当前方向和当前位置，然后同样的去进行分享的试探，当走到没路走的时候就进行原路返回。//试探方向存储结构int xx, yy;}Direction;//东南西北。
求取迷宫所有路径
仓鼠玉米的博客
04-13 1364
int maze[9][9]={{2, 2, 2, 2, 2, 2, 2, 2, 2}, {2, 0, 0, 0, 0, 0, 0, 0, 2}, {2, 0, 2, 2, 0, 2, 2, 0, 2}, {2, 0, 2, 0, 0, 2, 0, 0, 2}, {2, 0, 2, 0, 2, 0, 2, 0, 2}, {2, 0, 0, 0, 2, 0, 2, 0, 2}, {2, 2, 0,
求解迷宫问题的所有路径及最短路径程序
cncnlg的专栏
11-07 3543
路障  路障  路障  路障  路障  路障  路障  入口      路障  路障  路障    路障      路障  
递归求解迷宫所有路径c语言,数据结构C语言版 递归求解迷宫问题
weixin_39834780的博客
05-20 842
陈独秀的秘密数据结构C语言版 递归求解迷宫问题用递归函数求解迷宫问题(求出所有解)编译环境：Dev-C++ 4.9.9.2日期： 2011年2月12日*/#include// 迷宫坐标位置类型struct PosType{int x; // 行值int y; // 列值};#define MAXLENGTH 25 // 设迷宫的最大行列为25typedef int MazeType[MAXLEN...
迷宫问题的最短路径C语言实现（栈实现）
04-28
迷宫问题最短路径C语言printf("最短路径如下:\n"); printf("长度: %d\n",minlen); printf("路径: "); for(k=0;k;k++) printf("(%d,%d) ",Path[k].i,Path[k].j); printf("\n"); return 0;
c语言支持自己创建迷宫，并求解最短路径.zip
04-08
c语言支持自己创建迷宫，并求解最短路径c语言支持自己创建迷宫，并求解最短路径c语言支持自己创建迷宫，并求解最短路径c语言支持自己创建迷宫，并求解最短路径c语言支持自己创建迷宫，并求解最短路径c语言支持自己...
迷宫求解全部路径，输出最短
05-18
在IT领域，迷宫求解是一个经典的算法问题，它涉及到图论、深度优先搜索(DFS)、广度优先搜索(BFS)等计算机科学基础概念。本项目的目标是设计并实现一个程序，它能够找到迷宫中的所有可能路径，并且能够找出其中的最短...
python迷宫问题求最短路径_用栈求解迷宫问题的所有路径及最短路径程序
weixin_42365401的博客
02-21 1721
目的：能将栈运用的更为熟练实验内容：求解迷宫问题程序，要求输出如图所示的迷宫的路径，并求出第一条最短路径的长度以及最短路径。设计的算法功能：mgpath(int xi,int yi,int xe,int ye):求解迷宫问题，即输出从入口(xi,yi)到出口(ye,xe)的全部路径和最短路径(包含最短路径长度)。minlen记录最短路径长度，Path数组记录最短路径dispapath()：输出一条...
递归算法--01 迷宫问题：指定单入口和单出口，找到任意路径即可
一分耕耘一分收获
03-24 1985
递归算法--01 迷宫问题：指定单入口和单出口，找到任意路径即可 问题背景： 给你一个 m x n 的迷宫矩阵 maze （下标从 0 开始），矩阵中有空格子（用 '.' 表示）和墙体（用 '+' 表示）。同时给你迷宫的入口 entrance ，用 entrance = [entrancerow, entrancecol] 表示你一开始所在格子的行和列。每一步操作，你可以往 上，下，左 或者 右 移动一个格子。你不能进入墙所在的格子，你也不能离开迷宫。
【算法】（BFS/DFS）迷宫路径问题（C语言）
weixin_51450101的博客
05-01 7445
题目：现有一迷宫如下图所示，蓝色部分为墙壁，白色部分为通路，入口在左上角（1,1）处，出口在右下角（8,8）处，试找出一条路径以通过该迷宫（路径不能重叠）。
【迷宫问题】找出迷宫所有可能的路径C++
六根胡子
05-13 1650
用栈实现迷宫问题，找出所有可达的路径。
递归求解迷宫中所有迷宫路径（数据结构学习笔记）
省洗发水钱买书
12-14 7824
文章目录递归求解迷宫问题迷宫题目算法思路算法代码算法设计完整代码最终迷宫路径算法总结 递归求解迷宫问题 有些问题可以使用递归方法求解，将大问题分解成求解方法相同的小问题。递归调用必须有的两个因素：1、有递归出口，2、有递归体。并且递归调用的次数总是有限的。 迷宫题目 设计算法输出所有的迷宫路径，其中(1,1)为入口，(4,4)为出口。（规定以0为可走方块，1为不可走方块） int mg[M+2][N+2]= //M=4，N=4 { {1, 1, 1, 1, 1, 1},
迷宫的路径
qq_56089122的博客
05-24 457
寻找迷宫的最短路径。
迷宫求解最短路径c
05-31
以下是使用广度优先搜索算法求解迷宫最短路径的C语言代码示例： ```c #include <stdio.h> #include <stdlib.h> #define ROW 6 // 迷宫行数 #define COL 6 // 迷宫列数 // 迷宫地图 int maze[ROW][COL] = { {0, 0, 0, 0, 0, 0}, {0, 1, 0, 1, 0, 0}, {0, 1, 0, 0, 0, 1}, {0, 1, 0, 1, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 0, 0} }; // 记录迷宫中每个位置是否被访问过 int visited[ROW][COL] = {0}; // 记录每个位置的前一个位置 int pre[ROW][COL][2] = {0}; // 用于存储路径的队列 int queue[ROW*COL][2] = {0}; // 队列头和尾指针 int front = 0, rear = 0; // 判断是否到达终点 int isEnd(int row, int col) { return row == ROW-1 && col == COL-1; } // 判断某个位置是否可以走 int canMove(int row, int col) { return row >= 0 && row < ROW && col >= 0 && col < COL && maze[row][col] == 0 && visited[row][col] == 0; } // 打印路径 void printPath() { int row = ROW-1, col = COL-1; printf("Path: (%d, %d)", row, col); while (row != 0 || col != 0) { int temp_row = row, temp_col = col; row = pre[temp_row][temp_col][0]; col = pre[temp_row][temp_col][1]; printf(" -> (%d, %d)", row, col); } printf("\n"); } // 广度优先搜索 void bfs() { // 先将起点加入队列 queue[rear][0] = 0; queue[rear][1] = 0; rear++; visited[0][0] = 1; // 开始搜索 while (front != rear) { // 出队 int row = queue[front][0]; int col = queue[front][1]; front++; // 判断是否到达终点 if (isEnd(row, col)) { // 打印路径 printPath(); return; } // 尝试向上走 if (canMove(row-1, col)) { // 加入队列 queue[rear][0] = row-1; queue[rear][1] = col; rear++; visited[row-1][col] = 1; pre[row-1][col][0] = row; pre[row-1][col][1] = col; } // 尝试向下走 if (canMove(row+1, col)) { // 加入队列 queue[rear][0] = row+1; queue[rear][1] = col; rear++; visited[row+1][col] = 1; pre[row+1][col][0] = row; pre[row+1][col][1] = col; } // 尝试向左走 if (canMove(row, col-1)) { // 加入队列 queue[rear][0] = row; queue[rear][1] = col-1; rear++; visited[row][col-1] = 1; pre[row][col-1][0] = row; pre[row][col-1][1] = col; } // 尝试向右走 if (canMove(row, col+1)) { // 加入队列 queue[rear][0] = row; queue[rear][1] = col+1; rear++; visited[row][col+1] = 1; pre[row][col+1][0] = row; pre[row][col+1][1] = col; } } // 没有找到路径 printf("No path found!\n"); } int main() { bfs(); return 0; } ``` 该算法使用一个队列来存储待访问的位置，每次从队首取出一个位置进行访问，并将它周围可以访问的位置加入队列。在访问每个位置时，记录它的前一个位置，最后通过前一个位置数组来构造出最短路径。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值