a*寻路

最新推荐文章于 2024-07-04 21:06:46 发布
最新推荐文章于 2024-07-04 21:06:46 发布
阅读量622 收藏 1
点赞数
分类专栏： c/c++编程技术 C/C++经典规范源码分享 游戏开发 文章标签： wizard table iterator struct path 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gumingyaotangwei/article/details/5733154
版权

#include <list>
#include <math.h>
#include <map>
#include "iostream"

using namespace std;

 


// 坐标点
typedef struct  _point
{
 int timelist[1000];
 bool isWall;
 int x;
 int y;
 int isblock;
 _point()
 { 
  for(int i = 0; i < 1000; i++)
   timelist[i] = 0;
  isWall = false;
  x = 0;
  y = 0;
 }

 _point(int i)
 {
  isblock = i;
  for(int i = 0; i < 1000; i++)
   timelist[i] = 0;
  isWall = false;
  x = 0;
  y = 0;
 }
 _point(int _x, int _y)
 {
  x = _x;
  y = _y;
 }
}point;
//结点
typedef struct _Node
{
 point pt;
 int f, g, h;
 struct _Node *preNode;//父节点
}Node;
/************************************************************************/
/* A 星算法                                                                     */
/************************************************************************/
class AStar{
public:
 AStar(void);
 ~AStar(void);
public:
 int table_c[6][6];

 static const int SPEND_H = 10;//H值耗费
 static const int SPEND_G_FAR = 14;//远的G值耗费
 static const int SPEND_G_NEAR = 10;//近的G值耗费
 list<Node*> psOpenList; //开放列表
 list<Node*> psCloseList;//封闭列表
 Node *sStartNode; //起始节点
 Node *sEndNode; //终止节点
 Node *pcurrNode;//是否是终点? NOT NULL : NULL

 map<int,point> path; //用于存放寻路后的数据
 map<int,point>::iterator it;
public:
 void SetTables(int *);
 void SetStartNode(point st){sStartNode->pt.x = st.x;sStartNode->pt.y = st.y;};//设定起始节点
 void SetEndNode(point et){sEndNode->pt.x = et.x;sEndNode->pt.y = et.y;};//设定结束节点
 void Search();//主搜索
 void AddToOpenList(Node *src);//添加到开放列表
 void GetNodeByPoint(Node *pareNode, int _x, int _y);//通过坐标添加到开放列表
 bool IsClosed(Node *src);//坐标点是否在封闭列表中
 bool IsInOpenList(Node *src);//坐标点是否在开放列表中
 bool IsBlock(Node *src);//坐标点是否是阻挡点
 void SetH(Node *node);//设定H的耗费
 void SetG(Node *node);//设定G的耗费
 void SetF(Node *node);//设定F的耗费
 Node* GetBestNode(); //得到最优的节点(F值最低的节点)
 bool isPath(list<point> *path, int i, int j);//测试方法-用于输出
};

