二分法的妙用

基础

首先了解C++中存在于头文件 两个库函数：lower_bound和upper_bound
lower_bound(start, end, val)返回在[start, end)中找到第一个大于等于val的 位置
upper_bound(start, end, val)返回在[start, end)中找到第一个大于val的 位置

lower_bound及upper_bound的简单实现

只有一个等号的区别，以lower_bound为例，当v[mid]小于x是，left肯定要取mid+1，否则，right=mid，right一定符合, 让left不断逼近right

#include <iostream>
#include <vector>
using namespace std;
int lower_bound(vector<int>& v, int left, int right, int x){
    while(left < right){
        int mid = (left + right) / 2;
        if(v[mid] < x) left = mid + 1;
        else right = mid;
    }
    return left;
}

int upper_bound(vector<int>& v, int left, int right, int x){
    while(left < right){
        int mid = (left + right) / 2;
        if(v[mid] <= x) left = mid + 1;
        else right = mid;
    }
    return left;
}
int main() {
    vector<int> v{1,2,3,4,5,6,6,7,8,9};
    cout << lower_bound(v, 0, v.size(), 6);
    cout << upper_bound(v, 0, v.size(), 6);
    return 0;
}

题目

Split Array Largest Sum

题目链接：410. Split Array Largest Sum
题目解法：Solution with Greedy Algorithm and Binary Search
给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小
由题意，我们可以知道m必定在[max(max(nums), sum(nums)/m), sum(nums)]之间，我们可以先猜一个中间值max，并构造子数组使得每个子数组之和都不超过max，如果我们从小到大取max,得到一个结果组成数组B，则B中一定是[F,F,F,T,T]这种的，越大更容易为True，这种情况我们可以使用二分法找到第一个T，这个T对应的max就是最小的最大值

class Solution {
public:
    bool doable(vector<int>& nums, long long max, int cut){
        long acc = 0;
        for (int &num: nums) {
            if(num > max) return false;
            else if(acc + num <= max) acc += num;
            else {
                cut--;
                acc = num;
                if(cut < 0) return false;
            }
        }
        return true;
    }
    int splitArray(vector<int>& nums, int m) {
        long long left = 0, right = 0;
        for (int &num : nums) {
            left = max(left, (long long)num);
            right += num;
        }
        
        while (left < right) {
            long long mid = left + (right - left) / 2;
            if (doable(nums, mid, m - 1)) right = mid;
            else left = mid + 1;
        }
        return left;
    }
};

DP解法:dp方程很简单dp[i][j]表示将索引到i的（包括i）数组分解为j个组的最小最大和递推方程为dp[i][j] = min(max(dp[k][j-1], sum[k+1，i]) ），很慢

class Solution {
public:
    int splitArray(vector<int>& nums, int m) {
        int n = nums.size();
        vector<long long> p(n+1);
        p[0] = 0;
        
        for(long i = 1; i <= n; i++) p[i] = p[i-1] + nums[i-1];
        // sum[i, j] = p[j+1] - p[i];
        
        
        vector<vector<long long>> dp(n + 1, vector<long long>(n+1, INT_MAX));
        int MAX = 0;
        for(int i = 0; i < n; i++) {
            MAX = max(nums[i], MAX);
            dp[i][1] = p[i+1];
            dp[i][i+1] = MAX;
        }
        for(int i = 0; i < n; i++){
            for(int j = 2; j <= m; j++){
                for(int k = j-2; k < i; k++){
                    dp[i][j] = min(max(dp[k][j-1], p[i+1]- p[k+1]), dp[i][j]);
                }
            }
        }
        
        return dp[n-1][m];
    }
};

二维变一维

class Solution {
public:
    int splitArray(vector<int>& nums, int m) {
        int n = nums.size();
        vector<long long> p(n+1);
        p[0] = 0;
        
        for(long i = 1; i <= n; i++) p[i] = p[i-1] + nums[i-1];
        // sum[i, j] = p[j+1] - p[i];
        
        
        vector<long long> dp(n + 1, INT_MAX);
        int MAX = 0;
        for(int i = 0; i < n; i++) {
            
           
            dp[i] = p[i+1];
        }
        
        for(int j = 2; j <= m; j++){
            for(int i = n - 1; i >= 0; i--){
                dp[i] = INT_MAX;
                for(int k = j-2; k < i; k++){
                    dp[i] = min(max(dp[k], p[i+1]- p[k+1]), dp[i]);
                    
                }  
               
            }
        }
        
        
        
        return dp[n-1];
    }
};

Maximum Length of Repeated Subarray

题目链接：718. Maximum Length of Repeated Subarray
题目解法：Github Issue 324. Maximum Length of Repeated Subarray
这题本身很简单，DP的话和LCS差不多，也可以用偏移做，时间复杂度是\(O(n^2)\)
但是值得一提的是二分搜索的解法Binary Search + Rabin Karp + Hash Table, O(N log N), Beats 100%
大致思路是计算每个[0,i]串的hash值，然后计算长度为m的串hash值，判断两个数组中的串的hash是否有重合，如果有重合，增大l=m+1, 如果没有r=m-1，这种做法容易溢出，但思路很好

class Solution {
public:
    int findLength(vector<int>& A, vector<int>& B) {
        const int P = 19941229; //Rabin-Karp
        
        vector<int> hash1(A.size() + 1, 0), hash2(B.size() + 1, 0), p(max(A.size(), B.size()) + 1);
        int len = max(A.size(), B.size());
        p[0] = 1;
        for (int i = 1; i <= len; i++)
            p[i] = p[i - 1] * P;
        for (int i = 1; i <= A.size(); i++)
            hash1[i] = hash1[i - 1] + A[i - 1] * p[i];
        for (int i = 1; i <= B.size(); i++)
            hash2[i] = hash2[i - 1] + B[i - 1] * p[i];
        int l = 1, r = min(A.size(), B.size());
        while (l <= r) { //Binary search the answer
            int m = (l + r) / 2;
            unordered_set<int> hash;
            bool ok = false;
            for (int i = 1; i + m - 1 <= A.size(); i++) //Calculate Rabin-Karp hash for all substring s for the first string of length m, insert into hash table
                hash.insert((hash1[i + m - 1] - hash1[i - 1]) * p[len - (i + m - 1)]);
            for (int i = 1; i + m - 1 <= B.size(); i++){ //Calculate Rabin-Karp hash for the second string, query the hash table
                if (hash.count((hash2[i + m - 1] - hash2[i - 1]) * p[len - (i + m - 1)])) {
                    ok = true;
                    break;
                }
            }
            if (ok)
                l = m + 1;
            else
                r = m - 1;
        }
        return r;
    }
};

参考

• lower_bound