All Paths from Source Lead to Destination

All Paths from Source Lead to Destination - Problem

Journey Through a Directed Network

Imagine you're navigating through a complex road network represented as a directed graph. You have a collection of one-way roads defined by edges[i] = [ai, bi], indicating a direct path from city ai to city bi.

Your mission is to determine whether every possible journey starting from a source city will eventually lead to a specific destination city. This means:

• At least one path exists from source to destination
• No dead ends allowed: If any path leads to a city with no outgoing roads, that city must be the destination
• No infinite loops: All paths must have finite length

Return true if and only if all roads from source inevitably lead to the destination.

Input & Output

example_1.py — Valid Path Network

$ Input: n = 4, edges = [[0,1],[0,2],[1,3],[2,3]], source = 0, destination = 3

› Output: true

💡 Note: There are two paths from source 0 to destination 3: 0→1→3 and 0→2→3. Both paths end at the destination with no cycles or invalid dead ends.

example_2.py — Invalid Dead End

$ Input: n = 4, edges = [[0,1],[0,3],[1,2],[2,1]], source = 0, destination = 3

› Output: false

💡 Note: Path 0→1→2→1 creates a cycle between nodes 1 and 2, making it impossible to reach the destination. The infinite loop violates our requirement.

example_3.py — Wrong Terminal Node

$ Input: n = 3, edges = [[0,1],[1,1],[1,2]], source = 0, destination = 2

› Output: false

💡 Note: From source 0, we can go to node 1, but node 1 has a self-loop (1→1), creating an infinite cycle that prevents reaching destination 2.

Visualization

Tap to expand

Understanding the Visualization

Build Road Map

Create adjacency list representing all one-way roads in the network

Start Journey

Begin DFS from source (warehouse) marking it as currently traveling (GRAY)

Detect Traffic Circles

If we encounter a GRAY node, we found a cycle - invalid route

Check Dead Ends

Roads with no exits must lead to destination only

Mark Verified Routes

Mark completed paths as BLACK to avoid rechecking (memoization)

Key Takeaway

🎯 Key Insight: By using three-color DFS (WHITE/GRAY/BLACK), we can detect cycles during traversal while simultaneously validating paths and memoizing results to avoid redundant work.

Time & Space Complexity

Time Complexity

⏱️

O(2^N)

In worst case, we might explore exponentially many paths before detecting cycles

✓ Linear Growth

Space Complexity

O(N)

Recursion stack depth and path tracking can go up to N nodes

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁴
0 ≤ edges.length ≤ 10⁴
edges[i].length == 2
0 ≤ ai, bi ≤ n - 1
0 ≤ source ≤ n - 1
0 ≤ destination ≤ n - 1
The given graph may have self-loops and parallel edges

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 19

The optimal solution uses DFS with three-color state tracking (WHITE/GRAY/BLACK) to efficiently detect cycles and verify all paths lead to the destination. This approach achieves O(V + E) time complexity by visiting each node at most once and using memoization to avoid redundant work.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS (All Path Enumeration)	O(2^N)	O(N)	Enumerate all possible paths from source and verify each one
DFS with Three-Color State Tracking	O(V + E)	O(V)	Use DFS with WHITE/GRAY/BLACK coloring to efficiently detect cycles and verify paths

Brute Force DFS (All Path Enumeration) — Algorithm Steps

Build adjacency list representation of the graph
Use recursive DFS to enumerate all paths from source
For each path, track visited nodes to detect cycles
Verify that every enumerated path ends at destination
Check that no path leads to a dead-end other than destination

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin exploring from source node

Track Path

Keep track of visited nodes in current path

Check Cycles

If we revisit a node in current path, it's a cycle

Verify End

Every path must end at destination only

Code -

solution.c — C

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

#define MAX_NODES 10000

typedef struct {
    int* neighbors;
    int size;
    int capacity;
} AdjList;

bool dfs(AdjList* graph, int node, int destination, bool* visited, int n) {
    // Cycle detection
    if (visited[node]) {
        return false;
    }
    
    // No outgoing edges
    if (graph[node].size == 0) {
        return node == destination;
    }
    
    // Reached destination but has outgoing edges
    if (node == destination) {
        return false;
    }
    
    visited[node] = true;
    
    // All paths must lead to destination
    for (int i = 0; i < graph[node].size; i++) {
        int neighbor = graph[node].neighbors[i];
        bool* newVisited = (bool*)calloc(n, sizeof(bool));
        
        // Copy visited array
        for (int j = 0; j < n; j++) {
            newVisited[j] = visited[j];
        }
        
        if (!dfs(graph, neighbor, destination, newVisited, n)) {
            free(newVisited);
            return false;
        }
        free(newVisited);
    }
    
    return true;
}

bool leadsToDestination(int n, int** edges, int edgesSize, int source, int destination) {
    AdjList* graph = (AdjList*)calloc(n, sizeof(AdjList));
    
    // Initialize adjacency list
    for (int i = 0; i < n; i++) {
        graph[i].neighbors = (int*)malloc(n * sizeof(int));
        graph[i].size = 0;
        graph[i].capacity = n;
    }
    
    // Build graph
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0];
        int v = edges[i][1];
        graph[u].neighbors[graph[u].size++] = v;
    }
    
    bool* visited = (bool*)calloc(n, sizeof(bool));
    bool result = dfs(graph, source, destination, visited, n);
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i].neighbors);
    }
    free(graph);
    free(visited);
    
    return result;
}

int main() {
    int edges[][2] = {{0,1},{0,2},{1,3},{2,3}};
    int* edgePtr[4];
    for (int i = 0; i < 4; i++) {
        edgePtr[i] = edges[i];
    }
    
    printf("%d\n", leadsToDestination(4, edgePtr, 4, 0, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^N)

In worst case, we might explore exponentially many paths before detecting cycles

✓ Linear Growth

Space Complexity

O(N)

Recursion stack depth and path tracking can go up to N nodes

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁴
0 ≤ edges.length ≤ 10⁴
edges[i].length == 2
0 ≤ ai, bi ≤ n - 1
0 ≤ source ≤ n - 1
0 ≤ destination ≤ n - 1
The given graph may have self-loops and parallel edges

28.5K Views

Medium Frequency

~18 min Avg. Time

892 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

Brute Force DFS (All Path Enumeration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler