前缀和
- 一、【模板】一维前缀和
- 二、【模板】二维前缀和
- 三、寻找数组的中心下标
- 四、除自身以外数组的乘积
- 五、和为K子数组
- 六、和可被 K 整除的子数组
- 七、连续数组
- 八、矩阵区域和
一、【模板】一维前缀和
一维前缀和，链接
1、预处理出来一个前缀和数组
注意：一般处理前缀和数组的时候 下标要从1开始！
2、使用该前缀和数组
#include <iostream>
using namespace std;
#include<vector>
int main()
{
int n,q;
cin>>n>>q;
vector<int> arr(n+1);
// 1、读入数据
for(int i=1;i<=n;i++) cin>>arr[i];
// 2、预处理一个前缀和数组
vector<long long> dp(n+1);
for(int i=1;i<=n;i++) dp[i]=dp[i-1]+arr[i];
// 3、使用前缀和数组
int l,r;
while(q--)
{
cin>>l>>r;
cout<<dp[r]-dp[l-1]<<endl;
}
return 0;
}
二、【模板】二维前缀和
二维前缀和、链接
1、预处理出来一个前缀和数组
注意：一般处理前缀和数组的时候 下标要从1开始！
2、使用该前缀和数组
#include <iostream>
using namespace std;
#include<vector>
int main()
{ int n,m,q;
cin>>n>>m>>q;
vector<vector<int>> arr(n+1,vector<int>(m+1));
// 1、读入数据
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>arr[i][j];
}
}
vector<vector<long long>> dp(n+1,vector<long long>(m+1));
// 2、预处理出来一个前缀和数组
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
dp[i][j]=dp[i-1][j]+dp[i][j-1]+arr[i][j]-dp[i-1][j-1];
}
}
// 3、使用前缀和数组
int x1,y1,x2,y2;
while(q--)
{
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;
}
三、寻找数组的中心下标
寻找数组的中心下标、链接
class Solution
{
public:
int pivotIndex(vector<int>& nums)
{
// 1、预处理前缀和、后缀和
int n=nums.size();
vector<int> f(n),g(n);
for(int i=1;i<n;i++)
// 对f[0]、g[n-1]已经进行了特殊处理，所以两次处理都要从第二个数据开始！
f[i]=f[i-1]+nums[i-1];
for(int i=n-2;i>=0;i--)
g[i]=g[i+1]+nums[i+1];
// 2、使用前后缀和
for(int i=0;i<n;i++)
if(f[i]==g[i])
return i;
return -1;
}
};
四、除自身以外数组的乘积
除自身以外数组的乘积、链接
class Solution
{
public:
vector<int> productExceptSelf(vector<int>& nums)
{
int n=nums.size();
vector<int> f(n),g(n);
f[0]=g[n-1]=1;
// 1、预处理
for(int i=1;i<n;i++)
{
f[i]=f[i-1]*nums[i-1];
}
for(int i=n-2;i>=0;i--)
{
g[i]=g[i+1]*nums[i+1];
}
vector<int> ans(n);
// 2、使用预处理的数组
for(int i=0;i<n;i++)
{
ans[i]=f[i]*g[i];
}
return ans;
}
};
五、和为K子数组
和为 K 的子数组、链接
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;// sum：当前位置的前缀和
if(hash.count(sum-k)) ret+=hash[sum-k];
// 如果在哈希表里面找到sum-k的前缀和，说明在sum这个区间上有一个和为k的子数组！
hash[sum]++;
}
return ret;
}
};
六、和可被 K 整除的子数组
和可以被k整除的子数组、链接
1、补充的知识！
2、算法原理：
class Solution
{
public:
int subarraysDivByK(vector<int>& nums, int k)
{
unordered_map<int,int> hash;
hash[0%k]=1;//存的是0%k的余数
int sum=0,ret=0;
for(auto e:nums)
{
sum+=e;
int r=(sum%k+k)%k;// 注意：修正后的余数
if(hash.count(r)) ret+=hash[r];//我们找的是前缀和中的余数
hash[r]++;// 把当前位置的余数加入哈希表！
}
return ret;
}
};
七、连续数组
连续数组、链接
class Solution
{
public:
int findMaxLength(vector<int>& nums)
{
unordered_map<int,int> hash;
hash[0]=-1;
int sum=0,ret=0;
for(int i=0;i<nums.size();i++)
{
sum+=nums[i]==0?-1:1;// 1、将 数组中的0全部转化为-1,当前位置的前缀和
// 2、我们是 用完之后 把sum加入hash里面
if(hash.count(sum)) ret=max(ret,i-hash[sum]);// 如果在0~i-1区间找到了sum就更新ret
else hash[sum]=i; // 如果在hash里面，存在重复的<sum,i> 只保留前面的哪一个
}
return ret;
}
};
八、矩阵区域和
矩阵区域和、链接
class Solution
{
public:
vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k)
{
int m=mat.size(),n=mat[0].size();// m行，n列
// 1、预处理一个前缀和矩阵
vector<vector<int>> dp(m+1,vector<int> (n+1));// dp是我们的递推矩阵
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
dp[i][j]=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]+mat[i-1][j-1];
// 在dp里面用mat的话,i,j都要-1，因为dp开空间的时候就已经多开了一行一列！
}
}
// 2、使用
vector<vector<int>> ret(m,vector<int> (n));
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
// 最左上角，不能小于(0,0)。最右下角不能超出(m-1,n-1)
int x1=max(0,i-k)+1,y1=max(0,j-k)+1;
int x2=min(m-1,i+k)+1,y2=min(n-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;
}
};
