python利用dijkstra算法求解图中最短距离

利用dijkstra算法，来完成图中两个顶点间最短的距离，可以直接复制使用，只需要修改参数即可

 def dijkstra_raw(edges, from_node, to_node):
     """
     将节点信息和边进行比较获取正确的边集
     :param edges:
     :param from_node:
     :param to_node:
     :return:正无穷大
     """
     g = defaultdict(list)
     for l, r, c in edges:
         g[l].append((c, r))
     q, seen = [(0, from_node, ())], set()
     while q:
         (cost, v1, path) = heappop(q)
         if v1 not in seen:
             seen.add(v1)
             path = (v1, path)
             if v1 == to_node:
                 return cost, path
             for c, v2 in g.get(v1, ()):
                 if v2 not in seen:
                     heappush(q, (cost + c, v2, path))
     # inf 表示正无穷大
     return float("inf"), []

 def dijkstra(edges, from_node, to_node):
     """
     gain the shortest path and this node information
     :param edges: this is a array of path
     :param from_node: start node
     :param to_node: end node
     :return: the shortest path and this node information
     """
     len_shortest_path = -1
     ret_path = []
     length, path_queue = dijkstra_raw(edges, from_node, to_node)
     if len(path_queue) > 0:
         # 1. Get the length firstly;
         len_shortest_path = length
         # 2. Decompose the path_queue, to get the passing nodes in the shortest path.
         left = path_queue[0]
         # 2.1 Record the destination node firstly;
         ret_path.append(left)
         right = path_queue[1]
         while len(right) > 0:
             left = right[0]
             # 2.2 Record other nodes, till the source-node.
             ret_path.append(left)
             right = right[1]
         # 3. Reverse the list finally, to make it be normal sequence.
         ret_path.reverse()
     return len_shortest_path, ret_path

 def get_shortest_path(start_node, end_node):
     """
     the shortest_path of matrix
     :param start_node: start_position
     :param end_node: end_position
     :return: the shortest_path
     """
     # endless是不存在边的界限
     endless = 0
     edges_list = []
     m_top = get_array(0)
     for i in range(len(m_top)):
         for j in range(len(m_top[0])):
             if i != j and m_top[i][j] != endless:
                 edges_list.append((i, j, m_top[i][j]))  # (i,j) is a link; m_top[i][j] here is 1, the length of link (i,j).
     return dijkstra(edges_list, start_node, end_node)