三种迷宫小算法

最新推荐文章于 2023-04-26 09:37:04 发布
最新推荐文章于 2023-04-26 09:37:04 发布
阅读量764 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ksaila/article/details/82631643
版权

1.简单迷宫（只有一条通路或者是有几条通路（不带环））

SimpleMaze.h

#ifndef AAA
#define AAA

#include<stdio.h>
#include<assert.h>

#define NUMBER 20
#define ROW 6
#define COL 6
typedef int DataType;

//地图
typedef struct Maze
{
	int map[ROW][COL];
}Maze;

//坐标
typedef struct Coordinate
{
	DataType x;
	DataType y;
}Coordinate;

//栈
typedef struct Stack
{
	Coordinate a[NUMBER];
	int top;
}Stack;

void Cpmap(DataType a[ROW][COL], Maze *q);
void InitStack(Stack *cur);
void WalkMaze(Coordinate entry, Maze *q, Stack *cur);
void WalkMaze2(Coordinate entry, Maze *q, Stack *cur);
void PrintMaze(Maze q);

#endif //AAA

MazeFunc.c

#include"SimpleMaze.h"

//地图  
void Cpmap(DataType a[ROW][COL], Maze *q)
{
   int i = 0;
   int j = 0;
   for(i = 0; i < ROW; i++)
   {
	   for(j = 0; j < COL; j++)
	   {
		   q->map[i][j] = a[i][j];
	   }
   }
}
//初始化栈
void InitStack(Stack *cur)
{
	assert(cur);
	cur->top = 0;
}
//入栈
void PushStack(Stack *cur, Coordinate entry)
{
	assert(cur);
	cur->a[cur->top] = entry;
	cur->top++;
}
//出栈
void PopStack(Stack *cur)
{
	assert(cur);
	cur->top--;
}
//判断栈是否为空
int EmptyStack(Stack *cur)
{
	assert(cur);
	return 0 == cur->top;
}
//取栈顶的元素
Coordinate TopCellStack(Stack *cur)
{
	assert(cur);
	if(cur->top != 0)
		return cur->a[cur->top-1];
}
//判断该坐标是否是通路
int Passage(Maze *q,int x, int y)
{
	//首先判断坐标是否在有效的范围内
	if(x < ROW && x >= 0 && y < COL && y >= 0)
	{
		if(q->map[x][y] == 1)
		{
			return 1;
		}
	}
	return 0;
}
//判断是否是出口
int ExitMaze(Coordinate ret, Coordinate entry)
{
	if((ret.x == 0 || ret.x == ROW-1 || ret.y == 0 || ret.y == COL-1)&& ret.x != entry.x && ret.y != entry.y)
		return 1;
	return 0;
}
//打印迷宫
void PrintMaze(Maze q)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < ROW; i++)
	{
		for(j = 0; j < COL; j++)
		{
			printf("%d ", q.map[i][j]);
		}
		printf("\n");
	}
}
//简单的单通路迷宫

//入口--》走迷宫
//循环下面操作，直到找到出口/站空时退出
//    获取栈顶元素
//    每走一步，标记，判断是否到出口的位置,入栈
//    上：检测tmp的上方是否为通路
         //是：向上走--》入栈；continue
//     下：检测tmp的下方是否为通路
         //是：向下走--》入栈
//     左：检测tmp的左方是否为通路
         //是：向左走--》入栈
//     右：检测tmp的右方是否为通路
        //是：向右走--》入栈
//     当前步走错--》回退--》出栈
void WalkMaze(Coordinate entry, Maze *q, Stack *cur)
{
	Coordinate ret = entry;
	assert(cur && q);
	//首先标记入口节点，用2来表示已经走过的节点
	q->map[entry.x][entry.y] = 2;
	PushStack(cur,entry);
	while(!EmptyStack(cur))
	{
		Coordinate tmp = {0};
		ret = TopCellStack(cur);
		//到达迷宫的出口
		if(ExitMaze(ret, entry))
		{
			break;
		}
		tmp = ret;
		//上面是通路
		if(Passage(q,tmp.x-1, tmp.y))
		{
			tmp.x -= 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;
		}
		//下面是通路
		if(Passage(q,tmp.x+1, tmp.y))
		{
			tmp.x += 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;			
		}
		//左边是通路
		if(Passage(q,tmp.x,tmp.y-1))
		{
			tmp.y -= 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;
		}
		//右边是通路
		if(Passage(q, tmp.x, tmp.y+1))
		{
			tmp.y += 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;
		}
		//如果上下左右都不可以代表此处是一个死胡同，立刻出栈
		PopStack(cur);
		//用3来表示出栈的地址
		q->map[tmp.x][tmp.y] = 3;
	}
}
//多条通路的迷宫
//当走到第一条路的出口时，不要立即退出
//而是开始出栈返回，寻找第二条路，
//直到栈为空时停止
void WalkMaze2(Coordinate entry, Maze *q, Stack *cur)
{
	Coordinate ret = entry;
	assert(cur && q);
	//首先标记入口节点，用2来表示已经走过的节点
	q->map[entry.x][entry.y] = 2;
	PushStack(cur,entry);
	while(!EmptyStack(cur))
	{
		Coordinate tmp = {0};
		ret = TopCellStack(cur);
		tmp = ret;
		//到达迷宫的出口时，先打印一条路径，然后原路返回
		if(ExitMaze(ret, entry))
		{
			PrintMaze(*q);
			printf("\n");
			q->map[tmp.x][tmp.y] = 3;			
		}
		//上面是通路，向上走
		if(Passage(q,tmp.x-1, tmp.y))
		{
			tmp.x -= 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;
		}
		//下面是通路，向下走
		if(Passage(q,tmp.x+1, tmp.y))
		{
			tmp.x += 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;			
		}
		//左边是通路，向左走
		if(Passage(q,tmp.x,tmp.y-1))
		{
			tmp.y -= 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;
		}
		//右边是通路， 向右走
		if(Passage(q, tmp.x, tmp.y+1))
		{
			tmp.y += 1;
			PushStack(cur,tmp);
			q->map[tmp.x][tmp.y] = 2;
			continue;
		}
		//如果上下左右都不可以代表此处是一个死胡同，代表此时走错了，立刻出栈
		PopStack(cur);
		//用3来标记走错的路径
		q->map[tmp.x][tmp.y] = 3;
	}
}

Maze.c

#include"SimpleMaze.h"

void Text()
{
	Stack cur = {0};
	Coordinate entry;
	Maze m = {0};
	DataType a[ROW][COL] = {
	0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0,
	0, 1, 1, 1, 1, 1,
	0, 1, 0, 0, 0, 0,
	0, 1, 1, 1, 1, 1,
	0, 1, 0, 0, 0, 0
	};
	entry.x = 5;
	entry.y = 1;
	InitStack(&cur);
	Cpmap(a, &m);
    WalkMaze(entry, &m, &cur);
	PrintMaze(m);
}

int main()
{
	Text();
	return 0;
}

2.带环的迷宫

Maze.h

#ifndef AAA
#define AAA

#include<stdio.h>
#include<assert.h>

#define NUMBER 20
#define ROW 6
#define COL 6
typedef int DataType;

//地图
typedef struct Maze
{
	int map[ROW][COL];
}Maze;

//坐标
typedef struct Coordinate
{
	DataType x;
	DataType y;
}Coordinate;

//栈
typedef struct Stack
{
	Coordinate a[NUMBER];
	int top;
}Stack;

void StackInit(Stack *ret);
void ArrayInit(DataType a[ROW][COL], Maze *m);
void StackPop(Stack *cur);
int IsPass(Maze* m,Coordinate next,Coordinate ret);
int IsExport( Coordinate  next, Coordinate entry);
void  StackPush(Stack *cur, Coordinate ret);
void printMaze(Maze m);
void MazeRoute(Maze *m, Coordinate entry, Coordinate ret, Stack *cur, Stack *shortpath);

#endif //AAA

MazeFunc.c

#include"Maze.h"

//栈的初始化
void StackInit(Stack *ret)
{
	assert(ret);
	ret->top = 0;
}
//初始化地图
void ArrayInit(int a[ROW][COL], Maze *m)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < ROW; i++)
	{
		for(j = 0; j < COL; j++)
		{
			m->map[i][j] = a[i][j];
		}
	}
}
//出栈
void StackPop(Stack *cur)
{
	assert(cur);
	if((cur)->top == 0)
	{
		printf("栈空了\n");
		return;
	}
	(cur)->top--;
}
//是否是通路
int IsPass(Maze* m,Coordinate next,Coordinate ret)
{
	if(m->map[next.x][next.y] == 1 || m->map[next.x][next.y] > m->map[ret.x][ret.y])
	{
		return 1;
	}
	return 0;
}
//判断是否是出口
int IsExport( Coordinate  next, Coordinate entry)
{
	if(next.x == 0 || next.x == ROW-1 || next.y == 0 || next.y == COL-1)
	{
		if(next.x != entry.x && next.y != entry.y)
			return 1;
	}
	return 0;
}
//入栈
void  StackPush(Stack *cur, Coordinate ret)
{
	assert(cur);
	cur->a[cur->top] = ret;
	cur->top++;
}
//打印
void printMaze(Maze m)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < ROW; i++)
	{
		for(j = 0; j < COL; j++)
		{
			printf(" %d ", m.map[i][j]);
		}
		printf("\n");
	}
}
//迷宫路线
void MazeRoute(Maze *m, Coordinate entry, Coordinate ret, Stack *cur, Stack *shortpath)
{
	Coordinate next = ret;
	if(cur->top == 0)
		m->map[entry.x ][entry.y] = 2;
	//判断坐标是否合格
	if(!(ret.x >= 0 && ret.x < ROW && ret.y >= 0 && ret.y < COL))
	{
		printf("坐标不合理\n");
		return ;
	}
	//判断是否是出口
	if(IsExport(next, entry))
	{
		int i = 0;
		StackPush(cur, ret);
		if(shortpath->top == 0 || (shortpath->top > cur->top && shortpath->top))
		{
			for(i = 0; i < cur->top; i++)
			{
				shortpath->a[i] = cur->a[i];
			}
		}
		shortpath->top = cur->top;
		StackPop(cur);
		return ;
	}
		StackPush(cur, ret);
	//上
	next = ret;
	next.x -= 1;
	if(IsPass(m, next, ret))
	{
		m->map[next.x][next.y] = m->map[ret.x][ret.y]+1;
		MazeRoute(m, entry, next, cur, shortpath);
	}
	//下
	next = ret;
	next.x += 1;
	if(IsPass(m, next, ret))
	{
		m->map[next.x][next.y] = m->map[ret.x][ret.y]+1;
		MazeRoute(m, entry, next, cur, shortpath);
	}
	//左
	next = ret;
	next.y -= 1;
	if(IsPass(m, next, ret))
	{
		m->map[next.x][next.y] = m->map[ret.x][ret.y]+1;
		MazeRoute(m, entry, next, cur, shortpath);
	}
	//右
	next = ret;
	next.y += 1;
	if(IsPass(m, next, ret))
	{
		m->map[next.x][next.y] = m->map[ret.x][ret.y]+1;
		MazeRoute(m, entry, next, cur, shortpath);
	}
	StackPop(cur);
}

Maze.c

#include"Maze.h"

void Text()
{
	Stack cur;
	Stack shortpath;
	Coordinate entry;
	Maze m;
	DataType a[ROW][COL] = {
	0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0,
	0, 1, 1, 1, 0, 0,
	0, 1, 0, 1, 0, 0,
	0, 1, 1, 1, 1, 1,
	0, 1, 0, 0, 0, 0
	};
	entry.x = 5;
	entry.y = 1;
	StackInit(&cur);
	StackInit(&shortpath);
	ArrayInit(a, &m);
	MazeRoute(&m, entry, entry, &cur, &shortpath);
	printMaze(m);
}

int main()
{
	Text();
	return 0;
}

 

Ksaila
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
01数组寻找通路c语言,迷宫算法 之 迷宫生成和迷宫寻路
weixin_34071707的博客
05-23 1401
迷宫算法 之 迷宫生成和迷宫寻路本文讲解迷宫生成和迷宫寻路算法。////////////////////////////////////////////////////////////////////////////////////////////////////一、三种迷宫生成算法1、 DFS(即深度优先)算法生成，分为递归和非递归方法。2、 十字分割算法生成，分为递归和非递归方法。3、随机 ...
迷宫问题的三种求解方法（递归求解、回溯求解和队列求解）
永远飞翔的鸟
03-25 1万+
目录 一、迷宫问题的三种求解方法 递归求解 回溯求解 队列求解 二、华为迷宫问题 一、迷宫问题的三种求解方法 在迷宫问题中，给定入口和出口，要求找到路径。本文将讨论三种求解方法，递归求解、回溯求解和队列求解。 在介绍具体算法之前，先考虑将迷宫数字化。这里将迷宫用一个二维的list存储（即list嵌套在list里），将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用...
算法基础课——走迷宫（BFS）
m0_51553141的博客
01-25 2093
走迷宫 问题描述 给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。 最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。 请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。 数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。 输入格式 第一行包含两个整数 n 和 m。 接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维
迷宫问题的三种实现算法
Zju_ycj的博客
04-08 1万+
2.走迷宫2.1 问题描述给定一个迷宫Maze，并给定迷宫的路口和出口，用递归的方式搜索一条从入口到出口的可行路径（其中红色为围墙，蓝色为可行路），若存在这条路径，则打印出路径，若不存在路径，则输出信息，表示没有路径。  2.2 问题解决思路和关键点2.2.1 迷宫在程序中如何表示因为迷宫中每一个点的信息都只有两种可能（要么能走，要么不能走），我们可以以二维数组Maze[i][j]=value来存...
解密迷宫问题：三种高效算法Java实现，让你轻松穿越未知迷宫
xxxzzzqqq_的博客
04-26 4217
我们总结一下，在迷宫问题中，深度优先搜索（DFS）、广度优先搜索（BFS）和 A* 都可以用来寻找最短路径或最优解。空间要求低，不需要保存整个搜索树，只需要保存当前路径；所有解的路径长度差别不大，或者只需要找到其中一个解；迷宫比较大，而且有很多死路，采用 DFS 可以快速探索大面积空间。需要找到最短路径或最优解；迷宫中大部分路径长度差别不大；可以承受较大的空间复杂度，需要保存整个搜索树。需要找到最短路径或最优解；需要考虑迷宫中的障碍物，即寻找一条避开障碍物的路径；
迷宫寻路三大算法(BFS,DFS,A*)
Dog_dream的博客
05-10 2万+
迷宫寻路 这是我们的数据结构作业本加我们自己再网上找算法记录下来，不过本人比较执着画了几天时间还是把这些算法自己写出来了。总得来说网上所说的大体算法应该就有三种（BFS，DFS，A*） 这里是一个验证网址是南阳OJ的一道题这是网址 http://acm.nyist.me/problem/58 好了不说废话开始吧 BFS 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜...
C#实现4种经典迷宫生成算法和迷宫寻路算法
12-05
C#实现4种经典迷宫生成算法和迷宫寻路算法，4种经典的迷宫生成算法是：（1）使用并查集算法生成，（2）使用深度优先算法生成，（3）使用随机算法生成，（4）使用递归切割算法，而迷宫寻路使用A*算法。
走迷宫_算法、走迷宫_
09-29
有一个N*M的格子迷宫，1代表该格子为墙，不能通过，0代表可以通过，另外，在迷宫中有一些传送门，走到传送门的入口即会自动被传送到传送门的出口（一次传送算1步）。人在迷宫中可以尝试上下左右四个方向移动。现在...
一文看懂Python迷宫生成和迷宫破解算法
12-21
今天小编就为大家分享一今天小编就为大家分享一篇Python迷宫生成和迷宫破解算法实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 文章目录1迷宫生成1.随机PRIM2.深度优先2.迷宫破解1.填坑法2...
C++迷宫问题的求解算法
12-20
本文实例为大家分享了C++实现迷宫的具体代码，供大家参考，具体内容如下 一、 实验目的： （1） 熟练掌握链栈的基本操作及应用。 （2） 利用链表作为栈的存储结构，设计实现一个求解迷宫的非递归程序。 二、实验...
迷宫算法迷宫算法
12-06
迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法迷宫算法
三种迷宫生成算法概述
L__ear的博客
02-03 5628
1. Randomized Prim’s algorithm（随机Prim算法） 随机Prim算法属于打通墙壁生成迷宫的算法，下面我将以集合的角度来描述此算法。 首先是初始化，建立一个所有单元格都被墙隔开的迷宫。 以8*8的迷宫为例，将每个单元格进行编号。使用集...
游戏常用算法：四种迷宫生成算法
august5291的博客
09-18 8651
https://www.fgba.net/sitemap.xml
数据结构作业总结_三种迷宫生成算法+三种走迷宫算法+pyqt5可视化（1）
cj12345657582255的博客
04-11 1385
三种迷宫生成算法+三种走迷宫算法+pyqt5可视化 这是近期作业的总结，实现截图如下： 1.作业实现 1.1截图 1.2实现思路 将迷宫单元用二维列表表示，-1为墙，0为可以走的路 首先初始化格子，等待输入，当点击按下后接受输入的迷宫列数，行数 生成迷宫矩阵，据此画出迷宫。 点击走迷宫按钮后，根据全局变量矩阵maz由三种算法计算路径。 2.涉及的知识点 迷宫生成算法:dfs算法,bfs算法,Prim算法,Kruskal算法 走迷宫算法:dfs算法,bfs算法,A*算法,(迪杰斯特拉算法,弗洛伊德算
Java 算法之迷宫(简单实现)
cjxiaobaic的博客
09-10 1937
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
求解迷宫问题的三种方法(python实现)
热门推荐
不吃鱼的猫的博客
11-04 4万+
在迷宫问题中，给定入口和出口，要求找到路径。本文将讨论三种求解方法，递归求解、回溯求解和队列求解。 在介绍具体算法之前，先考虑将迷宫数字化。这里将迷宫用一个二维的list存储（即list嵌套在list里），将不可到达的位置用1表示，可到达的位置用0表示，并将已经到过的位置用2表示。 递归求解 递归求解的基本思路是： 每个时刻总有一个当前位置，开始时这个位置是迷宫人口。 如果当前位置就...
实验三：迷宫的实现
weixin_53273944的博客
12-24 1871
目录 一. 实验准备 迷宫的特点 遍历方法 深度优先遍历（DFS） 二. 迷宫的显示 界面弹窗的设置 定义按钮和界面 设置游戏界面以及游戏按钮监听 图片的读取和使用 设置鼠标监听 设置键盘监听 三. A*算法 一. 实验准备 迷宫的特点 1.迷宫的起点到终点肯定是存在一条通路的。 2.迷宫存在很多的岔路。 当我们将迷宫的所有路拉直之后，迷宫就会变成一个无向图。所以我们可以将迷宫转换为无向图的两个顶点之间的通路问题，图的遍历。 遍历方法 有很多种遍历方法...
迷宫算法 之 迷宫生成和迷宫寻路
Globalizationa的博客
06-14 2408
本文讲解迷宫生成和迷宫寻路算法。 //////////////////////////////////////////////////////////////////////////////////////////////////// 一、三种迷宫生成算法 　　　　1、 DFS（即深度优先）算法生成，分为递归和非递归方法。 　　　　2、 十字分割算法生成，分为递归和非递归方法。 　　　　3、随机 Prim 算法生成，一种非递归方法。 二、两种迷宫寻路算法 　　　　1、DFS 寻路，采用非...
C/C++实现：迷宫游戏（进阶版），深度优先算法实现案例
致力于C语言C++知识分享！
01-29 2115
玩家被困在一个迷宫里，拥有一盏油灯，油灯能够照亮以玩家为中心的一片圆形区域，随着时间的流逝，油灯的照明力会逐渐下降······
python迷宫寻路算法
最新发布
10-15
Python中常用的迷宫寻路算法有很多种，其中比较常见的是深度优先搜索（DFS）、广度优先搜索（BFS）和A*算法。这些算法都可以用来解决迷宫寻路问题，具体选择哪种算法取决于具体情况。 DFS算法是一种基于栈的搜索...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值