Python中Dijkstra算法实现最短路径的问题，有没有老哥帮我看一看代码啊？

import heapq

def dijkstra(graph, start):
    """
    使用优先队列实现Dijkstra算法
    
    参数:
        graph: dict, 邻接表表示的图 {节点: [(邻居节点, 权重), ...]}
        start: 起始节点
    
    返回:
        distances: dict, 从起始点到各节点的最短距离
        previous: dict, 最短路径的前驱节点
    """
    # 初始化距离字典，所有节点距离设为无穷大
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    
    # 优先队列 (当前距离, 节点)
    priority_queue = [(0, start)]
    
    # 记录路径前驱节点
    previous = {node: None for node in graph}
    
    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)
        
        # 如果当前距离大于已记录距离，跳过
        if current_distance > distances[current_node]:
            continue
        
        # 遍历邻居节点
        for neighbor, weight in graph[current_node]:
            distance = current_distance + weight
            
            # 如果找到更短路径
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                previous[neighbor] = current_node
                heapq.heappush(priority_queue, (distance, neighbor))
    
    return distances, previous

def get_shortest_path(previous, target):
    """根据前驱节点字典重构最短路径"""
    path = []
    node = target
    
    while node is not None:
        path.append(node)
        node = previous[node]
    
    return path[::-1]  # 反转得到从起点到终点的路径

# 示例图
graph = {
    'A': [('B', 4), ('C', 2)],
    'B': [('C', 1), ('D', 5)],
    'C': [('D', 8), ('E', 10)],
    'D': [('E', 2)],
    'E': []
}

# 测试
start_node = 'A'
distances, previous = dijkstra(graph, start_node)

print("从节点 {} 出发的最短距离:".format(start_node))
for node in distances:
    print(f"到节点 {node}: {distances[node]}")

print("\n最短路径示例 (A -> E):")
path = get_shortest_path(previous, 'E')
print(" -> ".join(path))

核心要点：

1. 优先队列优化：使用heapq实现最小堆，确保每次取距离最小的节点
2. 距离松弛：发现更短路径时更新距离和前驱节点
3. 路径重构：通过前驱节点字典反向追踪得到完整路径

常见问题检查：

• 确保图使用邻接表正确表示
• 权重必须为非负值（Dijkstra要求）
• 处理不可达节点（距离保持inf）

建议先检查图的表示是否正确。

我已经上传了 gist 的版本,我试试看吧
python<br>import heapq<br>import sys<br>import math<br>sys.setrecursionlimit(10000)<br>INF = 999999999<br>class Point:<br> def __init__(self, x, y):<br> self.x = float(x)<br> self.y = float(y)<br>def getCost(p,c):<br> x_dis = abs(p.x - c.x)<br> y_dis = abs(p.y - c.y)<br> cost = math.sqrt(x_dis * x_dis + y_dis * y_dis)<br> return cost<br>def dijkstra(G, start, endp): <br> dis = dict((point, INF) for point in G) <br> dis[start] = 0.00<br> vis = dict((point, False) for point in G) <br> # heap<br> pq = [] <br> heapq.heappush(pq, [dis[start], start])<br> path = dict((point, [start]) for point in G) <br> while len(pq) &gt; 0:<br> v_dis, v = heapq.heappop(pq) <br> if vis[v] == True:<br> continue<br> vis[v] = True<br> p = path[v].copy() <br> for point in G: <br> distance = getCost(v,point)<br> if distance &gt; 100.00:<br> continue<br> new_dis = dis[v] + distance<br> <br> if new_dis &lt; dis[point] and (not vis[point]):<br> dis[point] = new_dis <br><br> heapq.heappush(pq, [dis[point], point])<br> temp = p.copy()<br> temp.append(point) <br> path[point] = temp <br> distance = dis[endp]<br> if distance == INF:<br> print("-1")<br> else:<br> print("{:.2f}".format(distance))<br><br>while True:<br> try:<br> numbers = input().strip().split(",")<br> limit = int(numbers[0])<br> point_list = []<br> numbers = list(map(float, numbers))<br> stap = Point(numbers[1],numbers[2])<br> endp = Point(numbers[-2],numbers[-1])<br> if stap.x&gt;limit or stap.y&gt;limit or stap.x&lt;0 or stap.y&lt;0 :<br> print("-1")<br> elif endp.x&gt;limit or endp.y&gt;limit or endp.x&lt;0 or endp.y&lt;0 :<br> print("-1")<br> else: <br> for i in range(1, len(numbers), 2):<br> if numbers[i]&lt;=limit and numbers[i+1]&lt;=limit:<br> point_list.append(Point(numbers[i], numbers[i+1]))<br> dijkstra(point_list, point_list[0], point_list[-1])<br> except EOFError:<br> break<br>