迷宫问题（完整版）

已于 2024-05-20 13:07:41 修改
阅读量339 收藏 1
点赞数 10
文章标签： c++ 数据结构 c语言
于 2024-04-15 22:14:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80484340/article/details/137797087
版权

8083b066bfcd4a4c81f38b9e27408763.png

c++的代码与注释

#include<bits/stdc++.h>
using namespace std;

//方向的结构定义
typedef struct{
	int incX,incY;
}Direction;

Direction direct[4]; //创建四个方向的结构数组

//存储当前坐标和方向的结构体
typedef struct{
	int x, y;  //当前坐标
	int di;    //方向
}Box;



//打印迷宫
void show(int *maze[],int M, int N){
int i,j;
printf("\n");
	printf("迷宫如下：（-1代表走过的路径）\n");
	for(i = 0; i<M; i++){
		for(j = 0; j<N;j++){
	
	printf("%4d ",maze[i][j]);
	}
	printf("\n");
}
	printf("\n");

}

//处理迷宫
bool findPath(Direction direct[]){

int a,i,j;
int M,N;        //M是迷宫的行数，N是迷宫的列数
printf("   注意：  输入的M,N均要大于2\n\n");
printf("请输入M（迷宫的行数），N（迷宫的列数）： ");
scanf("%d %d",&M, &N);
	int maze[M][N];
	int *s[M];
	for(i=0;i<M;i++)
	  s[i]=maze[i];
	printf("请输入迷宫（输入1表示墙，输入0表示通道：）\n");
	for(i = 0; i<M; i++){
		for(j = 0; j<N;j++){
	cin >> a;
	maze[i][j]=a;
	}
}

int m1,n1;//起点坐标
	printf("请输入起点坐标：");
	scanf("%d %d", &m1, &n1);

	int m2,n2;//终点坐标
	printf("请输入终点坐标：");
	scanf("%d %d", &m2, &n2);
	Box temp;
		stack<Box>S;  
	int x, y, di;   //当前位置的横纵坐标和方向
	int line, col;   //下一位置的横纵坐标
	maze[m1][n1]=-1;
	temp={m1,n1,-1};  //初始化当前位置并入栈
	S.push(temp);
	
	//开始走迷宫，走过的位置信息要入栈，当下一位置路不通时要退栈访问，尝试其他路径方向
	while(!S.empty()){
temp=S.top();
S.pop();		
		x=temp.x; y=temp.y; di=temp.di+1;
		
	//	试探四个方向
		while(di<4){
			line=x+direct[di].incX;         //line 为下一位置的横坐标
			col=y+direct[di].incY;          //col 为下一位置的纵坐标
			if(maze[line][col]==0){         //如果下一位置能走
				temp={x, y, di};
				S.push(temp);
				x=line; y=col; maze[line][col]=-1;
				if(x==m2&&y==n2) {           //如果到达终点
					show(s,M,N);
					return true;
				}
				else di=0;                  //重置di的值为0用于下次循环
			}
			else di++;                     //如果下一位置不可走，di++后试探其他方向
		}
		
	}
	
	show(s,M,N);
	return false;	
	}
	

	
int main(){
	direct[0]={0,1};//向右
	direct[1]={1,0};//向下
	direct[2]={0,-1};//向左
	direct[3]={-1,0};//向上
	int i, j;

	if(findPath(direct)) cout<<"该迷宫能到达终点"<<endl;
	else cout<<"该迷宫不能到达终点"<<endl;
	
}

f7621eaf7f42452ea2b9404cce6c2397.png

C语言代码与注释

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

//方向的结构定义
typedef struct{
	int incX,incY;
}Direction;
 
Direction direct[4]; //创建四个方向的结构数组
 
//存储当前坐标和方向的结构体
struct Stack{
	int x, y;  //当前坐标
	int di;    //方向
	struct Stack*next;
};
int maze[100][100];
 //栈的创建
struct Stack* CreateStack(struct Stack*head);
//栈的判空
bool isEmpty(struct Stack*head);
//入栈
void push(struct Stack*head, struct Stack*x);
//访问栈顶元素
struct Stack* top(struct Stack*head);
//出栈
void pop(struct Stack*head);
//递归求迷宫
bool findPath( int M,int N,int startX, int startY, int endX, int endY);

