极限二分查找：LeetCode87的二分法高级应用

极限二分查找：LeetCode87的二分法高级应用

【免费下载链接】leetcode 🔥LeetCode solutions in any programming language | 多种编程语言实现 LeetCode、《剑指 Offer（第 2 版）》、《程序员面试金典（第 6 版）》题解 项目地址: https://gitcode.com/gh_mirrors/leetcode87/leetcode

二分查找（Binary Search）作为算法领域的经典范式，其时间复杂度O(log n)的特性使其成为处理大规模数据查找的利器。本文将深入剖析LeetCode87项目中二分查找的高级应用场景，通过三个典型案例展示从基础实现到复杂问题求解的完整思路，帮助读者掌握二分查找的极限优化技巧。

二分查找核心原理与项目应用概述

二分查找基于分治思想，通过不断将搜索区间减半实现高效查找。其核心条件是数据有序性和随机访问能力。在LeetCode87项目中，二分查找不仅用于基础的元素定位，更被拓展到求解最优解、边界确定等复杂场景。项目目录结构中，二分查找相关题解主要分布在solution目录下，如在排序数组中查找元素的第一个和最后一个位置和准时到达的列车最小时速等典型问题。

二分查找算法框架

标准二分查找的实现需要关注三个关键要素：搜索区间定义、终止条件和边界收缩策略。项目中常见的实现模式有两种：

# 左闭右闭区间 [left, right]
def binary_search(nums, target):
    left, right = 0, len(nums)-1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# 左闭右开区间 [left, right)
def binary_search(nums, target):
    left, right = 0, len(nums)
    while left < right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid
    return -1

项目中更推荐使用左闭右开区间模式，因其在处理边界问题时更简洁，如34题就采用了这种实现。

案例一：边界定位问题——寻找元素的左右边界

问题定义与挑战

34. 在排序数组中查找元素的第一个和最后一个位置要求在非递减数组中找到目标值的起始和结束索引，若不存在则返回[-1, -1]。该问题的核心挑战在于处理重复元素和确定精确边界。

二分查找的边界扩展技巧

项目提供的最优解法通过两次二分查找实现：

1. 第一次查找目标值的左边界（第一个大于等于target的位置）
2. 第二次查找目标值+1的左边界（第一个大于等于target+1的位置）

这种"偏移查找"策略巧妙将边界问题转化为标准二分查找，代码实现如下：

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        l = bisect.bisect_left(nums, target)
        r = bisect.bisect_left(nums, target + 1)
        return [-1, -1] if l == r else [l, r - 1]

算法复杂度分析

时间复杂度	空间复杂度	优势
O(log n)	O(1)	两次二分查找，避免线性扫描

该实现利用Python标准库bisect模块的bisect_left函数，其内部采用左闭右开区间实现。对于Java等语言，则需要手动实现类似逻辑：

private int search(int[] nums, int x) {
    int left = 0, right = nums.length;
    while (left < right) {
        int mid = (left + right) >>> 1;  // 无符号右移避免溢出
        if (nums[mid] >= x) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

案例二：最优解问题——列车最小时速计算

问题建模与单调性分析

1870. 准时到达的列车最小时速要求计算满足到达时间约束的最小列车时速。该问题通过单调性分析可转化为二分查找问题：时速越高，总时间越短，存在明确的单调关系。

二分查找在最优解问题中的应用

问题转化关键步骤

1. 可行性判断：当列车数量n > hour的向上取整值时，必然无法准时到达（每趟列车至少需1小时）
2. 搜索空间定义：时速范围[1, 10^7]（题目约束）
3. 判定函数设计：计算当前时速下的总耗时，判断是否满足hour约束

核心实现代码

def minSpeedOnTime(dist: List[int], hour: float) -> int:
    if len(dist) > math.ceil(hour):
        return -1
    
    def check(v):
        total = 0.0
        n = len(dist)
        for i in range(n):
            t = dist[i] / v
            # 最后一趟列车无需等待，其余需向上取整
            total += t if i == n-1 else math.ceil(t)
            if total > hour:
                return False
        return total <= hour
    
    # 二分查找最小满足条件的速度
    left, right = 1, 10**7
    while left < right:
        mid = (left + right) // 2
        if check(mid):
            right = mid
        else:
            left = mid + 1
    return left if check(left) else -1

关键优化点解析

1. 浮点数精度处理：hour参数保留两位小数，计算时使用浮点数但通过适当比较避免精度误差
2. 搜索边界优化：右边界设为10^7（题目保证答案不超过此值）
3. early exit：在check函数中提前终止耗时计算

该示意图展示了时速与总时间的单调关系，二分查找过程就是寻找满足时间约束的最小时速点。

案例三：复杂条件查找——可移除字符的最大数目

问题背景与二分策略

1898. 可移除字符的最大数目要求在字符串s中最多移除k个指定位置字符后，判断p是否仍为s的子序列。该问题通过二分查找k的可能取值（0到len(removable)），将原问题转化为"移除k个字符后p是否为s的子序列"的判定问题。

二分查找与子序列判定的结合

算法框架

1. 二分范围：k的可能取值范围[0, len(removable)]
2. 判定函数：对于当前k值，检查移除前k个指定字符后p是否为s的子序列
3. 最优解选择：寻找最大满足条件的k值

判定函数实现关键

def is_subsequence(s, p, removed):
    # removed为已移除字符的集合
    i = j = 0
    n, m = len(s), len(p)
    while i < n and j < m:
        if i in removed:
            i += 1
            continue
        if s[i] == p[j]:
            j += 1
        i += 1
    return j == m

为提高效率，项目中采用哈希集合存储已移除索引，使查找操作达到O(1)复杂度。

性能对比与优化

实现方式	时间复杂度	空间复杂度
线性扫描	O(n*m)	O(1)
二分查找+哈希	O(log k*(n+m))	O(k)

通过二分查找，将时间复杂度从O(nm)优化为O(log k(n+m))，在k较大时性能提升显著。

二分查找的极限优化与项目最佳实践

常见陷阱与避坑指南

1. 整数溢出：计算mid时使用left + (right-left)//2而非(left+right)//2
2. 边界条件：明确区间定义（闭区间/开区间）并保持一致
3. 循环终止：避免死循环，确保每次迭代区间严格缩小

项目中的二分查找模板总结

LeetCode87项目提炼出两种通用二分查找模板：

模板一：查找特定值

def binary_search(nums, target):
    left, right = 0, len(nums)-1
    while left <= right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

模板二：寻找边界值

def find_boundary(nums, target):
    left, right = 0, len(nums)
    while left < right:
        mid = left + (right - left) // 2
        if condition(mid):
            right = mid
        else:
            left = mid + 1
    return left

高级应用场景拓展

1. 多维二分：在矩阵等二维结构中应用二分查找
2. 三分法：求解单峰函数的极值点
3. 二分答案：将最优化问题转化为判定问题

项目提供的最长重复子串题解就是二分查找与字符串哈希结合的典型案例，展示了二分思想在非数值查找场景的创新应用。

总结与未来学习路径

二分查找作为一种基础但强大的算法思想，在LeetCode87项目中展现出惊人的灵活性和扩展性。从简单的元素定位到复杂的最优解问题，二分查找始终是效率与简洁的平衡典范。建议读者通过以下路径深化学习：

1. 基础巩固：完成solution目录下所有二分查找标签的简单题
2. 进阶训练：重点研究"二分答案"类问题，如最小化最大值、最大化最小值等
3. 综合应用：尝试结合其他算法（如哈希、动态规划）解决复杂问题

通过项目提供的丰富案例和完整代码实现，读者可以系统掌握二分查找的各种变体及其在不同场景下的优化策略，最终达到"极限二分"的境界。

项目完整题解目录提供了更多二分查找相关问题，建议结合实际代码进一步研究算法的实现细节和优化技巧。

【免费下载链接】leetcode 🔥LeetCode solutions in any programming language | 多种编程语言实现 LeetCode、《剑指 Offer（第 2 版）》、《程序员面试金典（第 6 版）》题解 项目地址: https://gitcode.com/gh_mirrors/leetcode87/leetcode