Village Road Network

Village Road Network - Problem

There are n villages numbered from 0 to n - 1. You are given a 2D array roads where each roads[i] = [u, v] means there is a bidirectional road between village u and village v.

Given two integers source and destination, return true if a traveler can reach destination from source using the available roads, or false otherwise.

Input & Output

Example 1 — Disconnected Villages

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

› Output: false

💡 Note: Villages 0,1,2 form one cluster. Villages 3,4,5 form another. No road connects the two clusters.

Example 2 — Connected Villages

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

› Output: true

💡 Note: All villages are connected. Route: 0 → 1 → 2 or directly 0 → 2.

Example 3 — Same Village

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

› Output: true

💡 Note: Source equals destination — the traveler is already there.

Constraints

1 ≤ n ≤ 2 × 10^5
0 ≤ edges.length ≤ 2 × 10^5
edges[i].length == 2
0 ≤ u, v < n
0 ≤ source, destination < n

Visualization

Tap to expand

Asked in

a Amazon 52 G Google 38 M Meta 28 M Microsoft 25

The key insight is that a traveler can reach the destination if both villages are in the same connected road network. BFS/DFS explores from source to check reachability. Union-Find groups villages by connectivity and checks in near O(1). Both are O(V+E) overall.

Common Approaches

✓ BFS Traversal

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

Build an adjacency list from roads. Starting from source, use BFS with a queue and visited set. If we ever dequeue the destination village, return true. If the queue empties without finding destination, return false.

Union-Find (Disjoint Set)

⏱️ Time: O(E × α(V)) Space: O(V)

Use Union-Find with path compression and union by rank. Process each road by unioning the two villages. After all roads are processed, check if find(source) == find(destination). This avoids building a full adjacency list.

BFS Traversal — Algorithm Steps

Step 1: Build adjacency list from edges
Step 2: Initialize queue with source, mark visited
Step 3: BFS: dequeue node, check if destination, enqueue unvisited neighbors
Step 4: Return true if destination found, false if queue exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Queue: [0], Visited: {0}

Expand 0

Neighbors: 1,2 → Queue: [1,2], Visited: {0,1,2}

Queue empty

5 not found → return false

Code -

solution.c — C

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

#define MAXN 200001
#define MAXE 400002

int head[MAXN], to[MAXE], nxt[MAXE], ecnt;
int visited[MAXN], queue[MAXN];

void addEdge(int u, int v) {
    to[ecnt] = v; nxt[ecnt] = head[u]; head[u] = ecnt++;
    to[ecnt] = u; nxt[ecnt] = head[v]; head[v] = ecnt++;
}

int main() {
    int n, source, dest, ch, num, neg, u, v;
    int i, front, back;
    ecnt = 0;
    memset(head, -1, sizeof(head));

    /* Parse n */
    while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')));
    neg = 0; num = 0;
    if (ch == '-') { neg = 1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { num = num * 10 + (ch - '0'); ch = getchar(); }
    n = neg ? -num : num;

    /* Parse edges - find outer [ */
    while ((ch = getchar()) != EOF && ch != '[');
    /* Now parse inner pairs */
    while (1) {
        ch = getchar();
        if (ch == EOF || ch == ']') break;  /* end of outer array */
        if (ch == '[') {
            /* parse pair */
            while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')));
            neg = 0; num = 0;
            if (ch == '-') { neg = 1; ch = getchar(); }
            while (ch >= '0' && ch <= '9') { num = num * 10 + (ch - '0'); ch = getchar(); }
            u = neg ? -num : num;

            while (ch != EOF && !(ch == '-' || (ch >= '0' && ch <= '9'))) ch = getchar();
            neg = 0; num = 0;
            if (ch == '-') { neg = 1; ch = getchar(); }
            while (ch >= '0' && ch <= '9') { num = num * 10 + (ch - '0'); ch = getchar(); }
            v = neg ? -num : num;

            addEdge(u, v);
            /* skip to ] */
            while (ch != ']' && ch != EOF) ch = getchar();
        }
    }

    /* Parse source */
    while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')));
    neg = 0; num = 0;
    if (ch == '-') { neg = 1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { num = num * 10 + (ch - '0'); ch = getchar(); }
    source = neg ? -num : num;

    /* Parse destination */
    while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')));
    neg = 0; num = 0;
    if (ch == '-') { neg = 1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { num = num * 10 + (ch - '0'); ch = getchar(); }
    dest = neg ? -num : num;

    /* BFS */
    memset(visited, 0, sizeof(visited));
    front = 0; back = 0;
    queue[back++] = source;
    visited[source] = 1;

    while (front < back) {
        int node = queue[front++];
        if (node == dest) {
            printf("true\n");
            return 0;
        }
        for (i = head[node]; i != -1; i = nxt[i]) {
            if (!visited[to[i]]) {
                visited[to[i]] = 1;
                queue[back++] = to[i];
            }
        }
    }
    printf("false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each node and edge at most once

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list O(E), visited set O(V), queue O(V)

✓ Linear Space

3 Views

High Frequency

~15 min Avg. Time

0 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

BFS Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler