写出A*算法

好的，以下是一个基于Python的A*算法实现：

import heapq

def astar(start, goal, h_func, neighbors_func):
    """
    A*算法求解单源最短路径问题
    :param start: 起点
    :param goal: 终点
    :param h_func: 启发函数，用于计算节点到终点的估价值
    :param neighbors_func: 邻接函数，用于计算一个节点的邻居节点列表
    :return: 最短路径和路径长度，路径不存在则返回None
    """
    closed_set = set()  # 已经访问过的节点集合
    open_heap = [(0, start)]  # 待访问的节点堆，存储 (f, node) 的元组，其中 f 为节点的估价值+到起点的路径长度，node 为节点本身
    came_from = {}  # 存储每个节点的前驱节点
    g_score = {start: 0}  # 存储每个节点到起点的路径长度

    while open_heap:
        _, current = heapq.heappop(open_heap)

        if current == goal:
            path = [current]
            while current in came_from:
                current = came_from[current]
                path.append(current)
            path.reverse()
            return path, g_score[goal]

        closed_set.add(current)
        for neighbor in neighbors_func(current):
            if neighbor in closed_set:
                continue

            tentative_g_score = g_score[current] + 1
            if neighbor not in open_heap or tentative_g_score < g_score[neighbor]:
                came_from[neighbor] = current
                g_score[neighbor] = tentative_g_score
                f_score = tentative_g_score + h_func(neighbor, goal)
                heapq.heappush(open_heap, (f_score, neighbor))

    return None  # 路径不存在

该函数接受起点、终点、启发函数和邻接函数作为输入，返回最短路径和路径长度。启发函数用于计算估价值，这里采用的是曼哈顿距离；邻接函数用于计算相邻节点列表，这里采用的是四联通。

在算法的实现中，我们使用了一个已经访问过的节点集合和一个待访问的节点堆来记录已经访问过的节点和待访问的节点，以及每个节点的前驱节点和到起点的路径长度。我们不断从待访问的节点堆中选择估价值最小的节点进行扩展，直到找到终点或者发现路径不存在为止。

在每次扩展节点的过程中，我们检查节点的邻居节点，如果节点还没有被访问过，或者当前节点到起点的路径长度比之前更短，就更新节点的前驱节点和到起点的路径长度，并将节点加入待访问的节点堆中。如果邻居节点已经被访问过，就跳过不做处理。

最终，如果找到了终点，我们可以从终点开始，依次通过每个节点的前驱节点，重建出最短路径。如果没有找到终点，则返回None表示路径不存在。