Bidirectional A*

双向A*。

A* : A*(A star)

从起点和终点同时开始A*搜索,直至交汇。

从起点端:代价值Fs=起点到当前点的距离Gs+当前点到终点的启发式代价值Hs

从终点端:代价值Fe=终点到当前点的距离Ge+当前点到起点的启发式代价值He

最终整个路径的代价值=Gs+Ge

图示

特点 

比A*更快

其他路径规划算法: 路径规划算法总览

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
双向A*算法是一种启发式搜索算法,它在搜索过程中从起点和终点同时进行搜索,直到两个搜索路径相遇。以下是一个简单的双向A*算法实现: 假设我们有一个有向图G,节点的表示方式为node,边的表示方式为edge。每个节点都有一个估价函数h(n),代表从该节点到终点的估计距离。我们需要维护两个数据结构:openSet1和openSet2,分别代表从起点和终点开始的搜索队列。 1. 初始化openSet1和openSet2,将起点和终点分别加入两个队列中。 2. 从openSet1和openSet2中各取出一个节点n1和n2,分别进行扩展。 对于节点n1,遍历它的子节点n1_child,计算从起点到n1_child的实际距离g(n1_child)和估计距离f(n1_child) = g(n1_child) + h(n1_child)。如果n1_child已经在openSet2中,则说明两个搜索路径相遇,搜索结束。如果n1_child不在openSet1中,将n1_child加入openSet1,并记录它的父节点为n1。 对于节点n2,遍历它的父节点n2_parent,计算从终点到n2_parent的实际距离g(n2_parent)和估计距离f(n2_parent) = g(n2_parent) + h(n2_parent)。如果n2_parent已经在openSet1中,则说明两个搜索路径相遇,搜索结束。如果n2_parent不在openSet2中,将n2_parent加入openSet2,并记录它的子节点为n2。 3. 重复步骤2,直到两个搜索路径相遇或者任意一个openSet为空。 下面是一个Python实现代码: ``` import heapq def bidirectional_astar(start, goal, neighbors, heuristic): # Initialize open sets open_set1 = [(heuristic(start, goal), start)] open_set2 = [(heuristic(goal, start), goal)] closed_set1 = {} closed_set2 = {} came_from1 = {} came_from2 = {} while open_set1 and open_set2: # Take the node with the lowest f-score from both open sets f1, current1 = heapq.heappop(open_set1) f2, current2 = heapq.heappop(open_set2) if current1 in closed_set2 or current2 in closed_set1: # Paths have met, return the final path path = reconstruct_path(current1, came_from1, came_from2) return path # Add the current nodes to their respective closed sets closed_set1[current1] = f1 closed_set2[current2] = f2 for neighbor in neighbors(current1): # Calculate the g-score and f-score for the neighbor g = came_from1[current1][0] + distance(current1, neighbor) f = g + heuristic(neighbor, goal) if neighbor in closed_set1: # Ignore the neighbor if it has already been evaluated continue if (f, neighbor) in open_set1: # Update the neighbor's g-score and parent if a better path is found index = open_set1.index((f, neighbor)) if g < came_from1[neighbor][0]: came_from1[neighbor] = (g, current1) open_set1[index] = (f, neighbor) heapq.heapify(open_set1) else: # Add the neighbor to the open set and record its parent came_from1[neighbor] = (g, current1) heapq.heappush(open_set1, (f, neighbor)) for neighbor in neighbors(current2): # Calculate the g-score and f-score for the neighbor g = came_from2[current2][0] + distance(current2, neighbor) f = g + heuristic(goal, neighbor) if neighbor in closed_set2: # Ignore the neighbor if it has already been evaluated continue if (f, neighbor) in open_set2: # Update the neighbor's g-score and parent if a better path is found index = open_set2.index((f, neighbor)) if g < came_from2[neighbor][0]: came_from2[neighbor] = (g, current2) open_set2[index] = (f, neighbor) heapq.heapify(open_set2) else: # Add the neighbor to the open set and record its parent came_from2[neighbor] = (g, current2) heapq.heappush(open_set2, (f, neighbor)) # No path was found return None def reconstruct_path(current, came_from1, came_from2): # Reconstruct the final path by following the parent pointers path = [current] while current in came_from1: current = came_from1[current][1] path.append(current) path.reverse() current = path[-1] while current in came_from2: current = came_from2[current][1] path.append(current) return path ``` 该算法的时间复杂度为O(b^(d/2)),其中b是分支因子,d是起点和终点之间的距离。双向A*算法比传统A*算法更快,因为它可以同时从起点和终点开始搜索,在搜索空间中找到相遇点,从而减少了搜索的时间和空间。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值