All paths from source to target

/*
 * Given a directed acyclic graph (DAG) of n nodes labeled from 0 to n - 1, find all possible paths from node 0 to node n - 1 and return them in any order.
 * The graph is given as follows: graph[i] is a list of all nodes you can visit from node i (i.e., there is a directed edge from node i to node graph[i][j]).
 * Example 1:
 * Input: graph = [[1,2],[3],[3],[]]
 * Output: [[0,1,3],[0,2,3]]
 * Explanation: There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.
 * Example 2:
 * Input: graph = [[4,3,1],[3,2,4],[3],[4],[]]
 * Output: [[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
 * Constraints:
 * n == graph.length
 * 2 <= n <= 15
 * 0 <= graph[i][j] < n
 * graph[i][j] != i (i.e., there will be no self-loops).
 * All the elements of graph[i] are unique.
 * The input graph is guaranteed to be a DAG.
 */
impl Solution {
  pub fn all_paths_source_target(graph: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let _n = graph.len();
    let mut result = vec![];
    let mut path = vec![0i32];
    fn dfs(node: usize, graph: &[Vec<i32>], path: &mut Vec<i32>, result: &mut Vec<Vec<i32>>) {
      if node == graph.len() - 1 {
        result.push(path.clone());
        return;
      }
      for &next in &graph[node] {
        path.push(next);
        dfs(next as usize, graph, path, result);
        path.pop();
      }
    }
    dfs(0, &graph, &mut path, &mut result);
    result
  }
}