Codestin Search App

Car Fleet - Problem

Imagine cars racing on a highway toward a finish line! 🏁

There are n cars positioned at different miles from the start (mile 0), all heading toward a target destination. Each car has its own starting position[i] and travels at a constant speed[i] miles per hour.

Here's the twist: Cars cannot overtake each other! If a faster car catches up to a slower one, it must slow down and form a car fleet - traveling together at the speed of the slowest car in the group.

Your mission: Determine how many separate car fleets will arrive at the destination. A fleet can be a single car or multiple cars traveling together.

Key rules:

Cars maintain their lanes (no passing)
When cars meet, they form a fleet at the slower speed
Even if cars meet exactly at the target, they're considered one fleet

Input & Output

example_1.py — Basic Fleet Formation

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

› Output: 3

💡 Note: Car at position 10 (speed 2): time = (12-10)/2 = 1. Car at position 8 (speed 4): time = (12-8)/4 = 1. These form one fleet. Car at position 5 (speed 1): time = (12-5)/1 = 7. Car at position 3 (speed 3): time = (12-3)/3 = 3. Car at position 0 (speed 1): time = (12-0)/1 = 12. Cars at positions 5,3,0 each form separate fleets since faster cars behind cannot catch up.

example_2.py — Single Fleet

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

› Output: 1

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

example_3.py — No Fleet Formation

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

› Output: 1

💡 Note: Car at 0 (speed 4): time = 100/4 = 25. Car at 2 (speed 2): time = 98/2 = 49. Car at 4 (speed 1): time = 96/1 = 96. The fastest car catches up to all others, forming one large fleet.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Cars start at different positions with different speeds, all heading to the same target

Calculate Arrival Times

Each car has a predicted arrival time based on distance and speed

Process from Front

Starting from cars closest to target, check if cars behind can catch up

Fleet Formation

Cars that arrive at same time or later form fleets with slower cars ahead

Key Takeaway

🎯 Key Insight: Sort cars by position and process from closest to target. Cars that take longer to arrive than previous fleets cannot be caught up to, forming new fleets!

Asked in

A Amazon 45 G Google 38 ⊞ Microsoft 28 f Meta 22

The optimal approach uses sorting and stack-based thinking. Sort cars by position (closest to target first), then process each car by calculating its arrival time. If a car takes longer to reach the target than the previous fleet, it forms a new fleet since faster cars behind cannot catch up. This gives us O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n²)	O(n)	For each car, check if it catches up to every other car before reaching target
Sorting + Stack (Optimal)	O(n log n)	O(n)	Sort cars by position, then use stack to track fleets from closest to target

Brute Force (Check All Pairs) — Algorithm Steps

Calculate time to reach target for each car: time = (target - position) / speed
For each pair of cars, check if faster car catches slower car before target
Group cars that will meet into fleets
Count the number of distinct fleets

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Times

Calculate time to reach target for each car

Check Pairs

For each pair, check if faster car catches slower car

Merge Fleets

Group cars that will meet into the same fleet

Count Fleets

Count the number of distinct fleet groups

Code -

solution.c — C

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

typedef struct {
    double pos, time;
    int id;
} Car;

int carFleet(int target, int* position, int* speed, int n) {
    if (n <= 1) return n;
    
    // Calculate time to reach target for each car
    Car* cars = (Car*)malloc(n * sizeof(Car));
    for (int i = 0; i < n; i++) {
        double timeToTarget = (double)(target - position[i]) / speed[i];
        cars[i] = (Car){(double)position[i], timeToTarget, i};
    }
    
    // Create fleet assignments
    int* fleetId = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) fleetId[i] = i;
    
    // Check every pair of cars
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) continue;
            
            // If car i is behind car j and will catch up
            if (cars[i].pos < cars[j].pos && cars[i].time >= cars[j].time) {
                // Merge fleets
                int oldFleet = fleetId[cars[i].id];
                int newFleet = fleetId[cars[j].id];
                for (int k = 0; k < n; k++) {
                    if (fleetId[k] == oldFleet) {
                        fleetId[k] = newFleet;
                    }
                }
            }
        }
    }
    
    // Count unique fleets
    int* seen = (int*)calloc(n, sizeof(int));
    int fleetCount = 0;
    for (int i = 0; i < n; i++) {
        if (!seen[fleetId[i]]) {
            seen[fleetId[i]] = 1;
            fleetCount++;
        }
    }
    
    free(cars);
    free(fleetId);
    free(seen);
    return fleetCount;
}

int main() {
    int target;
    scanf("%d", &target);
    
    // Read position array
    char line[1000];
    scanf(" %[^\n]", line);
    int position[100], speed[100], n = 0;
    
    char* token = strtok(line, " ");
    while (token) {
        position[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    // Read speed array
    scanf(" %[^\n]", line);
    token = strtok(line, " ");
    for (int i = 0; i < n; i++) {
        speed[i] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    printf("%d\n", carFleet(target, position, speed, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each car, we check against all other cars to determine fleet formation

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store fleet assignments for each car

⚡ Linearithmic Space

42.0K Views

High Frequency

~25 min Avg. Time

1.9K 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 (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler