leetcode-hot100-贪心

621. 任务调度器 - 力扣（LeetCode） (leetcode-cn.com)

• 思路：

1. 贪心策略为：先安排出现次数最多的任务，让这个任务两次执行的时间间隔正好为n。再在这个时间间隔内填充其他的任务。

2. 例如：
   ["A","A","A","B","B","B","A","B","B","B","C","C","C","F","F","E","E"]
   n=5
   

3. 即：4A，6B，3C，2F，2E
   

4. 那么首先安排任务最多的B，按照题目，正在下一个任务调度的时候，如果后面的任务能够弥补上n的空缺，那就弥补，不能就使用n进行弥补。

   

5. 那么根据图可以得知，需要的时间的间隔是[1,1,3,4,5]，那么总计为14，任务执行时间就是4+6+3+2+2=17，总时间为：14+17=31.

```
例如：tasks = ["A","A","A","B","B","B"], n = 2
```

7. 先安排出现次数最多的任务A，并且让两次执行A的时间间隔为n(2)。那么在这个时间间隔内，需要用其他任务类型进行填充，又因为其他任务类型只有一个B，不能够填充2的时间间隔，因此额外需要一个冷却时间间隔。

8. 

   1. maxTimes表示出现次数最多的那个任务出现的次数。
      maxCount表示一共有多少个任务出现次数一样。
      

   2. 图中，一共占用的方格就是所有任务需要的时间，即：

      (maxTimes−1)∗(n+1)+maxCount
      maxTime - 1表示可能下一次执行就没有冷却时间，直接可以执行完毕的
      n + 1表示这次的tasks需要冷却时间
      

   3. 此外，如果任务种类很多，那么此时就不需要冷却时间，只需要在一个任务的两次出现间隔填充其他任务，然后从左到右，从上到下依次执行即可，由于每一个任务占用一个时间代为，又正好使用了tasks中所有的任务，而且我们只使用tasks中的任务来占用方格（没有冷却时间），因此，在这种情况下，所需要的时间就是tasks的长度。

   4. 最后的计算结果和tasks的长度取最大就是最终结果。

• 代码

  class Solution {
      public int leastInterval(char[] tasks, int n) {
          int[] buckets = new int[26];
          //分别记录每次字符出现的次数
          for(int i = 0; i < tasks.length; i++){
              buckets[tasks[i] - 'A']++;
          }
          //[6A,6B,3C,2F,2E]，排序之后就是[2,2,3,6,6]
          Arrays.sort(buckets);
          //排序完成之后，排在最后面的就是出现次数最多的所需要的时间
          int maxTimes = buckets[25];
          //用来统计一共有多少个任务和出现最多的那个任务出现的次数一样的
          int maxCount = 1;
          for(int i = 25; i >= 1; i--){
              if(buckets[i] == buckets[i - 1]){
                  maxCount++;
              }else {
                  break;
              }
          }
          //加1的目的是还需要计算上最开始的任务数
          int res = (maxTimes - 1) * (n + 1) + maxCount;
          //如果任务种类数很多，多到可以不需要冷却时间了，那么只需要在相同任务的间隔填充其他不同的任务
          return Math.max(res, tasks.length);
      }
  }
  

406. 根据身高重建队列 - 力扣（LeetCode） (leetcode-cn.com)

• 本题的解题意图：

  输入: [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
  第二个参数表示前面有几个人的身高是大于等于自己的
  输出:
  [[7, 0]]
  [[7, 0], [7, 1]]
  [[7, 0], [6, 1], [7, 1]]
  [[5, 0], [7, 0], [6, 1], [7, 1]]
  [[5, 0], [7, 0], [5, 2], [6, 1], [7, 1]]
  [[5, 0], [7, 0], [5, 2], [6, 1], [4, 4], [7, 1]]
  

• 思路：

1. 按照从高到低的顺序进行排序，如果碰见两个身高相等的人，那么按照hi为第一关键字降序，ki为第二关键字升序进行排序。

2. 以示例1为例[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]：得到的排序结果就是

   [[7,0],[7,1],[6,1],[5,0],[5,2],[4,4]]。

3. 排序完成之后，创建一个res，用来保存结果。

4. 添加的时候，只需要根据每个人的ki进行插入排序即可，add()参数回顾。
   注：源码中Arrays.sort():
   

• 代码：

  class Solution {
      public int[][] reconstructQueue(int[][] people) {
          Arrays.sort(people, new Comparator<int[]>(){
              public int compare(int[] person1, int[] person2){
                  if(person1[0] != person2[0]){
                  //高的在前面，矮的在后面
                      return person2[0]- person1[0];
                  }else {
                  //高度相同，被插入次数少的在前面
                      return person1[1] - person2[1];
                  }
              }
          });
          List<int[]> res = new ArrayList<>();
          for(int[] person :people){
          //按照每一个人前面是否还有人进行插入
              res.add(person[1], person);
          }
          return res.toArray(new int[res.size()][]);
      }
  }
  

55. 跳跃游戏 - 力扣（LeetCode） (leetcode-cn.com)

• 思路：

1. 设置当前就是起跳点，根据当前位置+能够跳跃的距离之和大于等于数组长度，那么就是可以的。

• 代码：

  class Solution {
      public boolean canJump(int[] nums) {
          int k  = 0;
          for(int i = 0; i <= k; i++){
              k = Math.max(k, i + nums[i]);
              if(k >= nums.length - 1){
                  return true;
              }
          }
          return false;
      }
  }