LeetCode523,连续的子数组和

LeetCode523,连续的子数组和

题目描述

给定一个包含非负数的数组和一个目标整数 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。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/continuous-subarray-sum

解题思路

暴力，特别注意0！！！！！！！！！

1. 求一个数组中连续的子序列的和是否能被k整除。最坏的情况就是遍历所有的子序列。n-1+n-2+n-3+…+1=（n-1）n/2，时间复杂度：O(n^2)
2. 按照上面的思路，计算出每个子序列的和，进行判断。
3. 如果使用二维数组，使用二维数组时，会有一大半的空间都是空闲的（n[^2]-n(n-1)/2），会报超出内存限制。可以优化为一维数组。

使用二维数组，会报内存超出：

    public boolean solution(int[] n,int k){


        int[][] dp = new int[n.length-1][n.length];
        dp[0][0] = n[0];
        for (int i = 0;i<n.length-1;i++)
            for (int j = i+1;j<n.length;j++){
                if (i == 0)
                    dp[i][j] = dp[i][j-1]+n[j];
                else
                    dp[i][j] = dp[i-1][j] - n[i-1];
                if (k == 0) {
                    if (dp[i][j] == 0)
                        return true;
                }
                else
                  if (dp[i][j]%k == 0)
                        return true;
            }
        return false;
    }

优化后，转为一维数组：

    public boolean solution2(int[] n,int k){

        int[] dp = new int[n.length];

        for (int i = 0;i<n.length;i++) {
            if (n[i] == 0 && i < n.length - 1 && n[i + 1] == 0) {
                return true;
            }
            dp[i] = n[i];
            for (int j = i + 1; j < n.length; j++) {
                dp[j] = dp[j - 1] + n[j];
                if (k == 0) {
                    if (dp[j] == 0)
                        return true;
                } else if (dp[j] % k == 0)
                    return true;
            }
        }
        return false;
    }

缺点
优化为一维数组之后，过是过了，但是结果显示，时间空间都占的太多了。看了官方题解，这是人能想到的思路吗？！！！

官方思路

使用hashmap，用空间换时间

1. 记录子序列（从下标为0开始的子序列）的余数。sum(n) mod k
2. 如果出现两个子序列的余数相同（map.contains(key)）,则第后面的余数可以消除，将第一次出现的位置的子序列剔除，剩余的子序列为满足条件的子序列。