A星算法matlab源码及详细注释
A星算法详解范文
A星算法详解范文A*算法是一种常用的启发式算法,多用于解决图问题。
它是一种综合了Dijkstra算法和贪心算法的算法,利用估算函数来接近最短路径,提高效率。
下面我们来详细介绍A*算法。
A*算法的核心思想是综合考虑两个值:实际路径长度g(n)和启发式函数预估路径长度h(n)。
实际路径长度是指从起始点到当前点的路径长度,启发式函数预估路径长度是指从当前点到目标点的路径长度。
基于这两个值,A*算法会在过程中选择总的路径长度(f(n)=g(n)+h(n))最小的点进行扩展。
A*算法的伪代码如下:1. 将起始点加入open列表,并将起始点的f(n)值设为0。
2. 当open列表不为空时:a. 从open列表中选择f(n)值最小的点,并将该点加入closed列表。
b.如果选择的点是目标点,则结束,返回路径。
c.对于选择的点的每一个相邻点:i. 如果相邻点不可通行或者已经在closed列表中,则忽略。
ii. 如果相邻点不在open列表中,则将其加入open列表,并更新相邻点的父节点为选择的点,并计算相邻点的f(n)值。
iii. 如果相邻点已经在open列表中,比较从当前选择的点到相邻点的实际路径长度是否小于之前计算的路径长度,如果是,则更新相邻点的父节点和f(n)值。
A*算法的关键在于如何选择合适的启发式函数。
一个好的启发式函数应该尽量准确地估计从当前点到目标点的路径长度。
启发式函数常用的有以下几种形式:1.曼哈顿距离:启发式函数的值为当前点到目标点在格子网格中的曼哈顿距离,即横向和纵向的距离之和。
2.欧几里得距离:启发式函数的值为当前点到目标点的欧几里得距离,即两点之间的直线距离。
3.切比雪夫距离:启发式函数的值为当前点到目标点在格子网格中的切比雪夫距离,即横向和纵向的距离中最大的距离。
4.对角线距离:启发式函数的值为当前点到目标点在格子网格中的对角线距离,即两点之间的最短距离。
A*算法的优点是可以找到最短路径,而且在启发式函数设计合理的情况下,能够较快地找到最优解。
3A星算法实验报告
3A星算法实验报告
一、实验背景
星算法(A*)是一种基于启发式算法,它将图形中的启发式算法应用到
图形空间中的路径规划上,此算法具有较高的效率,可以把空间中没有考
虑的因素考虑在内,使过程更加的准确。
星算法的核心思想是:每次出最
佳的节点,也就是不停的计算出节点的最佳路径,然后从这个路径中选择
出一条最佳路径,再不断的迭代下去,直至找到目标。
二、实验步骤
(1)建立空间:定义空间的范围,比如设定节点的大小、路径的长度、地图大小等参数;
(2)初始化地图:设定起点和终点,初始化路径地图;
(3)计算启发函数:根据节点的位置,计算出每个节点的启发函数值;
(4)启发式:根据计算出来的启发函数值,按照启发式算法的方式,从起点开始不断的迭代;
(5)记录结果:记录出来的最佳路径,计算出最优路径的长度;
(6)对比结果:使用其他算法,如Dijkstra算法,对比结果,比较
各种算法的效率;
三、实验结果
实验结果表明,在进行路径时。
a星算法预处理路径
a星算法预处理路径1. 引言a星算法(A* algorithm)是一种常用的路径搜索算法,广泛应用于人工智能、游戏开发等领域。
在进行路径搜索时,为了提高搜索效率和准确性,预处理路径是一种常用的优化方法。
本文将详细介绍a星算法以及预处理路径的概念和原理,并探讨预处理路径在路径搜索中的应用。
2. a星算法简介2.1 原理a星算法是一种启发式搜索算法,借助估算函数(称为启发函数)确定搜索方向和顺序。
它通过评估节点的代价函数来估计从起始节点到目标节点的最短路径,并逐步探索潜在的最优路径。
其主要思想是将节点划分为开放列表(存储待考虑的节点)和关闭列表(存储已考虑的节点),不断选择开放列表中代价最小的节点进行拓展直到找到目标节点或开放列表为空。
2.2 估算函数估算函数是a星算法的核心,用于评估节点的优先级。
常用的估算函数包括曼哈顿距离、欧几里得距离和切比雪夫距离等。
估算函数应该能够高效地估计节点到目标节点的代价,以提高搜索效率和准确性。
3. 预处理路径3.1 定义预处理路径是指在路径搜索之前,通过预先计算和存储节点之间的最短路径信息,以加速实际路径搜索过程。
它可以理解为对路径搜索问题的离线处理,通过空间换取时间,提高路径搜索的效率。
3.2 实现预处理路径的实现需要基于已有的地图信息,可以利用传统的图论算法,如Dijkstra算法或Floyd-Warshall算法,计算出任意两个节点之间的最短路径。
然后将计算结果存储在数据结构中,以便在路径搜索时进行快速查找。
预处理路径的时间复杂度较高,但由于只需执行一次,可以将计算结果保存以供多次使用,大大提高了实际路径搜索的效率。
3.3 应用预处理路径在实际路径搜索中有广泛的应用。
它可以用于快速寻找两个节点之间的最短路径,避免重复计算和重复查询的时间浪费。
预处理路径还可以用于路径规划、导航系统等领域,提高系统的响应速度和用户体验。
4. a星算法与预处理路径的结合4.1 思路将a星算法与预处理路径相结合,可以进一步提高路径搜索的效率。
MATLAB编程技巧分享
MATLAB编程技巧分享一、MATLAB的介绍与基础知识MATLAB,全称为MATrix LABoratory,是一款功能强大的数学软件,被广泛应用于科学计算、数据分析与可视化。
它的优势在于强大的矩阵计算和向量化运算能力,以及丰富的工具箱和函数库。
在本文中,将分享一些MATLAB编程中的实用技巧,以提高编程效率和代码可读性。
二、代码注释的重要性在编写MATLAB代码时,良好的注释是至关重要的。
代码注释可以帮助他人理解你的代码逻辑和实现思路,也能够帮助自己在日后维护代码时快速回顾。
合理的代码注释应当包括函数功能的简要描述、输入输出参数的说明、关键变量的解释等。
同时,建议在代码中使用英文命名规范,以使他人更易读懂你的代码。
三、向量化运算提高运算速度MATLAB的一个重要特点是对向量化运算的支持,即一次性操作整个向量或矩阵。
与使用循环语句逐个元素进行运算相比,向量化运算可以大幅提高代码的运行效率。
例如,计算两个向量对应元素的乘积和可以使用点乘以及sum函数的组合,而不需要使用for循环。
四、矩阵运算的应用1. 矩阵乘法与点乘积在MATLAB中,矩阵乘法使用“*”运算符表示,点乘积则使用“.*”运算符表示。
矩阵乘法是按矩阵乘法规则进行操作,而点乘积则是对应元素进行相乘。
矩阵乘法在求解线性方程组、矩阵的特征值等方面有着广泛的应用。
2. 矩阵的转置与共轭转置通过使用“'”运算符,可以方便地对矩阵进行转置操作。
而共轭转置则使用“.'”运算符表示,它不仅会对矩阵进行转置,还会对矩阵中的复数元素进行共轭操作。
这些矩阵运算在信号处理、通信系统等领域中经常被使用。
五、优化MATLAB代码性能的技巧1. 预分配内存在循环中频繁地进行变量赋值操作会导致MATLAB不断地重新分配内存,从而影响程序运行效率。
为了避免这种情况,可以在循环之前预分配内存,即通过zeros或ones函数创建一个与循环中变量相同大小的矩阵。
a星算法的原理(一)
a星算法的原理(一)A星算法1. 引言A星算法(A*算法)是一种常用的路径搜索算法,用于在图形上找到两个节点之间的最短路径。
该算法通过在搜索过程中利用启发式函数(heuristic)来评估每个节点的可能成本,以决定搜索哪个节点。
2. 原理概述A星算法基于图搜索算法,通过维护一个优先级队列来选择下一个要扩展的节点。
具体来说,算法按照优先级从高到低的顺序遍历节点,直到找到目标节点或队列为空。
3. 节点评估为了选择下一个要扩展的节点,A星算法使用了一个评估函数。
该函数将节点的价值估计为从起始节点到目标节点的实际成本加上启发式函数的估计值。
4. 启发式函数启发式函数是A星算法的核心。
它根据当前节点和目标节点的位置计算节点的估计成本。
这个估计成本应该是乐观的,即不会低估实际成本。
常用的启发式函数包括曼哈顿距离和欧式距离。
4.1 曼哈顿距离曼哈顿距离是通过水平和垂直距离计算两个点之间的距离。
对于二维平面上的点A(x1, y1)和点B(x2, y2),曼哈顿距离的计算公式为:|x1 - x2| + |y1 - y2|4.2 欧式距离欧式距离是通过直线距离计算两个点之间的距离。
对于二维平面上的点A(x1, y1)和点B(x2, y2),欧式距离的计算公式为:sqrt((x1-x2)^2 + (y1-y2)^2)5. 算法步骤A星算法的具体步骤如下: 1. 初始化起始节点和目标节点。
2. 将起始节点添加到待扩展节点的优先级队列中,其中其估计成本为0。
3. 循环执行以下步骤直到找到目标节点或队列为空: - 从优先级队列中选择估计成本最低的节点。
- 如果该节点是目标节点,算法结束。
- 否则,将该节点标记为已访问,并将其邻居节点添加到优先级队列中。
4. 如果队列为空且未找到目标节点,则表示目标节点无法达到。
6. 优缺点A星算法的优点在于它可以快速找到最短路径,并且能在找到路径之前通过启发式函数进行剪枝,减少搜索空间。
A星算法中文详解
A星算法中文详解A*算法是一种图算法,用于找到从起始节点到目标节点的最短路径。
它是一种启发式算法,根据每个节点的估计成本来进行。
本文将详细介绍A*算法的原理、步骤和实现。
A* 算法的基本思想是在 Dijkstra 算法的基础上引入启发式函数,目的是在过程中尽量选择离目标节点更接近的路径。
启发式函数通常使用两个估计函数的和:g(n) 是从起始节点到当前节点的实际代价,h(n) 是当前节点到目标节点的估计代价。
通过评估 f(n) = g(n) + h(n) 的值,选择 f(n) 最小的节点作为下一步的节点。
这样,方向就会倾向于更接近目标节点的路径。
A*算法的步骤如下:1. 创建两个空集合:Open 集合和 Closed 集合。
Open 集合存储待考虑的节点,Closed 集合存储已经考虑过的节点。
2. 将起始节点添加到 Open 集合中,并初始化 g(n) 和 h(n) 的值。
3. 从 Open 集合中选择 f(n) 最小的节点作为当前节点,并将其移出 Open 集合,放入 Closed 集合中。
4.对当前节点的相邻节点进行遍历:- 如果相邻节点已经在 Closed 集合中,则忽略它。
- 如果相邻节点不在 Open 集合中,将其添加到 Open 集合,并计算g(n) 和 h(n) 的值。
- 如果相邻节点已经在 Open 集合中,计算经过当前节点到达相邻节点的 g(n) 值。
如果计算得到的 g(n) 值更小,则更新相邻节点的 g(n) 值。
5. 重复步骤 3 和 4,直到找到目标节点或者 Open 集合为空。
如果Open 集合为空且没有找到目标节点,则表示无法到达目标节点。
6.如果找到目标节点,可以通过回溯从目标节点到起始节点的路径。
路径上的节点可以通过每个节点的父节点指针找到。
以上就是A*算法的详细步骤。
A*算法的时间复杂度取决于启发式函数的选择和问题的规模。
通常情况下,A*算法的时间复杂度为O(b^d),其中b是分支因子,d是目标节点的最短路径长度。
A星算法详解
pnode->father = pnode_now;
if (orient % 2 == 0)
{
pnode->g = pnode->father->g + 10;
} else {
pnode->g = pnode->father->g + 14; } pnode->f = pnode->g + pnode->h; Openlist2.push_front(pnode); } Openlist2.sort(cmp<Node*>()); mygraph.Loc[pnode->loc_y][pnode->loc_x] = INOPEN; vect_node.push_back(pnode); //system("choice /t 0.5 /d y /n >nul"); system("pause"); system("cls"); mygraph.map(); }
6. 如果某个相邻方格 D 已经在 "开启 列表" 里了, 检查如果用新的路径 (就是经过 C 的路径) 到达它的话, G值是否会更低一些, 如果新的G值更低, 那就把它的 "父方格" 改 为目前选中的方格 C, 然后重新计算它的 F 值和 G 值 (H 值不需要重新计算, 因为对于 每 较个 高方 , 就C块o说p, yH明ri经g值h过是t ©不C2变0再1的到6 )C达. r如eDa果t不e新C是的h一enG个值明比智 的选择, 因为它需要更远的路, 这时我们什么 也不做.
MATLAB命令大全+注释小结
MATLAB命令⼤全+注释⼩结⼀、常⽤对象操作:除了⼀般windows窗⼝的常⽤功能键外。
1、!dir 可以查看当前⼯作⽬录的⽂件。
!dir& 可以在dos状态下查看。
2、who 可以查看当前⼯作空间变量名, whos 可以查看变量名细节。
3、功能键:功能键快捷键说明⽅向上键 Ctrl+P 返回前⼀⾏输⼊⽅向下键 Ctrl+N 返回下⼀⾏输⼊⽅向左键 Ctrl+B 光标向后移⼀个字符⽅向右键 Ctrl+F 光标向前移⼀个字符Ctrl+⽅向右键 Ctrl+R 光标向右移⼀个字符Ctrl+⽅向左键 Ctrl+L 光标向左移⼀个字符home Ctrl+A 光标移到⾏⾸End Ctrl+E 光标移到⾏尾Esc Ctrl+U 清除⼀⾏Del Ctrl+D 清除光标所在的字符Backspace Ctrl+H 删除光标前⼀个字符 Ctrl+K 删除到⾏尾Ctrl+C 中断正在执⾏的命令4、clc可以命令窗⼝显⽰的内容,但并不清除⼯作空间。
⼆、函数及运算1、运算符:+:加,-:减, *:乘, /:除, \:左除 ^:幂,‘:复数的共轭转置,():制定运算顺序。
2、常⽤函数表:sin( ) 正弦(变量为弧度)Cot( ) 余切(变量为弧度)sind( ) 正弦(变量为度数)Cotd( ) 余切(变量为度数)asin( ) 反正弦(返回弧度)acot( ) 反余切(返回弧度)Asind( ) 反正弦(返回度数)acotd( ) 反余切(返回度数)cos( ) 余弦(变量为弧度)exp( ) 指数cosd( ) 余弦(变量为度数)log( ) 对数acos( ) 余正弦(返回弧度)log10( ) 以10为底对数acosd( ) 余正弦(返回度数)sqrt( ) 开⽅tan( ) 正切(变量为弧度)realsqrt( ) 返回⾮负根tand( ) 正切(变量为度数)abs( ) 取绝对值atan( ) 反正切(返回弧度)angle( ) 返回复数的相位⾓atand( ) 反正切(返回度数)mod(x,y) 返回x/y的余数sum( ) 向量元素求和3、其余函数可以⽤help elfun和help specfun命令获得。
astar(a星)算法(精)
A*算法原理简介A*(A-Star)算法是一种静态路网中求解最短路最有A star算法在静态路网中的应用效的方法。
公式表示为: f(n)=g(n)+h(n),其中f(n) 是节点n从初始点到目标点的估价函数,g(n) 是在状态空间中从初始节点到n节点的实际代价,h(n)是从n到目标节点最佳路径的估计代价。
保证找到最短路径(最优解的)条件,关键在于估价函数h(n)的选取:估价值h(n)<= n到目标节点的距离实际值,这种情况下,搜索的点数多,搜索范围大,效率低。
但能得到最优解。
如果估价值>实际值, 搜索的点数少,搜索范围小,效率高,但不能保证得到最优解。
估价值与实际值越接近估价函数取得就越好例如对于几何路网来说,可以取两节点间欧几理德距离(直线距离)做为估价值,即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny));这样估价函数f在g值一定的情况下,会或多或少的受估价值h的制约,节点距目标点近,h值小,f值相对就小,能保证最短路的搜索向终点的方向进行。
明显优于Dijstra算法的毫无无方向的向四周搜索。
conditions of heuristicOptimistic (must be less than or equal to the real cost)As close to the real cost as possible详细内容主要搜索过程伪代码如下:创建两个表,OPEN表保存所有已生成而未考察的节点,CLOSED表中记录已访问过的节点。
算起点的估价值;将起点放入OPEN表;while(OPEN!=NULL){从OPEN表中取估价值f最小的节点n;if(n节点==目标节点){break;}for(当前节点n 的每个子节点X){算X的估价值;if(X in OPEN){if( X的估价值小于OPEN表的估价值 ){把n设置为X的父亲;更新OPEN表中的估价值; //取最小路径的估价值}}if(X inCLOSE) {if( X的估价值小于CLOSE表的估价值 ){把n设置为X的父亲;更新CLOSE表中的估价值;把X节点放入OPEN //取最小路径的估价值}}if(X not inboth){把n设置为X的父亲;求X的估价值;并将X插入OPEN表中; //还没有排序}}//end for将n节点插入CLOSE表中;按照估价值将OPEN表中的节点排序; //实际上是比较OPEN表内节点f的大小,从最小路径的节点向下进行。
matlab a星算法
matlab a星算法
A星算法(A* Algorithm)是一种图搜索算法,常用于寻找最
短路径或最佳路径。
在MATLAB中,可以使用以下步骤实现A星算法:
1. 创建一个表示图的数据结构,可以是一个邻接矩阵、邻接表或其他自定义数据结构。
2. 定义一个启发式函数(heuristic function),用于估计每个
节点到目标节点的距离。
常用的启发式函数是欧几里得距离或曼哈顿距离。
3. 初始化两个集合:开放集合和关闭集合。
开放集合包含待检查的节点,关闭集合包含已经检查过的节点。
4. 初始化起始节点,并将其添加到开放集合中。
5. 当开放集合不为空时,重复以下步骤:
- 从开放集合中选择一个节点,使其成本最小。
- 将该节点从开放集合中移除,添加到关闭集合中。
- 检查该节点是否为目标节点。
如果是,则找到了最短路径。
- 对于每个相邻节点:
- 如果该节点在关闭集合中,跳过。
- 如果该节点不在开放集合中,将其添加到开放集合中,并
计算该节点的成本。
- 如果该节点已经在开放集合中,并且新的成本小于之前的
成本,更新该节点的成本。
6. 如果开放集合为空,则无法找到最短路径。
在MATLAB中,可以使用循环和条件语句来实现上述步骤。
具体实现代码可能因具体问题而异,但以上步骤提供了A星算法的一般框架。
a星算法的原理
a星算法的原理A\*算法是一种广泛应用于图形搜索和路径规划的启发式搜索算法。
它结合了Dijkstra算法的最短路径搜索和贪心算法的启发式估计,以高效地找到从起点到目标节点的最优路径。
A\*算法的原理如下:1. 定义开放列表(Open List)和封闭列表(Closed List):开始时,将起点放入开放列表,其余节点不在任何列表中。
2. 计算启发式估价函数(Heuristic Function):对于每个节点,使用启发式估价函数估计从该节点到目标节点的代价。
这个估价函数通常称为h(n),其中n是当前节点,h(n)是从节点n到目标节点的估计代价。
这个启发式估价函数必须满足两个条件:首先,h(n)不能大于节点n到目标节点的真实代价(也就是启发式函数要保持不低估);其次,h(n)要尽可能准确地估计节点n 到目标节点的代价,以便更好地引导搜索方向。
3. 计算综合代价函数(Total Cost Function):对于每个节点n,计算综合代价函数f(n) = g(n) + h(n),其中g(n)是从起点到节点n的实际代价(也就是起点到节点n的路径长度)。
4. 选择下一个扩展节点:从开放列表中选择f(n)值最小的节点n,将其移动到封闭列表中。
5. 扩展节点:对于选中的节点n,检查其相邻节点。
对于每个相邻节点,计算它们的综合代价函数f(n') = g(n') + h(n'),其中g(n')是从起点到节点n'的实际代价。
如果节点n'不在开放列表和封闭列表中,则将其添加到开放列表,并更新节点n'的父节点为节点n,并将g(n')和h(n')值记录下来。
如果节点n'已经在开放列表中,检查新的g(n')值是否更小,如果是,则更新其父节点为节点n,并更新g(n')的值。
如果节点n'已经在封闭列表中,也要检查新的g(n')值是否更小,如果是,则将其移回到开放列表中,并更新其父节点和g(n')的值。
A星算法代码及相关注释
{
return Open->next;
}
//------------------------------------------------------------------------
//输出最佳路径函数入口
q = head;
//定义头节点为q
while(q->next)
{
if(q->next == p){
q->next = p->next;
p->next = NULL;
//遍历以q指向(有附加头结点)的单向链表的一个循环
if(q->next == NULL) return;
// free(p);
//如果q的下一个节点为空,返回并且释放该节点
struct Node *previous; //previous是用来存放地址的
//保存其父节点
};
int open_N=0;
//记录Open列表中节点数目
int inital_s[3][3]={
2,8,3,1,0,4,7,6,5
};
//八数码初始状态
int final_s[3][3]={
1,2,3,8,0,4,7,6,5
return 1;
}
else return 0;
case 1: if((j_0-1)>-1){ //空格和上面的数字相互交换
temp = Successor->s[i_0][j_0];
Successor->s[i_0][j_0] = Successor->s[i_0][j_0-1];
A星算法详解范文
A星算法详解范文
一、A星算法简介
A星算法是一种在图上寻找最短路径的算法,它结合了启发式,动态
规划和图论中的最短路径算法。
A星算法合并了确定性和启发式的优点,
既去发探索有可能的解决方案,又利用估计信息避免许多无用。
A星算法
因为不依赖于模型,被广泛用于路径规划,机器人,计算机视觉等领域。
二、A星算法的估价函数
A星算法是一种非常重要的启发式算法,主要的思想是通过估计函数
f(n)来代表当前状态n,这个函数应该反映从当前状态到目标状态的距离。
在A星算法中,f(n)代表的是什么呢?
A星算法的估价函数f(n)是一种有启发性的策略,它是状态n的“总
消费成本”,其计算公式为:f(n)=g(n)+h(n),其中,g(n)表示从起点到
当前状态n的实际成本,h(n)表示从当前状态n到目标状态的估计成本,
又称为启发函数。
三、A星算法的原理
A星算法以每个节点为中心,按照代价估计f(n)从小到大查找,从起
点开始,每次新扩展出最小f值的节点,如果该节点是终点,则找到了最
短路径,否则继续进行。
A星算法的策略主要有两种:一种是开放表open。
A星算法详细讲解_通俗易懂初学者必看
A星算法详细讲解_通俗易懂初学者必看A*算法是一种常用于路径规划的算法。
它是一种启发式的算法,通过估计距离来选择最有可能的路径。
这篇文章将详细介绍A*算法的工作原理和基本步骤。
A*算法的核心思想是维护一个开放列表和一个闭合列表。
初始时,将起点加入开放列表。
然后,从开放列表中选择一个节点,称为当前节点。
接下来,对当前节点的相邻节点进行处理。
将其加入开放列表并计算其启发式评估值。
启发式评估值通常是通过两个部分来计算的:G值和H值。
G值表示从起点到当前节点的实际代价,H值表示从当前节点到目标节点的估计代价。
可以使用欧几里得距离或曼哈顿距离等方式来计算H值。
在处理相邻节点时,需要判断它们是否已经存在于开放列表或闭合列表中。
如果节点已经存在于开放列表中,那么要比较新的G值和旧的G值。
如果新的G值更小,那么更新节点的G值和父节点。
如果节点已经存在于闭合列表中,那么忽略它。
在处理完相邻节点后,将当前节点加入闭合列表,并选择下一个节点作为当前节点。
重复这个过程,直到找到目标节点或者开放列表为空。
如果找到目标节点,就可以通过回溯从目标节点找到起点,得到最终的路径。
A*算法的优点是在保证找到最短路径的情况下,能够快速找到一个近似最佳路径。
它的效率较高,并且可以应用于不同的问题领域,如图像处理、游戏设计和机器人路径规划等。
然而,A*算法也存在一些限制。
由于它是基于启发式评估值的,所以在遇到复杂的迷宫或者障碍物时,可能不能找到最优解。
此外,A*算法也对内存的消耗较大,因为需要维护两个列表。
为了提高A*算法的效率和准确性,可以采用一些优化措施。
例如,可以使用二叉堆等数据结构替代列表,以提高节点的速度。
此外,还可以使用更精确的启发式函数来改进路径的估计。
总结起来,A*算法是一种常用于路径规划的算法。
它通过维护一个启发式评估值的列表来选择最有可能的路径。
虽然它有一些限制,但通过一些优化措施可以提高效率和准确性。
初学者可以通过详细了解A*算法的工作原理和基本步骤,来理解并应用该算法。
A星算法matlab源码及详细注释
A星算法matlab源码及详细注释A星算法matlab源码及详细注释function astardemo%ASTARDEMO Demonstration of ASTAR algorithm%% Copyright Bob L. Sturm, Ph. D., Assistant Professor% Department of Architecture, Design and Media Technology% formerly Medialogy% Aalborg University i Ballerup% formerly Aalborg University Copenhagen% $Revision: 0.1 $ $Date: 2011 Jan. 15 18h24:24$n = 20; % field size n x n tiles 20*20的界面wallpercent = 0.45; % this percent of field is walls 45%的界面作为阻碍物(墙)% create the n x n FIELD with wallpercent walls containing movement costs,% a starting position STARTPOSIND, a goal position GOALPOSIND, the costs% A star will compute movement cost for each tile COSTCHART,% and a matrix in which to store the pointers FIELDPOINTERS [field, startposind, goalposind, costchart, fieldpointers] = ...initializeField(n,wallpercent); %初始化界面% initialize the OPEN and CLOSED sets and their costssetOpen = [startposind]; setOpenCosts = [0]; setOpenHeuristics = [Inf];setClosed = []; setClosedCosts = [];movementdirections = {'R','L','D','U'};% keep track of the number of iterations to exit gracefully ifno solution counterIterations = 1;% create figure so we can witness the magicaxishandle = createFigure(field,costchart,startposind,goalposind);% as long as we have not found the goal or run out of spaces to explorewhile ~max(ismember(setOpen,goalposind)) && ~isempty(setOpen) %ismember(A,B)返回与A同大小的矩阵,其中元素1表示A 中相应位置的元素在B中也出现,0则是没有出现% for the element in OPEN with the smallest cost[temp, ii] = min(setOpenCosts + setOpenHeuristics); %从OPEN表中选择花费最低的点temp,ii是其下标(也就是标号索引) % find costs and heuristic of moving to neighbor spaces to goal% in order 'R','L','D','U'[costs,heuristics,posinds] = findFValue(setOpen(ii),setOpenCosts(ii), ...field,goalposind,'euclidean'); %扩展temp的四个方向点,获得其坐标posinds,各个方向点的实际代价costs,启发代价heuristics % put node in CLOSED and record its costsetClosed = [setClosed; setOpen(ii)]; %将temp插入CLOSE表中setClosedCosts = [setClosedCosts; setOpenCosts(ii)]; %将temp 的花费计入ClosedCosts% update OPEN and their associated costs 更新OPEN表分为三种情况if (ii > 1 && ii < length(setOpen)) %temp在OPEN表的中间,删除tempsetOpen = [setOpen(1:ii-1); setOpen(ii+1:end)];setOpenCosts = [setOpenCosts(1:ii-1); setOpenCosts(ii+1:end)]; setOpenHeuristics =[setOpenHeuristics(1:ii-1); setOpenHeuristics(ii+1:end)];elseif (ii == 1)setOpen = setOpen(2:end); %temp是OPEN表的第一个元素,删除temp setOpenCosts = setOpenCosts(2:end);setOpenHeuristics = setOpenHeuristics(2:end);else %temp是OPEN表的最后一个元素,删除tempsetOpen = setOpen(1:end-1);setOpenCosts = setOpenCosts(1:end-1);setOpenHeuristics = setOpenHeuristics(1:end-1);end% for each of these neighbor spaces, assign costs and pointers;% and if some are in the CLOSED set and their costs are smaller,% update their costs and pointersfor jj=1:length(posinds) %对于扩展的四个方向的坐标% if cost infinite, then it's a wall, so ignoreif ~isinf(costs(jj)) %如果此点的实际代价不为Inf,也就是没有遇到墙% if node is not in OPEN or CLOSED then insert into costchart and% movement pointers, and put node in OPENif ~max([setClosed; setOpen] == posinds(jj)) %如果此点不在OPEN表和CLOSE表中fieldpointers(posinds(jj)) = movementdirections(jj); %将此点的方向存在对应的fieldpointers 中costchart(posinds(jj)) = costs(jj); %将实际代价值存入对应的costchart中setOpen = [setOpen; posinds(jj)]; %将此点加入OPEN 表中setOpenCosts = [setOpenCosts; costs(jj)]; %更新OPEN表实际代价setOpenHeuristics = [setOpenHeuristics; heuristics(jj)]; %更新OPEN表启发代价% else node has already been seen, so check to see if we have% found a better route to it.elseif max(setOpen == posinds(jj)) %如果此点在OPEN表中I = find(setOpen == posinds(jj)); %找到此点在OPEN表中的位置% update if we have a better routeif setOpenCosts(I) > costs(jj) %如果在OPEN表中的此点实际代价比现在所得的大costchart(setOpen(I)) = costs(jj); %将当前的代价存入costchart中,注意此点在costchart中的坐标与其自身坐标是一致的(setOpen(I)其实就是posinds(jj)),下同fieldpointers setOpenCosts(I) = costs(jj); %更新OPEN表中的此点代价,注意此点在setOpenCosts中的坐标与在setOpen中是一致的,下同setOpenHeuristics setOpenHeuristics(I) = heuristics(jj); %更新OPEN表中的此点启发代价(窃以为这个是没有变的)fieldpointers(setOpen(I)) = movementdirections(jj); %更新此点的方向end% else node has already been CLOSED, so check to see if we have% found a better route to it.else %如果此点在CLOSE表中,说明已经扩展过此点% find relevant node in CLOSEDI = find(setClosed == posinds(jj));% update if we have a better routeif setClosedCosts(I) > costs(jj) %如果在CLOSE表中的此点实际代价比现在所得的大(有一个问题,经过此点扩展的点还需要更新当前代价呢)costchart(setClosed(I)) = costs(jj); %将当前的代价存入costchart中setClosedCosts(I) = costs(jj); %更新CLOSE表中的此点代价fieldpointers(setClosed(I)) = movementdirections(jj); %更新此点的方向endendendendif isempty(setOpen) break; end %当OPEN表为空,代表可以经过的所有点已经查询完毕set(axishandle,'CData',[costchart costchart(:,end); costchart(end,:) costchart(end,end)]);% hack to make image look rightset(gca,'CLim',[0 1.1*max(costchart(find(costchart < Inf)))]); %CLim 将CData中的值与colormap对应起来: [cmin cmax] Color axis limits (不过不太明白为什么要*1.1)drawnow; %cmin is the value of the data mapped to the first color in the colormap. cmax is the value of the data mapped to the last color in the colormap endif max(ismember(setOpen,goalposind)) %当找到目标点时disp('Solution found!'); %disp:Display array,disp(X)直接将矩阵显示出来,不显示其名字,如果X为string,就直接输出文字X % now find the way back using FIELDPOINTERS, starting from goal positionp = findWayBack(goalposind,fieldpointers);% plot final pathplot(p(:,2)+0.5,p(:,1)+0.5,'Color',0.2*ones(3,1),'LineWidth',4); drawnow;elseif isempty(setOpen)disp('No Solution!');end% end of the main function %%%%%%%%%%%%%%%%%%%%%%%%%%%% function p = findWayBack(goalposind,fieldpointers)% This function will follow the pointers from the goal position to the% starting positionn = length(fieldpointers); % length of the fieldposind = goalposind;% convert linear index into [row column][py,px] = ind2sub([n,n],posind);% store initial positionp = [py px];% until we are at the starting positionwhile ~strcmp(fieldpointers{posind},'S') %当查询到的点不是'S'起点时switch fieldpointers{posind}case 'L' % move left 如果获得该点的来源点方向为左时px = px - 1;case 'R' % move rightpx = px + 1;case 'U' % move uppy = py - 1;case 'D' % move downpy = py + 1;endp = [p; py px];% convert [row column] to linear indexposind = sub2ind([n n],py,px);end% end of this function %%%%%%%%%%%%%%%%%%%%%%%%%%%% function [cost,heuristic,posinds] = findFValue(posind,costsofar,field, ...goalind,heuristicmethod)% This function finds the movement COST for each tile surrounding POSIND in% FIELD, returns their position indices POSINDS. They are ordered: right,% left, down, up.n = length(field); % length of the field% convert linear index into [row column][currentpos(1) currentpos(2)] = ind2sub([n n],posind); %获得当前点的行列坐标,注意currentpos(1)是列坐标,currentpos(2)是行坐标[goalpos(1) goalpos(2)] = ind2sub([n n],goalind); %获得目标点的行列坐标% places to store movement cost value and position cost = Inf*ones(4,1); heuristic = Inf*ones(4,1); pos = ones(4,2);% if we can look left, we move from the right 向左查询,那么就是从右边来newx = currentpos(2) - 1; newy = currentpos(1);if newx > 0 %如果没有到边界pos(1,:) = [newy newx]; %获得新的坐标switch lower(heuristicmethod)case 'euclidean' %欧几里得距离(不像啊,亲)heuristic(1) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy); %heuristic(1)为启发函数计算的距离代价case 'taxicab'heuristic(1) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy);endcost(1) = costsofar + field(newy,newx); %costsofar为之前花费的代价,field(newy,newx)为环境威胁代价,cost(1)为经过此方向点的真实代价end% if we can look right, we move from the left 向右查询newx = currentpos(2) + 1; newy = currentpos(1);if newx <= npos(2,:) = [newy newx];switch lower(heuristicmethod)case 'euclidean'heuristic(2) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy);case 'taxicab'heuristic(2) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy);endcost(2) = costsofar + field(newy,newx);end% if we can look up, we move from down 向上查询newx = currentpos(2); newy = currentpos(1)-1;if newy > 0pos(3,:) = [newy newx];switch lower(heuristicmethod)case 'euclidean'heuristic(3) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy);case 'taxicab'heuristic(3) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy);endcost(3) = costsofar + field(newy,newx);end% if we can look down, we move from up 向下查询newx = currentpos(2); newy = currentpos(1)+1;if newy <= npos(4,:) = [newy newx];switch lower(heuristicmethod)case 'euclidean'heuristic(4) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy);case 'taxicab'heuristic(4) = abs(goalpos(2)-newx) + abs(goalpos(1)-newy);endcost(4) = costsofar + field(newy,newx);end% return [row column] to linear indexposinds = sub2ind([n n],pos(:,1),pos(:,2)); %posinds为此点扩展的四个方向上的坐标% end of this function %%%%%%%%%%%%%%%%%%%%%%%%%%%%初始化界面function [field, startposind, goalposind, costchart, fieldpointers] = ... initializeField(n,wallpercent)% This function will create a field with movement costs and walls, a start% and goal position at random, a matrix in which the algorithm will store% f values, and a cell matrix in which it will store pointers% create the field and place walls with infinite cost 初始化界面和墙field = ones(n,n) + 10*rand(n,n);% field(ind2sub([n n],ceil(n^2.*rand(floor(n*n*wallpercent),1)))) = Inf; %floor(x)下取整,即舍去正小数至最近整数,ceil(x)上取整,即加入正小数至最近整数,Inf 代表正无穷field(ceil(n^2.*rand(floor(n*n*wallpercent),1))) = Inf; %ind2sub是用来将线性坐标(总体位置序号)转为多维坐标(包含行列的坐标)的,发现其实不用转为多维坐标就可以,矩阵field可以访问线性坐标% create random start position and goal position 随机选择行列作为起点与终点startposind = sub2ind([n,n],ceil(n.*rand),ceil(n.*rand)); %sub2ind用来将行列坐标转换为线性坐标,这里是必要的,因为如果把startposind设置成[x,y]的形式,访问field([x,y])的时候goalposind = sub2ind([n,n],ceil(n.*rand),ceil(n.*rand)); %它并不是访问x行y列元素,而是访问线性坐标为x和y的两个元素% force movement cost at start and goal positions to not be walls 将初始坐标设置为0,以免成为墙field(startposind) = 0; field(goalposind) = 0;% put not a numbers (NaN) in cost chart so A* knows where to lookcostchart = NaN*ones(n,n); %costchart用来存储各个点的实际代价,NaN代表不是数据(不明确的操作)% set the cost at the starting position to be 0costchart(startposind) = 0; %起点的实际代价% make fieldpointers as a cell array 生成n*n的元胞fieldpointers = cell(n,n); %fieldpointers用来存储各个点的来源方向% set the start pointer to be "S" for start, "G" for goal 起点设置为"S",终点设置为"G"fieldpointers{startposind} = 'S'; fieldpointers{goalposind} = 'G'; % everywhere there is a wall, put a 0 so it is not considered墙设置为0 fieldpointers(field == Inf) = {0}; %很好的方式,field == Inf 返回墙的位置,fieldpointers(field == Inf)设置相应的位置% end of this function%%%%%%%%%%%%%%%%%%%%function axishandle = createFigure(field,costchart,startposind,goalposind)% This function creates a pretty figure% If there is no figure open, then create oneif isempty(gcbf) %gcbf是当前返回图像的句柄f1 = figure('Position',[450 150 500 500],'Units','Normalized', ...'MenuBar','none'); %这里的Position属性值为一个四元数组rect = [left, bottom, width, height],第一、二个参数表示窗口位置,都是从屏幕的左下角计算的%normalized —Units map the lower-left corner of the figure window to (0,0) and the upper-right corner to (1.0,1.0).Caxes2 = axes('position', [0.01 0.01 0.98 0.98],'FontSize',12, ... 'FontName','Helvetica'); %position根据前面figure设置的单位,in normalized units where (0,0) is the lower-left corner and (1.0,1.0) is the upper-rightelse% get the current figure, and clear it 获得当前图像并清空gcf; cla;endn = length(field);% plot field where walls are black, and everything else is white 0是黑色field(field < Inf) = 0; %注意,虽然修改了field,但是这里的field属于局部变量,根本没有影响主函数中的fieldpcolor([1:n+1],[1:n+1],[field field(:,end); field(end,:) field(end,end)]); %多了一行一列% set the colormap for the ploting the cost and looking really nicecmap = flipud(colormap('jet')); %flipud用于反转矩阵colormap为产生jet类型的颜色表jet ranges from blue to red % make first entry be white, and last be blackcmap(1,:) = zeros(3,1); cmap(end,:) = ones(3,1); %改变颜色表将尾色变为(0,0,0)是黑色,起色变为(1,1,1)是白色% apply the colormap, but make red be closer to goal 红色是更接近目标的颜色colormap(flipud(cmap));% keep the plot so we can plot over it%********不用反转就可以*********%%cmap = colormap('jet');%cmap(1,:) = ones(3,1); cmap(end,:) = zeros(3,1);%colormap(cmap);%*******************************%hold on;% now plot the f values for all tiles evaluatedaxishandle = pcolor([1:n+1],[1:n+1],[costchart costchart(:,end); costchart(end,:) costchart(end,end)]);% plot goal as a yellow square, and start as a green circle[goalposy,goalposx] = ind2sub([n,n],goalposind); %注意返回的列和行的位置[startposy,startposx] = ind2sub([n,n],startposind);plot(goalposx+0.5,goalposy+0.5,'ys','MarkerSize',10,'Line Width',6); %加0.5是为了把坐标移到方块中央,'ys'中y表示yellow,s 表示Square(方形)plot(startposx+0.5,startposy+0.5,'go','MarkerSize',10,'Lin eWidth',6); %'go'中g表示green,o表示Circle(圆形)% add a button so that can re-do the demonstrationuicontrol('Style','pushbutton','String','RE-DO& #39;, 'FontSize',12, ...'Position', [1 1 60 40], 'Callback','astardemo'); % end of this function。
python a星二进制算法
python a星二进制算法A 算法对二进制地图的应用A 算法是一种用于寻路和规划的知名算法。
它融合了深度优先搜索的探索性和广度优先搜索的效率,在各种寻路问题中表现出色。
当处理二进制地图时,即由 0(障碍物)和 1(可通行区域)组成的网格,A 算法仍然是一种有效的解决方案。
地图表示在将 A 算法应用于二进制地图之前,需要将地图表示为一个节点和边的图。
每个节点代表地图上的一个单元格,而边则表示相邻单元格之间的连接。
对于二进制地图,节点的权重可以设置为 1(可通行区域)或 0(障碍物)。
启发函数启发函数在 A 算法中至关重要,它估计当前节点到目标节点的距离。
对于二进制地图,常用的启发函数是曼哈顿距离或对角线距离。
曼哈顿距离计算当前节点和目标节点在网格上的水平和垂直距离之和,而对角线距离考虑了通过对角线移动的可能性。
搜索过程A 算法使用优先级队列来指导搜索过程。
该队列按节点的 f 值排序,其中 f 值由启发函数估计的到目标节点的距离和从起始节点到当前节点的路径成本之和组成。
搜索从起始节点开始,将其添加到队列中。
算法从队列中移除f 值最低的节点,将其扩展到所有相邻的未访问节点。
每个扩展的节点都会添加到队列中,并根据其 f 值进行排序。
此过程持续进行,直到目标节点被扩展或队列为空。
路径追踪一旦找到目标节点,就可以通过回溯从起始节点到目标节点的父节点关系来提取最优路径。
优化为了提高 A 算法的效率,可以应用以下优化技术:跳过闭列表优化:避免将已经扩展的节点添加到队列中。
跳过对角线移动优化:仅考虑水平和垂直移动,以减少计算量。
改进启发函数:使用更准确的启发函数,如加权对角线距离或分层 A。
实现A 算法可以通过编程语言(如 Python)中的库或算法实现。
以下是一个 Python 中实现 A 算法处理二进制地图的示例:```pythonimport heapqclass Node:def __init__(self, position, parent=None):self.position = positionself.parent = parentself.g_score = 0self.h_score = 0self.f_score = 0def __lt__(self, other):return self.f_score < other.f_score class AStar:def __init__(self, map, start, goal): self.map = mapself.start = startself.goal = goalself.open_list = [Node(start)]self.closed_list = set()def search(self):while self.open_list:current_node = heapq.heappop(self.open_list) if current_node.position == self.goal:returnself.reconstruct_path(current_node)self.closed_list.add(current_node.position)for neighbor inself.get_neighbors(current_node):if neighbor.position inself.closed_list:continueneighbor.g_score = current_node.g_score + 1neighbor.h_score =self.heuristic(neighbor.position, self.goal)neighbor.f_score = neighbor.g_score + neighbor.h_scoreif neighbor not in self.open_list:heapq.heappush(self.open_list, neighbor)return Nonedef reconstruct_path(self, current_node):path = []while current_node:path.append(current_node.position)current_node = current_node.parentreturn path[::-1]def get_neighbors(self, node):x, y = node.positionneighbors = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]return [Node(pos) for pos in neighbors if self.is_valid(pos)]def is_valid(self, position):x, y = positionreturn 0 <= x < len(self.map) and 0 <= y <len(self.map[0]) and self.map[x][y] == 1def heuristic(self, position, goal):x1, y1 = positionx2, y2 = goalreturn abs(x2 - x1) + abs(y2 - y1)```使用此代码,您可以将 A 算法应用于二进制地图并找到从起始点到目标点的最优路径。
人工智能(A星算法)
A*算法实验报告实验目的1.熟悉和掌握启发式搜索的定义、估价函数和算法过程2. 学会利用A*算法求解N数码难题3. 理解求解流程和搜索顺序实验原理A*算法是一种有序搜索算法,其特点在于对估价函数的定义上。
对于一般的有序搜索,总是选择f值最小的节点作为扩展节点。
因此,f是根据需要找到一条最小代价路径的观点来估算节点的,所以,可考虑每个节点n的估价函数值为两个分量:从起始节点到节点n的代价以及从节点n到达目标节点的代价。
实验条件1.Window NT/xp/7及以上的操作系统2.内存在512M以上3.CPU在奔腾II以上实验内容1.分别以8数码和15数码为例实际求解A*算法2.画出A*算法求解框图3.分析估价函数对搜索算法的影响4.分析A*算法的特点实验分析1. A*算法基本步骤1)生成一个只包含开始节点n0的搜索图G,把n放在一个叫OPEN的列表上。
2)生成一个列表CLOSED,它的初始值为空。
3)如果OPEN表为空,则失败退出。
4)选择OPEN上的第一个节点,把它从OPEN中移入CLPSED,称该节点为n。
5)如果n是目标节点,顺着G中,从n到n的指针找到一条路径,获得解决方案,成功退出(该指针定义了一个搜索树,在第7步建立)。
6)扩展节点n ,生成其后继结点集M ,在G 中,n 的祖先不能在M 中。
在G 中安置M 的成员,使他们成为n 的后继。
7)从M 的每一个不在G 中的成员建立一个指向n 的指针(例如,既不在OPEN 中,也不在CLOSED 中)。
把M 1的这些成员加到OPEN 中。
对M 的每一个已在OPEN 中或CLOSED 中的成员m ,如果到目前为止找到的到达m 的最好路径通过n ,就把它的指针指向n 。
对已在CLOSED 中的M 的每一个成员,重定向它在G 中的每一个后继,以使它们顺着到目前为止发现的最好路径指向它们的祖先。
8)按递增f *值,重排OPEN (相同最小f *值可根据搜索树中的最深节点来解决)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
else %如果此点在CLOSE表中,说明已经扩展过此点
% find relevant node in CLOSED
I = find(setClosed == posinds(jj));
% a starting position STARTPOSIND, a goal position GOALPOSIND, the costs
% A star will compute movement cost for each tile COSTCHART,
% and a matrix in which to store the pointers FIELDPOINTERS
% update if we have a better route
if setClosedCosts(I) > costs(jj) %如果在CLOSE表中的此点实际代价比现在所得的大(有一个问题,经过此点扩展的点还需要更新当前代价呢!!!)
costchart(setClosed(I)) = costs(jj); %将当前的代价存入costchart中
costchart(posinds(jj)) = costs(jj); %将实际代价值存入对应的costchart中
setOpen = [setOpen; posinds(jj)]; %将此点加入OPEN表中
setOpenCosts = [setOpenCosts; costs(jj)]; %更新OPEN表实际代价
setOpenCosts(I) = costs(jj); %更新OPEN表中的此点代价,注意此点在setOpenCosts中的坐标与在setOpen中是一致的,下同setOpenHeuristics
setOpenHeuristics(I) = heuristics(jj); %更新OPEN表中的此点启发代价(窃以为这个是没有变的)
% keep track of the number of iterations to exit gracefully if no solution
counterIterations = 1;
% create figure so we can witness the magic
axishandle = createFigure(field,costchart,startposind,goalposind);
setOpen = setOpen(1:end-1);
setOpenCosts = setOpenCosts(1:end-1);
setOpenHeuristics = setOpenHeuristics(1:end-1);
end
% for each of these neighbor spaces, assign costs and pointers;
[field, startposind, goalposind, costchart, fieldpointers] = ...
initializeField(n,wallpercent); %初始化界面
% initialize the OPEN and CLOSED sets and their costs
% as long as we have not found the goal or run out of spaces to explore
while ~max(ismember(setOpen,goalposind)) && ~isempty(setOpen) %ismember(A,B)返回与A同大小的矩阵,其中元素1表示A中相应位置的元素在B中也出现,0则是没有出现
setOpen = setOpen(2:end); %temp是OPEN表的第一个元素,删除temp
setOpenCosts = setOpenCosts(2:end);
setOpenHeuristics = setOpenHeuristics(2:end);
else %temp是OPEN表的最后一个元素,删除temp
end
end
end
if isempty(setOpen) break; end %当OPEN表为空,代表可以经过的所有点已经查询完毕
setOpen = [startposind]; setOpenCosts = [0]; setOpenHeuristics = [Inf];
setClosed = []; setClosedCosts = [];
movementdirections = {'R','L','D','U'};
% and if some are in the CLOSED set and their costs are smaller,
% update their costs and pointers
for jj=1:length(posinds) %对于扩展的四个方向的坐标
% put node in CLOSED and record its cost
setClosed = [setClosed; setOpen(ii)]; %将temp插入CLOSE表中
setClosedCosts = [setClosedCosts; setOpenCosts(ii)]; %将temp的花费计入ClosedCosts
ห้องสมุดไป่ตู้ setOpenHeuristics = [setOpenHeuristics; heuristics(jj)]; %更新OPEN表启发代价
% else node has already been seen, so check to see if we have
% found a better route to it.
setClosedCosts(I) = costs(jj); %更新CLOSE表中的此点代价
fieldpointers(setClosed(I)) = movementdirections(jj); %更新此点的方向
end
n = 20; % field size n x n tiles 20*20的界面
wallpercent = 0.45; % this percent of field is walls 45%的界面作为阻碍物(墙)
% create the n x n FIELD with wallpercent walls containing movement costs,
% if cost infinite, then it's a wall, so ignore
if ~isinf(costs(jj)) %如果此点的实际代价不为Inf,也就是没有遇到墙
% if node is not in OPEN or CLOSED then insert into costchart and
if setOpenCosts(I) > costs(jj) %如果在OPEN表中的此点实际代价比现在所得的大
costchart(setOpen(I)) = costs(jj); %将当前的代价存入costchart中,注意此点在costchart中的坐标与其自身坐标是一致的(setOpen(I)其实就是posinds(jj)),下同fieldpointers
% for the element in OPEN with the smallest cost
[temp, ii] = min(setOpenCosts + setOpenHeuristics); %从OPEN表中选择花费最低的点temp,ii是其下标(也就是标号索引)
% find costs and heuristic of moving to neighbor spaces to goal
setOpenCosts = [setOpenCosts(1:ii-1); setOpenCosts(ii+1:end)];
setOpenHeuristics = [setOpenHeuristics(1:ii-1); setOpenHeuristics(ii+1:end)];
elseif (ii == 1)
% update OPEN and their associated costs 更新OPEN表 分为三种情况
if (ii > 1 && ii < length(setOpen)) %temp在OPEN表的中间,删除temp
setOpen = [setOpen(1:ii-1); setOpen(ii+1:end)];
function astardemo
%ASTARDEMO Demonstration of ASTAR algorithm
%
% Copyright Bob L. Sturm, Ph. D., Assistant Professor
% Department of Architecture, Design and Media Technology
% movement pointers, and put node in OPEN
if ~max([setClosed; setOpen] == posinds(jj)) %如果此点不在OPEN表和CLOSE表中
fieldpointers(posinds(jj)) = movementdirections(jj); %将此点的方向存在对应的fieldpointers中
elseif max(setOpen == posinds(jj)) %如果此点在OPEN表中