代码

Question

我有一个字典，其中的键表示节点和值，表示键可以遍历的可能节点。

示例：

dependecyDict = { 'A': ['D'], 'B': ['A', 'E'], 'C': ['B'], 'D': ['C'], 'G':['H']}

我想创建一个新的dicitonary，ChainsDict，它将包含每个'key'可以通过dependecyDict遍历的所有'值'。

例如，此示例的程序输出将为：

ChainsDict = {'A': ['D', 'C', 'B','E'], 'B':['A','D','C','E'], 'C':['B','A','D','E'], 'D':['C','B','A','E'], 'G': ['H']}

我认为使用递归算法是制定解决方案的最佳方法，我尝试修改最短路径遍历算法，如下所示：

def helper(dependencyDict, ChainsDict):path = []
    for key in dependencyDict:
        path = path + [(recursiveRowGen(dependencyDict,key))]
    for paths in path:
        ChainsDict[paths[0]] = paths[1:]
    print(finalLineDict)
def recursiveRowGen(dependencyDict,key,path = []):
    path = path + [key]

        if not key in dependencyDict:
        print("no key: ",key)
        return path
        print(dependencyDict[key])
        for blocking in dependencyDict[key]:
            if blocking not in path:
                newpath = recursiveRowGen(dependencyDict,blocking,path)
                if newpath:
                    return newpath             
    return path

但是，当dependecyDict中的键具有多个值时，此代码在捕获正确输出时遇到问题。我找到了一个hacky解决方案，但它感觉不是很优雅。感谢任何帮助，谢谢！

Answer 1

这基本上是图遍历问题。您可以将每个密钥表示为图中的节点，其值是与其连接的节点。

您可以执行深度优先搜索或广度优先搜索图表。当然，对于这些方法中的每一种，还有迭代和递归解决方案。这是一个迭代实现（我添加了一些条件来消除循环）：

dependencyDict = { 'A': ['D'], 'B': ['A', 'E'], 'C': ['B'], 'D': ['C'], 'G':['H'] }
chainsDict = {}

for key in dependencyDict:
    currKey = key
    frontier = [key]
    visited = []
    while frontier:
        currKey = frontier[0]
        frontier.remove(currKey)
        if dependencyDict.get(currKey,0) and (currKey not in visited) and (currKey not in frontier):
            nodes = dependencyDict[currKey]
            frontier.extend(nodes)
            visited.append(currKey)
        elif currKey in visited:
            visited.remove(currKey)
        elif dependencyDict.get(currKey,0) == 0:
            visited.append(currKey)
    for i in visited:
        if i == key:
            visited.remove(i)
    chainsDict[key] = visited

print chainsDict

结果如下：

{'A': ['D', 'C', 'B', 'E'], 'C': ['B', 'A', 'E', 'D'], 'B': ['A', 'E', 'D', 'C'], 'D': ['C', 'B', 'A', 'E'], 'G': ['H']}

Answer 2

这是一个递归解决方案：

代码

def get_chain_d(argDict):
    def each_path(i,caller_chain):
        a=[]
        caller_chain.append(i)
        b = argDict.get(i,[])
        for j in b:
            if j not in caller_chain:
                a.append(j)
                a.extend(each_path(j,caller_chain))
        return a

    return {i:each_path(i,[]) for i in argDict}

dependecyDict = { 'A': ['D'], 'B': ['A', 'E'], 'C': ['B'], 'D': ['C'], 'G':['H']}

print(get_chain_d(dependecyDict))

输出：

{'B': ['A', 'D', 'C', 'E'], 'A': ['D', 'C', 'B', 'E'], 'D': ['C', 'B', 'A', 'E'], 'C': ['B', 'A', 'D', 'E'], 'G': ['H']}

Python：列出字典表示的图形中的所有可能路径

2 个答案:

代码

输出：