渣渣的Leetcode之旅（Python3）_前缀和（523,525）

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/continuous-subarray-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

如果要求第三位到第七位之间的和，用遍历的话时间复杂度也就O(5)，但是这个题目里的这样的组合非常多，这样做时间复杂度会非常高，绝对会超时。
所以引入一个概念前缀和。
total[3]表示前3位的和，total[7]表示前7位的和，要求3~7位之间数字的和，可以用total[7]-total[2]，时间复杂度为O(1)

另外，如果3~7位之间的数字和是x的倍数，那么total[3]%x 等于 total[7]%x
然后用哈希表记录total[n]%x 的值，如果有重复并且下标距离大于2，那么就找到目标了。（考虑一下从第一位一直加到n位，正好是目标值的倍数这种特殊情况**([23,2,4,6,6] 7)**）

class Solution:
    def checkSubarraySum(self, nums: List[int], k: int) -> bool:
        if len(nums)==1:
            return False
        dict_01 = {}
        dict_01[0] = -1
        list_01 = [0]*len(nums)
        for i in range(len(nums)):
            if i ==0:
                list_01[i] = nums[i]
            else:
                list_01[i] = list_01[i-1] + nums[i]
            temp = list_01[i]%k
            if temp in dict_01:
                if i - dict_01[temp] >=2:
                    return True
            else:
                dict_01[temp] = i
        return False

525. 连续数组

给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。

示例 1:

输入: nums = [0,1] 输出: 2 说明: [0, 1] 是具有相同数量0和1的最长连续子数组。

示例 2:

输入: nums = [0,1,0] 输出: 2 说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。

提示：

1 <= nums.length <= 105
nums[i] 不是 0 就是 1

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/contiguous-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

还是用前缀和的思想啊，如果你要确定nums[3]到nums[15]之间的0和1 的个数，难道用遍历吗
遍历一次nums数组，每到一个位置，记录从第一个数字到当前这个位置1的个数减去0的个数的差。如果说有两个位置的差值相等，那么这两个位置之间的0和1的个数相等。

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        if len(nums)==0:
            return 0
        num_1 , num_0 = 0,0
        dict_01 = {}
        fin_ans = 0
        for i in range(len(nums)):
            if nums[i]==1:
                num_1 += 1
            else:
                num_0 += 1
            middle = num_1 - num_0
            if middle == 0:
                if fin_ans<i+1:
                    fin_ans = i+1
            else:
                if middle in dict_01:
                    if fin_ans<i-dict_01[middle]:
                        fin_ans = i - dict_01[middle]
                else:
                    dict_01[middle] = i
        return fin_ans

第一次击败100%的用户