迪杰斯特拉

# coding=utf-8

import heapq
import math

DATA = {"data":
            {"node": [{"y": 390, "x": 2550, "id": 1},
                      {"y": 2430, "x": 4530, "id": 2},
                      {"y": 390, "x": 6530, "id": 3},
                      {"y": -1620, "x": 4530, "id": 4},
                      {"y": 410, "x": 530, "id": 5},
                      {"y": 390, "x": 8520, "id": 6},
                      {"y": 4420, "x": 4530, "id": 7},
                      {"y": -3600, "x": 4530, "id": 8},
                      {"y": 3410, "x": 9540, "id": 9},
                      {"y": -2600, "x": 9540, "id": 10}],
             "edge": [{"id": 1, "s_node": 1, "e_node": 2, "cost": 2842.8899999999999},
                      {"id": 2, "s_node": 2, "e_node": 3, "cost": 2856.8499999999999},
                      {"id": 3, "s_node": 3, "e_node": 4, "cost": 2835.5100000000002},
                      {"id": 4, "s_node": 4, "e_node": 1, "cost": 2821.4400000000001},
                      {"id": 5, "s_node": 1, "e_node": 4, "cost": 2821.4400000000001},
                      {"id": 6, "s_node": 4, "e_node": 3, "cost": 2835.5100000000002},
                      {"id": 7, "s_node": 3, "e_node": 2, "cost": 2856.8499999999999},
                      {"id": 8, "s_node": 2, "e_node": 1, "cost": 2842.8899999999999},
                      {"id": 9, "s_node": 1, "e_node": 5, "cost": 2020.0999999999999},
                      {"id": 10, "s_node": 5, "e_node": 1, "cost": 2020.0999999999999},
                      {"id": 11, "s_node": 3, "e_node": 6, "cost": 1990},
                      {"id": 12, "s_node": 6, "e_node": 3, "cost": 1990},
                      {"id": 15, "s_node": 5, "e_node": 2, "cost": 4481.1199999999999},
                      {"id": 16, "s_node": 2, "e_node": 6, "cost": 4481.2600000000002},
                      {"id": 17, "s_node": 6, "e_node": 4, "cost": 4467.6800000000003},
                      {"id": 18, "s_node": 4, "e_node": 5, "cost": 4485.6300000000001},
                      {"id": 19, "s_node": 2, "e_node": 7, "cost": 1990},
                      {"id": 20, "s_node": 7, "e_node": 2, "cost": 1990},
                      {"id": 21, "s_node": 4, "e_node": 8, "cost": 1980},
                      {"id": 22, "s_node": 8, "e_node": 4, "cost": 1980},
                      {"id": 23, "s_node": 3, "e_node": 9, "cost": 4263.8599999999997},
                      {"id": 24, "s_node": 9, "e_node": 3, "cost": 4263.8599999999997},
                      {"id": 25, "s_node": 3, "e_node": 10, "cost": 4242.6599999999999},
                      {"id": 26, "s_node": 10, "e_node": 3, "cost": 4242.6599999999999}]}}


def Vertex(edge,node):
    li0 = []
    parent=[]
    for i in range(len(node)):
        li0.append([])
        try:
            for j in range(len(edge)):
                if i + 1 == edge[j]["s_node"]:
                    li0[i].append(edge[j]["e_node"])
        except Exception as e:
            pass
    num=0
    for i in li0:
        num+=1
        for j in i:
            # ele=str(num)+str(j)
            ele=tuple([num,j])
            parent.append(ele)
    return li0,parent

def Dist(edge):
    li1 = []
    for i in range(len(node)):
        li1.append([])
        try:
            for j in range(len(edge)):
                if i + 1 == edge[j]["s_node"]:
                    li1[i].append(edge[j]["cost"])
        except Exception as e:
            pass
    return li1

def Allgraph(li0, li1):
    allgraph = []
    graph = {}
    for n in range(1, len(node)+1):
        graph[n] = {}
        nn = n - 1
        e1_node = li0[nn]
        for i in range(len(e1_node)):
            graph[n][e1_node[i]] = li1[nn][i]
    allgraph.append(graph)
    print('每个顶点所能达到的其他顶点和对应的距离：', allgraph)
    return allgraph


def init_distance(graph, s):
    distance = {s: 0}
    for vertex in graph:
        if vertex != s:
            distance[vertex] = 999999999999999999999999999999
    # print('初始距离：', distance)
    return distance


def dijkstra(graph, s,path):
    pqueue = []
    heapq.heappush(pqueue, (0, s))
    seen = set()
    parent = {s: None}
    distance = init_distance(graph, s)
    seen.add(s)
    while len(pqueue) > 0:
        pair = heapq.heappop(pqueue)
        dist = pair[0]
        vertex = pair[1]
        nodes = graph[vertex].keys()
        # print('当前顶点%s' % vertex, '可到达的点：', nodes)
        for w in nodes:
            if w !=s:
                # 寻找w顶点到终点的最短距离
                # print('尝试找到', w, '到终点更短的距离')
                path1=tuple([w,vertex])
                if path1 in path:
                    if dist + graph[vertex][w] < distance[w]:
                        heapq.heappush(pqueue, (dist + graph[vertex][w], w))
                        # w到终点最短路径的父顶点
                        parent[w] = vertex
                        # w 顶点到终点最短的距离
                        distance[w] = dist + graph[vertex][w]
                else:
                    for i in path:
                        if i[1] ==vertex:
                            w=i[0]
                            if dist + graph[w][vertex] < distance[w]:
                                heapq.heappush(pqueue, (dist + graph[w][vertex], w))
                                parent[w] = vertex
                                distance[w] = dist + graph[w][vertex]
    return parent, distance


if __name__ == '__main__':
    start = int(input('起点：'))
    end = int(input('终点：'))
    edge = DATA['data']['edge']
    node = DATA['data']['node']
    allgraph = Allgraph(Vertex(edge,node)[0],Dist(edge))
    parent_dict, distance_dict = dijkstra(allgraph[0], end,Vertex(edge,node)[1])
    print('最短距离：', distance_dict[start])
    path = []
    path.append(start)
    while parent_dict[start]:
        path.append(parent_dict[start])
        start = parent_dict[start]
    print('最短路径：', path)