C#实现A*算法

最新推荐文章于 2024-08-13 12:00:43 发布
最新推荐文章于 2024-08-13 12:00:43 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： C#技术内幕

 

 

 

原址http://www.bianceng.cn/Programming/csharp/201012/21809.htm

 

 

 

在游戏开发中，AI的最基本问题之一就是寻路算法或称路径规划算法，在三 年前，我曾实现过 基于“图算法”的最短路径规划算法，然而在游 戏中，我们通常将地图抽象为有单元格构成的矩形，如：

这个微型地图 由3*3的单元格构成，当然，实际游戏中的地图通常比它大很多，这里只是给出 一个示例。

由于游戏地图通常由单元格构成，所以，基于“图算法 ”的路径规划便不再那么适用，我们需要采用基于单元格的路径规划算法 。A*算法是如今游戏所采用的寻路算法中相当常用的一种算法，它可以保证在任 何起点和任何终点之间找到最佳的路径（如果存在的话），而且，A*算法相当有 效。

关于A*算法的原理的详细介绍，可以参考 这篇文章。当你明白A*算 法的原理之后，在来看接下来的A*算法的实现就会比较容易了。

现在， 让我们转入正题，看看如何在C#中实现A*算法。

首先，我们把地图划分 为单元格，如此，一个地图就可以由（M行*N列）个单元格构成。我们使用 AStarNode类来抽象单元格，表示一个节点，而节点的位置用Point表示，其X坐 标表示Column Index，Y坐标表示Line Index。AStarNode的定义如下：

Code

[copy to clipboard]CODE:

/// <summary>
　　/// AStarNode 用于保存规划到当前节点时的各个 Cost值以及父节点。
　　/// zhuweisky 2008.10.18
　　/// </summary>
　　public class AStarNode
　　{
　　 　　#region Ctor
　　　　public AStarNode(Point loc, AStarNode previous, int _costG, int _costH)
　　　　{
　　　　　　 this.location = loc;
　　　　　　this.previousNode = previous;
　　　　　　this.costG = _costG;
　　　　　　this.costH = _costH;
　　　　}
　　　　#endregion
　　　　#region Location
　　　　private Point location = new Point(0, 0);
　　　　/// <summary>
　　　　/// Location 节点所在的位置， 其X值代表ColumnIndex，Y值代表LineIndex
　　　　/// </summary>
　　　　public Point Location
　　　　{
　　　　　　get { return location; }
　　　　}
　　　　 #endregion
　　　　#region PreviousNode
　　　　private AStarNode previousNode = null;
　　　　/// <summary>
　　　　/// PreviousNode 父节点，即是由哪个节点导航到当前节点的。
　　　　/// </summary>
　　　　public AStarNode PreviousNode
　　　　{
　　　　　　get { return previousNode; }
　　　　}
　　　　#endregion
　　　　 #region CostF
　　　　/// <summary>
　　　　/// CostF 从起点导航经过本节点然后再到目的节点的估算总代价。
　　　　/// </summary>
　　　　public int CostF
　　　　{
　 　　　　　get
　　　　　　{
　　　　　　　　return this.costG + this.costH;
　　　　　　}
　　　　}
　　　 　#endregion
　　　　#region CostG
　　　　private int costG = 0;
　　　　/// <summary>
　　　　/// CostG 从起点导 航到本节点的代价。
　　　　/// </summary>
　　　　 public int CostG
　　　　{
　　　　　　get { return costG; }
　　　　}
　　　　#endregion
　　　　#region CostH
　　　　private int costH = 0;
　　　　/// <summary>
　　　　/// CostH 使用启发式方法估算的从本节点到目的节点的代价。
　　　　/// </summary>
　　　　public int CostH
　　 　　{
　　　　　　get { return costH; }
　　　　}
　　 　　#endregion
　　　　#region ResetPreviousNode
　　　　/// <summary>
　　　　/// ResetPreviousNode 当从起点到达本节点 有更优的路径时，调用该方法采用更优的路径。
　　　　/// </summary>
　　　　public void ResetPreviousNode(AStarNode previous, int _costG)
　　　　{
　　　　　　 this.previousNode = previous;
　　　　　　this.costG = _costG;
　　　　}
　　　　#endregion
　　　　public override string ToString()
　　　　{
　　　　　　return this.location.ToString();
　　　　}
　　}

 

/// <summary>
　　/// SimpleCostGetter ICostGetter接口的简化实 现。直线代价为10， 斜线为14。
　　/// </summary>
　　 public class SimpleCostGetter : ICostGetter
　　{
　　　　 #region ICostGetter 成员
　　　　public int GetCost(Point currentNodeLoaction, CompassDirections moveDirection)
　　　　 {
　　　　　　if (moveDirection == CompassDirections.NotSet)
　　　　　　{
　　　　　　　　return 0;
　　　　　　}
　　　　　　if (moveDirection == CompassDirections.East || moveDirection == CompassDirections.West || moveDirection == CompassDirections.South || moveDirection == CompassDirections.North)
　　　　　　{
　　　　　　　　return 10;
　　　　　 　}
　　　　　　return 14;
　　　　}
　　　　 #endregion
　　}

 

 

我们知道，如果定义上、下、左、右的 代价为1，那么斜线的代价应为根号2，为了提高计算效率，我们将根号2取近似 值为1.4，并将单位放大10倍（计算机对整数的运算比对浮点数的运算要快很多 ）。

我们还需要一个结构来保存在路径规划过程中的中间结果：

Code

[copy to clipboard]CODE:

/// <summary>
　　/// RoutePlanData 用于封装一次路径规划过程中 的规划信息。
　　/// </summary>
　　public class RoutePlanData
　　{
　　　　#region CellMap
　　　　 private Rectangle cellMap;
　　　　/// <summary>
　　 　　/// CellMap 地图的矩形大小。经过单元格标准处理。
　　　　/// </summary>
　　　　public Rectangle CellMap
　　　　 {
　　　　　　get { return cellMap; }
　　　　}
　　　 　#endregion
　　　　#region ClosedList
　　　　private IList<AStarNode> closedList = new List<AStarNode>();
　　　　/// <summary>
　　　　/// ClosedList 关闭列表，即存 放已经遍历处理过的节点。
　　　　/// </summary>
　　　 　public IList<AStarNode> ClosedList
　　　　{
　　　 　　　get { return closedList; }
　　　　}
　　　　 #endregion
　　　　#region OpenedList
　　　　private IList<AStarNode> openedList = new List<AStarNode>();
　　　　/// <summary>
　　　　/// OpenedList 开放列表，即存 放已经开发但是还未处理的节点。
　　　　/// </summary>
　　　　public IList<AStarNode> OpenedList
　　　　{
　　　　　　get { return openedList; }
　　　　}
　　　　 #endregion
　　　　#region Destination
　　　　private Point destination;
　　　　/// <summary>
　　　　/// Destination 目的节点的位置。
　　　　/// </summary>
　 　　　public Point Destination
　　　　{
　　　　　　get { return destination; }
　　　　}
　　　　#endregion
　　 　　#region Ctor
　　　　public RoutePlanData(Rectangle map, Point _destination)
　　　　{
　　　　　　this.cellMap = map;
　　　　　　this.destination = _destination;
　　　　}
　　　　#endregion
　　}

有了上述这些基础结构 ，我们便可以开始实现算法的核心功能了：

Code

[copy to clipboard]CODE:

/// <summary>
　　/// AStarRoutePlanner A*路径规划。每个单元格Cell的位置用Point表示
　 　/// F = G + H 。
　　/// G = 从起点A，沿着产生的路径，移动到网 格上指定方格的移动耗费。
　　/// H = 从网格上那个方格移动到终点B 的预估移动耗费。使用曼哈顿方法，它计算从当前格到目的格之间水平和垂直的 方格的数量总和，忽略对角线方向。
　　/// zhuweisky 2008.10.18
　　/// </summary>
　　public class AStarRoutePlanner
　　{
　　　　private int lineCount = 10;　//反映地图高度，对应 Y坐标
　　　　private int columnCount = 10; //反映地图宽度，对应X 坐标
　　　　private ICostGetter costGetter = new SimpleCostGetter();
　　　　private bool[][] obstacles = null; // 障碍物位置，维度：Column * Line
　　　　#region Ctor
　　　 　public AStarRoutePlanner() :this(10 ,10 ,new SimpleCostGetter())
　　　　{
　　　　}
　　　　public AStarRoutePlanner(int _lineCount, int _columnCount, ICostGetter _costGetter)
　　　　 {
　　　　　　this.lineCount = _lineCount;
　　　　　　 this.columnCount = _columnCount;
　　　　　　this.costGetter = _costGetter;
　　　　　　this.InitializeObstacles();
　　　 　}
　　　　/// <summary>
　　　　/// InitializeObstacles 将所有位置均标记为无障碍物。
　　　　/// </summary>
　　　　private void InitializeObstacles()
　　　　{
　　　　　　this.obstacles = new bool [this.columnCount][];
　　　　　　for (int i = 0; i < this.columnCount; i++)
　　　　　　{
　　　　　　　　 this.obstacles = new bool[this.lineCount];
　　　　　　}
　 　　　　　for (int i = 0; i < this.columnCount; i++)
　　　　 　　{
　　　　　　　　for (int j = 0; j < this.lineCount; j++)
　　　　　　　　{
　　　　　　　　　　this.obstacles[j] = false;
　　　　　　　　}
　　　　　　}
　　　　}
　　　　#endregion
　　　　#region Initialize
　　　　/// <summary>
　　　　/// Initialize 在路径规划之前先设置障碍物 位置。
　　　　/// </summary>
　　　　public void Initialize(IList<Point> obstaclePoints)
　　　　{
　　 　　　　if (obstacles != null)
　　　　　　{
　　　　　　　 　foreach (Point pt in obstaclePoints)
　　　　　　　　{
　 　　　　　　　　　this.obstacles[pt.X][pt.Y] = true;
　　　　　　 　　}
　　　　　　}
　　　　}
　　　　#endregion
　　　　#region Plan
　　　　public IList<Point> Plan(Point start, Point destination)
　　　　{
　　　　　　Rectangle map = new Rectangle(0, 0, this.columnCount, this.lineCount);
　　 　　　　if ((!map.Contains(start)) || (!map.Contains(destination)))
　　　　　　{
　　　　　　　　throw new Exception ("StartPoint or Destination not in the current map!");
　　　　　　}
　　　　　　RoutePlanData routePlanData = new RoutePlanData(map, destination);
　　　　　　AStarNode startNode = new AStarNode(start, null, 0, 0);
　　　　　　 routePlanData.OpenedList.Add(startNode);
　　　　　　AStarNode currenNode = startNode;
　　　　　　//从起始节点开始进行递归调用
　　　　　　return DoPlan(routePlanData, currenNode);
　　 　　}
　　　　#endregion
　　　　#region DoPlan
　　　 　private IList<Point> DoPlan(RoutePlanData routePlanData, AStarNode currenNode)
　　　　{
　　　　　　 IList<CompassDirections> allCompassDirections = CompassDirectionsHelper.GetAllCompassDirections();
　　　　　　 foreach (CompassDirections direction in allCompassDirections)
　 　　　　　{
　　　　　　　　Point nextCell = GeometryHelper.GetAdjacentPoint(currenNode.Location, direction);
　　　　　　　　if (!routePlanData.CellMap.Contains(nextCell)) //相邻 点已经在地图之外
　　　　　　　　{
　　　　　　　　　　 continue;
　　　　　　　　}
　　　　　　　　if (this.obstacles[nextCell.X][nextCell.Y]) //下一个Cell为障碍物
　 　　　　　　　{
　　　　　　　　　　continue;
　　　　　　　 　}
　　　　　　　　int costG = this.costGetter.GetCost (currenNode.Location, direction);
　　　　　　　　int costH = Math.Abs(nextCell.X - routePlanData.Destination.X) + Math.Abs (nextCell.Y - routePlanData.Destination.Y);
　　　　　　　　if (costH == 0) //costH为0，表示相邻点就是目的点，规划完成，构造结果路径
　　　　　　　　{
　　　　　　　　　　IList<Point> route = new List<Point>();
　　　　　　　　　　route.Add (routePlanData.Destination);
　　　　　　　　　　route.Insert(0, currenNode.Location);
　　　　　　　　　　AStarNode tempNode = currenNode;
　　　　　　　　　　while (tempNode.PreviousNode != null)
　　　　　　　　　　{
　　　　　　　　　　　　 route.Insert(0, tempNode.PreviousNode.Location);
　　　　　　　　 　　　　tempNode = tempNode.PreviousNode;
　　　　　　　　　　}
　　　　　　　　　　return route;
　　　　　　　　}
　 　　　　　　　AStarNode existNode = this.GetNodeOnLocation(nextCell, routePlanData);
　　　　　　　　if (existNode != null)
　　 　　　　　　{
　　　　　　　　　　if (existNode.CostG > costG)
　　　　　　　　　　{
　　　　　　　　　　　　//如果 新的路径代价更小，则更新该位置上的节点的原始路径
　　　　　　　　 　　　　existNode.ResetPreviousNode(currenNode, costG);
　　　　 　　　　　　}
　　　　　　　　}
　　　　　　　　else
　 　　　　　　　{
　　　　　　　　　　AStarNode newNode = new AStarNode(nextCell, currenNode, costG, costH);
　　　　　　　　　 　routePlanData.OpenedList.Add(newNode);
　　　　　　　　}
　　　　　　}
　　　　　　//将已遍历过的节点从开放列表转移到关闭 列表
　　　　　　routePlanData.OpenedList.Remove(currenNode);
　　　　　　routePlanData.ClosedList.Add(currenNode);
　　　　 　　AStarNode minCostNode = this.GetMinCostNode (routePlanData.OpenedList);
　　　　　　if (minCostNode == null) //表明从起点到终点之间没有任何通路。
　　　　　　{
　　　　 　　　　return null;
　　　　　　}
　　　　　　//对开放列表 中的下一个代价最小的节点作递归调用
　　　　　　return this.DoPlan(routePlanData, minCostNode);
　　　　}
　　　　 #endregion
　　　　#region GetNodeOnLocation
　　　　/// <summary>
　　　　/// GetNodeOnLocation 目标位置location是 否已存在于开放列表或关闭列表中
　　　　/// </summary>
　　　　private AStarNode GetNodeOnLocation(Point location, RoutePlanData routePlanData)
　　　　{
　　　　　　foreach (AStarNode temp in routePlanData.OpenedList)
　　　　　　{
　　　　　　　　if (temp.Location == location)
　　　　　　　　 {
　　　　　　　　　　return temp;
　　　　　　　　}
　 　　　　　}
　　　　　　foreach (AStarNode temp in routePlanData.ClosedList)
　　　　　　{
　　　　　　　　if (temp.Location == location)
　　　　　　　　{
　　　　　　　 　　　return temp;
　　　　　　　　}
　　　　　　}
　　 　　　　return null;
　　　　}
　　　　#endregion
　　 　　#region GetMinCostNode
　　　　/// <summary>
　　 　　/// GetMinCostNode 从开放列表中获取代价F最小的节点，以启动下一次递 归
　　　　/// </summary>
　　　　private AStarNode GetMinCostNode(IList<AStarNode> openedList)
　　　　{
　　　　　　if (openedList.Count == 0)
　　　　　　{
　　　 　　　　　return null;
　　　　　　}
　　　　　　AStarNode target = openedList[0];
　　　　　　foreach (AStarNode temp in openedList)
　　　　　　{
　　　　　　　　if (temp.CostF < target.CostF)
　　　　　　　　{
　　　　　　　　　　 target = temp;
　　　　　　　　}
　　　　　　}
　　　　 　　return target;
　　　　}
　　　　#endregion
　　}

代码中已经加了详尽的注释，要注意的有以下几点：

1.Initialize方法用于初始化障碍物的位置，所谓“障碍物 ”，是指导航时无法穿越的物体，比如，游戏中的墙、河流等。

2. 标记为红色的ResetPreviousNode方法调用处，说明，到达当前节点的当前路径 比已存在的路径代价更小，所以要选择更优的路径。

3.标记为黑体的 route.Insert(0, tempNode.PreviousNode.Location);方法调用，表示已经找到 最优路径，此处便可通过反向迭代的方式整理出从起点到终点的最终路径。

4.CostH 的计算使用曼哈顿方法，它计算从当前格到目的格之间水平和 垂直的方格的数量总和，忽略对角线方向。

5.在该算法中，至少还有一 个地方可以优化，那就是GetMinCostNode方法所实现的内容，如果在路径搜索的 过程中，我们就将OpenList中的各个节点按照Cost从小到大进行排序，那么每次 GetMinCostNode时，就只需要取出第一个节点即可，而不必在遍历OpenList中的 每一个节点了。在地图很大的时候，此法可以大幅提升算法效率。

最后 ，给出一个例子，感受一下：

Code

[copy to clipboard] CODE:

　　　　　AStarRoutePlanner aStarRoutePlanner = new AStarRoutePlanner();
　　　　　　IList<Point> obstaclePoints = new List<Point>();
　　　　　　 obstaclePoints.Add(new Point(2, 4));
　　　　　　 obstaclePoints.Add(new Point(3, 4));
　　　　　　 obstaclePoints.Add(new Point(4, 4));
　　　　　　 obstaclePoints.Add(new Point(5, 4));
　　　　　　 obstaclePoints.Add(new Point(6, 4));
　　　　　　 aStarRoutePlanner.Initialize(obstaclePoints);
　　　　　　 IList<Point> route = aStarRoutePlanner.Plan(new Point(3, 3), new Point(4, 6));

运行后，返回的route结果如下：

{3,3}, 　{2,3},　{1,3},　{1,4},　{1,5},　{2,5},　{2,6},　{3,6},　{4,6}

 

 

 

 

 

 

 

夜色。
关注
专栏目录
清晰简洁的A*寻路算法教程（含C#代码）
Xiuxiu234的博客
02-23 949
前言 本文主要讲述基于网格型地图的A*算法，对于基本图结构只需要将遍历的方法改为新的节点关系就可以实现。 目录 一、实现方法 二、核心思想 三、经典例子 四、代码实现 一、 实现方法 （一）数据结构 MapSign: 节点标记。表示节点的性质包含（FREE, OPEN, CLOSE, BAN） Mapnode：节点类。包含节点坐标Pos；移动代价Startcost；全部代价Cost；节点标记Mapsign; 父节点Fathernode； OpenList：所有已知可以从起点到达的节点。 CloseLis
A* 算法（示例程序+源码）（C#版）
05-30
这是一再游戏中很著名的寻路算法，是基于曼哈顿的算法的A*算法！
A*算法的C#实现
weixin_34240520的博客
10-22 202
     在游戏开发中，AI的最基本问题之一就是寻路算法或称路径规划算法，在三年前，我曾实现过基于“图算法”的最短路径规划算法，然而在游戏中，我们通常将地图抽象为有单元格构成的矩形，如：           （本图源于这里）      这个微型地图由3*3的单元格构成，当然，实际游戏中的地图通常比它大很多，这里只是给出一个示例。      由于游戏地图通常由单元格构成，所以，基于“图算法”的...
A*（A-Star）算法解析（附代码理解）
最新发布
LIUMAO99的博客
08-13 1001
这意味着算法会找到从起点到终点的最短路径，前提是启发式函数是可接受的（admissible），即它不会高估实际的代价。在图论中，节点代表图中的每一个顶点，可以是地图上的一个点、网络中的一个路由器或者任何可以表示为图中一个独立元素的实体。在A*算法中，节点通常代表可能的路径点，例如在地图上从一个城市到另一个城市可能的路线点。边是连接两个节点的线，在A*算法中，边代表从一个节点到另一个节点的路径。值越小，表示从起点到当前节点，再加上到目标点的估计代价越低，这个节点就越有可能是最短路径的一部分。
C# A*算法实现8数或者15数问题
aome1470的博客
03-24 111
－、问题描述 8数或15数问题是同一个问题，其就是一个随机排列的8个或15个数在一个方正格子中移动到达规定的一个目标状态。由于只有一个空格子，故只有在空格附近的棋子可以移动。 二、算法描述 F 算法选择 此问题需要对所有可能的路径进行穷举，但是由于随着树的高度的加大，其子结点的增加宿舍剧增，所以对所有的子结点进行穷举是不大现实的。而根据当前的状态和目标状态进行对比可以用一个评估函数来评估...
A*算法C#实现
07-27
A*算法，A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。代码使用c#语言实现，欢迎下载
C# A*算法
qq_60125117的博客
04-24 1897
A*算法是一种广泛使用的路径搜索算法，通常用于寻找在给定地图或图形中，起点到目标点之间的最短路径。它是一种基于贪心策略的启发式搜索算法，可以在大多数情况下找到最短路径。
C#实现的A*算法代码
04-18
总的来说，C#实现A*算法涉及的主要知识点包括启发式搜索、数据结构（如优先级队列）、图形搜索理论以及C#编程实践。通过理解这些概念并实际编码，你可以构建出一个高效且准确的路径搜索解决方案。
astar-algorithm-cpp:C ++和C＃中A *算法的实现
05-24
此代码是A *算法在C ++和C＃中的高效实现，旨在用于高性能实时应用程序（视频游戏），并具有可选的快速内存分配方案。 该A *教程随附了它： : Hart，Nillson和Raphael在论文描述了A *算法。 遗憾的是尼尔斯·...
C#A*算法
xiehaiyang1234的博客
02-25 552
代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Collections; namespace ConsoleApplication2 {     class Program     {             static void ...
C#写的A*算法
07-04
C#写的A*算法，支持4发现和八方向，可以选择性绕过斜角。内有详细注释！
A*算法 C#源代码
12-23
此为用C#写的A*算法源代码 using System; using System.Collections.Generic; using System.Text; using System.Drawing; namespace EtSoft.AStarLib { public class AStar { private StarNodeCollection openList = new StarNodeCollection(); private StarNodeCollection closeList = new StarNodeCollection(); public StarNode currentNode = null; #region 构造函数 /// <summary> /// 使用指定的地图对象、起点和终点初始化A星算法 /// </summary> /// <param name="map">地图对象</param> public AStar(Map map) { this.map = map; } /// <summary> /// /// </summary> /// <param name="map">地图对象</param> /// <param name="start">起点坐标</param> /// <param name="end">终点坐标</param> public AStar(Map map, Point start, Point end) : this(map) { this.start = new StarNode(start); this.end = new StarNode(end); openList.Add(new StarNode(start)); //AddStartNodeToOpenList(this.start); } /// <summary> /// /// </summary> /// <param name="map">地图对象</param> /// <param name="startX">起点X坐标</param> /// <param name="startY">起点Y坐标</param> /// <param name="endX">终点X坐标</param> /// <param name="endY">终点Y坐标</param> public AStar(Map map, int startX, int startY, int endX, int endY) : this(map, new Point(startX, startY), new Point(endX, endY)) { } #endregion #region 属性 protected Map map; /// <summary> /// 地图数据 /// </summary> public Map Map { get { return map; } set { map = value; } } private StarNode start = null; /// <summary> /// 起点坐标，如果没有设置起点，返回null /// </summary> public StarNode Start { get { return start; } set { start = value; openList.Clear(); openList.Add(start); //AddNodeToOpenList(start); } } private StarNode end = null; /// <summary> /// 终点坐标，如果没有设置终点，返回null /// </summary> public StarNode End { get { return end; } set { end = value; } } private StarNodeCollection path; /// <summary> /// 返回路径节点集合，没有路径则返回null /// </summary> public StarNodeCollection Path { get { return path; } } private bool allDirection = false; /// <summary> /// true，允许八方向寻路 /// </summary> public bool AllDirection { get { return allDirection; } set { allDirection = value; } } #endregion /// <summary> /// 开始寻路 /// </summary> public void StartSearchPath() { if (start == null) throw new InvalidNodeException(InvalidNodeTypes.NoStart); if (end == null) throw new InvalidNodeException(InvalidNodeTypes.NoEnd); path = null; openList.Clear(); closeList.Clear(); currentNode = start; SearchPath(currentNode); } //寻路递归，受保护的虚方法，允许在子类重写寻路算法 protected virtual void SearchPath(StarNode starNode) { //currentNode = starNode; openList.Remove(starNode); closeList.Add(starNode); AddNodeToOpenList(); if (closeList.Contains(end)) { //如果终点在关闭列表中，找到路径 StarNode node=starNode.Parent; path = new StarNodeCollection(); do { path.Add(node); node = node.Parent; } while (node != null && !node.Equals(start)); path.Reverse(); return; } else if (openList.Count == 0) { //终点不在关闭列表，开放列表已空，没有可通行的路径 return; } currentNode = GetNextNode(); //迭代过程 SearchPath(currentNode); } /// <summary> /// 获得当前节点的下一个最佳节点 /// </summary> /// <returns></returns> public StarNode GetNextNode() { openList.SortByF(); return openList[0]; } /// <summary> /// 把当前点周围可通过的点加入到开放列表中 /// </summary>
C#该写的A*算法,自动寻路
11-11
根据人工智能课上的A-Start算法写的,感觉比较好玩,有兴趣的可以下下来看看
A*算法
weixin_33766805的博客
09-05 1107
 Dijkstra算法 　　迪杰斯特拉（Dijkstra）算法是典型的最短路径的算法，由荷兰计算机科学家迪杰斯特拉于1959年提出，用来求得从起始点到其他所有点最短路径。该算法采用了贪心的思想，每次都查找与该点距离最近的点，也因为这样，它不能用来解决存在负权边的图。解决的问题可描述为：在无向图 G=(V,E) 中，假设每条边 E[i] 的长度为 w[i]，找到由顶点vs到其余各点的最短路径。 ...
A*算法的理解和使用 【C#版本】
IfURunWithMe的博客
11-26 850
  项目中使用到了自动寻路这些功能，正好总结一下A*的各种概念和个人的理解     目录   1、A*算法的基本概念 2、A*算法的寻路过程 3、图解 4、代码 1、A*算法的基本概念 启发式搜索：     启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对...
C#实现：A*寻路算法详解
"C#实现A*寻路算法组件" 本文将详细介绍如何在C#中创建一个.NET组件，该组件用于构建图结构并执行特定操作，特别是应用著名的A*寻路算法来寻找两个位置之间的最佳路径。首先，我们需要理解图的基本概念。 在图论中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值