A star算法优化一

最新推荐文章于 2024-09-02 10:00:53 发布
最新推荐文章于 2024-09-02 10:00:53 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： C++ C 机器人
C++ 同时被 3 个专栏收录
180 篇文章 11 订阅
订阅专栏
C
122 篇文章 1 订阅
订阅专栏
机器人
6 篇文章 0 订阅
订阅专栏

A*算法 求最优解

算法一直维护两个表: Open和Close

  • 将起点S加入Open中

  • 将所有S可到达的点（障碍物以及位于Close表中的点均看成不可达）加入到Open中。将起点从Open中删去，并加入到Close中

  • ①从Open中删去F值最小的点Min，并将其加入到Close中

  • ②将Min点所有可到达的点加入Open中，并设这些点的父节点为Min。若某点已经在Open中，则比较其F值，若新路径F值较小，说明从Min走路更短，更新其父节点为Min；否则不更新此点

  • 循环①②，直到Open中出现目的点E 

公式表示为： f(n)=g(n)+h(n),

其中 f(n) 是从初始状态经由状态n到目标状态的代价估计，

g(n) 是在状态空间中从初始状态到状态n的实际代价，

h(n) 是从状态n到目标状态的最佳路径的估计代价。

通俗一点讲:

g(n)代表你从起始点到下一点的实际距离（制定到下一点的距离的规则）

h(n)是自己设计的函数，可以是到目的地大致的距离


可将循环过程封装成函数：

[cpp]  view plain  copy
  1.     while (isNotEnd()) {  
  2.         Find_deleteMinFromOpen_AddToClose();  
  3.         putReachableIntoOpen(close.back());  
  4.     }  

举个栗子：

对于以下图：5行15列

000000000000000

0000000x0000000

00s0000x0000e00

0000000x0000000

000000000000000

其中x为墙壁，s为起点，e为终点，建立合适的模型，调用A star算法，找到一条s到e的最短路径。

取直走G值为10，斜走G值为14

这里H值设定为无视障碍到达终点所需的 步数*10

我们看开始的几步：

000000000000000

0000000x0000000

00s0000x0000e00

0000000x0000000

000000000000000

灰色的点G=10，H=9*10 ,其F值最小，加入Close


000000000000000

0000000x0000000

00s0000x0000e00

0000000x0000000

000000000000000

灰色的点G=10+10，H=8*10 ,其F值最小，加入Close


000000000000000

0000000x0000000

00s0000x0000e00

0000000x0000000

000000000000000

灰色的点G=10+10+10，H=7*10 ,其F值最小，加入Close


000000000000000

0000000x0000000

00s0000x0000e00

0000000x0000000

000000000000000

灰色的点G=10+10+10+10，H=6*10 ,其F值最小，加入Close


以此循环，直到e在Open中，此时只需要沿着父节点往回走就可以到达起点了，这条路就是当前情况下最优的解


结果：


000000000000000

0000000x0000000

00s0000x0000e00

0000000x0000000

000000000000000



C++实现：

[cpp]  view plain  copy
  1. #include#include#include#includeusing namespace std;  
  2. char square[5][15] = {//待求数据  
  3.     '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0',  
  4.     '0','0','0','0','0','0','0','x','0','0','0','0','0','0','0',  
  5.     '0','0','s','0','0','0','0','x','0','0','0','0','e','0','0',  
  6.     '0','0','0','0','0','0','0','x','0','0','0','0','0','0','0',  
  7.     '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'  
  8. };  
  9.   
  10. class point {  
  11.   
  12. public:  
  13.     point(char s) {  
  14.         v = s;  
  15.         G = 0;  
  16.         H = 0;  
  17.         F = 0;  
  18.     }  
  19.     pair ParentPosi;  
  20.     pair posi;  
  21.     char v;//value  
  22.     int F;  
  23.     int G;  
  24.     int H;  
  25.     int UpdateF() {  
  26.         F = G + H;  
  27.         return F;  
  28.     }  
  29.     int UpdateH() {  
  30.         int x = posi.first - 2;  
  31.         int y = posi.second - 12;  
  32.         x *= 10;  
  33.         y *= 10;  
  34.         if (x < 0) {  
  35.             x = -x;  
  36.         }  
  37.         if (y < 0) {  
  38.             y = -y;  
  39.         }  
  40.         H = x + y;  
  41.         return H;  
  42.     }  
  43.     void setPosi(pair x) {  
  44.         posi = x;  
  45.     }  
  46.     void setParentPosi(pair x) {  
  47.         ParentPosi= x;  
  48.     }  
  49.     void setG(int g) {  
  50.         G = g;  
  51.     }  
  52.     void setH(int h) {  
  53.         H = h;  
  54.     }  
  55.     point &operator = (point &s) {  
  56.         (*this).v=(s).v;  
  57.         (*this).ParentPosi = s.ParentPosi;  
  58.         (*this).posi = s.posi;  
  59.         (*this).F = s.F;  
  60.         (*this).G = s.G;  
  61.         (*this).H = s.H;  
  62.         return *this;  
  63.     }  
  64. };  
  65. vector open;  
  66. vector close;  
  67. point squ[5][15] = {  
  68.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  
  69.     0,0,0,0,0,0,0,'x',0,0,0,0,0,0,0,  
  70.     0,0,'s',0,0,0,0,'x',0,0,0,0,'e',0,0,  
  71.     0,0,0,0,0,0,0,'x',0,0,0,0,0,0,0,  
  72.     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  
  73. };  
  74. bool isInOpenList(pair s) {  
  75.     for (int i = 0;i<open.size();i++) {  
  76.         if (open[i].posi == s) {  
  77.             return true;  
  78.         }  
  79.     }  
  80.     return false;  
  81. }  
  82. bool isInCloseList(pair s) {  
  83.     for (int i = 0;i<close.size();i++) {  
  84.         if (close[i].posi == s) {  
  85.             return true;  
  86.         }  
  87.     }  
  88.     return false;  
  89. }  
  90. void putReachableIntoOpen(point min) {  
  91.     int x = min.posi.first;  
  92.     int y = min.posi.second;  
  93.   
  94.     int direc[8][2] = {  
  95.         0,1,  
  96.         1,1,  
  97.         1,0,  
  98.         1,-1,  
  99.         0,-1,  
  100.         -1,-1,  
  101.         -1,0,  
  102.         -1,1  
  103.     };  
  104.     for (int i = 0;i < 8;i++) {  
  105.         x = x + direc[i][0];  
  106.         y = y + direc[i][1];  
  107.         if (isInOpenList(make_pair(x, y))&&close.size()>0) {  
  108.             int tempi = 0;  
  109.             for (int i = 0;i < open.size();i++) {  
  110.                 if (open[i].posi == make_pair(x, y)) {  
  111.                     tempi = i;  
  112.                 }  
  113.             }  
  114.             if (direc[i][0] * direc[i][1] != 0) {//斜向  
  115.                 int G_now = close.back().G + 14;  
  116.                 if (G_now < open[tempi].G) { //G比较小就更新路径  
  117.                     open[tempi].ParentPosi = make_pair(x, y);  
  118.                     squ[open[tempi].posi.first][open[tempi].posi.second].ParentPosi = make_pair(x, y);  
  119.                 }  
  120.             }  
  121.             else {  
  122.                 int G_now = close.back().G + 10;  
  123.             }  
  124.             continue;  
  125.         }  
  126.         //既不在关闭也不在开启列表中而且可到达 就将其加入开启列表  
  127.         if ((!isInOpenList(make_pair(x, y))) && (!isInCloseList(make_pair(x,y)))&&x >= 0 && x < 5 && square[x][y] != 'x') {  
  128.             squ[x][y].setParentPosi(min.posi);  
  129.             open.push_back(squ[x][y]);  
  130.             if (direc[i][0] * direc[i][1] != 0) {//斜向  
  131.                 squ[x][y].setG(squ[x][y].G+14);  
  132.             }  
  133.             else {  
  134.                 squ[x][y].setG(squ[x][y].G + 10);  
  135.             }  
  136.             //cout << "(" << squ[x][y].posi.first << "," << squ[x][y].posi.second << ")" << endl;  
  137.         }  
  138.         x = x - direc[i][0];  
  139.         y = y - direc[i][1];  
  140.     }  
  141.     //cout << "------------------------" << "(" << x << "," << y << "):" << "------------------------" << endl;  
  142. }  
  143. void Find_deleteMinFromOpen_AddToClose() {  
  144.     point min_= open[0];  
  145.     int tempi = 0;  
  146.     for (int i = 0;i < open.size();i++) {  
  147.         if (open[i].UpdateF() < min_.UpdateF()) {  
  148.             min_ = open[i];  
  149.             tempi = i;  
  150.         }  
  151.     }  
  152.     close.push_back(min_);  
  153.     std::vector::iterator it=open.begin()+tempi;  
  154.     open.erase(it);  
  155.     //cout << "close:           (" << min_.posi.first << "," << min_.posi.second << ")" << endl;  
  156.     //cout << "closeSize()=" << close.size() << endl;  
  157.     //cout << "openSize()=" << open.size() << endl;  
  158. }  
  159. bool isNotEnd() {  
  160.     for (int i=0;i<open.size();i++) {  
  161.         if (open[i].v == 'e') {  
  162.             open[i].ParentPosi=close.back().posi;  
  163.             return false;  
  164.         }  
  165.     }  
  166.     return true;  
  167. }  
  168.   
  169. void findPath(pair begin,pairend) {  
  170.     //将起点放入open  
  171.     open.push_back(squ[2][2]);  
  172.     putReachableIntoOpen(squ[2][2]);  
  173.     int tempi = 0;  
  174.     for (int i = 0;i < open.size();i++) {  
  175.         if (open[i].v == 's') {  
  176.             tempi = i;  
  177.         }  
  178.     }  
  179.     std::vector::iterator it = open.begin()+tempi;//删除起点  
  180.   
  181.       
  182.     while (isNotEnd()) {  
  183.         Find_deleteMinFromOpen_AddToClose();  
  184.         putReachableIntoOpen(close.back());  
  185.     }  
  186. }  
  187. void print_path() {  
  188.     for (int i = 0;i < 5;i++) {  
  189.         for (int j = 0;j < 15;j++) {  
  190.             squ[i][j].posi = make_pair(i, j);  
一缕阳光a
关注
专栏目录
[C++]:A*——A Star算法简介
09-11 5381
A*算法 求最优解 算法一直维护两个表: Open和Close 将起点S加入Open中 将所有S可到达的点（障碍物以及位于Close表中的点均看成不可达）加入到Open中。将起点从Open中删去，并加入到Close中 ①从Open中删去F值最小的点Min，并将其加入到Close中 ②将Min点所有可到达的点加入Open中，并设这些点的父节点为Min。若某点已经在Ope
游戏服务器之优化a星寻路
陈嘉怡的专栏
02-20 6329
游戏服务器之a星寻路 主要用于npc找玩家。这个是个a*算法的优化算法。
A* 算法优化思路
最新发布
qq_45770364的博客
09-02 533
A* 算法性能优化思路
A_star算法C++程序
楼下滴小丑
10-15 521
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 ...
A* 算法
weixin_34081595的博客
04-22 142
经过不知道多少天的百度，今天终于看懂A*算法了； A*算法： （1）生成一个仅包含开始节点n0搜索树Tr。把n0放在一个称为open的有序列表中 （2）生成一个初始值为空的列表CLOSED （3）如果open为空，则失败退出 （4）选出open中的第一个节点，并将它从open中移除，放入closed中，称为该节点为n （5）如果n是目标节点，顺着Tr中的父节点回...
A_Star算法的C++实现（一）
Gorege__Hu的博客
08-17 338
运行环境：vs2022。
A星算法优化
u010879329的博客
12-08 1008
在A星算法这种经常用频繁用的算法中，一个小小的性能消耗就能放大很多倍，特别注意调用的函数的复杂度，公式的复杂度，以及运算的优化，尽量做到能不调用函数的不调用函数，能简化公式的尽量简化公式，能用&|位运算符号代替加减乘除的尽量用位运算代替，节省A星算法的性能开销。设置导航点，计算出离线导航数据，游戏运行时加载到内存。寻路时，找到起点附近的导航点和终点附近的导航点，只要计算出起点到导航点和终点到导航点的路径，再加上导航点之间的离线路径，就得到了整个路径。3、多次频繁A星寻路的优化。
a star算法matlab
04-18
在这个“a star算法matlab”项目中，开发者可能已经创建了一个能够根据用户自定义的起点（Start）、终点（Target）和障碍物（Obstacle）来寻找最短路径的程序。 A*算法的核心在于使用启发式函数（heuristic ...
A-star1算法_matlab_
09-29
总结来说，A-star1算法项目是利用MATLAB实现的一个多机器人路径规划工具，它结合了A*算法的高效性和MATLAB的便利性，实现了动态目标选择和碰撞避免功能，为机器人自主导航提供了有效的解决方案。通过深入理解和掌握A...
AStarpathfinder.rar_A star 算法_A算法 地图_a-star_寻路_寻路算法
09-22
A*（发音"A-star"）算法是一种广泛应用的路径搜索算法，尤其在游戏开发、图形学、机器人导航等领域中，用于解决在复杂环境中找到两点间最短路径的问题。它结合了Dijkstra算法的全局最优性和最佳优先搜索算法的效率，...
A*走路 自动寻路A*算法 易语言源码优化版
10-10
这个“A*走路 自动寻路A*算法 易语言源码优化版”是一个用易语言实现的A*算法优化版本，适用于游戏开发、地图导航等场景，帮助程序自动找到从起点到终点的最短路径。 A*算法的核心在于结合了Dijkstra算法的最短路径...
A星算法优化（一）启发函数
热门推荐
weixin_52029211的博客
03-17 2万+
笔者将从以下5个点进行改进： 1、启发函数——曼哈顿距离等 2、权重系数——动态加权等 3、搜索邻域——基于8邻域搜索改进 4、搜索策略——双向搜索、JPS策略等 5、路径平滑处理——贝塞尔曲线、B样条曲线等 一、启发函数（理论） A星算法评价函数为
A星寻路 A星算法优化
m0_58415365的博客
12-01 3774
A星寻路 启发式搜索 F=G+H F: 当前点到终点的代价(用来衡量效率:代价小(短)代价大(长)) G: 起点到当前点的代价 (忽略障碍物只看直线) H: 当前点到终点的预估代价 A星算法的优化 遇到相同代价格子的时候，可以启用双A星搜索，提高效率 还可以启用跳点搜索，比如方向相同 权重相等的节点所形成的大面积可行走区域，就可以省略其中相邻节点的处理 相关A*寻路算法在Unity中的简单应用 - 简书 ...
【A星算法的优化方案】
timieang0660的博客
02-09 3229
A星寻路优化方案
A*算法
10-15 6075
如此好贴，不能不转！原文地址：http://dev.gameres.com/Program/Abstract/Arithmetic/AmitAStar.mht 本文版权归原作者、译者所有，我只是转贴；如果侵害到您的权益，请联系我，我将删除本文。 基本上，这文章可以说是最佳A*
A *算法
qq_43390943的博客
04-02 1837
文章目录A* 算法Dijkstra 算法Greed-Best-First-Search算法启发函数A*算法的代码实现 A* 算法 A* 算法是求解最短路径的算法之一，其他的求解算法还有Dijkstra 算法、Bellman-ford 算法、SPFA 算法、Floyd算法等。 既然有了上面的那么多的算法，为什么还要设计A* 算法呢？ A* 算法较其他算法的不同就是它采用了启发式搜索的方式，一般算法采...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值