二分查找模版(必背)

模板 1 - binary_search

• 没有重复元素时，目标值若存在，则返回索引；若不存在，返回 -1
• 存在重复元素时，目标值若存在，则返回最小索引；若不存在，返回 -1

模板 2 - lower_bound

• 返回大于(含等于)目标值的最小索引（第一个大于、等于目标值的索引返回0）

​

模板 3 - upper_bound

• 返回大于等于目标值的最大索引+1（第一个大于目标值的索引返回3）

​

注意点：

- 跳出时都有lo + 1 == hi统一返回lo + 1或hi

- lo = -1 and hi = nums.size()和 lo = 0 and hi = nums.size() - 1取中时一致

/*为什么返回 `lo+1`，而不是 `hi`？（退出循环时有 lo + 1 == hi）
    模板开始时将 (lo, hi) 看做是一个开区间，通过不断二分，最终这个区间中只会含有一个值，即 (lo, hi]
    返回 lo+1 的含义是，结果就在 lo 的下一个；
    在迭代的过程中，hi 会从开区间变为闭区间，而 lo 始终是开区间，
    返回 lo+1 显得更加统一。
    当然，这跟迭代的写法是相关的，你也可以使最终的结果区间是 [lo, hi)nums[mid]<=v，
    这取决于个人习惯。
*/

int binary_search(vector<int> nums, int  n){
    if(nums.size() < 1) return -1;
    int lo = -1, hi = nums.size();
    while(lo + 1 < hi){
        int mid = lo + (hi - lo)/2;
        if(nums[mid] < n)
            lo = mid;
        else
            hi = mid;
    }
  	if(hi == nums.size()) return -1;//lo+1 = hi,防止return时访问越界
    return nums[lo+1] == n ? lo+1 : -1;
}

//满足条件<lo往右,else收缩（low,high]终值在闭区间右侧上6667(-1,0]
int lowwer_bound(vector<int> nums, int  n){
    if(nums.size() < 1) return -1;
    int lo = -1, hi = nums.size();
    while(lo + 1 < hi){
        int mid = lo + (hi - lo)/2;
        if(nums[mid] < n)
            lo = mid;
        else
            hi = mid;
    }
    return lo + 1;
}

//满足条件<=lo往右,=继续往右找到[low,high)6667[2,3)
int upper_bound(vector<int> nums, int  n){
    if(nums.size() < 1) return -1;
    int lo = -1, hi = nums.size();
    while(lo + 1 < hi){
        int mid = lo + (hi - lo)/2;
        if(nums[mid] <= n)
            lo = mid;
        else
            hi = mid;
    }
    return lo + 1;
}

int main(){
    vector<int> test{1,2,2,3,4,6,6,6,8,9};
    auto ret = blowwer_bound(test, 10);
  	//10,下标已经越界,但和下题不同,下题要求找不到返回的是-1
    cout << ret;
}

做到题测试一下，先别看答案。

LeetCode练习：34. Find First and Last Position of Element in Sorted Array

int lowwer_bound(vector<int> nums, int  n){
    if(nums.size() < 1) return -1;
    int lo = -1, hi = nums.size();
    while(lo + 1 < hi){
        int mid = lo + (hi - lo)/2;
        if(nums[mid] < n)
            lo = mid;
        else
            hi = mid;
    }
    if(hi == nums.size()) return -1;
    return nums[hi] == n ? hi : -1;
}
int upper_bound(vector<int> nums, int  n){
    if(nums.size() < 1) return -1;
    int lo = -1, hi = nums.size();
    while(lo + 1 < hi){
        int mid = lo + (hi - lo)/2;
        if(nums[mid] <= n)
            lo = mid;
        else
            hi = mid;
    }
    if(lo == -1) return -1;
    return nums[lo] == n ? lo : -1;
}
vector<int> searchRange(vector<int>& nums, int target) {
    vector<int> res;
    res.push_back(lowwer_bound(nums, target));
    res.push_back(upper_bound(nums, target));
    return res;
}

附上常见的写法，其实本质是一样的:

template<typename T>
int binarySearch(vector<T> &vec, T key){
    if(vec.size() < 0)
        return -1;
    int low = 0;
    int high = vec.size() - 1;
    int mid = 0;
    //low=high时不能跳出，此时需要进去进行vec[mid]==key判断
    while(low <= high){
        mid = low + (high - low)/2;
        if(vec[mid] == key)
            return mid;
        if(vec[mid] < key)
            low = mid + 1;
        else
            high = mid - 1;
    }
    //没找到返回-1
    return -1;
}

扩展：

/*
二分查找最优解的模板：
    在一定精度下，求满足条件 C 的最大/小解 x

注意点：
    - 初始化上下界：
        求最大值时，将下界 lo 初始化为一个特殊的可行解；上界初始化为一个不满足条件的解
        求最小值时，反之
    - 一般这种最优解问题会提供精度要求，需要在返回时处理
        - 最大值用“下取整” floor(ret * 1000) / 1000 ——三位精度，floor: 地板
        - 最小值用“上取整” ceil(ret * 1000) / 1000  ——三位精度，ceil:  天花板

*/

/*例 1：
求大于 目标值 v(>0) 的最小值，精确到 3 位小数
*/
double min_bigger(double v) {
    // 初始化上下界
    double lo = v - EPSILON, hi = INF;
    for (size_t i = 0; i < 100; i++) {          // 100 次循环已经能达到相当的精度
        double mid = lo + (hi - lo) / 2.0;
        if (mid <= v)
            lo = mid;
        else
            
            hi = mid;
    }
    // 因为 hi 在解空间中（hi 必大于 v），所以返回 hi
    return ceil(hi * 1000) / 1000; // 三位精度
}


/*例 2：POJ No.1064
    有 N 条绳子，长度分别为 Li。如果从它们中切割出 K 条长度相同的绳子，求这 K 条绳子的最大长度。答案保留 2 位小数。
*/
class Solution {
public:
    double max_length(vector<double> ls, int k) {
        double lo = 0, hi = INF;

        for (size_t i = 0; i < 100; i++) {
            double mid = lo + (hi - lo) / 2;

            if (C(ls, mid, k))
                lo = mid;
            else
                hi = mid;
        }
        // 因为 lo 在解空间中，所以返回 lo
        return floor(lo * 100) / 100;
    }
    
private:
    bool C(vector<double> ls, double mid, double k) {
        int n = 0;
        for (size_t i = 0; i < ls.size(); i++) {
            n += ls[i] / mid;
        }
        return n >= k; 
        // n >= k 说明还有加大的空间，所以当 C 返回 true 时，lo = mid
    }
};