LeetCode560之和为K的子数组（相关话题：前缀和）

最新推荐文章于 2024-03-11 13:59:42 发布

数据与后端架构提升之路

最新推荐文章于 2024-03-11 13:59:42 发布

阅读量441

点赞数

分类专栏： # 算法文章标签：算法 leetcode c语言

本文链接：https://blog.csdn.net/lzhcoder/article/details/117531940

版权

算法专栏收录该内容

125 篇文章 3 订阅

订阅专栏

题目描述

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

示例 1 :

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

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

思路分析

这个前缀和数组preSum的含义也很好理解，preSum[i]就是nums[0..i-1]的和。那么如果我们想求nums[i..j]的和，只需要一步操作preSum[j+1]-preSum[i]即可，而不需要重新去遍历数组了。

int subarraySum(int[] nums, int k) {
    int n = nums.length;
    // 构造前缀和
    int[] sum = new int[n + 1];
    sum[0] = 0; 
    for (int i = 0; i < n; i++)
        sum[i + 1] = sum[i] + nums[i];

    int ans = 0;
    // 穷举所有子数组
    for (int i = 1; i <= n; i++)
        for (int j = 0; j < i; j++)
            // sum of nums[j..i-1]
            if (sum[i] - sum[j] == k)
                ans++;

    return ans;
}

这个解法的时间复杂度空间复杂度，并不是最优的解法。不过通过这个解法理解了前缀和数组的工作原理之后，可以使用一些巧妙的办法把时间复杂度进一步降低。

优化的思路是：我直接记录下有几个sum[j]和sum[i]-k相等，直接更新结果，就避免了内层的 for 循环。我们可以用哈希表，在记录前缀和的同时记录该前缀和出现的次数。

代码实现

    public int subarraySum(int[] nums, int k) {
        
        //key是前缀和,前缀和出现的次数
        Map<Integer,Integer> map = new HashMap(); 
        int sum_i = 0;
        int sum_j = 0;
        int result = 0;
        map.put(0,1);
        for(int i=0;i<nums.length;i++){

            sum_i = sum_i + nums[i];
            //和当前前缀和sum_i差k的前缀和为sum_j
            sum_j = sum_i- k;
            if(map.get(sum_j)!=null){
                //之前存在这个前缀和就把结果加map.get(sum_j)
                result = result + map.get(sum_j);
            }
             map.put(sum_i,map.getOrDefault(sum_i,0)+1);

        }

      return result;

  }

相关题目

LeetCode525连续数组:给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。

示例 1:

输入: nums = [0,1]
输出: 2
说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。
示例 2:

输入: nums = [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。

提示：

1 <= nums.length <= 105
nums[i] 不是 0 就是 1

思路：由于「0 和 1 的数量相同」等价于「1 的数量减去 0 的数量等于 0」，我们可以将数组中的 0 视作 -1，则原问题转换成「求最长的连续子数组，其元素和为 0」。

    public int findMaxLength(int[] nums) {

        int n = nums.length;
        for (int i = 0; i < n; i++){
            if(nums[i]==0){
                nums[i]=-1;
            }
        }
        
        
            int max = 0;
            //key是前缀和,value是对应的下标
            Map<Integer,Integer> map = new HashMap(); 
            int sum_i = 0;
            int sum_j = 0;
            int result = 0;
            //"下标-1"处的前缀和为0(这个初始值很重要否则无法通[0,1]这个测试用例)
            map.put(0,-1);
            for(int i=0;i<nums.length;i++){
    
                sum_i = sum_i + nums[i];
                //和当前前缀和sum_i差0的前缀和为sum_j
                sum_j =  sum_i;
                if(map.get(sum_j)!=null){
                  //之前存在这个前缀和就计算数组长度,更新max
                    max = Math.max(max,i-map.get(sum_j));
                }else{
                    map.put(sum_i,i);
                }
 
            }
        return max;
    }