贪心算法：分糖果问题、主持人调度(二)

一、分糖果问题

1.1 题目

1.2 题解

【解法一】：两次遍历

思路：

代码：

 public int candy (int[] arr) {
      if(arr==null|| arr.length==0) return 0;

      int[] left=new int[arr.length];
      int[] right=new int[arr.length];
      left[0]=1;
      for(int i=1;i<arr.length;i++){
          if(arr[i]>arr[i-1]){
              left[i]=left[i-1]+1;
          }else {
              left[i]=1;
          }
      }
      right[arr.length-1]=1;
      for(int i=arr.length-2;i>=0;i--){
          if(arr[i]>arr[i+1]){
              right[i]=right[i+1]+1;
          }else {
              right[i]=1;
          }
      }
      int ret=0;
      for(int i=0;i<arr.length;i++){
          if(left[i]>right[i]){
              ret+=left[i];
          }else {
              ret+=right[i];
          }
      }
      return ret;
    }

【解法二】：一次遍历

对于i号小朋友应该分几个糖果，可以分成一下几种情况讨论

1. 如果arr[i]==arr[i-1]，那么i号分1个糖果即可

2. 如果arr[i]>arr[i-1]，那么i号得到的糖果应该比i-1号多一个

3. 如果arr[i]<arr[i-1]，此时i号该得到几个糖果，我们无法直接获知，因为我们并不直到当前i号所处的递减序列的长度

   我们直接分配给当前同学一个糖果，分配糖果的数量根据当前的递减序列长度而定，注意当当前的递减序列长度和上一个递增序列等长时，需要把最近的递增序列的最后一个同学也并进递减序列中。

代码：

   public int candy (int[] arr) {
      if(arr==null|| arr.length==0) return 0;
       int ret=1;
       int pre=1;
       int inc=1;
       int dec=0;
       for(int i=1;i<arr.length;i++){
           if(arr[i]>=arr[i-1]){ 
             dec=0;
             pre=arr[i]==arr[i-1]?1:pre+1;
             ret+=pre;
             inc=pre;
           }else {
              dec++;
              if(dec==inc) dec++;
              ret+=dec;
               pre=1;
           }
       }
      return ret;
    }

二、主持人调度(二)

2.1 题目

2.2 题解

思路：对二维数组排序，重写比较方法，如果两个活动的开始时间相同，那么根据结束时间进行排序，否则按照开始时间排序，判断各个活动的时间是否交叉，如果交叉需要增加主持人的个数，否则不需增加主持人的个数

具体步骤：
堆中元素的个数，代表所需的主持人数目

step1：对二维数组进行排序
step2：小根堆中保存的是活动的结束时间，堆顶元素代表还未结束的将要最快结束的活动的结束时间。
step3：将Integer.MIN_VALUE加入堆中，遍历后续活动，如果当前活动的开始时间大于堆顶元素的结束时间，说明主持人数目无需增加，将堆顶元素弹出，加入当前活动的结束时间
step4：如果当前活动的开始时间小于堆顶元素的结束时间，说明应该增加主持人数目，将当前活动的结束时间加入堆中

代码：

  public  static int minmumNumberOfHost (int n, int[][] startEnd) {
        if(n==0 || startEnd.length==0) return 0;
        Arrays.sort(startEnd, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]==o2[0]){
                    return  o1[1]-o2[1];
                }else {
                    return o1[0]-o2[0];
                }
            }
        });
        PriorityQueue<Integer> queue=new PriorityQueue<>();
        queue.offer(Integer.MIN_VALUE);
        for(int i=0;i<n;i++){
            if(startEnd[i][0]>=queue.peek()){
                queue.poll();
            }
            queue.offer(startEnd[i][1]);
        }
        return  queue.size();
    }