Codestin Search App

Car Pooling - Problem

Array Sorting Heap (Priority Queue) Simulation Prefix Sum Medium

Car Pooling Challenge: You're operating a rideshare service with a car that has a capacity of empty seats. Your car can only drive eastward along a straight highway - no U-turns allowed!

You have an array of trips where each trip is represented as [numPassengers, from, to]:
• numPassengers - number of passengers for this trip
• from - pickup location (km east from starting point)
• to - drop-off location (km east from starting point)

Your Goal: Determine if you can complete all trips without ever exceeding your car's passenger capacity. Return true if possible, false otherwise.

Example: With capacity=4 and trips=[[2,1,5],[3,3,7]], you pick up 2 passengers at km 1, then 3 more at km 3 (total 5 > 4), so return false.

Input & Output

example_1.py — Basic Valid Case

$ Input: trips = [[2,1,5],[3,5,7]], capacity = 5

› Output: true

💡 Note: At km 1, pick up 2 passengers (total: 2). At km 5, drop off 2 passengers and pick up 3 passengers (total: 3). Never exceeds capacity of 5.

example_2.py — Capacity Exceeded

$ Input: trips = [[2,1,5],[3,3,7]], capacity = 4

› Output: false

💡 Note: At km 1, pick up 2 passengers (total: 2). At km 3, pick up 3 more passengers (total: 5). This exceeds the capacity of 4.

example_3.py — Overlapping Trips

$ Input: trips = [[3,2,7],[3,7,9],[8,3,9]], capacity = 11

› Output: true

💡 Note: Multiple overlapping trips but total passengers never exceeds 11. Maximum occurs between km 3-7 with 3+8=11 passengers exactly at capacity.

Constraints

1 ≤ trips.length ≤ 1000
trips[i].length == 3
1 ≤ capacity ≤ 10⁵
0 ≤ numPassengers_i ≤ capacity
0 ≤ from_i < to_i ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Map the Route

Identify all pickup and dropoff locations along the eastward highway

Record Events

At each location, note passenger changes (+pickup, -dropoff)

Simulate Journey

Travel chronologically, tracking running passenger count

Check Capacity

Ensure passenger count never exceeds car capacity

Key Takeaway

🎯 Key Insight: We only need to check passenger counts at locations where pickups or drop-offs occur, not every single point along the route. This optimization reduces time complexity significantly for large distance ranges.

Asked in

U Uber 85 L Lyft 72 a Amazon 45 G Google 38

The optimal solution uses a TreeMap/SortedMap approach with O(n log n) time complexity. Record passenger changes at pickup/dropoff locations, then process events chronologically. This avoids checking every single location and only processes locations where actual events occur, making it highly efficient for large distance ranges.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n × max_location)	O(1)	Simulate the journey by checking passenger count at every possible location
TreeMap/SortedMap (Optimal)	O(n log n)	O(n)	Use sorted map to track passenger changes, process events chronologically in one pass
Difference Array (Two Pass)	O(n + max_location)	O(max_location)	Record all passenger changes, then simulate the journey chronologically

Brute Force Simulation — Algorithm Steps

Find the maximum destination among all trips
For each location from 0 to max destination:
Count passengers currently in car (picked up but not dropped off)
If count exceeds capacity, return false
If we complete the journey without exceeding capacity, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max Location

Determine the furthest destination point

Check Each Location

For every location, count active passengers

Validate Capacity

Ensure passenger count never exceeds capacity

Code -

solution.c — C

bool carPooling(int** trips, int tripsSize, int* tripsColSize, int capacity) {
    if (tripsSize == 0) {
        return true;
    }
    
    // Find the maximum destination
    int maxLocation = 0;
    for (int i = 0; i < tripsSize; i++) {
        if (trips[i][2] > maxLocation) {
            maxLocation = trips[i][2];
        }
    }
    
    // Check passenger count at each location
    for (int location = 0; location <= maxLocation; location++) {
        int currentPassengers = 0;
        
        // Count passengers currently in car
        for (int i = 0; i < tripsSize; i++) {
            int numPassengers = trips[i][0];
            int start = trips[i][1];
            int end = trips[i][2];
            
            if (start <= location && location < end) {
                currentPassengers += numPassengers;
            }
        }
        
        // Check if capacity is exceeded
        if (currentPassengers > capacity) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max_location)

For each location (up to max destination), we check all n trips to count active passengers

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

89.2K Views

High Frequency

~15 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler