Codestin Search App

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.

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⁶

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)

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
✓ 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)	O(N × M)	O(N + M)	Use BFS treating each bus route as a single hop for optimal performance

Brute Force (DFS All Paths) — Algorithm Steps

Build a map from each bus stop to all buses that visit it
Use DFS from the source stop
At each stop, try boarding every available bus
For each bus, explore all stops on that route
Track minimum buses needed to reach target
Use memoization to avoid infinite loops

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Source

Begin DFS from source stop, track available buses

Try Each Bus

For each bus at current stop, explore all destinations

Recursive Exploration

Recursively explore from each reachable stop

Track Minimum

Update minimum buses when target is reached

Code -

solution.c — C

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

int minBuses;

void dfs(int** routes, int* routeSizes, int routesSize, int** stopToBuses, 
         int* stopToBusesSize, int currentStop, int target, int busesTaken, 
         int* visitedBuses) {
    if (currentStop == target) {
        if (busesTaken < minBuses) {
            minBuses = busesTaken;
        }
        return;
    }
    
    if (busesTaken >= minBuses) return;
    
    // Implementation would require complex hash table in C
    // This is a simplified structure
}

int numBusesToDestination(int** routes, int routesSize, int* routeSizes, 
                          int source, int target) {
    if (source == target) return 0;
    
    minBuses = INT_MAX;
    
    // Build stop to buses mapping (complex in C)
    // Perform DFS
    
    return minBuses == INT_MAX ? -1 : minBuses;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(B^N)

B is number of buses, N is maximum stops per route. In worst case, we might try all bus combinations exponentially

✓ Linear Growth

Space Complexity

O(B × N)

Space for recursion stack and visited state tracking

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (DFS All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler