Question

我对Python很陌生，我开始试图在这里实现Dijkstra的算法：http://thomas.pelletier.im/2010/02/dijkstras-algorithm-python-implementation/。问题是我的矩阵看起来像这样：

    {
      2845: {27026: {'weight': 0.05950338}, 83860: {'weight': 0.013386887}},
     12422: {27023: {'weight': 0.0787193}, 27026: {'weight': 0.041424256}, 59721: {'weight': 0.11553069}},
     27022: {27025: {'weight': 0.1283993}, 83860: {'weight': 0.11746721}},
     27023: {12422: {'weight': 0.0787193}, 27025: {'weight': 0.22683257}},
     27025: {27022: {'weight': 0.1283993}, 27023: {'weight': 0.22683257}, 27026: {'weight': 0.20290035}},
     27026: {2845: {'weight': 0.05950338}, 12422: {'weight': 0.041424256}, 27025: {'weight': 0.20290035}},
     59721: {12422: {'weight': 0.11553069}},
     83860: {2845: {'weight': 0.013386887}, 27022: {'weight': 0.11746721}}
}

这仍然适用于上述算法，还是我必须稍作调整？如果是，那该怎么办？

由于

编辑：

这是我实施的算法：

def dijkstra(self, graph, start, end):
        D = {} # Final distances dict
        P = {} # Predecessor dict

        for node in graph.keys():
            D[node] = -1 # Vertices are unreachable
            P[node] = ""
        D[start] = 0 # The start vertex needs no move
        unseen_nodes = graph.keys() # All nodes are unseen

        while len(unseen_nodes) > 0:
            shortest = None
            node = ''
            for temp_node in unseen_nodes:
                if shortest == None:
                    shortest = D[temp_node]
                    node = temp_node
                elif (D[temp_node] < shortest):
                    shortest = D[temp_node]
                    node = temp_node
            unseen_nodes.remove(node)
            for child_node, child_value in graph[node].items():
                if D[child_node] < D[node] + child_value:
                    D[child_node] = D[node] + child_value
                    P[child_node] = node
        path = []
        node = end
        while not (node == start):
            if path.count(node) == 0:
                path.insert(0, node) # Insert the predecessor of the current node
                node = P[node] # The current node becomes its predecessor
            else:
                break
        path.insert(0, start) # Finally, insert the start vertex
        return path

我正在使用的矩阵如上所述，算法所需的矩阵是：

... graph = {
...     'A': {'B': 10, 'D': 4, 'F': 10},
...     'B': {'E': 5, 'J': 10, 'I': 17},
...     'C': {'A': 4, 'D': 10, 'E': 16},
...     'D': {'F': 12, 'G': 21},
...     'E': {'G': 4},
...     'F': {'H': 3},
...     'G': {'J': 3},
...     'H': {'G': 3, 'J': 5},
...     'I': {},
...     'J': {'I': 8},
... }

Answer 1

我认为这应该可行，但这取决于您的代码。如果您想要更完整的答案，请发布其余代码。

使用dicts可能比制作2D数组更令人头疼。如果你真的想使用dicts，我建议使用default dict。

Answer 2

在给定的源代码示例中，权重只是一个整数，而不是一个dict。由于你的图表有一个带有“权重”键的字典，你必须根据它改变代码。

这是您的代码的正确版本：

def dijkstra(self, graph, start, end):
        D = {} # Final distances dict
        P = {} # Predecessor dict

        for node in graph.keys():
            D[node] = -1 # Vertices are unreachable
            P[node] = ""
        D[start] = 0 # The start vertex needs no move
        unseen_nodes = graph.keys() # All nodes are unseen

        while len(unseen_nodes) > 0:
            shortest = None
            node = ''
            for temp_node in unseen_nodes:
                if shortest == None:
                    shortest = D[temp_node]
                    node = temp_node
                elif (D[temp_node] < shortest):
                    shortest = D[temp_node]
                    node = temp_node
            unseen_nodes.remove(node)
            for child_node, child_value in graph[node].items():
                if D[child_node] < D[node] + child_value['weight']:  # I changed the code here
                    D[child_node] = D[node] + child_value['weight']   # I changed the code here
                    P[child_node] = node
        path = []
        node = end
        while not (node == start):
            if path.count(node) == 0:
                path.insert(0, node) # Insert the predecessor of the current node
                node = P[node] # The current node becomes its predecessor
            else:
                break
        path.insert(0, start) # Finally, insert the start vertex
        return path

我的dicts dicts是否适用于这个Dijkstra的算法？

2 个答案: