Minimum Time to Complete Trips

Minimum Time to Complete Trips - Problem

You are given an array time where time[i] denotes the time taken by the i^th bus to complete one trip.

Each bus can make multiple trips successively; that is, the next trip can start immediately after completing the current trip. Also, each bus operates independently; that is, the trips of one bus do not influence the trips of any other bus.

You are also given an integer totalTrips, which denotes the number of trips all buses should make in total. Return the minimum time required for all buses to complete at least totalTrips trips.

Input & Output

Example 1 — Basic Case

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

› Output: 3

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

Example 2 — Slower Buses

$ 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 — Multiple Fast Buses

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

› Output: 4

💡 Note: At time 4: Each of the 3 buses completes 4 trips, totaling 12 trips which exceeds the required 10.

Constraints

1 ≤ time.length ≤ 10⁵
1 ≤ time[i], totalTrips ≤ 10⁷

Visualization

Tap to expand

Asked in

A Amazon 15 G Google 12 M Microsoft 8 F Facebook 6

The key insight is to use binary search on the answer space rather than checking each time unit sequentially. We search for the minimum time where all buses can complete at least the required number of trips. Best approach is binary search on answer space with Time: O(n log(min(time) × totalTrips)), Space: O(1).

Common Approaches

✓ Binary Search on Answer Space

⏱️ Time: O(n * log(min(time) * totalTrips)) Space: O(1)

Instead of checking each time sequentially, use binary search on the answer space. The minimum possible time is 1, and maximum is min(time) * totalTrips. For each candidate time, check if it's sufficient.

Brute Force - Linear Time Search

⏱️ Time: O(min(time) * totalTrips) Space: O(1)

Start from time 1 and increment until we find a time where all buses can complete at least totalTrips trips. For each time t, calculate how many trips each bus can make in time t.

Binary Search on Answer Space — Algorithm Steps

Set left=1, right=min(time)*totalTrips
For mid time, count total possible trips
If trips >= target, search left half, else right half

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Set search bounds: left=1, right=max_possible_time

Check Mid

Test if mid time can complete required trips

Narrow

Adjust bounds based on feasibility

Code -

solution.c — C

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

int canCompleteTrips(int* time, int timeSize, int totalTrips, long long t) {
    long long total = 0;
    for (int i = 0; i < timeSize; i++) {
        total += t / time[i];
        if (total >= totalTrips) return 1;
    }
    return 0;
}

long long solution(int* time, int timeSize, int totalTrips) {
    long long left = 1;
    int minTime = time[0];
    for (int i = 1; i < timeSize; i++) {
        if (time[i] < minTime) minTime = time[i];
    }
    long long right = (long long)minTime * totalTrips;
    
    while (left < right) {
        long long mid = left + (right - left) / 2;
        if (canCompleteTrips(time, timeSize, totalTrips, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int time[100];
    int timeSize = 0;
    parseArray(line, time, &timeSize);
    
    int totalTrips;
    scanf("%d", &totalTrips);
    
    long long result = solution(time, timeSize, totalTrips);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log(min(time) * totalTrips))

Binary search takes log(max_time) iterations, each iteration checks all n buses

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for binary search bounds

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler