Course Schedule III
This problem can be solved using a greedy approach. We’ll start by sorting the courses by their end day (lastDayi
). Then, we’ll iterate through the courses, trying to include as many as possible within the constraints. If at any point we find that the current course can’t be finished within its end day, we can swap it with the course that has the longest duration that we’ve already taken.
To manage the courses we have taken, we can use a maxheap data structure, which allows us to easily find and remove the course with the longest duration.
Here’s the code that demonstrates this approach:


The code first sorts the courses by their lastDayi
and then iterates through them, trying to include each one. If a course can’t be finished within its end day and there’s a longer course already taken, we swap them. The result is the maximum number of courses that can be taken, adhering to the given constraints.
The “Course Schedule III” involves sorting and priority queue concepts. Here are some problems to build up the necessary skills:
217. Contains Duplicate: This problem can help you understand basic uses of hash tables.
1046. Last Stone Weight: This problem involves the use of a priority queue to solve a problem.
215. Kth Largest Element in an Array: Understanding how to use a priority queue to find the Kth largest element can be helpful for similar problems.
75. Sort Colors: This problem introduces sorting inplace which is useful to understand.
378. Kth Smallest Element in a Sorted Matrix: The concept of sorting and binary search is well illustrated in this problem.
253. Meeting Rooms II: This problem is similar to Course Schedule III but is simpler, making it a good stepping stone.
1. Two Sum: This problem will help you understand basic hash table manipulation.
692. Top K Frequent Words: This problem combines concepts of sorting, priority queue and hash table.
767. Reorganize String: This problem will give you a good practice of using priority queue in string manipulation.
973. K Closest Points to Origin: It involves the concept of sorting based on custom rules and can help you understand the usage of priority queue in the context of sorting.


Problem Classification
This problem belongs to the domain of ‘Greedy Algorithms’ and ‘Sorting’ in Computer Science and Algorithm Design.
‘What’ Components:
There are ’n’ online courses, each represented by a pair of values indicating the duration of the course and the last day by which the course must be completed.
You can start taking courses from day 1, and you can take only one course at a time.
The task is to find the maximum number of courses you can take.
This is an ‘Optimization Problem’, as the goal is to maximize the number of courses that can be taken under the given constraints. Specifically, it falls under ‘Interval Scheduling Optimization Problems’, where you are asked to schedule tasks or activities (in this case, online courses) subject to time constraints. Here, the time constraints are defined by the duration and the last day to finish each course.
This problem involves decisionmaking at each step (which course to take next), and the decision can greatly influence the final result. Hence, this problem also involves elements of ‘Greedy Algorithms’, where we make what seems to be the best choice at each decision point.
The problem is categorized as ‘Greedy Algorithms’ because the algorithm to solve it would likely involve continuously making a locally optimal choice (the course that ends the earliest or lasts the shortest duration) with the hope that these local optimums will lead to a global optimum (maximum number of courses taken).
‘Sorting’ is also a critical aspect of many greedy problems. In this case, sorting the courses by their end dates or durations can significantly simplify the problem and facilitate the greedy choice at each step.
Finally, as the goal is to optimize (maximize) the number of courses taken under certain constraints, this problem falls under the umbrella of ‘Optimization Problems’.
Scheduling
Identifying Problem Isomorphism
“Course Schedule III” (LeetCode #630) involves prioritizing tasks (in this case, taking courses) based on a certain parameter (the course end day) to maximize the number of tasks that can be accomplished. In this problem, you’re given an array of course pairs where the first element of the pair is the duration of the course and the second is the last day you can start taking the course. The task is to find the maximum number of courses you can take.
A similar problem is “Maximum Number of Events That Can Be Attended” (LeetCode #1353). In this problem, you’re given a list of events where each event has a start time and end time. The goal is to attend as many events as possible, but you can only attend one event at a time.
The isomorphism between these problems lies in the fact that both involve scheduling based on start and end times (or duration and end day) to maximize the number of tasks/events/courses that can be attended or completed.
Here’s the mapping:
 In “Course Schedule III”, each course can be considered as an event in “Maximum Number of Events That Can Be Attended”.
 The duration and end day of a course in “Course Schedule III” map to the start and end time of an event in “Maximum Number of Events That Can Be Attended”.
Though the context of these problems differs (scheduling courses vs. attending events), they share the same core problem of task scheduling based on a start and end parameter to maximize the number of tasks that can be completed. This makes them approximately isomorphic.
Language Agnostic Coding Drills
List Sorting: The ability to sort a list is crucial in many problems. In this case, the courses are sorted based on their last day, which is the second item in each list. Understanding how sorting works and how to use custom sort functions (e.g., sorting by a specific item in a list of lists) is key.
Lambda Functions: A lambda function is a small, anonymous function that is defined on the fly without using the
def
keyword. Here, it is used to define the key for sorting the courses.Arrays and Lists: This includes understanding how to create and manipulate lists, accessing elements, and iterating over elements. Understanding how to work with 2D lists (list of lists) is especially important for this problem.
Heap Data Structure: A heap is a special treebased data structure. This problem uses a maxheap to keep track of the longest duration course in a schedule.
Heap Operations: This includes understanding and implementing various heap operations such as push (heapq.heappush) and pop (heapq.heappop).
Iterating and Updating Variables: This problem involves iterating through the sorted courses, and continuously updating variables to keep track of the current total duration and the maximum number of courses that can be taken.
When combining all these drills, the final solution iteratively adds each course to a heap (which sorts the durations in descending order), and if the total duration exceeds the current course’s last day, it removes the course with the longest duration. The length of the heap at the end gives the maximum number of courses that can be taken.
Targeted Drills in Python
List Sorting
Practice sorting a list of lists. You can start by defining a list of lists and then sort it based on the second element in the sublist.
1 2 3
courses = [[3, 2], [4, 3], [5, 4], [6, 7]] courses.sort(key=lambda c: c[1]) print(courses) # prints: [[3, 2], [4, 3], [5, 4], [6, 7]]
Lambda Functions
Write a lambda function that takes in two arguments and returns their product. Use this lambda function in a
map()
function to get the product of two lists.1 2 3
multiply = lambda x, y: x * y result = map(multiply, [1, 2, 3, 4], [2, 3, 4, 5]) print(list(result)) # prints: [2, 6, 12, 20]
Arrays and Lists
Manipulate 2D lists. For example, you could practice accessing specific elements, slicing lists, and iterating over lists.
1 2 3
courses = [[3, 2], [4, 3], [5, 4], [6, 7]] for course in courses: print(course) # prints each course
Heap Data Structure
Practice creating a heap and adding elements to it. For instance, you can use the
heapq
module in Python to create a heap.1 2 3 4 5 6
import heapq heap = [] heapq.heappush(heap, 3) heapq.heappush(heap, 2) heapq.heappush(heap, 1) print(heap) # prints: [1, 3, 2]
Heap Operations
Practice using the
heapq
module’sheappush
andheappop
operations to add and remove elements from the heap.1 2 3 4 5 6
import heapq heap = [] heapq.heappush(heap, 3) heapq.heappush(heap, 2) heapq.heappush(heap, 1) print(heapq.heappop(heap)) # prints: 1
Iterating and Updating Variables
Create a variable and update its value in a loop. For example, you could increment a variable by 1 in each iteration of a loop.
1 2 3 4
total = 0 for i in range(1, 11): total += i print(total) # prints: 55
When you understand each of these drills, you can use them in combination to solve the problem. The problem involves sorting a list of courses, pushing each course’s duration to a heap, popping off the longest duration if the total duration exceeds the last day of the current course, and then returning the number of courses in the heap.