前缀和-leetcode

前缀和就是数组第0项到当前项的和。如果用一个数组preSum表示数组A的前缀和：
preSum[i]=A[0]+A[1]+…+A[i];

数组A中的某项，可以表示为相邻前缀和之差：
A[i]=preSum[i]-preSum[i-1]

多项叠加，等号右边加减相消，得到通式：
A[i]+…+A[j]=preSum[j]−preSum[i−1]

i 当然可以为 0，此时 i - 1 为 - 1，我们故意让 preSum[-1] 为 0，此时：
A[0]+A[1]+…+A[j]=preSum[j]
预置这种不存在的情况，只是为了让 preSum[0]能套用通式。
560
238
528
1480
523
724
974
1314
1423
862
1712
304
209
525
1588
1177
370
//560.和为K的子数组
/*

• 给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。
  示例 1 :
  输入:nums = [1,1,1], k = 2
  输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
  说明 :
  数组的长度为 [1, 20,000]。
  数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。*/
  //[j…i]这个子数组和为k —> pre[i]-pre[j-1]==k ----> pre[j-1] = pre[i]-k

超时：

class Solution {
public:
    int subarraySum(vector<int>& A, int k) {
        int n = A.size();
        vector<int> presum(n+1);
        presum[0] = 0;
        for (int i = 0; i < n; i++) {
            presum[i+1] = presum[i] + A[i];
        }
        int res = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                if (presum[i] - presum[j] == k) {
                    res++;
                }
            }
        }
        return res;
    }
};

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        unordered_map<int, int> presum;
        presum[0] = 1;
        int res = 0, pre = 0;
        for (int i = 0; i < n; i++) {
            pre += nums[i];
            if (presum.find(pre - k) != presum.end()) {
                res += presum[pre - k];
            }
            presum[pre]++;
        }
        return res;
    }
};

//523.连续子数组和
/*

• 给定一个包含 非负数 的数组和一个目标 整数 k，编写一个函数来判断该数组是否含有连续的子数组，其大小至少为 2，且总和为 k 的倍数，即总和为 n*k，其中 n 也是一个整数。
  示例 1：
  输入：[23,2,4,6,7], k = 6
  输出：True
  解释：[2,4] 是一个大小为 2 的子数组，并且和为 6。

示例 2：
输入：[23,2,6,4,7], k = 6
输出：True
解释：[23,2,6,4,7]是大小为 5 的子数组，并且和为 42。/
复杂度：O(nn)

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        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 l = 0; l < n-1; l++) {
            for (int r = l + 1; r < n; r++) {
                int sum = presum[r+1] - presum[l];
                if (sum == k || (k != 0 && sum % k == 0)) {
                    return true;
                }
            }
        }
        return false;
    }
};

两个不同的前缀和的余数相等，意味着这两个前缀和之差就是k的倍数
(presum[i]-presum[j]) mod k == 0 ----> presum[i] mod k == presum[j] mod k

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        int sum = 0;
        unordered_map<int, int> mp;
        mp.insert({0, -1});
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
            if (k != 0) {
                sum = sum % k;
            }
            if (mp.count(sum)) {
                if (i - mp[sum] > 1) {
                    return true;
                }
            } else {
                mp.insert({sum, i});
            }
        }
        return false;
    }
};

//974.和可被K整除的子数组
给定一个整数数组 A，返回其中元素之和可被 K 整除的（连续、非空）子数组的数目。
示例：
输入：A = [4,5,0,-2,-3,1], K = 5
输出：7
解释：
有 7 个子数组满足其元素之和可被 K = 5 整除：
[4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]
超时：

class Solution {
public:
    int subarraysDivByK(vector<int>& A, int K) {
        int n = A.size();
        vector<int> presum(n+1);
        presum[0] = 0;
        for (int i = 0; i < n; i++) {
            presum[i+1] = presum[i] + A[i];
        }
        int res = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                if ((presum[i] - presum[j]) % K == 0) {
                    res++;
                }
            }
        }
        return res;
    }
};

class Solution {
public:
    int subarraysDivByK(vector<int>& A, int K) {
        int n = A.size();
        unordered_map<int, int> presum;
        presum[0] = 1;
        int res = 0, pre = 0;
        for (int i = 0; i < n; i++) {
	        //同余定理
            if (A[i] < 0) {
                A[i] = K - abs(A[i]) % K;
            }
            pre += A[i];
            int cur = pre % K;
            if (presum.find(cur) != presum.end()) {
                res += presum[cur];
            }
            presum[cur]++;
        }
        return res;
    }
};