Minimum Speed to Arrive on Time - Practice Coding Problems

Minimum Speed to Arrive on Time - Problem

Imagine you're planning your daily commute to work, and you must catch exactly n trains in sequence to reach your office. Each train travels a specific distance, but here's the catch: all trains can only depart at integer hours (1:00, 2:00, 3:00, etc.).

You're given:

A floating-point number hour representing your total time budget to reach the office
An integer array dist where dist[i] is the distance (in km) of the ith train ride

Key Constraint: If a train ride finishes at a non-integer time (like 1.3 hours), you must wait until the next integer hour to board the next train. However, the last train can arrive at any time within your budget.

Goal: Find the minimum positive integer speed (km/h) that allows all trains to travel fast enough for you to reach the office within the given time limit. Return -1 if it's impossible.

Example: If you have trains with distances [1, 3, 2] and hour = 6.0, at speed 1 km/h: Train 1 takes 1 hour (depart at 0:00, arrive at 1:00), Train 2 takes 3 hours (depart at 1:00, arrive at 4:00), Train 3 takes 2 hours (depart at 4:00, arrive at 6:00). Total time = 6 hours ✓

Input & Output

example_1.py — Basic case

$ Input: dist = [1,3,2], hour = 6.0

› Output: 1

💡 Note: At speed 1: Train 1 takes 1 hour (0→1), wait until hour 1. Train 2 takes 3 hours (1→4), wait until hour 4. Train 3 takes 2 hours (4→6). Total: 6 hours exactly.

example_2.py — Requires higher speed

$ Input: dist = [1,3,2], hour = 2.7

› Output: 3

💡 Note: At speed 3: Train 1 takes 1/3 hour, rounded up to 1 hour. Train 2 takes 1 hour. Train 3 takes 2/3 hour. Total: 1 + 1 + 0.67 = 2.67 ≤ 2.7

example_3.py — Impossible case

$ Input: dist = [1,1,100000], hour = 2.01

› Output: -1

💡 Note: We need at least 2 integer hours for the first 2 trains, leaving only 0.01 hours for the last train of distance 100000. This is impossible at any speed.

Visualization

Tap to expand

Understanding the Visualization

Check Feasibility

If we need more integer hours than our total budget, it's impossible

Set Search Range

Search speeds from 1 to 10^7 km/h

Binary Search

Test middle speed and narrow down based on whether it works

Calculate Travel Time

For each speed: sum of ceil(dist[i]/speed) for first n-1 trains + dist[n-1]/speed

Key Takeaway

🎯 Key Insight: This problem demonstrates the power of binary search on answer spaces. When we can efficiently check if a candidate solution works and the problem has monotonic properties, binary search reduces time complexity from O(S × n) to O(log S × n).

Time & Space Complexity

Time Complexity

⏱️

O(S × n)

Where S is the maximum possible speed (10^7) and n is number of trains. We might check up to 10^7 speeds, and for each speed we calculate time for n trains.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current speed and time calculations

✓ Linear Space

Constraints

n == dist.length
1 ≤ n ≤ 10⁵
1 ≤ dist[i] ≤ 10⁵
1 ≤ hour ≤ 10⁹
hour will have at most two digits after the decimal point
The answer is guaranteed to not exceed 10⁷

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 Apple 4

The optimal solution uses binary search to efficiently find the minimum speed. Since higher speeds always result in shorter travel times, we can search the range [1, 10⁷] and test each candidate speed in O(log S × n) time, much faster than the brute force O(S × n) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(S × n)	O(1)	Try every speed from 1 to 10^7 until we find one that works
Binary Search (Optimal)	O(n log S)	O(1)	Binary search on the speed since higher speeds always result in shorter times

Brute Force (Linear Search) — Algorithm Steps

Check if it's even possible (sum of distances > hour means impossible)
Try each speed from 1 to 10^7
For each speed, calculate total time: sum of ceiling(dist[i]/speed) for first n-1 trains + dist[n-1]/speed for last train
Return first speed where total time ≤ hour

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Speed 1

Calculate total time with speed 1 km/h

Try Speed 2

Calculate total time with speed 2 km/h

Continue...

Keep trying higher speeds until total time ≤ hour

Code -

solution.c — C

#include <stdio.h>
#include <math.h>

int minSpeedOnTime(int* dist, int distSize, double hour) {
    int n = distSize;
    
    // Impossible case: need at least n-1 integer hours for first n-1 trains
    if (n - 1 >= hour) {
        return -1;
    }
    
    // Try each speed from 1 to 10^7
    for (int speed = 1; speed <= 10000000; speed++) {
        double totalTime = 0;
        
        // Calculate time for first n-1 trains (must wait for integer hours)
        for (int i = 0; i < n - 1; i++) {
            totalTime += ceil((double) dist[i] / speed);
        }
        
        // Add time for last train (can arrive at any time)
        totalTime += (double) dist[n - 1] / speed;
        
        if (totalTime <= hour) {
            return speed;
        }
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(S × n)

Where S is the maximum possible speed (10^7) and n is number of trains. We might check up to 10^7 speeds, and for each speed we calculate time for n trains.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current speed and time calculations

✓ Linear Space

Constraints

n == dist.length
1 ≤ n ≤ 10⁵
1 ≤ dist[i] ≤ 10⁵
1 ≤ hour ≤ 10⁹
hour will have at most two digits after the decimal point
The answer is guaranteed to not exceed 10⁷

23.4K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler