Leetcode 875：科科吃香蕉 代码逻辑问题咨询

科科喜欢吃香蕉。这里有n堆香蕉，第i堆有piles[i]根香蕉。警卫已经离开，会在h小时后回来。
科科可以决定她每小时吃香蕉的速度k。每小时，她选择一堆香蕉，吃其中k根。如果这堆香蕉少于k根，她会吃掉所有剩余的，并且该小时内不再吃其他香蕉。
科科喜欢慢慢吃，但仍想在警卫回来前吃完所有香蕉。
返回最小的整数k，使得她能在h小时内吃完所有香蕉。

示例1：
输入: piles = [3,6,7,11], h = 8
输出: 4

示例2：
输入: piles = [30,11,23,4,20], h = 5
输出: 30

示例3：
输入: piles = [30,11,23,4,20], h = 6
输出: 23

import java.util.Arrays;

class Solution {
    public int minEatingSpeed(int[] piles, int h) {
        Arrays.sort(piles);

        int j = 0;
        int high = piles[piles.length-1];
      int i = 0;
      int k;
      outerLoop1:
        for( k = piles[0]; k <= high; k++) {
            while (j <= h && i < piles.length) {
                if (piles[i] > 0) {
                    piles[i] = piles[i] - k;
                }
                j++;
                i++;
                if (i == piles.length) {
                    i = 0;
                }
            }
            outerLoop:
            if (j == h) {
                int f = 0;
                while (f < piles.length) {
                    if (piles[i] > 0) {
                        break outerLoop;
                    } else {
                        f++;
                    }
                    
                }
                break outerLoop1;
            }
        }
        return k;
    }
}

用户知道这题应该用二分查找解决，但采用了从piles最小值到最大值遍历k的思路，模拟每小时吃k根香蕉的过程，尝试找到能在h小时内吃完所有香蕉的最小k。现咨询该代码的逻辑错误点，以及如何调整现有代码修复问题，不需要新解法，仅针对当前思路修正。

• 原数组被改坏了：你直接在输入的piles数组上做减法，测试完一个k之后，数组已经不是初始状态了，下一个k的判断肯定出错。
• 模拟吃香蕉的逻辑完全不对：题目要求每小时只能盯着一堆吃，要么吃k根，要么把这堆吃完就停。但你的代码是每小时换一堆，比如堆里有6根、k=4，应该花2小时吃完，但你代码里第一个小时减4，第二个小时直接去吃下一堆，完全不符合规则。
• 循环变量没重置：每次换k的时候，计时的j、当前处理堆的i都没变回0，导致下一个k的判断是接着上一个k的进度来的，逻辑全乱了。
• 吃完的判断逻辑混乱：当时间到h时，检查香蕉是否吃完的代码逻辑不清，i的位置不对，根本没法正确判断所有堆都吃完了。

import java.util.Arrays;

class Solution {
    public int minEatingSpeed(int[] piles, int h) {
        Arrays.sort(piles);
        // k的最小可能是1，最大是最大堆的数量（因为h至少等于堆数，此时k必须等于最大堆）
        int low = 1;
        int high = piles[piles.length - 1];
        
        // 从最小的k开始试，找到第一个能在h小时内吃完的
        for (int k = low; k <= high; k++) {
            int totalHours = 0;
            // 计算当前k下，每堆需要的时间
            for (int count : piles) {
                // 向上取整计算每堆耗时：比如7根香蕉，k=4，需要2小时
                totalHours += (count + k - 1) / k;
                // 如果已经超过h，不用继续算了，当前k不行
                if (totalHours > h) {
                    break;
                }
            }
            // 找到第一个满足条件的k，直接返回（因为从最小开始遍历，第一个就是最小的）
            if (totalHours <= h) {
                return k;
            }
        }
        // 这里是兜底，high肯定满足条件
        return high;
    }
}

1. 不动原数组：每次计算k的时候，直接用原数组的数值算时间，不会破坏原始数据，保证每个k的判断都是独立的。
2. 按规则算时间：用(count + k - 1) / k实现向上取整，完美符合题目里每小时吃k根（不足就吃完）的规则。
3. 每次重置计时：每个k对应的totalHours都是重新计算的，不会和上一个k的状态混在一起。
4. 提前止损：算到一半发现时间超了h，直接跳出循环，不用白费劲算剩下的堆。
5. 修正k的范围：最小k应该是1，不是piles[0]，比如h特别大的时候，k可以比最小堆还小，比如h=100，piles=[3,6,7,11]，k=1就够了。

内容的提问来源于stack exchange，提问作者bluets