Minimum Hours of Training to Win a Competition

Minimum Hours of Training to Win a Competition - Problem

Array Greedy Easy

You're preparing for an epic tournament where you'll face n opponents in sequence! 🏆

Starting with initialEnergy and initialExperience, you need to strategically train before the competition begins. Each opponent i has specific energy[i] and experience[i] values.

Victory Conditions: To defeat an opponent, you must have strictly greater energy AND experience than them.

Battle Mechanics:

✅ Win: Gain experience[i] points, lose energy[i] points
❌ Lose: Game over - you can't proceed to the next opponent

Training Rules: Each training hour lets you increase either your initial energy OR initial experience by 1.

Goal: Find the minimum training hours needed to defeat all opponents consecutively.

Input & Output

example_1.py — Basic Competition

$ Input: initialEnergy = 5, initialExperience = 3, energy = [1,4,3,2], experience = [2,6,3,1]

› Output: 8

💡 Note: You need 8 training hours total. Train energy to 11 (6 hours) and experience to 5 (2 hours) to defeat all opponents: Op1(1,2), Op2(4,6), Op3(3,3), Op4(2,1).

example_2.py — Minimal Training

$ Input: initialEnergy = 2, initialExperience = 4, energy = [1], experience = [3]

› Output: 0

💡 Note: You already have enough stats (2 > 1 energy and 4 > 3 experience) to defeat the single opponent, so no training is needed.

example_3.py — High Experience Opponent

$ Input: initialEnergy = 10, initialExperience = 2, energy = [5], experience = [10]

› Output: 9

💡 Note: You need to train experience from 2 to 11 (9 hours) to have strictly greater experience than the opponent's 10. Your energy of 10 is already sufficient.

Constraints

n == energy.length == experience.length
1 ≤ n ≤ 100
1 ≤ initialEnergy, initialExperience ≤ 100
1 ≤ energy[i], experience[i] ≤ 100
All values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Analyze the Quest Chain

Look at all bosses you must defeat in order

Plan Energy Training

Work backwards to ensure you have enough stamina for the entire quest

Plan Experience Training

Simulate the quest forward, accounting for XP gains after each victory

Execute Optimal Training

Train just enough to guarantee victory with minimum time investment

Key Takeaway

🎯 Key Insight: Energy and experience can be optimized separately since energy decreases while experience increases during battles, allowing us to use a greedy approach for both!

Asked in

G Google 12 a Amazon 18 f Meta 8 ⊞ Microsoft 6

The optimal greedy solution works in O(n) time by recognizing that energy and experience can be calculated independently. Calculate minimum energy by working backwards through opponents, then calculate minimum experience by simulating forward. The key insight is that energy decreases after each battle while experience increases, allowing separate optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Two-Pass Solution (Optimal)	O(n)	O(1)	Calculate minimum energy needed working backwards, then minimum experience working forwards
Brute Force Simulation	O(h²×n)	O(1)	Try all possible training combinations until we find one that works

Greedy Two-Pass Solution (Optimal) — Algorithm Steps

Work backwards through opponents to calculate minimum energy needed at start
Simulate forward through opponents to calculate minimum experience needed
Calculate training hours needed for both energy and experience
Return the sum of training hours needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Backwards Energy Pass

Calculate minimum energy needed at each step

Forward Experience Pass

Simulate and calculate experience training needed

Combine Results

Sum up energy and experience training requirements

Code -

solution.c — C

#include <stdio.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int trainingTime(int initialEnergy, int initialExperience, int* energy, int* experience, int n) {
    // Calculate minimum energy needed by working backwards
    int minEnergy = 1; // Need at least 1 energy at the end
    for (int i = n - 1; i >= 0; i--) {
        minEnergy = max(energy[i] + 1, minEnergy + energy[i]);
    }
    
    // Calculate minimum experience needed by simulating forward
    int currExp = initialExperience;
    int expTraining = 0;
    for (int i = 0; i < n; i++) {
        if (currExp <= experience[i]) {
            int needed = experience[i] + 1 - currExp;
            expTraining += needed;
            currExp += needed;
        }
        currExp += experience[i];
    }
    
    // Calculate energy training needed
    int energyTraining = max(0, minEnergy - initialEnergy);
    
    return energyTraining + expTraining;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make two passes through the opponent arrays

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for calculations

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Greedy Two-Pass Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler