Minimum Initial Energy to Finish Tasks - Practice Coding Problems

Minimum Initial Energy to Finish Tasks - Problem

Imagine you're a space explorer with limited energy reserves, and you have a series of critical missions to complete before your journey ends. Each mission has two important characteristics:

actual[i]: The energy you'll actually consume during the mission
minimum[i]: The minimum energy required to even start the mission

Here's the catch: you can choose the order in which to tackle these missions! Your goal is to find the minimum initial energy needed to complete all missions successfully.

Example: If a mission is [10, 12] and you have 11 energy units, you cannot start this mission. But if you have 13 energy units, you can complete it and will have 13 - 10 = 3 energy remaining.

The strategic challenge lies in determining the optimal order to minimize your starting energy requirements.

Input & Output

example_1.py — Basic Case

$ Input: tasks = [[1,2],[2,4],[4,8]]

› Output: 8

💡 Note: Starting with 8 energy: do task 3 (8-4=4 left), then task 2 (4-2=2 left), then task 1 (2-1=1 left). All tasks completed successfully.

example_2.py — Equal Requirements

$ Input: tasks = [[1,3],[2,3],[3,3]]

› Output: 6

💡 Note: All tasks have minimum=3. Start with 6: do task 3 (6-3=3), task 2 (3-2=1), but can't do task 1 (need 3, have 1). So we need more energy initially.

example_3.py — Single Task

$ Input: tasks = [[1,1]]

› Output: 1

💡 Note: Only one task requiring minimum 1 energy and consuming 1 energy. Need exactly 1 energy to start.

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ actual_i ≤ minimum_i ≤ 10⁴
actual_i ≤ minimum_i (you always need at least as much energy as you consume)

Visualization

Tap to expand

Understanding the Visualization

Mission Analysis

Each space mission requires minimum energy to start but only consumes a portion

Strategic Ordering

Missions with higher energy buffers should be prioritized when energy reserves are full

Resource Planning

Work backwards from final mission to determine minimum starting energy reserves needed

Key Takeaway

🎯 Key Insight: By tackling missions with higher energy buffer requirements first (when our reserves are fullest), we minimize the total energy needed to complete all missions successfully.

Asked in

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

The optimal solution uses a greedy sorting approach. The key insight is to sort tasks by their buffer requirement (minimum - actual) in descending order. Tasks with higher buffer requirements should be completed first when we have more energy available. After sorting, we work backwards to calculate the minimum initial energy needed.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Sorting (Optimal)	O(n log n)	O(n)	Sort tasks by (minimum - actual) in descending order, then simulate
Binary Search on Answer	O(n² log(sum))	O(n)	Binary search on the initial energy amount and check feasibility
Brute Force (Try All Permutations)	O(n! × n)	O(n)	Try every possible task order and find the minimum initial energy needed

Greedy Sorting (Optimal) — Algorithm Steps

Calculate (minimum - actual) for each task
Sort tasks in descending order by this difference
Work backwards from the last task to calculate minimum energy
For each task, ensure we have enough energy before starting it

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Buffer

For each task, calculate (minimum - actual)

Sort by Buffer

Sort tasks by buffer requirement (descending)

Work Backwards

Calculate minimum energy working from end to start

Code -

solution.c — C

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

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

int compare(const void* a, const void* b) {
    int* taskA = (int*)a;
    int* taskB = (int*)b;
    // Sort by (minimum - actual) in descending order
    return (taskB[1] - taskB[0]) - (taskA[1] - taskA[0]);
}

int minimumEffort(int tasks[][2], int n) {
    if (n == 0) return 0;
    
    // Sort by (minimum - actual) in descending order
    qsort(tasks, n, sizeof(int[2]), compare);
    
    // Work backwards to calculate minimum starting energy
    int minEnergy = 0;
    
    for (int i = n - 1; i >= 0; i--) {
        int actual = tasks[i][0];
        int minimum = tasks[i][1];
        minEnergy = max(minimum, actual + minEnergy);
    }
    
    return minEnergy;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int tasks[n][2];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &tasks[i][0], &tasks[i][1]);
    }
    
    printf("%d\n", minimumEffort(tasks, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, simulation is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Space for sorting (depending on sort algorithm used)

⚡ Linearithmic Space

52.5K 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

Greedy Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler