AO*算法（A-Optimal）是一种启发式搜索算法，可以用于解决优化问题。它在人工智能中的应用非常广泛，如路径规划、机器学习等。

下面是一个简单的示例，展示了AO*算法在路径规划中的应用。

# 定义节点类
class Node:
    def __init__(self, position, parent=None, cost=0, heuristic=0):
        self.position = position
        self.parent = parent
        self.cost = cost
        self.heuristic = heuristic
        self.total_cost = cost + heuristic

# 定义AO*算法函数
def a_star(start, goal):
    open_list = [start]
    closed_list = []

    while open_list:
        # 选择open_list中总代价最小的节点
        current_node = min(open_list, key=lambda x: x.total_cost)
        
        # 如果当前节点为目标节点，则返回路径
        if current_node.position == goal.position:
            path = []
            while current_node.parent:
                path.append(current_node.position)
                current_node = current_node.parent
            path.append(start.position)
            path.reverse()
            return path
        
        # 将当前节点从open_list中移除，并加入到closed_list
        open_list.remove(current_node)
        closed_list.append(current_node)
        
        # 扩展当前节点的邻居节点
        neighbors = get_neighbors(current_node)
        
        for neighbor in neighbors:
            # 如果邻居节点已经在closed_list中，则忽略
            if neighbor in closed_list:
                continue
            
            # 计算邻居节点的代价
            cost = current_node.cost + get_cost(current_node, neighbor)
            
            # 如果邻居节点不在open_list中，则将其加入open_list
            if neighbor not in open_list:
                neighbor.cost = cost
                neighbor.heuristic = get_heuristic(neighbor, goal)
                neighbor.parent = current_node
                open_list.append(neighbor)
            else:
                # 如果邻居节点在open_list中，并且新的代价更小，则更新其代价和父节点
                if cost < neighbor.cost:
                    neighbor.cost = cost
                    neighbor.parent = current_node
    
    return None

# 获取节点的邻居节点
def get_neighbors(node):
    # 根据实际情况实现获取邻居节点的函数
    pass

# 获取节点之间的代价
def get_cost(node1, node2):
    # 根据实际情况实现获取节点之间代价的函数
    pass

# 获取节点的启发式代价
def get_heuristic(node, goal):
    # 根据实际情况实现获取节点的启发式代价的函数
    pass

# 示例使用
start_node = Node((0, 0))
goal_node = Node((5, 5))

path = a_star(start_node, goal_node)
print(path)

在实际应用中，需要根据具体问题实现get_neighbors、get_cost和get_heuristic函数。get_neighbors函数用于获取节点的邻居节点，get_cost函数用于计算节点之间的代价，get_heuristic函数用于获取节点的启发式代价。

以上是一个简单的AO*算法的示例，实际应用中可能需要根据具体问题进行适当的修改和扩展。