【基础算法】二分

二分

0x01：基本概念

【基本思路】
在闭区间 [l, r]之间，每次将区间长度缩小一半，当 l == r时，我们就找到目标值。
【使用情况】
在闭区间内存在边界值，左边（右边）符合，右边（左边）不符合，再根据边界值是属于那一边的分两种情况。
一个区间具有单调性质,就一定可以二分。
或者具有某种区间性质的话,也可以使用二分.
二分的题目一般会出现最大值最小值,或者单调性质,

0x02：版本1（left）

将区间[l, r]划分为[l, mid]和[mid + 1, r]时，其更新操作是 r = mid或者l = mid + 1，计算mid时不需要加1

int bsearch_1(int l, int r){ //边界属于左边
	while(l < r){
		int mid = l + r >> 1;
		if(check(mid)) r = mid;
		else l = mid + 1;
	}
	return l;
}

0x03：版本2（right）

将区间[l, r]划分成[l, mid - 1]和[mid, r]时，其更新操作是 r = mid - 1，或者 l = mid，此时为了防止死循环，计算 mid时需要加1

int bsearch_2(int l, int r){ // 边界属于右边
	while(l < r){
		int mid = l + r + 1 >> 1;
		if(check(mid)) l = mid;
		else r = mid - 1;
	}
	return l;
}

0x04：实数二分

double l = a, r = b;
while(r - l > esp){
	double mid = (l + r) / 2;
	if(check()) r = mid;
	else l = mid;
}

0x04：连个版本的区别

check(mid)是确定mid的合法性。

题目总结

0x01：数的范围

【题目】
给定一个按照升序排列的长度为n的整数数组，以及 q 个查询。
对于每个查询，返回一个元素k的起始位置和终止位置（位置从0开始计数）。
如果数组中不存在该元素，则返回“-1 -1”。

【输入格式】
第一行包含整数n和q，表示数组长度和询问个数。
第二行包含n个整数（均在1~10000范围内），表示完整数组。
接下来q行，每行包含一个整数k，表示一个询问元素。
【输出格式】
共q行，每行包含两个整数，表示所求元素的起始位置和终止位置。
如果数组中不存在该元素，则返回“-1 -1”。

【数据范围】

1≤n≤100000 
1≤q≤10000 
1≤k≤10000 

【输入样例】

6 3
1 2 2 3 3 4
3
4
5

【输出样例】

3 4
5 5
-1 -1

【解题思路】
二分
分别找到最左边和最右边的index，分别用来两种模板
找左边界时，条件是【a[ mid ] >= num】右边相等的数位置不要变，左边的可以去掉，向前走一步;
找右边界时，条件是【a[ mid ] <= num】左边相等的数位置不要变，右边的可以去掉，向后退一步;
【CODE】

#include<iostream>

using namespace std;

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

int main(){
    cin >> n >> q;
    for(int i = 0; i < n; ++i) cin >> a[i];
    
    while(q --){
        int x;
        cin >> x;
        
        int l = 0, r = n - 1;
        while(l < r){ // 找到左边界
            int mid = l + r >> 1;
            if(a[mid] >= x)r = mid;
            else l = mid + 1;
        }
        
        if(a[l] != x){ // 找到有边界
            cout << "-1 -1" << endl;
            continue;
        }
        int res = l;
        
        r = n - 1;
        while( l < r){
            int mid = l + r + 1 >> 1;
            if(a[mid]  <= x) l = mid;
            else r = mid - 1;
        }
        
        cout << res << " " << l << endl;
    }
    return 0;
}

0x02：数的三次方

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

【输入格式】
共一行，包含一个浮点数n。
【输出格式】
共一行，包含一个浮点数，表示问题的解。
注意，结果保留6位小数。

【数据范围】

−10000≤n≤10000 

【输入样例】

1000.00

【输出样例】

10.000000

【解题思路】
实数二分
【CODE】

#include<iostream>

using namespace std;

const double esp = 1e-7;

double a;

int main(){
    
    cin >> a;
    
    double l = -10000, r = 10000; // 有负数的存在，需要遍历所有
   
    
    while(r - l >= esp){
        double mid = (l + r) / 2;
        if(mid * mid * mid >= a) r = mid;
        else l = mid;
    }
    
    printf("%.6lf", l);
    
    return 0;
    
}

0x03：最佳牛围栏

【题目】
农夫约翰的农场由 N 块田地组成，每块地里都有一定数量的牛,其数量不会少于1头，也不会超过2000头。
约翰希望用围栏将一部分连续的田地围起来，并使得围起来的区域内每块地包含的牛的数量的平均值达到最大。
围起区域内至少需要包含 F 块地，其中 F 会在输入中给出。
在给定条件下，计算围起区域内每块地包含的牛的数量的平均值可能的最大值是多少。

【输入格式】
第一行输入整数 N 和 F ，数据间用空格隔开。
接下来 N 行，每行输入一个整数，第 i+1 行输入的整数代表第 i 片区域内包含的牛的数目。
【输出格式】
输出一个整数，表示平均值的最大值乘以1000再 向下取整 之后得到的结果。

【数据范围】

1≤N≤100000 
1≤F≤N 

【输入样例】

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

【输出样例】

6500

【解题思路】
对平均值进行实数二分
【CODE】

#include<iostream>

using namespace std;

const int N = 100010;
const double esp = 1e-6;

int a[N];
double sum[N];
int n, m;

bool check(double avg){
    for(int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i] - avg;
    
    double mins = 0;
    for(int i = m, j = 0; i <= n; ++i, ++j){
        mins = min(mins, sum[j]);
        if(sum[i] - mins >= esp) return true;
    }
    return false;
    
    
}

int main(){
    cin >> n >> m;
    double l = 0, r = 0;

    for(int i = 1; i <= n ; ++i){
        cin >> a[i];
        r = max(r, double(a[i]));
    }
    
    while(r - l >= esp){ // 对平均值二分
        double mid = (r + l) / 2;
        if(!check(mid)) r = mid;
        else l =mid;
    }
    
    cout << int(r * 1000 ) << endl;
    return 0;
}

0x04：特殊排序

【题目】
有N个元素，编号1.2…N，每一对元素之间的大小关系是确定的，关系具有反对称性，但不具有传递性。
注意：不存在两个元素大小相等的情况。
也就是说，元素的大小关系是N个点与N*(N-1)/2条有向边构成的任意有向图。
然而，这是一道交互式试题，这些关系不能一次性得知，你必须通过不超过10000次提问来获取信息，每次提问只能了解某两个元素之间的关系。
现在请你把这N个元素排成一行，使得每个元素都小于右边与它相邻的元素。
你可以通过我们预设的bool函数compare来获得两个元素之间的大小关系。
例如，编号为a和b的两个元素，如果元素a小于元素b,则compare（a,b）返回true，否则返回false。
将N个元素排好序后，把他们的编号以数组的形式输出，如果答案不唯一，则输出任意一个均可。

【数据范围】

1≤N≤1000 

【输入样例】

[[0, 1, 0], [0, 0, 0], [1, 1, 0]]

【输出样例】

[3, 1, 2]

【解题思路】
首先读题可以知道这题是符合单调性质的
例：如果 i 大于a（已排好序的其中一个元素） 那么 i 一定可以再 a 的右侧找到一个位置插入。这样就有一个边界值，可以使用二分找出。
【CODE】

// Forward declaration of compare API.
// bool compare(int a, int b);
// return bool means whether a is less than b.

class Solution {
public:
    vector<int> specialSort(int N) {
        vector<int> res;
        res.push_back(1);
        for(int i = 2; i <= N; ++i){
            int l = 0, r=res.size() - 1;
            while(l < r){
                int mid = l + r + 1>> 1;
                if(compare(res[mid], i)) l = mid;
                else r = mid - 1;
            }
            res.push_back(i);
            for(int i = res.size() - 2; i > r; --i){ //将元素后移
                swap(res[i], res[i + 1]);
            }
            if(compare(i, res[r])) swap(res[r], res[r + 1]); // 防止 i 最小
        }
        return res;
    }
};

练习

0x01：分巧克力

【题目】
儿童节那天有 K 位小朋友到小明家做客。
小明拿出了珍藏的巧克力招待小朋友们。
小明一共有 N 块巧克力，其中第 i 块是 Hi×Wi 的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出 K 块巧克力分给小朋友们。
切出的巧克力需要满足：
形状是正方形，边长是整数
大小相同
例如一块 6×5 的巧克力可以切出 6 块 2×2 的巧克力或者 2 块 3×3 的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小明计算出最大的边长是多少么？

【输入格式】
第一行包含两个整数 N 和 K。
以下 N 行每行包含两个整数 Hi 和 Wi。
输入保证每位小朋友至少能获得一块 1×1 的巧克力。
【输出格式】
输出切出的正方形巧克力最大可能的边长。

【数据范围】
1≤N,K≤105,
1≤Hi,Wi≤105

【输入样例】

2 10
6 5
5 6

【输出样例】

2

【解题思路】
二分模板
【CODE】

#include<iostream>

using namespace std;

const int NUM = 100000;

int N, M;
int g[NUM][5];

bool check(int mid){
    int num = 0;
    for(int i = 0; i < N; ++i){
        num += (g[i][0] / mid) * (g[i][1] / mid);
    }
    if(num >= M) return true;
    else return false;
}


int main(){
    cin >> N >> M;
    int r = 0;
    for(int i = 0; i < N; ++i){
        cin >> g[i][0] >> g[i][1];
        r = max(r, g[i][0]);
        r = max(r, g[i][1]);
    }
    
    int l = 0;
    while(l < r){
        int mid = l + r + 1>> 1;
        if(check(mid)) l = mid;
        else r = mid - 1;
    }
    cout << r << endl;
    return 0;
}