《LeetCode之每日一题》：48.连续的子数组和

题目链接： 连续的子数组和

有关题目

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

1.子数组大小 至少为 2 ，且
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 <= 10^5
0 <= nums[i] <= 10^9
0 <= sum(nums[i]) <= 2^31 - 1
1 <= k <= 2^31 - 1

题解

前缀和 + 哈希表
思路：取自肥宅男孩
题解：参考官方题解

思路：
【同余定理】 【哈希表】【简化前缀和】


同余定理：如果两个整数m、n满足n-m能被k整除，那么n和m对k同余

即 ( pre(j) - pre (i) ) % k == 0 则 pre(j) % k == pre(i) % k

推导 => pre (i) % k = (a0 + a1 + ... + ai) % k = (a0 % k + a1 % k + ... ai % k ) % k （该推导在简化前缀和的时候有用，说明当前前缀和 % k 不会影响后面的前缀和 % k ）

哈希表 存储 Key ：pre(i) % k
Value： i

遍历过程：

1.计算前缀和 pre( j ) % k

2.当pre(j) % k 在哈希表中已存在，则说明此时存在 i 满足 pre(j) % k == pre(i) % k ( i < j )

3.HashMap里，已知Key，可以取到Value 即i的值， 最后 判断 j - i >= 2 是否成立 即可

当 pre(j) % k 不存在于哈希表，则将 (pre(j) % k, j ) 存入哈希表
因在计算 pre(i) = (pre(i-1) + nums[i]) % k 时，pre(i) 只与上一个状态有关

故可以直接用变量pre 替代数组。 那么 求前缀和 % k 的公式就简化为 题解代码中的 remainder = (remainder + nums[i]) % k;

解释同余定理

取自宫水三叶

代码一：

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        if(nums.size() < 2)
            return false;
        unordered_map<int,int> mp;//定义哈希表存放键值对
        //<key, value>,这里对应<remainder,preRemainder>
        mp[0] = -1;//我们人为规定初始化为-1
        int remainder = 0;//remainder中文意思为余数的意思
        for (int i = 0; i < nums.size(); i++)
        {
            remainder = (remainder + nums[i]) % k;//这里用到同余定理，上面的思路里面有解释
            //上面的思路中使用了动态规划转至滚动数组进行优化
            if (mp.count(remainder))//hash的特性找出remainder第一次出现的位置
                {
                    int preRemainder = mp[remainder];//找出下标
                    if (i - preRemainder >= 2)  
                    //只要最大长度至少为 2,即存在符合要求的子数组。
                        return true;
                }
            else
                mp[remainder] = i;//没找到的话就录入hash表
       }
       return false;
    }
};

代码二：
参考宫水三叶

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        int m = nums.size();
        vector<int> sum(m + 1,0);//初始化别忘记了
        for (int i = 1; i <= m; i++)
            sum[i] = sum[i - 1] + nums[i - 1];//拿到前i项和
        unordered_set<int> set;
        for(int i = 2; i <= m; i++)
        {
            set.insert(sum[i - 2] % k);//据题意录入满足最大长度的前i - 2项和的余数
            if (set.count(sum[i] % k)) //检查hash表中是否有含有满足条件的第i项和余数
            //insert插入余数，count查出余数，满足子数组的长度最小为2
                return true;
        }
        return false;
    }
};

//当然我们可以把两个for循环给合并成一个
//sun[1] = sum[0] + nums[0];

//把接下来的部分合并为一个for循环中

代码三：

滚动数组优化代码二

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        int m = nums.size();
        int ppre = 0, pre = nums[0];
        unordered_set<int> set;
        for (int i = 2; i <= m; i++)
        {
            set.insert(ppre % k);
            
            //pre = num[0] + [1]
            pre += nums[i - 1];
            if (set.count(pre % k))//对应二中的pre[i]
                return true;
            ppre += nums[i - 2];
        }
        return false;
    }
};