与'有关的问题；访问列表'；在使用Dijkstras时，Python

我对编码还比较陌生，所以对于被覆盖的、笨拙的代码，我深表歉意

此外，f.f.r.这是麻省理工学院的开放式课件“习题集11，绕过麻省理工学院的最快方法”。（对于以后的习题集，我无法在线找到解决方案。）

我已经实现了Dijkstra算法的一个最成功的版本，有动态规划和没有动态规划。在这个实现中，我保留了一个节点列表，以避免循环/无限循环……但据我所知，这就是我遇到问题的地方。考虑到我的边是加权的，并且在某些情况下我希望通过不同的边重新访问相同的节点，这将导致我的代码忽略正确的解决方案。因此，我想找到一种方法来修改我的代码，这样它就能记住访问了哪些边，而不是哪个节点，而且……我确实尝试过修改它，以记住访问了哪些边——但我的实现不起作用——所以我希望看到正确的编写方法

我的代码失败的输入示例：

# Test case 6
print "---------------"
print "Test case 6:"
print "Find the shortest-path from Building 1 to 32 without going outdoors"
expectedPath6 = ['1', '3', '10', '4', '12', '24', '34', '36', '32']
brutePath6 = bruteForceSearch(digraph, '1', '32', LARGE_DIST, 0)
dfsPath6 = directedDFS(digraph, '1', '32', LARGE_DIST, 0)
print "Expected: ", expectedPath6
print "Brute-force: ", brutePath6
print "DFS: ", dfsPath6

代码的输出

---------------
Test case 6:
Find the shortest-path from Building 1 to 32 without going outdoors
Expected:  ['1', '3', '10', '4', '12', '24', '34', '36', '32']
Brute-force:  ['1', '3', '10', '13', '24', '34', '36', '32']
DFS:  ['1', '3', '3', '3', '7', '7', '9', '13', '24', '34', '36', '36', '32']

邻接列表是dict中dict的形式，其中权重存储为元组。要检查暴力代码、地图输入或有向图的构建方式，请访问此GitHub

def findDist（有向图、开始、路径）：
路径=[str（开始）]+路径
距离=0
距离=0
对于范围内的i（len（path）-1）：
edgeVals=无
listOfDest=digraph.edges[节点（路径[i]）]
对于listOfDest中的节点：
如果node.has_键（node（路径[i+1]））：
edgeVals=node.values（）
距离=距离+边值[0][0]
outDistance=outDistance+edgeVals[0][1]
打破
返回（距离，超出距离）
def directedDFS（有向图、开始、结束、maxTotalDist、MaxDistOutdoor、toPrint=False、visited=[]、level=0、memo={}）：
"""
使用“定向深度优先”查找从起点到终点的最短路径。
搜索进近。路径上行驶的总距离不得超过
超过maxTotalDist，则此路径上的室外距离必须为
不超过maxDisOutdoors。
参数：
有向图：类有向图或其子类的实例
开始，结束：开始和结束建筑编号（字符串）
maxTotalDist：路径上的最大总距离（整数）
maxDistOutdoors：路径上户外花费的最大距离（整数）
假设：
起点和终点是图中现有建筑的编号
返回：
从起点到终点的最短路径，由
建筑物编号列表（字符串），[n_1，n_2，…，n_k]，
在有向图中，存在从n_i到n_i（i+1）的边，
为什么你的代码忽略了正确的答案？请将输出的相关部分复制并粘贴到实际问题中。文本图像从来没有文本本身有用（除非是关于呈现文本或其他内容的问题）@Blckknght我添加了我的解决方案最失败的测试数据dramatically@MxyL我不确定你到底是什么意思，也许这就是我的问题——我可以说边有多重权重（总行走距离和室外行走距离），对于某些输入，正确的解决方案不仅包括到达目的地，而且还包括在不走出去的情况下到达目的地。因此，理想情况下，代码会丢弃这些解决方案。在给定特定情况下，您应该能够遍历代码，并能够说“这就是为什么它不会沿着这条边走，选择一条不同的边“，这应该能让我们了解哪些线是可疑的。
def findDist(digraph, start, path):
path = [str(start)] + path
distance = 0
outDistance = 0
for i in range(len(path)-1):
    edgeVals = None
    listOfDest = digraph.edges[Node(path[i])]
    for node in listOfDest:
        if node.has_key(Node(path[i+1])):
            edgeVals = node.values()
            distance = distance + edgeVals[0][0]
            outDistance = outDistance + edgeVals[0][1]
            break
return (distance, outDistance)

def directedDFS(digraph, start, end, maxTotalDist, maxDistOutdoors, toPrint = False, visited = [], level = 0, memo = {}):
"""
Finds the shortest path from start to end using directed depth-first.
search approach. The total distance travelled on the path must not
exceed maxTotalDist, and the distance spent outdoor on this path must
not exceed maxDisOutdoors.

Parameters: 
    digraph: instance of class Digraph or its subclass
    start, end: start & end building numbers (strings)
    maxTotalDist : maximum total distance on a path (integer)
    maxDistOutdoors: maximum distance spent outdoors on a path (integer)

Assumes:
    start and end are numbers for existing buildings in graph

Returns:
    The shortest-path from start to end, represented by 
    a list of building numbers (in strings), [n_1, n_2, ..., n_k], 
    where there exists an edge from n_i to n_(i+1) in digraph, 
    for all 1 <= i < k.

    If there exists no path that satisfies maxTotalDist and
    maxDistOutdoors constraints, then raises a ValueError.
"""
#TODO
if toPrint:
    print start, end
check = start
start = Node(start)
end = Node(end)
if not (digraph.hasNode(start) and digraph.hasNode(end)):
    raise ValueError('Start or end not in graph.')
path = [str(start)]
if start == end:
    return path
shortestDist = None
shortestOutDist = None
distFilter = (maxTotalDist <= maxDistOutdoors)
for child in digraph.childrenOf(start):
    childNode = child.keys()[0]
    if (str(childNode) not in visited):
        visited = visited + [str(childNode)]
        try:
            newPath = memo[start, end]
        except:
            newPath = directedDFS(digraph, str(childNode), str(end), maxTotalDist, maxDistOutdoors, toPrint, visited, level = level + 1)
        if newPath == None:
            continue
        newPathDist = findDist(digraph, start, newPath)
        if (distFilter) and (newPathDist[1] <= maxDistOutdoors) and ((shortestDist == None) or (newPathDist[0] < findDist(digraph, start, shortestDist)[0])):
            shortestDist = newPath
        elif (not distFilter) and ((shortestOutDist == None) or (newPathDist[1] <= findDist(digraph, start, shortestOutDist)[1])):
            if (shortestOutDist == None) or (newPathDist[0] <= findDist(digraph, start, shortestOutDist)[0]):
                shortestOutDist = newPath
                memo[childNode, end] = newPath
if (distFilter) and (shortestDist != None):
    path = path + shortestDist
elif (not distFilter) and (shortestOutDist != None):
    path = path + shortestOutDist
else: 
    path = None
if (level == 0) and (not distFilter) and (shortestOutDist == None):
    raise ValueError('No such path!')
elif (level == 0) and (not distFilter) and (findDist(digraph, start, shortestOutDist)[1] > maxDistOutdoors):
    raise ValueError('No such path!')
elif (level == 0) and (distFilter) and (shortestDist == None):
    raise ValueError('No such path!')
elif (level == 0) and (distFilter) and (findDist(digraph, start, shortestDist)[0] > maxTotalDist):
    raise ValueError('No such path!')
return path