leecode797. 所有可能的路径

给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）

graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。

示例 1：

输入：graph = [[1,2],[3],[3],[]]
输出：[[0,1,3],[0,2,3]]
解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3
示例 2：

输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]
输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
 

提示：

n == graph.length
2 <= n <= 15
0 <= graph[i][j] < n
graph[i][j] != i（即不存在自环）
graph[i] 中的所有元素 互不相同
保证输入为 有向无环图（DAG）
 

class Solution {


    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
        List<List<Integer>> list = new ArrayList<>();
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        dfs(graph, graph[0], graph.length - 1, stack, list);
        return list;
    }

    public void dfs(int[][] graph, int[] curArr, int end, Stack<Integer> stack, List<List<Integer>> list) {
        //遍历当前数组
        for (int i = 0; i < curArr.length; i++) {
            int next = curArr[i];
            stack.push(next);
            //当前为结束点
            if (next == end) {
                List<Integer> integers = new ArrayList<>();
                for (Integer integer : stack) {
                    integers.add(integer);
                }
                list.add(integers);
                //System.out.println("-------" + list);
                stack.pop();
            } else {
                dfs(graph, graph[next], end, stack, list);
            }
        }
        //当前节点遍历完
        stack.pop();

    }
}