[Leetcode] 630. Course Schedule III 解题报告

题目：

There are n different online courses numbered from 1 to n. Each course has some duration(course length) t and closed on dth day. A course should be taken continuously for t days and must be finished before or on the dth day. You will start at the 1st day.

Given n online courses represented by pairs (t,d), your task is to find the maximal number of courses that can be taken.

Example:

Input: [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]]
Output: 3
Explanation: 
There're 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 ready to take the next course on the 101st day.
Second, take the 3rd course, it costs 1000 days so you will finish it on the 1100th day, and ready to take the next course on the 1101st day. 
Third, take the 2nd course, it costs 200 days so you will finish it on the 1300th day. 
The 4th course cannot be taken now, since you will finish it on the 3300th day, which exceeds the closed date.

Note:

1. The integer 1 <= d, t, n <= 10,000.
2. You can't take two courses simultaneously.

思路：

又是一道很难的题目。基本思路还是贪心策略。我们首先按照课程的最晚结束时间排序，因为越需要早点结束的课程我们就越优先安排。然后就遍历课程，并安排当前课程。一旦发现安排了当前课程之后，其结束时间超过了最晚结束时间，那么我们就从已经安排的课程中，取消掉一门最耗时的课程。这样当遍历完成之后，已经安排的课程就是最终可以安排的课程。

为了方便地在已经安排的课程中取消掉一门最耗时的课程，我们采用优先队列这种数据结构来维护当前已安排课程，这样可以保证每次都取消掉最耗时的课程。算法的时间复杂度是O(nlogn)，空间复杂度是O(k)，k <= n，k是最终可以选择的最大课程数。这种空间复杂度我记得好像叫做“输出敏感性”的。

代码：

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;                    // the current day
        for (int i = 0; i < courses.size(); ++i) {
            heap.push(courses[i][0]);   // push the time cost of courses[i]
            now += courses[i][0];
            if (now > courses[i][1]) {  // exceeds the deadlines, so we remove the one that is most time-consuming
                now -= heap.top();
                heap.pop();
            }
        }
        return heap.size();
    }
};