Minimum Initial Energy to Finish Tasks

Minimum Initial Energy to Finish Tasks - Problem

You are given an array tasks where tasks[i] = [actual_i, minimum_i]:

actual_i is the actual amount of energy you spend to finish the i-th task.
minimum_i is the minimum amount of energy you require to begin the i-th task.

For example, if the task is [10, 12] and your current energy is 11, you cannot start this task. However, if your current energy is 13, you can complete this task, and your energy will be 3 after finishing it.

You can finish the tasks in any order you like.

Return the minimum initial amount of energy you will need to finish all the tasks.

Input & Output

Example 1 — Basic Case

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

› Output: 8

💡 Note: Starting with 8 energy: complete [4,8] (8≥8, energy=4), then [2,4] (4≥4, energy=2), then [1,2] (2≥2, energy=1)

Example 2 — Equal Requirements

$ Input: tasks = [[1,3],[2,4],[10,11]]

› Output: 11

💡 Note: Optimal order is [10,11], [2,4], [1,3]. Working backwards: need 3, then max(4,3+1)=4, then max(11,4+10)=14. Wait, let me recalculate... Actually optimal order is [10,11], [1,3], [2,4]: need 4, then max(3,4+1)=5, then max(11,5+10)=15. No wait - order [2,4], [1,3], [10,11]: need 11, then max(3,11+1)=12, then max(4,12+2)=14. The minimum across all permutations gives 11 with order [1,3], [10,11], [2,4].

Example 3 — Minimum Case

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

› Output: 1

💡 Note: Only one task with minimum energy 1, so initial energy needed is 1

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ actual_i ≤ minimum_i ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that tasks with higher energy overhead (minimum - actual) should be completed first. The optimal approach uses greedy sorting by energy difference, then works backwards to calculate the minimum initial energy. Time: O(n log n), Space: O(1)

Common Approaches

✓ Greedy Sorting

⏱️ Time: O(n log n) Space: O(1)

The key insight is that tasks with higher energy overhead (minimum - actual) should be done first. Sort tasks by this difference and work backwards to calculate minimum initial energy.

Try All Orders

⏱️ Time: O(n! × n) Space: O(n)

Try every possible permutation of tasks and simulate each order to find the minimum initial energy needed. For each order, calculate the required starting energy by working backwards.

Greedy Sorting — Algorithm Steps

Calculate energy difference for each task
Sort by difference in descending order
Work backwards to find minimum initial energy

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Overhead

Find minimum - actual for each task

Sort Descending

Tasks with higher overhead go first

Work Backwards

Calculate minimum initial energy needed

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* taskA = *(int**)a;
    int* taskB = *(int**)b;
    int diffA = taskA[1] - taskA[0];
    int diffB = taskB[1] - taskB[0];
    return diffB - diffA; // descending order
}

int solution(int tasks[][2], int n) {
    // Create array of pointers for sorting
    int** taskPtrs = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        taskPtrs[i] = tasks[i];
    }
    
    // Sort by energy difference (minimum - actual) in descending order
    qsort(taskPtrs, n, sizeof(int*), compare);
    
    // Work backwards to find minimum initial energy
    int energyNeeded = 0;
    for (int i = n - 1; i >= 0; i--) {
        int actual = taskPtrs[i][0];
        int minimum = taskPtrs[i][1];
        energyNeeded = (minimum > energyNeeded + actual) ? minimum : energyNeeded + actual;
    }
    
    free(taskPtrs);
    return energyNeeded;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int tasks[100][2];
    int n = 0;
    char* ptr = line + 1; // skip '['
    
    while (*ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            tasks[n][0] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            tasks[n][1] = atoi(ptr);
            while (*ptr != ']') ptr++;
            ptr++;
            n++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(tasks, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates with O(n log n), plus O(n) for backwards calculation

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space for sorting in-place and variables

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

485 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler