Every route from source to target

def all_paths(n, edges):
    adj = [[] for _ in range(n)]
    for u, v in edges:
        adj[u].append(v)
    for nb in adj:
        nb.sort()                       # smallest first: paths come out in order
    out, path, on_path = [], [0], [False] * n
    on_path[0] = True

    def explore(u):
        if u == n - 1:
            out.append(path[:])         # a copy: path keeps changing
            return
        for v in adj[u]:
            if not on_path[v]:
                on_path[v] = True
                path.append(v)
                explore(v)
                path.pop()              # backtrack
                on_path[v] = False

    explore(0)
    return out

#include <algorithm>
#include <functional>
#include <vector>

std::vector<std::vector<int>> solve(int n, const std::vector<std::vector<int>>& edges) {
    std::vector<std::vector<int>> adj(n), out;
    for (const auto& e : edges) adj[e[0]].push_back(e[1]);
    for (auto& nb : adj) std::sort(nb.begin(), nb.end());
    std::vector<int> path{0};
    std::vector<bool> onPath(n, false);
    onPath[0] = true;
    std::function<void(int)> explore = [&](int u) {
        if (u == n - 1) { out.push_back(path); return; }
        for (int v : adj[u]) {
            if (onPath[v]) continue;
            onPath[v] = true; path.push_back(v);
            explore(v);
            path.pop_back(); onPath[v] = false;          // backtrack
        }
    };
    explore(0);
    return out;
}

import java.util.*;

class Solution {
    private List<List<Integer>> adj;
    private List<int[]> out;
    private Deque<Integer> path;
    private boolean[] onPath;
    private int target;

    public int[][] allPaths(int n, int[][] edges) {
        adj = new ArrayList<>();
        for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
        for (int[] e : edges) adj.get(e[0]).add(e[1]);
        for (List<Integer> nb : adj) Collections.sort(nb);
        out = new ArrayList<>();
        path = new ArrayDeque<>();
        onPath = new boolean[n];
        target = n - 1;
        path.addLast(0);
        onPath[0] = true;
        explore(0);
        return out.toArray(new int[0][]);
    }

    private void explore(int u) {
        if (u == target) {
            out.add(path.stream().mapToInt(Integer::intValue).toArray());   // a copy
            return;
        }
        for (int v : adj.get(u)) {
            if (onPath[v]) continue;
            onPath[v] = true; path.addLast(v);
            explore(v);
            path.removeLast(); onPath[v] = false;          // backtrack
        }
    }
}

function allPaths(n, edges) {
  const adj = Array.from({ length: n }, () => []);
  for (const [u, v] of edges) adj[u].push(v);
  for (const nb of adj) nb.sort((a, b) => a - b);
  const out = [], path = [0], onPath = new Array(n).fill(false);
  onPath[0] = true;
  const explore = u => {
    if (u === n - 1) { out.push([...path]); return; }   // record a copy
    for (const v of adj[u]) {
      if (onPath[v]) continue;
      onPath[v] = true; path.push(v);
      explore(v);
      path.pop(); onPath[v] = false;                     // backtrack
    }
  };
  explore(0);
  return out;
}

fn solve(n: i64, edges: &[[i64; 2]]) -> Vec<Vec<i64>> {
    let n = n as usize;
    let mut adj = vec![Vec::new(); n];
    for e in edges {
        adj[e[0] as usize].push(e[1] as usize);
    }
    for nb in adj.iter_mut() {
        nb.sort();
    }
    fn explore(u: usize, adj: &[Vec<usize>], path: &mut Vec<i64>, on_path: &mut Vec<bool>, out: &mut Vec<Vec<i64>>) {
        if u == adj.len() - 1 {
            out.push(path.clone());
            return;
        }
        for &v in &adj[u] {
            if on_path[v] {
                continue;
            }
            on_path[v] = true;
            path.push(v as i64);
            explore(v, adj, path, on_path, out);
            path.pop();                                    // backtrack
            on_path[v] = false;
        }
    }
    let mut out = Vec::new();
    let mut on_path = vec![false; n];
    on_path[0] = true;
    explore(0, &adj, &mut vec![0], &mut on_path, &mut out);
    out
}

import Data.List (sort)
import qualified Data.Map.Strict as M

solve :: Int -> [[Int]] -> [[Int]]
solve n edges = explore [0]
  where
    adj = M.map sort (M.fromListWith (++) [(u, [v]) | [u, v] <- edges])
    -- the path is kept reversed: its head is the current node
    explore path@(u : _)
      | u == n - 1 = [reverse path]
      | otherwise = concat [explore (v : path) | v <- M.findWithDefault [] u adj, v `notElem` path]