从入度为 0 的顶点打印 DAG 中所有可能的路径

给定一个有向无环图 (DAG)，有N个顶点和M 个边，任务是打印从入度为零的顶点开始的所有路径。

Indegree of a vertex is the total number of incoming edges to a vertex. 
 

例子：

Input: N = 6, edges[] = {{5, 0}, {5, 2}, {4, 0}, {4, 1}, {2, 3}, {3, 1}} 
Output: All possible paths: 
4 0 
4 1 
5 0 
5 2 3 1 
Explanation: 
The given graph can be represented as: 
 

There are two vertices whose indegree are zero i.e vertex 5 and 4, after exploring these vertices we got the fallowing path: 
4 -> 0 
4 -> 1 
5 -> 0 
5 -> 2 -> 3 -> 1 

Input: N = 6, edges[] = {{0, 5}} 
Output: All possible paths: 
0 5 
Explanation: 
There will be only one possible path in the graph. 

方法：

1. 创建一个布尔数组indeg0 ，它存储所有入度为零的顶点的真值。
2. 对所有入度为 0 的顶点应用 DFS。
3. 打印从入度为 0 的顶点到出度为零的顶点的所有路径。

Illustration: 
For the above graph: 
indeg0[] = {False, False, False, False, True, True} 
Since indeg[4] = True, so applying DFS on vertex 4 and printing all path terminating to 0 outdegree vertex are as follow: 
4 -> 0 
4 -> 1 
Also indeg[5] = True, so applying DFS on vertex 5 and printing all path terminating to 0 outdegree vertex are as follow: 
5 -> 0 
5 -> 2 -> 3 -> 1 
 

下面是上述方法的实现：

Python3

# Python program to print all
# possible paths in a DAG
 
# Recursive function to print all paths
def dfs(s):
    # Append the node in path
    # and set visited
    path.append(s)
    visited[s] = True
 
    # Path started with a node
    # having in-degree 0 and
    # current node has out-degree 0,
    # print current path
    if outdeg0[s] and indeg0[path[0]]:
        print(*path)
 
    # Recursive call to print all paths
    for node in adj[s]:
        if not visited[node]:
            dfs(node)
 
    # Remove node from path
    # and set unvisited
    path.pop()
    visited[s] = False
 
 
def print_all_paths(n):
    for i in range(n):
 
        # for each node with in-degree 0
        # print all possible paths
        if indeg0[i] and adj[i]:
            path = []
            visited = [False] * (n + 1)
            dfs(i)
 
 
# Driver code
from collections import defaultdict
 
n = 6
# set all nodes unvisited
visited = [False] * (n + 1)
path = []
 
# edges = (a, b): a -> b
edges = [(5, 0), (5, 2), (2, 3),
         (4, 0), (4, 1), (3, 1)]
 
# adjacency list for nodes
adj = defaultdict(list)
 
# indeg0 and outdeg0 arrays
indeg0 = [True]*n
outdeg0 = [True]*n
 
for edge in edges:
    u, v = edge[0], edge[1]
    # u -> v
    adj[u].append(v)
 
    # set indeg0[v] <- false
    indeg0[v] = False
 
    # set outdeg0[u] <- false
    outdeg0[u] = False
 
print('All possible paths:')
print_all_paths(n)

输出：

All possible paths:
4 0
4 1
5 0
5 2 3 1

时间复杂度： O (N + E) ²
辅助空间： O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。