Find if Path Exists in Graph - Practice Coding Problems

Find if Path Exists in Graph - Problem

Imagine you're planning a trip through a network of cities connected by bidirectional roads. You have a map showing all the connections, and you need to determine if it's possible to travel from your starting city to your destination.

Given a bidirectional graph with n vertices labeled from 0 to n-1, where edges are represented as a 2D array edges[i] = [u_i, v_i], determine if there's a valid path from source to destination.

Key points:

The graph is undirected - you can travel both ways on any road
No city connects to itself
At most one direct road exists between any two cities
Return true if a path exists, false otherwise

Input & Output

example_1.py — Simple Path

$ 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 paths are valid.

example_2.py — Disconnected Graph

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

› Output: false

💡 Note: There is no path from vertex 0 to vertex 5. Vertices 0,1,2 form one connected component while vertices 3,4,5 form another separate component.

example_3.py — Same Source and Destination

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

› Output: true

💡 Note: Since source equals destination, we are already at the target. No movement needed.

Visualization

Tap to expand

Understanding the Visualization

Build the Road Network

Convert the edges array into an adjacency list representing bidirectional roads between cities

Start the Journey

Begin exploration from the source city, marking it as visited to avoid going in circles

Explore Connected Cities

Visit each neighboring city that hasn't been visited yet, continuing the search recursively

Destination Found!

If we reach the destination city, return true. If all reachable cities are explored without finding destination, return false

Key Takeaway

🎯 Key Insight: Graph connectivity problems are efficiently solved using DFS/BFS traversal with visited tracking or Union-Find for multiple queries. The key is recognizing that we only need to check if two nodes belong to the same connected component.

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and traverse each edge once in worst case

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage O(V + E) plus visited set O(V) plus recursion stack O(V)

✓ Linear Space

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
There are no duplicate edges and no self edges

Asked in

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

This graph connectivity problem can be solved optimally using Depth-First Search (DFS) with visited tracking in O(V + E) time. Build an adjacency list, then explore from source until destination is found. Union-Find is another excellent approach, especially for multiple queries, with nearly constant time per operation due to path compression.

Common Approaches

Approach	Time	Space	Notes
✓ Depth-First Search (Optimal)	O(V + E)	O(V + E)	Use DFS with visited tracking to efficiently explore the graph
Union-Find (Disjoint Set)	O(E * α(V))	O(V)	Use Union-Find data structure to efficiently check connectivity
Brute Force Path Enumeration	O(2^n)	O(n)	Try all possible paths using recursive exploration without optimization

Depth-First Search (Optimal) — Algorithm Steps

Handle edge case: if source equals destination, return true
Build adjacency list from the edges array
Initialize visited set and start DFS from source
For each unvisited neighbor, recursively explore
Mark nodes as visited to avoid cycles
Return true if destination is reached, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Build adjacency list and start DFS from source

Mark Visited

Mark current node as visited to avoid cycles

Explore Unvisited

Recursively visit each unvisited neighbor

Success or Backtrack

Return true if destination found, otherwise continue search

Code -

solution.c — C

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

#define MAX_N 200000

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
bool visited[MAX_N];

bool dfs(int node, int destination) {
    if (node == destination) return true;
    
    visited[node] = true;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor]) {
            if (dfs(neighbor, destination)) return true;
        }
    }
    
    return false;
}

bool validPath(int n, int** edges, int edgesSize, int* edgesColSize, int source, int destination) {
    if (source == destination) return true;
    
    // Initialize
    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], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    return dfs(source, destination);
}

int main() {
    // Input parsing and function call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and traverse each edge once in worst case

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage O(V + E) plus visited set O(V) plus recursion stack O(V)

✓ Linear Space

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
There are no duplicate edges and no self edges

125.0K Views

High 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler