这道题快拿二分写！二分总结

大家在做二分的时候也许会遇到很多问题，这篇文章就解题模板和例题帮你更加深入理解二分解题思路。

模板

整数二分模板

bool check(int x) {/* ... */} // 检查x是否满足某种性质

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
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;
}
yxc总结

浮点数二分算法模板

bool check(double x) {/* ... */} // 检查x是否满足某种性质

double bsearch_3(double l, double r)
{
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求
    while (r - l > eps)
    {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    return l;
}
yxc 总结

整数二分

浮点二分例题

剪绳子
输入格式
第一行包含2个正整数N、M，表示原始绳子的数量和需求绳子的数量。

第二行包含N个整数，其中第 i 个整数Li表示第 i 根绳子的长度。

输出格式
输出一个数字，表示裁剪后最长的长度，保留两位小数。

数据范围
1≤N,M≤100000,
0<Li<109
输入样例：
3 4
3 5 4
输出样例：
2.50
样例解释
第一根和第三根分别裁剪出一根2.50长度的绳子，第二根剪成2根2.50长度的绳子，刚好4根。

解题关键：
1.写出mid
2.对mid进行判断
判断能总共剪出长度为 mid 的绳子多少根：总共能剪出的根数 = 每一根绳子能剪出的根数之和。
如果能剪出长度为 mid 的绳子，则 l = mid: ，如果不能，则 r = mid。

import java.util.*;
class Main{
    static int []arr;
    static int N,M;
    public static void main(String [] args){
        Scanner sc = new Scanner(System.in);
         N = sc.nextInt();
         M = sc.nextInt();
        arr = new int[N];
        for(int i =0;i < N; i++){
            arr[i] = sc.nextInt();
        }
        double l = 0;
        double r = 1e9;
        while(r-l>1e-4){
            double mid = (l+r)/2;
            if(check(mid)){
                l = mid;
            }else{
               r = mid;
            }
        }
        System.out.printf("%.2f",l);
        
        
    }
    static boolean check(double mid){
        int sum =0;
        for(int i =0;i<N;i++){
            sum+=arr[i]/mid;
            if(sum>=M){
                return true;
            }
        }
        return false;
    }
}

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

输入格式
共一行，包含一个浮点数n。

输出格式
共一行，包含一个浮点数，表示问题的解。

注意，结果保留6位小数。

数据范围
−10000≤n≤10000
输入样例：
1000.00
输出样例：
10.000000

import java.util.*;
class Main{
    public static void main(String [] args){
        Scanner sc = new Scanner(System.in);
        double x = sc.nextDouble();
        double l = -10000;
        double r = 10000;
        while(r-l>1e-8){
            double mid = (l+r)/2;
            if(mid*mid*mid>=x){
                r = mid;
            }else{
                l = mid;
            }
        }
        System.out.printf("%.6f",l);
    }
}

整数二分例题

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

import java.util.*;
class Main{
    static int n,q;
    static int []nums = new int[100005];
    public static void main(String [] args){
            Scanner sc = new Scanner(System.in);
            n =sc.nextInt();
            q = sc.nextInt();
            for(int i =0;i<n;i++){
                nums[i] = sc.nextInt();
            }
            while((q--)!=0){
                int x = sc.nextInt();
                
                int l = 0, r = n-1;
                while(l<r){
                    int mid = (l+r)/2;
                    if(nums[mid]<x){
                        l = mid+1;
                    }else{
                        r = mid;
                    }
                }
                if(nums[l]!=x){
                    System.out.println("-1 -1");
                }else{
                    System.out.print(l+" ");
                    
                     l = 0; r = n-1;
                    while(l<r){
                    int mid = (l+r+1)/2;
                    if(nums[mid]<=x){
                        l = mid;
                    }else{
                        r = mid-1;
                    }
                        
                    }
                    System.out.print(l);
                    System.out.println();
                }
            }
        }
    }

儿童节那天有 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

import java.util.*;
import java.math.*;
class Main{
    static int [] H = new int[100005];
    static int [] W= new int[100005];
    static int N,K;
    public static void main(String []args){
        Scanner sc = new Scanner(System.in);
         N = sc.nextInt();
         K = sc.nextInt();
         int max =  0;
        for(int i =0;i<N;i++){
            H[i] = sc.nextInt();
            W[i] = sc.nextInt(); 
            max = Math.max(max,Math.max(H[i],W[i]));
        }
        int l = 1,r = max;
        while(l<r){
            int mid = (l+r+1)/2;
            if(check(mid)){
                l = mid;
            }else{
                r = mid-1;
            }
        }
        System.out.println(l);
    }
    static boolean check(int mid){
        int sum = 0;
        for(int i =0;i<K;i++){
            sum += (H[i]/mid)*(W[i]/mid);
             if(sum>=K){
                 return true;
             }
        }
        return false;
       
    }
}