记一次失败的探索过程：算法题-连续的子数组和

题目

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

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

示例 1：

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

示例 2：

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

说明：
数组的长度不会超过 10,000 。
你可以认为所有数字总和在 32 位有符号整数范围内。

探索

探索1.二维dp

刚开始上手做，第一反应是回溯加剪枝（原谅我的懒惰），用二维数组去保存中间变量，每次都判断一下是否能整除k，于是产出了下面的代码：

    public boolean checkSubarraySum(int[] nums, int k) {
        if (nums == null || nums.length < 2 || k <= 0) {
            return false;
        }
        int n = nums.length;
        for (int i = 0; i < n; i ++) {
            nums[i] %= k;
            if (i > 0 && nums[i] == 0 && nums[i-1] == 0) {
                return true;
            }
        }
        int[][] dp = new int[n][n];
        dp[n-1][n-1] = nums[n-1];
        for (int i = n-2; i >=0; i --) {
            for (int j = i; j < n; j ++) {
                if (i == j) {
                    dp[i][j] = nums[i];
                } else {
                    dp[i][j] = nums[i] + dp[i+1][j];
                }
                dp[i][j] = dp[i][j] % k;
                if (i != j && dp[i][j] == 0) return true;
            }
        }
        return false;
    }

跑了一下，超出内存了，二维数组占的太多了，进行修改。

探索2.一维数组

上面代码里的递推公示可以看出：
dp[i][j] = nums[i] + dp[i+1][j];
其实每次只是使用了上一层的结果（如果从矩阵的角度来看，是下面一层，因为是倒着算的）。那么二维矩阵就没必要了，一维的就可以，于是出现了下面的代码：

    public boolean checkSubarraySum(int[] nums, int k) {
        if (nums == null || nums.length < 2 || k <= 0) {
            return false;
        }
        int n = nums.length;
        for (int i = 0; i < n; i ++) {
            nums[i] %= k;
            if (i > 0 && nums[i] == 0 && nums[i-1] == 0) {
                return true;
            }
        }
        int[] dp = new int[n];
        dp[n-1] = nums[n-1];
        for (int i = n-2; i >=0; i --) {
            for (int j = i; j < n; j ++) {
                if (i == j) {
                    dp[j] = nums[i];
                } else {
                    dp[j] += nums[i];
                }
                dp[j] %= k;
                if (i != j && dp[j] == 0) return true;
            }
        }
        return false;
    }

跑了一下，超时了。。最后的测试项数据量太大。。

探索3.抄答案

没想到啥好办法，学习了一下评论区里大神的方法，受教了。大致思路为：

在每个索引位置i,计算当前和对k的mod值,
假设在索引x处, sum[0~x] = mk + mod_x;
在索引y处, sum[0~y] = nk + mod_y;
如果mod_x == mod_y且y-x>1说明sum[x~y]即为一个符合要求的连续子数组,用map来保存每个mod值对应的索引,
一旦出现新的mod值出现在map中,判断索引差是否大于1.

其实就是计算0-i的mod值，用一个map来保存mod和索引。
如果出现两个mod相同的位置，且索引距离超过1，那么这两个索引之间的部分就是我们想要的部分。一次遍历就完成了，very nice～

最后的代码为：

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