2

我对 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},
... }
4

2 回答 2

0

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

此外，使用 dicts 可能比仅仅制作一个 2D 数组更令人头疼。如果您真的想使用 dicts，我建议您使用默认 dict。

于 2013-02-13T22:04:44.040 回答
0

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

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

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
于 2013-02-13T22:44:49.597 回答