Question

在考虑Python中的寻路算法时，我做了这个，我很好奇它的平均和最坏情况的复杂性，因为我是编码新手，不知道如何计算出嵌套嵌套的数量循环。从实验上看，它似乎比我在课堂上自己编写的O（n ^ 2）Dijkstra算法要快。


    def Pathfinder(l,s):
        E=[s]
        L=dict()
        P=dict()   
        for n in range(len(l)):
            L[n]=math.inf
        L[s]=0
        P[s]="-"
        p=-1
        for m in E:
            p+=1
            for node, length in l[m].items():
                if length + L[m] < L[node]:
                    L[node] = length + L[m]
                    P[node] = m
                    b=0
                    for k in range(p,len(E)):
                        if node == E[k]:
                            b=1
                    if b==0:
                        E.append(node)
        return L, P

输入是一个图形和一个起点，由字典列表给出，每个“ from”节点由列表中字典的位置给出，“ to”节点由字典中的键给出，和“弧长”是值。例如：

[{1 : 2, 2 : 5},
{2 : 3},
{3 : 4},
{0 : 21, 1 : 8}]
0 -> 1 (arc length 2)
0 -> 2 (arc length 5)
1 -> 2 (arc length 3)
2 -> 3 (arc length 4)
3 -> 0 (arc length 21)
3 -> 1 (arc length 8)

它返回2个字典； L是一个字典，其中键是每个节点，值是最小距离 P是一个字典，其中键是每个节点，而值是最短路径中该节点的直接前任。使用上图，从节点0开始，它返回

({0: 0, 1: 2, 2: 1, 3: 3}, {0: '-', 1: 2, 2: 0, 3: 1})

哪个是正确的它的工作方式是：对于每个节点，检查它可以到达的每个节点的总路径长度是否短于已知路径，将其设置为新的长度和后继路径，并将该节点置于末尾。稍后要检查的列表（它将更新以该节点为后继节点的所有节点的路径长度）。块“ b = 0”到“ if b == 0”确保每个节点仅被“以后检查”一次，但是一旦被检查，就不再需要以后检查了，但是可以放在最后再次出现在列表中。但是我不知道如何开始对复杂性进行理论化。

我对寻路算法的复杂性感兴趣

0 个答案: