二分查找 难题汇总 模板验证 二分答案 本质上是答案在一段range里，然后根据该range去二分搜索！

69. x 的平方根   二分答案的雏形

难度简单1245

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

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

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

 

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

class Solution:
    def mySqrt(self, x: int) -> int:
        if x == 0:
            return x

        l, r = 1, x//2 + 1
        while l + 1 < r:
            mid = (l + r) // 2
            if mid * mid <= x:
                l = mid
            else:
                r = mid

        return l

　　

29. 两数相除

难度中等1049

给你两个整数，被除数 dividend 和除数 divisor。将两数相除，要求 不使用 乘法、除法和取余运算。

整数除法应该向零截断，也就是截去（truncate）其小数部分。例如，8.345 将被截断为 8 ，-2.7335 将被截断至 -2 。

返回被除数 dividend 除以除数 divisor 得到的 商 。

注意：假设我们的环境只能存储 32 位 有符号整数，其数值范围是 [−231,  231 − 1] 。本题中，如果商 严格大于 231 − 1 ，则返回 231 − 1 ；如果商 严格小于 -231 ，则返回 -231 。

 

示例 1:

输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = 3.33333.. ，向零截断后得到 3 。

示例 2:

输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = -2.33333.. ，向零截断后得到 -2 。

 

提示：

• -231 <= dividend, divisor <= 231 - 1
• divisor != 0

 

leetcode上的，一开始都没有反应过来要用二分答案。

def quick_mul(x,y):
    ans = 0
    while y:
        if y & 1:
            ans += x
        x += x
        y >>= 1
    return ans


class Solution:
    def divide(self, dividend: int, divisor: int) -> int:
        def helper(a, b):
            a, b = abs(a), abs(b)
            if a < b:
                return 0
            l, r = 1, a
            while l + 1 < r:
                mid = (l + r) // 2
                if quick_mul(b, mid) <= a:
                    l = mid
                else:
                    r = mid
            if quick_mul(l, b) == a:
                return l
            if quick_mul(r, b) == a:
                return r
            return l

        if dividend > 0 and divisor < 0:
            ans = -helper(dividend, divisor)
        elif dividend < 0 and divisor > 0:
            ans = -helper(dividend, divisor)
        else:
            ans = helper(dividend, divisor)

        min_val, max_val = -(1<<31), (1<<31)-1
        if ans > max_val:
            ans = max_val
        if ans < min_val:
            ans = min_val
        return ans

　

4. 寻找两个正序数组的中位数

难度困难6226

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

 

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

经典题目：见我另外文章分析思路

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        def findKth(A, l_a, r_a, B, l_b, r_b, k):
            rangeA = r_a - l_a + 1
            rangeB = r_b - l_b + 1
  
            if rangeA == 0:
                return B[l_b+k-1]
  
            if rangeB == 0:
                return A[l_a+k-1]
  
            if k == 1: # 注意位置，是放在上面2个if后面，k为1时，只需要返回A B首个元素最小即可
                return min(A[l_a], B[l_b])
  
            if rangeA > rangeB: # 之所有要交换，是因为后面pb = k - pa可能导致l_b + pb越界！例如：A有100个元素，B只有1个，k为50的情形
                return findKth(B, l_b, r_b, A, l_a, r_a, k)
  
            pa = min(k // 2, rangeA)
            pb = k - pa
  
            if A[l_a + pa - 1] == B[l_b + pb - 1]:
                return A[l_a + pa - 1]
            elif A[l_a + pa - 1] < B[l_b + pb - 1]:                
                return findKth(A, l_a + pa, r_a, B, l_b, l_b + pb - 1, k - pa) # 注意收缩r_b为l_b + pb - 1, 这是因为我们已经知道 A[l_a + pa - 1] 小于 B[l_b + pb - 1]，并且 pa + pb = k。这意味着在 A 和 B 的合并数组中，B[l_b + pb - 1] 前面至少有 k 个元素（包括 B[l_b + pb - 1] 本身）。因此，第 k 大的元素不可能在 B[l_b + pb - 1] 之后。
            else:
                return findKth(A, l_a, l_a + pa - 1, B, l_b + pb, r_b, k - pb)
         
        A, B = nums1, nums2
        k = len(A) + len(B)
        if k & 1:
            return findKth(A, 0, len(A) - 1, B, 0, len(B) - 1, k//2 + 1) # 注意有+1，因为是第k大
        else:
            a = findKth(A, 0, len(A) - 1, B, 0, len(B) - 1, k//2 + 1) # 注意有+1，因为是第k大
            b = findKth(A, 0, len(A) - 1, B, 0, len(B) - 1, k//2)
            return (a + b)/2

　　

　

75 · 寻找峰值

描述

给定一个整数数组(size为n)，其具有以下特点：

• 相邻位置的数字是不同的
• A[0] < A[1] 并且 A[n - 2] > A[n - 1]

假定P是峰值的位置则满足A[P] > A[P-1]且A[P] > A[P+1]，返回数组中任意一个峰值的位置。

• 数组保证至少存在一个峰
• 如果数组存在多个峰，返回其中任意一个就行
• 数组至少包含 3 个数

样例

样例 1：

输入：

A = [1, 2, 1, 3, 4, 5, 7, 6]

 

输出：

1

解释：

返回任意一个峰顶元素的下标，6也同样正确。
样例 2：

输入：

A = [1,2,3,4,1]

输出：

3

解释：

返回峰顶元素的下标。

 

https://www.lintcode.com/problem/75/

分析：

 

 

 注意：a[mid-1] a[mid] a[mid+1]一定不会越界！！！

from typing import (
    List,
)

class Solution:
    """
    @param a: An integers array.
    @return: return any of peek positions.
    """
    def find_peak(self, a: List[int]) -> int:
        # write your code here
        l, r = 0, len(a) - 1
        while l + 1 < r:
            mid = (l + r) // 2
            if a[mid] <= a[mid+1]:
                l = mid
            else:
                r = mid

        if a[l] >= a[r]:
            return l
        
        return r

 

141. 对x开根

中文

English

实现 int sqrt(int x) 函数，计算并返回 x 的平方根。

样例

Example 1:
	Input:  0
	Output: 0


Example 2:
	Input:  3
	Output: 1
	
	Explanation:
	return the largest integer y that y*y <= x. 
	
Example 3:
	Input:  4
	Output: 2
	

挑战

O(log(x))

class Solution:
    """
    @param x: An integer
    @return: The sqrt of x
    """
    def sqrt(self, x):
        # write your code here
        l, r = 0, x
        while l + 1 < r:
            mid = (l + r) >> 1
            if mid*mid > x:
                r = mid
            else:
                l = mid

        if r*r == x:
            return r
            
        return l

 

https://www.lintcode.com/problem/141/

class Solution:
    """
    @param x: An integer
    @return: The sqrt of x
    """
    def sqrt(self, x: int) -> int:
        # write your code here
        assert x >= 0
        if x <= 1:
            return x

        l, r = 0, x - 1
        while l + 1 < r:
            mid = (l + r) // 2
            if mid * mid <= x:
                l = mid
            else:
                r = mid
        
        if l * l <= x:
            return l
        
        return r
        

 

 

183. 木材加工

中文

English

有一些原木，现在想把这些木头切割成一些长度相同的小段木头，需要得到的小段的数目至少为 k。当然，我们希望得到的小段越长越好，你需要计算能够得到的小段木头的最大长度。

样例

Example 1

Input:
L = [232, 124, 456]
k = 7
Output: 114
Explanation: We can cut it into 7 pieces if any piece is 114cm long, however we can't cut it into 7 pieces if any piece is 115cm long.

Example 2

Input:
L = [1, 2, 3]
k = 7
Output: 0
Explanation: It is obvious we can't make it.

挑战

O(n log Len), Len为 n 段原木中最大的长度

注意事项

木头长度的单位是厘米。原木的长度都是正整数，我们要求切割得到的小段木头的长度也要求是整数。无法切出要求至少 k 段的,则返回 0 即可。

木头长度的范围在 1 到 max(L)，在这个范围内二分出一个长度 length，然后看看以这个 wood length 为前提的基础上，能切割出多少木头，如果少于 k 根，说明要短一些才行，如果多余 k，说明可以继续边长一些。

 

L = [232, 124, 456]
k = 7
Output: 114
为啥是114因为(232/114 == 2)+(123/114==1) + (456/114==4) == 7
如果长度继续延长，例如115，则(232/115 == 2)+(123/115==1) + (456/115==3) == 6 所以k=7满足不了！
如果长度减少，极端情况是1，则(232/1 == 232)+(123/1==123) + (456/1==456) > 7 。。。
所以本质上是二分。。。

 

https://www.lintcode.com/problem/183/

 

class Solution:
    """
    @param L: Given n pieces of wood with length L[i]
    @param k: An integer
    @return: The maximum length of the small pieces
    """
    def woodCut(self, L, k):
        # write your code here
        def cut_piece(length):
            ans = 0
            for i in L:
                ans += i // length
            return ans
        
        if not L:
            return 0
            
        l, r = 1, max(L)
        while l + 1 < r:
            mid = (l + r) >> 1
            if cut_piece(mid) >= k:
                l = mid
            else:
                r = mid
        
        if cut_piece(r) >= k:
            return r
        
        if cut_piece(l) >= k:
            return l
        
        return 0

 看到了吧，其实二分答案的模板还是很简单的，就是二分的模板！！！

 

437. 书籍复印

中文

English

给定 n 本书, 第 i 本书的页数为 pages[i]. 现在有 k 个人来复印这些书籍, 而每个人只能复印编号连续的一段的书, 比如一个人可以复印 pages[0], pages[1], pages[2], 但是不可以只复印 pages[0], pages[2], pages[3] 而不复印 pages[1].

所有人复印的速度是一样的, 复印一页需要花费一分钟, 并且所有人同时开始复印. 怎样分配这 k 个人的任务, 使得这 n 本书能够被尽快复印完?

返回完成复印任务最少需要的分钟数.

样例

样例 1:

输入: pages = [3, 2, 4], k = 2
输出: 5
解释: 第一个人复印前两本书, 耗时 5 分钟. 第二个人复印第三本书, 耗时 4 分钟.

样例 2:

输入: pages = [3, 2, 4], k = 3
输出: 4
解释: 三个人各复印一本书.

挑战

时间复杂度 O(nk)

注意事项

书籍页数总和小于等于2147483647

 

基于答案值域的二分法。 答案的范围在 max(pages)~sum(pages) 之间，每次二分到一个时间 time_limit 的时候，用贪心法从左到右扫描一下 pages，看看需要多少个人来完成抄袭。 如果这个值 <= k，那么意味着大家花的时间可能可以再少一些，如果 > k 则意味着人数不够，需要降低工作量。

时间复杂度 $\mathrm{O(nlog(sum)) \; ==>不太容易想到。。。还是非常巧妙的！}$

$\mathrm{https://www.lintcode.com/problem/437/}$

是该问题时间复杂度上的最优解法

class Solution:
    """
    @param pages: an array of integers
    @param k: An integer
    @return: an integer
    """
    def copyBooks(self, pages, k):
        if not pages:
            return 0
            
        start, end = max(pages), sum(pages)
        while start + 1 < end:
            mid = (start + end) // 2
            if self.get_least_people(pages, mid) <= k:
                end = mid
            else:
                start = mid
                
        if self.get_least_people(pages, start) <= k:
            return start
            
        return end
        
    def get_least_people(self, pages, time_limit):
        count = 0
        time_cost = 0 
        for page in pages:
            if time_cost + page > time_limit:
                count += 1
                time_cost = 0
            time_cost += page
            
        return count + 1

 

from typing import (
    List,
)

class Solution:
    """
    @param pages: an array of integers
    @param k: An integer
    @return: an integer
    """
    def copy_books(self, pages: List[int], k: int) -> int:
        # write your code here        
        assert k > 0
        if not pages:
            return 0

        l, r = max(pages), sum(pages)
        while l + 1 < r:
            mid = (l + r) // 2
            num = self.need_least_people(pages, mid)   
            if num > k:
                l = mid
            else:
                r = mid
                
        if self.need_least_people(pages, l) <= k:
            return l   

        return r
        
    def need_least_people(self, pages, n):
        ans = 0
        s = 0
        i = 0
        while i < len(pages):
            while i < len(pages) and s + pages[i] <= n:
                s += pages[i]
                i += 1
            
            s = 0
            ans += 1            

        return ans

 

二分答案比较考察人的换角度思考能力。

633. 寻找重复的数

中文

English

给出一个数组 nums 包含 n + 1 个整数，每个整数是从 1 到 n (包括边界)，保证至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。

样例

Example 1:

Input:
[5,5,4,3,2,1]
Output:
5

Example 2:

Input:
[5,4,4,3,2,1]
Output:
4

注意事项

1.不能修改数组(假设数组只能读)
2.只能用额外的O(1)的空间
3.时间复杂度小于O(n^2)
4.数组中只有一个重复的数，但可能重复超过一次

基于值的二分法。 这个题比较好的理解方法是画一个坐标轴：

• x轴是 0, 1, 2, ... n。
• y轴是对应的 <=x 的数的个数，比如 <=0 的数的个数是0，就在（0,0）这个坐标画一个点。<=n 的数的个数是 n+1 个，就在 (n,n+1)画一个点。

把所有的点连接起来之后，是一个类似下图的折线：

我们可以知道这个折线图的有如下的一些属性：

1. 大部分时候，我们会沿着斜率为 1 的那条虚线前进
2. 如果出现了一些空缺的数，就会有横向的折线
3. 一旦出现了重复的数，就会出现一段斜率超过 1 的折线
4. 斜率超过 1 的折线只会出现一次

试想一下，对比 y=x 这条虚线，当折线冒过了这条虚线出现在这条虚线的上方的时候，一定是遇到了一个重复的数。 一旦越过了这条虚线以后，就再也不会掉到虚线的下方或者和虚线重叠。 因为折线最终会停在 (n,n+1) 这个位置，如果要从 y=x 这条虚线或者这条虚线的下方到达 (n,n+1) 这个位置， 一定需要一个斜率 > 1的折线段，而这个与题目所说的重复的数只有一个就是矛盾的。因此可以证明，斜率超过1 的折线只会出现1次， 且会将折线整体带上 y=x 这条虚线的上方。因此第一个在 y=x 上方的 x 点，就是我们要找的重复的数。

时间复杂度是 $\mathrm{O(nlogn)}$

 

public class Solution {
    /**
     * @param nums an array containing n + 1 integers which is between 1 and n
     * @return the duplicate one
     */
    public int findDuplicate(int[] nums) {
        // Write your code here
        int l = 1;
        int r = nums.length - 1;  // n
        
        while (l + 1 < r) {
            int mid = l + (r - l) / 2;
            if (count(nums, mid) <= mid) {
                l = mid;
            } else {
                r = mid;
            }
        }
        
        if (count(nums, l) <= l) {
            return r;
        }
        return l;
    }
    
    private int count(int[] nums, int mid) {
        int cnt = 0;
        for (int item : nums) {
            if (item <= mid) {
                cnt++;
            }
        }
        return cnt;
    }
}

from typing import (
    List,
)

class Solution:
    """
    @param nums: an array containing n + 1 integers which is between 1 and n
    @return: the duplicate one
    """
    def find_duplicate(self, nums: List[int]) -> int:
        # write your code here
        l, r = 1, len(nums) - 1
        while  l + 1 < r:
            mid = (l + r) // 2
            if self.count_lessthan(nums, mid) <= mid:
                l = mid
            else:
                r = mid
        
        if self.count_lessthan(nums, l) <= l:
            return r
        
        return l

    def count_lessthan(self, nums, n):
        return sum(1 for i in nums if i <= n)

 

利用分值二分法來計算出答案。

答案的範圍會在start, end = 1, max(nums)之間，去計算小於等於mid的個數

617. 子数组的最大平均值 II

中文

English

给出一个整数数组，有正有负。找到这样一个子数组，他的长度大于等于 k，且平均值最大。

样例

Example 1:

Input:
[1,12,-5,-6,50,3]
3
Output:
15.667
Explanation:
 (-6 + 50 + 3) / 3 = 15.667

Example 2:

Input:
[5]
1
Output:
5.000

注意事项

保证数组的大小 >= k

基于二分答案的方法 二分出 average 之后，把数组中的每个数都减去 average，然后的任务就是去求这个数组中，是否有长度 >= k 的 subarray，他的和超过 0。==>解法不优雅！感觉还不如传统解决N^2前缀和解法！

class Solution:
    """
    @param: nums: an array with positive and negative numbers
    @param: k: an integer
    @return: the maximum average
    """
    def maxAverage(self, nums, k):
        if not nums:
            return 0
            
        start, end = min(nums), max(nums)
        while end - start > 1e-5:
            mid = (start + end) / 2
            if self.check_subarray(nums, k, mid):
                start = mid
            else:
                end = mid
                
        return start
        
    def check_subarray(self, nums, k, average):
        prefix_sum = [0]
        for num in nums:
            prefix_sum.append(prefix_sum[-1] + num - average)
            
        min_prefix_sum = 0
        for i in range(k, len(nums) + 1):
            if prefix_sum[i] - min_prefix_sum >= 0:
                return True
            min_prefix_sum = min(min_prefix_sum, prefix_sum[i - k + 1])
            
        return False

我们再来一个结合贪心的二分搜索（当然，用dp更直观）

300. 最长递增子序列

 

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

 

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

import bisect

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        """
        如果使用二分查找算法，我们可以维护一个数组tails，其中tails[i]是长度为i+1的所有递增子序列中末尾元素的最小值。对于每个元素nums[i]，我们可以使用二分查找在tails中找到第一个大于nums[i]的元素，并用nums[i]替换它。如果nums[i]大于tails中的所有元素，那么我们就将nums[i]添加到tails的末尾。最后，tails的长度就是最长递增子序列的长度。
        见https://leetcode.cn/problems/longest-increasing-subsequence/solutions/24173/zui-chang-shang-sheng-zi-xu-lie-dong-tai-gui-hua-2/?company_slug=bytedance 本质上是贪心
        """
        tails = []
        for num in nums:
            index = bisect.bisect_left(tails, num)
            if index == len(tails):
                tails.append(num)
            else:
                tails[index] = num
        return len(tails)