A星搜索 (A* Search)

致敬:P. E.Hart, N. J. Nilsson, and B. Raphael.Aformal basis for the heuristic determination of minimum cost paths in graphs.IEEE Trans. Syst. Sci. and Cybernetics, SSC-4(2):100-107, 1968

 

A*搜寻算法,俗称A星算法,作为启发式搜索算法中的一种,这是一种在图形平面上,有多个节点的路径,求出最低通过成本的算法。

A*算法最为核心的部分,就在于它的一个估值函数的设计上:
       f(n)=g(n)+h(n)

   其中f(n)是每个可能试探点的估值,它有两部分组成:
   
一部分,为g(n),它表示从起始搜索点到当前点的代价(通常用某结点在搜索树中的深度来表示)。
   
另一部分,即h(n),它表示启发式搜索中最为重要的一部分,即当前结点到目标结点的估值,h(n)设计的好坏,直接影响着具有此种启发式函数的启发式算法的是否能称为A*算法。

  一种具有f(n)=g(n)+h(n)策略的启发式算法能成为A*算法的充分条件是:
      1
、搜索树上存在着从起始点到终了点的最优路径。
      2
、问题域是有限的。
      3
、所有结点的子结点的搜索代价值>0
      4
h(n)=<h*(n)h*(n)为实际问题的代价值)。

   当此四个条件都满足时,一个具有f(n)=g(n)+h(n)策略的启发式算法能成为A*算法,并一定能找到最优解。

以上文字引用CSDN用户v_July_v: http://blog.csdn.net/v_JULY_v/article/details/6093380

以下实例来自Uppsala University课程Artificial Intelligence 考试:

PointsSABCG
S 23  
A2 75 
B37 6 
C056 11
G   11 




上表表示从initial node S 出发到达final node G点与点之间的距离(可以看成g(n)),且给出如下启发式函数(可以看成h(n)):

PointsABC
G1595

求从点S出发到达点G搜索过程中各个点的扩展顺序,最短路径方案以及最短路径的长度?


 

 

 

 

ExploredExpandFrontier
NullSAs=2+15=17,Bs=3+9=12
SBAs=17,CB=3+6+5=14
SBCAs=17,Bc=3+6+6+9=24, GC=3+6+11+0=20
SBCABA=2+7+9=18,CA=2+5+5=12, Gc=20
SBCACBA=18,AC=2+5+5+15=27, GC=2+5+11+0=18
SBCACG 



 

点的扩展顺序如下:SBCACG

最短路径方案由G点反推至S可得:G-C-A-S,则最优搜索路径为S->A->C->G

最短路径长度为GC=18

好的,我来回答你的问题。 首先,A*算法是一种启发式搜索算法,用于在图形地图中寻找最短路径。在寻路问题中,每个节点都有一个估计成本值,这个成本可以从起点到该节点的路径长度和该节点到终点的估计距离之和来计算。A*算法通过估计成本值来选择下一个要探索的节点,并尽可能快地到达终点。 下面是使用Python 3实现A*算法求解5x5迷宫寻路的代码: ```python import heapq # 用于计算曼哈顿距离 def manhattan_distance(node, target): return abs(node[0] - target[0]) + abs(node[1] - target[1]) # 用于生成迷宫 def create_maze(): maze = [['.', '.', '.', '.', '#'], ['.', '#', '.', '#', '.'], ['.', '.', '.', '#', '.'], ['#', '.', '#', '.', '.'], ['.', '.', '.', '.', '.']] return maze # 用于检查节点是否在迷宫内,并且是不是障碍物 def is_valid_node(node, maze): if node[0] < 0 or node[0] >= len(maze) or node[1] < 0 or node[1] >= len(maze[0]): return False if maze[node[0]][node[1]] == '#': return False return True # 用于获取邻居节点 def get_neighbors(node, maze): neighbors = [] for d in [[0, 1], [0, -1], [1, 0], [-1, 0]]: neighbor = (node[0] + d[0], node[1] + d[1]) if is_valid_node(neighbor, maze): neighbors.append(neighbor) return neighbors # A*寻路 def astar_search(maze, start, target): heap = [(0, start)] came_from = {} cost_so_far = {start: 0} while heap: current = heapq.heappop(heap)[1] if current == target: break for next_node in get_neighbors(current, maze): new_cost = cost_so_far[current] + 1 if next_node not in cost_so_far or new_cost < cost_so_far[next_node]: cost_so_far[next_node] = new_cost priority = new_cost + manhattan_distance(next_node, target) heapq.heappush(heap, (priority, next_node)) came_from[next_node] = current # 没有找到路径 if target not in came_from: return None # 重构路径 path = [target] while path[-1] != start: path.append(came_from[path[-1]]) path.reverse() return path # 测试 maze = create_maze() start = (0, 0) target = (4, 4) path = astar_search(maze, start, target) if path: for node in path: maze[node[0]][node[1]] = '*' for row in maze: print(row) else: print('没有找到路径') ``` 这个程序首先定义了一个maze变量用于存储迷宫的状态。然后,它定义了一个manhattan_distance函数用于计算两个节点之间的曼哈顿距离,该距离在A*算法中用于估计距离。接下来,它定义了一些函数,包括create_maze(用于生成迷宫),is_valid_node(用于检查节点是否合法),get_neighbors(用于获取相邻节点)和astar_search(用于运行A*算法)。 在astar_search函数中,程序使用了一个优先队列来管理未探索的节点。对于每个探索的节点,程序计算每个相邻节点的成本,并根据这些成本来选择下一个要探索的节点。如果程序找到目标节点,则它会返回一条路径。否则,它将返回None。 最后,程序使用了一个maze变量和一个path变量来在控制台上显示迷宫和路径。 希望这个程序可以帮助你理解如何使用Python实现A*算法来解决迷宫寻路问题。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值