这个课题么有专门做过，总觉的急需要总结，又不需要的。
不过，总归是个高频词，不好好搞一下，就算是知识点遗漏了。

455. 分发饼干

用代价最小的饼干，满足最容易满足的（胃最小）的小孩

860. 柠檬水找零

用现有的零钱满足当下

435. 无重叠区间

思路：题目要求去除区间数量最少，反过来考虑就是尽量保持小区间。用贪心思路，可以这么尝试去搞：对原有区间按照左边界，从小到大排序。在最小的左边界，找到同时最小的右边界。
意思是这样的，但是代码写出来，是另一个相近的更好表达的意思：
按照操作过程理解，当找到一个区间[a1, b1]，其上一个区间是 [a0, b0]，如果 两个区间不重叠，则有 b0 <= a1，这时不要删除任何空间；反正需要删除 [a1, b1]。这样就能保证 [a0, b0] 一定是从左开始第一个最小子区间。

  1. var eraseOverlapIntervals = function(intervals) {
  2.     intervals.sort((a, b) => a[0] - b[0]);
  3.     intervals.sort((a, b) => a[1] - b[1]);
  5.     let count = 0;
  6.     let left;
  7.     let right;
  8.     for (let i = 0; i < intervals.length; i++) {
  9.         let [start, end] = intervals[i];
  10.         if (i === 0) {
  11.             left = start;
  12.             right = end;
  13.         } else {
  14.             if (right > start) {
  15.                 count++;
  16.                 continue;
  17.             } else { 
  18.                 left = start;
  19.                 right = end;
  20.             }
  21.         }
  22.     }
  24.     return count;
  25. };

逻辑不变，代码优化：

  1. var eraseOverlapIntervals = function(intervals) {
  2.     intervals.sort((a, b) => a[0] - b[0]);
  3.     intervals.sort((a, b) => a[1] - b[1]);
  5.     let count = 0;
  6.     let left = -Infinity;
  7.     let right = -Infinity;
  8.     for (let i = 0; i < intervals.length; i++) {
  9.         let [start, end] = intervals[i];
  10.         if (right > start) {
  11.             count++;
  12.             continue;
  13.         } else { 
  14.             left = start;
  15.             right = end;
  16.         }
  17.     }
  19.     return count;
  20. };

执行太慢：
image.png

https://leetcode-cn.com/circle/article/LUIqgZ/

881. 救生艇

每个船最多两人，求用最少的船？
最贪心的 => 一个船尽量坐两个人 => 优先安排最重的那个

  1. var numRescueBoats = function(people, limit) {
  2.     let n = people.length;
  3.     people = people.sort((a, b) => a - b);
  4.     if (people[n - 1] > limit) {
  5.         return null; // 船的容量小于最重的人，这活干不了
  6.     }
  7.     if (people[0] === limit) { // 优化点
  8.         return n;
  9.     }
  11.     let light = 0;
  12.     let heavy = n - 1;
  13.     let result = [];
  15.     while (light <= heavy) {
  16.         if (people[light] + people[heavy] <= limit) {
  17.             result.push([people[light], people[heavy]]);
  18.             heavy--;
  19.             light++
  20.         } else {
  21.             result.push([people[heavy]]);
  22.             heavy--;
  23.         }
  24.     }
  26.     return result.length;
  27. };

然而，题目优先考虑最轻的人：
image.png
如果考虑最重的人，要满足两人之和最大，去分配船。
其实无论从最轻还是最重的人考虑，都是要让人两人体重和最大。而从最轻的人考虑更方便，对于体重轻的人，尽量选择体重最大的人，满足贪心的设定。