A 算法中单队列实现原理与“关闭列表”的隐式处理-Python教程-PHP中文网

A 算法中单队列实现原理与“关闭列表”的隐式处理

心靈之曲

发布： 2025-11-22 14:57:01

原创

876人浏览过

A 算法中单队列实现原理与“关闭列表”的隐式处理

本教程深入探讨a*寻路算法的一种常见实现变体，该变体仅使用一个优先队列（open列表）而非显式地维护一个“关闭列表”（closed集合）。我们将通过分析python代码，解释如何利用节点分数（g_score和f_score）的初始化和动态更新来隐式管理已访问节点的状态，从而实现与传统双列表a*算法相同的寻路效果。

A* 算法概述与标准结构

A 算法是一种高效的图搜索算法，广泛应用于路径规划和寻路问题。它通过结合启发式信息来优化Dijkstra算法，以更快的速度找到从起点到目标点的最短路径。A 算法的核心在于其评估函数 f(n) = g(n) + h(n)：

g(n)：从起点到当前节点 n 的实际代价。
h(n)：从当前节点 n 到目标点的估计启发式代价。

在经典的A*算法实现中，通常会维护两个关键的数据结构：

OPEN 列表 (优先队列)：存储所有待探索的节点。这些节点根据其 f(n) 值进行排序，f(n) 值最小的节点具有更高的优先级，优先被取出进行扩展。
CLOSED 集合 (哈希集合/字典)：存储所有已经完全探索过的节点。一旦一个节点被移入 CLOSED 集合，就意味着我们已经找到了从起点到该节点的最佳路径。其主要目的是避免重复处理已经以最优路径访问过的节点，从而提高算法效率并防止搜索陷入循环。

标准A*算法的伪代码通常会明确地包含对这两个列表的操作，例如：

从 OPEN 列表中取出 f(n) 最小的节点。
将该节点添加到 CLOSED 集合。
检查其所有邻居节点，并根据路径代价决定是更新其信息、将其添加到 OPEN 列表，还是将其从 CLOSED 集合移回 OPEN 列表（如果找到了更优路径）。

单队列 A* 算法实现分析

下面我们将分析一个Python实现的A*算法，它仅使用一个优先队列，但依然能正确地找到最优路径。

from pyamaze import maze,agent,textLabel
from queue import PriorityQueue

# 启发式函数：曼哈顿距离
def h(cell1,cell2):
    x1,y1=cell1
    x2,y2=cell2
    return abs(x1-x2) + abs(y1-y2)

def aStar(m):
    start=(m.rows,m.cols)
    # g_score: 从起点到当前节点的实际代价，初始全部为无穷大
    g_score={cell:float('inf') for cell in m.grid}
    g_score[start]=0
    # f_score: g_score + h_score，用于优先队列排序，初始全部为无穷大
    f_score={cell:float('inf') for cell in m.grid}
    f_score[start]=h(start,(1,1)) # 目标点假定为(1,1)

    open=PriorityQueue()
    # 优先队列存储 (f_score, h_score, cell)，h_score作为 tie-breaker
    open.put((h(start,(1,1)),h(start,(1,1)),start))
    aPath={} # 用于重建路径的父节点映射

    while not open.empty():
        currCell=open.get()[2] # 获取当前f_score最低的节点
        if currCell==(1,1): # 到达目标
            break

        # 探索邻居
        for d in 'ESNW': # 东、南、西、北方向
            if m.maze_map[currCell][d]==True: # 如果存在通路
                if d=='E':
                    childCell=(currCell[0],currCell[1]+1)
                if d=='W':
                    childCell=(currCell[0],currCell[1]-1)
                if d=='N':
                    childCell=(currCell[0]-1,currCell[1])
                if d=='S':
                    childCell=(currCell[0]+1,currCell[1])

                # 计算通过当前节点到达邻居的临时g_score和f_score
                temp_g_score=g_score[currCell]+1 # 假设每一步代价为1
                temp_f_score=temp_g_score+h(childCell,(1,1))

                # 如果通过当前节点到达邻居的路径更优
                if temp_f_score < f_score[childCell]:
                    g_score[childCell]= temp_g_score
                    f_score[childCell]= temp_f_score
                    open.put((temp_f_score,h(childCell,(1,1)),childCell)) # 将更新后的节点加入队列
                    aPath[childCell]=currCell # 记录父节点

    # 路径重建
    fwdPath={}
    cell=(1,1)
    while cell!=start:
        fwdPath[aPath[cell]]=cell
        cell=aPath[cell]
    return fwdPath

if __name__=='__main__':
    m=maze(5,5)
    m.CreateMaze()
    path=aStar(m)

    a=agent(m,footprints=True)
    m.tracePath({a:path})
    l=textLabel(m,'A Star Path Length',len(path)+1)
    m.run()

登录后复制

“关闭列表”的隐式处理机制

上述Python代码并没有显式地使用一个 CLOSED 集合。那么，它是如何避免重复处理节点和确保找到最优路径的呢？其秘密在于 g_score 和 f_score 字典的巧妙运用：

LobeHub

LobeChat brings you the best user experience of ChatGPT, OLLaMA, Gemini, Claude

201

查看详情

初始化为无穷大：
- 在算法开始时，所有迷宫单元格的 g_score 和 f_score 都被初始化为 float('inf')。这是一种非常有效的“未访问”或“未处理”标记。任何实际的路径代价都将是一个有限值，因此任何被探索到的节点都会更新其分数。
- 这与传统A*中检查节点是否在 OPEN 或 CLOSED 集合中的效果类似：如果一个节点的 f_score 仍为无穷大，它就相当于“未被发现”或“未被考虑”。
条件更新与优先队列的特性：
- 代码中的核心逻辑是 if temp_f_score < f_score[childCell]。当算法探索到 currCell 的邻居 childCell 时，它会计算通过 currCell 到达 childCell 的新路径代价 temp_f_score。
- 只有当这个新路径的 f_score 小于 childCell 当前已知的 f_score 时，childCell 的 g_score 和 f_score 才会被更新，并且 childCell 会被重新放入优先队列。
- 等效于“重新打开”节点：如果一个节点已经被访问过（其 f_score 是一个有限值），但现在发现了一条通过 currCell 到达它的更优路径，那么它的 f_score 会被更新，并再次进入优先队列。这实际上起到了“重新打开”（re-open）节点的效果，即允许算法重新考虑这个节点，因为它可能通过一条更好的路径被访问。
- 优先队列的自适应性：由于 PriorityQueue 总是取出 f_score 最小的节点，即使同一个 childCell 因为不同的路径被多次放入队列，也只会优先处理具有最优 f_score 的那个条目。当一个节点被从队列中取出时，如果其 f_score 已经不是 f_score 字典中记录的当前最优值（这意味着在此期间有其他路径更新了该节点），那么这个旧的、劣质的队列条目实际上会被忽略，因为后续的路径更新条件 temp_f_score < f_score[childCell] 将不会满足。