LeetCode 560. 和为K的子数组 （前缀和）

LeetCode 暑期打卡第七周题五

题目：
给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
说明 :

数组的长度为 [1, 20,000]。
数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subarray-sum-equals-k
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

先思考暴力怎么写，然后从暴力的逻辑上去优化。

方法一：暴力求解
每个子数组判断是否满足题意：

class Solution {
    int n;

    public int subarraySum(int[] nums, int k) {
        n = nums.length;
        int ans = 0;
        for (int start = 0; start < n; start++) {
            int sum = 0;
            for (int end = start; end < n; end++) {
                sum += nums[end];
                if (sum == k) ans++;
            }
        }
        return ans;
    }
}

时间复杂度 O(n ^ 2)

LeetCode的判题能AC，但是如果在赛场上这个题O(n ^ 2)是肯定要超时的，并不满足当前O(n ^ 2)的时间复杂度。

---

方法二：前缀和
前缀和思想：
sn代表前n项总和，则有：
s0 = 0 ,
s1 = a1,
s2 = a1 + a2,
…
si = a1 + a2 + … + ai,
…
sn = a1 + a2 + … + an.
所以如果需要数组中间连续一段的求和即 a[left] + a[left + 1] + … + a[right - 1] + a[right] , 只需计算 s[right] - s[left - 1] , 本方法采用这个思想。

代码来自LeetCode官方题解。

public class Solution {
    public int subarraySum(int[] nums, int k) {
        int count = 0;
        int[] sum = new int[nums.length + 1];
        sum[0] = 0;
        for (int i = 1; i <= nums.length; i++)
            sum[i] = sum[i - 1] + nums[i - 1];
        for (int start = 0; start < nums.length; start++) {
            for (int end = start + 1; end <= nums.length; end++) {
                if (sum[end] - sum[start] == k)
                    count++;
            }
        }
        return count;
    }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/subarray-sum-equals-k/solution/he-wei-kde-zi-shu-zu-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

时间复杂度 O(n ^ 2)
依旧达不到线性级别，必须再优化

---

方法三：前缀和+哈希表维护
哈希表真的快，这个算法来源于他人提示，利用哈希表存储。
如果s[right] - s[left - 1] = k 则有 s[left - 1] = s[right] - k, 则原题变成在数列中寻找s[right] - k 出现次数，变成了哈希表的模板题（似乎现在也写了几个哈希表的模板了，差不多能稍微理解一点利用哈希表来做题），具体看代码

class Solution {
    int n, sum = 0, ans = 0;

    public int subarraySum(int[] nums, int k) {
        n = nums.length;
        Map<Integer, Integer> map = new HashMap<>();
        map.put(0, 1);
        for (int i = 0; i < n; i++) {
            sum += nums[i];
            if (map.containsKey(sum - k)) ans += map.get(sum - k);
            map.put(sum, map.getOrDefault(sum, 0) + 1);
        }
        return ans;
    }
}

时间复杂度 O(n)

哈希表真的再要反复学习！