leetcode 630. Course Schedule III（课程表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.

安排课程的问题，数组中包含[t, d]，t表示每门课的时间，d表示这门课的deadline

思路：
按理说做事情要先做deadline近的，如果先做deadline宽松的，做完了那么deadline近的就危险了，所以先按deadline的顺序排序
Input: [100, 200], [200, 1300], [1000, 1250], [2000, 3200],[1900, 3200]
排好后：[100, 200], [1000, 1250], [200, 1300], [2000, 3200], [1900, 3200]

前三个都没有问题，t=1300，第三门的deadline也是1300
但是t+2000后变成了3300 > 3200, 倒数第二门课显然是上不了，但是是有机会上最后一门课的，这时候应该怎么办，应该从前面的课中去掉一个耗时最长的，这样才能留下更大的buffer
就需要把刚才耗时最长的2000去掉，这样就可以上最后一门1900课时的课了

也就是greedy的方法
deadline先考虑近的
满足不了条件的时候先舍弃耗时长的，因为我们追求的是课的数量

**顺便说下java版lambda函数
比如Arrays.sort(courses, (a, b) ->{return a[1] - b[1];});
这里的courses的每一个元素是int[]类型的，所以a，b不指定类型也可以推测出来是int[]
{}里面语句也是要；结尾
PriorityQueue queue = new PriorityQueue<>((a, b)->Integer.compare(b,a));
因为优先队列是Integer类型的，所以a，b也不需要明确指定类型，推测出是Integer

    public int scheduleCourse(int[][] courses) {
        int time = 0;
        
        Arrays.sort(courses, (a, b)->Integer.compare(a[1], b[1]));
        PriorityQueue<Integer> heap = new PriorityQueue<>(Collections.reverseOrder());
        
        for(int[] course : courses) {
            int duration = course[0];
            int end = course[1];
            time += duration;
            heap.add(duration);
            
            if(time > end) {
                time -= heap.poll();            
            }
        }
        return heap.size();
    }

改进一下时间效率，判断 < 截止时间时才加进去，在heap中去掉最大时间时仍然超过截止时间时放弃当前course。

public int scheduleCourse(int[][] courses) {
    int time = 0;
    
    Arrays.sort(courses, (a, b)->Integer.compare(a[1], b[1]));
    PriorityQueue<Integer> heap = new PriorityQueue<>(Collections.reverseOrder());
    
    for(int[] course : courses) {
        int duration = course[0];
        int end = course[1];
        if(time + duration <= end) {
            time += duration;
            heap.add(duration);
        } else if (!heap.isEmpty() && duration < heap.peek()) {
            time += (duration - heap.poll());
            heap.add(duration);
        }
        
    }
    return heap.size();
}