迷宫问题（不太熟）

最新推荐文章于 2024-03-11 22:00:17 发布
最新推荐文章于 2024-03-11 22:00:17 发布
阅读量152 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41218103/article/details/107674622
版权

1.用栈解决

/*用栈求解迷宫问题*/
#include<stdio.h>
#define maxsize 100 
typedef struct
{
	int i;  //行号 
	int j; //列号 
	int di; //方位 
}BOX;
typedef struct
{
	BOX data[maxsize];
	int top;  //栈顶 
 } stType;
 int mg[10][10]= {{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,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};//地图
int M=8;//行数
int N=8;//列数
bool mgpath(int x,int y,int xe,int ye)
{
	BOX path[maxsize];
	int k=0,di=-1,i,j,find=0;
	stType s;
	s.top=-1;
	s.top++;
	s.data[s.top].i=x;
	s.data[s.top].j=y;
	s.data[s.top].di=-1;
	mg[x][y]=-1;  //将入口处的迷宫值设为-1避免重复走到该处 
	while(s.top!=-1)
	{
		di=s.data[s.top].di;//原因：若栈顶元素是第一次做栈顶则：每个栈的栈顶元素的di值均为-1 
	//若栈顶元素是第二次做栈顶即曾进栈过一个元素，但这个元素无相邻的可走方块从而回退到栈顶元素，
			//则应从目前栈顶元素di的di+1方向开始找，
			//因为刚刚di之前的已经找过路了,di方向对应的元素方块无相邻的可走方块 
		if(s.data[s.top].i==xe&&s.data[s.top].j==ye)
		{
			printf("迷宫路径如下:\n");
			while(s.top!=-1)
			{
				path[k++]=s.data[s.top];
				s.top--;
			}
			while(k>=1)
            {
            	k--;
                printf("\t(%d,%d)",path[k].i,path[k].j);
                if((k+2)%5==0)
                    printf("\n");
            }
			return true;
		}
		else 
		{
			find=0;
			while(di<=3)
			{
				printf("di1:%d\n",di);
				printf("------------\n");
				di++;
				printf("di:%d\n",di);
				if (di==1)
				{
					i=s.data[s.top].i;
					j=s.data[s.top].j+1;
				}
				else if(di==2)
				{
					i=s.data[s.top].i+1;
					j=s.data[s.top].j;
				}
				else if(di==3)
				{
					i=s.data[s.top].i;
					j=s.data[s.top].j-1;
				}
				else if(di==0)
				{
					i=s.data[s.top].i-1;
					j=s.data[s.top].j;
				}
				if (mg[i][j]==0)
				{
					s.data[s.top].di=di;
					s.top++;
					s.data[s.top].di=-1;
					s.data[s.top].i=i;
					s.data[s.top].j=j;
					find=1;
					mg[i][j]=-1; 
					break;
				}
			}
			printf("===========\n");
			if(find==0)
			{
				mg[s.data[s.top].i][s.data[s.top].j]=0;
				s.top--;
			}
		}
	 }
	 return false; 
}
int main()
{
	if(mgpath(1,1,M,N)!=true)
        printf("false！！\n");
    return 0;
}

2.用队列解决

函数：

bool mgpath(int x,int y,int xe,int ye)
{
	qutype q;
	int i,j;
	q.front=q.rear=-1; 
	q.rear++;
	q.data[q.rear].i=x;
	q.data[q.rear].j=y;
	q.data[q.rear].pre=-1;
	mg[x][y]=-1;
	while(q.rear!=-1)
	{
		q.front++;
		i=q.data[q.front].i;
		j=q.data[q.front].j;
		if (i==xe&&j==ye)
		{
			
			print(q,q.front);
			return true;
		}
		else
		{
			for(int di=0;di<4;di++)
			{
				if (di==1)
				{
					i=q.data[q.front].i;
					j=q.data[q.front].j+1;
				}
				else if(di==2)
				{
				    i=q.data[q.front].i+1;
					j=q.data[q.front].j;
				}
				else if(di==3)
				{
					i=q.data[q.front].i;
					j=q.data[q.front].j-1;
				}
				else if(di==0)
				{
					i=q.data[q.front].i-1;
					j=q.data[q.front].j;
				}
				if(mg[i][j]==0)
				{
					q.rear++;
					q.data[q.rear].i=i;
					q.data[q.rear].j=j;
					q.data[q.rear].pre=q.front;
					mg[i][j]=-1;
				}
			}
		}
	}
	return false;
}

完整代码：

 #include<stdio.h>
#define maxsize 100 
typedef struct
{
	int i;  //行号 
	int j; //列号 
	int pre; //上一个方块的下标 
}BOX;
typedef struct
{
	BOX data[maxsize];
	int front,rear;
}qutype;
int mg[10][10]= {{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,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};//地图
int M=8;//行数
int N=8;//列数
void print(qutype q,int front)
{
	printf("ok!\n");
	int k=front,k1;
	printf("k:%d\n",k);
	do
	{
	    k1=k;
		k=q.data[k].pre;
	//	printf("k:%d\n",k);
		q.data[k1].pre=-1;
	}while(k!=0);
	printf("路径如下:\n");
	for(int k=0;k<maxsize;k++)
	{
		int j=0;
		if(q.data[k].pre==-1)
		{
			j++;
			printf("(%d,%d)",q.data[k].i,q.data[k].j);
			if(j%5==0)
			printf("\n");
		}
			
			
	}
}
bool mgpath(int x,int y,int xe,int ye)
{
	qutype q;
	int i,j;
	q.front=q.rear=-1; 
	q.rear++;
	q.data[q.rear].i=x;
	q.data[q.rear].j=y;
	q.data[q.rear].pre=-1;
	mg[x][y]=-1;
	while(q.rear!=-1)
	{
		q.front++;
		i=q.data[q.front].i;
		j=q.data[q.front].j;
		if (i==xe&&j==ye)
		{
			
			print(q,q.front);
			return true;
		}
		else
		{
			for(int di=0;di<4;di++)
			{
				if (di==1)
				{
					i=q.data[q.front].i;
					j=q.data[q.front].j+1;
				}
				else if(di==2)
				{
				    i=q.data[q.front].i+1;
					j=q.data[q.front].j;
				}
				else if(di==3)
				{
					i=q.data[q.front].i;
					j=q.data[q.front].j-1;
				}
				else if(di==0)
				{
					i=q.data[q.front].i-1;
					j=q.data[q.front].j;
				}
				if(mg[i][j]==0)
				{
					q.rear++;
					q.data[q.rear].i=i;
					q.data[q.rear].j=j;
					q.data[q.rear].pre=q.front;
					mg[i][j]=-1;
				}
			}
		}
	}
	return false;
}
int main()
{
	if(mgpath(1,1,M,N)!=true)
        printf("false！！\n");
    return 0;
}

3.用递归

#include<stdio.h>
#include<stdlib.h>
#define maxsize 100
typedef struct
{
	int i;
	int j;
 } Box;
 typedef struct
 {
 	Box data[maxsize];
 	int length;
 }pathtype;
 int mg[6][6]= {{1,1,1,1,1,1},
    {1,0,0,0,1,1},
    {1,0,1,0,0,1},
    {1,0,0,0,1,1},
    {1,1,0,0,0,1},
    {1,1,1,1,1,1}
};//地图
int M=4;//行数
int N=4;//列数
int I=0;
 void mgpath(int x,int y,int xe,int ye,pathtype path)
 {
 	if(x==xe&&y==ye)
 	{
 		path.data[path.length].i=x;
 		path.data[path.length].j=y;
 		mg[x][y]=-1;
 		path.length++;
 		//printf("I:%d\n",I++);
 		for(int k=0;k<path.length;k++)
 		{
 			printf("\t(%d,%d)\t",path.data[k].i,path.data[k].j);
 		//	if((k+1)%5==0)
 		//		printf("\n");
		 }
		 printf("\n");
	 }
	 else
	 {
	 	if(mg[x][y]==0)  //[x][y]可走 
	 	{
	 		int di=0,i1,j1;
		 	while(di<4)
		 	{
			 	path.data[path.length].i=x;
		 		path.data[path.length].j=y;
		 	//	mg[x][y]=-1;
		 		path.length++;
		 		switch(di)
		 		{
		 			case 0:i1=x-1;j1=y;break;
		 			case 1:i1=x;j1=y+1;break;
		 			case 2:i1=x+1;j1=y;break;
		 			case 3:i1=x;j1=y-1;break;
				}
				mg[x][y]=-1;
				mgpath(i1,j1,xe,ye,path);
				path.length--;   //回退找不同的路径 
				mg[x][y]=0;
				di++;
		 	}
	 	}
	 }
 }
 int main()
 {
 	pathtype p;
 	p.length=0;
 	int x=1,y=1,xe=4,ye=4;
 	mgpath(x,y,xe,ye,p);
 	return 0;
 }
立里∑
关注
专栏目录
python迷宫问题_迷宫问题python实现(靠右手摸墙)
weixin_39848970的博客
12-04 590
这是大二时候的数学模型毕业课程设计，我选择了自己研究盲人穿越迷宫的问题。当然后来再在网上查了这个问题研究比较成熟了，但是自己研究出来了也是小有成果的。当时是用C++实现的，而且用了不必要的递归来进行。现简化为简单的循环，并使用python实现了。以下进行我自己设计算法的思路设计，最后附上现在的python源码“@”表示墙，“·”表示迷宫中可行路线上的空格，走过的路线用“X”表示。本问题只研究12×...
多种 迷宫问题 与 多种 解法
CourserLi的博客
01-20 992
包含4道不同类型的迷宫问题，其中包含的解法有：DFS、BFS、二分法、（模拟），使用的主体包含： 数组 和 queue容器
数据结构-线性
weixin_47478682的博客
03-25 114
栈 原理：先进后出。 顺序存储 #include<stdio.h> #define max 10000 typedef struct stack { int data[max]; int top; }Stack; int insert(Stack *s,int n); int main() { Stack s; s.top=-1;//表示没有数。 int n,i; scanf("%d",&n); if(insert(&s,n
小韩详解Linux常用命令 -- top
Pangpangbupang.
09-15 3861
前言： top命令是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，类似于Windows的任务管理器。下面详细介绍它的使用方法。top是一个动态显示过程,即可以通过用户按键来不断刷新当前状态.如果在前台执行该命令,它将独占前台,直到用户终止该程序为止。比较准确的说,top命令提供了实时的对系统处理器的状态监视。它将显示系统中CPU最“敏感”的任务列表.该命令可以按CPU使用。内存使用和执行时间对任务进行排序；而且该命令的很多特性都可以通过交互式命令或者在个人定制文件...
迷宫问题
w17865816936的博客
02-25 350
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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线
迷宫问题代码详解
七分熟少女
07-08 3161
迷宫问题是回溯法的典型应用，可以用栈解决，也可以用队列来解决迷宫问题。 下面是小编用栈解决迷宫问题的已经成功运行的代码，提供给大家参考。 #include<iostream> #include<stdlib.h> using namespace std; #define MaxSize 100 typedef struct Box { int i; //当前方块...
对迷宫问题应用深度搜索算法,利用python代码实现过程中出现的一些不成熟想法
最新发布
qq_48370921的博客
03-11 245
①在按照公式:pre_direction=2*(当前位置的行坐标-先前位置的行坐标)+当前位置的列坐标-先前位置的列坐标,计算后运行代码,仍然出现了后退-前进的逻辑死循环,情况未有改变.①建立一个方向搜索函数,按照东南西北的方向搜索可以前进的方向,一旦有一个方向可以前进,给出前进坐标,并退出函数,否则返回-1(表示无看前进方向).目前的解决算法:深度搜索算法:从一个点出发,选择一个方向,直到没有方向可以前进,则退回到上一个有方向前进的点,从另一个方向继续搜索.向上-向左-向下-向前-向上-...
回溯算法迷宫c语言中文网,回溯算法解迷宫问题（C语言）.doc
weixin_42115513的博客
05-23 302
回溯算法解迷宫问题(C语言).doc回溯算法解迷宫问题 C 语言回溯法也称为试探法,该方法首放弃关于问题规模大小的限制 ,并将问题的候选解按某一顺序逐一枚举和试验.当发现当前候选解不可能是解时 ,就选择下一个候选解;倘若当前候选解除了还不满足问题规模要求外,满足所有其他要求时 ,继续扩大当前候选解的规模,并继续试探. 如果当前候选解满足包括问题规模在内的所有要求时, 该候选解就是问题的一个解. 在...
poj3984迷宫问题
qq_42759120的博客
07-22 121
连接：http://poj.org/problem?id=3984 描述 定义一个二维数组： INT迷宫[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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到...
migong.rar_迷宫游戏
09-21
迷宫游戏的核心算法是解决寻路问题，A*寻路算法是一种常用的方法。A*算法结合了Dijkstra算法和最佳优先搜索，通过引入启发式函数（如曼哈顿距离或欧几里得距离）来预测到达目标的代价，从而有效减少搜索空间，提高...
android 迷宫游戏设计.7z
03-31
传统的迷宫游戏靠按键来控制角色的移动，虽然这些迷宫游戏无论是地图还是操作都已比较成熟，但运行在Android平台上无法展示出Android重力感应的优势。另一方面，运行在Android上的迷宫还很少见。
双人迷宫游戏.pptx
09-26
根据给定文件的信息，我们可以提炼出与“双人迷宫游戏”相关的知识点，包括但不限于游戏设计、PPT模板使用以及游戏开发中常见的元素等。 ### 游戏设计基础 #### 双人迷宫游戏概念 - **定义**：双人迷宫游戏是一种...
C语言 - 【回溯算法】迷宫问题 (顺序栈与链栈)
热门推荐
⚡
11-07 1万+
回溯算法可以看成是栈的一个十分成熟的应用， 本质上秉承着："正确前进错误返回"的原则，通过入栈存储以前经过的所有节点， 当在一个方向上遇到死路，则依次弹栈返回前一个节点，继续按照相同的规律继续下一步的判断+入栈+弹栈操作。 < 本篇文章主要通过顺序栈与链栈(通过链表模拟)的方式实现迷宫问题 > 一：迷宫问题思路分析及实现（顺序栈） 1> 先不谈具体算法，首...
C语言中base operand of ‘-＞‘is not a pointer的错误
qq_41218103的博客
07-25 1万+
如果你使用的变量x是个结构体，应该用.访问其成员，如：x.num 如果你使用的变量x是个结构体指针，应该用->访问其成员，如：x->num 如果当前变量x是个结构体而你却使用了x->num的方式访问，就属会出现上面的报错。 "."一般情况下读作"的”，结构体a的b。 “->”一般读作"指向的结构体的"，a指向的结构体的b ...
一元多项式相加（单链表的应用）
qq_41218103的博客
08-02 1109
#include<stdio.h> #include<stdlib.h> typedef struct Lnode { float coef;//系数 int expn;//指数 struct Lnode *next; } Lnode,*Linknode; void init(Linknode &L) //初始化L { L=(Linknode)malloc(sizeof(Linknode)); L->next=NULL; } void
第二章王道数据结构练习题12-14题--7/21
qq_41218103的博客
07-21 230
#include<stdio.h> #include<stdlib.h> typedef struct DNode { int data; struct DNode *next; } DNode,*DLinklist; void init(DLinklist &L) //初始化链表 利用前插法 { int x=0; L=(DLinklist)malloc(sizeof(DNode)); L->next=NULL; printf("请输入
队列
qq_41218103的博客
07-25 190
顺序队列 注意：（1）进队操作要先判断栈是否满（由于顺序队列不好判断 −>->−>循环队列） （2） 先将数据放入尾指针所指的数组，再尾指针++。 L.data[L.rear]=e ; L.rear++; void init(squeue &L) //初始化 { L.front=L.rear=0; } bool enter(squeue &L,int e) { if (队满) return false; L.data[L.r.
使用BFS解决迷宫问题
"本文介绍了一种解决迷宫问题的方法，通过广度优先搜索（BFS）算法寻找从起点到终点的最短路径。代码详细易懂，适合初学者学习。" 在计算机科学中，迷宫问题是一个经典的路径搜索问题，通常涉及到在一个二维网格中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值