[C++&Rust]LeetCode No.523 连续的子数组和(每日一题)

原贴地址：http://blog.leanote.com/post/dawnmagnet/lc523

题目

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

• 子数组大小 至少为 2 ，且
• 子数组元素总和为 k 的倍数。

如果存在，返回 true ；否则返回 false 。

如果存在一个整数 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

思路分析

这道题是一个道子数组的题目。
子数组通常会有一个暴力解法。复杂度是$O(n^2)$，且通常都会超时
一般来说都需要我们优化成$O(nlgn)$或者$O(n)$的复杂度。

在这道题中，子数组最关键的性质是可以被k整除。
如果无从下手，可以从暴力的思路里找找线索。
我们可以枚举左边界也可以枚举右边界，对于每一次枚举右边界来说，我们都需要让左边界在0至右边界的范围内移动，获得该区间的值。之前我们说过，快速获取一段区间内的和这种问题可以用前缀和来表示，可以极大地降低复杂度，所以我们就采用前缀和处理一遍数组。

当然在前缀和处理数组的过程中，我们可以进行一个模k的动作，因为对于大于k的和来说，是没有意义的。
我们举个例子来看。
原数组|23|2|6|4|7
–|
原数组模6|5|2|0|4|1
前缀和|23|25|31|35|42
前缀和模6|5|1|1|5|0
对于该输入而言，我们发现将前缀和模k对于整体计算是一个非常好的习惯。假如我们的右边界进行到了前缀和35的位置如果按照传统的暴力算法，我们会遍历35之前的所有（当然除了35的左边最靠近的那个，因为数组长度需要大于2）前缀和，23，25，31，并且求35减去哪个可以整除6。然后对于可以整除这件事而言，大于k的数字可以直接被模k，可以整除的在模k之后就变成了0。对于35而言，35模k是5，那么我们要在前面的数组中找到一个数字，用5减去它是0，那不就是在前面的数组中找5吗！
既然我们遍历过前面的数组，直接套个哈希集合上去，可以在$O(1)$的时间内查找之前是否出现过5，这个题目就可以一遍遍历就获得答案了。

当然还要提醒一句，前缀和千万别忘了还有边界情况，也就是左边界是0的情况，在这种情况下，只要遍历到一个前缀和等于0的，就说明有从左边界开始的子数组满足和可以模k，就直接返回true即可。

C++代码

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        if (nums.size() < 2) return false;
        nums[0] %= k;
        for (int i = 1; i < nums.size(); ++i) nums[i] = (nums[i - 1] + nums[i]) % k;
        if (nums[1] == 0) return true;
        unordered_set<int> s;
        for (int i = 2; i < nums.size(); ++i) {
            s.insert(nums[i - 2]);
            if (s.find(nums[i]) != s.end() || nums[i] == 0) {
                return true;
            }
        }
        return false;
    }
};

Rust代码

use std::collections::HashSet;
impl Solution {
    pub fn check_subarray_sum(mut nums: Vec<i32>, k: i32) -> bool {
        let n = nums.len();
        if n < 2 {
            return false;
        }
        nums[0] %= k;
        for i in 1..n {
            nums[i] = (nums[i - 1] + nums[i]) % k;
        }
        if nums[1] == 0 {
            return true;
        }
        let mut s = HashSet::new();
        for i in 2..n {
            s.insert(nums[i - 2]);
            if s.contains(&nums[i]) || nums[i] == 0 {
                return true;
            }
        }
        return false;
    }
}