//栈的创建
struct Stack* CreateStack(struct Stack*head){
	head = (struct Stack*)malloc(sizeof(struct Stack));	
	head->next=NULL;
	return head;
}

//栈的判空
bool isEmpty(struct Stack*head){
if(head->next==NULL) return true;	
	else return false;
}

//入栈
void push(struct Stack*head, struct Stack*x){
	x->next=head->next;
	head->next=x;
}

//访问栈顶元素
struct Stack* top(struct Stack*head){
	return head->next;
}


//出栈
void pop(struct Stack*head){
	if(head->next->next!=NULL) head->next=head->next->next;
	else head->next=NULL;
}

 
//打印迷宫
void show(int M, int N){
int i,j;
printf("\n");
	printf("迷宫如下：（-1代表走过的路径）\n");
	for(i = 0; i<M; i++){
		for(j = 0; j<N;j++){
	
	printf("%4d ",maze[i][j]);
	}
	printf("\n");
}
	printf("\n");
 
}
 
//迭代处理迷宫
bool FindPath(Direction direct[]){
 
int a,i,j;
int M,N;        //M是迷宫的行数，N是迷宫的列数
printf("\n注意：  输入数字时迷宫四周的最外层必须全部是 1\n\n");
printf("请输入M（迷宫的行数），N（迷宫的列数）： ");
scanf("%d %d",&M, &N);
	printf("请输入迷宫（输入1表示墙，输入0表示通道：）\n");
	for(i = 0; i<M; i++){
		for(j = 0; j<N;j++){
	scanf("%d",&a);
	maze[i][j]=a;
	}
}
 
int m1,n1;//起点坐标
	printf("请输入起点坐标：");
	scanf("%d %d", &m1, &n1);
 
	int m2,n2;//终点坐标
	printf("请输入终点坐标：");
	scanf("%d %d", &m2, &n2);
	struct Stack*H;
	struct Stack*head = CreateStack(H);
  if(maze[m1][n1]==1||maze[m2][n2]==1)
  {
  	printf("\n墙不能作为入口或出口，请重新输入！\n\n");
  	return false;
  }
	int x, y, di;   //当前位置的横纵坐标和方向
	int line, col;   //下一位置的横纵坐标
	maze[m1][n1]=-1;
	//初始化当前位置并入栈
	struct Stack*X=(struct Stack*)malloc(sizeof(struct Stack));
	X->x=m1;
	X->y=n1;
	X->di=-1;
	push(head,X);
	
	if(m1<M&&m1>=1&&n1>=1&&n1<N&&m2<M&&m2>=1&&n2>=1&&n2<N){
	
	//开始走迷宫，走过的位置信息要入栈，当下一位置路不通时要退栈访问，尝试其他路径方向
	while(!isEmpty(head)){
struct Stack*Temp=top(head);
pop(head);		
		x=Temp->x; y=Temp->y; di=Temp->di+1;
		
	//	试探四个方向
		while(di<4){
			line=x+direct[di].incX;         //line 为下一位置的横坐标
			col=y+direct[di].incY;          //col 为下一位置的纵坐标
			if(maze[line][col]==0){         //如果下一位置能走
				struct Stack*temp=(struct Stack*)malloc(sizeof(struct Stack));
				temp->x=x;
                temp->y=y;
	            temp->di=di;
				push(head,temp);
				x=line; y=col; maze[line][col]=-1;
				if(x==m2&&y==n2) {           //如果到达终点
					show(M,N);
					return true;
				}
				else di=0;                  //重置di的值为0用于下次循环
			}
			else di++;                     //如果下一位置不可走，di++后试探其他方向
		}
		
	}
	
	show(M,N);
	return false;	
}

else{
	printf("\n坐标输入有误，请重新输入！\n\n");
	return false;
}


	}
	
 
	
	
	//递归处理迷宫

 bool digui(){
int a,i,j;
int M,N;        //M是迷宫的行数，N是迷宫的列数
printf("注意：  输入的M,N均要大于2\n");
printf("请输入M（迷宫的行数），N（迷宫的列数）： ");
scanf("%d %d",&M, &N);
printf("请输入迷宫（输入1表示墙，输入0表示通道：）\n");
for(i = 0; i<M; i++){
for(j = 0; j<N;j++){
scanf("%d",&a);
maze[i][j]=a;
}
}
 
int m1,n1;//起点坐标
printf("请输入起点坐标：");
scanf("%d %d", &m1, &n1);
 
int m2,n2;//终点坐标
printf("请输入终点坐标：");
scanf("%d %d", &m2, &n2);

bool c=findPath(M,N,m1,n1,m2,n2);

if(c){
	maze[m2][n2]=-1;
	show(M,N);
	return true;
} 

else return false;
}


//maze是一个二维矩阵，0表示可以走，1表示不能走
//startX和startY是起点的坐标，endX和endY是终点的坐标
bool findPath( int M,int N,int startX, int startY, int endX, int endY) {
    //如果已经到达终点，则返回true
    if (startX == endX && startY == endY) {
        return true;
    }
    //如果当前位置不可走，则返回false
    if (maze[startX][startY] == 1) {
        return false;
    }
    //将当前位置标记为已访问
    maze[startX][startY] = -1;
    //递归查找下一个可走位置
    if (startX + 1 <= M && maze[startX + 1][startY] != -1 && findPath( M,N,startX + 1, startY, endX, endY)) {
        return true;
    }
    if (startX - 1 >= 0 && maze[startX - 1][startY] != -1 && findPath( M,N,startX - 1, startY, endX, endY)) {
        return true;
    }
    if (startY + 1 <= N && maze[startX][startY + 1] != -1 && findPath( M,N,startX, startY + 1, endX, endY)) {
        return true;
    }
    if (startY - 1 >= 0 && maze[startX][startY - 1] != -1 && findPath( M,N,startX, startY - 1, endX, endY)){
	return true;
	}
    
    //如果没有找到可走位置，则返回false
    return false;
}
	
	
	
int main(){
		direct[0].incX=0;	direct[0].incY=1;//向右
	    direct[1].incX=1;	direct[1].incY=0;//向下
	    direct[2].incX=0;	direct[2].incY=-1;//向左
	    direct[3].incX=-1;	direct[3].incY=0;//向上
	int i,j;
	for(i=0;i<99;i++)
	  for(j=0;j<99;j++)
	     maze[i][j]=1;
	int option = 1 ;
	while(option >= 1 && option <= 3){
		
	printf("\n                           1.用迭代求迷宫问题\n");
   	printf("                           2.用递归求迷宫问题\n");
   	printf("                           3.退出\n");
		scanf("%d",&option); 
	switch(option){
			case 1:
				{
					
					if(FindPath(direct)) printf("该迷宫能到达终点\n");
	                else printf("该迷宫不能到达终点\n");
					break;
				}
			
			
			case 2:
				{
					if(digui()) printf("该迷宫能到达终点\n");
	                else printf("该迷宫不能到达终点\n");
					break;
				}
			
			case 3:
				{
					break;
				}
				
					
		}                 
	if(option == 3) break;
	}
	
	
}

递归核心算法：

//maze是一个二维矩阵，0表示可以走，1表示不能走
//startX和startY是起点的坐标，endX和endY是终点的坐标
bool findPath( int M,int N,int startX, int startY, int endX, int endY) {
    //如果已经到达终点，则返回true
    if (startX == endX && startY == endY) {
        return true;
    }
    //如果当前位置不可走，则返回false
    if (maze[startX][startY] == 1) {
        return false;
    }
    //将当前位置标记为已访问
    maze[startX][startY] = -1;
    //递归查找下一个可走位置
    if (startX + 1 <= M && maze[startX + 1][startY] != -1 && findPath( M,N,startX + 1, startY, endX, endY)) {
        return true;
    }
    if (startX - 1 >= 0 && maze[startX - 1][startY] != -1 && findPath( M,N,startX - 1, startY, endX, endY)) {
        return true;
    }
    if (startY + 1 <= N && maze[startX][startY + 1] != -1 && findPath( M,N,startX, startY + 1, endX, endY)) {
        return true;
    }
    if (startY - 1 >= 0 && maze[startX][startY - 1] != -1 && findPath( M,N,startX, startY - 1, endX, endY)){
	return true;
	}
    
    //如果没有找到可走位置，则返回false
    return false;
}

