(l + r) // 2 to l + (r - l) // 2; improved doc; added hidden binary s…

…earch problems

basic_algorithm/binary_search.md

@@ -1,32 +1,29 @@
 # 二分搜索
 
-## 二分搜索模板
+给一个**有序数组**和目标值，找第一次/最后一次/任何一次出现的索引，时间复杂度 O(logN)。
 
-给一个**有序数组**和目标值，找第一次/最后一次/任何一次出现的索引，如果没有出现返回-1
+## 模板
 
-模板四点要素
+常用的二分搜索模板有如下三种形式：
 
-- 1、初始化：start=0、end=len-1
-- 2、循环退出条件：start + 1 < end
-- 3、比较中点和目标值：A[mid] ==、 <、> target
-- 4、判断最后两个元素是否符合：A[start]、A[end] ? target
-
-时间复杂度 O(logn)，使用场景一般是有序数组的查找
+![binary_search_template](https://img.fuiboom.com/img/binary_search_template.png)
 
-典型示例
+其中，模板 1 和 3 是最常用的，几乎所有二分查找问题都可以用其中之一轻松实现。模板 2 更高级一些，用于解决某些类型的问题。详细的对比可以参考 Leetcode 上的文章：[二分搜索模板](https://leetcode-cn.com/explore/learn/card/binary-search/212/template-analysis/847/)。
 
 ### [binary-search](https://leetcode-cn.com/problems/binary-search/)
 
 > 给定一个  n  个元素有序的（升序）整型数组  nums 和一个目标值  target  ，写一个函数搜索  nums  中的 target，如果目标值存在返回下标，否则返回 -1。
 
+- 模板 3 的实现
+
 ```Python
 class Solution:
     def search(self, nums: List[int], target: int) -> int:
 
         l, r = 0, len(nums) - 1
 
         while l + 1 < r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] < target:
                 l = mid
             else:
@@ -40,25 +37,16 @@ class Solution:
             return -1
 ```
 
-大部分二分查找类的题目都可以用这个模板，然后做一点特殊逻辑即可
-
-另外二分查找还有一些其他模板如下图，大部分场景模板 3 都能解决问题，而且还能找第一次/最后一次出现的位置，应用更加广泛
-
-![binary_search_template](https://img.fuiboom.com/img/binary_search_template.png)
-
-所以用模板#3 就对了，详细的对比可以这边文章介绍：[二分搜索模板](https://leetcode-cn.com/explore/learn/card/binary-search/212/template-analysis/847/)
-
-- 如果是最简单的二分搜索，不需要找第一个、最后一个位置、或者是没有重复元素，可以使用模板 1，代码更简洁
+- 如果是最简单的二分搜索，不需要找第一个、最后一个位置，或者是没有重复元素，可以使用模板 1，代码更简洁。同时，如果搜索失败，left 是第一个大于 target 的索引，right 是最后一个小于 target 的索引。
 
 ```Python
-# 无重复元素搜索时，更方便
 class Solution:
     def search(self, nums: List[int], target: int) -> int:
 
         l, r = 0, len(nums) - 1
 
         while l <= r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] == target:
                 return mid
             elif nums[mid] > target:
@@ -67,12 +55,9 @@ class Solution:
                 l = mid + 1
 
         return -1
-# 如果找不到，start 是第一个大于target的索引
-# 如果在B+树结构里面二分搜索，可以return start
-# 这样可以继续向子节点搜索，如：node:=node.Children[start]
 ```
 
-- 模板 2：
+- 模板 2 的实现
 
 ```Python
 class Solution:
@@ -81,7 +66,7 @@ class Solution:
         l, r = 0, len(nums) - 1
 
         while l < r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] < target:
                 l = mid + 1
             else:
@@ -93,18 +78,15 @@ class Solution:
         return -1
 ```
 
-
-
 ## 常见题目
 
 ### [find-first-and-last-position-of-element-in-sorted-array](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/)
 
 > 给定一个包含 n 个整数的排序数组，找出给定目标值 target 的起始和结束位置。如果目标值不在数组中，则返回`[-1, -1]`
 
-- 思路：核心点就是找第一个 target 的索引，和最后一个 target 的索引，所以用两次二分搜索分别找第一次和最后一次的位置
+- 思路：核心点就是找第一个 target 的索引，和最后一个 target 的索引，所以用两次二分搜索分别找第一次和最后一次的位置，下面是使用模板 3 的解法
 
 ```Python
-# 使用模板3的解法
 class Solution:
     def searchRange(self, nums, target):
         Range = [-1, -1]
@@ -113,7 +95,7 @@ class Solution:
 
         l, r = 0, len(nums) - 1
         while l + 1 < r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] < target:
                 l = mid
             else:
@@ -128,7 +110,7 @@ class Solution:
 
         l, r = 0, len(nums) - 1
         while l + 1 < r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] <= target:
                 l = mid
             else:
@@ -153,7 +135,7 @@ class Solution:
 
         l, r = 0, len(nums) - 1
         while l < r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] < target:
                 l = mid + 1
             else:
@@ -166,7 +148,7 @@ class Solution:
 
         l, r = 0, len(nums) - 1
         while l < r:
-            mid = (l + r + 1) // 2
+            mid = l + (r - l + 1) // 2
             if nums[mid] > target:
                 r = mid - 1
             else:
@@ -180,7 +162,7 @@ class Solution:
 
 > 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
 
-思路：使用模板 1，若不存在，随后的左边界为第一个大于目标值的索引（插入位置），右边界为最后一个小于目标值的索引
+- 使用模板 1，若不存在，左边界为第一个大于目标值的索引（插入位置），右边界为最后一个小于目标值的索引
 
 ```Python
 class Solution:
@@ -189,7 +171,7 @@ class Solution:
         l, r = 0, len(nums) - 1
 
         while l <= r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] == target:
                 return mid
             elif nums[mid] > target:
@@ -204,10 +186,11 @@ class Solution:
 
 > 编写一个高效的算法来判断  m x n  矩阵中，是否存在一个目标值。该矩阵具有如下特性：
 >
-> - 每行中的整数从左到右按升序排列。
-> - 每行的第一个整数大于前一行的最后一个整数。
+> 1. 每行中的整数从左到右按升序排列。
+>
+> 2. 每行的第一个整数大于前一行的最后一个整数。
 
-思路：两次二分，首先定位行数，接着定位列数
+- 两次二分，首先定位行数，接着定位列数
 
 ```Python
 class Solution:
@@ -219,7 +202,7 @@ class Solution:
         l, r = 0, len(matrix) - 1
 
         while l <= r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if matrix[mid][0] == target:
                 return True
             elif matrix[mid][0] < target:
@@ -230,7 +213,7 @@ class Solution:
         row = r
         l, r = 0, len(matrix[0]) - 1
         while l <= r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if matrix[row][mid] == target:
                 return True
             elif matrix[row][mid] < target:
@@ -241,36 +224,11 @@ class Solution:
         return False
 ```
 
-### [first-bad-version](https://leetcode-cn.com/problems/first-bad-version/)
-
-> 假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
-> 你可以通过调用  bool isBadVersion(version)  接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
-
-```Python
-class Solution:
-    def firstBadVersion(self, n):
-
-        l, r = 1, n
-
-        while l + 1 < r:
-            mid = (l + r) // 2
-            if isBadVersion(mid):
-                r = mid
-            else:
-                l = mid
-
-        if isBadVersion(l):
-            return l
-        else:
-            return r
-```
-
 ### [find-minimum-in-rotated-sorted-array](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/)
 
-> 假设按照升序排序的数组在预先未知的某个点上进行了旋转( 例如，数组  [0,1,2,4,5,6,7] 可能变为  [4,5,6,7,0,1,2] )。
-> 请找出其中最小的元素。假设数组中无重复元素。
+> 假设按照升序排序的数组在预先未知的某个点上进行了旋转，例如，数组 [0, 1, 2, 4, 5, 6, 7] 可能变为 [4, 5, 6, 7, 0, 1, 2]。请找出其中最小的元素。假设数组中无重复元素。
 
-思路：使用二分搜索，当中间元素大于右侧元素时意味着拐点即最小元素在右侧，否则在左侧
+- 使用二分搜索，当中间元素大于右侧元素时意味着拐点即最小元素在右侧，否则在左侧
 
 ```Python
 class Solution:
@@ -279,7 +237,7 @@ class Solution:
         l , r = 0, len(nums) - 1
 
         while l < r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] > nums[r]: # 数组有重复时，若 nums[l] == nums[mid] == nums[r]，无法判断移动方向
                 l = mid + 1
             else:
@@ -290,9 +248,7 @@ class Solution:
 
 ### [find-minimum-in-rotated-sorted-array-ii](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/)
 
-> 假设按照升序排序的数组在预先未知的某个点上进行了旋转
-> ( 例如，数组  [0,1,2,4,5,6,7] 可能变为  [4,5,6,7,0,1,2] )。
-> 请找出其中最小的元素。(包含重复元素)
+> 假设按照升序排序的数组在预先未知的某个点上进行了旋转，例如，数组 [0, 1, 2, 4, 5, 6, 7] 可能变为 [4, 5, 6, 7, 0, 1, 2]。请找出其中最小的元素。数组中可能包含重复元素。
 
 ```Python
 class Solution:
@@ -301,7 +257,7 @@ class Solution:
         l , r = 0, len(nums) - 1
 
         while l < r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] > nums[r]:
                 l = mid + 1
             elif nums[mid] < nums[r] or nums[mid] != nums[l]:
@@ -314,10 +270,7 @@ class Solution:
 
 ### [search-in-rotated-sorted-array](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/)
 
-> 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
-> ( 例如，数组  [0,1,2,4,5,6,7]  可能变为  [4,5,6,7,0,1,2] )。
-> 搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回  -1 。
-> 你可以假设数组中不存在重复的元素。
+> 假设按照升序排序的数组在预先未知的某个点上进行了旋转，例如，数组 [0, 1, 2, 4, 5, 6, 7] 可能变为 [4, 5, 6, 7, 0, 1, 2]。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回  -1。假设数组中不存在重复的元素。
 
 ```Python
 class Solution:
@@ -326,7 +279,7 @@ class Solution:
         l , r = 0, len(nums) - 1
 
         while l <= r:
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] == target:
                 return mid
             elif nums[mid] > target:
@@ -342,15 +295,9 @@ class Solution:
         return -1
 ```
 
-注意点
-
-> 面试时，可以直接画图进行辅助说明，空讲很容易让大家都比较蒙圈
-
 ### [search-in-rotated-sorted-array-ii](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/)
 
-> 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
-> ( 例如，数组  [0,0,1,2,2,5,6]  可能变为  [2,5,6,0,0,1,2] )。
-> 编写一个函数来判断给定的目标值是否存在于数组中。若存在返回  true，否则返回  false。(包含重复元素)
+> 假设按照升序排序的数组在预先未知的某个点上进行了旋转，例如，数组 [0, 0, 1, 2, 2, 5, 6] 可能变为 [2, 5, 6, 0, 0, 1, 2]。编写一个函数来判断给定的目标值是否存在于数组中，若存在返回  true，否则返回  false。数组中可能包含重复元素。
 
 ```Python
 class Solution:
@@ -363,7 +310,7 @@ class Solution:
                 l += 1
                 r -= 1
                 continue
-            mid = (l + r) // 2
+            mid = l + (r - l) // 2
             if nums[mid] == target:
                 return True
             elif nums[mid] > target:
@@ -379,6 +326,28 @@ class Solution:
         return False
 ```
 
+## 隐含的二分搜索
+
+有时用到二分搜索的题目并不会直接给你一个有序数组，它隐含在题目中，需要你去发现或者构造。一类常见的隐含的二分搜索的问题是求某个有界数据的最值，以最小值为例，当数据比最小值大时都符合条件，比最小值小时都不符合条件，那么符合/不符合条件就构成了一种有序关系，再加上数据有界，我们就可以使用二分搜索来找数据的最小值。注意，数据的界一般也不会在题目中明确提示你，需要你自己去发现。
+
+### [koko-eating-bananas](https://leetcode-cn.com/problems/koko-eating-bananas/)
+
+```Python
+class Solution:
+    def minEatingSpeed(self, piles: List[int], H: int) -> int:
+
+        l, r = 1, max(piles)
+
+        while l < r:
+            mid = l + (r - l) // 2
+            if sum([-pile // mid for pile in piles]) < -H:
+                l = mid + 1
+            else:
+                r = mid
+
+        return l
+```
+
 ## 总结
 
 二分搜索核心四点要素（必背&理解）