寻路算法基础和示例

已于 2023-06-16 21:20:12 修改
阅读量660 收藏 6
点赞数
分类专栏： 算法 文章标签： 算法
于 2023-04-08 21:30:06 首次发布
原文链接：https://blog.csdn.net/gghhb12/article/details/124337225
版权

一、概述

广度优先搜索、Dijkstra和A*是图上的三种典型路径规划算法。它们都可用于图搜索，不同之处在于队列和启发式函数两个参数。

算法的一般性原理如下：

  • 将边界初始化为包含起始节点的队列。
  • 当边界队列不为空时，从队列中“访问”并删除一个“当前”节点，同时将访问节点的每个邻居节点添加到队列，其成本是到达当前节点的成本加上从当前节点访问邻居的成本再加上邻居节点和目标节点的启发式函数值。其中，启发式函数是对两个节点的路径成本的估计。
  • 存储访问路径（通常存储在cameFrom图中），以便后续重建路径。如果邻居节点已经在列表中，同时新路径的成本较低，那么更改其成本。
  • 找到目标路径（提前退出）或列表为空时，停止算法。
    点此链接进入交互演示页面：https://interactive-pathfinding.netlify.com/

二、BFS

使用先进先出队列实现BFS。这种队列会忽略路径中链接的开销，并根据跳数进行扩展，因此可以确保找到最短路径的跳数，而跳数相关的成本。启发式函数的选择是任意的，因为在这个过程中其并不起作用。

使用数组可实现先进先出，即将元素附加到末尾并从头删除
在这里插入图片描述

BFS演示动图。注意边界节点（黄色）是如何在网格中扩展为正方形的。在这里，正方形是相同“跳距”的节点集。

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm> 
using namespace std;
 
struct Node {
    int x;
    int y;
};
class Solution {
public:
    vector<Node> shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        int ans = 0;
        queue<Node> myQ; // BFS一般通过队列方式解决
        int M = grid.size();
        int N = grid[0].size();
        vector<Node> ret;
        // 先判断边界条件，很明显，这两种情况下都是不能到达终点的。
        if (grid[0][0] == 1 || grid[M - 1][N - 1] == 1) {
            return ret;
        }
       
        // 记录已经走过的节点的上一个节点
        vector<vector<Node>> mem(M, vector<Node>(N, {-1,-1}));
        
        myQ.push({0, 0});
        mem[0][0] = {-2,-2};
 
        // 以下是标准BFS的写法
        while (!myQ.empty()) {
            int size = myQ.size();
 
            for (int i = 0; i < size; i++) {
                Node currentNode = myQ.front();
                int x = currentNode.x;
                int y = currentNode.y;
 
                // 判断是否满足退出的条件
                if (x == (N - 1) && y == (M - 1)) {
                    cout<<"start"<<endl;
                    int p=x,q=y;
                    ret.push_back({p,q});
                    while(mem[q][p].x!=-2 && mem[q][p].y!=-2){
                        ret.push_back(mem[q][p]);
                        p=mem[q][p].x;q=mem[q][p].y;
                        cout<<p<<q<<endl;
                    }
                    reverse(ret.begin(),ret.end());
                    return ret;
                }
 
                // 下一个节点所有可能情况
                vector<Node> nextNodes = {{x + 1, y}, {x - 1, y}, {x + 1, y - 1}, {x + 1, y + 1},
                                          {x, y + 1}, {x, y - 1}, {x - 1, y - 1}, {x - 1, y + 1}};
 
                for (auto& n : nextNodes) {
                    // 过滤条件1： 边界检查
                    if (n.x < 0 || n.x >= N || n.y < 0 || n.y >= M) {
                        continue;
                    }
                    // 过滤条件2：备忘录检查
                    if (mem[n.y][n.x].x != -1 && mem[n.y][n.x].y!=-1) {
                        continue;
                    }
                    // 过滤条件3：题目中的要求
                    if (grid[n.y][n.x] == 1) {
                        continue;
                    }
 
                    // 通过过滤筛选，加入队列！
                    mem[n.y][n.x] = currentNode;
                    myQ.push(n);
                }               
 
                myQ.pop();
            }
            ans++;
        }
 
