All Simple Paths in an Undirected Graph

Build an undirected graph with nodes 0..n-1 from edges. Return every simple path from source to target.
A simple path repeats no node. Sort each adjacency list and return paths in depth-first lexicographic order.

Function
allSimplePaths(n: int, edges: int[][], source: int, target: int) → int[][]

Examples
Example 1
n = 4
edges = [[0,1],[1,3],[0,2],[2,3],[1,2]]
source = 0
target = 3
return = [[0,1,2,3],[0,1,3],[0,2,1,3],[0,2,3]]
DFS follows sorted neighbors and never repeats a node.

Constraints
1 <= n <= 15.
Edges are unique undirected pairs.
Source and target are valid distinct nodes.

Build an adjacency list from edges, add both directions, and sort each list. Then run DFS from source with a current path and a visited set. When you reach target, copy the path into the results and return. Otherwise loop over sorted neighbors, skip visited ones, push, recurse, pop, and unmark. Sorted neighbors give you the required depth-first lexicographic order for free, so no final sort is needed. The common pitfalls: appending the live path list instead of a copy, so every result mutates into the same list. Forgetting to unmark on backtrack. Forgetting to sort adjacency lists. Also, stop at target and don't continue past it, since a simple path can't revisit nodes anyway. With n <= 15, the worst case is huge for dense graphs, but that's inherent to the output size. If you blank mid-assessment, StealthCoder is the hedge that keeps you moving.

Drill it cold or hedge it with StealthCoder. Either way, don't walk into the OA hoping you remember the trick.