Minimum Time to Repair Cars

Minimum Time to Repair Cars - Problem

You are given an integer array ranks representing the ranks of some mechanics. ranks[i] is the rank of the i^th mechanic.

A mechanic with a rank r can repair n cars in r × n² minutes.

You are also given an integer cars representing the total number of cars waiting in the garage to be repaired.

Return the minimum time taken to repair all the cars.

Note: All the mechanics can repair the cars simultaneously.

Input & Output

Example 1 — Basic Case

$ Input: ranks = [4,2,3,1], cars = 10

› Output: 16

💡 Note: At time 16: mechanic 1 repairs √(16/4)=2 cars, mechanic 2 repairs √(16/2)=2√2≈2 cars, mechanic 3 repairs √(16/3)≈2 cars, mechanic 4 repairs √(16/1)=4 cars. Total = 2+2+2+4 = 10 cars exactly.

Example 2 — Single Mechanic

$ Input: ranks = [1], cars = 1

› Output: 1

💡 Note: Only one mechanic with rank 1 needs to repair 1 car. Time needed = 1 × 1² = 1 minute.

Example 3 — Multiple Cars per Mechanic

$ Input: ranks = [5,1,8], cars = 6

› Output: 16

💡 Note: At time 16: mechanic 1 repairs √(16/5)≈1 car, mechanic 2 repairs √(16/1)=4 cars, mechanic 3 repairs √(16/8)≈1 car. Total = 1+4+1 = 6 cars.

Constraints

1 ≤ ranks.length ≤ 10⁵
1 ≤ ranks[i] ≤ 100
1 ≤ cars ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is to use binary search on the answer space instead of trying each time value. Since if we can repair all cars in time T, we can also do it in T+1, the problem has a monotonic property perfect for binary search. Best approach is binary search on answer with time complexity O(M × log(T)) where M is number of mechanics and T is the maximum possible time.

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(M × log(T)) Space: O(1)

Instead of trying every time value, binary search on the possible time range. For each mid time, calculate if all cars can be repaired, then narrow the search range accordingly.

Linear Search on Time

⏱️ Time: O(T × M) Space: O(1)

For each possible time t, calculate how many cars each mechanic can repair in that time. Keep incrementing t until the total cars repaired equals or exceeds the target.

Binary Search on Answer — Algorithm Steps

Set left=1, right=max possible time
Binary search: check if mid time can repair all cars
If yes, try smaller time; if no, try larger time

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set search range [1, max_time]

Test Mid

Check if mid time can repair all cars

Narrow

Adjust range based on result until found

Code -

solution.c — C

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

int canRepairInTime(int* ranks, int ranksSize, int cars, long long time) {
    long long totalCars = 0;
    for (int i = 0; i < ranksSize; i++) {
        // Instead of sqrt(time / rank), calculate the largest x where x*x*rank <= time
        long long x = 0;
        while ((x + 1) * (x + 1) * ranks[i] <= time) {
            x++;
        }
        totalCars += x;
        if (totalCars >= cars) return 1;
    }
    return totalCars >= cars;
}

long long solution(int* ranks, int ranksSize, int cars) {
    long long left = 1;
    int minRank = ranks[0];
    for (int i = 1; i < ranksSize; i++) {
        if (ranks[i] < minRank) minRank = ranks[i];
    }
    long long right = (long long)minRank * cars * cars;
    long long result = right;
    
    while (left <= right) {
        long long mid = left + (right - left) / 2;
        if (canRepairInTime(ranks, ranksSize, cars, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

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 ranks[100];
    int ranksSize = 0;
    parseArray(line, ranks, &ranksSize);
    
    int cars;
    scanf("%d", &cars);
    
    printf("%lld\n", solution(ranks, ranksSize, cars));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(M × log(T))

M mechanics × log of max possible time T, where T ≤ min(ranks) × cars²

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for binary search

✓ Linear Space

68.4K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler