【力扣时间】【1705】【中等】吃苹果的最大数目

关注

最新推荐文章于 2025-06-22 00:15:00 发布 · 204 阅读

原创 ·

本内容遵循 CC 4.0 BY-SA 版权协议

保姆级教程：用SSH手动重建黑群晖RAID1阵列，修复‘存储空间损毁’ 本文提供了一份详细的SSH手动重建黑群晖RAID1阵列的教程，帮助用户修复‘存储空间损毁’问题。通过深入解析mdadm软RAID的底层逻辑，从诊断到重建的全过程，确保用户能够掌握黑群晖存储池的修复技术。适用于技术爱好者和系统管理员。阅读详情

吃苹果的最大数目

什么苹果烂得这么快？

1、来看题

点我！

今天的题，只能说不愧是中等题吧。
从题目描述到难度都是中规中矩。

一点点来看吧。

2、审题

题目将了一个小故事，但也很清楚地表述了题意。
一句话说，这是一个贪心问题。

来分析下重点：

你会在第i天得到apples[i]个苹果，且这些苹果，将在days[i]后腐烂
你每天最多只出一个苹果。（烂了都不多吃，也不给别人）
尽管是同一颗树上结的果，但每次结果的数量和腐烂时间都毫无关联。
尽管apples[]和days[]的长度都为n，但并不代表n天后就结束了，只要苹果还有剩余，你就可以继续吃下去。
可能会出现有几天没有苹果可吃的情况。

很明显的贪心问题了。
苹果的腐烂时间便是其优先级，而我们需要做得就是得出最优结果，能够吃掉更多的苹果。

3、思路

保持一贯的贪心思想，很明显苹果的腐烂时间决定了其优先级。
辣么带入现实考虑，为了尽可能多吃苹果，我们会优先吃临近腐烂的苹果。

而这也是我解题的思路。

由于days[]给出的是保质期长度，而我们需要记住的是腐烂时间，即第i天的苹果，会在第i+days[i]天腐烂。我们以这个时间来标记苹果，为它们分批。
注意，由于苹果每次的保质期长度都不同，所以可能出现后结的苹果先腐烂掉，或者不同日期的苹果在同一天腐烂的情况。

然后，我们就需要遍历apples[]，记录不通批次的苹果腐烂的时间，并同时开吃！即一边遍历，我们一遍处理吃苹果的逻辑。毕竟case就已经给出期间若干天没有苹果可吃的情况。

我们以优先级队列存储不同批次的苹果，并且每次开吃时，都从最近将要腐烂的批次中取苹果来吃。保证了贪心的思路。

辣么最后，需要注意的就是遍历完apples[]，即已经没有增量数据后，处理残量逻辑的情况。

思路明确！开动！

4、挽起袖子撸代码！

class Solution {

    public int eatenApples(int[] apples, int[] days) {
        int n = apples.length;

        int eaten = 0;
        PriorityQueue<int[]> rotted = new PriorityQueue<>(Comparator.comparingInt(o -> o[0]));
        for (int i = 0; i < apples.length; i++) {
            //当第i天结出的苹果数不为0时
            if (apples[i] != 0) {
                //计算腐烂的日期
                int rottedDay = i + days[i];

                rotted.offer(new int[]{rottedDay, apples[i]});
            }

            //如果有苹果可以吃
            if (eaten(rotted, i)) {
                ++eaten;
            }
        }

        //时间来到等n天
        int day = n;
        while (!rotted.isEmpty()) {
            //取出最近一批将要腐烂的苹果
            int[] apple = rotted.poll();

            if (apple[0] <= day) {
                continue;
            }

            //能够吃掉的数量为 库存数 和 腐烂前日期差 中的更小值
            int ate = Math.min(apple[0] - day, apple[1]);
            eaten += ate;

            //时间也移动吃掉数量的天数
            day += ate;
        }

        return eaten;
    }

    /**
     * 恰一个
     *
     * @param rotted
     * @param day
     * @return
     */
    private boolean eaten(PriorityQueue<int[]> rotted, int day) {
        while (!rotted.isEmpty()) {
            //从队列中拿出最近一批腐烂的苹果
            int[] apples = rotted.peek();

            //如果苹果已腐烂，则继续拿取
            if (apples[0] <= day) {
                //清除此批次的所有苹果
                rotted.poll();
                continue;
            }

            //让此批次的苹果数-1
            --apples[1];
            if (apples[1] == 0) {
                //如果这批苹果已全部吃完，则清除数据
                rotted.poll();
            }
            return true;
        }

        return false;
    }
}

5、解读

可以看到，我使用了一个优先级队列，其元素为一个二元数组，int[0]用于记录该批苹果的腐烂日期，而int[1]则是该批苹果的数量。

除了主方法外，我还实现了一个名为eaten()的方法来处理吃的逻辑。
其逻辑便是每次从优先级队列rotted中取出最近快要过期的批次的苹果，并时其库存-1。
如果这批苹果已吃完，则将该数组出队列。

//让此批次的苹果数-1
--apples[1];
 if (apples[1] == 0) {
     //如果这批苹果已全部吃完，则清除数据
     rotted.poll();
 }

传入的day用来判断此刻已经到了第几天，来淘汰已经腐烂了的苹果批次。

//如果苹果已腐烂，则继续拿取
if (apples[0] <= day) {
     //清除此批次的所有苹果
     rotted.poll();
     continue;
 }

如果有苹果可吃，则返回true。没有时返回false。

主函数可分为两个部分。
第一部分时日期<n，我们一边处理增量的数据，一边开吃。

for (int i = 0; i < apples.length; i++) {
    //当第i天结出的苹果数不为0时
     if (apples[i] != 0) {
         //计算腐烂的日期
         int rottedDay = i + days[i];

         rotted.offer(new int[]{rottedDay, apples[i]});
     }

     //如果有苹果可以吃
     if (eaten(rotted, i)) {
         ++eaten;
     }
 }

eaten记录了吃掉的苹果总数。

第二部分是日期>=n时，已经没有增量数据了，我们开始处理剩余的苹果数量。我当然仍然可以使用eaten()，但我嫌这样太慢，于是换了一种方法。
我选择直接出队最近一批将要腐烂的苹果，并根据当前日期判断能够吃掉多少。
能吃掉的数量为这批苹果的剩余数量 和 当前日期到腐烂日期间的差值中的最小值。

//能够吃掉的数量为 库存数 和 腐烂前日期差 中的更小值
int ate = Math.min(apple[0] - day, apple[1]);
eaten += ate;

毕竟可能在你吃完前，这批苹果就已经烂光了。也可能在烂光前，你已经吃完了。
注意时间的流动也是你吃掉的数量，毕竟每天仅吃一个苹果嘛。

//时间也移动吃掉数量的天数
day += ate;

6、提交

在这里插入图片描述
最后的结果如上，没想到又成了内存消耗排名较高的解法了。

7、咀嚼

en……
每次遍历并插入优先级队列，时间复杂度为O(NlongN)。
之后清空队列，复杂度为O(N)，
所以整体是O(NlongN)。
空间复杂度为O(N)。

8、学习大牛！

我看我的耗时排名不高，本以为又有黑科技了。
但大牛们的解法思路基本上都与我相同，估计又是在什么步骤浪费了些许时间吧。

总之，学我这套就行！

9、总结

贪心复习，今天题比之之前的辣道贪心题要简单不少。~~废话，之前的可是困难！~~

下班下班！

收录于

我的算法历程

标签

#leetcode #贪心算法 #算法

CTF逆向实战：如何快速识别RC4、TEA和Base64的魔改变种？本文针对CTF逆向比赛中常见的加密算法魔改问题，详细讲解了如何快速识别和破解RC4、TEA和Base64的变种。通过分析算法核心特征、常见魔改手法，并结合动态调试与脚本编写等实战技巧，帮助逆向分析人员有效应对算法混淆，提升解题效率。阅读详情