leetcode_刷题总结(c++)_前缀和

主要参考：
一套模板解决四个《前缀和+哈希表》问题
动画模拟】秒杀七道题

首先明确：
子序列：可以连续，也可以不连续
子数组（子字符串）：必须是连续的

前缀和

前缀和思想和滑动窗口会经常用在求子数组和子串问题上，前缀和其实和求解数列的和十分相似。

Sn = a1+a2+a3+…an; 此时Sn就是数列的前 n 项和。
例 S5 = a1 + a2 + a3 + a4 + a5; S2 = a1 + a2。
故可以通过 S5-S2 得到 a3+a4+a5 的值。

这个过程就和我们做题用到的前缀和思想类似。

前缀和数组里保存的就是前 n 项的和。

sum[r] =a[1]+a[2]+a[3]+a[l-1]+a[l]+a[l+1]…a[r];
sum[l-1]=a[1]+a[2]+a[3]+a[l-1];
sum[r]-sum[l-1]=a[l]+a[l+1]+…+a[r];
求【l，r】区间的和 =》sum[r] -presum[l-1]

模板

//nums从0开始
//presum[0]=0方便处理边界可以少一些判断条件，统一形式
presum[0]=0;
for (int i = 1; i <= n; i ++) {
	presum[i] += presum[i - 1] + nums[i-1];//nums[i-1]代表第i个数
}
 //或
for (int i = 0; i < n; i ++){
	presum[i+1]=nums[i]+presum[i];
}
 
 
//nums从1开始
for (int i = 1; i <= n; i ++) {
	presum[i] += presum[i - 1] + nums[i];//nums[i-1]代表第i个数
}

leetcode部分题目

560. 和为 K 的子数组

560. 和为 K 的子数组
前缀和：（超时）

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n=nums.size();
        vector<int> presum(n+1);
        int ans=0;
        for(int i=0;i<n;i++){
            //前缀和是presum[1]开始填充的
            presum[i+1]=nums[i]+presum[i];
        }
        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                //注意偏移，因为我们的nums[2]到nums[4]等于presum[5]-presum[2]
                //所以这样就可以得到nums[i,j]区间内的和
                if(presum[j+1]-presum[i]==k){
                    ans++;
                }
            }
        }
        return ans;
    }
};

前缀和+哈希表：

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        unordered_map<int,int> map={{0,1}};  //初始值根据题意进行改变
        int ans=0,presum=0;
        for(auto& num:nums){
            presum+=num;
            int cur=presum-k;    //cur值根据题意进行改变
            if(map.count(cur)){
                ans+=map[cur];
            }
            map[presum]++;  //map[cur或者presum]根据题意改变
        }
   	 	return ans;
    }
};

from collections import defaultdict
class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        pre=0
        count=0
        dic=defaultdict(int)
        dic[0]=1
        n=len(nums)
        for i in range(n):
            pre+=nums[i]
            if pre-k in dic.keys():
                count+=dic[pre-k]
            dic[pre]+=1
        return count

作者：Goofy Zhukovskyv0m
链接：https://leetcode.cn/problems/subarray-sum-equals-k/solutions/2661660/560-he-wei-k-de-zi-shu-zu-python-ti-jie-bb6w2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1.两数之和

1.两数之和
思路：
最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x
使用暴力发枚举寻找 target - x 的时间复杂度过高

使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N)降低到 O(1)。
创建一个哈希表，对于每一个 x，
首先查询哈希表中是否存在 target - x，
然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n=nums.size();
        unordered_map<int,int> mp;
        for(int i=0;i<n;i++){
            if(mp.count(target-nums[i])){
                return {{i,mp[target-nums[i]]}};
            }
            mp[nums[i]]=i;
        }
        return {};
    }
};

724. 寻找数组的中心下标

724. 寻找数组的中心下标
思路：
求出前缀和数组，
计算每个下标前面及后面的值 ，比较是否相等，若相等，则是中心坐标。

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

1248. 统计「优美子数组」

1248. 统计「优美子数组」

思路：
与 求和为 K 的子数组 相似，这个题目是让求 恰好有 k 个奇数数字的连续子数组，这两个题几乎是一样的，
上个题中将前缀区间的和保存到哈希表中，
这个题目只需将前缀区间的奇数个数保存到区间内即可，
只不过将 sum += x 改成了判断奇偶的语句。

前缀和：超时

class Solution {
public:
    int numberOfSubarrays(vector<int>& nums, int k) {
        int n=nums.size();
        vector<int> sum(n+1);
        int ans=0;
        sum[0]=1;
        for(int i=0;i<n;i++){
            //前缀和是sum[1]开始填充的
            sum[i+1]=sum[i]+(nums[i]&1);
            
        }
        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                //注意偏移，因为我们的nums[2]到nums[4]等于sum[5]-sum[2]
                //所以这样就可以得到nums[i,j]区间内的和
                if(sum[j+1]-sum[i]==k){
                    ans++;
                }
            }
        }
        return ans;
    }
};

前缀和+哈希表：

class Solution {
public:
    int numberOfSubarrays(vector<int>& nums, int k) {
        unordered_map<int,int> map={{0,1}};
        int sum=0;//统计奇数的个数
        int ans=0;
        for(auto& a:nums){
            sum+=(a&1);//如果是奇数则加一，偶数加0，相当于没加
            int cur=sum-k;
            if( map.count(cur)){
                ans+=map[cur];
            }
            map[sum]++;
        }
    	return ans;
    }
};

974 和可被 K 整除的子数组

974 和可被 K 整除的子数组
思路：
与 560. 和为 K 的子数组 一模一样 ，最后判断条件换一下即可。

前缀和：超时

class Solution {
public:
    int subarraysDivByK(vector<int>& nums, int k) {
        int n=nums.size();
        vector<int> presum(n+1);
        int ans=0;
        for(int i=0;i<n;i++){
            //前缀和是presum[1]开始填充的
            presum[i+1]=nums[i]+presum[i];
            // cout<<presum[i+1]<<" ";
        }
        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                //注意偏移，因为我们的nums[2]到nums[4]等于presum[5]-presum[2]
                //所以这样就可以得到nums[i,j]区间内的和
                if((presum[j+1]-presum[i])%k==0){
                    ans++;
                }
            }
        }
        return ans;
    }
};

前缀和+哈希表：

class Solution {
public:
    int subarraysDivByK(vector<int>& nums, int k) {
        unordered_map<int,int> map={{0,1}};  //初始值根据题意进行改变
        int ans=0,sum=0;
        for(auto& a:nums){
            sum+=a;
            int cur=(sum%k+k)%k;
            if(map.count(cur)){
                ans+=map[cur];
            }
            map[cur]++;

        }
        return ans;
    }
};

523 连续的子数组和
930.和相同的二元子数组（中等)