前缀和

记录下leetcode里关于前缀和的题目。前缀和的概念很简单， sum[i+1] = sum(a[0]...a[i])， 计算 a[i]...a[j]的和就是 sum[j+1] - sum[i]。但是暴力枚举符合条件的(i, j)对往往超时，需要结合hash表记录。

1.和为k的子数组

https://leetcode-cn.com/problems/subarray-sum-equals-k/

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
说明 :

数组的长度为 [1, 20,000]。
数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

最简单的想法，暴力枚举前缀和数组中的 i, j，然后统计sum[j] - sum[i] = k (n >= j > i >= 0) 的个数，但是O(n^2)的复杂度对这个规模是过不了的。

既然需要求的是 sum[j] - sum[i] = k (0 <= i < j <= n) 的个数，那么可以顺序遍历 j(1...n)， 寻找之前出现过的 sum[j] - k 的数量。将之前出现过的 sum[i]的个数用哈希表存储，这样保证了每一次寻找等于(sum[j] - k)的sum[i]都满足 i < j 这一条件。

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        if(n == 0) return 0;
        vector<int> sum(n+1, 0);
        for (int i = 0; i < n; ++i)
        {
            sum[i+1] = sum[i] + nums[i];
        }
        // sum[j] - sum[i] = k; j > i >= 0;
        int cnt = 0;
        unordered_map<int, int> mp;
        mp[0] = 1;
        for (int i = 1; i <= n; ++i)
        {
            if(mp.count(sum[i] - k) > 0) cnt += mp[sum[i] - k];
            mp[sum[i]]++;
        }
        return cnt;
    }
};

2. 和被k整除的子数组

https://leetcode-cn.com/problems/subarray-sums-divisible-by-k/

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
说明 :

数组的长度为 [1, 20,000]。
数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

同样，暴力枚举 i j 的做法是超时的。要找的目标是 (sum[j] - sum[i]) % k = 0, (0 <= i < j <= n) 的个数。根据模运算的性质， sum[i] % k = sum[j] % k。因此，只要以sum[i]对k取模的结果为key，用哈希表存储不同模值的结果数目即可。假设sum数组中一共有m个数模k等于x，那么能产生的 i j 对个数就是 m * (m - 1) / 2。

这里还要注意一点，C++负数对正数取模的结果还是负数，需要单独处理，否则结果会错误。

对负数x， x % k = (x % k + k) % k。

class Solution {
public:
    int subarraysDivByK(vector<int>& A, int K) {
        int n = A.size();
        if(n == 0) return 0;
        vector<int> sum(n + 1, 0);
        unordered_map<int,int> mp;
        mp[0] = 1;
        // 注意负数取模 (x % K + K) % K
        for (int i = 0; i < n; ++i)
        {
            sum[i+1] = sum[i] + A[i];
            if(sum[i+1] < 0) mp[(sum[i+1]%K + K) % K]++;
            else mp[sum[i+1] % K]++;
        }
        // (sum[j] - sum[i]) % K == 0 -> sum[j] % K = sum[i] % K; j > i >= 0;
        int cnt = 0;
        for(auto it : mp)
        {
            cnt += it.second * (it.second-1) / 2;
        }
        return cnt;
    }
};

3. 713. 乘积小于K的子数组

给定一个正整数数组 nums。

找出该数组内乘积小于 k 的连续的子数组的个数。

示例 1:

输入: nums = [10,5,2,6], k = 100
输出: 8
解释: 8个乘积小于100的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于100的子数组。
说明:

0 < nums.length <= 50000
0 < nums[i] < 1000
0 <= k < 10^6

乘积可以通过对数运算转换成求和，那么 nums[i] *....* nums[j] < k 等价于 log(nums[i]) +...+ log(nums[j]) < log(k)，即 sum[j+1] - sum[i] < log(k)。

由于要求的是连续子数组的个数，对于每一个 j (0 <= j < n)，如果能找到最小的 i， 满足 sum[j+1] - sum[i] < log(k)，那么[i...j]中所有以j结尾的子数组都满足要求，一共是 j - i + 1个。而找最小的i 满足 sum[j+1] - sum[i] < log(k)，等价于 sum[i] > sum[j+1] - log(k)， 由于sum数组单调增，可以用二分法 upperbound来找这个最小的 i。

但是有一个地方需要注意，这里的数值都是double，因此在使用upperbound时如果使用默认的 < 运算符可能会出错，需要自定义 compare函数， a < b 等价于 a - b < - eps，这里eps可以取 1e-9。

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        int n = nums.size();
        if(n == 0 || k <= 1) return 0;
        //转换为对数 nums[i]*....*nums[j] < k <=> log(nums[i]) +....+ log(nums[j]) < logk <=> sum[j+1] - sum[i] < logk
        //对于每个 0 < j < n， [i...j]的和 sum[j+1] - sum[i] < logk 的最小的i，满足sum[i] > sum[j+1] - logk, 0<= i <= j,
        // 则以 nums[j]结尾的乘积小于k的子数组个数 j - i + 1
        vector<double> sum(n+1, 0);
        for (int i = 0; i < n; ++i)
        {
            sum[i+1] = sum[i] + log(nums[i]);
        }
        int ans = 0;
        for (int j = 0; j < n; ++j)
        {
            //注意double的比较 a < b，要重载compare函数， a < b <=> a - b < -eps (eps取1e-9)
            int i = upper_bound(sum.begin(), sum.begin() + j + 1, sum[j+1] - log(k), [](const double a, const double b){return a - b < -1e-9;}) - sum.begin();
            ans += j - i + 1;
        }
        return ans;
    }
};

 这一解法的时间复杂度是 O(nlogn)，实际上有复杂度 O(n)的解法：

维护一个滑动窗口[left,right)，如果滑动窗口的乘积小于k，那么窗口内所有以 nums[right-1]结尾的子数组都满足要求，一共是 right - left个。如果窗口的乘积大于等于k，那么就缩小窗口大小，不断增加left，直到窗口满足条件。

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        int n = nums.size();
        if(n == 0 || k <= 1) return 0;
        int left = 0, right = 0, ans = 0;
        //如果[left,right)的乘积小于k，那么所有以nums[right-1]结尾的子数组乘积都小于k，一共有right - left个
        int product = 1;
        while(right < n)
        {
            right++;
            product = product * nums[right-1];          
            while(product >= k && left < right)
            {
                product /= nums[left++];
            }
            ans += right - left;
        }
        return ans;
    }
};

4.327. 区间和的个数

给定一个整数数组 nums，返回区间和在 [lower, upper] 之间的个数，包含 lower 和 upper。
区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。

说明:
最直观的算法复杂度是 O(n2) ，请在此基础上优化你的算法。

示例:

输入: nums = [-2,5,-1], lower = -2, upper = 2,
输出: 3 
解释: 3个区间分别是: [0,0], [2,2], [0,2]，它们表示的和分别为: -2, -1, 2。

这一题可以用归并的方法做，不过比较难想到：https://blog.csdn.net/chch1996/article/details/106002600。

事实上这一题和第1题统计和为k的子数组个数非常相似，只不过这里要统计的是和落在[lower, upper]区间的子数组个数。也就是，依次遍历到每个presum[i]，考察它前面出现过的presum[j]中，有多少能满足 lower <= presum[i] - presum[j] <= upper, 也就是在hash表中 presum[i] - upper <= presum[j] <= presum[i] - lower的个数。因为是范围，所以用map自动排序，lowerbound和upperbound找 map中第一个 >= persum[i] - upper 的迭代器 left, 第一个 > presum[i] - lower 的迭代器 right， 累计[left, right)中的个数即可。

注意mp[0] = 1，经常忘记。

class Solution {
public:
    int countRangeSum(vector<int>& nums, int lower, int upper) {
        int n = nums.size();
        vector<long long> presum(n+1, 0);
        for (int i = 0; i < n; ++i)
        {
            presum[i+1] = presum[i] + nums[i];
        }
        map<long long, int> mp;
        mp[0] = 1;
        int ans = 0;
        // lower <= presum[i] - ? <= upper
        //  presum[i] - upper <= ? <= presum[i] - lower
        for (int i = 1; i <= n; ++i)
        {
            auto left = mp.lower_bound(presum[i] - upper);
            auto right = mp.upper_bound(presum[i] - lower);
            auto it = left;
            while(it != right && it != mp.end())
            {
                ans += it->second;
                it++;
            }
            mp[presum[i]]++;
        }
        return ans;
    }
};

5.1546. 和为目标值的最大数目不重叠非空子数组数目

给你一个数组 nums 和一个整数 target 。

请你返回 非空不重叠 子数组的最大数目，且每个子数组中数字和都为 target 。

 

示例 1：

输入：nums = [1,1,1,1,1], target = 2
输出：2
解释：总共有 2 个不重叠子数组（加粗数字表示） [1,1,1,1,1] ，它们的和为目标值 2 。
示例 2：

输入：nums = [-1,3,5,1,4,2,-9], target = 6
输出：2
解释：总共有 3 个子数组和为 6 。
([5,1], [4,2], [3,5,1,4,2,-9]) 但只有前 2 个是不重叠的。
示例 3：

输入：nums = [-2,6,6,3,5,4,1,2,8], target = 10
输出：3
示例 4：

输入：nums = [0,0,0], target = 0
输出：3
 

提示：

1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
0 <= target <= 10^6

 可以用贪心或者动态规划两种方法去做。

动态规划方法比较常规，但是设计状态转移有难度：

如果令dp[i]: 表示[0...i]中，最多的不重叠的和为target的子数组数量，那么对于下标为i的元素，如果不考虑它，dp[i] = dp[i-1]；如果考虑它，那么如果它能和前面一段组成和为target的子数组，即[j...i]和为target，那么 dp[i] = dp[j - 1] + 1。

因此，需要快速查找 i 是否能和前面一段构成和为target的子数组，如果能构成的话端点j是多少。这就需要利用前缀和。如果当前的前缀和是sum，而前缀和为 sum - target 的最近位置是 k， 那么就是说 [k + 1...i] 的和是target，dp[i] = dp[k] + 1。

class Solution {
    //动态规划：如果当前位置i能够与前面一段组成target，[j...i]的和是target，那么 dp[i] = max(dp[i-1], dp[j-1] + 1)
public:
    int maxNonOverlapping(vector<int>& nums, int target) {
        const int MAXN = 1e5;
        int dp[MAXN] = {0};
        //dp[i]: [0...i]中最多有多少不重叠的子数组和为target
        dp[0] = nums[0] == target ? 1 : 0;
        unordered_map<int,int> h;
        h[0] = -1;
        h[nums[0]] = 0;
        int sum = nums[0], n = nums.size();
        for(int i = 1; i < n; i++)
        {
            dp[i] = dp[i-1];
            sum += nums[i];
            auto it = h.find(sum - target);
            if(it != h.end()) dp[i] = max(dp[i], it->second >= 0 ? dp[it->second] + 1 : 1);
            h[sum] = i;
        }
        return dp[n-1];
    }
};

贪心：每找到一个子数组[i...j]和为target，那么就将状态重置，从 j+1开始继续找，因为即使后面存在k, k > j, 使得 [i...k]的和为target，也不会优于选择[i...j]。

class Solution {
    //动态规划：如果当前位置i能够与前面一段组成target，[j...i]的和是target，那么 dp[i] = max(dp[i-1], dp[j-1] + 1)
public:
    int maxNonOverlapping(vector<int>& nums, int target) {
        const int MAXN = 1e5;
        int dp[MAXN] = {0};
        //dp[i]: [0...i]中最多有多少不重叠的子数组和为target
        dp[0] = nums[0] == target ? 1 : 0;
        unordered_map<int,int> h;
        h[0] = -1;
        h[nums[0]] = 0;
        int sum = nums[0], n = nums.size();
        for(int i = 1; i < n; i++)
        {
            dp[i] = dp[i-1];
            sum += nums[i];
            auto it = h.find(sum - target);
            if(it != h.end()) dp[i] = max(dp[i], it->second >= 0 ? dp[it->second] + 1 : 1);
            h[sum] = i;
        }
        return dp[n-1];
    }
};