二分答案的应用

二分的基本用途是在单调序列或单调函数中做查找操作，特别注意一定要具有单调性.

整数定义域上的二分（模板）：

int erfen(int l,int r){
　　int l=1,r=n,ans;
　　while(l<=r){
　　　　int mid=(l+r)>>1;
　　　　if(check(mid)) ans=mid,l=mid+1;
　　　　else r=mid-1;
　　}
　　return ans;
}

实数域上的二分（模板）：

double erfen(double l,double r){
　　double mid;
　　while(r-l>eps){
　　　　mid=(l+r)/2.0;
　　　　if(check(mid)) r=mid;
　　　　else l=mid;
　　}　　
　　return l;//返回l和r都行
}

eps是要确定好的精度，一般题目要求保留k位小数，则取eps=10−(k+2)10−(k+2)；

有时精度不容易确定或表示，就干脆采用循环固定次数的二分方法，往往结果的精度更高(实数二分常常卡精度)

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

二分答案：求最小值最大(或最大值最小)的问题，常常选用二分法求解，同时配合贪心，DP等其他算法检验答案的合理性(即check函数)，将最优化问题转化为判定性问题；

例题：数列分段II（洛谷1182）

　　对于给定的一个长度为N的正整数数列A，现要将其分成M(M≤N)段，并要求每段连续，且每段和的最大值最小。

　　求最大值最小，典型的二分答案题；

#include<bits/stdc++.h>
#define LL long long
#define INF 99999999
using namespace std;
int n,m,l,r,mid;
int a[100005];
bool check(int x){//二分每段和的最大值的最小值
    int sum=0,tot=1;
    for(int i=0;i<n;i++){
        sum+=a[i];//sum表示当前段的值的和
        if(sum>x){
            tot++;//tot表示分的段数，表示新开一段
            sum = a[i];
        }
    }
    if(tot>m) return 1;
    //分的段数比m大的话，表示答案在更大的区间内
    else return 0;
}
int main(){
    scanf("%d%d",&n,&m);//n个数,分成m段
    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);//读入n个数
        r+=a[i];//r把n个数的和记录下来
        l=max(l,a[i]);//l记录n个数中最大的数
        //l,r就是二分的两个端点，每段和的值一定大于等于l，同时小于等于r
    }
    while(l<r){//二分模板
        mid=(l+r)/2;
        if(check(mid)==1) l=mid + 1;
        else r=mid;
    }
    printf("%d\n",r);
    return 0;}

例题：扩散（洛谷1661）

　　一个点每过一个单位时间就会向四个方向扩散一个距离，两个点a、b连通，记作e(a,b),当且仅当a、b的扩散区域有公共部分。连通块的定义是块内的任意两个点u、v都必定存在路径e(u,a0),e(a0,a1),…,e(ak,v)。给定平面上的n给点，问最早什么时刻它们形成一个连通块。

　　方法一：二分时间t，运用并查集判断连通块；

　　方法二：假设任意两点之间有边，相当于求所有点构成的最小生成树中最长的一条边。把两点扩散连接的时长作为边的权值，开一个结构体存边，然后用kruskal算法求最小生成树，找到其中最长的边即可。

方法一：

#include<bits/stdc++.h>
using namespace std;
long long ans;
int n;
int xx[51],yy[51],father[51];
int find(int x){
    while(father[x]!=x) x=father[x];
    return x;
}//并查集的查询操作，没有路径压缩优化
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d%d",&xx[i],&yy[i]);
    int l=0,r=1000000000;//二分时间t可能在的区间
    while(l<=r){
        int mid=(l+r)/2;
        for(int i=1;i<=n;i++)
          father[i]=i;//初始化并查集
        for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++){
  int dis=abs(xx[i]-xx[j])+abs(yy[i]-yy[j]);
  //求出两点间的曼哈顿距离
            if(dis<=mid*2){
                int r1=find(i),r2=find(j);
                if(r1!=r2) father[r2]=r1;
            }
   //因为是两个点同时扩散，所以mid*2
   //表示这两个点可以连通
        }
        int cnt=0;//连通块的数量
        for(int i=1;i<=n;i++){
            if(father[i]==i) cnt++;
        }//有多少个点指向自己，就有多少个连通块
        if(cnt==1){
        //表示时间t还可以更小，或者就是t
            ans=mid;
            r=mid-1;
        }
        else l=mid+1;
    }
    printf("%lld",ans);
    return 0;
}

方法二：把题目要求转换一下，假设任意两点之间有边，相当于求所有点构成的最小生成树中最长的一条边。

把两点扩散连接的时长作为边的权值，开一个结构体存边，然后用kruskal算法求最小生成树，找到其中最长的边即可。

#include<bits/stdc++.h>
using namespace std;
struct Edge{
    int x,y,val;
}edge[3000];
int father[3000];
int cnt,n,ans;
bool cmp(Edge x,Edge y){
    return x.val<y.val;
}
void in(){
    int x[51],y[51];
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>x[i]>>y[i];
    for(int i=1;i<=n;i++)   
    for(int j=1;j<i;j++){
        edge[++cnt].x=i;
        edge[cnt].y=j;
        //建边，存图
        int dis;
        dis=abs(x[i]-x[j])+abs(y[i]-y[j]);
        if(dis&1) edge[cnt].val=(dis>>1)+1; 
        else  edge[cnt].val=(dis>>1);
    }//把两点扩散连接的时长作为边的权值
}
int find(int x) {
    if(father[x]!=x) 
    	father[x]=find(father[x]);
    return father[x];
}//并查集查询操作，路径压缩优化
void kruskal(){
    int p=1;
    for(int i=1;i<=n;i++)
        father[i]=i;//并查集初始化
    for(int i=1;i<=cnt;i++)
        int u=find(edge[i].x);
        int v=find(edge[i].y);
        if(u!=v){
            father[u]=v;
            ans=max(edge[i].val,ans);
            //找最长的一条边
            p++;
            if(p==n) return;
        }
    return ;
}
int main()
{
    in();
    sort(edge+1,edge+cnt+1,cmp);//结构体排序
    kruskal();
    cout<<ans<<endl;
    return 0;
}