[Leetcode]Subarray Sum Equals K 子数组和为K

版权声明：作者：Britesun 欢迎转载，与人分享是进步的源泉！ https://blog.csdn.net/qq_34807908/article/details/81903170

题目

Given an array of integers and an integer k, you need to find the total number of continuous subarrays whose sum equals to k.

• Example 1:

Input:nums = [1,1,1], k = 2
Output: 2

• Note:

The length of the array is in range [1, 20,000].
The range of numbers in the array is [-1000, 1000] and the range of the integer k is [-1e7, 1e7].

分析题目

• 本题给了我们一个数组，让我们求和为k的连续子数组的个数
• 第一种解法：暴力求解，考虑给定nums数组的每个可能的子数组，找到每个子数组的元素之和，并检查是否等于k。当总和等于k时，count 自增1。
• 第二种解法：使用累加和，对于每个考虑的新子数组，我们不是每次都确定元素的总和，而是使用累积和数组sum。然后，为了计算位于两个索引之间的元素之和，我们可以减去对应于两个索引的累加和以直接获得总和，而不是迭代子数组以获得总和。
• 第三种解法：是大家推崇的一种解法，用一个哈希表来建立连续子数组之和跟其出现次数之间的映射。建立哈希表的目的是为了让我们可以快速的查找sum-k是否存在，即是否有连续子数组的和为sum-k，如果存在的话，那么和为k的子数组一定也存在。
  值得注意的是初始化要加入{0,1}这对映射。
  因为我们的解题思路是遍历数组中的数字，用sum来记录到当前位置的累加和，我们这样当sum刚好为k的时候，那么数组从起始到当前位置的这段子数组的和就是k，满足题意，如果哈希表中事先没有map[0]项的话，这个符合题意的结果就无法累加到结果res中。所以初始化要加入{0，1} 这对映射。

解法一：Brute Force（TLE）

Complexity - Time: O(n³), Space: O(1)

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

解法二 Using Cummulative sum（使用累加数组）

Complexity - Time: O(n²), Space: O(n)

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

解法三 Using Hashmap（使用hash表）

Complexity - Time: O(n), Space: O(n)

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