算法之前缀和-编程知识

题目1: 【模板】一维前缀和（easy）

方法一: 暴力解法, 时间复杂度O(n*q), 当n=10^5, q = 10^5, 时间复杂度为O(10^10), 会超时.

方法二:

前缀和: 快速求出数组中某一段连续区间的和.

第一步: 预处理出来一个前缀和数组dp:

1. dp[i]表示区间[1,i]里所有元素的和

2. dp[i] = dp[i-1] + arr[i]

为什么还有一个前缀和数组?

使用暴力解法是先把arr存进去, 再遍历一次arr求和.

但是求和在存入原始数据的时候就能一起完成 O(n), 而区间[l,r]的和就是dp[r] - dp[l-1], 直接取出数据即可 O(q), 最终时间复杂度是O(n) + O(q), 实际上求前l项数据的和 与 求前r项数据的和 本质是同一类问题, 可以把同一类问题抽象成一种状态表示, 进而用动态规划思想去解决.

细节问题:

我们的数组都要像题目一样表示, 也就是下标从1开始计数, 为什么?

因为 dp[i] = dp[i-1] + arr[i] 这个公式, 当 i==0 的时候会出现dp[-1]越界访问, 而下标从1开始, 第一个数据是dp[1] = dp[0] + arr[1], 对于dp[0]保证其初始化的时候为0即可.

#include <iostream>
using namespace std;int main() 
{int n,q;long long arr[100001]= {0};long long dp[100001] = {0};cin >> n >> q;//O(n)for(int i = 1; i <= n; i++){cin >> arr[i];dp[i] = arr[i] + dp[i-1];}//O(q)for(int j = 0; j < q; j++){long long l,r;cin >> l >> r;cout << dp[r] - dp[l-1] << endl;}return 0;
}
// 64 位输出请用 printf("%lld")

题目2: 【模板】二维前缀和（medium）

方法1: 暴力求解,时间复杂度O(m*n*q)

方法2:前缀和

2.1 利用一维前缀和:

相当于x2x1+1个一维的前缀和相加, 只需要:
1. 确定好每次区间的起始坐标为y1+(x1-1)*m, 则终止坐标为起始坐标+(y2-y1),
2. 起始坐标+=m, 重复循环计算

#include <iostream>
using namespace std;int main()
{int n, m, q;long long arr[1000001] = { 0 };long long dp[1000001] = { 0 };cin >> n >> m >> q;//O(n)for (int i = 1; i <= n * m; i++){cin >> arr[i];dp[i] = arr[i] + dp[i - 1];}//O(q)for (int j = 0; j < q; j++){long long x1, x2, y1, y2, sum = 0;cin >> x1 >> y1 >> x2 >> y2;long long start = y1 + ((x1 - 1) * m);long long gap = y2 - y1;for (int i = 0; i < x2 - x1 + 1; i++){sum += dp[start+gap] - dp[start- 1];start += m;}cout << sum << endl;}return 0;
}
// 64 位输出请用 printf("%lld")

2.2 二维的前缀和

a. 预处理一个前缀和矩阵

dp[i][j]表示: 从 [1][1] 位置到 [i][j] 位置这个矩阵的元素和.

可以把矩阵 i*j 沿 i 和 j 分为四块, 分别标记为A,B,C,D, 因为这样划分A+B 和 A+C 的面积可以分别用dp[i-1][j]和dp[i][j-1]表示, 而D的面积就是arr[i][j], 所以dp[i][j] = A+B + A+C + D - A = dp[i-1][j] + dp[i][j-1] + dp[i-1][j] + arr[i][j] - dp[i-1][j-1]

b.使用这个前缀和矩阵

将矩阵沿x1 y1划分成四份, D的面积推导同上:

#include <iostream>
using namespace std;int main()
{int n, m, q;long long arr[1001][1001] = { 0 };long long dp[1001][1001] = { 0 };cin >> n >> m >> q;//O(n)for (int i = 1; i <= n; i++){for(int j = 1; j<=m;j++){cin >> arr[i][j];dp[i][j] = dp[i-1][j] + dp[i][j-1] + arr[i][j] - dp[i-1][j-1];}}//O(q)for (int j = 0; j < q; j++){long long x1, x2, y1, y2, sum = 0;cin >> x1 >> y1 >> x2 >> y2;cout<< dp[x2][y2] - dp[x1-1][y2] - dp[x2][y1-1] + dp[x1-1][y1-1] << endl;}return 0;
}
// 64 位输出请用 printf("%lld")

题目3: 寻找数组的中心下标

直接利用前缀和:

同之前一样, 利用递推公式求出dp[i], 来表示前i个数的和:

而后缀和可以用前缀和来表示: dp[n]-dp[i+1]

class Solution {
public:int pivotIndex(vector<int>& nums) {int n = nums.size();vector<int> dp(n+1);dp[0] = 0;for(int i = 1; i <= n;i++){dp[i] = dp[i-1] + nums[i-1];}for(int i = 0; i < n;i++){if(dp[i] == dp[n]-dp[i+1])return i;}return -1;}
};

也可以用f[i]表示题意中的前缀和, g[i]表示题中的后缀和, 注意f[i]要从前向后初始化, 而g[i]要从后向前初始化, 最后用f[i] == g[i]进行比较即可:

class Solution {
public:int pivotIndex(vector<int>& nums) {int n = nums.size();vector<int> f(n);vector<int> g(n);//初始化dp数组f[0] = 0;g[n-1] = 0;for(int i = 1; i < n;i++){f[i] = f[i-1] + nums[i-1];g[n-1-i] = g[n-i] + nums[n-i];}//判断for(int i = 0; i < n;i++){if(f[i] == g[i])return i;}return -1;}
};

题目4: 除自身以外数组的乘积

"前缀和"的思路和上一题几乎一模一样, 只是前缀和变成了前缀积, 注意把 f[0] 和 g[n-1] 设置为1:

class Solution {
public:vector<int> productExceptSelf(vector<int>& nums) {int n = nums.size();vector<int> f(n), g(n), answer(n);//初始化dp数组f[0] = 1;g[n-1] = 1;for(int i = 1; i < n;i++){f[i] = f[i-1] * nums[i-1];g[n-1-i] = g[n-i]* nums[n-i];}for(int i = 0; i < n; i++)answer[i] = f[i]*g[i];return answer;}
};

前缀和思路实际上是一种空间换时间的做法, 此题时间复杂度和空间复杂度都是O(N)

优化一下上面的前缀积, 改成空间复杂度为O(1):

由于输出数组不算在空间复杂度内, 那么我们可以将用answer数组计算出前缀积, 然后再动态构造后缀积得到结果, 最后的answer[i]从后向前计算, 即可很巧妙的利用到上次存放的answer[i]前缀积:

class Solution {
public:vector<int> productExceptSelf(vector<int>& nums) {int n = nums.size();vector<int> answer(n);//初始化dp数组answer[0] = 1;for(int i = 1; i < n;i++)answer[i] = answer[i-1] * nums[i-1];//此时answer[i]还是前缀积int R = 1;//动态更新后缀积for(int i = n-1; i >= 0; i--){answer[i] = answer[i] * R;//最终结果,answer[i]为前缀积*后缀积R *= nums[i];//后缀积动态更新}return answer;}
};

题目5: 和为 k 的子数组（medium）

此时是连续的子数组, 看上去可以用滑动窗口解决, 但是不能, 因为数据范围中有0和负数, 滑动窗口滑到和为k时不能停下来, 还要继续往后滑, 因为不确定后面有没有负数和0, 不具备单调性, 所以不能用滑动窗口

前缀和+哈希表:

当下标为i时, 要找一段和为K的子数组, 只需要在[0, i-1]区间内找, 找有多少个前缀和等于sum[i] - k的子数组, 怎么去找呢?

每次求出sum[i]之后然后遍历一遍0~i-1, 这样时间复杂度还是O(n^2+n), 而暴力解法时间复杂度是O(n^2), 所以不能这样去找.

用一个哈希表去存放 前缀和等于sum[i]-k 出现的次数, 这样每次只需要 +=sum[i-k] 对应的值即可, 因为默认值是0.

注意:

1.前缀和加入哈希表的时机?

在计算sum[i]之前, 只保存 [0,i-1] 位置的前缀和.

2. 如果 sum[i] 等于k, 那么它本身就是一个要找的子数组, 在哈希表中所对应的应该是sum[i]-k=0, 但是这个0相当于在[0,-1]区间内, 并不会被加入进哈希表, 所以在哈希表初始化时要令hash[0]=1, 避免这种情况被遗漏

3. 我们不用真的创建一个前缀和数组, 用一个sum变量去标记前一个前缀和即可.

class Solution {
public:int subarraySum(vector<int>& nums, int k) {unordered_map<int,int> hash;hash[0] = 1;int sum = 0, ret = 0;for(auto e: nums){sum += e;ret += hash[sum-k];hash[sum]++;}return ret;}
};

题目6: 和可被 K 整除的子数组

前置知识:

1. 同余定理:
如果 (a - b) % n == 0 , 那么我们可以得到一个结论: a % n == b % n 。用文字叙述就是, 如果两个数相减的差能被 n 整除, 那么这两个数对 n 取模的结果相同.

2. c++ 中负数取模的结果, 以及如何修正「负数取模」的结果
a. c++ 中关于负数的取模运算, 因为c++整除是向零取整(余数符号和被除数一样), 而不是向下取整(余数符号和除数相等), 所以我们来推导一下上面的结论, 因为(a - b) % n == 0 , 所以a = b+kn, 两边同时取余即可得到上面的结论, 但是这里两边同时取余是有条件的, 假如以c++的取余规则, a是正数, b是负数, 这就导致a是向下取整(实际是向零取整, 但是方向都相同)得到的余数, 而b是向上取整(实际是向零取整, 方向是向上取整)得到的余数, 取余是不等价的, 所以需要把负数的取余操作进行修正, 以(a % n + n) % n 的形式输出保证为正.

了解了这些再来看这道题:假如一段区间和能被k整除, 也就是(sum-k)%k = 0, 根据同余定理, sum%k = x%k, 所以对于每一个sum, 只需找去找[0, i-1]区间里前缀和(x) = sum%k的次数即可, 又回归到了上一道题, 思路同上一道题, 注意当k==sum的时候, 需要找0, 所以hash[0]要初始化为1:

class Solution {
public:int subarraysDivByK(vector<int>& nums, int k) {unordered_map<int,int> hash;hash[0] = 1;int sum = 0, ret = 0;for(auto e : nums){sum += e;ret += hash[(sum%k+k)%k];hash[(sum%k+k)%k]++;}return ret;}
};

题目7: 连续数组（medium）

此题如果直接去统计区间0和1的个数会发现很困难, 可以转化一下, 把所有的0看作-1, 含有相同数量的0和1的子数组的和就为0, 问题转化为求和为0的子数组, 和之前的那道题类似.

前缀和 + 哈希:

1. 哈希表中存什么?

这题不是求和为k的子数组的数目, 而是求区间长度, 所以哈希表应该存 hash<前缀和, 下标>

2. 什么时候存入哈希表?

和之前一样, 判断完再存入

3. 出现重复的<sum,i>, 该如何处理?

因为是从前向后遍历数组的, 所以下标i越小, 求出的区间就越长, 所以只存入第一个前缀和为sum的i即可.

4. 区间长度怎么算?

如图, i-j 即为区间长度

5. hash[0]该如何初始化?

同之前一样, 可能当前的sum和就为0, 要去区间 [0,-1] 寻找0, 所以hash[0] = - 1

class Solution {
public:int findMaxLength(vector<int>& nums){unordered_map<int, int> hash;hash[0] = -1; //默认有一个前缀和为0的情况int sum = 0, ret = 0, n = nums.size();for(int i = 0; i < n; i++){sum += nums[i] == 0 ? -1 : 1;//计算当前前缀和if(hash.count(sum)) ret = max(ret,i-hash[sum]);else //找不到sum才存下标hash[sum] = i;}return ret;}
};

题目8 : 矩阵区域和（medium）

题目的描述是让我们求出一个矩阵, 矩阵里每个元素answer[i][j] 是 mat[i][j] 周围k格内元素的和, 如果越界则以边界为界限.

解法: 利用二维前缀和

a. dp[i][j]表示: dp[i][j] = A+B + A+C + D - A = dp[i-1][j] + dp[i][j-1] + dp[i-1][j] + arr[i][j] - dp[i-1][j-1]

b.使用这个前缀和矩阵

所以只要我们给定两个点x1,y1 和 x2,y2, 对应矩阵的和可以求出来, 所以对于每一个answer[i][j], 我们只需要确定好x1,y1,x2,y2即可, 由题意, x1 = i-k, y1 = j-k, x2 = i+k, y2=j+k, 但是还要考虑越界情况, 所以x1 = max(i-k,0), y1 = max(j-k,0), x2 = min(i+k, n-1), y2 = min(j+k, m-1)

下标的对应关系:

此题大体思路是这样, 但是注意我们原题中给的矩阵mat是下标从0开始的, 也就是说对应的dp[i][j]如果在边界上初始化会出现越界访问, 所以我们应该给dp数组开辟一个n+1*m+1大小的空间, 其中第0行第0列全部初始化为0, 方便dp[i][j]的计算, 与之对应的, 初始化公式也要进行修改:

dp里用到mat就要减1:

ans里用到dp就要加1, 因为ans的下标是对应着mat的下标:

class Solution {
public:vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {int n = mat.size(), m = mat[0].size();vector<vector<int>> dp(n+1,vector<int>(m+1));//n+1 * m+1for(int i = 1; i <= n; i++){for(int j = 1; j <= m; j++){dp[i][j] = dp[i][j-1] + dp[i-1][j] + mat[i-1][j-1] - dp[i-1][j-1];}}vector<vector<int>> ret(n, vector<int>(m));//n * mfor(int i = 0; i < n; i++){for(int j = 0; j < m; j++){int x1 = max(0,i-k)+1, y1 = max(0,j-k)+1;int x2 = min(n-1,i+k)+1, y2 = min(m-1,j+k)+1; ret[i][j] = dp[x2][y2] - dp[x1-1][y2] - dp[x2][y1-1] + dp[x1-1][y1-1];}}return ret;}
};