Last updated on August 3rd, 2024 at 10:10 pm

Here, We see ** Course Schedule III LeetCode Solution**. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

*List of all LeetCode Solution*

*List of all LeetCode Solution*

## Topics

Greddy

## Level of Question

Hard

**Course Schedule III LeetCode Solution**

## Table of Contents

**Problem Statement**

There are `n`

different online courses numbered from `1`

to `n`

. You are given an array `courses`

where `courses[i] = [duration`

indicate that the _{i}, lastDay_{i}]`i`

course should be taken ^{th}**continuously** for `duration`

days and must be finished before or on _{i}`lastDay`

._{i}

You will start on the `1`

day and you cannot take two or more courses simultaneously.^{st}

Return *the maximum number of courses that you can take*.

**Example 1:****Input:** courses = [[100,200],[200,1300],[1000,1250],[2000,3200]] **Output:** 3

**Explanation:** There are totally 4 courses, but you can take 3 courses at most:

First, take the 1st course, it costs 100 days so you will finish it on the 100th day, and be ready to take the next course on the 101^{st} day.

Second, take the 3^{rd} course, it costs 1000 days so you will finish it on the 1100^{th} day, and ready to take the next course on the 1101^{st} day.

Third, take the 2^{nd} course, it costs 200 days so you will finish it on the 1300^{th} day.

The 4^{th} course cannot be taken now, since you will finish it on the 3300^{th} day, which exceeds the closed date.

**Example 2:****Input:** courses = [[1,2]] **Output:** 1

**Example 3:****Input:** courses = [[3,2],[4,3]] **Output:** 0

**1. Course Schedule III LeetCode Solution C++**

class Solution { public: int scheduleCourse(vector<vector<int>>& courses) { sort(courses.begin(), courses.end(), [](vector<int> a, vector<int> b){return a[1] < b[1];}); priority_queue<int> heap; int now = 0; for (int i = 0; i < courses.size(); ++ i) { heap.push(courses[i][0]); now += courses[i][0]; if (now > courses[i][1]) now -= heap.top(), heap.pop(); } return heap.size(); } };

**2. Course Schedule III LeetCode Solution Java**

class Solution { public int scheduleCourse(int[][] courses) { Arrays.sort(courses, (a,b) -> a[1] - b[1]); PriorityQueue<Integer> pq = new PriorityQueue<>((a,b) -> b - a); int total = 0; for (int[] course : courses) { int dur = course[0], end = course[1]; if (dur + total <= end) { total += dur; pq.add(dur); } else if (pq.size() > 0 && pq.peek() > dur) { total += dur - pq.poll(); pq.add(dur); } } return pq.size(); } }

**3. Course Schedule III LeetCode Solution JavaScript**

var scheduleCourse = function(courses) { courses.sort((a,b) => a[1] - b[1]) let total = 0, pq = new MaxPriorityQueue({priority: x => x}) for (let [dur, end] of courses) if (dur + total <= end) total += dur, pq.enqueue(dur) else if (pq.front() && pq.front().element > dur) total += dur - pq.dequeue().element, pq.enqueue(dur) return pq.size() };

**4. Course Schedule III LeetCode Solution Python**

class Solution(object): def scheduleCourse(self, courses): heap, total = [], 0 for dur, end in sorted(courses, key=lambda el: el[1]): if dur + total <= end: total += dur heappush(heap, -dur) elif heap and -heap[0] > dur: total += dur + heappop(heap) heappush(heap, -dur) return len(heap)