逐步解析力扣1705. 吃苹果的最大数目（优先队列的补充学习）

https://leetcode-cn.com/problems/maximum-number-of-eaten-apples/

官方解法用到了贪心 + 优先队列

先学习下优先队列

优先队列的数据结构

PriorityQueue里的元素是有序的，默认情况下是单调增，可以通过传入Comparator根据自己的需求来更改。

在概念上，它是一个有序的二叉树，这种顺序的规则是（默认情况下），每个节点的值都比它的孩子节点的值小。一个最小堆如下图所示：

只要符合每个节点的值都比它的孩子节点小即可。

在实现上，它使用数组来存储。因为该最小堆的是完全二叉树，所以按照每层从左向右的顺序存储，那么节点下标为 n 的孩子节点分别（2n+1）和（2n+2）为如上图的存储方式为：

应用场景

数据的操作为每次需要取最大值或最小值时

继承图

优先队列的插入
为了保持PriorityQueue元素的有序性，在进行插入时，我们总是对插入后的数组做调整，这种调整的方式如下：

• 首先将新增元素放到队尾
• 将插入元素与它的父节点比较，如果父节点比元素大，将元素与父节点元素调换位置
• 继续将该元素与父节点比较，直到该元素为根节点或比父节点的元素大为止
  

优先队列的使用

常用方法
1.add(e)、offer(e)
将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，offer(E)方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
2.element()、peek()
element()和peek()的语义完全相同，都是获取但不删除队首元素，也就是队列中权值最小的那个元素，二者唯一的区别是当方法失败时前者抛出异常，后者返回null。根据小顶堆的性质，堆顶那个元素就是全局最小的那个；由于堆用数组表示，根据下标关系，0下标处的那个元素既是堆顶元素。所以直接返回数组0下标处的那个元素即可。
3.remove()、poll()
remove()和poll()方法的语义也完全相同，都是获取并删除队首元素，区别是当方法失败时前者抛出异常，后者返回null。由于删除操作会改变队列的结构，为维护小顶堆的性质，需要进行必要的调整。

例子：

Comparator<Node> cmp = new Comparator<Node>() {
	public int compare(Node a, Node b) { //这里是小根堆
	if (a.key == b.key) return a.sec - b.sec; //第二键值做参考
		return a.key - b.key; //第一键值做参考
	}
};
Queue<Node> pq = new PriorityQueue<>(cmp);

简单的使用

int n = in.nextInt();
Node[] A = new Node [n];
for (int i = 0; i < n; i++) {
	A[i] = new Node();
	A[i].key = in.nextInt();
	A[i].sec = in.nextInt();
	pq.add(A[i]);
}
while (!pq.isEmpty()) {
	System.out.println(pq.element().key + " " + pq.element().sec);
	pq.poll();
}

算法解答里声明的优先队列也是一样的，初始化comparator，根据数组的第一个index的值进行队列的排入

PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);

看一下offer的源码

transient Object[] queue; // non-private to simplify nested class access

 public boolean offer(E e) {
        if (e == null)   //判空
            throw new NullPointerException();
        modCount++;  //记录优先队列修改的次数
        int i = size;
        if (i >= queue.length) // 元素的个数大于等于数组的大小
            grow(i + 1); // 扩容
        size = i + 1;
        if (i == 0) //元素个数为空，将元素放入数组的第一个格子中
            queue[0] = e;
        else
            siftUp(i, e);// 增加元素
        return true;
}

private void siftUp(int k, E x) {
        if (comparator != null)   //传入了comparator 时
            siftUpUsingComparator(k, x);
        else     //没有传入comparator 时
            siftUpComparable(k, x);
}

//传入了comparator时
private void siftUpUsingComparator(int k, E x) {
		//k刚开始为数组中现有元素的最后一个下标
        while (k > 0) {  
            int parent = (k - 1) >>> 1; //找到k所在位置的父节点下标
            Object e = queue[parent];
            //使用传入的comparator比较
            if (comparator.compare(x, (E) e) >= 0)  //比较元素大于父节点，则什么也不做
                break;
            //否则将两个值互换
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
}

没有传入comparator的与传入的同理，比较时使用的是默认的比大小方法：

// 没有传入comparator时
private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
}

理解

先理解一下题目

画一下就懂了

代码

public static void main(String[] args) {
        int[] a = {1,0,0,5,2};
        int[] b = {2,2,1,4,2};
        System.out.println(eatenApplesq(a,b));
    }
    public static int eatenApplesq(int[] apples, int[] days) {
        int ans = 0;
        PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);//(a, b) -> a[0] - b[0]comparator比较器
        int n = apples.length;
        int i = 0;
        while (i < n) {
            while (!pq.isEmpty() && pq.peek()[0] <= i) {
                pq.poll();
            }
            int rottenDay = i + days[i];
            int count = apples[i];
            if (count > 0) {
                pq.offer(new int[]{rottenDay, count});
            }
            if (!pq.isEmpty()) {
                int[] arr = pq.peek();
                arr[1]--;
                if (arr[1] == 0) {
                    pq.poll();
                }
                ans++;
            }
            i++;
        }
        //第二阶段
        while (!pq.isEmpty()) {
            while (!pq.isEmpty() && pq.peek()[0] <= i) {
                pq.poll();
            }
            if (pq.isEmpty()) {
                break;
            }
            int[] arr = pq.poll();//poll()取出队列，存到arr上
            int curr = Math.min(arr[0] - i, arr[1]);
            ans += curr;
            i += curr;
        }
        return ans;

    }

解法

可以在优先队列中存储二元组，每个二元组表示苹果的腐烂日期和在该日期腐烂的苹果个数，则优先队列中的元素个数最多为 n 个（即数组长度）

计算分为两个阶段，第一阶段是第 0 天到第 n−1 天，即天数在数组下标范围内，第二阶段是第 n 天及以后，即天数在数组下标范围外。

在第一阶段，由于每天树上都可能长出苹果，因此需要对每一天分别计算是否能吃到苹果，并更新优先队列。具体做法如下：

1. 将优先队列中的所有腐烂日期小于等于当前日期的元素取出，这些元素表示已经腐烂的苹果，无法食用；
   

2. 根据 days 和 apples的当前元素计算当天长出的苹果的腐烂日期和数量，如果数量大于 0，则将腐烂日期和数量加入优先队列；
   

3. 如果优先队列不为空，则当天可以吃 1 个苹果，将优先队列的队首元素的数量减 1，如果队首元素的数量变成 0 则将队首元素取出。
   
   第一天：存入队列
   
   第二天：苹果数量-1
   
   第二天：继续入列，注意腐烂日期为i+days[i]
   
   第三天：队首苹果数量再-1，相应的吃掉的苹果ans+1
   
   第三天：腐烂日期为2+days[2]=2，2 <= i，所以这一天要将队首出列
   
   
   第四天：继续入列，new int[]{3+days[3]=7,5}
   
   第五天：出列和入列
   
   
   第一阶段完成

在第二阶段，由于树上不会再长出苹果，因此只需要考虑能吃到的苹果数量。由于优先队列中的每个元素的数量可能很大，因此需要根据当前日期和优先队列的队首元素的腐烂日期和数量计算能吃到的苹果数量。

假设当前日期是第 i 天，首先将优先队列中的所有腐烂日期小于等于 i 的元素取出，如果优先队列不为空，则根据优先队列的队首元素计算能吃到的苹果数量。

假设优先队列的队首元素的腐烂日期是 x，数量是 y，其中 x>i，则有 y 个苹果，距离腐烂还有 x−i 天，因此能吃到的苹果数量是 curr=min(x−i,y)。将优先队列的队首元素 (x,y) 取出并将日期增加 curr，重复上述操作直到优先队列为空，即可得到吃苹果的最大数目。

第六天：

这里腐烂日期是7，数量是4，距离腐烂还有7-5=2天，能吃的苹果数量是curr=min(2,4)=2也就是2个苹果，加到i和ans上继续下次遍历

这里i=7了，把队首踢出

继续走阶段二，腐烂日期是12，数量是4，距离腐烂还有12-7=5天，能吃的苹果数量是curr=min(5,4)=4也就是4个苹果，加到i和ans上继续下次遍历

取出最后一条队列后结束

力扣写的太简单不太容易懂，实际走过一遍后就清楚了