Minimum Time to Complete All Tasks

Minimum Time to Complete All Tasks - Problem

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.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Task 1 needs 1 second in [2,3], task 2 needs 3 seconds in [2,5]. Optimal: run at times 2,3,4,5 for total 4 seconds.

Example 2 — Single Task

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

› Output: 2

💡 Note: One task needs 2 seconds within [1,3]. We can run at any 2 time points, minimum runtime is 2.

Example 3 — Non-overlapping

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

› Output: 2

💡 Note: Tasks don't overlap in time windows. Need 1 second for each task, total runtime is 2.

Constraints

1 ≤ tasks.length ≤ 2000
tasks[i].length == 3
1 ≤ starti ≤ endi ≤ 2000
1 ≤ durationi ≤ tasks[i][1] - tasks[i][0] + 1

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

This problem requires finding the minimum computer runtime to complete all tasks. The key insight is to use a greedy approach: sort tasks by end time and schedule them as late as possible to maximize overlap opportunities. Best approach uses interval merging for optimal results. Time: O(n log n), Space: O(k).

Common Approaches

✓ Brute Force Enumeration

⏱️ Time: O(2^(n*m)) Space: O(n*m)

For each task, try all possible ways to schedule its required duration within its time window. Generate all combinations and find the one with minimum total computer runtime.

Greedy Scheduling

⏱️ Time: O(n log n + n*m) Space: O(m)

Sort tasks by their end times and process them in order. For each task, schedule it as late as possible within its time window to maximize potential overlap with future tasks.

Optimal Greedy with Interval Merging

⏱️ Time: O(n log n + n*k) Space: O(k)

Sort tasks by end time and use a more sophisticated greedy strategy. Instead of just scheduling late, we maintain intervals of used time and try to minimize total coverage by smart interval merging.

Brute Force Enumeration — Algorithm Steps

Generate all possible schedules for each task
For each combination, calculate total runtime
Return minimum runtime found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Schedules

For each task, generate all possible ways to fit duration in time window

Test Combinations

Try every combination of task schedules

Find Minimum

Return the combination with minimum total computer runtime

Code -

solution.c — C

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

#define MAX_TASKS 1000
#define MAX_TIME 10000

typedef struct {
    int start;
    int end;
    int duration;
} Task;

static int occupied[MAX_TIME];

int compare(const void *a, const void *b) {
    Task *ta = (Task *)a;
    Task *tb = (Task *)b;
    return ta->end - tb->end;
}

int solution(Task tasks[], int n) {
    if (n == 0) {
        return 0;
    }
    
    // Sort tasks by end time (greedy approach)
    qsort(tasks, n, sizeof(Task), compare);
    
    memset(occupied, 0, sizeof(occupied));
    
    for (int i = 0; i < n; i++) {
        int start = tasks[i].start;
        int end = tasks[i].end;
        int duration = tasks[i].duration;
        
        // Count how many slots this task already has scheduled
        int alreadyScheduled = 0;
        for (int t = start; t <= end; t++) {
            if (occupied[t]) {
                alreadyScheduled++;
            }
        }
        
        // Schedule remaining duration as late as possible
        int needToSchedule = duration - alreadyScheduled;
        
        // Go backwards from end to start, scheduling in available slots
        for (int t = end; t >= start; t--) {
            if (needToSchedule <= 0) {
                break;
            }
            if (!occupied[t]) {
                occupied[t] = 1;
                needToSchedule--;
            }
        }
    }
    
    // Count total occupied slots
    int total = 0;
    for (int i = 0; i < MAX_TIME; i++) {
        if (occupied[i]) {
            total++;
        }
    }
    
    return total;
}

void parseTaskArray(const char* str, Task tasks[], int* count) {
    *count = 0;
    const char* p = str;
    
    // Find first opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != '\0') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\r') p++;
        
        if (*p == '[') {
            p++; // Skip opening bracket
            
            // Parse start
            while (*p == ' ') p++;
            tasks[*count].start = (int)strtol(p, (char**)&p, 10);
            
            // Skip comma
            while (*p == ' ' || *p == ',') p++;
            
            // Parse end
            tasks[*count].end = (int)strtol(p, (char**)&p, 10);
            
            // Skip comma
            while (*p == ' ' || *p == ',') p++;
            
            // Parse duration
            tasks[*count].duration = (int)strtol(p, (char**)&p, 10);
            
            (*count)++;
            
            // Skip to closing bracket
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }
    
    Task tasks[MAX_TASKS];
    int count = 0;
    
    parseTaskArray(line, tasks, &count);
    
    printf("%d\n", solution(tasks, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n*m))

For each task, we have exponentially many ways to schedule it within its time window

⚡ Linearithmic

Space Complexity

O(n*m)

Store all possible scheduling combinations

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

856 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

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler