以下是一个示例代码，演示如何使用BFS、DFS和LRTA*算法来寻找最优路径：

import heapq

# 创建一个图的类
class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = [[] for _ in range(vertices)]
    
    # 添加边
    def add_edge(self, u, v, w):
        self.graph[u].append((v, w))
        self.graph[v].append((u, w))
    
    # 使用BFS算法寻找最优路径
    def bfs(self, start, end):
        visited = [False] * self.V
        queue = []
        queue.append((start, [start]))
        visited[start] = True
        
        while queue:
            node, path = queue.pop(0)
            if node == end:
                return path
            
            for neighbor, _ in self.graph[node]:
                if not visited[neighbor]:
                    visited[neighbor] = True
                    queue.append((neighbor, path + [neighbor]))
    
    # 使用DFS算法寻找最优路径
    def dfs(self, start, end):
        visited = [False] * self.V
        stack = []
        stack.append((start, [start]))
        
        while stack:
            node, path = stack.pop()
            visited[node] = True
            
            if node == end:
                return path
            
            for neighbor, _ in self.graph[node]:
                if not visited[neighbor]:
                    stack.append((neighbor, path + [neighbor]))
    
    # 使用LRTA*算法寻找最优路径
    def lrta_star(self, start, end):
        h = [float('inf')] * self.V
        h[end] = 0
        
        while True:
            if start == end:
                return h[start]
            
            next_node = -1
            min_h = float('inf')
            
            for node in range(self.V):
                if h[node] < min_h:
                    next_node = node
                    min_h = h[node]
            
            if next_node == -1:
                break
            
            for neighbor, cost in self.graph[next_node]:
                h[next_node] = min(h[next_node], cost + h[neighbor])
    
# 创建一个图的实例
g = Graph(7)

# 添加边
g.add_edge(0, 1, 2)
g.add_edge(0, 2, 1)
g.add_edge(1, 3, 3)
g.add_edge(1, 4, 1)
g.add_edge(2, 5, 2)
g.add_edge(2, 6, 4)

# 使用BFS算法寻找最优路径
bfs_path = g.bfs(0, 6)
print("BFS最优路径：", bfs_path)

# 使用DFS算法寻找最优路径
dfs_path = g.dfs(0, 6)
print("DFS最优路径：", dfs_path)

# 使用LRTA*算法寻找最优路径
lrta_star_cost = g.lrta_star(0, 6)
print("LRTA*最优路径代价：", lrta_star_cost)

以上代码创建了一个图的类，并实现了BFS、DFS和LRTA*算法来寻找最优路径。可以根据具体需求修改图的顶点和边，然后调用相应的算法进行路径搜索。