记录下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];
}
};