update

Author: tiationg-kho

README.md

@@ -17,6 +17,7 @@ def minSubArrayLen(self, target: int, nums: List[int]) -> int:
 '''
 1. notice: only works for positive elements
 2. if num can be negative then use monotonic queue and prefix sum and sliding window
+3. think about [20, -30, 20, 10] and 30, correct res should be 2
 '''
 
 class Solution:
@@ -48,6 +49,7 @@ def valid(length):
 '''
 1. notice: only works for positive elements
 2. if num can be negative then use monotonic queue and prefix sum and sliding window
+3. think about [-10, -10, -10, 20] and 20, correct res should be 1
 '''
 
 class Solution:

[H]array/[H]array-sliding-window/209-minimum-size-subarray-sum.py

@@ -0,0 +1,26 @@
+from collections import deque
+class Solution:
+    def longestSubarray(self, nums: List[int], limit: int) -> int:
+        res = 0
+        min_queue = deque([])
+        max_queue = deque([])
+        left = 0
+        for right in range(len(nums)):
+            while min_queue and nums[min_queue[- 1]] >= nums[right]:
+                min_queue.pop()
+            min_queue.append(right)
+            while max_queue and nums[max_queue[- 1]] <= nums[right]:
+                max_queue.pop()
+            max_queue.append(right)
+            while nums[max_queue[0]] - nums[min_queue[0]] > limit:
+                left += 1
+                if min_queue[0] < left:
+                    min_queue.popleft()
+                if max_queue[0] < left:
+                    max_queue.popleft()
+            res = max(res, right - left + 1)
+        return res
+    
+# time O(n), each num will only pop and push twice and both cost O(1)
+# space O(n), due to deque's size
+# using stack and queue and montonic and monotonic queue and sliding window

[I]stack-queue/[I]stack-queue-monotonic/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.py

@@ -0,0 +1,36 @@
+class Solution:
+    def maxResult(self, nums: List[int], k: int) -> int:
+        dp = [float('-inf') for _ in range(len(nums))]
+        dp[0] = nums[0]
+
+        for right in range(1, len(nums)):
+            for left in range(max(0, right - k), right):
+                dp[right] = max(dp[right], dp[left] + nums[right])
+        return dp[- 1]
+
+# time O(nk)
+# space O(n)
+# using dp (this will TLE)
+
+from collections import deque
+class Solution:
+    def maxResult(self, nums: List[int], k: int) -> int:
+        dp = [float('-inf') for _ in range(len(nums))]
+        dp[0] = nums[0]
+        queue = deque([])
+
+        for right in range(len(nums)):
+            left = right - k
+            while queue and queue[0] < left:
+                queue.popleft()
+            if queue:
+                dp[right] = dp[queue[0]] + nums[right]
+            while queue and dp[queue[- 1]] <= dp[right]:
+                queue.pop()
+            queue.append(right)
+
+        return dp[- 1]
+    
+# time O(n)
+# space O(n)
+# using stack and queue and montonic and monotonic queue and sliding window and dp

[I]stack-queue/[I]stack-queue-monotonic/1696-jump-game-vi.py

@@ -0,0 +1,19 @@
+from collections import deque
+class Solution:
+    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
+        res = []
+        queue = deque([])
+        for right, num in enumerate(nums):
+            left = right - k + 1
+            while queue and nums[queue[- 1]] <= num:
+                queue.pop()
+            queue.append(right)
+            while queue and queue[0] < left:
+                queue.popleft()
+            if left >= 0:
+                res.append(nums[queue[0]])
+        return res
+    
+# time O(n)
+# space O(k)
+# using stack and queue and montonic and monotonic queue and sliding window

[I]stack-queue/[I]stack-queue-monotonic/239-sliding-window-maximum.py

@@ -0,0 +1,20 @@
+class Solution:
+    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        
+        val_idx = {}
+        for i, num in enumerate(nums1):
+            val_idx[num] = i
+
+        res = [- 1 for _ in range(len(nums1))]
+        stack = []
+        for i in range(len(nums2)):
+            while stack and nums2[stack[- 1]] < nums2[i]:
+                idx = stack.pop()
+                if nums2[idx] in val_idx:
+                    res[val_idx[nums2[idx]]] = nums2[i]
+            stack.append(i)
+        return res
+    
+# time O(n)
+# space O(n), due to stack and hashmap
+# using stack and queue and montonic and monotonic stack (consider one side’s relationship) and hashmap

[I]stack-queue/[I]stack-queue-monotonic/496-next-greater-element-i.py

@@ -0,0 +1,14 @@
+class Solution:
+    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
+        res = [0 for _ in range(len(temperatures))]
+        stack = []
+        for i in range(len(temperatures)):
+            while stack and temperatures[stack[- 1]] < temperatures[i]:
+                idx = stack.pop()
+                res[idx] = i - idx
+            stack.append(i)
+        return res
+    
+# time O(n), each temperature will only pop and push once and both cost O(1)
+# space O(n), due to stack's size
+# using stack and queue and montonic and monotonic stack (consider one side’s relationship)

[I]stack-queue/[I]stack-queue-monotonic/739-daily-temperatures.py

@@ -0,0 +1,31 @@
+from collections import deque
+class Solution:
+    def shortestSubarray(self, nums: List[int], k: int) -> int:
+        prefix = [0 for _ in range(len(nums) + 1)]
+        total = 0
+        for i, num in enumerate(nums):
+            total += num
+            prefix[i + 1] = total
+
+        res = float('inf')
+        queue = deque([])
+        for i in range(len(prefix)):
+            while queue and prefix[i] - prefix[queue[0]] >= k:
+                idx = queue.popleft()
+                res = min(res, i - idx)
+            while queue and prefix[queue[- 1]] >= prefix[i]:
+                queue.pop()
+            queue.append(i)
+        return res if res != float('inf') else - 1
+
+# time O(n)
+# space O(n)
+# using stack and queue and montonic and monotonic queue and sliding window and prefix
+'''
+1. monotonic queue store the potential subarray's head idices
+2. monotonic queue needs to store the smallest prefix sum at queue's head
+3. because smaller prefix gets more chance to fulfill the condition
+4. once it met condition, record it, then popleft it (cur round is the best condition for shortest)
+5. if cur idx's prefix sum is smaller than queue's tail, then pop from queue (using cur idx is shorter)
+6. append cur idx in queue
+'''

[I]stack-queue/[I]stack-queue-monotonic/862-shortest-subarray-with-sum-at-least-k.py

@@ -0,0 +1,32 @@
+class Solution:
+    def minRemoveToMakeValid(self, s: str) -> str:
+        res = []
+        balance = 0
+        for c in s:
+            if c == '(':
+                balance += 1
+                res.append(c)
+            elif c == ')':
+                if balance > 0:
+                    balance -= 1
+                    res.append(c)
+            else:
+                res.append(c)
+
+        balance = 0
+        for i in range(len(res) - 1, - 1, - 1):
+            if res[i] == ')':
+                balance += 1
+            elif res[i] == '(':
+                if balance > 0:
+                    balance -= 1
+                else:
+                    res[i] = ''
+            else:
+                continue
+
+        return ''.join(res)
+    
+# time O(n), due to traverse twice
+# space O(n)
+# using stack and queue and variables to simulate stack

[I]stack-queue/[I]stack-queue/1249-minimum-remove-to-make-valid-parentheses.py

