Title Description

Ideas ：

Through the title, we can see the following restrictions

Speed k Of The scope is Sum of all bananas / h <= k <= max(piles)

Because the sum of all bananas exceeds int Range , therefore

The optimized range is 0 <= k <= max(piles)

Ideas 1. Since it is within a certain range , We can try brute force cracking

from 0 Start , Every time k+=1 , Until you can finish eating bananas

Ideas 2. When the data is too large , Out of time , Therefore, you can use dichotomy to find

Get a number , This speed can finish ,right = k; Can't finish ,left = k+1;k=left+(right-left)/2;

Yes, of course , We have to write a function to judge whether we can finish

The code is as follows

class Solution {
    public int minEatingSpeed(int[] piles, int h) {       
        int left = 1;
        int right = 0;
        for(int temp : piles)
        {
            right = Math.max(right,temp);
        }
        int k=0;
        while(left<right)
        {
            k = left+(right - left)/2;
            // Write a function to judge whether you can finish , And back to boolean
            if(judge(piles,k,h))
            {
                // Can finish 
                right = k;
            }
            else
            {
                left = k+1;
            }
        }
        return right;
    }
    public boolean judge(int []piles,int b,int h)
    {
        
        int count1=0;
        for(int temp : piles)
        {          
            int temp2 = (temp + b -1)/b;
            count1 += temp2;
        }
        if(count1 > h)// cannot eat out 
        {
            return false;
        }
        else
        {
            return true;
        }
    }
}

Problems encountered

1.for Reference of circular knowledge points

for(int temp : piles)
{}
 Instead of  
for(int i=0;i<piles.length;i++)
{
    int temp = piles[i];
}

2. Count the number of times each pile eats

while(temp > 0)
{
    temp -= speed;
    count1 ++;
}

 Replace with 

temp = (temp-1 + speed ) /speed;
count1 += temp;

// temp-1 + speed  It's to make sure that   When the number of heaps is less than the speed , The guaranteed times are  1
// Direct use  temp/speed  There may be eating , But the frequency of eating is  0