给你一个整数数组 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()，然后计算数组的和是否为k的倍数，复杂度为O()，总的复杂度为O()。

       接下来我们对该题进行简化，因为是连续子数组，很容易考虑到是否可以用前缀和的方式。这样只需要我们枚举左右边界即可，时间复杂度为O()。

       如果想进一步优化的话，这里用到了一个数学定理：同余定理。我们设sum[i]为前i个数（0, 1, 2, 3, ..., i - 1）的和，那么区间[i, j]的和为sum[j + 1] - sum[i]，如果其结果是k的倍数，则有sum[j + 1] - sum[i] = n * k，等式两边分别对k取余，有sum[j + 1] % k - sum[i] % k = 0，即sum[j + 1] % k = sum[i] % k。这就启发我们只需要验证左右两个边界对k取余的结果是否相同。此时引入哈希表，记录不同余数第一次出现（使数组尽可能长，满足对数组长度的要求）的下标。这种情况下时间复杂度为O(N)。

       另外，记录前缀和的时候，我们只需要一个变量sum即可。而在Leetcode官方题解上是这样写的：

int remainder = 0;
remainder = (remainder + nums[i]) % k;

/*
简单证明一下：
设remainder(i)为第i次得到的结果
remainder(0) = 0
remainder(1) = (remainder(0) + nums[0]) % k
             = nums[0] % k
remainder(2) = (remainder(1) + nums[1]) % k
             = (remainder(1) % k + nums[1] % k) % k（分配律)
             = (nums[0] % k % k + nums[1] % k) % k
             = (nums[0] % k + nums[1] % k) % k
             = (nums[0] + nums[1]) % k（分配律）
remainder(3) = (remainder(2) + nums[2]) % k
             = (remainder(2) % k + nums[2] % k) % k（分配律）
             = ((nums[0] + nums[1]) % k % k + nums[2] % k) % k
             = ((nums[0] + nums[1]) % k + nums[2] % k) % k
             = (nums[0] + nums[1] + nums[2]) % k（分配律）
以此类推
*/

题解代码如下：

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        if(n < 2) return false;
        unordered_map<int, int> mp;
        mp[0] = -1;
        int remainder = 0;
        for(int i = 0; i < n; i++){
            remainder = (remainder + nums[i]) % k;
            if(mp.count(remainder)){
                int preIndex = mp[remainder];
                if(i - preIndex >= 2)
                    return true;
            }else{
                mp[remainder] = i;
            }
        }
        return false;
    }
};