All Paths From Source to Target - Practice Coding Problems

All Paths From Source to Target - Problem

Given a directed acyclic graph (DAG) with n nodes labeled from 0 to n-1, find all possible paths from the source node 0 to the target node n-1.

The graph is represented as an adjacency list where graph[i] contains all nodes you can reach directly from node i. Since this is a DAG, there are no cycles, which guarantees that our path-finding will eventually terminate.

Goal: Return all possible paths from node 0 to node n-1 in any order.

Example: If we have a graph [[1,2],[3],[3],[]], this represents:
- Node 0 can go to nodes 1 and 2
- Node 1 can go to node 3
- Node 2 can go to node 3
- Node 3 has no outgoing edges (target)

Input & Output

example_1.py — Basic Graph

$ Input: graph = [[1,2],[3],[3],[]]

› Output: [[0,1,3],[0,2,3]]

💡 Note: There are two paths from node 0 to node 3: 0->1->3 and 0->2->3. Both paths are valid since we can reach the target node 3 from source node 0.

example_2.py — Linear Path

$ 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]]

💡 Note: There are 5 different paths from node 0 to node 4. Each represents a different route through the directed graph.

example_3.py — Single Path

$ Input: graph = [[1],[2],[]]

› Output: [[0,1,2]]

💡 Note: Only one path exists from node 0 to node 2: 0->1->2. This is a simple linear graph with no alternative routes.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start at source node 0 with empty path

Explore

Add current node to path and explore each neighbor

Found Target

When reaching target node, save current path to results

Backtrack

Remove current node and try other branches

Key Takeaway

🎯 Key Insight: DFS with backtracking naturally explores all paths in a tree-like manner, and the DAG property ensures termination without cycles.

Time & Space Complexity

Time Complexity

⏱️

O(2^N * N)

In worst case, we might have 2^N paths (exponential), and each path can be up to N nodes long

✓ Linear Growth

Space Complexity

O(2^N * N)

Space for storing all paths, plus recursion stack depth of at most N

✓ Linear Space

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

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses Depth-First Search (DFS) with backtracking to systematically explore all possible paths from source to target. Since the graph is a DAG (no cycles), we can safely traverse without worrying about infinite loops. The algorithm maintains a current path and adds it to results when reaching the target, then backtracks to explore alternative routes.

Common Approaches

Approach	Time	Space	Notes
✓ Depth-First Search with Backtracking	O(2^N * N)	O(2^N * N)	Recursively explore all paths from source to target using DFS

Depth-First Search with Backtracking — Algorithm Steps

Start DFS from node 0 with an empty path
Add current node to the current path
If current node is the target (n-1), add path to results
Otherwise, recursively explore all neighbors
Backtrack by removing current node when returning

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Node 0

Begin DFS traversal from the source node 0

Explore Neighbors

Visit each neighbor recursively, building the current path

Reach Target

When target is reached, save the current path

Backtrack

Return to previous node and try other paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NODES 15
#define MAX_PATHS 10000
#define MAX_PATH_LEN 15

int result[MAX_PATHS][MAX_PATH_LEN];
int path_lengths[MAX_PATHS];
int result_count = 0;
int current_path[MAX_PATH_LEN];
int path_len = 0;

void dfs(int graph[][MAX_NODES], int graph_sizes[], int node, int target, int n) {
    // Add current node to path
    current_path[path_len++] = node;
    
    // If we reached target, add path to results
    if (node == target) {
        for (int i = 0; i < path_len; i++) {
            result[result_count][i] = current_path[i];
        }
        path_lengths[result_count] = path_len;
        result_count++;
    } else {
        // Explore all neighbors
        for (int i = 0; i < graph_sizes[node]; i++) {
            int neighbor = graph[node][i];
            dfs(graph, graph_sizes, neighbor, target, n);
        }
    }
    
    // Backtrack
    path_len--;
}

int main() {
    // Sample graph: [[1,2],[3],[3],[]]
    int graph[MAX_NODES][MAX_NODES] = {{1,2},{3},{3},{}};
    int graph_sizes[] = {2, 1, 1, 0};
    int n = 4;
    
    result_count = 0;
    path_len = 0;
    
    dfs(graph, graph_sizes, 0, n-1, n);
    
    printf("[");
    for (int i = 0; i < result_count; i++) {
        printf("[");
        for (int j = 0; j < path_lengths[i]; j++) {
            printf("%d", result[i][j]);
            if (j < path_lengths[i] - 1) printf(",");
        }
        printf("]");
        if (i < result_count - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^N * N)

In worst case, we might have 2^N paths (exponential), and each path can be up to N nodes long

✓ Linear Growth

Space Complexity

O(2^N * N)

Space for storing all paths, plus recursion stack depth of at most N

✓ Linear Space

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

68.0K Views

Medium Frequency

~15 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Depth-First Search with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler