对二分的一些探讨和理解

一.前引

假设有一个数组ai,满足a1<=a2<=a3<=...<=an,求最小的m满足am>=k.

若a[n/2]>=k,那么答案一定在n/2的左边，即m<=n/2,否则m>n/2

每一次答案的查询范围折半，这样logn次就能找到答案.

来看两个个实际的例子：

case 1:小明想了一个1~100之间的数让小红猜，每次小红告诉她认为的那个数，小明回答她大了或者小了直到正确.

假如小红先猜500，小明回答小了，小红再猜750.若小明回答大了，就猜250...就像这样不断地缩小范围，每次猜最中间的那个数，最后一定可以猜对.

case 2:在我们学校进行oi动员宣讲时，可爱的xr姐姐  xr学长带领我们做了一个翻书的游戏，这本书总共n页，我们要求他翻到某一页.他当时先翻到最中间，看一下页码，再决定是往前翻还是往后翻.不断地缩小范围，每次翻中间的一页，直到翻到指定页数

二.概念

二分查找，又名折半查找，是一种在有序表中快速查找的办法

通常，我们维护一个答案可能存在的区间，通过每次将要查找的值与区间的中央元素相比较，不断缩小区间，直到区间只剩下一个数，这个数即是答案.

区间一开始的长度是n,每次缩小一半，最后变为1，应操作O(log 2 n)次

三.代码实现

这里给出一道模板题目https://www.acwing.com/problem/content/791/

返回一个元素 k 的起始位置和终止位置

两遍二分，第一次找到第一个等于k的数，第二次找到最后一个等于k的数

#include <iostream>

using namespace std;

const int N=1e5+10;

int a[N];

int main()
{
    int n,q;
    cin>>n>>q;
    for(int i=0;i<n;i++) cin>>a[i];
    while(q--)
    {
        int k;
        cin>>k;
        int l=0,r=n-1;
        while(l<r)
        {
            int mid=l+r>>1;
            if(a[mid]<k) l=mid+1;
            else r=mid;           
        }
        if(a[l]!=k) 
        {
            cout<<"-1 -1"<<endl;
            continue;
        }
        cout<<l<<' ';
        l=0,r=n-1;
        while(l<r)
        {
            int mid=l+r+1>>1;
            if(a[mid]>k) r=mid-1;
            else l=mid;
        }
        cout<<r<<endl;
    }
    return 0;
}

四.应用

• 从有序数组里找给定的值
• 从有序数组里找大于等于给定的值的最小的值
• 寻找单调函数的零点
• 求一些方程的近似解
• 二分答案

这里我们介绍一下二分答案，顾名思义，它用二分的方法枚举答案，并且枚举时判断这个答案是否可行。但是，二分并不是在所有情况下都是可用的，使用二分需要满足两个条件。一个是有界，一个是单调。

• 最优化问题：在满足某些条件的情况下，最大化（最小化）某个值
• 可行性问题：在满足某些条件的情况下，构造出一个合法方案
• 在做一些最优化问题时，我们会遇到这样的情况：直接做比较困难，但是假如我们把问题转化一下，变成可行性问题，会变得简单。并且答案是单调的，那么就可以使用二分答案的技巧
• 套用上面二分查找的写法，然后把判断条件变成判断目标答案是否可行
• 时间复杂度为 O(logn)× 每次判断答案的时间

如果题目规定了有“最大值最小”或者“最小值最大”的东西，那么这个东西应该就满足二分答案的有界性（显然）和单调性（能看出来）

五.例题

我们先用几个题目理解一下二分答案

noip2015跳石头

题意：直线上有 n 块石头，需要移走 m 块（最两边的不能移走），使得剩下的石头中，最近的两块石头间距最大，求这个最大值

二分跳跃距离(答案区间0~25)，将这个跳跃距离认为是最短的跳跃距离。以这个标准去搬运石头

使用一个check函数去判断这个解是不是可行解。如果这个解是可行解，那么可能存在比这个解更优的可行解，那我们就去它的右边二分.去右边的原因是右边的值较大，而我们要找的是最小值的最大解，而且这个区间是递增的。我们有可能在右边的区间找到更大更优的解，若没有则当前的可行解即是最优解.反过来，如果这个解是一个非法的解，那我们就不必去右边找了，右边的解一定都是非法解。

check函数应该怎么实现呢？大体思路是判断这个解是不是一个合法的解，每个题目不一定相同。在这个题目里，我们以这个距离为最短距离去判断需要搬走多少石头，将搬走的数量与实际要求的数量相比，若超出则说明此解不合法。

模拟跳石头的过程，开始在起点,pos=0,我在跳之前判断我当前要跳跃的距离，如果这个距离比二分出的mid小，那么这就是一个不合法的石头应该移走。为什么呢？因为我们二分出的mid已经是最小的跳跃距离了，不可能再有比它还小的了。移走之后，计数器+1继续往前跳，不断进行这个操作，知道pos=n+1(n不是终点)

模拟完后查看计数器的值，它代表了我们以mid为答案要移走的石头数量，判断这个数量是否超过m

下面是代码实现

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int L,n,m;
int d[1000010]; 
int l,r,mid,ans;

bool check(int t)
{
	int cnt=0;
	int pos=0;//下一块石头的位置 
	int now=0;//当前人的位置 
	while(pos<n+1)
	{
		pos++;
		if(d[pos]-d[now]<t) cnt++;//出现了比最短距离还短的距离，那么这块石头应当搬走 
		else now=pos;//否则就跳过去 
	}
	if(cnt>m) return false;
	else return true;
}

int main()
{
	cin>>L>>n>>m;
	for(int i=1;i<=n;i++) cin>>d[i];
	d[n+1]=L;
	l=1;r=L;
	while(l<=r){
		mid=(l+r)/2;
		if(check(mid)){
			ans=mid;
			l=mid+1;//找到一个可行解，右移看看能不能找到更优的可行解 
		}
		else
		{
			r=mid-1;
		}
	}
	cout<<ans<<endl;
	return 0;
}

这个题目有个很明显的特征：最小值最大化，下面我们再来看一道这种的例题

POJ2456

题意:c头牛，n个隔间，c头牛容易打架，分配隔间使得相邻的牛距离越远越好，即求牛之间最小距离的最大值

先对隔间的坐标排序。牛之间的最小距离为0，最大距离不超过区间长度，二分地查找分割距离的最大值

每获得一个mid就check一次，check时贪心的放置牛，使前i个牛符合分割标准

check就看看按这个距离能否放下所有的牛

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,c;
int x[1000010];

bool check(int t)
{
	int now=x[0];
	int cnt=1;
	for(int i=1;i<n;i++)//剩下的隔间 
	{
		if(x[i]-now>=t)//这个隔间和上个隔间>=t,还可以放牛 
		{
			now=x[i];
			cnt++;//放进去一头牛 
		}
		if(cnt>=c) return true;
	}
	return false;
}

int main()
{
	cin>>n>>c;
	for(int i=0;i<n;i++) cin>>x[i];
	sort(x,x+n);
	int l,r,mid;
	l=1,r=x[n-1]-x[0];
	while(l<r)
	{
		mid=(l+r)/2;
		if(check(mid)){
			l=mid+1;
		}
		else r=mid;
	}
	cout<<r-1<<endl;
	return 0;
} 

noip提高组2001(或之前) 一元三次方程求解

求ax3+bx2+cx+d=0的解，保证有三个不同实根且都位于-100到100之间，且根与根之间的绝对值>=1

从-100到100枚举根，以每个值为区间左端点，长度为1，如果满足题目条件(>=1)并符合函数的零点定理(f(x1)*f(x2)<0)我们就对[x1,x2]这个区间进行二分，如果f(x1)*f(mid)<0我们就去mid左边试试看，如果不是则去mid右边，这样不断缩小区间长度，整个二分过程必须满足绝对值>=1

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
double a,b,c,d;

double f(double x)
{
	return (x*x*x*a+x*x*b+x*c+d);
}

int main()
{
	cin>>a>>b>>c>>d;
	double x1,x2,x3;
	double x;
	double mid;
	for(x=-100;x<=100;x++)
	{
	    x1=x,x2=x+1;
	    if(f(x1)==0) printf("%.2lf ",x1);
	    else if(f(x1)*f(x2)<0)
	    {
	    	while(x2-x1>=0.001)
	    	{
	    		mid=(x1+x2)/2;
	    		if(f(x1)*f(mid)<0) x2=mid;
	    		else x1=mid;
			}
		    printf("%.2lf ",x1);
		}
	}
	return 0;
}

Luogu P1182数列分段 Section II

二分区间(max(a[i])，sum(a[i]))，因为两种极端情况是每个数自成一组，或只分出了一组

对于找出来的每一个最大值，验证以它为最大值的情况下的分组情况。在这里我们贪心地分组，如果加上这个数比最大值小就加上，否则就再分一组

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m;
int a[100010];	
int sum,cnt;

bool check(int mid,int a[])
{
	for(int i=0;i<n;i++)
	{
		if(sum+a[i]<=mid) sum+=a[i];
		else sum=a[i],cnt++;
	}
	return cnt>=m;
}

int main()
{
	cin>>n>>m;
	int l=0,r,mid;
	for(int i=0;i<n;i++) 
	{
		cin>>a[i];
		l=max(l,a[i]);
		r+=a[i];
	}
    while(l<=r)
    {
    	mid=(l+r)/2;
    	sum=0,cnt=0;
    	if(check(mid,a)) l=mid+1;
    	else r=mid-1;
	}
    cout<<l;
	return 0;
} 

Luogu P1873砍树

待更。。。