Maximum Energy Boost From Two Drinks - Practice Coding Problems

Maximum Energy Boost From Two Drinks - Problem

Imagine you're a professional athlete preparing for the most important competition of your career! 🏃‍♂️💪

A futuristic sports scientist has provided you with two different energy drinks A and B, each offering varying energy boosts throughout the day. You have n hours to prepare, and you must drink exactly one energy drink per hour to maximize your total energy boost.

Here's the catch: switching between drinks isn't instant! If you want to switch from one energy drink to another, your body needs one full hour to cleanse your system - meaning you get zero energy boost during that transition hour.

Your Goal: Determine the maximum total energy boost you can achieve over n hours. You can start with either drink A or drink B.

Input: Two integer arrays energyDrinkA and energyDrinkB of length n, representing energy boosts per hour.

Output: The maximum total energy boost possible.

Input & Output

example_1.py — Basic case

$ Input: energyDrinkA = [1, 3, 1], energyDrinkB = [3, 1, 1]

› Output: 5

💡 Note: Start with B (3), switch to A in hour 2 but get 0 due to switching penalty, then get A (1) in hour 3. Total: 3 + 0 + 1 = 4. Or start with B (3), continue with B (1), continue with B (1). Total: 3 + 1 + 1 = 5. The maximum is 5.

example_2.py — No switching optimal

$ Input: energyDrinkA = [4, 1, 1], energyDrinkB = [1, 1, 3]

› Output: 7

💡 Note: Start with A (4), switch to B (penalty = 0), then B (3). Total: 4 + 0 + 3 = 7. This beats staying with one drink throughout.

example_3.py — Single hour

$ Input: energyDrinkA = [5], energyDrinkB = [3]

› Output: 5

💡 Note: With only one hour, choose the higher energy drink A with value 5.

Constraints

n == energyDrinkA.length == energyDrinkB.length
1 ≤ n ≤ 10⁵
1 ≤ energyDrinkA[i], energyDrinkB[i] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Initial Choice

Hour 0: Choose between drink A (4 energy) or B (1 energy) - A is better

Continue vs Switch

Hour 1: Continue A (4+1=5) or switch to B (penalty, so just 1) - Continue A

Optimal Decision

Hour 2: Continue A (5+1=6) or switch to B (1+1=2) - Continue A wins

Final Result

Maximum energy achieved: 6 units by staying with drink A throughout

Key Takeaway

🎯 Key Insight: Dynamic programming tracks the optimal energy for each drink choice, efficiently handling the switching penalty by considering both continuation and switching options at each step.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 31

The optimal solution uses dynamic programming to track the maximum energy possible ending with each drink type. At each hour, we calculate the maximum energy by either continuing with the same drink (no penalty) or switching drinks (with one-hour penalty). The key insight is that we only need to maintain two values: maximum energy ending with drink A and maximum energy ending with drink B. This gives us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track maximum energy ending with each drink type
Brute Force (Recursive Exploration)	O(2^n)	O(n)	Try all possible drink sequences with recursion

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP arrays: dpA[i] = max energy ending at hour i with drink A
For each hour, calculate dpA[i] and dpB[i]
Consider continuing same drink (no penalty) vs switching (skip hour penalty)
Return maximum of dpA[n-1] and dpB[n-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with energy from first hour for both drinks

Transition

For each hour, calculate max energy continuing vs switching

Update

Update prevA and prevB with current maximum values

Result

Return maximum of final prevA and prevB

Code -

solution.c — C

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

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

long long maxEnergyBoost(int* energyDrinkA, int* energyDrinkB, int n) {
    if (n == 0) return 0;
    if (n == 1) return max(energyDrinkA[0], energyDrinkB[0]);
    
    long long prevA = energyDrinkA[0];
    long long prevB = energyDrinkB[0];
    
    for (int i = 1; i < n; i++) {
        long long currA = max(
            prevA + energyDrinkA[i],  // Continue with A
            prevB                     // Switch from B to A
        );
        
        long long currB = max(
            prevB + energyDrinkB[i],  // Continue with B
            prevA                     // Switch from A to B
        );
        
        prevA = currA;
        prevB = currB;
    }
    
    return max(prevA, prevB);
}

int main() {
    char line[10000];
    int energyDrinkA[1000], energyDrinkB[1000];
    int n = 0;
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " \n");
    while (token != NULL) {
        energyDrinkA[n] = atoi(token);
        n++;
        token = strtok(NULL, " \n");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, " \n");
    for (int i = 0; i < n && token != NULL; i++) {
        energyDrinkB[i] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%lld\n", maxEnergyBoost(energyDrinkA, energyDrinkB, n));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n hours, constant work per hour

✓ Linear Growth

Space Complexity

O(1)

Only need to track previous hour's maximum energies

✓ Linear Space

23.5K Views

High Frequency

~18 min Avg. Time

847 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