题目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+1
for(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 * m
for(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;
}
};
![[java基础揉碎]Object类详解](https://img-blog.csdnimg.cn/direct/ff94e2d601624394ae09db4a72f111b2.png)
