贪心算法

贪心算法

406.根据身高重建队列

• 题目描述：假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

• 思路：可以先将people数组由大到小进行排序，然后将矮个子的人插入到高个子里。高个子先站好位，矮个子插入到第K个位置上，前面肯定有K个高个子，再有矮个子插到前面也满足前面有K个高个子的要求。（先排序，后插入）

  class Solution {
      public static int[][] reconstructQueue(int[][] people) {
            Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]);
  
          LinkedList<int[]> list = new LinkedList<>();
          for (int[] i : people) {
              list.add(i[1], i);
          }
          return list.toArray(new int[list.size()][2]);
      }
  }
  

• 收获： Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]);重写了 Comparator<int[]>() 比较器，其中o1 - o2代表升序，o2 - o1代表降序，且o2代表的是数组中靠前的元素，o1代表的是数组中靠后的元素（和我想的有些许出入）；LinkedList.add()方法是用的前插法添加元素的，刚好可以用来插入排序（以后要用到插入就可以想到LinkedList）。

452.用最少数量的箭引爆气球

• 题目描述：在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

• 思路： 贪心算法里的区间问题，一般的解决方法是先将区间数组按上限进行有小到大的排序，然后用前一个区间的上限和后一个区间的下限比较，看是否有交集存在。

  class Solution {
      public int findMinArrowShots(int[][] points) {
          if(points == null || points.length == 0){
              return 0;
          }
          Arrays.sort(points, new Comparator<int[]>() {
              @Override
              public int compare(int[] a, int[] b) {
                  if(a[1] > b[1]){
                      return 1;
                  }else if(a[1] < b[1]){
                      return -1;
                  }else {
                      return 0;
                  }
              }
          });
          int count = 1;
          int index = points[0][1];
          for (int i = 1; i < points.length; i++) {
              if (index < points[i][0]){
                  index = points[i][1];
                  count++;
              }
          }
          return count;  
      }
  }
  

• 收获： 这里有个注意点是这里不可以直接用Arrays.sort(points , (o1 , o2) -> o1[1] - o2[1])相减，因为示例里有一个集合是{{-2147483646,-2147483645},{2147483646,2147483647}}直接减会越界的，排序结果会相反。传入数组非法也是需要考虑的。

605.种花问题

• 题目描述：假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false。

• 思路： 用的连跳两格的方法，因为如果遇到1的格子,那么下一个格子一定是0，这是毋庸置疑的（规则限定），所以如果遇到当前格子是0，且是最后一个格子，或者下个格子不是1的，果断填充；否则连跳3格（连跳2格的话左边的格子还是1）。只要可以填充的数量大于等于输入的n即可。（跳格子）

  class Solution {
      public boolean canPlaceFlowers(int[] flowerbed, int n) {
          int count = 0;
          int i = 0;
          while(i < flowerbed.length){
              if(flowerbed[i] == 1){
                  i += 2;
              }else{
                  if(i == flowerbed.length - 1 || flowerbed[i + 1] == 0){
                      count++;
                      i += 2;
                  }else if(flowerbed[i + 1] == 1){
                      i += 3;
                  }
              }
          }
          return n <= count;
      }
  }
  

• 收获： 像这种题，n根本无所谓，只要求出可以种植花的最大个数，最大个数大于等于n就满足条件了，本质还是贪心求最多可以种多少朵，不要被题目所迷惑了。