【C++】前缀和算法专题

介绍

【模版】一维前缀和

算法思路：

代码实现

【模版】二维前缀和

算法思路

代码实现

寻找数组中心的下标

算法思路

代码实现

总结

除自身以外数组的乘积

算法思路

代码实现

和为K的子数组

算法思路

代码实现

和可被整除的K的子数组

算法思想

代码实现

连续数组

算法思想

代码实现

总结

矩阵区域和

算法思想

代码实现

总结

介绍

前缀和是指某序列的前n项和，可以把它理解为数学上的数列的前n项和，而差分可以看成前缀和的逆运算。合理的使用前缀和与差分，可以将某些复杂的问题简单化。

【模版】一维前缀和

模版前缀和【模板】前缀和_牛客题霸_牛客网

算法思路：

a. 先预处理出来⼀个「前缀和」数组：

⽤ dp[i] 表⽰： [1, i] 区间内所有元素的和，那么 dp[i - 1] ⾥⾯存的就是 [1,i - 1] 区间内所有元素的和，那么：可得递推公式： dp[i] = dp[i - 1] +arr[i] ；

b. 使⽤前缀和数组，「快速」求出「某⼀个区间内」所有元素的和：当询问的区间是 [l, r] 时：区间内所有元素的和为： dp[r] - dp[l - 1] 。

代码实现

#include<iostream>
#include<vector>
using namespace std;


int main()
{
    int n;cin>>n;
    vector<int>s(n+1);
    int q=0;cin>>q;
    for(int i=1;i<=n;i++)cin>>s[i];
    vector<long long>dp(n+1);//防止数据溢出
    for(int i=0;i<=n;i++)
    dp[i]=dp[i-1]+s[i];
    while(q--)
    {
        int r=0,l=0;
        cin>>r>>l;
        cout<<dp[l]-dp[r-1]<<endl;
    }
    return 0;
}

【模版】二维前缀和

【模版二维前缀和】【模板】二维前缀和_牛客题霸_牛客网

算法思路

类⽐于⼀维数组的形式，如果我们能处理出来从 [0, 0] 位置到 [i, j] 位置这⽚区域内所有

元素的累加和，就可以在 O(1) 的时间内，搞定矩阵内任意区域内所有元素的累加和。因此我们接下来仅需完成两步即可：

◦ 第⼀步：搞出来前缀和矩阵

这⾥就要⽤到⼀维数组⾥⾯的拓展知识，我们要在矩阵的最上⾯和最左边添加上⼀⾏和⼀列0，这样我们就可以省去⾮常多的边界条件的处理（同学们可以⾃⾏尝试直接搞出来前缀和矩阵，边界条件的处理会让你崩溃的）。处理后的矩阵就像这样：

这样，我们填写前缀和矩阵数组的时候，下标直接从 1 开始，能⼤胆使⽤ i - 1 , j - 1 位置的值。

注意 dp 表与原数组 matrix 内的元素的映射关系：

i. 从 dp 表到 matrix 矩阵，横纵坐标减⼀；

ii. 从 matrix 矩阵到 dp 表，横纵坐标加⼀。

前缀和矩阵中 sum[i][j] 的含义，以及如何递推⼆维前缀和⽅程

a. sum[i][j] 的含义：

sum[i][j] 表⽰，从 [0, 0] 位置到 [i, j] 位置这段区域内，所有元素的累加和。对应下图的红⾊区域。

代码实现

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,q;
    cin>>n>>m>>q;
    vector<vector<int>>arr(n+1,vector<int>(m+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));
    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];

    while(q--)
    {
        int x1,y1,x2,y2;
        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;
}

寻找数组中心的下标

寻找数组中心的下标. - 力扣（LeetCode）

算法思路

从中⼼下标的定义可知，除中⼼下标的元素外，该元素左边的「前缀和」等于该元素右边的「后缀

和」。

▪ 因此，我们可以先预处理出来两个数组，⼀个表⽰前缀和，另⼀个表⽰后缀和。

▪ 然后，我们可以⽤⼀个 for 循环枚举可能的中⼼下标，判断每⼀个位置的「前缀和」以及「后缀和」，如果⼆者相等，就返回当前下标。

代码实现

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        //统计前缀和和后缀和
        int n=nums.size();
        vector<int>f(n),g(n);
        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];
        for(int i=0;i<n;i++)
        if(f[i]==g[i])return i;
        return -1;
    }
};

总结

此类方法命名为前缀和，并非仅仅是“前”缀和，也有可能是后缀和，与其将其看作是模版，不如将其理解为一种思想，灵活运用。

除自身以外数组的乘积

除自身以外数组的乘积. - 力扣（LeetCode）

算法思路

注意题⽬的要求，不能使⽤除法，并且要在 O(N) 的时间复杂度内完成该题。那么我们就不能使

⽤暴⼒的解法，以及求出整个数组的乘积，然后除以单个元素的⽅法。

继续分析，根据题意，对于每⼀个位置的最终结果 ret[i] ，它是由两部分组成的：

i. nums[0] * nums[1] * nums[2] * ... * nums[i - 1]

ii. nums[i + 1] * nums[i + 2] * ... * nums[n - 1]

于是，我们可以利⽤前缀和的思想，使⽤两个数组 post 和 suf，分别处理出来两个信息：

i. post 表⽰：i 位置之前的所有元素，即 [0, i - 1] 区间内所有元素的前缀乘积，

ii. suf 表⽰： i 位置之后的所有元素，即 [i + 1, n - 1] 区间内所有元素的后缀乘积，然后再处理最终结果。

代码实现

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n=nums.size();
        vector<int>f(n,1),g(n,1);
        f[0]=1;g[n-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;
        for(int i=0;i<n;i++)
        {
            ans.push_back(f[i]*g[i]);
        }
        return ans;
    }
};

和为K的子数组

和为K的子数组. - 力扣（LeetCode）

算法思路

设 i 为数组中的任意位置，⽤ sum[i] 表⽰ [0, i] 区间内所有元素的和。

想知道有多少个「以 i 为结尾的和为 k 的⼦数组」，就要找到有多少个起始位置为 x1, x2,x3... 使得 [x, i] 区间内的所有元素的和为 k 。那么 [0, x] 区间内的和是不是就是sum[i] - k 了。于是问题就变成：

◦ 找到在 [0, i - 1] 区间内，有多少前缀和等于 sum[i] - k 的即可。

我们不⽤真的初始化⼀个前缀和数组，因为我们只关⼼在 i 位置之前，有多少个前缀和等于sum[i] - k 。因此，我们仅需⽤⼀个哈希表，⼀边求当前位置的前缀和，⼀边存下之前每⼀种前缀和出现的次数。

代码实现

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        map<int,int>hash;
        int sum=0;
        int ret=0;hash[0]=1;
        for(auto x:nums)
        {
            sum+=x;//求出前缀和
            if(hash[sum-k])ret+=hash[sum-k];//每次sum都是已知量，又推出的关系我们可以确定每次前一部分的序列也是已知量；
            hash[sum]++;
        }
        return ret;
    }
};

和可被整除的K的子数组

和可被整除的K的子数组. - 力扣（LeetCode）

算法思想

本题需要的前置知识：

• 同余定理

如果 (a - b) % n == 0 ，那么我们可以得到⼀个结论： a % n == b % n 。⽤⽂字叙述就是，如果两个数相减的差能被 n 整除，那么这两个数对 n 取模的结果相同。

例如： (26 - 2) % 12 == 0 ，那么 26 % 12 == 2 % 12 == 2 。

• c++ 中负数取模的结果，以及如何修正「负数取模」的结果

a. c++ 中关于负数的取模运算，结果是「把负数当成正数，取模之后的结果加上⼀个负号」。例如： -1 % 3 = -(1 % 3) = -1

b. 因为有负数，为了防⽌发⽣「出现负数」的结果，以 (a % n + n) % n 的形式输出保证为正。

例如： -1 % 3 = (-1 % 3 + 3) % 3 = 2。

思路与 560. 和为 K 的⼦数组这道题的思路相似。

设 i 为数组中的任意位置，⽤ sum[i] 表⽰ [0, i] 区间内所有元素的和。

• 想知道有多少个「以 i 为结尾的可被 k 整除的⼦数组」，就要找到有多少个起始位置为 x1,x2, x3... 使得 [x, i] 区间内的所有元素的和可被 k 整除。

• 设 [0, x - 1] 区间内所有元素之和等于 a ， [0, i] 区间内所有元素的和等于 b ，可得(b - a) % k == 0 。

