力扣523连续得子数组和——前缀和，同余

题目

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

给你一个整数数组 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

思路

第一步

首先如果找i-j的子数组，再计算i-j的和就是n三次方的时间复杂度，肯定是超时的。
基于以前的经验直接用前缀和，来O(1)计算子数组的和，优化到n平方时间复杂度。

第二步

尝试写出来之后，发现果然超时了，因此要继续进行优化，看了例子给出的K非常非常大，因此浪费了太多时间在i的循环上。
也就是前i个数的和都小于K，然后还遍历i-j个数，因此可以剪枝。
适用二分法，快速找到大于等于K的前i个数的i，然后再继续往下进行。
可以自己写二分函数，也可以直接调用sort.Search()

func checkSubarraySum(nums []int, k int) bool {
	n := len(nums)
	sumIndex := make([]int, n+1)
	//sumIndex[i]表示前i-1个数的和
	for i := 1; i <= n; i++ {
		sumIndex[i] = sumIndex[i-1] + nums[i-1]
	}
	i := 0
	if n > 2 {
		i = sort.Search(n-2, func(i int) bool { return sumIndex[i+2] >= k }) + 2
	}
	for ; i <= n; i++ {
		//超时 因此改用二分
		for j := 0; j < i-1; j++ {
			if (sumIndex[i]-sumIndex[j])%k == 0 {
				return true
			}
		}

	}
	return false
}

第三步

速度已经优化， 但是另一个测试用例出错了，输入的数很小很小，所有数加起来都没有K大，因此输出了false,但是答案是true。才想到原来n可以等于0，即只要连续出现了两个0，就可以满足任何K。
因此在代码最开始可以进行一下判断，更节省时间

        for j:=0;j<n-1;j=j+2{
        if nums[j]==0&&nums[j+1]==0{
            return true
        }
    }

官方题解

官方不仅采用了前缀和，而且考虑到两者的差是K的整数倍，只要余数相同就行，因此维护一个余数的map,更为快捷方便。

func checkSubarraySum(nums []int, k int) bool {
    m := len(nums)
    if m < 2 {
        return false
    }
    mp := map[int]int{0: -1}
    remainder := 0
    for i, num := range nums {
        remainder = (remainder + num) % k
        if prevIndex, has := mp[remainder]; has {
            if i-prevIndex >= 2 {
                return true
            }
        } else {
            mp[remainder] = i
        }
    }
    return false
}

从结果来看，耗时差不多，官方的内存空间占用更少