Find if Path Exists in Graph

Find if Path Exists in Graph - Problem

There is a bi-directional graph with n vertices, where each vertex is labeled from 0 to n - 1 (inclusive). The edges in the graph are represented as a 2D integer array edges, where each edges[i] = [ui, vi] denotes a bi-directional edge between vertex ui and vertex vi. Every vertex pair is connected by at most one edge, and no vertex has an edge to itself.

You want to determine if there is a valid path that exists from vertex source to vertex destination.

Given edges and the integers n, source, and destination, return true if there is a valid path from source to destination, or false otherwise.

Input & Output

Example 1 — Basic Connected Graph

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

› Output: true

💡 Note: There are two paths from vertex 0 to vertex 2: 0→1→2 and 0→2. Both are valid paths.

Example 2 — Disconnected Components

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

› Output: false

💡 Note: Vertex 0 is in component {0,1,2} while vertex 5 is in component {3,4,5}. No path exists between them.

Example 3 — Same Source and Destination

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

› Output: true

💡 Note: Source and destination are the same vertex. A path always exists from a vertex to itself.

Constraints

1 ≤ n ≤ 2 × 10⁵
0 ≤ edges.length ≤ 2 × 10⁵
edges[i].length == 2
0 ≤ u_i, v_i ≤ n - 1
u_i != v_i
0 ≤ source, destination ≤ n - 1

Visualization

Tap to expand

Asked in

F Facebook 15 a Amazon 12 G Google 10 M Microsoft 8

The key insight is that this is a graph connectivity problem - we need to determine if two nodes belong to the same connected component. The most efficient approaches are DFS or BFS traversal starting from the source. Both have optimal Time: O(V + E), Space: O(V) complexity.

Common Approaches

✓ Breadth-First Search (BFS)

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

Perform breadth-first search using a queue, exploring all nodes at current level before moving to next level. This guarantees finding the shortest path in unweighted graphs.

Brute Force - Try All Paths

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

Generate all possible paths from source and check if any reaches destination. This approach doesn't use visited tracking, leading to potential infinite loops and repeated work.

Depth-First Search (DFS)

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

Perform depth-first search from source, marking visited nodes to avoid cycles. If we reach destination during traversal, return true. This is the most intuitive graph traversal approach.

Breadth-First Search (BFS) — Algorithm Steps

Initialize queue with source node
While queue is not empty, process current node
Add all unvisited neighbors to queue
Return true if destination is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with source node 0 in queue

Level 1

Process node 0, add neighbors 1 and 3 to queue

Level 2

Process node 1, find destination 2

Code -

solution.c — C

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

#define MAX_NODES 200000
#define MAX_QUEUE 200000
#define MAX_EDGES_PER_NODE 1000

static int graph[MAX_NODES][MAX_EDGES_PER_NODE];
static int graphSize[MAX_NODES];
static bool visited[MAX_NODES];
static int queue[MAX_QUEUE];
static int front = 0, rear = 0;

void enqueue(int val) {
    queue[rear++] = val;
}

int dequeue() {
    return queue[front++];
}

bool isEmpty() {
    return front >= rear;
}

bool solution(int n, int edges[][2], int edgesSize, int source, int destination) {
    if (source == destination) return true;
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
        visited[i] = false;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0];
        int v = edges[i][1];
        if (graphSize[u] < MAX_EDGES_PER_NODE) {
            graph[u][graphSize[u]++] = v;
        }
        if (graphSize[v] < MAX_EDGES_PER_NODE) {
            graph[v][graphSize[v]++] = u;
        }
    }
    
    // BFS
    front = rear = 0;
    enqueue(source);
    visited[source] = true;
    
    while (!isEmpty()) {
        int node = dequeue();
        
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            
            if (neighbor == destination) return true;
            
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                enqueue(neighbor);
            }
        }
    }
    
    return false;
}

int main() {
    int n;
    scanf("%d", &n);
    
    static char edgesStr[100000];
    scanf("%s", edgesStr);
    
    int source, destination;
    scanf("%d %d", &source, &destination);
    
    static int edges[10000][2];
    int edgesSize = 0;
    
    // Handle empty array case
    if (strcmp(edgesStr, "[]") == 0) {
        edgesSize = 0;
    } else {
        // Parse edges - format [[a,b],[c,d]...]
        char* ptr = edgesStr + 1; // Skip first '['
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++; // Skip '['
                
                // Parse first number
                int num1 = 0;
                bool negative = false;
                if (*ptr == '-') {
                    negative = true;
                    ptr++;
                }
                while (*ptr >= '0' && *ptr <= '9') {
                    num1 = num1 * 10 + (*ptr - '0');
                    ptr++;
                }
                if (negative) num1 = -num1;
                
                // Skip comma
                while (*ptr && *ptr != ',') ptr++;
                if (*ptr == ',') ptr++;
                
                // Parse second number
                int num2 = 0;
                negative = false;
                if (*ptr == '-') {
                    negative = true;
                    ptr++;
                }
                while (*ptr >= '0' && *ptr <= '9') {
                    num2 = num2 * 10 + (*ptr - '0');
                    ptr++;
                }
                if (negative) num2 = -num2;
                
                edges[edgesSize][0] = num1;
                edges[edgesSize][1] = num2;
                edgesSize++;
                
                // Skip to closing bracket
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    bool result = solution(n, edges, edgesSize, source, destination);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and each edge twice (bidirectional)

⚠ Quadratic Growth

Space Complexity

O(V)

Queue and visited set can store up to V vertices

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~15 min Avg. Time

2.8K 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

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search (BFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler