Car Fleet II - Practice Coding Problems

Car Fleet II - Problem

Imagine a futuristic highway where self-driving cars travel in perfect formation! You have n cars on a single-lane road, each with different starting positions and speeds. Here's the twist: when faster cars catch up to slower ones, they don't just stop - they merge into a fleet and continue together at the speed of the slowest car!

Given an array cars where cars[i] = [position_i, speed_i]:

Position: Distance from the start of the road (guaranteed that cars are sorted by position)
Speed: Initial speed in meters per second

Goal: For each car, calculate when it will collide with the next car ahead, or return -1 if no collision occurs.

Key Rules:

Cars can only move forward and catch up to cars ahead
When cars collide, they form a fleet moving at the slowest car's speed
You need to account for chain reactions of collisions!

Input & Output

example_1.py — Basic Collision

$ Input: cars = [[1,2],[2,1],[4,3],[7,2]]

› Output: [1.0, -1, 3.0, -1]

💡 Note: Car 0 (pos=1, speed=2) catches Car 1 (pos=2, speed=1) in 1 second. Car 1 won't catch anyone. Car 2 (pos=4, speed=3) catches Car 3 (pos=7, speed=2) in 3 seconds. Car 3 is the last car.

example_2.py — Chain Reaction

$ Input: cars = [[3,4],[5,4],[6,3],[9,1]]

› Output: [2.0, 1.0, 1.5, -1]

💡 Note: Car 1 catches Car 2 in 1 second, forming a fleet at speed 3. Car 0 then catches this fleet in 2 seconds. Car 2 catches Car 3 in 1.5 seconds.

example_3.py — No Collisions

$ Input: cars = [[1,1],[2,2],[3,3]]

› Output: [-1, -1, -1]

💡 Note: Each car is faster than the car behind it, so no collisions occur. Cars maintain their spacing forever.

Visualization

Tap to expand

Understanding the Visualization

Setup

Cars are positioned on highway, each with different speeds

Process Right-to-Left

Start from the rightmost car and work backwards

Stack Management

Maintain a stack of cars that could be collision targets

Collision Calculation

For each car, find the earliest valid collision time

Chain Reaction Handling

Account for how fleet formations affect future collisions

Key Takeaway

🎯 Key Insight: Cars only collide with the next 'collision boundary' ahead, not arbitrary cars. Use a monotonic stack to efficiently track these boundaries!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each car is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n cars in worst case

⚡ Linearithmic Space

Constraints

1 ≤ cars.length ≤ 10⁵
1 ≤ position_i, speed_i ≤ 10⁶
position_i < position_i+1 (cars are sorted by position)
Important: Answers within 10^-5 of actual answers are accepted

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses a monotonic stack to process cars from right to left in O(n) time. Key insight: each car only needs to consider the next 'collision boundary' ahead, not all cars. The stack maintains potential collision targets, and we eliminate cars that become unreachable due to chain collisions.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use a monotonic stack to efficiently track collision events from right to left
Brute Force Simulation	O(n²)	O(1)	Simulate time step by step until all possible collisions occur

Monotonic Stack (Optimal) — Algorithm Steps

Process cars from right to left (reverse order)
Maintain a stack of cars that are potential collision targets
For each car, pop from stack cars that won't be collision targets
Calculate collision time with the remaining car on top of stack
Add current car to stack if it could be a target for previous cars

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Stack

Start from rightmost car, maintain stack of potential collision targets

Process Each Car

For each car, remove invalid targets from stack

Calculate Collision

Find collision time with remaining valid target

Update Stack

Add current car to stack for future cars to consider

Code -

solution.c — C

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

typedef struct {
    int* data;
    int top;
    int capacity;
} Stack;

Stack* createStack(int capacity) {
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    stack->data = (int*)malloc(capacity * sizeof(int));
    stack->top = -1;
    stack->capacity = capacity;
    return stack;
}

void push(Stack* stack, int item) {
    stack->data[++stack->top] = item;
}

int pop(Stack* stack) {
    return stack->data[stack->top--];
}

int peek(Stack* stack) {
    return stack->data[stack->top];
}

int isEmpty(Stack* stack) {
    return stack->top == -1;
}

double* getCollisionTimes(int** cars, int carsSize, int* returnSize) {
    *returnSize = carsSize;
    double* result = (double*)malloc(carsSize * sizeof(double));
    Stack* stack = createStack(carsSize);
    
    for (int i = 0; i < carsSize; i++) {
        result[i] = -1;
    }
    
    // Process cars from right to left
    for (int i = carsSize - 1; i >= 0; i--) {
        // Remove cars from stack that current car can't catch
        while (!isEmpty(stack)) {
            int j = peek(stack);
            // If current car is slower or equal, it can't catch car j
            if (cars[i][1] <= cars[j][1]) {
                break;
            }
            
            // If current car will catch car j before car j catches its target
            double collisionTime = (double)(cars[j][0] - cars[i][0]) / (cars[i][1] - cars[j][1]);
            if (result[j] == -1 || collisionTime <= result[j]) {
                result[i] = collisionTime;
                break;
            }
            
            // Car j will be caught by its target before current car catches it
            pop(stack);
        }
        
        // Add current car to stack for future cars to consider
        push(stack, i);
    }
    
    free(stack->data);
    free(stack);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each car is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n cars in worst case

⚡ Linearithmic Space

Constraints

1 ≤ cars.length ≤ 10⁵
1 ≤ position_i, speed_i ≤ 10⁶
position_i < position_i+1 (cars are sorted by position)
Important: Answers within 10^-5 of actual answers are accepted

27.5K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler