单源最短路

给你一个无向图，图中包含 5000 个点 m 个边，任意两个点之间的距离是 w ，无重边或自环。请求出1号点到n号点的最短距离。

注意：图中可能存在孤立点，即存在点与任意点都没有边相连

如果1号点不能到达n号点，输出-1.

import heapq
from collections import defaultdict
import sys
import math

lines = sys.stdin.readlines()
n, m = [int(i) for i in lines[0].split()]
# 保存节点到源点的距离
distance = {}
# 保存节点的父节点
parent = {}
#初始化一个字典，存储邻接点及距离，字典里面的key也是一个字典
dis = defaultdict(dict)
#源点的父节点设置为none
parent[1] = None
#存储处理过的点
occ_set = set()
# 初始化最小堆
Q = []
#Q表示堆，0为距离，1为节点，将（0，1）存入堆Q中
heapq.heappush(Q, (0, 1))
#源点到源点的距离为0
distance[1] = 0
#将所有节点到源点的距离初始化为无穷大math.inf
for i in range(1, 5001):
    distance[i] = math.inf
#遍历所有行，不直接用for line in lines[1:] 是为了避免越界问题
#更新两节点之间的距离
""" x = 0
for line in lines[1:]:
    if x <= m:
        i,o,w = [int(i) for i in line.split()]
        dis[i][o] = w
        dis[o][i] = w
        x += 1   """ 
for idx,line in enumerate(lines[1:]):
    if idx <= m:
        i,o,w = [int(i) for i in line.split()]
        dis[i][o] = w
        dis[o][i] = w
print(dis)
#Dijkstra算法
#当堆Q不为空时（Q中存的节点及到源点的距离）
while len(Q) > 0:
    d, node = heapq.heappop(Q)
    #print("d:",d)
    #print("node:",node)
    #将该节点存入已访问集合中
    occ_set.add(node)
    #print("occ_set:",occ_set)
    #访问节点的邻接点
    for key in dis[node].keys():
        #print("key:",key) #2
        #print("dis[node].keys():",dis[node].keys()) #{2:3}
        if key not in occ_set:
            if dis[node][key] + d <= distance[key]:
                #print("dis[node][key]:",dis[node][key])
                #print("distance[key]:",distance[key])
                distance[key] = dis[node][key] + d
                heapq.heappush(Q, (distance[key], key))
                #print("Q:",Q)
                parent[key] = node

print(-1 if distance[n] == math.inf else distance[n])