0x04二分

二分：一般二分的基础用法是在单调序列或单调函数中进行查找。因此当问题的答案具有单调性时，就可能通过二分把求解转化为判定。
整数二分：下面的二分的写法保证最终答案处于闭区间[l,r]之内，循环以l=r结束，每次二分的中间值mid会归属于左半段与右半段二者之一。
在单调递增序列a中查找>=x的数中最小的一个（当没有找到x，停留在大于x的数中最小的一个）（即x或x的后继）(左边界)

while(l<r){
	int mid = (l+r)>>1;
	if(a[mid]>=x) r = mid
	else l = mid+1;
}
return a[l];

在单调递增序列a中查找<=x的数中最大的一个（当没有找到x时，停留在小于x数中最大的一个）（即x或x的前驱）（右边界）

while(l<r){
	int mid = (l+r+1)>>1;  //假如这里也用mid = (l+r)>>1  那么会出现错误 
	if(a[mid]<=x) l = mid;  //当r-l等于1 时，即当r=1, l = 0吋，mid = (l+r)>>1  
	else r=mid-1;            //  mid = 0,如果还是进入 l=mid 这个分支，则区间没有缩小，造成死循环。
	
}

注意：二分实现中的采用了右移运算>>1，而不是整数除法/2。这是因为右移运算是向下取整，而整数除法是向零取整，在二分值域包含负数时后者不能正常工作。

实数域上的二分：
在实数域上二分较为简单，确定好所需的精度 eps，以l+eps<r为循环条件，每次根据在mid上的判定选择 r = mid 或 l =mid 分支之一即可。一般需要保留k位小数时，则取eps = 10^-(k+2)

while(l+1e-5<r){
	double mid = (l+r)/2;
	if(calc(mid))  r=mid;
	else l = mid;
}

有时精度不容易确定或表示，就干脆采用循环固定次数的二分方法，也是一种相当不错的策略。这种方法得到的结果的精度通常比设置eps更高。

for(int i = 0; i<100;i++){
	double mid = (l+r)/2;
	if(calc(mid)) r = mid;
	else l = mid;
 }

三分求单峰函数极值：
有一类函数被称为单峰函数，它们拥有唯一的极大值点，在极大值点左侧严格单调上升，右侧严格单调下降；或者拥有唯一的极小值点，在极小值点左侧严格单调下降，在极小值点右侧严格单调上升。
以单峰函数f为例，我们在函数定义域[l,r]上任取两个点lmid与rmid，把函数分成三段。
1.若f(lmid)<f(rmid)，则lmid与rmid要么同时处于极大值点左侧（单调上升函数段），要么处于极大值点两侧。无论哪种情况，极大点都在lmid右侧。可令 l=lmid。
2.同理，若f(lmid)>f(rmid)，则极大值点一定在mid左侧，可令r = rmid。
如果我们取lmid与rmid为三等分点，那么定义域范围每次缩小1/3。如果我们取lmid与rmid在二等分点两侧极其接近的地方，那么定义域范围每次近似缩小1/2。通过log级别的时间复杂度即可在指定精度下求出极值，这就是三分法。
注意：我们在介绍单峰函数时特别强调了“严格”单调性。若在三分法过程中遇到f(lmid) = f(rmid) ，当函数严格单调时，令l = lmid 或 r = rmid均可。如果函数不严格单调，即在函数中存在一段值相等的部分，那么我们无法判断定义域的左右边界如何缩小，三分法就不再适用。

二分答案转化为判定：
一个宏观的最优化问题也可以抽象为函数，其“定义域”是该问题下的可行方案，对这些可行方案进行评估得到的数值构成函数的“值域”，最优解就是评估值最优的方案（不妨设评分越高越优）。假设最优解的评分是S，显然对于x>s,都不存在一个合法的方案达到x分。否则就与的最优性矛盾；而对于x<=s，一定存在一个合法方案达到或超过x分，因为最优解就满足这个条件。这样问题的值域就具有一种特殊的单调性------在S的一侧合法，在S的另一侧不合法，就像一个在(-oo ，S]上值为1，在（S，+oo）上值为0的分段函数，可通过二分找到这个分界点S。借助二分，我们把求最优解的问题，转化为给定一个值mid，判定是否存在一个可行方案评分达到mid的问题。

题目一：有N本书排成一行，已知第i本的厚度是Ai。把它们分成连续的M组，使T最小化。其中T表示厚度之和最大的一组的厚度。
题目思想：题目描述中出现了类似于“最大值最小”的含义，这说明答案具有单调性，可用二分转化为判定的最常见、最典型的特征之一。如果我们以“把书划分为M组的方案”作为定义域，“厚度之和最大的一组的厚度”作为评分（即值域），需要最小化这个厚度值，也就是评分越小越优，相应地， 假设最终答案为S，因为S的最优性，如果要求每组厚度都<s，那么这M组一定不能容纳这些书，可能需要更多的组才能把书分完，也就意味着对于本题的限制条件不存在可行的分书方案。如果每组的厚度可以>S，那么一定存在一种分书方案使得组数不会超过M。最优解就处于分书可行性的分界点上。

#include<iostream>
#include<algorithm>
using namespace std;
const int N =10010;
int n,m;
int a[N];
bool valid(int size){
    int group = 1;
    int rest = size;
    for(int i=1;i<=n;i++){
        if(rest>=a[i]) rest-=a[i];
        else group++,rest = size - a[i];
    }
    return group<=m;
}
int main(){
    cin>>n>>m;
    int s,l,r;
    s=l=r=0;
    for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            r+=a[i];
        }
    while(l<r){
        int mid = (l+r)/2;
        if(valid(mid)) r = mid;
        else l = mid+1;
    }
    cout<<l<<endl;
    return 0;
}

题目二：
农夫约翰的农场由 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

题目思想：这道题目并没有二分的特征词，如“最大值最小，最小值最大”，而且数列也不单调，所以我们不能显示的得出来是否采用二分。那么我们判断是否存在一个平均值大于等于mid，如果最优解是x，那么mid<=x的时候，必然可以找到一段，其 平均值>mid，否则一定找不到。
注意：对于二分，二分是二分性而不是单调性，只要满足可以找到一个值一半满足一半不满足即可，而不用满足单调性。
如果把数列中每个数都减去二分的值，就转化为判定“是否存在一个长度不小于L的子段，子段和非负”。
我们不仅需要找到F大小区间内，我们还要打到>F区间内的，我们如果用二次for太费时间了，我们这里可以使用双指针的做法，我们设i=0,j=F每次使两个数++ 因为i,j始终满足相距F的距离，所以我们用一个变量minv来存储i所遍历到的最小值，这样我们比较的距离一定是≥F的，并且如果我们用j位的前缀和数减去minv的话，就能得到我们的最优解，如果这个最优解＞= 0 那么就满足我们的指定条件（ 到此，结束）

#include<iostream>
using namespace std;
const int N =100010;
int n,f;
double sum[N];
int a[N];
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=0,j=f;j<=n;j++,i++){
        mins = min(mins,sum[i]);
        if(sum[j]-mins>0) return true;
    }
    return false;
}
int main(){
    cin>>n>>f;
    double l,r;
    l=r=0;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        r= max(r,(double)a[i]);
    }
    while(r-l>1e-5){
        double mid =(l+r)/2;
        if(check(mid)) l= mid;
        else r = mid;
    }
    cout<<(int)(r*1000)<<endl;
    return 0;
}

题目三：
有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]] // compare(1,1 ) =0 compare (1,2) =1(1<2)
//compare(3,1) =1(3<1) compare(3,2)=1(3<2)
输出样例
[3, 1, 2]

题目思想：我们可以通过二分法确定第k个元素的位置：若第k个元素比第mid个元素小，令r = mid，否则令 l = mid+1;然后再将数组向后挪一个空位，最后插入。

// 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 j=res.size()-2;j>r;j--) swap(res[j],res[j+1]);
            if(!compare(res[r],i)) swap(res[r],res[r+1]);  //如果所有的数都比这个数大，我只能放第一个
            
        }
        return res;
    }
};

题目四：
给定一个按照升序排列的长度为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

#include<iostream>
#include<algorithm>
using namespace std;
const int N =100010;
int n,m;
int a[N];
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    while(m--){
        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;
        else {
            cout<<l<<" ";
            int l=0,r=n-1;
            while(l<r){
                int mid = (l+r+1)>>1;
                if(a[mid]<=x) l=mid;
                else r = mid-1;
            }
            cout<<l<<endl;
        }
    }
    
    return 0;
}