Bus Routes - Practice Coding Problems

Bus Routes - Problem

You're planning a journey through a complex city bus system! 🚌

You have an array routes where each routes[i] represents the stops that bus i visits in order. Each bus follows its route in a circular pattern forever. For example, if routes[0] = [1, 5, 7], then bus 0 travels: 1 → 5 → 7 → 1 → 5 → 7 → ... infinitely.

You start at bus stop source (not on any bus initially) and want to reach bus stop target. You can only travel by taking buses - no walking between stops!

Goal: Find the minimum number of buses you need to take to get from source to target. Return -1 if it's impossible.

Think of this as finding the shortest path in a graph where nodes are bus stops and edges represent bus connections! 🎯

Input & Output

example_1.py — Basic Bus Transfer

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

› Output: 2

💡 Note: Take bus 0 (route [1,2,7]) from stop 1 to stop 7, then take bus 1 (route [3,6,7]) from stop 7 to stop 6. Total: 2 buses.

example_2.py — No Transfer Needed

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

› Output: -1

💡 Note: There's no way to get from stop 15 to stop 12. Stop 15 is on routes [4,5,15] and [15,19,26,7], but neither connects to any route containing stop 12.

example_3.py — Same Source and Target

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

› Output: 0

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

Visualization

Tap to expand

Understanding the Visualization

Build Route Graph

Map each stop to all buses serving it, creating connections between routes

BFS on Routes

Start BFS from all buses serving source, treating each route as one hop

Check Route Coverage

For each route, check if it contains target before expanding

Expand to Connected Routes

Add all buses reachable from any stop on current route

Key Takeaway

🎯 Key Insight: Transform the problem from finding shortest path between stops to finding shortest path between bus routes, dramatically reducing complexity from O(stops²) to O(routes × avg_stops_per_route)

Time & Space Complexity

Time Complexity

⏱️

O(N × M)

N is total number of stops across all routes, M is number of bus routes. Each stop is processed at most once per bus route

✓ Linear Growth

Space Complexity

O(N + M)

Space for stop-to-buses mapping (N) and BFS queue/visited set (M)

✓ Linear Space

Constraints

1 ≤ routes.length ≤ 500
1 ≤ routes[i].length ≤ 10⁵
All values of routes[i] are unique
Sum of routes[i].length ≤ 10⁵
0 ≤ routes[i][j] ≤ 10⁶
0 ≤ source, target ≤ 10⁶

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18 U Uber 15

The optimal solution uses BFS on bus routes rather than individual stops. Key insight: once you board a bus, you can reach any stop on that route with the same cost. This reduces the problem from O(stops) to O(buses) complexity, making it much more efficient for large transit networks.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal BFS (Bus Route Level)	O(N × M)	O(N + M)	Use BFS treating each bus route as a single hop for optimal performance
Brute Force (DFS All Paths)	O(B^N)	O(B × N)	Try all possible bus combinations using DFS
BFS with Stop-by-Stop Movement	O(B × N × S)	O(S × B)	Use BFS treating each bus stop as a node, checking all reachable stops

Optimal BFS (Bus Route Level) — Algorithm Steps

Build a map from each stop to all buses serving it
Initialize BFS queue with all buses reachable from source
For each bus route, check if it contains the target stop
If not, find all buses reachable from any stop on current bus
Add newly reachable buses to queue with incremented distance
Use visited set to avoid re-processing same bus routes

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Stops to Buses

Build mapping from each stop to serving buses

Initialize with Source Buses

Start BFS with all buses serving source

Check Route for Target

For each bus, check if it serves target

Expand to Connected Buses

Add buses reachable from current route stops

Code -

solution.c — C

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

typedef struct {
    int busId;
    int busesTaken;
} BusState;

int numBusesToDestination(int** routes, int routesSize, int* routeSizes, 
                          int source, int target) {
    if (source == target) return 0;
    
    // Implementation would require complex hash table and queue in C
    // This shows the algorithm structure
    
    return -1;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N × M)

N is total number of stops across all routes, M is number of bus routes. Each stop is processed at most once per bus route

✓ Linear Growth

Space Complexity

O(N + M)

Space for stop-to-buses mapping (N) and BFS queue/visited set (M)

✓ Linear Space

Constraints

1 ≤ routes.length ≤ 500
1 ≤ routes[i].length ≤ 10⁵
All values of routes[i] are unique
Sum of routes[i].length ≤ 10⁵
0 ≤ routes[i][j] ≤ 10⁶
0 ≤ source, target ≤ 10⁶

67.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal BFS (Bus Route Level) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler