在上一篇浅谈二分思想中，我们谈到了提过二分的本质，其实就是不断折半，折到最后折无可折的那个结果就是最符合要求的结果。

现在我们从答案出发，对答案的整体可能范围不断二分，最后找到最合适的答案。我们称这种方法为二分答案法。

二分答案法：

1. 估计 最终答案可能的范围 是什么
2. 分析 问题的答案 和 给定条件 之间的单调性 ，这种分析往往只需要简单分析。
3. 建立一个$f$函数，当答案固定的情况下，判断给定的条件是否达标。
4. 在 最终答案可能的范围上不断二分搜索，每次用$f$函数判断， 直到二分结束，找到最合适的答案

核心点：分析单调性、建立$f$函数

$Problem1$ 爱吃香蕉的珂珂 LeetCode 875

珂珂喜欢吃香蕉。这里有 n 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 h 小时后回来。

珂珂可以决定她吃香蕉的速度 k （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 k 根。如果这堆香蕉少于 k 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉。

珂珂喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。

返回她可以在 h 小时内吃掉所有香蕉的最小速度 k（k 为整数）。

示例 1：

输入：piles = [3,6,7,11], h = 8
输出：4

示例 2：

输入：piles = [30,11,23,4,20], h = 5
输出：30

示例 3：

输入：piles = [30,11,23,4,20], h = 6
输出：23

提示：

• 1 <= piles.length <= 104
• piles.length <= h <= 109
• 1 <= piles[i] <= 109

问题分析：

我们先贪心地想，既然吃香蕉的速度为$k$，那为了在有限时间内吃掉更多堆香蕉，我们应该要优先吃掉 香蕉数量不大于$k$ 的堆，对于 香蕉数量大于$k$ 的堆，我们也要优先吃掉 香蕉数量较少 的堆。所以我们要先对$piles[i]$进行升序排序，然后从左往右 一个堆一个堆地 去吃。

现在吃香蕉堆的顺序确定下来了，但是如果吃的速度太慢（$k$太小），就算选择了最优顺序也不能在$h$小时内吃掉所有香蕉。所以我们要增大吃香蕉的速度$k$，很容易发现，$k$越小，越可能吃不完，$k$越大，在$h$小时内越可能吃完所有香蕉。

按照刚刚的分析，我们知道能否在$h$小时内吃完所有香蕉相对于**吃香蕉的速度($k$)**是单调的，草图如下：

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/3b96977d6bfa4d4cb07e32116439d1c9.jpeg#pic_center)

所以我们可以可能利用二分来寻找最小的$k$。

好了，现在我们就来详细讨论一下是怎么个二分法，二分法的代码应该怎样去写。

​ 因为吃香蕉的速度肯定不小于$0$，所以初始左边界$left=0$，那右边界呢？按道理我们选一个非常大的数作为右边界就可以，但是这样会使得我们二分的次数增多，浪费时间，所以我们应该找到符合题目情况的合理右边界。

​ 我们在最开始的贪心分析中，不是对$piles[i]$排了序嘛，如果$piles[i]$的最大值$piles[N-1]$都比$k$小，那就说明珂珂每吃一次就可以吃掉一堆，毫无疑问地符合条件，所以我们就把右边界$right$取值为$piles[N-1]$。

​ 现在轮到$mid$了，$mid=(left+right)/2$，当$mid$满足条件：吃香蕉速度为$mid$时，珂珂能在$h$小时内吃完所有香蕉，我们就把右边界$right$赋值为$mid$。当$mid$不满足条件时，我们就把左边界$left$赋值为$mid+1$。

​ 当区间被二分缩小到一位数或者左边界$left$大于右边界$right$时，我们取出$right$作为最终值。

以上就是二分部分的讨论，那现在就剩下 $k$是否满足条件 的问题上来了。

其实也很简单，从左往右一个堆一个堆地吃，统计每个堆需要吃的次数再求和就可以了。

解决代码：

bool check_Pro1(int lamda, vector<int>& new_piles, int h) {
        if (lamda == 0)
            return false;
        long sum = 0;
        for (int i = 0; i < new_piles.size(); i++) {
            sum += (new_piles[i] / lamda) + (new_piles[i] % lamda == 0 ? 0 : 1);
        }
        if (sum > h)
            return false;
        return true;
}

int solution_Pro1(vector<int> piles, int h) {
    sort(piles.begin(), piles.end());
    int left = 0;
    int right = piles[piles.size() - 1];

    while (left < right) {
        int mid = (left + right) / 2;
        check_Pro1(mid, piles, h) ? right = mid : left = mid + 1;
    }
    return right;
}

$Problem2$ 分割数组的最大值 LeetCode 410

给定一个非负整数数组 nums 和一个整数 k ，你需要将这个数组分成 k 个非空的连续子数组。

设计一个算法使得这 k 个子数组各自和的最大值最小。

示例 1：

输入：nums = [7,2,5,10,8], k = 2
输出：18
解释：
一共有四种方法将 nums 分割为 2 个子数组。 
其中最好的方式是将其分为 [7,2,5] 和 [10,8] 。
因为此时这两个子数组各自的和的最大值为18，在所有情况中最小。

示例 2：

输入：nums = [1,2,3,4,5], k = 2
输出：9

示例 3：

输入：nums = [1,4,4], k = 3
输出：4

提示：

• 1 <= nums.length <= 1000
• 0 <= nums[i] <= 106
• 1 <= k <= min(50, nums.length)

---

问题分析：

这显然是一个最小化最大值问题，基本上也要用到二分思想，这个二分基本上是对 需要最小化的变量 进行二分。

我们记某种划分得到的$k$个子数组各自和的最大值为$score$，用数学公式来表示，其实就是：
$$max(每部分的和sum)$$
题目要求返回的是$score$的最小值，所以我们要使$max(每部分的和sum)$尽可能的小。现在我们来分析一下$score$的可能取值范围吧，也就是分析范围区间的左边界$left$与右边界$right$。【一般在分析边界的时候，都往极端情况去分析，极端情况更可能出现最值嘛】

​ 数组nums是非负整数数组，所以每部分的和$sum$至少由一个数构成，而$score$又是各自和的最大值，所以$score$的值不可能小于$nums$中的最大值，我们记为$max$，那么区间的左边界$left$我们可以定为$max$，那区间的右边界呢？区间的右边界自然是每部分和的最大可能取值，我们知道，非负整数数组的某个子数组累加和一定不会大于整体累加和，我们把数组nums的整体累加和记为$A$,则区间的右边界应该定为$A$。

分析到这里，我们知道了$score$的可能取值范围，现在就需要寻找$score$与哪种问题条件之间具有单调性了，根据单调性我们才可以进行二分寻找最合适的答案。

我们从$score$入手，一般而言，$score$越大，数组和为$score$的那个区间中的数字个数会越多一点，其他区间中的数字个数也可以略微增加一些，只要保证区间数组和不大于$score$。每个区间的数字个数多了，但是总数组的数字也就只有N个，这就说明区间的个数少了嘛。所以我们可以得出：

​ 【结论2-1】 子数组各自和的最大值$score$越大，其对应的至少区间个数越小。

相应地，我们提出如下问题：

​ 【问题2-1】给定一个非负整数数组nums，要想将其分裂成一个个连续的子数组，并且保证这些连续子数组的各自和的最大值为$score$，请问至少需要划分成几个子数组？

如果$score$的值$A_1$时对应的子数组个数为$a$，$score$的值为$A_2$时对应的子数组个数为$b$，根据【结论1】，可以得出$b<=a$。

回到二分查找条件上来，如果$score=mid$时，其对应的【问题2-1】的解小于k，说明我们能给出这么一种划分，将整个数组nums份成$k$个子数组并且子数组各自和的最大值为$score$。那说明这个$mid$取值是满足题目条件的，所以我们缩小区间$right=mid$。如果$mid$不满足条件（【问题2-1】的解大于$k$），那我们就要选择$score$取值较大的那一片区间，$left=mid+1$。

至此，二分的初始范围和二分查找条件都已经分析完毕。

现在只剩下【问题2-1】的解决方案，这个解决方案其实也比较简单，需要用到贪心思想。

​ 我们贪心地想，一个子区间的区间累加和越大，这个子区间的长度一般来说会越大，对整个数组nums来说，如果每个子区间的区间累加和尽可能地逼近$score$（但小于$score$），那整个数组被划分之后的子区间数量会尽可能地少。

直接看下面这段解决代码你就明白了：

解决代码：

int check_Pro2(vector<int>& nums, int score) {
    int ans = 1;
    int subSum = 0; //记录子区间的累加和

    for (int i = 0;i < nums.size();i++) {
        subSum += nums[i];
        if (subSum > score) {
            ans++;
            subSum = nums[i];
        }
    }
    return ans;
}

int solution_Pro2(vector<int>& nums, int k) {
    int sum = 0;
    int max = 0;
    for (int num : nums) {
        sum += num;
        max = num > max ? num : max;
    }

    //主体二分框架
    int left = max;
    int right = sum;

    while (left < right) {
        int mid = (left + right) / 2;
        if (check_Pro2(nums, mid) > k) {
            left = mid + 1;
        }
        else {
            right = mid;
        }
    }
    return right;
}

$Problem3$ 机器人跳跃问题 nowcoder ZJ24

机器人正在玩一个古老的基于DOS的游戏。游戏中有$N+1$座建筑——从$0$到$N$编号，从左到右排列。

编号为$0$的建筑高度为0个单位，编号为$i$的建筑的高度为$H_i$个单位。

起初， 机器人在编号为0的建筑处。每一步，它跳到下一个（右边）建筑。假设机器人在第k个建筑，且它现在的能量值是$E$, 下一步它将跳到第$k+1$个建筑。它将会得到或者失去正比于与$H_{k+1}$与$E$之差的能量。如果$ H_{k+1}> E$ 那么机器人就失去 $H_{k+1}-E$ 的能量值，否则它将得到$ E - H_{k+1}$ 的能量值。

游戏目标是到达第N个建筑，在这个过程中，能量值不能为负数个单位。现在的问题是机器人以多少能量值开始游戏，才可以保证成功完成游戏？

输入描述：

第一行输入，表示一共有 N 组数据

第二个是 N 个空格分隔的整数，$H_1,H_2,H_3,...,H_n$ 代表建筑物的高度

输出描述：

输出一个单独的数表示完成游戏所需的最少单位的初始能量

示例：

输入：5
	 3 4 3 2 4
输出：4

问题分析：

问题最后要返回的是，机器人能够成功完成游戏需要的最少能量值，而成功完成游戏代表着什么呢？代表着从初始位置开始，机器人向右一步一步跳直到跳到终点第$N+1$个建筑的过程中，在中途从未出现过能量值为负的情况。

我们记机器人的初始能量值为$energy$，一般而言，$energy$越大，每跳一步失去的能量值或者得到的能量值越大，在游戏过程中能量值耗尽的可能性就越小，即完成游戏就越容易。所以我们可以分析出 能否成功完成游戏与初始能量值 之间是具有单调性的，函数图如下：

现在我们来讨论这道题的二分框架。我们很容易想到，能量$energy$不能为负，所以左边界。当$energy$比这些建筑的最大高度还大时，机器人在跳跃过程中会畅通无阻，所以我们将右边界$right$设置为$max$【$max$为这些建筑的最大高度】。

二分筛选也很简单，如果初始值为$mid$时不能成功完成游戏，那我们就需要选择较大的区间：$left=mid+1$，如果可以完成游戏，我们就选择较小的区间来逼近$energy$的最小值：$right=mid$。

好了，现在又只剩下一个问题：

​ 给定初始能量值$energy$，机器人能否成功完成游戏，能则返回$true$，否则返回$false$。

这个问题我暂时想不出来有什么简单的解法，只能带着$energy$一步步跳，中途如果$energy$为负，则直接返回$false$，若到达终点时$energy$仍非负，则返回$true$。

解决代码：

bool check_Pro3(vector<int> Heights, int N, int energy, int max) {
    for (int i = 0; i < N; i++) {
        if (energy >= Heights[i]) {
            energy += (energy - Heights[i]);
        } else   energy -= (Heights[i] - energy);

        if (energy >= max)    return true;
        if (energy < 0)   return false;
    }
    return true;
}

int main() {
    int N;
    cin >> N;
    vector<int> Heights(N);
    int max = 0;
    for (int i = 0; i < N; i++) {
        int num ;
        cin >> num;
        Heights[i] = num;
        max = max > Heights[i] ? max : Heights[i];
    }

    int left = 0;
    int right = max;
    int answer = right;

    while (left <= right) { // 使用 <= 保证区间收敛
        int mid = (left + right) / 2;
        if (check_Pro3(Heights, N, mid, max)) {
            answer = mid; // 保存当前可行的解
            right = mid - 1; // 尝试更小的能量
        } else {
            left = mid + 1; // 增加能量
        }
    }
    cout << answer;

    return 0;
}

【注意】 我们以上代码解释两点：

1. 在check函数中设置if (energy >= max) return true;是因为如果不加限制地让$energy$一直这么加下去，$energy$很有可能会超过int甚至long数据类型的表示范围，所以我们要适当地进行剪枝。在某一时刻$energy$比最大值$max$还要大，那么之后的建筑机器人一定可以到达，所以我们提前返回true。
2. 第二点是针对于二分的，如果$mid$满足条件，我们就用answer去存储这个当前可行解，之后再利用right = mid - 1与left = mid +1来收敛二分区间。

我们再来看今天这篇文章的最后一题

$Problem4$ 找出第K小的数对距离

数对 (a,b) 由整数 a 和 b 组成，其数对距离定义为 a 和 b 的绝对差值。

给你一个整数数组 nums 和一个整数 k ，数对由 nums[i] 和 nums[j] 组成且满足 0 <= i < j < nums.length 。返回 所有数对距离中 第 k 小的数对距离。

示例 1：

输入：nums = [1,3,1], k = 1
输出：0
解释：数对和对应的距离如下：
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
距离第 1 小的数对是 (1,1) ，距离为 0 。

示例 2：

输入：nums = [1,1,1], k = 2
输出：0

示例 3：

输入：nums = [1,6,1], k = 3
输出：5

提示：

• n == nums.length
• 2 <= n <= 104
• 0 <= nums[i] <= 106
• 1 <= k <= n * (n - 1) / 2

---

问题分析：

乍一看，这道题和前三道题有些许不同，前三道题都是最大化…或者最小化…问题，这道题只需要选择第$k$小的数对距离。所以我们需要思考一下怎么对这个第$k$小的数对距离问题进行转换，转换成可以进行二分答案的问题。

我们记数对距离为$pairDistance$，由于数对有很多种，所以$pairDistance$也有很多取值，出现重复取值的情况也比较常见。对于二分答案来说，不管取值的情况是连续的还是零散的，我们只想要知道$pairDistance$取值的左边界和右边界。

​ 左边界显然易见，因为数对距离是两个数$a,b$之间的差值的绝对值，所以左边界$left=0$，右边界也很简单，数组的最大值减去最小值就是差值的最大值，也就是所有数对距离中的最大值嘛，如果我们对整个数组从小到大进行排序的话，右边界$right=nums[N-1]-nums[0]$。

现在我们需要思考一下$pairDistance$跟什么东西放一起讨论具有函数单调性呢，这个东西最好还要和题目所给条件有关。

​ 回想一下，我们还从未讨论过第$k$小这个条件，如果这个数对距离【我们记为$pairDistanc{e}_k$】是第k小的，那么在它之间一定有第1小【$pairDistance1$】、… 、 第$k-1$小【$pairDistanc{e}_{k-1}$】的数对距离。根据这个我们可以知道，$pairDistance$越大，比它小的数对距离就越多。

我们回到二分框架的$mid$上，如果数对距离为$mid$时，数对距离小于或等于$mid$的数对个数 大于或等于 $k$，说明答案在整个区间的左半部分，这时我们要$answer=mid,right=mid-1$来收敛区间和保留当前可行解【疑点1】，如果数对距离大于$mid$的数对个数大于$k$，那说明答案在整个区间的右半部分，我们要$left=mid+1$来选取右半部分进行区间收敛并选取可行解【疑点2】。

现在我们只剩下一个问题需要解决：

​ 【问题4-1】给定一个整数$distance$，数对距离小于或等于$distance$的数对有多少个？

在最开始分析的时候，我们已经对数组进行了排序，所以数对距离就是数对中 下标大的数 减去 下标小的数 。回到【问题4-1】，这个问题其实有暴力解法，我把所有的数对都遍历一遍，拎出 数对距离小于或等于$distance$ 的数对进行计数就好了，但是这种操作的时间复杂度是$O(n\ast (n-1)/2)$，肯定会超时。

看过我之前文章的同学可能会想到，我之前写过一篇 【滑动窗口遍历数组】的文章，利用滑动窗口可以在 带着目的 的情况下大大减少遍历数组的时间。

我们直接给出解决【问题4-1】的代码：

bool check_Pro4(vector<int> nums, int distance, int k) {
    int left = 0;
    int ans = 0;
    while (left < nums.size() - 1) {
        int right = left + 1;
        while (nums[right] - nums[left] <= distance) {
            //数对距离比distance小，窗口可以继续往右移
            ans++;
            right++;
        }
        left++;
    }
    return ans <= k;
}

解决代码：

现在只剩个二分主框架：

int solution_Pro4(vector<int> nums, int k) {
    sort(nums.begin(), nums.end());
    int left = 0, right = nums[nums.size() - 1];
    int answer;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (check_Pro4(nums, mid, k)) {
            answer = mid;
            right = mid - 1;
        }
        else {
            left = mid + 1;
        }
    }
    return answer;
}

在第四题末尾补充一下对两个疑点的解释：

1. 数对距离为$mid$时，数对距离小于或等于$mid$的数对个数 大于或等于 $k$，这对应着两种情况。第一种情况：$mid$的值和真正第$k$小的值不相等，那我们利用$right=mid-1$来收敛区间没问题，即使加上$answer=mid$也不会影响最终的$answer$，因为真正第$k$小的值在收敛后的区间里，它会对$answer$进行更新。第二种情况：$mid$的值和真正第$k$小的值相等，这个时候我们仍然在利用$right=mid-1$收敛区间，如果不加上$answer = mid $，那真正第$k$小的值就被我们错过了，这显然要出问题，所以最后我们选定$answer = mid， right = mid - 1$。
2. 如果 数对距离小于或等于$mid$的数对个数小于 $k$，那说明$mid$是第$m$小的数，这个$m$一定小于$k$，所以我们只需要选取右半部分区间来进行收敛，只需要$left=mid+1$即可。