• 由同余定理可得， [0, x - 1] 区间与 [0, i] 区间内的前缀和同余。于是问题就变成：

◦ 找到在 [0, i - 1] 区间内，有多少前缀和的余数等于 sum[i] % k 的即可。

代码实现

class Solution {
public:
    int subarraysDivByK(vector<int>& nums, int k) {
        int ret=0;
        map<int,int>hash;
        hash[0]=1;
        int sum=0;
        for(auto n:nums)
        {
            sum+=n;
            int r=(sum%k+k)%k;
            if(hash.count(r))ret+=hash[r];
            hash[r]++;
        }
        return ret;
    }
};

连续数组

连续数组. - 力扣（LeetCode）

算法思想

稍微转化⼀下题⽬，就会变成我们熟悉的题：

• 本题让我们找出⼀段连续的区间， 0 和 1 出现的次数相同。

• 如果将 0 记为 -1 ， 1 记为 1 ，问题就变成了找出⼀段区间，这段区间的和等于 0 。

• 于是，就和 560. 和为 K 的⼦数组这道题的思路⼀样

设 i 为数组中的任意位置，⽤ sum[i] 表⽰ [0, i] 区间内所有元素的和。

想知道最⼤的「以 i 为结尾的和为 0 的⼦数组」，就要找到从左往右第⼀个 x1 使得 [x1, i]区间内的所有元素的和为 0 。那么 [0, x1 - 1] 区间内的和是不是就是 sum[i] 了。于是问题就变成：

• 找到在 [0, i - 1] 区间内，第⼀次出现 sum[i] 的位置即可。

我们不⽤真的初始化⼀个前缀和数组，因为我们只关⼼在 i 位置之前，第⼀个前缀和等于 sum[i]的位置。因此，我们仅需⽤⼀个哈希表，⼀边求当前位置的前缀和，⼀边记录第⼀次出现该前缀和的

位置。

代码实现

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        int n=nums.size();
        int sum=0;
        map<int,int>hash;
        hash[0]=-1;
        int ret=0;
        for(int i=0;i<nums.size();i++)
        {
            sum+=nums[i]==0?-1:1;
            if(hash.count(sum))ret=max(ret,i-hash[sum]);//如果满足条件就不需要更新左端点
            else
            hash[sum]=i;//如果不符合时就需要不断地更新左端点
        }
        return ret;
    }
};

总结

上面的这4道题，又很高的相似性，都是在一段序列中，后一部分是连续的，而前面的一部分与整个序列的和具有一定的关系，每次我们求出的整个序列的sum都是已知的，通过退出的前一段序列的前缀和与整个数组的前缀和关系,可以得到前一段序列的前缀和，比如sum-k,sum%k...我们只需要每次查找有多少个满足条件的子序列即可；

矩阵区域和

矩阵区域和. - 力扣（LeetCode）

算法思想

⼆维前缀和的简单应⽤题，关键就是我们在填写结果矩阵的时候，要找到原矩阵对应区域的「左上

⻆」以及「右下⻆」的坐标（推荐⼤家画图）左上⻆坐标： x1 = i - k ， y1 = j - k ，但是由于会「超过矩阵」的范围，因此需要对 0取⼀个 max 。因此修正后的坐标为： x1 = max(0, i - k), y1 = max(0, j - k) ;

右下⻆坐标： x1 = i + k ， y1 = j + k ，但是由于会「超过矩阵」的范围，因此需要对 m- 1 ，以及 n - 1 取⼀个 min 。因此修正后的坐标为： x2 = min(m - 1, i + k), y2 = min(n - 1, j + k) 。

然后将求出来的坐标代⼊到「⼆维前缀和矩阵」的计算公式上即可~（但是要注意下标的映射系）。

代码实现

class Solution {
public:
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
        int m=mat.size();//行
        int n=mat[0].size();//列
       vector<vector<int>>dp(m+1,vector<int>(n+1));//数组映射
        //预处理二维矩阵
        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];
        vector<vector<int>>ret(m,vector<int>(n));
        //往原来数组中填充
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                //下标映射到dp数组
                int x1=max(0,i-k)+1;
                int y1=max(0,j-k)+1;
                int x2=min(m-1,i+k)+1;
                int 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];//在dp矩阵中计算
            }
        }
        return ret;

    }
};