        return ret;        
    }
};
 
int main(int argc,  char* argv[]) {
  vector<vector<int>> input={{0,0},{0,0}};
  Solution *test=new  Solution();
  vector<Node> ret=test->shortestPathBinaryMatrix(input);
  cout<<"road"<<ret.size()<<endl;
  for(auto n: ret){
      cout<<n.x<<n.y<<endl;
  }
    system("pause");
  return 0;
}

三、Dijkstra

在图上使用优先级队列和始终返回0的启发式函数，便得到Dijkstra算法。
Dijkstra 是解决单源最短路径问题的算法，是贪婪算法的经典例子，是广度优先搜索算法，是一种发散式的搜索，计算源点(起点)到所有节点的最短路径，解决的是有权图中最短路径问题(注意：权值不能为负)。时间复杂度和空间复杂度都比较高。
相比于BFS，Dijkstra最大的不同在于考虑了成本。通过该算法，可以根据节点到节点的成本找到最短路径。

优先级队列使用数组实现，在每次插入新节点后对该数组进行排序。尽管实现优先级队列还有其他更高效的方式，但在我们的场景中，数组是足够快的，而且实现起来也简单。
在这里插入图片描述

Dijkstra展示动画，注意此时的边界是一个圆。

四、A*

为实现A算法，需要传递一个实际启发式函数，例如两个节点之间的欧式距离。通过“节点成本”+“节点到目标节点的估算成本”对节点进行加权，通过优先搜索更大可能的节点加快搜索速度。
在这里插入图片描述

借助启发式方法，A可以比Dijkstra或BFS更快地找到正确路径。

任务：用整型二维数组模拟地图（1代表墙壁，0代表通路），给定起点坐标和终点坐标，用A*寻路算法查找最短路径.

#include <iostream>
#include <vector>
 
#define ROWS 12    //地图行数
#define COLS 12    //地图列数
 
#define SC   10    //直线代价
#define OC   14    //斜线代价
 
using namespace std;
 
//地图节点
struct Pos
{
    int Row = 0;            //所处行数
    int Col = 0;            //所处列数
 
    int G = 0;          //当前点到起点的代价
    int H = 0;          //当前点到终点的代价
    int F = 0;          //总代价   
 
    void SetF()
    {
        F = G + H;
    }
};
 
//A*搜索树结构
struct TreeNode
{
    Pos MyPos;                          //位置信息
    TreeNode* pParent = nullptr;        //父结点指针
    TreeNode* pChild0 = nullptr;        //孩子0结点指针
    TreeNode* pChild1 = nullptr;        //孩子1结点指针
    TreeNode* pChild2 = nullptr;        //孩子2结点指针
    TreeNode* pChild3 = nullptr;        //孩子3结点指针
    TreeNode* pChild4 = nullptr;        //孩子4结点指针
    TreeNode* pChild5 = nullptr;        //孩子5结点指针
    TreeNode* pChild6 = nullptr;        //孩子6结点指针
    TreeNode* pChild7 = nullptr;        //孩子7结点指针
};
 
//探索方向
enum Director
{
    D_up, D_down, D_left, D_right, D_lup, D_ldown, D_rup, D_rdown
};
 
//辅助地图结点
struct Mark {
    int  val;            //1表示墙壁，0表示通路
    bool bIsFind;       //是否已被探索，1表示已被探索，0表示未被探索
};
 
//创建新的树结点
TreeNode* CreateTreeNode(Pos PosA);
 
//判断是否可以探索
bool bCanWalk(Mark PathMap[ROWS][COLS], int Row, int Col);
 
