平安夜关于苹果的题目——1705. 吃苹果的最大数目

题目

OJ平台

题目解析

题目给出的数据是每天生产出来的苹果数量，以及该苹果对应的过期时间，而题目通过限制每天只能吃一个苹果。
最后问最多能吃多少个苹果？

很明显，这是一道模拟题，我们模拟从第0天到最后，每天吃一个苹果能延续到第几天，就是能吃多少个苹果。

我们如何模拟呢？

我们需要维护一个二元关系的元素->[过期时间，苹果数量],由于是根据时间来遍历，所以过期时间我们可以正常的算出来，而且也很好判断是否过期。这个时候取苹果就是根据这个过期时间的远近来取的，这也是这题贪心的部分，我们需要取得距离过期时间最近的苹果，也就是在构建每个元素的同时，我们每次需要取出过期时间最近的元素来进行判断。如果以及过期就扔掉，如果未过期就判断这个元素的苹果是否数量大于0，如果这两者都满足就取一个苹果，否则直接扔掉。这个过程反应在代码里面就是一个优先队列元素的更改和出队的过程。接下来查看下面的解题代码应该就很懂了！注意题目给出的苹果树数据我们都需要完全的给他入队，不要留空挡。(这个可查看力扣官方题解的动画描述来理解)

解题代码

cpp代码

class Solution {
public:
//贪心例题：从第一天开始往后遍历，先把最先容易腐烂变质的吃掉。
//如何实现这一过程的模拟？这就需要用到优先队列一直将最容易变质的取下来吃掉。如果已经变质则直接扔掉
//如何判断是否变质？根据给出的日期维护一个二元的整体，一旦变质日期不大于当前日期，则变质了。
    int eatenApples(vector<int>& apples, vector<int>& days) {
        int n = apples.size();
        priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>pq;
        int sum = 0;  //存储答案
        int date = 0; //TODO 当前日期，从第0天开始记
        while(!pq.empty()||date<n){//TODO 优先队列不为空||还有数据未取完
            //TODO 随着日期的进行，同时也更新队列中的数据：每个元素由(过期时间,苹果数量)组成
            if(date<n&&days[date])
                pq.push(make_pair(days[date]+date-1,apples[date]));
            //TODO 把 已经过期的||已经用完的 苹果排除
            while(!pq.empty()&&(date>pq.top().first||pq.top().second==0))
               pq.pop();
            //TODO 每过一天就吃一个最接近过期苹果
            if(!pq.empty()){ 
               sum++;
               const_cast<pair<int,int>&>(pq.top()).second--;//这里注意强转才能改数据
            }
            date++; //不断更新日期
        }
        return sum;
    }
};

go语言

func eatenApples(apples, days []int) (ans int) {
    h := hp{}
    i := 0
    for ; i < len(apples); i++ {
        for len(h) > 0 && h[0].end <= i {
            heap.Pop(&h)
        }
        if apples[i] > 0 {
            heap.Push(&h, pair{i + days[i], apples[i]})
        }
        if len(h) > 0 {
            h[0].left--
            if h[0].left == 0 {
                heap.Pop(&h)
            }
            ans++
        }
    }
    for len(h) > 0 {
        for len(h) > 0 && h[0].end <= i {
            heap.Pop(&h)
        }
        if len(h) == 0 {
            break
        }
        p := heap.Pop(&h).(pair)
        num := min(p.end-i, p.left)
        ans += num
        i += num
    }
    return
}

type pair struct{ end, left int }
type hp []pair

func (h hp) Len() int            { return len(h) }
func (h hp) Less(i, j int) bool  { return h[i].end < h[j].end }
func (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
func (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }

func min(a, b int) int {
    if a > b {
        return b
    }
    return a
}