算法练习Day11 [LeetCode]560. 和为 K 的子数组

560. 和为 K 的子数组

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

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

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

暴力解法：

class Solution {
    public int subarraySum(int[] nums, int k) {
         int len = nums.length;
         int sum = 0;
         int count = 0;
         //双重循环
         for (int i = 0; i < len; ++i) {
             for (int j = i; j < len; ++j) {
                 sum += nums[j];
                 //发现符合条件的区间
                 if (sum == k) {
                     count++;
                 }
             }
             //记得归零，重新遍历
             sum = 0;
         }
         return count;
    }
}

用前缀和解法

class Solution {
    public int subarraySum(int[] nums, int k) {
        //前缀和数组
        int[] presum = new int[nums.length+1];
          presum[0]=0;
        for (int i = 0; i < nums.length; i++) {
            //这里需要注意，我们的前缀和是presum[1]开始填充的
            presum[i+1] = nums[i] + presum[i];
        }
        //统计个数
        int count = 0;
        for (int i = 0; i < nums.length; ++i) {
            for (int j = i; j < nums.length; ++j) {
                //注意偏移
                //这样就可以得到nums[i,j]区间内的和
                if (presum[j+1] - presum[i] == k) {
                    count++;
                }
            }
        }
        return count;
    }
}

虽然用到了前缀和数组，但是对比暴力法并没有提升性能，时间复杂度仍为O(n^2)，空间复杂度O(n)。

前缀和 + HashMap方法解

将所有的前缀和,与该前缀和出现的次数存到 map 里。
注意：在此我们设置HashMap中第一个键值对为{0,1},我们后期更新count的时候要注意以往键值对中是否出现与前缀和pre[i]−k 相同的 pre[j] ，所以第一位要设置0，后面出现的前缀和减去k=0就可计数count=1。
举例说明：[3,4,7]，k=7;
1.设置第一个键值对为{0，1}；此时count=0；前缀和为0；
2.从3开始：前缀和=3，设置第二个键值对为{3，1}；前缀和-k=3-7=-4，-4与已有的键值对中的前缀和不相等。
3.遍历4：前缀和=7，设置第三个键值对为{7，1}；前缀和-k=7-7=0，0与之前的键值对中的前缀和0相等，count=1；
4.遍历7：前缀和为14，设置第四个键值对为{14，1}；前缀和-k=14-7=7,7与之前键值对中的前缀和7相等，count=2；
5.所以输出count=2。

public class Solution {
    public int subarraySum(int[] nums, int k) {
        int count = 0, pre = 0;
        HashMap < Integer, Integer > mp = new HashMap < > ();
        mp.put(0, 1);
        for (int i = 0; i < nums.length; i++) {
            pre += nums[i];
            if (mp.containsKey(pre - k)) {
                count += mp.get(pre - k);
            }
            mp.put(pre, mp.getOrDefault(pre, 0) + 1);
            //当Map集合中有这个key时，就使用这个key值，如果没有就使用默认值defaultValue
        }
        return count;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的长度。我们遍历数组的时间复杂度为 O(n)，中间利用哈希表查询删除的复杂度均为O(1)，因此总时间复杂度为 O(n)。

• 空间复杂度：O(n)，其中 n 为数组的长度。哈希表在最坏情况下可能有 n个不同的键值，因此需要 O(n)的空间复杂度。