Minimum Time to Complete Trips - Practice Coding Problems

Minimum Time to Complete Trips - Problem

Imagine you're managing a bus terminal where multiple buses operate on different schedules. Each bus has its own trip duration, and they all work independently to serve passengers.

You are given an array time where time[i] represents the time it takes for the i-th bus to complete one round trip. Each bus can immediately start its next trip after finishing the current one, operating continuously without any downtime.

Your goal is to find the minimum time required for all buses combined to complete at least totalTrips trips. Think of it as finding the optimal scheduling point where your bus fleet achieves the required service level.

Example: If you have buses with trip times [1, 2, 3] and need 5 total trips, you need to find when the combined trips from all buses first reaches or exceeds 5.

Input & Output

example_1.py — Basic Case

$ Input: time = [1, 2, 3], totalTrips = 5

› Output: 3

💡 Note: At time 3: Bus 1 completes 3 trips, Bus 2 completes 1 trip, Bus 3 completes 1 trip. Total = 5 trips.

example_2.py — Single Bus

$ Input: time = [2], totalTrips = 1

› Output: 2

💡 Note: Only one bus that takes 2 time units per trip. To complete 1 trip, we need exactly 2 time units.

example_3.py — Multiple Identical Buses

$ Input: time = [5, 5, 5], totalTrips = 9

› Output: 15

💡 Note: At time 15: each bus completes 3 trips (15/5 = 3), so total is 3 × 3 = 9 trips.

Visualization

Tap to expand

Understanding the Visualization

Initialize Fleet

Set up buses with their respective trip times

Binary Search Setup

Establish search bounds for possible completion times

Test Time Points

For each candidate time, calculate total possible trips

Narrow Search

Adjust bounds based on whether target is achievable

Find Minimum

Converge to the earliest time meeting requirements

Key Takeaway

🎯 Key Insight: The monotonic property (if time T works, then T+1 also works) enables binary search, reducing time complexity from O(T*n) to O(n*log(T)) where T is the answer.

Time & Space Complexity

Time Complexity

⏱️

O(T * n)

T is the minimum time needed (could be very large), n is number of buses

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ time.length ≤ 10⁵
1 ≤ time[i], totalTrips ≤ 10⁷
All buses operate independently and continuously
Answer will fit in a 64-bit signed integer

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 🍎 Apple 22

The optimal solution uses binary search on the answer space. Since the problem has a monotonic property (if we can complete enough trips by time T, we can do it by any time > T), we can binary search for the minimum valid time. The search space is [1, min(time) * totalTrips], and for each candidate time, we calculate the total trips possible and adjust our search bounds accordingly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Time Search)	O(T * n)	O(1)	Check every time unit until we find enough trips
Binary Search on Answer (Optimal)	O(n * log(min(time) * totalTrips))	O(1)	Binary search the answer space to find minimum time efficiently

Brute Force (Linear Time Search) — Algorithm Steps

Start with current_time = 1
For each time point, calculate trips completed by each bus
Sum up all trips and check if >= totalTrips
If yes, return current time; otherwise increment time

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Time 1

Begin checking from time = 1

Count Trips

For each bus, calculate trips completed

Check Target

See if total trips >= target

Increment Time

Move to next time unit if not enough

Code -

solution.c — C

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

long long minimumTimeToCompleteTrips(int* time, int timeSize, int totalTrips) {
    long long currentTime = 1;
    
    while (1) {
        long long totalCompleted = 0;
        for (int i = 0; i < timeSize; i++) {
            totalCompleted += currentTime / time[i];
        }
        
        if (totalCompleted >= totalTrips) {
            return currentTime;
        }
        
        currentTime++;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(T * n)

T is the minimum time needed (could be very large), n is number of buses

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ time.length ≤ 10⁵
1 ≤ time[i], totalTrips ≤ 10⁷
All buses operate independently and continuously
Answer will fit in a 64-bit signed integer

68.2K Views

Medium Frequency

~15 min Avg. Time

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Time Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler