二分法

1. 二分查找法代码实现：

// 二分查找法
// A[]为严格递增序列，left为二分下界，x为欲查询的数
// 二分区间为左闭右闭的[left, right], 传入的初值为[0, n-1]
int binarySearch(int A[], int left, int right, int x){
    int mid;
    while (left <= right){
        mid = (left + right) / 2;  // mid = left + (right - left) / 2;
        if (A[mid] == x){
            return mid;
        }
        else if (A[mid] > x){
            right = mid - 1;
        }
        else if (A[mid] < x){
            left = mid + 1;
        }
    }

    return -1;
}

 

2. 二分法求序列中第一个大于等于x的元素的位置L

// 求序列中第一个大于等于x的元素的位置L
// 二分上下界为左闭右闭的[left, right], 传入的初值为[0, n]
int lower_bound(int A[], int left, int right, int x){
    int mid;
    while (left < right){
        mid = (left + right) / 2;        
        if (A[mid] >= x){
            right = mid;
        }
        else{
            left = mid + 1;
        }
    }
    return left;            // 返回夹出来的位置
}

 

3. 二分法求序列中第一个大于x 的元素的位置R

int upper_bound(int A[], int left, int right, int x){
    int mid;
    while (left < right){
        mid = (left + right) / 2;
        if (A[mid] > x){
            right = mid;
        }
        else{
            left = mid + 1;
        }
    }
    return left;
}

 

4. 二分法解决“寻找有序序列第一个满足某条件的元素的位置”问题的固定模板

// 二分区间为左闭右闭[left, right]， 初值必须能覆盖解的所有取值
int solve(int left, int right){
    int mid;
    while (left < right){
        mid = (left + right) / 2;
        if (条件成立){
            right = mid;
        }
        else{
            left = mid + 1;
        }
    }

    return left;
}

 

5. 二分法求根号2的近似值

double calSqrt(){
    double left = 1, right = 2, mid;        // [left, right] = [1, 2]
    while (right - left > eps){
        mid = (left + right) /2;
        if (f(mid) > 2){
            right = mid;
        }
        else{
            left = mid;
        }
    }

    return mid;
}

 

6. 二分法求某个单调函数根的近似值

// 利用二分法求单调函数的根
const double eps2 = 1e-5;
double f(double x){
    return ...;            // 写函数的表达式
}

double solve(double L, double R){
    double left = L, right = R, mid;
    while (right - left > eps2){
        mid = (left + right) / 2;
        if (f(mid) > 0){
            right = mid;
        }
        else{
            left = mid;
        }
    }
    return mid;
}            

 

7. 快速幂的递归写法（二分法实现）

// 快速幂的递归写法
typedef long long LL;
// a^b & m
LL binaryPow(LL a, LL b, LL m){
    if (b == 0)
        return 1;
    if (b & 1){            // 如果b为奇数
        return a * binaryPow(a, b - 1, m) % m;
    }
    else{
        LL mu = binaryPow(a, b / 2, m);
        return mu * mu % m;
    }
}

 

 

二分使用实战：

　　　　　　　　1030 完美数列 (25分)

给定一个正整数数列，和正整数 p，设这个数列中的最大值是 M，最小值是 m，如果 M≤mp，则称这个数列是完美数列。

现在给定参数 p 和一些正整数，请你从中选择尽可能多的数构成一个完美数列。

输入格式：

输入第一行给出两个正整数 N 和 p，其中 N（≤10​5​​）是输入的正整数的个数，p（≤10​9​​）是给定的参数。第二行给出 N 个正整数，每个数不超过 10​9​​。

输出格式：

在一行中输出最多可以选择多少个数可以用它们组成一个完美数列。

输入样例：

10 8
2 3 20 4 5 1 6 7 8 9

 

输出样例：

8

 

分析：输入数据到数组，对数组进行排序，对每个元素用二分法求出第一个大于 a[i] * p 的元素的位置 j ，（j - i) 即为完美数列的长度，将所有长度取最大值即为结果

代码：这里用到了上面求序列中第一个大于x 的元素的位置R的函数upper_bound()

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
using namespace std;

long long a[100010] = { 0 };

long long upper_bound(long long A[], long long left, long long right, long long x){
    long long mid;
    while (left < right){
        mid = (left + right) / 2;
        if (A[mid] > x){
            right = mid;
        }
        else{
            left = mid + 1;
        }
    }
    return left;
}

int main()
{
    freopen("in.txt", "r", stdin);
    long long ans = 1;        //  存储“完美数列”的最大长度
    long long n, p;
    scanf("%lld %lld", &n, &p);

    // 读取输入
    for (long i = 0; i < n; i++){
        scanf("%lld", &a[i]);
    }
    // 排序
    sort(a, a + n);
    // 遍历数组，对每个元素都查找最大值的位置j，区间长度与ans比较，取较大者
    for (long long i = 0; i < n; i++){
        // 寻找第一个大于a[i] * p的元素的位置
        long long j = upper_bound(a, i + 1, n, a[i] * p);
        ans = max(ans, j - i);
    }
    printf("%lld\n", ans);
    fclose(stdin);
    return 0;
}