算法-前缀和数组、差分数组

目录

前缀和 

1，前缀和 + 二分查找

2，前缀和 + 哈希

3， 前缀和 + 差分

4，前缀和二维数组

5，最大区间和

差分数组

1，leetcode370 区间加法（直接考察的差分数组技巧）：

2，leetcode航班预订系统

3，1094. 拼车

Leetcode]253. 会议室 II（数组/堆）

---

前缀和 

见：力扣

前缀和指一个数组的某下标之前的所有数组元素的和（包含其自身），前缀和是一种重要的预处理，能够降低算法的时间复杂度。

用途：

前缀和主要适用的场景是原始数组不会被修改的情况下，频繁查询某个区间的累加和。

   给定数组：nums[n] = {a1, a2, ...., an-1};共n个元素

前缀和数组：preSum[n + 1] = {0, a1, a1 + a2, ...., a1+..+an-1};

    // 构造前缀和
    vector<int> preSum(n + 1);
    preSum[0] = 0; 
    for (int i = 0; i < n; i++) {
        preSum[i + 1] = preSum[i] + nums[i];
    }

可推导出2个变换公式：

（1）nums的[i, j]区间元素的和(包括i, j)等于：preSum[j + 1] - preSum[i]，（以nums的下标维度，遍历范围：[0, numsSize)）

        特例：nums[i]（[i, i]区间元素的和）等于preSum[i + 1] - preSum[i]

（2）preSum[i] 记录给定数组nums中 [0, i - 1] 区间的元素和（其中 i = 1, 2, ..., preSumSize-1）。（以preSum的下标维度, 遍历范围：[1, preSumSize)）

1，前缀和 + 二分查找

​​​​​​1712. 将数组分成三个子数组的方案数

 //前缀和+二分：提示连续子数组和--想到前缀和， 且非负--前缀和单调升序--想到二分

// 思路

// 遍历前缀和数组, 设遍历中的下标i为left和mid的闭区间边界(边界1)，此时[i + 1, preSumSize -2]区间内查找划分mid和right的边界(边界2)，使得满足leftSum <= midSum <= rightSum条件。

// 边界2最小值为lowerIdx, 边界2最大值为upperIdx。即边界2闭区间[lowerIdx, upperIdx]内的所有值都满足本轮在边界1的情况下使得leftSum <= midSum <= rightSum成立。

// (1)先寻找lowerIdx：在[i + 1, preSumSize - 1)区间内，只需找满足midSum=(preSum[边界2] - preSum[i]) >= leftSum条

//    件(即找target = 2 * leftSum)的lower_bound就是边界2最小值。

// (2)再寻找upperIdx：在[i + 1, preSumSize - 1)区间内，只需找满足rightSum=(preSum[preSumSize-1] - preSum[边界2]) >= midSum=(preSum[边界2] - preSum[i])条

//    件(即找target = preSum[i] + (preSum[preSumSize-1] - preSum[i]) / 2, 即midSum和rightSum的平均值)的upper_bound就是边界2最大值

// (3)对lowerIdx和upperIdx进行有效区间判定：按照midSum>=leftSum寻找到lowerIdx，又按照rightSum>=midSum寻找到midSum，因此当upperIdx >= lowerIdx时，

//    就得到了边界2有效的闭区间范围[lowerIdx, upperIdx]使得leftSum <= midSum <= rightSum

/*
     {1,   2,  2,  2,  5,   0}

i  0  1    2   3   4    5   6
  {0, 1,   3|, 5,  7,  12,  12}
i:2
    当用i=2分出leftSum，那么在[i + 1, preSumSize - 1)区间找target，而求midSum时是始终用preSum[mid] - leftSum求得，求rightSum时始终用preSum[preSumSize - 1] - leftSum求得
    leftIdx， target = 2 * leftSum
    rightIdx，target = leftSum + (preSum[preSumSize - 1] - leftSum) / 2
leftIdx:4
  {0, 1,   3|, 5,  7|, 12, 12|} // 在[i + 1, preSumSize - 1)区间找target=2*3=6的lowerbound, leftIdx = lowerboundIdx
     [0,   1][1,   3][3,   5]
     {1,   2}{2,   2}{5,    0}
     3-0=3     7-3=4   12-7=5
rightIdx:4
  {0, 1,   3|, 5,  7|, 12, 12} // 在[i + 1, preSumSize - 1)即{5, 7, 12}区间找target=3 + (12-3)/2 = 7的upperbound, rightIdx = upperboundIdx - 1
     [0,   1][1,   3][3,   5]
     {1,   2}{2,   2}{5,   0}
        3        4      5

i  0  1    2   3   4    5   6
  {0, 1|,   3, 5,  7,  12,  12}
i:1
leftIdx:2
  {0, 1|,   3|,5,  7, 12, 12|} // 在[i + 1, preSumSize - 1)区间找target=2*1=2的lowerbound, leftIdx = lowerboundIdx
     1    2       12-3=9
rightIdx:3
  {0, 1|,   3, 5|,  7, 12, 12} // 在[i + 1, preSumSize - 1)区间找target=1 + (12-1)/2 = 6的upperbound, rightIdx = upperboundIdx - 1
     1   5-1=4      12-5 = 7
*/

 二分模板见：二分搜索模板_u011764940的博客-CSDN博客

class Solution {
public:
    int waysToSplit(vector<int>& a) {
        int aSize = a.size();
        vector<int> preSum(aSize + 1);
        for (int i = 0; i < aSize; i++) {
            preSum[i + 1] = preSum[i] + a[i];
        }

        long long res = 0;
        int preSumSize = preSum.size();
        // 因为是直接用preSum[i]标识nums的和，因此用preSum索引[1, n]遍历
        for (int i = 1; i < preSumSize - 2; i ++) { // 剪枝：left和mid的分界点不能大于等于在preSumSize - 2这样分不出left/mid/right三段
            int leftSum = preSum[i]; // a数组[0, i - 1)的区间和
            if (leftSum * 3 > preSum[preSumSize - 1]) { // 剪枝
                break;
            }

            // 调标准库：228ms
            // int leftIdx = lower_bound(preSum.begin() + i, preSum.end() - 1, 2 * leftSum) - preSum.begin(); // lower_bound是找大于等于target，满足leftIdx的左闭
            // int rightIdx = upper_bound(preSum.begin() + i, preSum.end() - 1, leftSum + (preSum[aSize] - leftSum) / 2) - preSum.begin() - 1; // upper_bound是找大于target，是右开，因此减1后得到右闭且减1会使midSum更小于rightSum
            // 调手写：160ms
            int leftIdx = LowerBound(preSum, i + 1, preSumSize - 1, 2 * leftSum);
            int rightIdx = UpperBound(preSum, i + 1, preSumSize - 1, leftSum + (preSum[preSumSize - 1] - leftSum) / 2) - 1;
            // leftIdx = max(i + 1, leftIdx); // 可略，因为本身就是在i + 1起始点开始找的，LowerBound返回值可能范围[i+1, preSumSize-1]
            // rightIdx = min(preSumSize - 2, rightIdx); // 可略, UpperBound返回的是大于target的idx(可能的范围是[i+1, preSumSize-1])， 已经减去1了（可能的范围是[i, preSumSize-2]）
            if (rightIdx >= leftIdx) {
                res += (rightIdx - leftIdx + 1);
            }
        }

        return res % int(1e9 + 7);
    }

private:
    // 入参搜索范围[left, right)及结果均与std::lower_bound相同
    int LowerBound(const vector<int> &nums, int left, int right, int target)
    {
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                right = mid;
            } else if (nums[mid] > target) {
                right = mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        return left;
    }

    // 入参搜索范围[left, right)及结果均与std::upper_bound相同
    int UpperBound(const vector<int> &nums, int left, int right, int target)
    {
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        return left;
    }
};

209. 长度最小的子数组 --（可以用滑动窗口，也可以用前缀和+二分）

算法滑动窗口_u011764940的博客-CSDN博客

 

法1：滑动窗口

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int sum = 0;
        int left = 0;
        int right = 0;
        int result = nums.size();
        while (right < nums.size()) {
            sum += nums[right];
            right++;
            while (sum >= s) {
                result = min(result, right - left);
                sum -= nums[left];
                left++;
            }
        }
        return result;
    }
};

法2：前缀和 + 二分

因为这道题保证了数组中每个元素都为正，所以前缀和一定是递增的，这一点保证了二分的正确性。如果题目没有说明数组中每个元素都为正，这里就不能使用二分来查找这个位置了。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        vector<int> sums(n + 1, 0); 
        for (int i = 1; i <= n; i++) {
            sums[i] = sums[i - 1] + nums[i - 1];
        }
        for (int i = 1; i <= n; i++) {
            int target = s + sums[i - 1];
            auto bound = lower_bound(sums.begin(), sums.end(), target);
            if (bound != sums.end()) {
                ans = min(ans, static_cast<int>((bound - sums.begin()) - (i - 1)));