[算法]连续的子数组和

题目描述

注：本题来自力扣，链接为
https://leetcode-cn.com/problems/continuous-subarray-sum/

连续的子数组和
给你一个整数数组 nums 和一个整数 k ，编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组：

1. 子数组大小 至少为 2 ，且子数组元素总和为 k 的倍数。如果存在，返回 true ；否则，返回 false 。
2. 如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。

示例 1：

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

示例 2：

输入：nums = [23,2,6,4,7], k = 6
输出：true
解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42 。 
42 是 6 的倍数，因为 42 = 7 * 6 且 7 是一个整数。

示例 3：

输入：nums = [23,2,6,4,7], k = 13
输出：false

提示：

1 <= nums.length <= 105
0 <= nums[i] <= 109
0 <= sum(nums[i]) <= 231 - 1
1 <= k <= 231 - 1

题解

暴力解法

不考虑各种因素，最容易想到的解题思路就是使用穷举法，对题目进行暴力求解，这也是笔者自己能直接想到的唯一方法。

代码简单直接，并且对每步进行了注释，这里就不再赘述了。

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        int window = 2;	// 最低子数组长度为 2
        while(nums.length >= window) {
            int add = 0;
            // 先算出 0 到 window 之和
            for(int i = 0; i < window; i++) {
                add += nums[i];
            }
            if(add % k == 0) {
                return true;
            }
            // 窗口右移
            for(int i = window; i < nums.length; i++) {
                add += nums[i] - nums[i - window];
                if(add % k == 0) {
                    return true;
                }
            }
            window++;   // 加长窗口
        }
        return false;
    }
}

前缀和+哈希表

上面的穷举法显然已经超时，所以我就从各路大神的解法中找到了此解法，利用前缀和和同余定理求解，非常巧妙。

我们首先算出前缀和数组，即图中的 sums，然后循环对该数组取余，当发现有余数相等时就直接返回 true。题解中使用了 HashSet 记录出现过的余数。相比较于穷举法，此法只用了一层循环，时间复杂度大大降低，达到了算法的时间要求。

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
       int sum = 0;   // 当求余得 0 时自然直接证明了结果
       int newSum = nums[0];    // 前缀和
       HashSet<Integer> set = new HashSet(); // 存储余数
       for(int i = 1; i < nums.length; i++) {
           set.add(sum % k);
           sum = newSum;
           newSum += nums[i];
           if(set.contains(newSum % k)) {
               return true;
           }
       }
       return false;
    }
}

实际代码中我并没有计算出完整的前缀和数组，而是在运算过程中动态计算，这样可以减少部分工作量。还有一点值得一提：子数组长度需要大于或等于 2，所以在代码中我用了两个sum来控制长度，保证判断的不是相邻数。