【C++刷LeetCode套路2】Array题型: 二分法查找套路和解题模板

一.二分法的概念

二分法，可以用于解决有序区间内的搜索问题，其时间复杂度为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.题目

https://leetcode-cn.com/problems/maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold/

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;
    }