leetcode刷题笔记-prefix sum

3356. Zero Array Transformation II

class Solution:
    def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:
        # queriy = 左边界，右边界，v
        # 只要是在边界内，preS 就加上， 但是超过边界的时候，就是右边界+1的时候就要减去v
        preS = 0
        boundary = [0] * (len(nums) + 1) # 记录边界
        re = 0 # 记录用多少个query
        for i, n in enumerate(nums):
            preS += boundary[i] # 可能是负数，超过query边界，也可以是正数，之前拿到的query的left太大之前用不到，但是queries必须按顺序拿
            if n == 0 or n - preS <= 0: continue

            while queries: # 按顺序拿
                l, r, v = queries.pop(0)
                re += 1
                boundary[l] += v
                boundary[r+1] -= v
                
                if l <= i and r >=i: # 在边界内就直接加上
                    preS += v

                if n - preS <= 0:
                    break
            
            if n - preS > 0:
                return -1

        return re

1124. Longest Well-Performing Interval

class Solution:
    def longestWPI(self, hours: List[int]) -> int:
        # preSum, >8 is 1, else is -1
        preS = 0
        re = 0
        v2i = {}
        for i, v in enumerate(hours):
            v = 1 if v > 8 else -1
            preS += v
            if preS > 0:
                re = i + 1
            else: # preS <= 0
                if (preS - 1) in v2i:  # total S (already <=0) - (a preS) should make the rest of the subarray sum > 0
                    re = max(re, i - v2i[preS-1])
                if preS not in v2i:
                    v2i[preS] = i

        return re

1685. Sum of Absolute Differences in a Sorted Array

https://leetcode.com/problems/sum-of-absolute-differences-in-a-sorted-array/description/

class Solution:
    def getSumAbsoluteDifferences(self, nums: List[int]) -> List[int]:
#         res[i] = (nums[i] - nums[0]) + (nums[i] - nums[1]) + ... + (nums[i] - nums[i - 1])        <--- absolute difference of nums[i] with first i numbers
#      + (nums[i] - nums[i]) + (nums[i + 1] - nums[i]) + (nums[i + 2] - nums[i]) + ... + (nums[n - 1] - nums[i])   <--- absolute difference of nums[i] with last n - i numbers

#         res[i] = i * nums[i] - (nums[0] + ... + nums[i - 1])        <--- absolute difference of nums[i] with first i numbers
#      + (nums[i + 1] + ... + nums[n]) - (n - i) * nums[i]   <--- absolute difference of nums[i] with last n - i numbers

#      res[i] = i * nums[i] - prefixSum[i] +
#       prefixSum[n] - prefixSum[i] - (n - i) * nums[i]

        pre_s = [0]
        for n in nums:
            pre_s.append(n + pre_s[-1])
        re, n = [], len(nums)
        for i, v in enumerate(nums):
            re.append(i*v - pre_s[i] + pre_s[n] - pre_s[i] - (n-i) *v)
        return re

974. Subarray Sums Divisible by K

class Solution:
    def subarraysDivByK(self, nums: List[int], k: int) -> int:
        '''
        how many ways can we pair up all prefix sum pairs (i,j) where i < j such that (prefix[j] - prefix[i]) % K == 0. we easily get a O(n^2) solution.
        To linear: 
        I noted above that we need to find all prefix sum pairs (i,j) such tha (p[j] - p[i]) % K == 0.
        But this is only true, if and only if p[j] % K == p[i] % K
        '''
 
        count = [0] * k
        count[0] = 1 # [0] can be diviable by k
        preS = re = 0
        for n in nums:
            preS = (preS + n) % k
            re += count[preS]
            count[preS] += 1
        return re