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.
Analysis:
A DFS for all the nodes should solve the problem.
Code (Java):
class Solution { public List<List<Integer>> allPathsSourceTarget(int[][] graph) { List<List<Integer>> ans = new ArrayList<>(); if (graph == null || graph.length == 0) { return ans; } // DFS // List<Integer> path = new ArrayList<>(); findPathToTarget(graph, 0, path, ans); return ans; } private void findPathToTarget(int[][] graph, int source, List<Integer> path,
List<List<Integer>> ans) { path.add(source); if (source == graph.length - 1) { List<Integer> cloneList = new ArrayList<>(path); ans.add(cloneList); } for (int neighbor : graph[source]) { findPathToTarget(graph, neighbor, path, ans); } path.remove(path.size() - 1); } }
Complexity Analysis
- Time Complexity: . We can have exponentially many paths, and for each such path, our prepending operation
path.add(0, node)
will be . - Space Complexity: , the size of the output dominating the final space complexity.
No comments:
Post a Comment