@@ -0,0 +1,42 @@
+class MinStack:
+
+    def __init__(self):
+        self.stack = []
+        self.min_num = None
+
+    def push(self, val: int) -> None:
+        if self.min_num == None:
+            self.stack.append(0)
+            self.min_num = val
+        elif val < self.min_num:
+            self.stack.append(val - self.min_num)
+            self.min_num = val
+        else:
+            self.stack.append(val - self.min_num)
+
+    def pop(self) -> None:
+        diff = self.stack.pop()
+        if len(self.stack) == 0:
+            self.min_num = None
+        elif diff < 0:
+            self.min_num += abs(diff)
+
+    def top(self) -> int:
+        diff = self.stack[- 1]
+        if diff < 0:
+            return self.min_num
+        return self.min_num + diff
+
+    def getMin(self) -> int:
+        return self.min_num
+
+# Your MinStack object will be instantiated and called as such:
+# obj = MinStack()
+# obj.push(val)
+# obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.getMin()
+
+# time O(1)
+# space O(n)
+# using stack and queue and implement stack/queue and one stack

[I]stack-queue/[I]stack-queue/155-min-stack.py

@@ -0,0 +1,31 @@
+from collections import deque
+class MyStack:
+
+    def __init__(self):
+        self.queue = deque([])
+
+    def push(self, x: int) -> None:
+        old_element_count = len(self.queue)
+        self.queue.append(x)
+        for _ in range(old_element_count):
+            self.queue.append(self.queue.popleft())
+
+    def pop(self) -> int:
+        return self.queue.popleft()
+
+    def top(self) -> int:
+        return self.queue[0]
+
+    def empty(self) -> bool:
+        return len(self.queue) == 0
+
+# Your MyStack object will be instantiated and called as such:
+# obj = MyStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.empty()
+
+# time O(n), due to push, and others are O(1)
+# space O(n), due to queue
+# using stack and queue and implement stack/queue and one queue

[I]stack-queue/[I]stack-queue/225-implement-stack-using-queues.py

@@ -0,0 +1,50 @@
+class TextEditor:
+
+    def __init__(self):
+        self.left = []
+        self.right = []
+
+    def addText(self, text: str) -> None:
+        for c in text:
+            self.left.append(c)
+
+    def deleteText(self, k: int) -> int:
+        res = 0
+        while self.left and k:
+            self.left.pop()
+            k -= 1
+            res += 1
+        return res
+
+    def cursorLeft(self, k: int) -> str:
+        while self.left and k:
+            self.right.append(self.left.pop())
+            k -= 1
+        res = ''
+        for i in range(len(self.left) - 1, - 1, - 1):
+            res = self.left[i] + res
+            if len(res) == 10:
+                break
+        return res
+
+    def cursorRight(self, k: int) -> str:
+        while self.right and k:
+            self.left.append(self.right.pop())
+            k -= 1
+        res = ''
+        for i in range(len(self.left) - 1, - 1, - 1):
+            res = self.left[i] + res
+            if len(res) == 10:
+                break
+        return res
+
+# Your TextEditor object will be instantiated and called as such:
+# obj = TextEditor()
+# obj.addText(text)
+# param_2 = obj.deleteText(k)
+# param_3 = obj.cursorLeft(k)
+# param_4 = obj.cursorRight(k)
+                       
+# time O(s) for add, O(1) for init, others are O(k)
+# space O(n)
+# using stack and queue and stack to simulate and two stacks

[I]stack-queue/[I]stack-queue/2296-design-a-text-editor.py

@@ -0,0 +1,33 @@
+class MyQueue:
+
+    def __init__(self):
+        self.stack1 = []
+        self.stack2 = []
+
+    def push(self, x: int) -> None:
+        self.stack1.append(x)
+
+    def pop(self) -> int:
+        self.peek()
+        return self.stack2.pop()
+
+    def peek(self) -> int:
+        if self.stack2:
+            return self.stack2[- 1]
+        while self.stack1:
+            self.stack2.append(self.stack1.pop())
+        return self.stack2[- 1]
+
+    def empty(self) -> bool:
+        return len(self.stack1) == 0 and len(self.stack2) == 0
+
+# Your MyQueue object will be instantiated and called as such:
+# obj = MyQueue()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.peek()
+# param_4 = obj.empty()
+
+# time O(1) for push(), empty() ,and initiation, amortized O(1) for pop(), peek()
+# space O(n), due to two stacks
+# using stack and queue and implement stack/queue and two stacks