Car Pooling

Car Pooling - Problem

Array Sorting Heap (Priority Queue) Simulation Prefix Sum Medium

There is a car with capacity empty seats. The vehicle only drives east (i.e., it cannot turn around and drive west).

You are given the integer capacity and an array trips where trips[i] = [numPassengers_i, from_i, to_i] indicates that the i^th trip has numPassengers_i passengers and the locations to pick them up and drop them off are from_i and to_i respectively.

The locations are given as the number of kilometers due east from the car's initial location.

Return true if it is possible to pick up and drop off all passengers for all the given trips, or false otherwise.

Input & Output

Example 1 — Exceeds Capacity

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

› Output: false

💡 Note: At kilometer 2, we have 2 passengers from trip 1 and 3 passengers from trip 2, totaling 5 passengers which exceeds capacity 4.

Example 2 — Within Capacity

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

› Output: true

💡 Note: Maximum passengers at any point is 5 (at km 2), which equals the capacity, so it's possible.

Example 3 — Sequential Trips

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

› Output: true

💡 Note: At km 3-7: 11 passengers (3+8), km 7-9: 11 passengers (3+8). Maximum is 11 which equals capacity 11.

Constraints

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

Visualization

Tap to expand

Asked in

U Uber 45 L Lyft 38 a Amazon 32 G Google 28

The key insight is to track passenger count changes at each location rather than simulating every kilometer. The optimal approach uses difference array technique for O(n + max_location) time complexity. For sparse locations, event-based sorting works better at O(n log n).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n × max_location) Space: O(1)

For each kilometer from start to end, count how many passengers should be in the car by iterating through all trips. This simulates the actual journey step by step.

Bucket Array (Difference Array)

⏱️ Time: O(n + max_location) Space: O(max_location)

Create an array representing all possible locations. Use difference array technique to efficiently apply passenger changes for trip ranges, then compute prefix sum to get actual passenger counts.

Event-Based Simulation

⏱️ Time: O(n log n) Space: O(n)

Create pickup and dropoff events, sort them by location, then process events in order while tracking current passenger count. This avoids checking every kilometer.

Brute Force Simulation — Algorithm Steps

Find the maximum location from all trips
For each kilometer, count passengers from active trips
Check if count exceeds capacity

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Journey

Begin at km 0, check all trips

Check Each KM

Count active passengers at each point

Validate Capacity

Ensure count never exceeds limit

Code -

solution.c — C

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

bool solution(int trips[][3], int tripCount, int capacity) {
    if (tripCount == 0) return true;
    
    int maxLocation = 0;
    for (int i = 0; i < tripCount; i++) {
        if (trips[i][2] > maxLocation) {
            maxLocation = trips[i][2];
        }
    }
    
    for (int km = 0; km <= maxLocation; km++) {
        int currentPassengers = 0;
        for (int i = 0; i < tripCount; i++) {
            if (trips[i][1] <= km && km < trips[i][2]) {
                currentPassengers += trips[i][0];
            }
        }
        
        if (currentPassengers > capacity) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for trips array
    int trips[100][3];
    int tripCount = 0;
    
    char* ptr = strchr(line, '[');
    ptr++; // Skip first [
    
    while (ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            sscanf(ptr, "%d,%d,%d", &trips[tripCount][0], &trips[tripCount][1], &trips[tripCount][2]);
            tripCount++;
            ptr = strchr(ptr, ']');
            if (ptr) ptr++;
        } else {
            ptr++;
        }
    }
    
    int capacity;
    scanf("%d", &capacity);
    
    bool result = solution(trips, tripCount, capacity);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max_location)

For each location up to max_location, we check all n trips

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current passenger count

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~15 min Avg. Time

892 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