二分搜索算法运用的框架套路

我们前文 我作了首诗，保你闭着眼睛也能写对二分查找 详细介绍了二分搜索的细节问题，探讨了「搜索一个元素」，「搜索左侧边界」，「搜索右侧边界」这三个情况，教你如何写出正确无 bug 的二分搜索算法。

但是前文总结的二分搜索代码框架仅仅局限于「在有序数组中搜索指定元素」这个基本场景，具体的算法问题没有这么直接，可能你都很难看出这个问题能够用到二分搜索。

对于二分搜索算法在具体问题中的运用，前文 二分搜索的运用（一） 和前文 二分搜索的运用（二） 有过介绍，但是还没有抽象出来一个具体的套路框架。

所以本文就来总结一套二分搜索算法运用的框架套路，帮你在遇到二分搜索算法相关的实际问题时，能够有条理地思考分析，步步为营，写出答案。

警告：本文略长略硬核，建议清醒时学习。

原始的二分搜索代码

二分搜索的原型就是在「有序数组」中搜索一个元素target，返回该元素对应的索引。

如果该元素不存在，那可以返回一个什么特殊值，这种细节问题只要微调算法实现就可实现。

还有一个重要的问题，如果「有序数组」中存在多个target元素，那么这些元素肯定挨在一起，这里就涉及到算法应该返回最左侧的那个target元素的索引还是最右侧的那个target元素的索引，也就是所谓的「搜索左侧边界」和「搜索右侧边界」，这个也可以通过微调算法的代码来实现。

我们前文 二分搜索算法框架详解 详细探讨了上述问题，对这块还不清楚的读者建议复习前文，已经搞清楚基本二分搜索算法的读者可以继续看下去。

在具体的算法问题中，常用到的是「搜索左侧边界」和「搜索右侧边界」这两种场景，很少有让你单独「搜索一个元素」。

因为算法题一般都让你求最值，比如前文 二分搜索的运用（一） 中说的例题让你求吃香蕉的「最小速度」，让你求轮船的「最低运载能力」，前文 二分搜索的运用（二） 讲的题就更魔幻了，让你使每个子数组之和的「最大值最小」。

求最值的过程，必然是搜索一个边界的过程，所以后面我们就详细分析一下这两种搜索边界的二分算法代码。

「搜索左侧边界」的二分搜索算法的具体代码实现如下：

// 搜索左侧边界int left_bound（int［］ nums， int target） {

if （nums.length == 0） return -1;

int left = 0， right = nums.length;

while （left 《 right） {

int mid = left + （right - left） / 2;

if （nums［mid］ == target） {

// 当找到 target 时，收缩右侧边界

right = mid;

} else if （nums［mid］ 《 target） {

left = mid + 1;

} else if （nums［mid］ 》 target） {

right = mid;

}

}

return left;

}

假设输入的数组nums = ［1，2，3，3，3，5，7］，想搜索的元素target = 3，那么算法就会返回索引 2。

「搜索右侧边界」的二分搜索算法的具体代码实现如下：

// 搜索右侧边界int right_bound（int［］ nums， int target） {

if （nums.length == 0） return -1;

int left = 0， right = nums.length;

while （left 《 right） {

int mid = left + （right - left） / 2;

if （nums［mid］ == target） {

// 当找到 target 时，收缩左侧边界

left = mid + 1;

} else if （nums［mid］ 《 target） {

left = mid + 1;

} else if （nums［mid］ 》 target） {

right = mid;

}

}

return left - 1;

}

输入同上，那么算法就会返回索引 4：

好，上述内容都属于复习，我想读到这里的读者应该都能理解。记住上述的图像，所有能够抽象出上述图像的问题，都可以使用二分搜索解决。

二分搜索问题的泛化

什么问题可以运用二分搜索算法技巧？

首先，你要从题目中抽象出一个自变量x，一个关于x的函数f（x），以及一个目标值target。

同时，x， f（x）， target还要满足以下条件：

1、f（x）必须是在x上的单调函数（单调增单调减都可以）。

2、题目是让你计算满足约束条件f（x） == target时的x的值。

上述规则听起来有点抽象，来举个具体的例子：

给你一个升序排列的有序数组nums以及一个目标元素target，请你计算target在数组中的索引位置，如果有多个目标元素，返回最小的索引。

这就是「搜索左侧边界」这个基本题型，解法代码之前都写了，但这里面x， f（x）， target分别是什么呢？

我们可以把数组中元素的索引认为是自变量x，函数关系f（x）就可以这样设定：

// 函数 f（x） 是关于自变量 x 的单调递增函数// 入参 nums 是不会改变的，所以可以忽略，不算自变量int f（int x， int［］ nums） {

return nums［x］;

}

其实这个函数f就是在访问数组nums，因为题目给我们的数组nums是升序排列的，所以函数f（x）就是在x上单调递增的函数。

最后，题目让我们求什么来着？是不是让我们计算元素target的最左侧索引？

是不是就相当于在问我们「满足f（x） == target的x的最小值是多少」？

如果遇到一个算法问题，能够把它抽象成这幅图，就可以对它运用二分搜索算法。

算法代码如下：

// 函数 f 是关于自变量 x 的单调递增函数int f（int x， int［］ nums） {

return nums［x］;

}

int left_bound（int［］ nums， int target） {

if （nums.length == 0） return -1;

int left = 0， right = nums.length;

while （left 《 right） {

int mid = left + （right - left） / 2;

if （f（mid， nums） == target） {

// 当找到 target 时，收缩右侧边界

right = mid;

} else if （f（mid， nums） 《 target） {

left = mid + 1;

} else if （f（mid， nums） 》 target） {

right = mid;

}

}

return left;

}

这段代码把之前的代码微调了一下，把直接访问nums［mid］套了一层函数f，其实就是多此一举，但是，这样能抽象出二分搜索思想在具体算法问题中的框架。

运用二分搜索的套路框架

想要运用二分搜索解决具体的算法问题，可以从以下代码框架着手思考：

// 函数 f 是关于自变量 x 的单调函数int f（int x） {

// ...

}

// 主函数，在 f（x） == target 的约束下求 x 的最值int solution（int［］ nums， int target） {

if （nums.length == 0） return -1;

// 问自己：自变量 x 的最小值是多少？

int left = ...;

// 问自己：自变量 x 的最大值是多少？

int right = ... + 1;

while （left 《 right） {

int mid = left + （right - left） / 2;

if （f（mid） == target） {

// 问自己：题目是求左边界还是右边界？

// ...

} else if （f（mid） 《 target） {

// 问自己：怎么让 f（x） 大一点？

// ...

} else if （f（mid） 》 target） {

// 问自己：怎么让 f（x） 小一点？

// ...

}

}

return left;

}

具体来说，想要用二分搜索算法解决问题，分为以下几步：

1、确定x， f（x）， target分别是什么，并写出函数f的代码。

2、找到x的取值范围作为二分搜索的搜索区间，初始化left和right变量。

3、根据题目的要求，确定应该使用搜索左侧还是搜索右侧的二分搜索算法，写出解法代码。

下面用几道例题来讲解这个流程。

例题一、珂珂吃香蕉

珂珂每小时最多只能吃一堆香蕉，如果吃不完的话留到下一小时再吃；如果吃完了这一堆还有胃口，也只会等到下一小时才会吃下一堆。

他想在警卫回来之前吃完所有香蕉，让我们确定吃香蕉的最小速度K。函数签名如下：

int minEatingSpeed（int［］ piles， int H）;

那么，对于这道题，如何运用刚才总结的套路，写出二分搜索解法代码？

按步骤思考即可：

1、确定x， f（x）， target分别是什么，并写出函数f的代码。

自变量x是什么呢？回忆之前的函数图像，二分搜索的本质就是在搜索自变量。

所以，题目让求什么，就把什么设为自变量，珂珂吃香蕉的速度就是自变量x。

那么，在x上单调的函数关系f（x）是什么？

显然，吃香蕉的速度越快，吃完所有香蕉堆所需的时间就越少，速度和时间就是一个单调函数关系。

所以，f（x）函数就可以这样定义：

若吃香蕉的速度为x根/小时，则需要f（x）小时吃完所有香蕉。

代码实现如下：

// 定义：速度为 x 时，需要 f（x） 小时吃完所有香蕉// f（x） 随着 x 的增加单调递减int f（int［］ piles， int x） {

int hours = 0;

for （int i = 0; i 《 piles.length; i++） {

hours += piles［i］ / x;

if （piles［i］ % x 》 0） {

hours++;

}

}

return hours;

}

target就很明显了，吃香蕉的时间限制H自然就是target，是对f（x）返回值的最大约束。

2、找到x的取值范围作为二分搜索的搜索区间，初始化left和right变量。

珂珂吃香蕉的速度最小是多少？多大是多少？

显然，最小速度应该是 1，最大速度是piles数组中元素的最大值，因为每小时最多吃一堆香蕉，胃口再大也白搭嘛。

这里可以有两种选择，要么你用一个 for 循环去遍历piles数组，计算最大值，要么你看题目给的约束，piles中的元素取值范围是多少，然后给right初始化一个取值范围之外的值。

我选择第二种，题目说了1 《= piles［i］ 《= 10^9，那么我就可以确定二分搜索的区间边界：

public int minEatingSpeed（int［］ piles， int H） {

int left = 1;

// 注意，right 是开区间，所以再加一

int right = 1000000000 + 1;

// ...

}

3、根据题目的要求，确定应该使用搜索左侧还是搜索右侧的二分搜索算法，写出解法代码。

现在我们确定了自变量x是吃香蕉的速度，f（x）是单调递减的函数，target就是吃香蕉的时间限制H，题目要我们计算最小速度，也就是x要尽可能小：

这就是搜索左侧边界的二分搜索嘛，不过注意f（x）是单调递减的，不要闭眼睛套框架，需要结合上图进行思考，写出代码：

public int minEatingSpeed（int［］ piles， int H） {

int left = 1;

int right = 1000000000 + 1;

while （left 《 right） {

int mid = left + （right - left） / 2;

if （f（piles， mid） == H） {

// 搜索左侧边界，则需要收缩右侧边界

right = mid;

} else if （f（piles， mid） 《 H） {

// 需要让 f（x） 的返回值大一些

right = mid;

} else if （f（piles， mid） 》 H） {

// 需要让 f（x） 的返回值小一些

left = mid + 1;

}

}

return left;

}

PS：关于mid是否需要 + 1 的问题，前文 二分搜索算法详解 进行了详细分析，这里不展开了。

至此，这道题就解决了，现在可以把多余的 if 分支合并一下，最终代码如下：

public int minEatingSpeed（int［］ piles， int H） {

int left = 1;

int right = 1000000000 + 1;

while （left 《 right） {

int mid = left + （right - left） / 2;

if （f（piles， mid） 《= H） {

right = mid;

} else {

left = mid + 1;

}

}

return left;

}

// f（x） 随着 x 的增加单调递减int f（int［］ piles， int x） {

// 见上文

}

PS：我们代码框架中多余的 if 分支主要是帮助理解的，写出正确解法后建议合并多余的分支，可以提高算法运行的效率。

例题二、运送货物

再看看力扣第 1011 题「在 D 天内送达包裹的能力」：

要在D天内按顺序运输完所有货物，货物不可分割，如何确定运输的最小载重呢？

函数签名如下：

int shipWithinDays（int［］ weights， int days）;

和上一道题一样的，我们按照流程来就行：

1、确定x， f（x）， target分别是什么，并写出函数f的代码。

题目问什么，什么就是自变量，也就是说船的运载能力就是自变量x。

运输天数和运载能力成反比，所以可以让f（x）计算x的运载能力下需要的运输天数，那么f（x）是单调递减的。

函数f（x）的实现如下：

// 定义：当运载能力为 x 时，需要 f（x） 天运完所有货物// f（x） 随着 x 的增加单调递减int f（int［］ weights， int x） {

int days = 0;

for （int i = 0; i 《 weights.length; ） {

// 尽可能多装货物

int cap = x;

while （i 《 weights.length） {

if （cap 《 weights［i］） break;

else cap -= weights［i］;

i++;

}

days++;

}

return days;

}

对于这道题，target显然就是运输天数D，我们要在f（x） == D的约束下，算出船的最小载重。

2、找到x的取值范围作为二分搜索的搜索区间，初始化left和right变量。

船的最小载重是多少？最大载重是多少？

显然，船的最小载重应该是weights数组中元素的最大值，因为每次至少得装一件货物走，不能说装不下嘛。

最大载重显然就是weights数组所有元素之和，也就是一次把所有货物都装走。

这样就确定了搜索区间［left， right）：

public int shipWithinDays（int［］ weights， int days） {

int left = 0;

// 注意，right 是开区间，所以额外加一

int right = 1;

for （int w ： weights） {

left = Math.max（left， w）;

right += w;

}

// ...

}

3、需要根据题目的要求，确定应该使用搜索左侧还是搜索右侧的二分搜索算法，写出解法代码。

现在我们确定了自变量x是船的载重能力，f（x）是单调递减的函数，target就是运输总天数限制D，题目要我们计算船的最小载重，也就是x要尽可能小：

这就是搜索左侧边界的二分搜索嘛，结合上图就可写出二分搜索代码：

public int shipWithinDays（int［］ weights， int days） {

int left = 0;

// 注意，right 是开区间，所以额外加一

int right = 1;

for （int w ： weights） {

left = Math.max（left， w）;

right += w;

}

while （left 《 right） {

int mid = left + （right - left） / 2;

if （f（weights， mid） == days） {

// 搜索左侧边界，则需要收缩右侧边界

right = mid;

} else if （f（weights， mid） 《 days） {

// 需要让 f（x） 的返回值大一些

right = mid;

} else if （f（weights， mid） 》 days） {

// 需要让 f（x） 的返回值小一些

left = mid + 1;

}

}

return left;

}

到这里，这道题的解法也写出来了，我们合并一下多余的 if 分支，提高代码运行速度，最终代码如下：

public int shipWithinDays（int［］ weights， int days） {

int left = 0;

int right = 1;

for （int w ： weights） {

left = Math.max（left， w）;

right += w;

}

while （left 《 right） {

int mid = left + （right - left） / 2;

if （f（weights， mid） 《= days） {

right = mid;

} else {

left = mid + 1;

}

}

return left;

}

int f（int［］ weights， int x） {

// 见上文

}

本文就到这里，总结来说，如果发现题目中存在单调关系，就可以尝试使用二分搜索的思路来解决。搞清楚单调性和二分搜索的种类，通过分析和画图，就能够写出最终的代码。

责任编辑：haq