Car Pooling - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting events by location, then O(n) to process

⚡ Linearithmic

Space Complexity

O(n)

Map stores at most 2n entries (pickup and drop-off events)

⚡ Linearithmic Space

Constraints

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

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

TreeMap/SortedMap (Optimal) — Algorithm Steps

Create a sorted map to store passenger changes at each location
For each trip, add +passengers at start location and -passengers at end location
Process events in chronological order (sorted by location)
Keep running sum of passengers and check capacity at each event
Return false if capacity exceeded, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Events

Record all pickup (+) and dropoff (-) events

Sort by Location

Process events in chronological order

Running Sum Check

Track passengers and validate capacity

Code -

solution.c — C

#include <stdlib.h>

typedef struct {
    int location;
    int change;
} Event;

int compareEvents(const void* a, const void* b) {
    Event* eventA = (Event*)a;
    Event* eventB = (Event*)b;
    return eventA->location - eventB->location;
}

bool carPooling(int** trips, int tripsSize, int* tripsColSize, int capacity) {
    if (tripsSize == 0) {
        return true;
    }
    
    Event events[2000]; // Max 1000 trips * 2 events each
    int eventCount = 0;
    
    // Record all events
    for (int i = 0; i < tripsSize; i++) {
        int numPassengers = trips[i][0];
        int start = trips[i][1];
        int end = trips[i][2];
        
        // Find or create start event
        int startIdx = -1;
        for (int j = 0; j < eventCount; j++) {
            if (events[j].location == start) {
                startIdx = j;
                break;
            }
        }
        if (startIdx == -1) {
            events[eventCount].location = start;
            events[eventCount].change = numPassengers;
            eventCount++;
        } else {
            events[startIdx].change += numPassengers;
        }
        
        // Find or create end event
        int endIdx = -1;
        for (int j = 0; j < eventCount; j++) {
            if (events[j].location == end) {
                endIdx = j;
                break;
            }
        }
        if (endIdx == -1) {
            events[eventCount].location = end;
            events[eventCount].change = -numPassengers;
            eventCount++;
        } else {
            events[endIdx].change -= numPassengers;
        }
    }
    
    // Sort events by location
    qsort(events, eventCount, sizeof(Event), compareEvents);
    
    // Process events in chronological order
    int currentPassengers = 0;
    for (int i = 0; i < eventCount; i++) {
        currentPassengers += events[i].change;
        if (currentPassengers > capacity) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting events by location, then O(n) to process

⚡ Linearithmic

Space Complexity

O(n)

Map stores at most 2n entries (pickup and drop-off events)

⚡ Linearithmic Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

TreeMap/SortedMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler