动态规划系列-连续的子数组和(leetcode523)

【问题描述】

      给定一个包含非负数的数组和一个目标整数 k，编写一个函数来判断该数组是否含有连续的子数组，其大小至少为 2，总和为 k 的倍数，即总和为 n*k，其中 n 也是一个整数。

示例：

输入: [23,2,4,6,7], k = 6
输出: True
解释: [2,4] 是一个大小为 2 的子数组，并且和为 6。

【题解】

1.暴力法

public class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        for (int start = 0; start < nums.length - 1; start++) {
            for (int end = start + 1; end < nums.length; end++) {
                //记录和，注意k可能为0
                int sum = 0;
                for (int i = start; i <= end; i++)
                    sum += nums[i];
                if (sum == k || (k != 0 && sum % k == 0))
                    return true;
            }
        }
        return false;
    }
}

性能分析: 三次数组遍历时间复杂度：,空间复杂度

2.减少重复计算，优化计算复杂度

   方法1中，每次计算start到end之间的和，都要遍历，存在大量重复计算，可以通过一个额外的 sum 数组保存数组前缀和，那么 sum[i]保存着到第 i个元素位置的前缀和，这部分可以单独计算；因此，求第 i 个数到第 j个数之间的和，我们只需要求出 :

      i~j连续之间元素和：sum[j] - sum[j]+nums[i] 

public class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        int[] sum = new int[nums.length];
        sum[0] = nums[0];
        //额外前缀和数组预计算
        for (int i = 1; i < nums.length; i++)
            sum[i] = sum[i - 1] + nums[i];
        for (int start = 0; start < nums.length - 1; start++) {
            for (int end = start + 1; end < nums.length; end++) {
                //这是数组第i项到第j项之间的元素的和
                int summ = sum[end] - sum[start] + nums[start];
                if (summ == k || (k != 0 && summ % k == 0))
                    return true;
            }
        }
        //没有得到题解,返回false
        return false;
    }
}

性能分析:时间复杂度,空间复杂度

3.发现规律，借助hashmap，空间换时间的角度

  发现概率:如果连续子数组（不妨设下标为i到j之间的数组元素）的和total为k的倍数，sum%k==0,那么即:

         (1)前缀和sum[i]可以写成sum[i]=a+k*n的形式，a是整数，如果k能整除sum[i]，则a等于0;前缀和sum[j](j>i)可以写成sum[j]=b+k*n'的形式；

         (2) 任意连续子数组合记作temp，数组下标i+1~j之间元素和sum[j]-sum[i]可写成

temp=sum[j]-sum[i]=(b-a)+(n'-n)*k的形式(i+1到j之间的元素) 

       （3）由题意连续子数组和temp%k==0则一定有b-a也是k的倍数,即b%k==a%k，即前缀和的余数出现相等情况满足题意为true，想到用map来进行存前缀和余数作为key以及其对应的位置索引作为value，依次判断是否重复出现即可；有题题意，子数组大小至少为2；最初，前两个元素和若满足条件即模k为0，则和0相比即可。所以也初始初始map.put(0,-1)即可，子数组长即当前索引i-map.get(temp%n); 

性能分析:时间复杂度,空间复杂度:由于map存的是数组前缀元素和模k的余数，仅与数组元素个数n和模k的取值范围(最多为0,1,2,...,k-1共k个值)，所以空间复杂度为

public class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        int sum = 0;
        HashMap < Integer, Integer > map = new HashMap < > ();
        map.put(0, -1);
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            if (k != 0)
                sum = sum % k;
            if (map.containsKey(sum)) {
                if (i - map.get(sum) > 1)
                    return true;
            } else
                map.put(sum, i);
        }
        return false;
    }
}

【总结】

   (1)重复计算预先用额外数组计算，进行保存，减少遍历

   (2)空间换时间，借助连续子数组和，用map存余数操作，显著的优化了时间复杂度