【优选算法】---前缀和

一、【模板】一维前缀和

一维前缀和，链接

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;
    }
};