##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2589.html

# 2589. Minimum Time to Complete All Tasks

## Description

There is a computer that can run an unlimited number of tasks at the same time. You are given a 2D integer array tasks where tasks[i] = [starti, endi, durationi] indicates that the ith task should run for a total of durationi seconds (not necessarily continuous) within the inclusive time range [starti, endi].

You may turn on the computer only when it needs to run a task. You can also turn it off if it is idle.

Return the minimum time during which the computer should be turned on to complete all tasks.

Example 1:

Input: tasks = [[2,3,1],[4,5,1],[1,5,2]]
Output: 2
Explanation:
- The first task can be run in the inclusive time range [2, 2].
- The second task can be run in the inclusive time range [5, 5].
- The third task can be run in the two inclusive time ranges [2, 2] and [5, 5].
The computer will be on for a total of 2 seconds.


Example 2:

Input: tasks = [[1,3,2],[2,5,3],[5,6,2]]
Output: 4
Explanation:
- The first task can be run in the inclusive time range [2, 3].
- The second task can be run in the inclusive time ranges [2, 3] and [5, 5].
- The third task can be run in the two inclusive time range [5, 6].
The computer will be on for a total of 4 seconds.


Constraints:

• 1 <= tasks.length <= 2000
• tasks[i].length == 3
• 1 <= starti, endi <= 2000
• 1 <= durationi <= endi - starti + 1

## Solutions

• class Solution {
Arrays.sort(tasks, (a, b) -> a - b);
int[] vis = new int;
int ans = 0;
for (int i = start; i <= end; ++i) {
duration -= vis[i];
}
for (int i = end; i >= start && duration > 0; --i) {
if (vis[i] == 0) {
--duration;
ans += vis[i] = 1;
}
}
}
return ans;
}
}

• class Solution {
public:
sort(tasks.begin(), tasks.end(), [&](auto& a, auto& b) { return a < b; });
bitset<2010> vis;
int ans = 0;
for (int i = start; i <= end; ++i) {
duration -= vis[i];
}
for (int i = end; i >= start && duration > 0; --i) {
if (!vis[i]) {
--duration;
ans += vis[i] = 1;
}
}
}
return ans;
}
};

• class Solution:
def findMinimumTime(self, tasks: List[List[int]]) -> int:
vis =  * 2010
ans = 0
for start, end, duration in tasks:
duration -= sum(vis[start : end + 1])
i = end
while i >= start and duration > 0:
if not vis[i]:
duration -= 1
vis[i] = 1
ans += 1
i -= 1
return ans


• func findMinimumTime(tasks [][]int) (ans int) {
vis := int{}
for _, x := range vis[start : end+1] {
duration -= x
}
for i := end; i >= start && duration > 0; i-- {
if vis[i] == 0 {
vis[i] = 1
duration--
ans++
}
}
}
return
}

• function findMinimumTime(tasks: number[][]): number {
tasks.sort((a, b) => a - b);
const vis = new Array(2010).fill(0);
let ans = 0;
for (let [start, end, duration] of tasks) {
for (let i = start; i <= end; ++i) {
duration -= vis[i];
}
for (let i = end; i >= start && duration > 0; --i) {
if (vis[i] === 0) {
--duration;
ans += vis[i] = 1;
}
}
}
return ans;
}