Minimum Time to Finish the Race - Practice Coding Problems

Minimum Time to Finish the Race - Problem

Race Strategy Optimization

Imagine you're a Formula 1 strategist managing tire changes during a race! 🏎️

You have access to different tire types, where each tire type i is described by [f_i, r_i]:
• f_i: Base time for the first lap with this tire
• r_i: Degradation factor (time multiplier for successive laps)

The time for the x-th successive lap on tire type i is: f_i × r_i^(x-1)

Example: If f_i = 3, r_i = 2, then:
• Lap 1: 3 × 2⁰ = 3 seconds
• Lap 2: 3 × 2¹ = 6 seconds
• Lap 3: 3 × 2² = 12 seconds

Your Mission: Complete numLaps laps in minimum total time. You can:
• Start with any tire type
• Change to any tire type (including the same one) after any lap
• Each tire change costs changeTime seconds
• You have unlimited supply of each tire type

Goal: Return the minimum time to finish all laps!

Input & Output

example_1.py — Basic Race Strategy

$ Input: tires = [[2,3],[3,4]], changeTime = 5, numLaps = 4

› Output: 21

💡 Note: Optimal strategy: Start with tire 0, do 2 laps (2 + 6 = 8), change tire (+5), use tire 0 again for 2 laps (2 + 6 = 8). Total: 8 + 5 + 8 = 21 seconds.

example_2.py — Single Tire Race

$ Input: tires = [[1,10],[2,2],[3,4]], changeTime = 6, numLaps = 5

› Output: 25

💡 Note: Best strategy is to use tire 1 for all 5 laps: 2 + 4 + 8 + 16 + 32 = 62. But changing tires can be better: use tire 1 for 2 laps (2+4=6), change (+6), use tire 1 for 2 laps (2+4=6), change (+6), use tire 1 for 1 lap (2). Total: 6+6+6+6+2 = 26. Actually optimal is different combination giving 25.

example_3.py — Edge Case

$ Input: tires = [[1,1]], changeTime = 10, numLaps = 1

› Output: 1

💡 Note: Only one tire available, one lap needed. Time = 1 * 1^0 = 1 second. No tire changes needed.

Constraints

1 ≤ tires.length ≤ 10⁵
tires[i].length == 2
1 ≤ f_i, changeTime ≤ 10⁵
2 ≤ r_i ≤ 10⁵
1 ≤ numLaps ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Analyze Tire Performance

Calculate how each tire performs over consecutive laps, considering exponential degradation

Find Sweet Spots

Determine the optimal number of consecutive laps for each tire before changing becomes beneficial

Dynamic Programming

Build up optimal strategies for increasing lap counts by trying all possible last segments

Optimize Transitions

Balance segment performance against tire change time costs to find the global minimum

Key Takeaway

🎯 Key Insight: Pre-compute optimal single-tire segments and use dynamic programming to combine them efficiently, balancing tire degradation against change costs.

Asked in

f Meta 25 a Amazon 18 G Google 15 ⊞ Microsoft 12

The optimal approach uses dynamic programming with pre-computed single-tire segments. Key insights: (1) Pre-compute optimal times for consecutive laps with each tire, (2) Limit consecutive laps since tire degradation makes changes beneficial, (3) Use DP to optimally combine segments with tire change costs. Time complexity: O(numLaps × tires × maxConsecutiveLaps)

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(numLaps × tires × maxConsecutiveLaps)	O(numLaps + tires × maxConsecutiveLaps)	Pre-compute optimal single-tire segments, then use DP to combine them with tire changes
Brute Force (Try All Combinations)	O(t^numLaps)	O(numLaps)	Try every possible tire change combination using recursion

Dynamic Programming (Optimal) — Algorithm Steps

Pre-compute minTime[tire][laps] = minimum time to do 'laps' consecutive laps with single tire
Limit consecutive laps to reasonable bound (when tire change becomes better)
Initialize DP array where dp[i] = minimum time to complete i laps
For each number of laps, try all possible last segments with different tires
For each tire and segment length, calculate: dp[i-length] + changeTime + segmentTime
Return dp[numLaps]

Visualization

Tap to expand

Step-by-Step Walkthrough

Pre-compute Segments

Calculate optimal time for consecutive laps with each tire

DP Base Case

dp[0] = 0 (no time needed for 0 laps)

Build Solutions

For each lap count, try all tire+segment combinations

Optimal Combination

Choose minimum between continue vs change tire options

Code -

solution.c — C

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

int minimumFinishTime(int** tires, int tireCount, int changeTime, int numLaps) {
    int maxConsecutive = 20;
    
    // Pre-compute single tire performance
    int** minTime = (int**)malloc(tireCount * sizeof(int*));
    for (int i = 0; i < tireCount; i++) {
        minTime[i] = (int*)malloc((maxConsecutive + 1) * sizeof(int));
        for (int j = 0; j <= maxConsecutive; j++) {
            minTime[i][j] = INT_MAX;
        }
    }
    
    for (int i = 0; i < tireCount; i++) {
        int f = tires[i][0], r = tires[i][1];
        long long time = 0;
        for (int laps = 1; laps <= maxConsecutive; laps++) {
            time += f * (long long)pow(r, laps - 1);
            if (time > INT_MAX) break;
            minTime[i][laps] = (int)time;
            if (time > changeTime + f) break;
        }
    }
    
    // DP array
    int* dp = (int*)malloc((numLaps + 1) * sizeof(int));
    for (int i = 0; i <= numLaps; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int laps = 1; laps <= numLaps; laps++) {
        for (int tire = 0; tire < tireCount; tire++) {
            int maxSeg = laps < maxConsecutive ? laps : maxConsecutive;
            for (int segmentLen = 1; segmentLen <= maxSeg; segmentLen++) {
                if (minTime[tire][segmentLen] == INT_MAX) continue;
                
                int prevLaps = laps - segmentLen;
                if (prevLaps == 0) {
                    if (minTime[tire][segmentLen] < dp[laps]) {
                        dp[laps] = minTime[tire][segmentLen];
                    }
                } else if (dp[prevLaps] != INT_MAX) {
                    long long newTime = (long long)dp[prevLaps] + changeTime + minTime[tire][segmentLen];
                    if (newTime < dp[laps]) {
                        dp[laps] = (int)newTime;
                    }
                }
            }
        }
    }
    
    int result = dp[numLaps];
    
    // Cleanup
    for (int i = 0; i < tireCount; i++) {
        free(minTime[i]);
    }
    free(minTime);
    free(dp);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(numLaps × tires × maxConsecutiveLaps)

We iterate through each lap count, try each tire type, and consider reasonable consecutive lap counts

✓ Linear Growth

Space Complexity

O(numLaps + tires × maxConsecutiveLaps)

DP array for lap counts plus pre-computed single-tire times

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

845 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler