迷宫寻路算法
㈠ 数据结构算法 用C++ 迷宫最短路径
一般迷宫寻路可以用递归的算法，或者用先进后出的栈数据结构实现
用的是深度优先的算法，可以寻找到走出迷宫的路径
但本题要求求出最短的路径，这就要使用广度优先的算法
一般在程序中需要用到先进先出的队列数据结构
下面是程序的代码，主要原理是用到
quei，quej和prep三个数组来构成队列
分别储存路径的行，列坐标和上一个节点在队列中的位置
大致算法如下，右三个嵌套的循环实现
首先是第一个节点进入队列
当队列不空（循环1）
｛
遍历队列中每节点(循环2）
｛
将八个方向能够走的节点加入队列（循环3）
｝
旧的节点出列
｝
#include<iostream>
#include<ctime>
usingnamespacestd;
#defineMAXNUM50
voidmain()
{
intm,n,i,j,x;
cout<<"请输入迷宫大小"<<endl;
cin>>m>>n;
intmaze[MAXNUM][MAXNUM];
srand((int)time(NULL));
for(i=0;i<=m+1;i++){
for(j=0;j<=n+1;j++){
if(i==0||j==0||i==m+1||j==n+1)
maze[i][j]=1;
else
{
x=rand()%1000;
if(x>700){maze[i][j]=1;}//控制矩阵中1的个数，太多1迷宫很容易走不通
else{maze[i][j]=0;}
}
cout<<maze[i][j]<<'';
}
cout<<endl;
}
//以上是输入和迷宫生成，一下是走迷宫
intmove[8][2]={0,1,1,0,0,-1,-1,0,1,1,-1,1,-1,-1,1,-1};
int*quei=newint[m*n];//储存行坐标队列
int*quej=newint[m*n];//储存列坐标队列
int*prep=newint[m*n];//储存之前一步在队列中的位置
inthead,rear,length;//队列头，队列尾，队列长度
head=0;rear=1;length=1;
quei[head]=1;quej[head]=1;prep[head]=-1;//入口位置进队列
intpos;//当前节点在队列中的位置，
intii,jj,ni,nj;//当前节点的坐标，新节点的坐标
intdir;//移动方向
if(maze[1][1]==1)length=0;//第一点就不能通过
elsemaze[1][1]=1;
while(length)//队列非空继续
{
for(pos=head;pos<head+length;pos++)//寻找这一层所有节点
{
ii=quei[pos];jj=quej[pos];//当前位置坐标
if(ii==m&&jj==n)break;
for(dir=0;dir<8;dir++)//寻找8个方向
{
ni=ii+move[dir][0];nj=jj+move[dir][1];//新坐标
if(maze[ni][nj]==0)//如果没有走过
{
quei[rear]=ni;quej[rear]=nj;prep[rear]=pos;//新节点入队
rear=rear+1;
maze[ni][nj]=1;//标记已经走过
}
}
}
if(ii==m&&jj==n)break;
head=head+length;
length=rear-head;//这一层节点出列
}
if(ii==m&&jj==n)
{
while(pos!=-1)
{
cout<<'('<<quei[pos]<<','<<quej[pos]<<')';
pos=prep[pos];
if(pos!=-1)cout<<',';
}
}
else
{
cout<<"THEREISNOPATH."<<endl;
}
delete[]quei;
delete[]quej;
delete[]prep;
}
㈡ 求广度优先算法C++走迷宫程序，可以显示路径
一般迷宫寻路可以用递归的算法，或者用先进后出的栈数据结构实现
用的是深度优先的算法，可以寻找到走出迷宫的路径
但本题要求求出最短的路径，这就要使用广度优先的算法
一般在程序中需要用到先进先出的队列数据结构
下面是程序的代码，主要原理是用到
quei，quej和prep三个数组来构成队列
分别储存路径的行，列坐标和上一个节点在队列中的位置
大致算法如下，右三个嵌套的循环实现
首先是第一个节点进入队列
当队列不空（循环1）
｛
遍历队列中每节点(循环2）
｛
将八个方向能够走的节点加入队列（循环3）
｝
旧的节点出列
｝
#include<iostream>
#include<ctime>
usingnamespacestd;
#defineMAXNUM50
voidmain()
{
intm,n,i,j,x;
cout<<"请输入迷宫大小"<<endl;
cin>>m>>n;
intmaze[MAXNUM][MAXNUM];
srand((int)time(NULL));
for(i=0;i<=m+1;i++){
for(j=0;j<=n+1;j++){
if(i==0||j==0||i==m+1||j==n+1)
maze[i][j]=1;
else
{
x=rand()%1000;
if(x>700){maze[i][j]=1;}//控制矩阵中1的个数，太多1迷宫很容易走不通
else{maze[i][j]=0;}
}
cout<<maze[i][j]<<'';
}
cout<<endl;
}
//以上是输入和迷宫生成，一下是走迷宫
intmove[8][2]={0,1,1,0,0,-1,-1,0,1,1,-1,1,-1,-1,1,-1};
int*quei=newint[m*n];//储存行坐标队列
int*quej=newint[m*n];//储存列坐标队列
int*prep=newint[m*n];//储存之前一步在队列中的位置
inthead,rear,length;//队列头，队列尾，队列长度
head=0;rear=1;length=1;
quei[head]=1;quej[head]=1;prep[head]=-1;//入口位置进队列
intpos;//当前节点在队列中的位置，
intii,jj,ni,nj;//当前节点的坐标，新节点的坐标
intdir;//移动方向
if(maze[1][1]==1)length=0;//第一点就不能通过
elsemaze[1][1]=1;
while(length)//队列非空继续
{
for(pos=head;pos<head+length;pos++)//寻找这一层所有节点
{
ii=quei[pos];jj=quej[pos];//当前位置坐标
if(ii==m&&jj==n)break;
for(dir=0;dir<8;dir++)//寻找8个方向
{
ni=ii+move[dir][0];nj=jj+move[dir][1];//新坐标
if(maze[ni][nj]==0)//如果没有走过
{
quei[rear]=ni;quej[rear]=nj;prep[rear]=pos;//新节点入队
rear=rear+1;
maze[ni][nj]=1;//标记已经走过
}
}
}
if(ii==m&&jj==n)break;
head=head+length;
length=rear-head;//这一层节点出列
}
if(ii==m&&jj==n)
{
while(pos!=-1)
{
cout<<'('<<quei[pos]<<','<<quej[pos]<<')';
pos=prep[pos];
if(pos!=-1)cout<<',';
}
}
else
{
cout<<"THEREISNOPATH."<<endl;
}
delete[]quei;
delete[]quej;
delete[]prep;
}
㈢ A*path与Dijkstra寻路、迷宫生成
假设有人想从 A 点移动到一墙之隔的 B 点，如下图，绿色的是起点 A，红色是终点 B，蓝色方块是中间的墙。
在 A*寻路算法中，我们通过从绿色起点 A 开始，检查相邻方格的方式，向外扩展直到找到目标。
我们做如下操作开始搜索：
通常对于方格节点，我们认为水平/垂直移动一格耗费为 10，对角线移动耗费为 14。
G = 从 起点 沿着生成的路径，移动到当前节点的总移动耗费。
H = 从当前节点移动到 终点 的移动耗费估算。这经常被称为启发式的，因为它只是个猜测，我们没办法事先知道路径的实际长度。
对于方格节点通常使用 曼哈顿方法 ，它计算从当前格到 终点 之间水平和垂直的方格的数量总和，忽略对角线方向和障碍物。然后把结果乘以水平/垂直的移动耗费。
对于允许走对角线的节点使用 对角线方法 ，允许任意走的节点使用 欧几里得方法
当H值总为0时，退化为Dijkstra寻路算法
先构建一个如下的模型图,其中黑色为墙壁,红色为路径节点。墙可以为一个方形格子也可以仅仅是一条线(为方格时对角线上的墙壁始终无法被打通)。
先构建一个除了外圈为黑色墙壁,内部全是灰色通路的迷宫模型
㈣ 【寻路】A星算法浅析
**A*算法：智能寻路的导航灯**
在寻找最优路径的众多算法中，A*算法凭借其高效性和实用性脱颖而出。它巧妙地结合了Dijkstra算法的精确性和Greedy Best First Search的效率，为我们解决复杂地图上的路径问题提供了有力工具。让我们一起探索A*算法的精髓，看看它是如何在迷宫中指引我们前进的。
**1. A*算法的基础原理**
A*算法的关键在于引入了一个启发式函数H，它代表从当前节点到目标节点的预估距离。与Dijkstra算法的纯距离计算不同，A*算法考虑了目标节点的直接可达性，通过计算每个节点的F值（G + H，G为从起点到当前节点的实际代价，H为预估目标距离）来决定搜索路径。
**2. 与BFS和Dijkstra的对比**
- BFS（广度优先搜索）是盲目搜索，不考虑未来路径的成本，A*则是深度优先搜索的优化，通过启发式函数避免了不必要的探索。
- Dijkstra算法虽然找到的是最短路径，但时间复杂度较高。A*在保证路径效率的同时，寻求的是更短路径，特别是当目标节点位置信息可用时。
**3. A*算法的伪代码**
A*的搜索过程如下：
- 将起始节点加入开放列表，F值最小的节点优先处理。
- 选择F值最小的节点，如果它是目标节点，搜索结束；否则，将其所有邻居节点加入开放列表，更新它们的F值。
- 重复步骤3，直到找到目标节点或者开放列表为空。
**4. 实现细节与优化**
- 使用优先队列（如二叉堆）存储节点，便于快速访问F值最小的节点。
- 在计算F值时，检查斜线路径，利用曼哈顿距离或欧几里得距离（视情况而定）。
- 判断直接通行的节点，避免重复搜索。
- 对路径进行平滑处理，提升视觉效果。
- 设计多级寻路系统，应对复杂环境中的路径选择。
**5. A*与B*与JPS的异同**
- B*算法更偏向于目标导向，可能会在目标附近产生较宽的探索范围。
- JPS（Jump Point Search）在A*的基础上，通过寻找跳跃点加速搜索，尤其在大量障碍物中表现优秀。
通过A*算法，我们能够在游戏、机器人导航、实时路径规划等领域找到最短或较短的路径，它的灵活性和效率使得它成为现代计算机科学中的瑰宝。理解并掌握A*算法，就像拥有了一把智慧的钥匙，能帮助我们在迷宫般的现实世界中轻松寻路。
㈤ C++ DFS算法实现走迷宫自动寻路
深度优先搜索（DFS）是一种遍历图或搜索树的算法。它的基本思想是从树或图的根节点开始，尽可能地深入到树的某一分支中。当无法继续向下探索时，回溯并尝试其他分支。DFS算法在图或树的遍历中非常常用，但在迷宫问题中同样适用。
在迷宫问题中，DFS算法用于寻找从起点到终点的路径。通过深度优先搜索，我们可以探索每个可能的路径，直至找到通向目标的路线。
实现此算法的代码展示了手动操控与自动寻路两种模式。手动模式允许用户逐步探索迷宫，而自动模式则自动寻找并显示从起点到终点的路径。
程序的灵活性在于，只需调整迷宫地图的二维数组和相关常量，即可改变地图大小。自动寻路功能同样可用。
理论上，DFS算法在任何大小和复杂度的迷宫中都能有效寻找路径。然而，这种算法采用递归实现，导致空间占用较大。当迷宫地图增大到一定程度，如20*20，可能会触发堆栈溢出异常。因此，程序中提供了18*18和15*15的迷宫地图用于测试。
编译环境为Windows VS2019。该算法的代码包含游戏类（Game.h）和主函数文件（迷宫.cpp），并提供了一定的调试支持。如果您在使用过程中发现任何问题，欢迎指出，感谢您对本项目的贡献。