All Paths from Source Lead to Destination

All Paths from Source Lead to Destination - Problem

Given the edges of a directed graph where edges[i] = [ai, bi] indicates there is an edge between nodes ai and bi, and two nodes source and destination of this graph, determine whether or not all paths starting from source eventually end at destination.

This means:

At least one path exists from the source node to the destination node
If a path exists from the source node to a node with no outgoing edges, then that node is equal to destination
The number of possible paths from source to destination is a finite number

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

Input & Output

Example 1 — Valid Path Structure

$ Input: 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 destination 3, and there are no cycles, so return true.

Example 2 — Wrong Destination

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

› Output: false

💡 Note: Path 0→1→3 ends at node 3, not at the specified destination 2. Since not all paths lead to destination, return false.

Example 3 — Cycle Present

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

› Output: false

💡 Note: There is a self-loop at node 1 (1→1), creating an infinite cycle. This violates the finite paths requirement, so return false.

Constraints

1 ≤ edges.length ≤ 10⁴
edges[i].length == 2
0 ≤ ai, bi ≤ 10³
0 ≤ source ≤ 10³
0 ≤ destination ≤ 10³

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The optimal approach uses DFS with three-color state tracking to detect cycles and validate that all paths from source lead to destination. The key insight is using GRAY state to detect back edges (cycles) while ensuring leaf nodes equal the destination. Time: O(V + E), Space: O(V + E)

Common Approaches

✓ Backtracking

⏱️ Time: N/A Space: N/A

Brute Force DFS

⏱️ Time: O(2^N) Space: O(N)

Build adjacency list and use DFS to explore all paths from source. For each node reached, check if it's a dead end (no outgoing edges) and verify it equals destination.

DFS with Three States

⏱️ Time: O(V + E) Space: O(V + E)

Implement DFS with three states: WHITE (unvisited), GRAY (visiting), BLACK (visited). This efficiently detects cycles and ensures all paths from source lead to destination without infinite loops.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_NODES 1001
#define WHITE 0
#define GRAY 1
#define BLACK 2

static int graph[MAX_NODES][MAX_NODES];
static int outDegree[MAX_NODES];
static int color[MAX_NODES];

bool dfs(int node, int destination) {
    // If we reach a node with no outgoing edges
    if (outDegree[node] == 0) {
        return node == destination;
    }
    
    // Mark as visiting (gray)
    color[node] = GRAY;
    
    // Check all neighbors
    for (int i = 0; i < outDegree[node]; i++) {
        int neighbor = graph[node][i];
        
        // If we encounter a gray node, there's a cycle
        if (color[neighbor] == GRAY) {
            return false;
        }
        
        // If unvisited (white), recursively check
        if (color[neighbor] == WHITE) {
            if (!dfs(neighbor, destination)) {
                return false;
            }
        }
    }
    
    // Mark as completely processed (black)
    color[node] = BLACK;
    return true;
}

bool leadsToDestination(int** edges, int edgesSize, int* edgesColSize, int source, int destination) {
    // Initialize
    for (int i = 0; i < MAX_NODES; i++) {
        outDegree[i] = 0;
        color[i] = WHITE;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int from = edges[i][0];
        int to = edges[i][1];
        graph[from][outDegree[from]++] = to;
    }
    
    return dfs(source, destination);
}

int parseEdges(char* input, int edges[][2]) {
    if (strcmp(input, "[]") == 0 || strcmp(input, "[]\n") == 0) {
        return 0;
    }
    
    int count = 0;
    char* ptr = input;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr && *ptr != ']') {
        // Find start of sub-array
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr || *ptr != '[') break;
        ptr++; // skip '['
        
        // Parse first number
        edges[count][0] = (int)strtol(ptr, &ptr, 10);
        
        // Skip comma
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
        
        // Parse second number
        edges[count][1] = (int)strtol(ptr, &ptr, 10);
        
        // Skip to end of sub-array
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
        
        count++;
        
        // Skip comma between sub-arrays
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
    }
    
    return count;
}

int main() {
    char line[10000];
    static int edgeList[10000][2];
    
    // Read edges
    if (!fgets(line, sizeof(line), stdin)) return 1;
    int edgesSize = parseEdges(line, edgeList);
    
    // Read source
    int source;
    if (scanf("%d", &source) != 1) return 1;
    
    // Read destination
    int destination;
    if (scanf("%d", &destination) != 1) return 1;
    
    // Convert to format expected by function
    int** edges = malloc(edgesSize * sizeof(int*));
    int* edgesColSize = malloc(edgesSize * sizeof(int));
    for (int i = 0; i < edgesSize; i++) {
        edges[i] = malloc(2 * sizeof(int));
        edges[i][0] = edgeList[i][0];
        edges[i][1] = edgeList[i][1];
        edgesColSize[i] = 2;
    }
    
    bool result = leadsToDestination(edges, edgesSize, edgesColSize, source, destination);
    printf("%s\n", result ? "true" : "false");
    
    // Cleanup
    for (int i = 0; i < edgesSize; i++) {
        free(edges[i]);
    }
    free(edges);
    free(edgesColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

35.0K Views

Medium Frequency

~25 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