Minimum Time to Complete All Tasks - Practice Coding Problems

Minimum Time to Complete All Tasks - Problem

Imagine you're managing a smart computer that can run unlimited tasks simultaneously, but you want to minimize its power consumption by turning it on only when absolutely necessary.

You're given a list of tasks where each task is represented as [start_time, end_time, duration]. This means:

Task i must run for exactly duration[i] seconds
It can only run within the time window [start_time[i], end_time[i]]
The task doesn't need to run continuously - it can be split across multiple time segments

Goal: Find the minimum total time the computer needs to be powered on to complete all tasks.

Key insight: Tasks can overlap in time, and when they do, the computer can work on multiple tasks simultaneously without additional power cost!

Input & Output

basic_example.py — Python

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

› Output: 3

💡 Note: Task 1 needs 1 unit in [2,3], Task 2 needs 1 unit in [4,5], Task 3 needs 2 units in [1,5]. Optimal schedule: run at times 3,4,5. Task 1 uses time 3, Task 3 uses times 4,5, Task 2 uses time 5 (overlaps with Task 3). Total: 3 time units.

overlap_example.py — Python

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

› Output: 4

💡 Note: Task 1 needs 2 units in [1,3], Task 2 needs 3 units in [2,5], Task 3 needs 1 unit in [5,6]. Schedule: Task 1 at times 2,3; Task 2 at times 3,4,5; Task 3 at time 5. Total unique times: 2,3,4,5 = 4 units.

single_task.py — Python

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

› Output: 1

💡 Note: Only one task requiring 1 unit of time in window [7,10]. Computer needs to run for exactly 1 time unit (can pick any time from 7 to 10).

Constraints

1 ≤ tasks.length ≤ 2000
1 ≤ start_i ≤ end_i ≤ 2000
1 ≤ duration_i ≤ end_i - start_i + 1
Key constraint: Each task's duration cannot exceed its time window length

Visualization

Tap to expand

Understanding the Visualization

Input Tasks

Each task has a time window [start, end] and required duration

Sort by Deadline

Process tasks in order of earliest deadline first

Schedule Late

For each task, assign time slots as late as possible in its window

Maximize Overlap

Later tasks can reuse already-scheduled time slots

Key Takeaway

🎯 Key Insight: By sorting tasks by deadline and scheduling each task as late as possible in its window, we maximize opportunities for time slot sharing between overlapping tasks, minimizing total computer runtime.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 25

The optimal solution uses a greedy approach with sorting. Sort tasks by end time, then for each task, schedule its required duration as late as possible within its time window. This maximizes overlap opportunities with future tasks, minimizing total computer runtime. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(max_time * n))	O(max_time)	Try all possible time assignments for each task and find minimum total time
Greedy with Sorting (Optimal)	O(n log n + n * max_time)	O(max_time)	Sort tasks by end time and greedily schedule as late as possible

Brute Force (Try All Combinations) — Algorithm Steps

For each task, generate all possible time slot assignments within its valid range
For each combination of assignments, calculate total computer-on time
Track the minimum time across all valid combinations
Return the minimum total time found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

For each task, generate all possible ways to assign its required duration within its time window

Test Each Combination

For every combination of task assignments, calculate total computer-on time

Find Minimum

Track and return the combination that requires minimum total computer time

Code -

solution.c — C

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

#define MAX_TASKS 100
#define MAX_TIME 1000

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

int used_time[MAX_TIME];
int remaining[MAX_TASKS];
Task tasks[MAX_TASKS];
int num_tasks;

int count_used_time() {
    int count = 0;
    for (int i = 0; i < MAX_TIME; i++) {
        if (used_time[i]) count++;
    }
    return count;
}

int all_zero() {
    for (int i = 0; i < num_tasks; i++) {
        if (remaining[i] != 0) return 0;
    }
    return 1;
}

int backtrack(int task_idx) {
    if (task_idx == num_tasks) {
        if (all_zero()) {
            return count_used_time();
        }
        return INT_MAX;
    }
    
    int start = tasks[task_idx].start;
    int end = tasks[task_idx].end;
    int duration = tasks[task_idx].duration;
    int min_time = INT_MAX;
    
    // Simplified brute force - try all combinations
    // This is a simplified version due to C's limitations
    for (int mask = 0; mask < (1 << (end - start + 1)); mask++) {
        int count = 0;
        for (int i = 0; i < (end - start + 1); i++) {
            if (mask & (1 << i)) count++;
        }
        
        if (count == duration) {
            // Apply this assignment
            int time_slots[MAX_TIME];
            memcpy(time_slots, used_time, sizeof(used_time));
            
            for (int i = 0; i < (end - start + 1); i++) {
                if (mask & (1 << i)) {
                    time_slots[start + i] = 1;
                }
            }
            
            memcpy(used_time, time_slots, sizeof(used_time));
            remaining[task_idx] = 0;
            
            int result = backtrack(task_idx + 1);
            if (result < min_time) {
                min_time = result;
            }
            
            // Backtrack
            remaining[task_idx] = duration;
        }
    }
    
    return min_time;
}

int solution() {
    memset(used_time, 0, sizeof(used_time));
    for (int i = 0; i < num_tasks; i++) {
        remaining[i] = tasks[i].duration;
    }
    
    int result = backtrack(0);
    return result == INT_MAX ? 0 : result;
}

int main() {
    // Example input
    num_tasks = 3;
    tasks[0] = (Task){2, 3, 1};
    tasks[1] = (Task){4, 5, 1};
    tasks[2] = (Task){1, 5, 2};
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(max_time * n))

For each task and each possible time unit, we have binary choice (run or not)

✓ Linear Growth

Space Complexity

O(max_time)

Need to track time slots being used across all tasks

✓ Linear Space

42.8K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler