小浩算法-java题解(二分篇)

原文链接
https://www.geekxh.com/0.0.%E5%AD%A6%E4%B9%A0%E9%A1%BB%E7%9F%A5/01.html
这里是把这个大佬的题解用java写一下做个记录

二分篇

第875题：阿珂喜欢吃香蕉

这里总共有 N 堆香蕉，第 i 堆中有piles[i] 根香蕉。警卫已经离开了，将在 H 小时后回来。 阿珂可以决定她吃香蕉的速度 K （单位：根/小时），每个小时，她将会选择一堆香蕉，从中吃掉 K 根。
如果这堆香蕉少于 K 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉。

珂珂喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。返回她可以在 H 小时内吃掉所有香蕉的最小速度 K（K 为整数）。

示例 1：

输入: piles = [3,6,7,11], H = 8
输出: 4

解题思路：
参考：https://leetcode-cn.com/problems/koko-eating-bananas/solution/er-fen-cha-zhao-ding-wei-su-du-by-liweiwei1419/
1小时最低吃1个香蕉，最多吃一大堆香蕉，通过二分找到那个最合适的。

class Solution {
    public int minEatingSpeed(int[] piles, int H) {
        int maxval=1;
        for(int num:piles)
           maxval=Math.max(num,maxval);
        
        int left=1;//最少吃一根香蕉
        int right=maxval;//最多吃最多的那一堆，一个小时只吃一堆，多了没意义

        while(left< right)
        {
            int mid=left+(right-left)/2;//防止超出范围
            if(check(piles,mid)>H)//说明这样吃超出时间范围，需要缩小
            {
                left=mid+1;
            }
            else
               right=mid;
        }
        return left;
    }
    public int check(int [] piles,int speed)
    {
        int sum=0;
        for(int pile:piles)
        {
            sum+=(pile+speed-1)/speed;//这个是向上取整
        }
        return sum;
    }
}

第69题：x的平方根

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

解题思路：
新手版本：

class Solution {
    public int mySqrt(int x) {
       double mid=(double)x/2;
       double right=x;
       double left=0;
       while((int)left<(int)right)
       {
           if(mid*mid==x)
               return (int)mid;
           else if(mid*mid>x)
           {
               right=mid;
               mid=(double)(right+left)/2;
           }else
           {
               left=mid;
               mid=(double)(right+left)/2;
           }
       }
        return (int)mid;
    }
}

进阶版本：

public class Solution { 
    public int mySqrt(int x) { 
        if (x == 0) return 0; 
        long left = 1; 
        long right = x / 2; 
        while (left < right) { 
            //注意这一行代码 
            long mid = (right + left) / 2 + 1;
            if (mid > x / mid) {
                right = mid - 1;
            } else {
                left = mid;
            }
        }
        return (int) left;
    }
}

第278题：第一个错误的版本

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:

给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。

解题思路: 二分，判断中间是不是，是就向右走，不是就向左走，到找到为止。

/* The isBadVersion API is defined in the parent class VersionControl.
      boolean isBadVersion(int version); */

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int le=1;
        int ri=n;
        while(le<ri)
        {
            int mid=le+(ri-le)/2;
            if(isBadVersion(mid))
               ri=mid;
            else 
               le=mid+1;
        }
        return le;
    }
}

第153题：旋转排序数组最小值Ⅰ

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。请找出其中最小的元素。你可以假设数组中不存在重复元素。
示例 1:

输入: [3,4,5,1,2]
输出: 1

解题思路：
方法一:一次遍历，找到那个前面>后面的元素。

class Solution {
    public int findMin(int[] nums) {
       int ans=nums[0];
       if(nums.length==1) return ans;
       for(int i=1;i<nums.length;i++)
    {
        if(nums[i-1]>nums[i])
         ans=nums[i];
    }
    return ans;
    }
}

方法二：二分法，有点类似前面都是0，后面都是1，找到那个第一个出现的1。刚开始都是0，然后旋转后一部分就到后面去了，就成为1，找到那个最小值也就是找到那个第一次出现的1。
至于为什么选择有边界看这个：
https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/er-fen-cha-zhao-wei-shi-yao-zuo-you-bu-dui-cheng-z/

class Solution {
    public int findMin(int[] nums) {
    int left=0;
    int right=nums.length-1;
    while(left<right)
    {
        int mid=left+(right-left)/2;
        if(nums[mid]<nums[right])
        {
            right=mid;//mid有可能是那个最小值
        }else 
        {
            left=mid+1;//mid绝对不可能那个最小值
        }
    }
    return nums[left];
    }
}

第154题：旋转排序数组最小值Ⅱ

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。请找出其中最小的元素。 注意数组中可能存在重复的元素。
示例 1：

输入: [1,3,5]
输出: 1

解题思路：
参考：
https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/154-find-minimum-in-rotated-sorted-array-ii-by-jyd/
判断mid和right。
如果mid>right，那么铁定是在右边，i的取值就是mid<i<=right。所以left=mid+1。
如果mid<right，那么铁定是在左边，i的取值就是left<i<=mid。所以right=mid。
如果是等于，那么right=right-1。证明详情请看这个大佬的题解。

class Solution {
    public int findMin(int[] nums) {
    int left=0;
    int right=nums.length-1;
    while(left<right)
    {
        int mid=left+(right-left)/2;
        if(nums[mid]<nums[right])
        {
            right=mid;
        }else if(nums[mid]>nums[right])
        {
            left=mid+1;
        }else
        right=right-1;
    }
    return nums[left];
    }
}

第475题：供暖器

冬季已经来临。你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。现在，给出位于一条水平线上的房屋和供暖器的位置，找到可以覆盖所有房屋的最小加热半径。所以，你的输入将会是房屋和供暖器的位置。你将输出供暖器的最小加热半径。
说明:

给出的房屋和供暖器的数目是非负数且不会超过 25000。

给出的房屋和供暖器的位置均是非负数且不会超过10^9。

只要房屋位于供暖器的半径内(包括在边缘上)，它就可以得到供暖。

所有供暖器都遵循你的半径标准，加热的半径也一样。

示例 1:

输入: [1,2,3],[2]
输出: 1
解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1，那么所有房屋就都能得到供暖。

解题思路：
两遍遍历，找到每个房间距离供暖的最短距离，找到这些距离中的最大值。
参考：https://leetcode-cn.com/problems/heaters/solution/bian-li-liang-bian-sui-ran-su-du-man-shi-man-liao-/

class Solution {
    public int findRadius(int[] houses, int[] heaters) {
       int rad=-1;
       for(int num:houses)
         rad=Math.max(rad,f(num,heaters));
       return rad;
    }
    public int f(int n,int [] heaters)
    {
        int ans=1000000010;
        for(int num:heaters)
        {
            ans=Math.min(ans,Math.abs(num-n));
        }
        return ans;
    }
}