迭代算法：（注意：循环之前要有一次入栈操作）

//开始走迷宫，走过的位置信息要入栈，当下一位置路不通时要退栈访问，尝试其他路径方向
	while(!isEmpty(head)){
struct Stack*Temp=top(head);
pop(head);		
		x=Temp->x; y=Temp->y; di=Temp->di+1;
		
	//	试探四个方向
		while(di<4){
			line=x+direct[di].incX;         //line 为下一位置的横坐标
			col=y+direct[di].incY;          //col 为下一位置的纵坐标
			if(maze[line][col]==0){         //如果下一位置能走
				struct Stack*temp=(struct Stack*)malloc(sizeof(struct Stack));
				temp->x=x;
                temp->y=y;
	            temp->di=di;
				push(head,temp);
				x=line; y=col; maze[line][col]=-1;
				if(x==m2&&y==n2) {           //如果到达终点
					show(M,N);
					return true;
				}
				else di=0;                  //重置di的值为0用于下次循环
			}
			else di++;                     //如果下一位置不可走，di++后试探其他方向
		}
		
	}
	
	show(M,N);
	return false;	
}

JAVA 之子
关注
C++迷宫问题
Christopherwa的博客
01-28 4731
C++迷宫问题
c++迷宫问题
12-11
c++迷宫问题，强用1表示，通路用0表示 最后输出迷宫路径
C++实现迷宫问题
weixin_33995481的博客
05-14 919
新建一个.txt文档来存储迷宫，输入n*n的迷宫矩阵并保存起来，如下图//Stack.h#pragmaonce template<classT> classstack { public: stack()//构造函数 :_arr(NULL) ,_top(0) ,_capacity(0) {} ~stack()...
C++迷宫求解算法实现与优化
最新发布
weixin_28968525的博客
09-25 967
本文还有配套的精品资源，点击获取 简介：在C++中，迷宫求解算法是编程学习的重要课题，涉及搜索算法、图论和路径查找技术。迷宫通常被抽象为二维矩阵，算法包括深度优先搜索（DFS）、广度优先搜索（BFS）和A*算法等。文章将详细介绍这些方法在C++中的实现，并强调如何通过数据结构和优先级队列来优化搜索效率，实现路径回溯。最终目标是创建一个 MazeSolver 类...
迷宫问题c++代码
不才的专栏
07-16 4428
#include #include #include #include #include #include using namespace std;#define LEN 12typedef struct{ int x,y;}postype;typedef struct{ int m,n; int arr[LEN][LEN];}mazetype;typedef struct{ int
c++ 迷宫问题
weixin_30511039的博客
08-31 549
迷宫问题 Description 定义一个二维数组： 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 ...
C++ 迷宫问题
赵四司机的博客
06-04 1527
问题描述： 有一个迷宫地图，有一些可达的位置，也有一些不可达的位置（障碍、墙壁、边界）。从一个位置到下一个位置只能通过向上（或者向右、或者向下、或者向左）走一步来实现，从起点出发，找到任何可以到达出口的路径并输出，最后输出最短路径以及最短路径长度。 用二维矩阵来模拟迷宫地图，1代表该位置不可达，0代表该位置可达。每走过一个位置就将地图的对应位置标记，以免重复。 以下是源代码： 迷宫.cpp: #include"迷宫1.h" int main() { cout << "该迷宫为：" &lt
迷宫问题——数据结构课程设计迷宫问题完整版(含源代码).pdf
06-16
《迷宫问题——数据结构课程设计迷宫问题完整版》是一份详细的教学材料，涵盖了如何使用数据结构解决迷宫问题的全过程。这份资料是针对兰州理工大学计算机与通信学院2012年春季学期《算法与数据结构》课程设计的项目...
迷宫问题——数据结构课程设计迷宫问题完整版(含源代码).docx
06-18
《迷宫问题——数据结构课程设计迷宫问题完整版(含源代码)》是一份详细的实践教学材料，针对计算机科学与技术专业学生的算法与数据结构课程设计。该文档旨在通过解决迷宫问题来深入理解数据结构的应用，以及提高编程...
迷宫问题-数据结构课程设计迷宫问题完整版(含源代码).docx
05-25
标题中的“迷宫问题-数据结构课程设计迷宫问题完整版(含源代码).docx”指的是一个关于数据结构课程设计的项目，该项目聚焦于解决迷宫问题。迷宫问题是一个经典的路径寻找问题，通常涉及到深度优先搜索（DFS）、广度...
迷宫问题—数据结构课程设计迷宫问题完整版(含源代码+报告).rar
02-16
本程序主要是对任意给定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。使我们基本掌握线性表及栈上基本运算的实现，进一步理解和熟练掌握课本中所学的各种数据结构，学会如何把学到的知识用于解决实际...
迷宫求解课程设计报告完整版
05-20
【迷宫求解课程设计】是计算机科学领域中常见的一个问题，通常用于教授基本的图论概念和搜索算法。在这个课程设计中，目标是设计一个C++程序，解决一个8x8的迷宫问题，从入口(1,1)找到所有可能路径及最短路径至出口...
迷宫问题 C++程序
09-10
这是心理学中的一个经典问题。心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入，让老鼠自行找到出口出来。迷宫中设置很多障碍阻止老鼠前行，迷宫唯一的出口处放有一块奶酪，吸引老鼠找到出口。 简而言之，迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题。
C++之迷宫问题
Exist1001的博客
11-13 7141
问题描述    迷宫问题： 迷宫问题的求解是实验心理学中的一个经典问题，心理学家把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫，迷宫中设置很多墙壁，对前进的方向形成了多处 障碍，心理学家在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以达到出口。设计算法实现迷宫问题。迷宫示意图，其中1代表有障碍，0代表无障碍，前进方向 有四个，分别是上，下， 左，右。 1 1 1 1 1 1 1 1 1...
迷宫问题 C++
weixin_43943281的博客
10-31 353
迷宫问题 问题描述： 其中黑色节点表示无法通行，白色节点表示可以同行，需要找出从一个节点到另一个节点的路径。 (B)问题分析： 采用回溯算法，设置俩个栈，一个栈存放已选路径，另一个栈存放已选路径中的周围可通行节点。采用深度优选进行遍历，如果遇到死胡同，则进行回溯，并对栈做相应处理。 ©算法实现： typedef struct Node { int row; int col; Node(int row, int col) :row(row), col(col) {}; Node() {}; boo
迷宫问题C++
m0_73934144的博客
12-11 1188
定义一个二维数组： 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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
迷宫问题_C++
DYNA_M的博客
04-01 2136
Description 有一个 10 x 10 的迷宫，起点是‘S’，终点是‘E’，墙是‘#’，道路是空格。一个机器人从起点走到终点。当机器人走到一个通道块，前面已经没有路可走时，它会转向到当前面向的右手方向继续走。如果机器人能够过，则留下足迹‘*’，如果走不通，则留下标记‘!’。 下面给出书中的算法，请你模拟机器人的走法输出最终的状态。 Input 一个 10 x 10 的二维字符数组。 Out...
C++ 实现迷宫问题
ztt_1105的博客
07-21 2639
通过C++设计了一个迷宫游戏，涉及到链表，C++基本操作，终端字符处理，深度优先遍历算法。下面开始吧！ 在全局变量中定义地图，包括地图的长和高（30*20），同时还需定义一些标记。 flag 用于创建地图，true代表地图传创建成功。 slow用于更换游戏速度，true代表游戏慢速。 autogame用于更换游戏模式，true代表自动游戏。 #define MAX_X 20 #define...
数据结构——迷宫问题用C++完整版
04-29
以下是使用 C 语言实现迷宫问题的完整代码： ```c #include #include #include #define MAX_ROW 5 #define MAX_COL 5 int maze[MAX_ROW][MAX_COL] = { {0, 1, 0, 0, 0}, {0, 1, 0, 1, 0}, {0, 0, 0, 0, 0}, ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值