update

Author: tiationg-kho

README.md

@@ -0,0 +1,18 @@
+from collections import defaultdict
+class Solution:
+ def numberOfSubarrays(self, nums: List[int], k: int) -> int:
+ prefix_count = defaultdict(int)
+ prefix_count[0] = 1
+
+ total = 0
+ res = 0
+ for num in nums:
+ if num % 2:
+ total += 1
+ res += prefix_count[total - k]
+ prefix_count[total] += 1
+ return res
+ 
+# time O(n)
+# space O(n)
+# using array and prefix sum and hashmap to validate the gap subarray

[H]array/[H]array-prefix-sum/1248-count-number-of-nice-subarrays.py

@@ -0,0 +1,18 @@
+class Solution:
+ def maxSubArrayLen(self, nums: List[int], k: int) -> int:
+ prefix_idx = {}
+ prefix_idx[0] = - 1
+
+ total = 0
+ res = 0
+ for i, num in enumerate(nums):
+ total += num
+ if total - k in prefix_idx:
+ res = max(res, i - prefix_idx[total - k])
+ if total not in prefix_idx:
+ prefix_idx[total] = i
+ return res
+ 
+# time O(n)
+# space O(n)
+# using array and prefix sum and hashmap to validate the gap subarray

[H]array/[H]array-prefix-sum/325-maximum-size-subarray-sum-equals-k.py

@@ -0,0 +1,36 @@
+from sortedcontainers import SortedDict
+class Solution:
+ def maxSumSubmatrix(self, matrix: List[List[int]], k: int) -> int:
+ rows, cols = len(matrix), len(matrix[0])
+
+ prefix = [[0 for _ in range(cols + 1)] for _ in range(rows + 1)]
+ for r in range(rows):
+ total = 0
+ for c in range(cols):
+ total += matrix[r][c]
+ prefix[r + 1][c + 1] = total
+ 
+ def get_sum(part_rows):
+ prefix_dict = SortedDict()
+ prefix_dict[0] = - 1
+ total = 0
+ res = float('-inf')
+ for r, part_row in enumerate(part_rows):
+ total += part_row
+ idx = prefix_dict.bisect_left(total - k)
+ if idx < len(prefix_dict):
+ res = max(res, total - prefix_dict.peekitem(idx)[0])
+ if total not in prefix_dict:
+ prefix_dict[total] = r
+ return res
+
+ res = float('-inf')
+ for lc in range(cols):
+ for rc in range(lc, cols):
+ part_rows = [row[rc + 1] - row[lc] for i, row in enumerate(prefix) if i > 0]
+ res = max(res, get_sum(part_rows))
+ return res
+ 
+# time O(C**2 * RlogR)
+# space O(RC)
+# using array and prefix sum and hashmap to validate the gap subarray and binary search

[H]array/[H]array-prefix-sum/363-max-sum-of-rectangle-no-larger-than-k.py

@@ -0,0 +1,18 @@
+class Solution:
+ def checkSubarraySum(self, nums: List[int], k: int) -> bool:
+ prefix_idx = {}
+ prefix_idx[0] = - 1
+
+ total = 0
+ for i, num in enumerate(nums):
+ total += num
+ total %= k
+ if total in prefix_idx and i - prefix_idx[total] >= 2:
+ return True
+ if total not in prefix_idx:
+ prefix_idx[total] = i
+ return False
+ 
+# time O(n)
+# space O(n)
+# using array and prefix sum and hashmap to validate the gap subarray

[H]array/[H]array-prefix-sum/523-continuous-subarray-sum.py

@@ -0,0 +1,22 @@
+class Solution:
+ def findMaxLength(self, nums: List[int]) -> int:
+ nums = [- 1 if num == 0 else 1 for num in nums]
+
+ prefix_idx = {}
+ prefix_idx[0] = - 1
+ total = 0
+ res = 0
+ for i, num in enumerate(nums):
+ total += num
+ if total in prefix_idx:
+ res = max(res, i - prefix_idx[total])
+ else:
+ prefix_idx[total] = i
+ return res
+
+# time O(n)
+# space O(n)
+# using array and prefix sum and hashmap to validate the gap subarray
+'''
+1. if meet the same prefix in hashmap means the gap is balanced
+'''

[H]array/[H]array-prefix-sum/525-contiguous-array.py

@@ -0,0 +1,26 @@
+class Solution:
+ def splitArray(self, nums: List[int]) -> bool:
+ prefix = [0 for _ in range(len(nums) + 1)]
+ total = 0
+ for i, num in enumerate(nums):
+ total += num
+ prefix[i + 1] = total
+
+ for j in range(3, len(nums) - 3):
+ prefix_set = set()
+ for i in range(1, j - 1):
+ if prefix[i] == prefix[j] - prefix[i + 1]:
+ prefix_set.add(prefix[i])
+ for k in range(j + 2, len(nums) - 1):
+ if prefix[k] - prefix[j + 1] == prefix[- 1] - prefix[k + 1]:
+ if prefix[k] - prefix[j + 1] in prefix_set:
+ return True
+ return False
+ 
+# time O(n**2)
+# space O(n)
+# using array and prefix sum and hashmap to validate the gap subarray 
+'''
+1. xixjxkx
+ 0123456
+'''

[H]array/[H]array-prefix-sum/548-split-array-with-equal-sum.py

@@ -0,0 +1,19 @@
+from collections import defaultdict
+class Solution:
+ def subarraySum(self, nums: List[int], k: int) -> int:
+ prefix_count = defaultdict(int)
+ prefix_count[0] = 1
+ total = 0
+ res = 0
+ for num in nums:
+ total += num
+ res += prefix_count[total - k]
+ prefix_count[total] += 1
+ return res
+ 
+# time O(n)
+# space O(n)
+# using array and prefix sum and hashmap to validate the gap subarray
+'''
+1. if meet the prefix - k in hashmap means the gap is valid
+'''

[H]array/[H]array-prefix-sum/560-subarray-sum-equals-k.py

@@ -0,0 +1,18 @@
+from collections import defaultdict
+class Solution:
+ def subarraysDivByK(self, nums: List[int], k: int) -> int:
+ prefix_count = defaultdict(int)
+ prefix_count[0] = 1
+
+ total = 0
+ res = 0
+ for num in nums:
+ total += num
+ total %= k
+ res += prefix_count[total]
+ prefix_count[total] += 1
+ return res
+ 
+# time O(n), due to traverse
+# space O(n)
+# using array and prefix sum and hashmap to validate the gap subarray

[H]array/[H]array-prefix-sum/974-subarray-sums-divisible-by-k.py

@@ -0,0 +1,20 @@
+from collections import defaultdict
+class Solution:
+ def numKLenSubstrNoRepeats(self, s: str, k: int) -> int:
+ char_freq = defaultdict(int)
+ res = 0
+ left = 0
+ for right in range(len(s)):
+ char_freq[s[right]] += 1
+ while right - left + 1 > k or char_freq[s[right]] > 1:
+ char_freq[s[left]] -= 1
+ if char_freq[s[left]] == 0:
+ char_freq.pop(s[left])
+ left += 1
+ if len(char_freq) == k:
+ res += 1
+ return res
+ 
+# time O(n)
+# space O(k)
+# using array and standard sliding window and hashmap