Course Schedule III

Course Schedule III - Problem

There are n different online courses numbered from 1 to n. You are given an array courses where courses[i] = [duration_i, lastDay_i] indicate that the i^th course should be taken continuously for duration_i days and must be finished before or on lastDay_i.

You will start on the 1st day and you cannot take two or more courses simultaneously. Return the maximum number of courses that you can take.

Key points:

Each course has a duration and deadline
Courses must be taken sequentially (no overlap)
Goal is to maximize the number of courses completed
You start on day 1

Input & Output

Example 1 — Basic Scheduling

$ Input: courses = [[100,200],[200,300],[1000,2000]]

› Output: 3

💡 Note: We can take all three courses. Sort by deadline: Course 1 (deadline 200), Course 2 (deadline 300), Course 3 (deadline 2000). Course 1: days 1-100, finishes by day 100 ≤ 200. Course 2: days 101-300, finishes by day 300 ≤ 300. Course 3: days 301-1300, finishes by day 1300 ≤ 2000. All three courses can be completed.

Example 2 — Single Course

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

› Output: 1

💡 Note: Only one course available. Taking it from day 1-1, finishes by day 2, which meets the deadline.

Example 3 — Tight Deadlines

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

› Output: 0

💡 Note: No courses can be completed. First course needs 3 days but deadline is day 2. Second course needs 4 days but deadline is day 3.

Constraints

1 ≤ courses.length ≤ 10⁴
1 ≤ duration_i, lastDay_i ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to sort courses by deadline and use a max heap to track taken courses. When a course can't fit, we replace the longest currently taken course if the new one is shorter. This greedy approach with smart swapping guarantees the optimal solution. Best approach: Greedy with Max Heap. Time: O(n log n), Space: O(n)

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Sort First

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(2^n × n log n) Space: O(n)

Try every possible combination of courses (2^n combinations) and for each combination, check if all courses can be completed within their deadlines. Return the maximum count among valid combinations.

Greedy - Sort by Deadline

⏱️ Time: O(n log n) Space: O(1)

Sort all courses by their deadlines in ascending order. Then iterate through the sorted list and take each course if it can be completed before its deadline, considering the time already spent on previous courses.

Optimal - Greedy with Max Heap

⏱️ Time: O(n log n) Space: O(n)

Sort courses by deadline, then iterate through them. For each course, if it can be taken within deadline, add it to our selection (max heap tracks durations). If it can't fit but has shorter duration than our longest taken course, swap them out.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char* solution(char* order, char* s) {
    int count[256] = {0}; // ASCII character count
    int sLen = strlen(s);
    
    // Count frequency of each character in s
    for (int i = 0; i < sLen; i++) {
        count[(int)s[i]]++;
    }
    
    char* result = (char*)malloc((sLen + 1) * sizeof(char));
    int resultIdx = 0;
    
    // Add characters according to order
    for (int i = 0; order[i]; i++) {
        char c = order[i];
        while (count[(int)c] > 0) {
            result[resultIdx++] = c;
            count[(int)c]--;
        }
    }
    
    // Add remaining characters not in order, maintaining their original relative positions
    for (int i = 0; i < sLen; i++) {
        char c = s[i];
        if (count[(int)c] > 0) {
            result[resultIdx++] = c;
            count[(int)c]--;
        }
    }
    
    result[resultIdx] = '\0';
    return result;
}

int main() {
    char order[1001], s[1001];
    fgets(order, sizeof(order), stdin);
    fgets(s, sizeof(s), stdin);
    order[strcspn(order, "\n")] = 0;
    s[strcspn(s, "\n")] = 0;
    char* result = solution(order, s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

89.0K Views

Medium-High Frequency

~25 min Avg. Time

1.9K 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