文章目录
一.二分法的概念
二分法,可以用于解决有序区间内的搜索问题,其时间复杂度为O(log n),最常见用于已经排好序的区间。
使用二分法的两大原则:
- 每次都要缩小搜索区域
- 缩小区域时不能排除潜在正确值
二. 二分法三大模板
(一)找一个准确值
- while循环条件:left <= right
- 缩减搜索区域:left = med + 1, right = med - 1;
(二)找一个模糊值
- while循环条件:left < right
- 缩减搜索区域:left = med, right = med - 1; 或者 left = med + 1, right = med;
(三)万用型
- while循环条件:left < right - 1
- 缩减搜索区域:left = med, right = med;
三. 相关例题及其解法
(一)leetcode 1062 最长字符串(困难)
1.题目
(二)leetcode1231. 分享巧克力(困难)
1.题目
https://leetcode-cn.com/problems/divide-chocolate/
2.解法
本题为最小值最大化问题,采用二分法+贪心算法解决,但是其中有很多细节。
贪心算法,简言之就是从某一项开始累加,一直加到当前设定的最大值(只能小于),然后如果当前的和再加上下一项不小于设定的最大值了,那么就从下一项开始重新开始累加,并更新累加次数。
class Solution {
public:
int maximizeSweetness(vector<int>& sweetness, int K) {
int left = *min_element(sweetness.begin(), sweetness.end()); // 左边界
int right = accumulate(sweetness.begin(), sweetness.end(), 0) / (K+1); //有边界
int ans = 0; //记录最终结果
if(K == 0) return right; //K = 0,就是只有一个人吃,返回总和即可
while(left <= right){
int med = (left + right)/2;
int sum = 0, cur = 0;
for(int sweet : sweetness){
// 下面if部分就是最小值最大化的贪心算法
sum += sweet;
if(sum >= med){
sum = 0;
cur++;
}
}
if(cur >= K+1){ // 这个时候说明这个甜度是有可能成立的
left = med + 1;
ans = med; // 记录答案
}
else{ //这个时候说明这个甜度太大了,所以右边界左移,这种情况不做记录
right = med - 1;
}
}
return ans;
}
};
(三)leetcode410. 分割数组的最大值(困难)
1.题目
https://leetcode-cn.com/problems/split-array-largest-sum/
2.解法
本题为大值最小化问题,采用二分法+贪心算法解决,但是其中有很多细节。
注意本题代码和1231题目的区别
class Solution {
public:
int splitArray(vector<int>& nums, int m) {
int left = *max_element(nums.begin(), nums.end());
int right = accumulate(nums.begin(), nums.end(), 0);
while(left < right){
int med = (left + right) / 2;
int cur = 1, sum = 0;
for(int num : nums){
//贪心算法,只能这么写,如果改成上面那种会报错
if(sum+num > med){
sum = 0;
cur++;
}
sum += num;
}
if(cur > m){
left = med + 1; //这里也无需单独一个ans记录
}
else{
right = med;
}
}
return left;
}
};
(四)leetcode410. 分割数组的最大值(简单)
1.题目
https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/
2.解法
本题就是简单的二分法,只需要比较array[med]和array[med+1]的大小即可
class Solution {
public:
int peakIndexInMountainArray(vector<int>& arr) {
int left = 0, right = arr.size();
while(left < right){
int med = (left + right) / 2;
if(arr[med] < arr[med + 1]){
left = med + 1;
}
else{
right = med;
}
}
return left;
}
};
(五)leetcode1011. 在 D 天内送达包裹的能力(中等)
1.题目
https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/
2.解法
本题是最大值最小化的问题, 采用贪心算法和二分法。注意贪心算法的书写顺序
class Solution {
public:
int shipWithinDays(vector<int>& weights, int days) {
int left = *max_element(weights.begin(), weights.end());
int sum = accumulate(weights.begin(), weights.end(), 0);
int right = sum;
while(left < right){
int med = (left + right) / 2;
int need = 1, cur = 0;
for(int weight:weights){
//最大值最小化的贪心算法
if(cur + weight > med){
cur = 0;
need++;
}
cur += weight;
}
if(need <= days){
right = med;
}
else{
left = med+1;
}
}
return left;
}
};
(六)leetcode1292. 元素和小于等于阈值的正方形的最大边长(中等)
1.题目
2.解法
(1) 前缀和算法
对与一个大小为二维数组array,此外再定义一个大小为新的数组p用来记录前缀和。
p[i][j]记录的就是从array[0][0]到array[i][j]这个矩形区域所有元素的总和。
我们拿上面的这张图片来看,假设这是一个二维数组。不难发现P[i][j] = p[i][j-1] + p[i-1][j] - p[i-1][j-1] + array[i][j]
但是,再仔细想一下会发现这里有一个问题。那就是当i = 0 或者 j = 0的时候,上面那个式子就出错了。所以对于一个size = (m , n)的array, 我们需要用一个size = (m+1, n+1)的数组p来记录其前缀和,这个时候的计算原理和上面是一样的,不过稍有变动。代码如下:
for(int i = 1; i <= m; i++)
for(int j = 1; j <= n; j++){
p[i][j] = p[i][j-1] + p[i-1][j] - p[i-1][j-1] + array[i-1][j-1];
}
(2) 代码
本题为最小值最大化,利用二分法+遍历
这里涉及到前缀和算法,令p记录其前缀和。那么以array[i][j]为左上角定点、边长为l的正方形区域内元素总和为
p[i+l-1][j+l-1] -p[i][j+l-1] - p[i+l-1][j] + p[i][j];
知道了这些,我们要做的就是搜索一个合适的最大边长,对于一个size = (m, n)的array, left = 1, right = min(m, n);
一个注意点就是由于我们的目标是找到边长最大的正方形,那么如果我们在前两重循环枚举到 (i, j) 之前已经找到了一个边长为c的
正方形,那么在枚举以 (i, j) 为左上角的正方形时,我们可以忽略所有边长小于等于 c 的正方形,直接从 c + 1 开始枚举。
class Solution {
public:
int getRect(vector<vector<int>>& p, int x1, int y1, int x2, int y2){
return p[x2][y2] - p[x1-1][y2] - p[x2][y1-1] + p[x1 - 1][y1 - 1];
}
int maxSideLength(vector<vector<int>>& mat, int threshold) {
int row = mat.size(), col = mat[0].size();
vector<vector<int>> p(row+1, vector<int>(col + 1));
for(int i = 1; i <= row; i++)
for(int j = 1; j <= col; j ++){
p[i][j] = p[i-1][j] + p[i][j-1] - p[i-1][j-1] + mat[i - 1][j - 1];
}
int right = min(row, col);
int ans = 0;
for(int i = 1; i <= row; i++)
for(int j = 1; j <= col; j++)
for(int c = ans+1; c <= right; c++){
if(i+c-1 <= row && j+c-1 <= col && getRect(p, i, j, i+c-1, j+c-1) <= threshold){
ans++;
}
else{
break;
}
}
return ans;
}