//计算两点间的曼哈顿距离
int Distance_Manhatttan(Pos PosA, Pos PosB);
 
 
int main()
{
    
    vector<TreeNode*>::iterator it;
    vector<TreeNode*>::iterator itMin;
  
    //初始化地图，12*12，1代表墙壁，0代表通路
    int Map[ROWS][COLS] =
    {
 
        {0,0,0,0,0,1,0,0,0,0,0,0},
        {0,0,0,1,0,1,0,0,0,0,0,0},
        {0,0,0,1,0,1,0,0,0,0,0,0},
        {1,0,0,1,0,1,0,0,0,0,0,0},
        {1,1,1,1,0,1,0,0,0,0,0,0},
        {0,0,0,0,0,1,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,1,0,0,0,0,0,0},
        {0,0,0,0,0,1,0,0,0,0,0,0},
        {0,0,0,0,0,1,0,0,0,0,0,0},
        {0,0,0,0,0,1,0,0,0,0,0,0},
        {0,0,0,0,0,1,0,0,0,0,0,0},
    };
 
    //初始化辅助地图
    Mark PathMap[ROWS][COLS] = { 0 };
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; j < COLS; j++)
        {
            PathMap[i][j].val = Map[i][j];
        }
    }
 
    //初始化起点坐标和终点坐标
    Pos SrcPos = { 1,1 };
    Pos DstPos = { 2,11 };
 
    //起点作为树的根结点
    TreeNode* pRoot = CreateTreeNode(SrcPos);
    pRoot->MyPos.G = Distance_Manhatttan(DstPos, SrcPos);
    pRoot->MyPos.SetF();
 
    //临时容器，用于存储当前待探索的树结点
    vector<TreeNode*> buff;
    //布尔变量判断是否已寻路完成
    bool bFindPath = false;
    //根结点作为探索的起点
    TreeNode* pTempNode = pRoot;
 
    while (1)
    {
        //对当前点的八个方向进行探索
        for (int i = 0; i < 8; i++)
        {
            Pos TempPos = pTempNode->MyPos;
 
            //如果当前结点坐标为终点坐标，寻路完成，退出循环
            if (TempPos.Col == DstPos.Col && TempPos.Row == DstPos.Row)
            {
                bFindPath = true;
                break;
            }
 
            //根据寻路方向判断G值的增量，直线代价为SC，斜线代价为OC
            switch (i)
            {
            case D_up:       TempPos.Row--;  TempPos.G += SC;                     break;
            case D_down:     TempPos.Row++;  TempPos.G += SC;                     break;
            case D_left:     TempPos.Col--;  TempPos.G += SC;                     break;
            case D_right:    TempPos.Col++;  TempPos.G += SC;                     break;
            case D_lup:      TempPos.Row--;  TempPos.Col--;  TempPos.G += OC;     break;
            case D_ldown:    TempPos.Row++;  TempPos.Col--;  TempPos.G += OC;     break;
            case D_rup:      TempPos.Row--;  TempPos.Col++;  TempPos.G += OC;     break;
            case D_rdown:    TempPos.Row++;  TempPos.Col++;  TempPos.G += OC;     break;
            default:
                break;
            }
 
            //判断TempPos是否符合探索条件
            if (bCanWalk(PathMap, TempPos.Row, TempPos.Col))
            {
                //辅助地图标记相关位置为已探索，并计算相应的H,F值
                PathMap[TempPos.Row][TempPos.Col].bIsFind = true;
                TempPos.H = Distance_Manhatttan(TempPos, DstPos);
                TempPos.SetF();
 
                //创建新结点入树
                TreeNode* pNew = CreateTreeNode(TempPos);
                switch (i)
                {
                case 0:     pTempNode->pChild0 = pNew;   break;
                case 1:     pTempNode->pChild1 = pNew;   break;
                case 2:     pTempNode->pChild2 = pNew;   break;
                case 3:     pTempNode->pChild3 = pNew;   break;
                case 4:     pTempNode->pChild4 = pNew;   break;
                case 5:     pTempNode->pChild5 = pNew;   break;
                case 6:     pTempNode->pChild6 = pNew;   break;
                case 7:     pTempNode->pChild7 = pNew;   break;
                default:
                    break;
                }
                pNew->pParent = pTempNode;
 
                //将新结点添加到待探索的节点容器中
                buff.push_back(pNew);
            } 
        }
 
        //寻路完成，退出循环
        if (bFindPath || buff.size() == 0) break;
 
        //选取F值最小的结点作为下一个pTempNode
        itMin = buff.begin();
        for (it = buff.begin(); it != buff.end(); it++)
        {
            itMin = (*it)->MyPos.F < (*itMin)->MyPos.F ? it : itMin;
        }
        pTempNode = *itMin;
        buff.erase(itMin);
    }
 
    //寻路完成，成功则打印路径，失败则返回错误信息
    if (bFindPath)
    {
        cout << "已找到最佳路径如下：" << endl;
        while (pTempNode)
        {
            printf_s("(%d,%d)\n", pTempNode->MyPos.Row, pTempNode->MyPos.Col);
            pTempNode = pTempNode->pParent;
        }
    }
    else
    {
        cout << "ERROR: 未找到路径！" << endl;
    }
 
    return 0;
}
 
//判断是否可以探索
bool bCanWalk(Mark PathMap[ROWS][COLS], int Row, int Col)
{
    if (Row >= ROWS || Row<0 || Col>COLS || Col < 0) return false;
   
    if (PathMap[Row][Col].bIsFind) return false;
    if (PathMap[Row][Col].val) return false;
 
    return true;
}
 
//计算两点间的曼哈顿距离
int Distance_Manhatttan(Pos PosA,Pos PosB)
{
    return (PosA.Row > PosB.Row ? (PosA.Row - PosB.Row) : (PosB.Row - PosA.Row))
        + (PosA.Col > PosB.Col ? (PosA.Col - PosB.Col) : (PosB.Col - PosA.Col));
}
 
 
//创建新的树结点
TreeNode* CreateTreeNode(Pos PosA)
{
    TreeNode* pNew = new TreeNode;
    memset(pNew, 0, sizeof(TreeNode));
    pNew->MyPos = PosA;
    return pNew;
}

非允许的启发式函数：
只有应用可允许启发式函数，A*才能找到最短路径，这也意味着算法永远不会高估实际路径长度。由于欧氏距离是两点之间的最短距离/路径，因此欧氏距离绝不会超出。

但如果将其乘以常数k>0会怎样呢？这样会高估距离，成为非允许的启发式函数。
在这里插入图片描述

