Course Schedule III - Practice Coding Problems

Course Schedule III - Problem

Imagine you're a lifelong learner looking to maximize your knowledge by taking as many online courses as possible! 🎓

You have access to n different online courses, each with specific requirements:

Each course i takes exactly duration[i] consecutive days to complete
Each course must be finished by its deadline: lastDay[i]
You start on day 1 and can only take one course at a time

Your goal is to find the maximum number of courses you can successfully complete within their deadlines.

Example: If you have courses [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]], you need to strategically choose which courses to take to maximize your learning!

Input & Output

example_1.py — Basic Case

$ Input: courses = [[100,200],[200,1300],[1000,1250],[2000,3200]]

› Output: 3

💡 Note: We can take 3 courses: [100,200], [200,1300], and [2000,3200]. The course [1000,1250] cannot fit because it would make us miss the deadline for [200,1300].

example_2.py — Impossible Course

$ Input: courses = [[1,2]]

› Output: 1

💡 Note: We can take this single course since 1 day duration fits within the 2-day deadline.

example_3.py — No Courses Possible

$ Input: courses = [[3,2],[4,3]]

› Output: 0

💡 Note: Both courses are impossible to complete - they require more time than their deadlines allow.

Constraints

1 ≤ courses.length ≤ 10⁴
1 ≤ duration_i, lastDay_i ≤ 10⁴
courses[i].length == 2

Visualization

Tap to expand

Understanding the Visualization

Sort by Urgency

List all courses by their deadlines - handle urgent deadlines first

Greedy Selection

Try to take each course, keeping track of total time spent

Strategic Dropping

If you can't meet a deadline, drop your most time-consuming course

Maximize Learning

This ensures you take the maximum number of courses possible

Key Takeaway

🎯 Key Insight: The greedy approach of prioritizing deadlines while strategically dropping the most time-consuming courses ensures we maximize our learning opportunities!

Asked in

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

The optimal solution uses a greedy approach with priority queue. Sort courses by deadline, then process each course: add it to a max-heap and check timing. If the deadline is exceeded, drop the longest course taken so far. This strategy maximizes the number of courses while respecting all deadlines.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy + Priority Queue (Optimal)	O(n log n)	O(n)	Sort by deadline, use max-heap to track durations and drop longest courses when needed
Brute Force (Try All Combinations)	O(2^n × n! × n)	O(n)	Generate all possible course combinations and check which gives maximum courses

Greedy + Priority Queue (Optimal) — Algorithm Steps

Sort all courses by their deadlines (earliest deadline first)
Initialize a max-heap to track durations of selected courses
For each course in sorted order:
Add current course duration to heap and update total time
If total time exceeds current course's deadline:
Remove the longest course from heap (if it's longer than current)
Update total time accordingly
Return the final count of courses in the heap

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Deadline

Sort all courses by their deadlines (earliest first)

Process Each Course

Add course to heap and check if deadline is met

Drop if Needed

If deadline exceeded, drop the longest course taken so far

Maximize Count

This strategy guarantees maximum number of courses

Code -

solution.c — C

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

// Simple max heap implementation
typedef struct {
    int* data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createHeap(int capacity) {
    MaxHeap* heap = (MaxHeap*)malloc(sizeof(MaxHeap));
    heap->data = (int*)malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MaxHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->data[index] <= heap->data[parent]) break;
        swap(&heap->data[index], &heap->data[parent]);
        index = parent;
    }
}

void heapifyDown(MaxHeap* heap, int index) {
    while (2 * index + 1 < heap->size) {
        int maxChild = 2 * index + 1;
        if (2 * index + 2 < heap->size && heap->data[2 * index + 2] > heap->data[maxChild]) {
            maxChild = 2 * index + 2;
        }
        if (heap->data[index] >= heap->data[maxChild]) break;
        swap(&heap->data[index], &heap->data[maxChild]);
        index = maxChild;
    }
}

void push(MaxHeap* heap, int value) {
    heap->data[heap->size] = value;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int pop(MaxHeap* heap) {
    int max = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return max;
}

int compare(const void* a, const void* b) {
    int* courseA = *(int**)a;
    int* courseB = *(int**)b;
    return courseA[1] - courseB[1]; // Sort by deadline
}

int scheduleCourse(int** courses, int coursesSize) {
    // Sort courses by deadline
    qsort(courses, coursesSize, sizeof(int*), compare);
    
    MaxHeap* heap = createHeap(coursesSize);
    int totalTime = 0;
    
    for (int i = 0; i < coursesSize; i++) {
        int duration = courses[i][0];
        int deadline = courses[i][1];
        
        push(heap, duration);
        totalTime += duration;
        
        if (totalTime > deadline) {
            int longestDuration = pop(heap);
            totalTime -= longestDuration;
        }
    }
    
    int result = heap->size;
    free(heap->data);
    free(heap);
    return result;
}

int main() {
    // Example usage
    int course1[] = {100, 200};
    int course2[] = {200, 1300};
    int course3[] = {1000, 1250};
    int course4[] = {2000, 3200};
    int* courses[] = {course1, course2, course3, course4};
    
    printf("%d\n", scheduleCourse(courses, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for heap operations across all courses

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for the heap to store course durations

⚡ Linearithmic Space

95.0K Views

Medium-High Frequency

~25 min Avg. Time

2.8K 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 + Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler