Car Fleet

Car Fleet - Problem

There are n cars at given miles away from the starting mile 0, traveling to reach the mile target. You are given two integer arrays position and speed, both of length n, where position[i] is the starting mile of the ith car and speed[i] is the speed of the ith car in miles per hour.

A car cannot pass another car, but it can catch up and then travel next to it at the speed of the slower car. A car fleet is a single car or a group of cars driving next to each other. The speed of the car fleet is the minimum speed of any car in the fleet.

If a car catches up to a car fleet at the mile target, it will still be considered as part of the car fleet. Return the number of car fleets that will arrive at the destination.

Input & Output

Example 1 — Multiple Fleets

$ Input: target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]

› Output: 3

💡 Note: Car at position 10 (speed 2) takes 1.0 time. Car at position 8 (speed 4) takes 1.0 time, joining the first fleet. Car at position 5 (speed 1) takes 7.0 time, forming a new fleet. Cars at positions 3 and 0 join existing fleets based on their arrival times.

Example 2 — Single Fleet

$ Input: target = 10, position = [3], speed = [3]

› Output: 1

💡 Note: Only one car, so it forms one fleet by itself.

Example 3 — No Catching Up

$ Input: target = 100, position = [0,2,4], speed = [4,2,1]

› Output: 1

💡 Note: All cars take 25.0, 49.0, and 96.0 time respectively. The fastest car catches up to others, forming one large fleet.

Constraints

n == position.length == speed.length
1 ≤ n ≤ 10⁵
0 < target ≤ 10⁶
0 ≤ position[i] < target
All the values of position are unique
0 < speed[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 f Facebook 28

The key insight is that cars closer to the target control fleet formation. The optimal approach sorts cars by position and calculates arrival times: (target - position) / speed. Using a monotonic stack or simple iteration, we count fleets by tracking when arrival times increase. Time: O(n log n), Space: O(n)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(n × target) Space: O(n)

For each time unit, move all cars forward and check if any faster car catches up to a slower car ahead. When cars meet, they form a fleet and travel at the slower speed.

Monotonic Stack Approach

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

Sort cars by position, then use a stack to maintain arrival times. The stack represents potential fleet leaders - when a car has longer arrival time, it becomes a new fleet leader.

Sort by Position + Time Calculation

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

Sort cars by their starting position, calculate how long each takes to reach target, then use the fact that cars behind can only catch up if they arrive earlier or at the same time.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

168.4K Views

High Frequency

~25 min Avg. Time

2.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