遍历有向图中的所有可用路径

Question

图表结构的编号如下所示。

在python中的图形对象中加载此结构。我把它作为一个多行字符串，如下所示。

myString='''1
2 3
4 5 6
7 8 9 10
11 12 13 14 15'''

将其表示为列表列表。

>>> listofLists=[ list(map(int,elements.split())) for elements in myString.strip().split("\n")]
>>> print(listofLists)
[[1], [2, 3], [4, 5, 6], [7, 8, 9, 10], [11, 12, 13, 14, 15]]

使用python

中的下面的Node和edge类创建图形结构

Node Class，它需要将位置作为元组和值 示例：元素及其位置，值

1 --- position (0,0) and value is 1
2 --- position (1,0) and value is 2
3 --- position (1,1) and value is 3

节点类

class node(object):
    def __init__(self,position,value):
        '''
        position : gives the position of the node wrt to the test string as a tuple
        value    : gives the value of the node
        '''
        self.value=value
        self.position=position

    def getPosition(self):
        return self.position

    def getvalue(self):
        return self.value

    def __str__(self):
        return 'P:'+str(self.position)+' V:'+str(self.value)

edge类在两个节点之间创建一条边。

class edge(object):
    def __init__(self,src,dest):
        '''src and dest are nodes'''
        self.src = src
        self.dest = dest

    def getSource(self):
        return self.src

    def getDestination(self):
        return self.dest
    #return the destination nodes value as the weight
    def getWeight(self):
        return self.dest.getvalue()

    def __str__(self):
        return (self.src.getPosition(),)+'->'+(self.dest.getPosition(),)

定向图类如下。图结构构建为dict邻接列表。 {节点1：[节点2，节点3]，结点2：[节点3，节点4] ......}

class Diagraph(object):

    '''the edges is a dict mapping node to a list of its destination'''
    def __init__(self):
        self.edges = {}

    '''Adds the given node as a key to the dict named edges ''' 
    def addNode(self,node):
        if node in self.edges:
            raise ValueError('Duplicate node')
        else:
            self.edges[node]=[]

    '''addEdge accepts and edge class object checks if source and destination node are present in the graph '''     
    def addEdge(self,edge):
        src = edge.getSource()
        dest = edge.getDestination()
        if not (src in self.edges and dest in self.edges):
            raise ValueError('Node not in graph')
        self.edges[src].append(dest)

    '''getChildrenof returns  all the children of the node'''   
    def getChildrenof(self,node):
        return self.edges[node]

    '''to check whether a node is present in the graph or not'''    
    def hasNode(self,node):
        return node in self.edges

    '''rootNode returns the root node i.e node at position (0,0)''' 
    def rootNode(self):
        for  keys in self.edges:
            return keys if keys.getPosition()==(0,0) else 'No Root node for this graph'

用于创建和返回要工作的图形对象的函数。

def createmygraph(testString):
    '''input is a multi-line string'''

    #create a list of lists from the string
    listofLists=[ list(map(int,elements.split())) for elements in testString.strip().split("\n")]
    y = Diagraph()
    nodeList = []

    # create all the nodes and store it in a list nodeList
    for i in range(len(listofLists)):
        for j in range(len(listofLists)):
            if i<=j:
                mynode=node((j,i),listofLists[j][i])
                nodeList.append(mynode)
                y.addNode(mynode)

    # create all the edges
    for srcNode in nodeList:
    # iterate through all the nodes again and form a logic add the edges
        for destNode in nodeList:
            #to add the immediate down node eg : add 7 (1,0) to 3 (0,0) , add 2 (2,0) to 7 (1,0)
            if srcNode.getPosition()[0]==destNode.getPosition()[0]-1 and srcNode.getPosition()[1]==destNode.getPosition()[1]-1:
                y.addEdge(edge(srcNode,destNode))
            #to add the bottom right node eg :add 4 (1,1) to 3 (0,0) 
            if srcNode.getPosition()[0]==destNode.getPosition()[0]-1 and srcNode.getPosition()[1]==destNode.getPosition()[1]:
                y.addEdge(edge(srcNode,destNode))

    return y

如何列出两个节点之间可用的所有路径。具体来说，在 1 ----＆gt; 11，1 ----＆gt; 12,1 ----＆gt; 13之间，1- ---＆gt; 14,11 ----＆gt; 15  对于这种情况，我尝试了左第一深度优先方法。但它未能获得路径。

def leftFirstDepthFirst(graph,start,end,path,valueSum):
    #add input start node to the path
    path=path+[start]
    #add the value to the valueSum variable
    valueSum+=start.getvalue()
    print('Current Path ',printPath(path))
    print('The sum is ',valueSum)
    # return if start and end node matches.
    if start==end:
        print('returning as start and end have matched')
        return path

    #if there are no further destination nodes, move up a node in the path and remove the current element from the path list.
    if not graph.getChildrenof(start):
        path.pop()
        valueSum=valueSum-start.getvalue()
        return leftFirstDepthFirst(graph,graph.getChildrenof(path[-1])[1],end,path,valueSum)
    else:
        for aNode in graph.getChildrenof(start):
            return leftFirstDepthFirst(graph,aNode,end,path,valueSum)
    print('no further path to explore')

测试代码。

#creating a graph object with given string
y=createmygraph(myString)

用于返回终端节点，如11,12,13,14,15。

def fetchTerminalNode(graph,position):
    terminalNode=[]
    for keys in graph.edges:
        if not graph.edges[keys]:
            terminalNode.append(keys)
    return terminalNode[position]

首先运行深度第一个功能。

source=y.rootNode() # element at position (0,0)
destination=fetchTerminalNode(y,1) #ie. number 12
print('Path from ',start ,'to ',destination)
xyz=leftFirstDepthFirst(y,source,destination,[],0)

为元素11和12提取路径，但不为13或14或15提取路径。即destination=fetchTerminalNode(y,2)不起作用。可以请任何人建议解决此问题的方法。

Answer 1

给出tree

tree = \
  [ [1]
  , [2, 3]
  , [4, 5, 6]
  , [7, 8, 9, 10]
  , [11, 12, 13, 14, 15]
  ]

一个traverse函数

def traverse (tree):
  def loop (path, t = None, *rest):
    if not rest:
      for x in t:
        yield path + [x]
    else:
      for x in t:
        yield from loop (path + [x], *rest)
  return loop ([], *tree)

遍历所有路径......

for path in traverse (tree):
  print (path)

# [ 1, 2, 4, 7, 11 ]
# [ 1, 2, 4, 7, 12 ]
# [ 1, 2, 4, 7, 13 ]
# [ 1, 2, 4, 7, 14 ]
# [ 1, 2, 4, 7, 15 ]
# [ 1, 2, 4, 8, 11 ]
# [ 1, 2, 4, 8, 12 ]
# ...
# [ 1, 3, 6, 9, 15 ]
# [ 1, 3, 6, 10, 11 ]
# [ 1, 3, 6, 10, 12 ]
# [ 1, 3, 6, 10, 13 ]
# [ 1, 3, 6, 10, 14 ]
# [ 1, 3, 6, 10, 15 ]

或收集列表中的所有路径

print (list (traverse (tree)))
# [ [ 1, 2, 4, 7, 11 ]
# , [ 1, 2, 4, 7, 12 ]
# , [ 1, 2, 4, 7, 13 ]
# , [ 1, 2, 4, 7, 14 ]
# , [ 1, 2, 4, 7, 15 ]
# , [ 1, 2, 4, 8, 11 ]
# , [ 1, 2, 4, 8, 12 ]
# , ...
# , [ 1, 3, 6, 9, 15 ]
# , [ 1, 3, 6, 10, 11 ]
# , [ 1, 3, 6, 10, 12 ]
# , [ 1, 3, 6, 10, 13 ]
# , [ 1, 3, 6, 10, 14 ]
# , [ 1, 3, 6, 10, 15 ]
# ]

上面，我们使用了Python中的高级功能的生成器。也许您希望了解如何使用更原始的功能实现解决方案......

我们在这里寻找的通用机制是列表monad，它捕获了模糊计算的概念;某些可能返回多个值的过程。

Python已经提供了列表以及使用[]构建它们的方法。我们只需要提供绑定操作，名为flat_map

def flat_map (f, xs):
  return [ y for x in xs for y in f (x) ]

def traverse (tree):
  def loop (path, t = None, *rest):
    if not rest:
      return map (lambda x: path + [x], t)
    else:
      return flat_map (lambda x: loop (path + [x], *rest), t)
  return loop ([], *tree)

print (traverse (tree))
# [ [ 1, 2, 4, 7, 11 ]
# , [ 1, 2, 4, 7, 12 ]
# , [ 1, 2, 4, 7, 13 ]
# , ... same output as above ...
# ]

哦，Python有一个内置的product函数，恰好可以正常工作。唯一的区别是路径将输出为元组()而不是列表[]

from itertools import product

tree = \
  [ [1]
  , [2, 3]
  , [4, 5, 6]
  , [7, 8, 9, 10]
  , [11, 12, 13, 14, 15]
  ]

for path in product (*tree):
  print (path)

# (1, 2, 4, 7, 11)
# (1, 2, 4, 7, 12)
# (1, 2, 4, 7, 13)
# (1, 2, 4, 7, 14)
# (1, 2, 4, 7, 15)
# ... same output as above ...

在您的程序中，您尝试通过各种类node和edge以及diagraph来抽象此机制。最终你可以根据需要构建你的程序，但要知道它不会需要比我们在这里写的更复杂。

更新

