1665. Minimum Initial Energy to Finish Tasks

/**
 * Problem: LeetCode 1665 - Minimum Initial Energy to Finish Tasks
 * Difficulty: Hard
 * Language: Java
 * Author: CodeByTushu
 */
import java.util.Arrays;

class Solution {
    public int minimumEffort(int[][] tasks) {
        // Sort tasks descending by (minimum - actual)
        // Prioritizing tasks with larger surplus energy (minimum - actual) minimizes overall starting energy
        Arrays.sort(tasks, (a, b) -> (b[1] - b[0]) - (a[1] - a[0]));

        int initialEnergy = 0;
        int currentEnergy = 0;

        for (int[] task : tasks) {
            int actual = task[0];
            int minimum = task[1];

            if (currentEnergy < minimum) {
                initialEnergy += (minimum - currentEnergy);
                currentEnergy = minimum;
            }
            currentEnergy -= actual;
        }

        return initialEnergy;
    }
}

"""
Problem: LeetCode 1665 - Minimum Initial Energy to Finish Tasks
Difficulty: Hard
Language: Python
Author: CodeByTushu
"""
from typing import List

class Solution:
    def minimumEffort(self, tasks: List[List[int]]) -> int:
        # Sort tasks descending by (minimum - actual)
        # Prioritizing tasks with larger surplus energy (minimum - actual) minimizes overall starting energy
        tasks.sort(key=lambda t: t[1] - t[0], reverse=True)

        initial_energy = 0
        current_energy = 0

        for actual, minimum in tasks:
            if current_energy < minimum:
                initial_energy += minimum - current_energy
                current_energy = minimum
            current_energy -= actual

        return initial_energy

/**
 * Problem: LeetCode 1665 - Minimum Initial Energy to Finish Tasks
 * Difficulty: Hard
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    int minimumEffort(vector<vector<int>>& tasks) {
        // Sort tasks descending by (minimum - actual)
        // Prioritizing tasks with larger surplus energy (minimum - actual) minimizes overall starting energy
        sort(tasks.begin(), tasks.end(), [](const vector<int>& a, const vector<int>& b) {
            return (a[1] - a[0]) > (b[1] - b[0]);
        });

        int initialEnergy = 0;
        int currentEnergy = 0;

        for (const auto& task : tasks) {
            int actual = task[0];
            int minimum = task[1];

            if (currentEnergy < minimum) {
                initialEnergy += (minimum - currentEnergy);
                currentEnergy = minimum;
            }
            currentEnergy -= actual;
        }

        return initialEnergy;
    }
};

/**
 * Problem: LeetCode 1665 - Minimum Initial Energy to Finish Tasks
 * Difficulty: Hard
 * Language: JavaScript
 * Author: CodeByTushu
 */
var minimumEffort = function(tasks) {
    // Sort tasks descending by (minimum - actual)
    // Prioritizing tasks with larger surplus energy (minimum - actual) minimizes overall starting energy
    tasks.sort((a, b) => (b[1] - b[0]) - (a[1] - a[0]));

    let initialEnergy = 0;
    let currentEnergy = 0;

    for (let i = 0; i < tasks.length; i++) {
        const actual = tasks[i][0];
        const minimum = tasks[i][1];

        if (currentEnergy < minimum) {
            initialEnergy += (minimum - currentEnergy);
            currentEnergy = minimum;
        }
        currentEnergy -= actual;
    }

    return initialEnergy;
};