AStar::AStar()
{
 sStartNode = new Node();
 sEndNode = new Node();
 pcurrNode = NULL;
}
AStar::~AStar(void)
{
 delete sStartNode;
 delete sEndNode;
 delete pcurrNode;
}
void AStar::SetTables(int *tables)
{
 if (tables != NULL)
 {
  for (int i = 0; i < 6; i++)
  {
   for (int j = 0; j < 6; j++)
   {
    table_c[i][j] = tables[i*6+j];
   }  
  }
 }
}
void AStar::Search()
{
 Node *currentNode;//当前节点
 currentNode = sStartNode;
 currentNode->preNode = NULL;//初始节点的父节点为空
 currentNode->g = 0;
 SetH(currentNode);
 SetF(currentNode);
 psOpenList.push_front(sStartNode);//添加起始点到开放列表
 do
 {
  currentNode = GetBestNode();//从开放列表得到最优节点
  //遍历当前结点周围的结点并加入开放列表，当前节点从开放列表中移到封闭列表中
  AddToOpenList(currentNode);

  psCloseList.push_front(currentNode);//添加到关闭列表中
  if(psOpenList.size() < 1 || pcurrNode)break; //如果目标节点已经存在于开放列表或开放列表是空则退出
 } while (true);
 //*******************************测试方法Start*******************************//
 // list<point> path; //用于存放寻路后的数据

 do
 {
  //path.push_front(currentNode->pt);
  path.insert(map<int,point>::value_type(path.size()+1,currentNode->pt));
  //cout<<currentNode->pt.x<<"/t"<<currentNode->pt.y<<endl;
  if(currentNode->pt.x == sStartNode->pt.x && currentNode->pt.y == sStartNode->pt.y)break;
  currentNode = currentNode->preNode;

 } while (true);

 /* //输出模拟的地图和寻路后的路径
 for(int j=0;j<6;++j)
 {
 for (int i=0;i<6;++i)
 {
 if(isPath(&path,i,j))
 cout<<"/033[1;37m o"<<"/t";
 else
 cout<<"/033[0;32;31m ×"<<"/t";
 }
 cout<<endl;
 }*/
 //*******************************测试方法End*******************************//

}
//*******************************测试方法Start*******************************//
bool AStar::isPath(list<point> *path, int i, int j)
{
 for(list<point>::iterator openIterator = path->begin(); openIterator != path->end(); ++openIterator)
 {
  if((*openIterator).x == i && (*openIterator).y == j){return true;}
 }
 return false;
}
//*******************************测试方法End*******************************//
//添加到开放列表
void AStar::AddToOpenList(Node *src){
 //添加当前坐标的周围坐标(一共8个方向)
 GetNodeByPoint(src, src->pt.x, src->pt.y + 1);//上
 GetNodeByPoint(src, src->pt.x, src->pt.y - 1);//下
 GetNodeByPoint(src, src->pt.x - 1, src->pt.y);//左
 GetNodeByPoint(src, src->pt.x + 1, src->pt.y);//右
 GetNodeByPoint(src, src->pt.x - 1, src->pt.y + 1);//左上
 GetNodeByPoint(src, src->pt.x - 1, src->pt.y - 1);//左下
 GetNodeByPoint(src, src->pt.x + 1, src->pt.y + 1);//右上
 GetNodeByPoint(src, src->pt.x + 1, src->pt.y - 1);//右下
}
void AStar::GetNodeByPoint(Node *pareNode, int _x, int _y)
{
 //如果坐标已经越界则不添加---具体参数读配置文件
 if(_x < 0 || _y< 0 || _x >10 || _y>10)
  return ;
 Node *sNode = new Node();
 //设定坐标值
 sNode->pt.x = _x;
 sNode->pt.y = _y;
 //如果此坐标存在于封闭列表或是阻挡物的话，不进行添加
 if(IsClosed(sNode) || IsBlock(sNode))
 {
  return;
 }
 else
 {
  //设定父结点
  sNode->preNode = pareNode;
  SetG(sNode);SetH(sNode);SetF(sNode);//设定各种耗费
  psOpenList.push_front(sNode);//添加到开放列表
  if(sNode->pt.x == sEndNode->pt.x && sNode->pt.y == sEndNode->pt.y)
   pcurrNode = sNode;//终点坐标已经存在于开放列表
 }
}
//是否存在于封闭列表
bool AStar::IsClosed(Node *src)
{
 for(list<Node*>::iterator openIterator = psCloseList.begin(); openIterator != psCloseList.end(); ++openIterator)
 {
  if((*openIterator)->pt.x == src->pt.x && (*openIterator)->pt.y == src->pt.y){return true;}
 }
 return false;
}
//是否存在于开放列表
bool AStar::IsInOpenList(Node *src)
{
 for(list<Node*>::iterator openIterator = psOpenList.begin(); openIterator != psOpenList.end(); ++openIterator)
 {
  if((*openIterator)->pt.x == src->pt.x && (*openIterator)->pt.y == src->pt.y){return true;}
 }
 return false;
}
//是否是阻挡坐标
bool AStar::IsBlock(Node *src)
{
 //下面是测试数据，真实的数据去读配置文件
 if (table_c[src->pt.x][src->pt.y])
 {
  return true;
 }
 
// if(!tables[src->pt.y][src->pt.x])return true;
 //if(src->pt.isWall)return true;
 /* if(src->pt.x == 0 && src->pt.y == 4)return true;
 if(src->pt.x == 1 && src->pt.y == 4)return true;
 if(src->pt.x == 2 && src->pt.y == 9)return true;
 if(src->pt.x == 3 && src->pt.y == 4)return true;
 if(src->pt.x == 4 && src->pt.y == 4)return true;
 //if(src->pt.x == 5 && src->pt.y == 4)return true;
 if(src->pt.x == 6 && src->pt.y == 4)return true;
 if(src->pt.x == 7 && src->pt.y == 4)return true;
 if(src->pt.x == 8 && src->pt.y == 4)return true;
 if(src->pt.x == 9 && src->pt.y == 4)return true;
 if(src->pt.x == 10 && src->pt.y == 4)return true;*/
 return false;
}
//计算从B点(某点)到终点的耗费
void AStar::SetH(Node *node)
{
 node->h = (abs(node->pt.x - sEndNode->pt.x) + abs(node->pt.y - sEndNode->pt.y)) * SPEND_H;
}
//计算从起点到B点(某点)的耗费
void AStar::SetG(Node *node)
{
 if(node->pt.x != node->preNode->pt.x && node->pt.y != node->preNode->pt.y)
  node->g = node->preNode->g + SPEND_G_FAR;
 else
  node->g = node->preNode->g + SPEND_G_NEAR;
}
//计算总体耗费 F = G + H
void AStar::SetF(Node *node)
{
 node->f = node->g + node->h;
}
//从开放列表中得到最优值(F值最低)
Node* AStar::GetBestNode()
{
 Node* bNode;
 int bestF = 9999999;
 list<Node*>::iterator iterT;//记录最优值的位置方便删除
 for(list<Node*>::iterator openIterator = psOpenList.begin(); openIterator != psOpenList.end(); ++openIterator)
 {
  if(bestF > (*openIterator)->f){
   bestF = (*openIterator)->f; bNode = *openIterator;
   iterT = openIterator;
  }
 }
 if(bNode)
  psOpenList.erase(iterT);//找到最优值后从开放列表中删除
 return bNode;
}

 


/*
int tables[6][6] = {{1,1,1,0,1,1},
     {1,1,1,0,1,1},
     {1,0,1,0,1,1},
     {1,1,1,0,1,1},
     {0,1,1,1,1,1},
     {0,1,1,0,0,1}};
*/

int tables_ta[36] = {1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,0,0,1};

struct Wizard
{
 int id;
 int begintime;
 int speed;

 point nowPoint;
 point goPoint;

 AStar astar;
 Wizard()
 {
  id = -1;
  begintime = 1;
  speed = 1;

  nowPoint.x = 0;
  nowPoint.y = 0;

  goPoint.x = 0;
  goPoint.y = 0;

  point tp;
  tp.x = nowPoint.x;
  tp.y = nowPoint.y;
  path.insert(map<int,point>::value_type(path.size()+1,tp));
 }

 map<int,point> path; //用于存放寻路后的数据
 map<int,point>::iterator it;
};


struct  node
{
 bool bIsWall;
 map<int,int> nodelist;
 map<int,int>::iterator it;

 node()
 {
  bIsWall = false;
 }
};

 

void getway_t(Wizard *t_Wizard, node table_table[][6])
{
 // 1.路径查找
 int tabless[6][6];
 for (int i = 0; i<6; i++)
 {
  for (int j = 0; j < 6; j++)
  {
   tabless[i][j] = 0;
  }  
 }
 
 bool bIsOut = false;
 for (int i = 0; i < 4; i++)
 {
  int po = 1;// 时间位置

  while (!bIsOut)
  {
   t_Wizard->it = t_Wizard->path.find(po);
   // 得到时间片的 地图信息
   for(int m = 0; m < 6; m++)
   {
    for (int n = 0; n < 6; n++)
    {
     if(table_table[m][n].bIsWall)
     {
      tabless[m][n] = -1;
     }else if (m <= t_Wizard->it->second.x+1 && m >= t_Wizard->it->second.x-1 && n <= t_Wizard->it->second.y+1 && n >= t_Wizard->it->second.y-1)// 周围8个方向位置
     {
      table_table[m][n].it = table_table[m][n].nodelist.find(po+t_Wizard->speed);// 往后推他停留时间 相对最小时间倍数
      if (table_table[m][n].it == table_table[m][n].nodelist.end())
      {
       tabless[m][n] = 0;
      }else
      {
       tabless[m][n] = table_table[m][n].it->second;
      } 
     }else
     {
      tabless[m][n] = 0;
     }     
    }
   }

   AStar astar;// 设置地图
   if ()
   {
    astar.SetTables(tables_ta);
   }else
   {
    astar.SetTables(tables_ta);
   }
   

   t_Wizard->it = t_Wizard->path.find(po);

   astar.SetStartNode(t_Wizard->it->second);
   astar.SetEndNode(t_Wizard->goPoint);
   astar.Search();

   astar.it = astar.path.find(2);
   point pttp;
   pttp.x = astar.it->second.x;
   pttp.y = astar.it->second.y;
   t_Wizard->path.insert(map<int,point>::value_type(t_Wizard->path.size()+1,pttp));

   if (astar.it->second.x == t_Wizard->goPoint.x && astar.it->second.y == t_Wizard->goPoint.y)
   {
    bIsOut = true;
   }   

   po++;
  }  
 }
 // 2.路径登记
 int popp = 0;
 t_Wizard->it = t_Wizard->path.begin();
 for (;t_Wizard->it != t_Wizard->path.end();t_Wizard->it++)
 {
  for (int cnn = 0; cnn < t_Wizard->speed; cnn++)
  {
   table_table[t_Wizard->it->second.x][t_Wizard->it->second.y].it = table_table[t_Wizard->it->second.x][t_Wizard->it->second.y].nodelist.find(t_Wizard->speed*popp+t_Wizard->begintime);
   if (table_table[t_Wizard->it->second.x][t_Wizard->it->second.y].it != table_table[t_Wizard->it->second.x][t_Wizard->it->second.y].nodelist.end())
   {
    table_table[t_Wizard->it->second.x][t_Wizard->it->second.y].it->second = t_Wizard->id;
   }else
   {
    table_table[t_Wizard->it->second.x][t_Wizard->it->second.y].nodelist.insert(map<int,int>::value_type(table_table[t_Wizard->it->second.x][t_Wizard->it->second.y].nodelist.size()+1,t_Wizard->id));
   }   
  } 
  
  popp++;
 } 
}


node table_table[6][6];// 全局桌面 存放所有登记信息
//int tabless[6][6];

/************************************************************************/
/* A 星算法测试                                                                     */
/************************************************************************/
int main(int argc, char* argv[])
{
// node table_table[6][6];// 全局桌面 存放所有登记信息
// int tabless[6][6];
// for ()
// {
// }
 

 Wizard a_Wizard1;
 a_Wizard1.id = 1;
 a_Wizard1.begintime = 0;
 a_Wizard1.speed = 4;
 a_Wizard1.nowPoint.x = 0;
 a_Wizard1.nowPoint.y = 0;
 a_Wizard1.goPoint.x = 5;
 a_Wizard1.goPoint.y = 5;

 Wizard a_Wizard2;
 a_Wizard2.id = 2;
 a_Wizard2.begintime = 1;
 a_Wizard2.speed = 3;
 a_Wizard2.nowPoint.x = 0;
 a_Wizard2.nowPoint.y = 0;
 a_Wizard1.goPoint.x = 5;
 a_Wizard1.goPoint.y = 5;

 Wizard a_Wizard3;
 a_Wizard2.id = 3;
 a_Wizard2.begintime = 2;
 a_Wizard2.speed = 2;
 a_Wizard2.nowPoint.x = 0;
 a_Wizard2.nowPoint.y = 0;
 a_Wizard1.goPoint.x = 5;
 a_Wizard1.goPoint.y = 5;

 Wizard a_Wizard4;
 a_Wizard2.id = 4;
 a_Wizard2.begintime = 3;
 a_Wizard2.speed = 1;
 a_Wizard2.nowPoint.x = 0;
 a_Wizard2.nowPoint.y = 0;
 a_Wizard1.goPoint.x = 5;
 a_Wizard1.goPoint.y = 5;

 getway_t(&a_Wizard1,table_table);

 getway_t(&a_Wizard2,table_table);

 getway_t(&a_Wizard3,table_table);

 getway_t(&a_Wizard4,table_table);

 getchar();
 return 0;
}

 

/*
#include <sys/time.h>
struct timeval
{
 long tv_sec;
 long tv_usec;
};

timeval start;
timeval end;

gettimeofday(&start,NULL);
gettimeofday(&end,NULL);

int sec = (start.tv_usec-end.tv_usec)*1000000;
*/

lurenceGu
关注
专栏目录
Python3 A*寻路算法实现方式
09-18
A* (A-star) 寻路算法是一种广泛应用在游戏开发、地图导航、路径规划等领域的高效搜索算法。它结合了Dijkstra算法的最短路径特性与优先队列的效率，通过引入启发式函数来指导搜索过程，使得路径查找更加智能且节省...
JS实现的A*寻路算法详解
12-12
A*寻路算法是一种在图形或网格环境中寻找最短路径的高效算法，广泛应用于游戏开发、路径规划等领域。本文将详细解析使用JavaScript实现A*寻路算法的过程。 首先，我们需要理解A*算法的基本原理。A*算法的核心在于...
Unity 实现A* 寻路算法
热门推荐
YF云飞的博客
10-03 1万+
A* 寻路算法在Unity中的示例
A*寻路算法
jkkk_的博客
10-12 3170
深度优先算法（BFS）在所有方向上平等的探索，是最好写的寻路算法Dijkstra算法优先考虑低成本的路径，在游戏中可以规定远离敌人、避开森林需要更高的成本，所以当移动成本发生变化的时候我们使用该算法而不是BFSA*寻路是对Dijkstra算法的修改，针对单个目标时进行了优化，Dijkstra的算法可以找到所有位置的路径;A 查找到一个位置的路径，或多个位置中最近的路径。它优先考虑似乎更接近目标的路径。下图依次表示他们的搜索区间。
Unity | A*寻路算法
持续学习！
01-28 2618
A*(A-Star)简介在游戏开发的过程中，不免需要涉及到怪物AI的寻路或让玩家自动导航到目标点位置，当在没有障碍的场景中，直接让怪物/玩家向目标点移动即可，但在有障碍物的场景中（如迷宫，房间，围墙等等），寻路算法就变得尤为重要。A*是目前主流的寻路算法之一，它的作用就是寻找开始点与目标点之间，避开障碍的最短路径。
unity之A*寻路
qq_42345116的博客
05-15 2449
二、 思路解析 我们先来了解一下A*寻路的思路： 1.每个块需要一个数据类，这个类中要存的数据有： 每个移动方块都有三个值F=G+H、G（代表起点到当前点的距离）H（当前点到终点的距离）。并且每个移动方块都会存储自己上一个块（Parent） 2.首先 创建一个开放列表（OpenList：存放已经找到并计算好FGH值的周围块）和一个关闭列表（closeList：不可移动的块，如起点、障碍物和已经走过的块） 3.将起点放入开放列表（openList）中，只要开放列表（openList）中存在可移动
C++实现A*寻路算法
crazybobo1207的博客
11-07 1416
和dijkstra算法一样，整个图是慢慢被探索的，所以也需要定义两个集合，一个是已经处理（探索）过的点的集合，另一个是待处理的点的集合（“待处理的点的集合”并不等于“未处理过的点的集合”，前者指的是已经看到但未处理的点，后者还包括那些在远处尚未看到的点）。A*算法的核心公式是F（起点到终点的距离）=G（起点到当前点的距离，即已经走过的路）+H（当前点到终点的距离，即还没走过的路）。2.将该点的8个邻接点（边界点、障碍物、已经处理过的点，这三者除外）放入open_list中，当遇到了终点时，break;
android a*算法寻路,[转]A*寻路算法
weixin_39594103的博客
05-29 352
在游戏中，有一个很常见地需求，就是要让一个角色从A点走向B点，我们期望是让角色走最少的路。嗯，大家可能会说，直线就是最短的。没错，但大多数时候，A到B中间都会出现一些角色无法穿越的东西，比如墙、坑等障碍物。这个时候怎么办呢？ 是的，我们需要有一个算法来解决这个问题，算法的目标就是计算出两点之间的最短路径，而且要能避开障碍物。百度百科：A*搜寻算法俗称A星算法。这是一种在图形平面上，有多个节点的路径...
【A*寻路】我看过的最简单的A*寻路算法讲解
bark2003的专栏
07-22 786
注：原文出自Patrick Lester，一稿翻译为Panic。很久以前的老文章了，但我觉得真的非常的经典，想把它完善一下让以后的人能够更好的体会原作者和原翻译的精髓吧。我在此基础上修改了部分译文，更新了部分错误，在此对两位前辈表示最高的致意！以下是原文：在看下面这篇文章之前，先介绍几个理论知识，有助于理解A*算法。启发式搜索：启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的...
golang的A*寻路
csdn93033的博客
08-23 355
golang的A*寻路
【Unity学习笔记】A*寻路算法
最新发布
milu_ELK的博客
07-04 1410
而不是类似Dijkstra算法，每次遍历相邻结点时尽管下一个结点可能出现权值过大的情况，但是我们不能确保它不是全局最优的，因此我们依然要把它加入到遍历路径中。贪心算法适用于路径带有不同权值的时候，遍历时我们优先遍历相邻结点中权值较小者，这样做的好处是如果找到了路径，那么我们的路径一定是部分最短的（相邻结点永远是最短的，虽然不一定是全局最短，但是相对来说不会是最差的）依次类推，按照表格上的路径，在第二轮发现v4达到不了v3，因此我们放弃这条路径，再次回到第二轮，选择除了这条路径以外最短的，也就是。
A*寻路TS实现
weakenCoder的博客
08-05 1277
const {ccclass, property} = cc._decorator; @ccclass export default class Helloworld extends cc.Component { @property(cc.Prefab) blockPb: cc.Prefab = null; @property(cc.Node) DITU: cc.Node = null; @p...
cocos creator 实现A*寻路
06-30
A*（A-Star）寻路算法是路径规划领域中一种广泛应用的算法，它结合了Dijkstra算法的最短路径特性与优先级队列的效率优势。在Cocos Creator中，利用JavaScript实现A*寻路算法可以为游戏或交互式应用提供高效、智能的...
A*寻路 -- 更加真实 的路径（二）
04-09
A*算法作为其中的一种高效寻路算法，被广泛应用。本文将深入探讨A*寻路算法，以及它如何提供更加真实的路径计算。我们将通过源码分析来理解其工作原理，并探索在实际项目中如何运用。 A*算法是Dijkstra算法的一个...
A_Star:A *寻路网络演示
03-13
**JavaScript实现A*寻路** 在JavaScript中实现A*寻路算法，通常涉及以下几个关键部分： 1. **数据结构**：首先，我们需要定义一个图或网格的数据结构来存储节点。这通常是一个二维数组，每个元素代表一个节点，...
模板库的基本使用( 《二》 对象管理)
gumingyaotangwei 的专栏
07-18 4935
前面讲了使用模板库进行对象的管理这里我们讲下算法的 管理 代码都很简单就不详细讲解了不懂可以留言或者交流 //=====================================================================================
首先讲一下 TL中使用Lua脚本的过程 脚本中的Timer过程
gumingyaotangwei 的专栏
04-01 4633
1.首先在c++源码中添加需要注册到Lua的函数   INT LuaFnSetTimer(Lua_State* L)   {   LUA_ENTER_FUNCTION   SceneID_t sceneId = Lua_ValueToNumber(L,1);   ObjID_t selfId = Lua_ValueToNumber(L,2);   ScriptID_t scriptI
简单win32程序创建控件
gumingyaotangwei 的专栏
10-13 3553
Win32 SDK利用ListView控件。 为了使用ListView控件,我们需要初始化公共控件库,我们需要在程序刚刚启动时调用 InitCommonControls() 函数，如果发生链接错误，说明我们没有链接拥有该函数的库文件。它们对应的 头和库 DLL分别为 #in
自己实现纯win32窗口事件（编辑框输入浮点数，静态框实现超链接，以前网上看见过相似代码自己改哈，以后有用）
gumingyaotangwei 的专栏
12-10 2933
/************************主窗口回调函数（放置编辑框的窗口）************************/LRESULT CALLBACK ProcMain(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam){  switch (Msg)  {  case WM_CLOSE:    EndDialog(hDlg, 0
理解A*寻路算法：从复杂到简单
"A*寻路算法是一种广泛应用在游戏开发、路径规划等领域的高级寻路算法，旨在找到两点间最短或最优的路径。对于初学者来说，A*算法可能显得复杂，但理解其原理和实施步骤后，会发现其实效性和效率都非常高。本文将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值