路过的小熊~
关注
专栏目录
寻路算法（BFS，DFS， A*寻路）
weixin_45583482的博客
12-04 4509
博主真的有段时间没写博客了，主要这段时间在练内功（算法和数据结构），因此就没有写博客了。这次用两个小时写出了寻路算法，算是对之前博主学习进程的一个交待吧。 我们回归正题，BFS和DFS是我们遍历链表树图等等数据结构时候的一种方法，而寻路换句话说就是从起点遍历到终点的过程。（我就不介绍寻路方面的最基础的问题，大家如果需要从头了解的话可以看其他人的博客） 我先默认大家已经了解并掌握了BFS和DFS的基本概念；广度遍历和深度遍历。即使用队列和栈遍历的两种方法。 1，保存路径 寻路算法相比于我们平常使用BFS，DF
jQuery 迷宫寻路算法示例
05-12
摘要:脚本资源,Ajax/JavaScript,迷宫　迷宫寻路，基于jQuery实现，设置迷宫大小，设置算法，点击开始就可以自动寻路了。 　操作说明:左键点击设置障碍(可以拖动设置)，右键点击设置迷宫起点和终点。
寻路问题--如何找到一条从起点坐标到终点坐标的路径？
weixin_30885111的博客
07-25 925
一，寻路问题介绍 正如组合问题与动态规划的联系之应用提到的从起点(0,0)到终点(X,Y)一共有多少种走法。与之相似的另一个问题是如何找到从(0,0)到(X,Y)的路径？ 首先对问题建模。使用一个矩阵(二维数组)的下标 表示 各个点的坐标。矩阵元素只取 0 或者 1，0 表示此坐标是一个可达的正常顶点；而 1 则表示这是一个不可达的障碍顶点。比如 如下矩阵： {0,0,1,1,0}{1,0,...
10种寻路算法
最新发布
Gyp郭小帅的博客
09-09 5384
这也是一种适用于带权重的图的寻路算法，但与Dijkstra算法不同的是，Bellman-Ford可以处理图中存在负权重边的情况。：这是一种使用启发式方法来指导搜索过程的寻路算法，通常用于找到从起点到目标点的最短路径。：这是一种递归算法，它沿着图的深度遍历路径，直到找到目标或到达无法进一步前进的位置。：这种算法会扩展所有的节点，即按宽度优先的顺序，因此它通常用于搜索无权重图。：这是一种适用于带权重的图的寻路算法，它会找到从起点到所有其他点的最短路径。：这是一种用于寻找所有顶点对之间的最短路径的算法。
A*寻路算法入门(一)
weixin_33929309的博客
11-21 134
大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请告诉我,如果觉得不错请多多支持点赞.谢谢! hopy ;) 免责申明：本博客提供的所有翻译文章原稿均来自互联网，仅供学习交流之用，请勿进行商业用途。同时，转载时不要移除本申明。如产生任何纠纷，均与本博客所有人、发表该翻译稿之人无任何关系。...
A*寻路算法入门(七)
weixin_33912445的博客
11-22 113
大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请告诉我,如果觉得不错请多多支持点赞.谢谢! hopy ;) 免责申明：本博客提供的所有翻译文章原稿均来自互联网，仅供学习交流之用，请勿进行商业用途。同时，转载时不要移除本申明。如产生任何纠纷，均与本博客所有人、发表该翻译稿之人无任何关系。...
游戏寻路算法的简单实现
Gnorth的专栏
06-19 4409
提到寻路算法，大家都会想到A*算法。 在度娘找了不少代码，看了不少教程之后，尤其是这个文章中提到的总结：http://www.cppblog.com/christanxw/archive/2006/04/07/5126.html A*算法总结(Summary of the A* Method) Ok ，现在你已经看完了整个的介绍，现在我们把所有步骤放在一起： 1.         把起点加
A*寻路算法入门
skyline_zx的专栏
12-02 564
原文网址：http://www.policyalmanac.org/games/aStarTutorial.htm 这篇文章图文并茂地阐述了A The A* (pronounced A-star) algorithm can be complicated for beginners. While there are many articles on the web that explain
寻路算法：找到NPC最好的行走路径
博文视点（北京）官方博客
11-29 3851
引言：寻路就是一个看似简单问题的解：给定点A 和B，AI 该怎么智能地在游戏世界中行走？这个问题的复杂来自于实际上A 和B 之间存在大量的路径可走，但只有一条是最佳的。只是找到一条两点之间的有效路径是不够的。理想的寻路算法需要查找所有可能的情况，然后比较出最好的路径。 本文将从搜索空间，可接受的启发式算法、贪婪最佳优先算法进行探讨。搜索空间的表示最简单的寻路算法设计就是将图作为数据结构。一个图包...
three.js算法寻路示例
10-28
在这个"three.js算法寻路示例"中，我们将探讨如何结合three.js、Vue框架以及几种路径寻找算法来解决3D环境中的寻路问题。 首先，让我们了解`three.js`。Three.js是一个开源的JavaScript库，它为WebGL提供了一个高级...
A*寻路算法
08-22
实现的功能： 1 把open队列中的元素移到close队列中，表示起始节点已经走过了，那么接下来应该走哪一步呢？ * 2 把起始位置周围的 8 个点都找出来 并且 计算出 估价函数值最低的那个元素 那么这个元素就是接下来要走的这步 * 3 接下来走的这步确定了 那么就又该把这个位置的点移动到 close队列中，然后继续找周围的点 并且进行估价
A星寻路算法案例
04-10
A星寻路算法（A* Search Algorithm）是计算机...通过分析和实践"A星寻路算法案例"，你可以更好地理解和运用这一算法，解决实际问题。记住，实践中遇到的问题和解决方案往往能帮助你深入理解理论知识，并提升编程技能。
JS/HTML5游戏常用算法之路径搜索算法 A*寻路算法完整实例
10-17
本实例将详细介绍A*寻路算法，并提供完整的JS代码示例，以帮助开发者更好地理解和应用。 A*寻路算法的核心思想是结合了Dijkstra算法的全局最优性和启发式搜索的效率。它通过评估每个节点的f(n)值来决定下一个应该...
javaScript AStar 寻路算法
12-24
在提供的`javascript-astar-master`压缩包中，可能包含了实现A*算法的源代码、示例和测试。通过阅读和理解这些代码，可以深入学习A*算法的实现细节，例如如何处理障碍物、优化搜索效率、以及如何适应不同类型的图...
关于 A*、Dijkstra、BFS 寻路算法的可视化解释
萌兔兔MMQ！！
04-15 774
广度优先搜索、Dijkstra和A*是图上的三种典型路径规划算法。它们都可用于图搜索，不同之处在于队列和启发式函数两个参数。 本项目探索并可视化不同算法如何根据选择参数进行图搜索。 算法的一般性原理如下： 将边界初始化为包含起始节点的队列。 当边界队列不为空时，从队列中“访问”并删除一个“当前”节点，同时将访问节点的每个邻居节点添加到队列，其成本是到达当前节点的成本加上从当前节点访问邻居的成本再加上邻居节点和目标节点的启发式函数值。其中，启发式函数是对两个节点的路径成本的估计。 存储访问路径（通常存储在ca
寻路算法.
unber的博客
06-28 84
图的寻路算法也可以通过深度优先遍历 dfs 实现，寻找图 graph 从起始 s 点到其他点的路径，在上一小节的实现类中添加全局变量 from数组记录路径，from[i] 表示查找的路径上i的上一个节点。首先构造函数初始化寻路算法的初始条件，from = new int[G.V()] 和 from = new int[G.V()]，并在循环中设置默认值，visited 数组全部为false，from 数组全部为 -1 值，后面对起始节点进行 dfs 的递归处理。...
寻路算法实践1
Siliphen Labs
02-09 6339
最近一段时间学了 Qt , Boost , 图论基础算法 后，就做了这个练习作品。 本程序是为了测试，从点S到点D是否有通路。如果有通路，那么路径都是什么 最短的路径又是什么。    先上运行时的效果图吧。 （可执行程序和源代码下载在本帖末尾）       点击左下角的“开始搜索”按键后，就会按照按钮右边的组合框中选择的算法来搜索从S到D的路径。 目前实现的算法有：DF
寻路算法
qq_29569995的博客
12-08 231
原题地址：https://www.codewars.com/kata/5326ef17b7320ee2e00001df/train/ruby 地图中只有一条可行路线。例如：map = [[true, false], [true, true]];solve(map, {'x'=>0,'y'=>0}, {'x'=>1,'y'=>1}) # Should return ['right', 'd
算法：A星寻路（含实例）
weixin_52596036的博客
01-05 2340
a星寻路是寻路算法中比较常用的一种，核心是启发式寻路算法（曼哈顿方法），实际开发中常用于计算最优路径，自动寻路等......
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值