正如@user3386109在评论中指出的那样，我上面的程序会生成路径，就像每个父级都连接到所有子项一样。这是一个错误，但是因为您的图表显示父母只连接到相邻的孩子。我们可以通过修改我们的计划来解决这个问题 - 以下粗体

进行更改

def traverse (tree):
  def loop (path, i, t = None, *rest):
    if not rest:
      for (j,x) in enumerate (t):
        if i == j or i + 1 == j:
          yield path + [x]
    else:
      for (j,x) in enumerate (t):
        if i == j or i + 1 == j:
          yield from loop (path + [x], j, *rest)
  return loop ([], 0, *tree)

上面我们使用索引i和j来确定哪些节点“相邻”但是它们混乱了loop一堆。此外，新代码看起来像是引入了一些重复。赋予此意图名称adjacencies可使我们的功能更加清晰

def traverse (tree):
  def adjacencies (t, i):
    for (j, x) in enumerate (t):
      if i == j or i + 1 == j:
        yield (j, x)

  def loop (path, i, t = None, *rest):
    if not rest:
      for (_, x) in adjacencies (t, i):
        yield path + [x]
    else:
      for (j, x) in adjacencies (t, i):
        yield from loop (path + [x], j, *rest)

  return loop ([], 0, *tree)

使用它是一样的，但这次我们得到原始问题中指定的输出

for path in traverse (tree):
  print (path)

# [1, 2, 4, 7, 11]
# [1, 2, 4, 7, 12]
# [1, 2, 4, 8, 12]
# [1, 2, 4, 8, 13]
# [1, 2, 5, 8, 12]
# [1, 2, 5, 8, 13]
# [1, 2, 5, 9, 13]
# [1, 2, 5, 9, 14]
# [1, 3, 5, 8, 12]
# [1, 3, 5, 8, 13]
# [1, 3, 5, 9, 13]
# [1, 3, 5, 9, 14]
# [1, 3, 6, 9, 13]
# [1, 3, 6, 9, 14]
# [1, 3, 6, 10, 14]
# [1, 3, 6, 10, 15]

这个简单的adjancies函数工作的原因是因为您的输入数据是统一且有效的。您可以通过对图像中的路径进行颜色编码来清晰地显示索引i和i + 1。我们永远不必担心索引越界错误，因为您可以看到i + 1永远不会在没有子节点的节点上计算（即最后一行）。如果您要指定无效数据，traverse不保证有效结果。

Answer 2

PFB我能提出的功能，使用breathfirstSearch打印根节点和终端节点之间的所有可用路径。

Google Colab/github链接

def breathfirstalgo(graph,tempPaths,finalPath):
## iterates over all the lists inside the tempPaths and checks if there are child nodes to its last node.
condList=[graph.getChildrenof(apartList[-1]) for apartList in tempPaths if graph.getChildrenof(apartList[-1])]

tempL=[]    
if condList:

    for partialList in tempPaths:
        #get the children of the last element of partialList
        allchild=graph.getChildrenof(partialList[-1])

        if allchild:
            noOfChild=len(allchild)
            #create noOfChild copies of the partialList
            newlist=[partialList[:] for _ in range(noOfChild)]      
            #append the a child element to the new list
            for i in range(noOfChild):
                newlist[i].append(allchild[i])

            #append each list to the temp list tempL
            for alist in newlist:
                tempL.append(alist)

        else:
            pass

    #after completion of the for loop i.e iterate through 1 level
    return breathfirstalgo(graph,tempL,finalPath)
else:
    #append all the lists from tempPaths to finalPath that will be returned
    for completePath in tempPaths:
        finalPath.append(completePath)
    return finalPath

测试breathfirstsearch解决方案如下。

mygraph=createmygraph(myString)
print('The graph object is ',mygraph)
print('The root node is ',mygraph.rootNode())
#print(mygraph)
all_list=breathfirstalgo(mygraph,tempPaths=[[mygraph.rootNode()]],finalPath=[])

print('alllist is ')
for idx,partlist in enumerate(all_list):
    print(printPath(partlist))

将节点类的__str__修改为str(self.value)

后，输出如下所示

The graph object is  <__main__.Diagraph object at 0x7f08e5a3d128>
The root node is  1
alllist is 
-->1-->2-->4-->7-->11
-->1-->2-->4-->7-->12
-->1-->2-->4-->8-->12
-->1-->2-->4-->8-->13
-->1-->2-->5-->8-->12
-->1-->2-->5-->8-->13
-->1-->2-->5-->9-->13
-->1-->2-->5-->9-->14
-->1-->3-->5-->8-->12
-->1-->3-->5-->8-->13
-->1-->3-->5-->9-->13
-->1-->3-->5-->9-->14
-->1-->3-->6-->9-->13
-->1-->3-->6-->9-->14
-->1-->3-->6-->10-->14
-->1-->3-->6-->10-->15