[leetcode]#797. All Paths From Source to Target

Given a directed, acyclic graph of N nodes.  Find all possible paths from node 0 to node N-1, and return them in any order.

The graph is given as follows:  the nodes are 0, 1, ..., graph.length - 1.  graph[i] is a list of all nodes j for which the edge (i, j) exists.

Example:
Input: [[1,2], [3], [3], []] 
Output: [[0,1,3],[0,2,3]] 
Explanation: The graph looks like this:
0--->1
|    |
v    v
2--->3
There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.

Note:

• The number of nodes in the graph will be in the range [2, 15].

• You can print different paths in any order, but you should keep the order of nodes inside one path.
• class Solution:
•     def allPathsSourceTarget(self, graph):
          """
          :type graph: List[List[int]]
          :rtype: List[List[int]]
          """
          def my_reduce(D):#将多层嵌套的列表展开为1层
              while type(D[0])!=type(D[1]):
                  n=len(D)
                  for i in range(1,n):
                      D[0].append(D[i])
                  D=D[0]
              return D
          n=len(graph)
          def path(end):#递归求解
              if end==0:#递归基础
                  return [0]
              else:
                  A=[]
                  B=[]
                  for i in range(n):
                      if end in graph[i]:
                          A=path(i)+[end]
                          B.append(A)
              for i in range(len(B)):#将B中元素展开
                  B[i]=my_reduce(B[i])
              for c in B:
                  m=len(c)
                  for i in range(m-1):
                      if type(c[i])==list:
                          c[i].append(c[-1])
                  c=c[:-1]
              C=[]
              for c in B:
                  if type(c[0])==int:
                      C.append(c)
                  else:
                      i=len(c)
                      for j in range(i):
                          if type(c[j])==list:
                              C.append(c[j])
              return C
          return path(n-1)