挑战程序设计 第三章笔记

3.1 不光是查找值！“二分搜索”

3.1.1 从有序数组中查找某个值

数的范围

给定一个按照升序排列的长度为 n 的整数数组，以及 q个查询。

对于每个查询，返回一个元素 k 的起始位置和终止位置（位置从 00 开始计数）。

如果数组中不存在该元素，则返回 -1 -1。

二分查找

#include <iostream>
using namespace std;

const int N = 100010;
int n, q, nums[N];

int lower_bound(int x){
    int low = 0, high = n;//返回>=x的第一个数的下标，可能所有数都小于x返回n+1
    while (low < high){
        int mid = low + (high - low) / 2;
        if (nums[mid] >= x) high = mid;
        else    low = mid+1;
    }
    return low;
}

int main(){
    cin >> n >> q;
    for (int i = 0; i < n; i++)    cin >> nums[i];
    while (q--){
        int x;
        cin >> x;
        int low = lower_bound(x), high = lower_bound(x+1);
        if (low == n || (nums[low] != x))   low = -1;
        if (nums[high-1] != x)  high = -1;
        if (low == -1 || high == -1)    
            cout << "-1 -1" << endl;
        else
            cout << low << " " << high-1 << endl;
    }
    return 0;
}

在C++的STL容器中实现了lower_bound(first_iterator, last_iterator, val)返回>=val的第一个元素的地址

upper_bound(first_iterator, last_iterator, val)返回>val的第一个元素的地址

数的三次方根

给定一个浮点数 n，求它的三次方根。

只要满足单调性就可以利用二分查找

#include <iostream>
using namespace std;

int main(){
    double n, error = 1e-8;
    cin >> n;
    double left = -100, right = 100;
    while (right - left > error){
        double mid = left + (right - left) / 2;
        if (mid*mid*mid >= n)
            right = mid;
        else
            left = mid;
    }
    printf("%.6f", right);
    return 0;
}

3.1.2 判断一个解是否可行

Cable master

N条绳子，分成K段，每条绳子的长度是Li，每条绳子最长的长度是多少，保留两位小数

单调性：绳子越长，可以分成的段数越少，反之可以分成的段数越多

二分绳子的长度

#include <iostream>
#include <cmath>
using namespace std;

const int N = 10010;
int n, k;
double nums[N];

bool judge(double x){
    //将所有的绳子分成长度为x的k段是否可行
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += (int) (nums[i] / x);
    return sum >= k;
}

int main(){
    cin >> n >> k;
    for (int i = 0; i < n; i++)
        cin >> nums[i];
    double left = 0, right = 0x3f3f3f3f ,eps = 1e-10;
    while (right - left > eps){
        double mid = left + (right - left) / 2;
        if (judge(mid)) left = mid;
        else right = mid;
    }
    printf("%.2f", floor(right * 100) / 100);	//保留小数点后两位
    return 0;
}

3.1.3 最大化最小值

Aggressive cows

题目大意：n个房子，m头牛，房子有一个横坐标，问将m头牛塞进房子，每两头牛之间的最大间隔是多少。

单调性：假设最大间隔为d，d越大在n个牛舍里面可以放置的牛的数量越少，反之可以放置的牛的数量越多

对最大间隔d进行二分

使用贪心算法来判断d是否是一个可行解

#include <iostream>
#include <algorithm>
using namespace std;

const int MAX_N = 100010;
int N, M, nums[MAX_N];

bool check(int d){
    //任意两头牛之间的距离>=d
    int last = 0;   //贪心：第一头牛放在nums[0]的位置
    for (int i = 1; i < M; i++){
        int cur = last + 1;     //当前牛的位置放在last之后
        while (cur < N && nums[cur] < nums[last] + d)//当两头牛之间的距离<d，不断向后寻找新的位置
            cur++;
        if (cur == N)   //第i头牛没有位置可以放置
            return false;
        last = cur;     //更新上一次放置牛的位置
    }
    return true;
}

int main(){
    cin >> N >> M;
    for (int i = 0; i < N; i++)
        cin >> nums[i];
    sort(nums, nums + N);
    int left = 0, right = nums[N-1] - nums[0];
    while (right - left > 1){
        int mid = (left + right) / 2;
        if (check(mid))
            left = mid;
        else    
            right = mid-1;
    }
    /*	二分查找有不同的形式，注意如果没处理好可能会陷入死循环
    while (left < right){
        int mid = (left + right + 1) >> 1;
        if (check(mid))
            left = mid;
        else    
            right = mid-1;
    }
    */
    cout << left << endl;
    return 0;
}

3.1.4 最大化平均值

n个物品的重量和价值分别是wi, vi，从中选出k个物品使单位重量的价值最大

样例输入：

3 2
2 2
5 3
2 1

样例输出：

0.75 （选取第1个和第3个物品）

试图使用贪心算法，对物品的单位重量的价值进行排序，从高到低选取k个

那么选取的是第1个物品和第二个物品，单位重量的价值 = （2 + 3）/ (2 + 5) = 0.714

单调性，对于单位重量的价值x而言，x越大满足的物品个数越少，反之满足的物品数量越少

利用二分查找来求最大的平均值

假设check(x)判断满足k个物品中单位重量的价值是否>=x

#include <iostream>
#include <algorithm>
using namespace std;

const int MAX_N = 10010;
int n, k, w[MAX_N], v[MAX_N];
double y[MAX_N];

bool check(double x){
    for (int i = 0; i < n; i++){
        y[i] = v[i] - x * w[i];
    }
    sort(y, y+n);
    double sum = 0;
    for (int i = 0; i < k; i++){
        sum += y[n-i-1];
    }
    return sum >= 0;
}

int main(){
    cin >> n >> k;
    double left = 0, right = 0, eps = 1e-10;
    for (int i = 0; i < n; i++){
        cin >> w[i] >> v[i];
        if (1.0 * v[i] / w[i] > right)
            right = v[i]/w[i];
    }
    while (right - left > eps){
        double mid = (right + left) / 2;
        if (check(mid)){
            left = mid;
        }else    
            right = mid;
    }
    cout << right << endl;
    return 0;
}

3.1.5 summary

二分查找并不只限于查找元素值，对于具有单调性的问题，可以尝试使用二分查找

练习

最小化数组中的最大值

礼盒的最大甜蜜度

如果遇到死循环，可以修改循环条件

while (left < right) 和 while (right - left > 1) 根据题意返回left或者right