Bus Routes

Bus Routes - Problem

You are given an array routes representing bus routes where routes[i] is a bus route that the i-th bus repeats forever.

For example, if routes[0] = [1, 5, 7], this means that the 0-th bus travels in the sequence 1 → 5 → 7 → 1 → 5 → 7 → 1 → ... forever.

You will start at the bus stop source (you are not on any bus initially), and you want to go to the bus stop target.

You can travel between bus stops by buses only. Return the least number of buses you must take to travel from source to target. Return -1 if it is not possible.

Input & Output

Example 1 — Basic Transfer

$ Input: routes = [[1,2,7],[3,6,7]], source = 1, target = 6

› Output: 2

💡 Note: Take Bus 0 from stop 1 to stop 7, then transfer to Bus 1 from stop 7 to reach stop 6. Total: 2 buses.

Example 2 — Direct Route

$ Input: routes = [[7,12],[4,5,15],[6],[15,19,26,7]], source = 15, target = 12

› Output: -1

💡 Note: No possible route from stop 15 to stop 12. Bus 1 contains 15, Bus 0 contains 12, but they don't share any common stops.

Example 3 — Same Stop

$ Input: routes = [[1,2,7],[3,6,7]], source = 6, target = 6

› Output: 0

💡 Note: Already at target stop, no buses needed.

Constraints

1 ≤ routes.length ≤ 500
1 ≤ routes[i].length ≤ 10⁵
All the values of routes[i] are unique
sum(routes[i].length) ≤ 10⁵
0 ≤ routes[i][j] < 10⁶
0 ≤ source, target < 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is to model this as a graph problem where buses are nodes, not stops. Use BFS on buses to find the minimum transfers. Build a stop→buses mapping first, then explore buses level by level. Best approach is BFS with Time: O(N×M), Space: O(N×M).

Common Approaches

✓ BFS (Optimal)

⏱️ Time: O(N × M) Space: O(N × M)

Build a mapping of stops to buses, then use BFS to explore buses level by level. Each level represents one more bus transfer, guaranteeing we find the minimum.

Brute Force DFS

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

For each bus that contains the source stop, recursively explore all possible transfers to other buses until we reach the target. This explores all possible paths without optimization.

BFS (Optimal) — Algorithm Steps

Step 1: Create a map from each stop to all buses that visit it
Step 2: Start BFS from all buses that contain the source stop
Step 3: For each bus, explore all its stops and queue new reachable buses
Step 4: Return the level when target is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Building

Create stop→buses mapping for quick lookup

BFS Queue

Start with buses containing source, explore level by level

Optimal Result

First time target is found gives minimum transfers

Code -

solution.c — C

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

#define MAX_ROUTES 500
#define MAX_STOPS_PER_ROUTE 100
#define MAX_QUEUE 100000

typedef struct {
    int bus;
    int transfers;
} QueueItem;

int parseRoutes(char* s, int routes[][MAX_STOPS_PER_ROUTE], int routeSizes[]) {
    int numRoutes = 0;
    int len = strlen(s);
    
    if (len <= 2) return 0;
    
    int i = 1; // Skip first '['
    while (i < len - 1) {
        if (s[i] == '[') {
            int j = i + 1;
            while (j < len && s[j] != ']') j++;
            
            // Parse numbers in this route
            int routeSize = 0;
            int k = i + 1;
            char numStr[20];
            int numIdx = 0;
            
            while (k <= j) {
                if (s[k] == ',' || s[k] == ']') {
                    if (numIdx > 0) {
                        numStr[numIdx] = '\0';
                        routes[numRoutes][routeSize++] = atoi(numStr);
                        numIdx = 0;
                    }
                } else if (s[k] >= '0' && s[k] <= '9') {
                    numStr[numIdx++] = s[k];
                }
                k++;
            }
            
            routeSizes[numRoutes] = routeSize;
            numRoutes++;
            i = j + 1;
        } else {
            i++;
        }
    }
    return numRoutes;
}

int solution(int routes[][MAX_STOPS_PER_ROUTE], int routeSizes[], int numRoutes, int source, int target) {
    if (source == target) return 0;
    
    QueueItem queue[MAX_QUEUE];
    int front = 0, rear = 0;
    int visitedBuses[MAX_ROUTES] = {0};
    
    // Find buses containing source
    for (int i = 0; i < numRoutes; i++) {
        for (int j = 0; j < routeSizes[i]; j++) {
            if (routes[i][j] == source) {
                queue[rear].bus = i;
                queue[rear].transfers = 1;
                rear++;
                visitedBuses[i] = 1;
                break;
            }
        }
    }
    
    while (front < rear) {
        QueueItem current = queue[front++];
        
        // Check all stops on current bus
        for (int i = 0; i < routeSizes[current.bus]; i++) {
            int stop = routes[current.bus][i];
            if (stop == target) {
                return current.transfers;
            }
            
            // Find other buses that visit this stop
            for (int j = 0; j < numRoutes; j++) {
                if (!visitedBuses[j]) {
                    for (int k = 0; k < routeSizes[j]; k++) {
                        if (routes[j][k] == stop) {
                            visitedBuses[j] = 1;
                            queue[rear].bus = j;
                            queue[rear].transfers = current.transfers + 1;
                            rear++;
                            break;
                        }
                    }
                }
            }
        }
    }
    
    return -1;
}

int main() {
    char routesStr[100000];
    int routes[MAX_ROUTES][MAX_STOPS_PER_ROUTE];
    int routeSizes[MAX_ROUTES];
    int source, target;
    
    fgets(routesStr, sizeof(routesStr), stdin);
    scanf("%d %d", &source, &target);
    
    // Remove newline
    int len = strlen(routesStr);
    if (len > 0 && routesStr[len-1] == '\n') {
        routesStr[len-1] = '\0';
    }
    
    int numRoutes = parseRoutes(routesStr, routes, routeSizes);
    
    int result = solution(routes, routeSizes, numRoutes, source, target);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N × M)

N routes × M average stops per route, each stop/bus visited once

⚠ Quadratic Growth

Space Complexity

O(N × M)

HashMap storing stop→buses mapping plus BFS queue space

⚡ Linearithmic Space

89.3K Views

Medium Frequency

~35 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler