Delivery Route Exists

Delivery Route Exists - Problem

A logistics company operates n warehouses numbered from 0 to n - 1.

You are given a 2D array roads where roads[i] = [u, v] means a delivery truck can travel in both directions between warehouse u and warehouse v.

Given two integers source and destination, return true if a delivery truck can reach the destination warehouse from the source warehouse, or false otherwise.

Input & Output

Example 1 — No Route

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

› Output: false

💡 Note: Warehouses 0,1,2 form one network. Warehouses 3,4,5 form another. No route connects them.

Example 2 — Route Exists

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

› Output: true

💡 Note: All warehouses connected. Route: 0→1→2 or 0→2.

Example 3 — Same Warehouse

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

› Output: true

💡 Note: Source equals destination.

Constraints

1 ≤ n ≤ 2 × 10^5
0 ≤ roads.length ≤ 2 × 10^5
0 ≤ u, v < n
0 ≤ source, destination < n

Visualization

Tap to expand

Asked in

a Amazon 0 G Google 0

The key insight is that a delivery is possible if both warehouses are in the same connected road network. BFS explores from source. Union-Find groups warehouses by connectivity.

Common Approaches

✓ BFS Route Search

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

Build adjacency list from roads. BFS from source with queue and visited set. If destination dequeued, return true. If queue empties, return false.

Union-Find (Disjoint Set)

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

Use Union-Find with path compression. Process each road by unioning. Check find(source)==find(destination).

BFS Route Search — Algorithm Steps

Step 1: Build adjacency list
Step 2: BFS from source
Step 3: Check if destination visited
Step 4: Return result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Queue: [0]

Expand

Visit 1,2. Queue: [1,2]

Done

Queue empty, 5 not found → 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 once

✓ Linear Growth

Space Complexity

O(V+E)

Adjacency list + visited set

✓ Linear Space

4 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 Route Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler