update

Author: tiationg-kho

README.md

@@ -8,7 +8,7 @@
     - connected
     - acyclic
     - non-direction edges
-    - one path/edge between any two vertices/node
+    - one path between any two vertices/nodes
 - important tree concepts
     - traversal of the tree
     - depth/height of tree

[A]tree/tree.md

@@ -0,0 +1,23 @@
+class Solution:
+    def removeKdigits(self, num: str, k: int) -> str:
+        stack = []
+        for c in num:
+            while stack and stack[- 1] > c and k:
+                stack.pop()
+                k -= 1
+            stack.append(c)
+        
+        while stack and k:
+            stack.pop()
+            k -= 1
+
+        res = ''.join(stack).lstrip('0')
+        return res if res else '0'
+
+# time O(n)
+# space O(n)
+# using stack and queue and montonic and monotonic stack (consider one side’s relationship)
+'''
+1. 21: when met 1, we pop 2 out and choose 1 to make num smaller
+2. 12: when met 1, we cannot pop 1 cause it will make num larger
+'''

[I]stack-queue/[I]stack-queue-monotonic/402-remove-k-digits.py

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

[I]stack-queue/[I]stack-queue-monotonic/503-next-greater-element-ii.py

@@ -0,0 +1,24 @@
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
+        heights = [0] + heights + [0]
+        res = 0
+        stack = []
+        for i in range(len(heights)):
+            while stack and heights[stack[- 1]] > heights[i]:
+                idx = stack.pop()
+                height = heights[idx]
+                left_bound = stack[- 1]
+                right_bound = i
+                width = right_bound - left_bound - 1
+                res = max(res, height * width)
+            stack.append(i)
+        return res
+        
+# time O(n)
+# space O(n), due to stack
+# using stack and queue and montonic and monotonic stack (consider two side’s relationship)
+'''
+1. decide height
+2. then find the left smaller element and right smaller element
+3. count the area between these two bound
+'''

[I]stack-queue/[I]stack-queue-monotonic/84-largest-rectangle-in-histogram.py

@@ -0,0 +1,29 @@
+class Solution:
+    def maximalRectangle(self, matrix: List[List[str]]) -> int:
+        
+        def helper(heights):
+            heights = [0] + heights + [0]
+            stack = []
+            res = 0
+            for i in range(len(heights)):
+                while stack and heights[stack[- 1]] > heights[i]:
+                    idx = stack.pop()
+                    res = max(res, heights[idx] * (i - stack[- 1] - 1))
+                stack.append(i)
+            return res
+
+        res = 0
+        rows, cols = len(matrix), len(matrix[0])
+        prefix = [0 for _ in range(cols)]
+        for r in range(rows):
+            for c in range(cols):
+                if matrix[r][c] == "1":
+                    prefix[c] += 1
+                else:
+                    prefix[c] = 0
+            res = max(res, helper(prefix))
+        return res
+    
+# time O(RC)
+# space O(C)
+# using stack and queue and montonic and monotonic stack (consider two side’s relationship) and prefix

[I]stack-queue/[I]stack-queue-monotonic/85-maximal-rectangle.py

@@ -111,7 +111,7 @@
         - user two stack or dll
     - can simulate nested list iterator
 - **use monotonic queue and sliding window**
-    - if we want to maintain the min/max value and there is a constraint/consideration about the length of valid subarray (sliding window)
+    - if we want to get the min/max value for each subarray, and there is a constraint/consideration about subarray's length (sliding window)
         - eg. get every [i, i + k - 1] subarray's min/max value
             - naive way might take O(nk)
             - use monotonic queue only spend O(n)
@@ -123,15 +123,14 @@
         - when to record the cur best res
         - (order of these steps is not guaranteed)
 - **use monotonic stack (consider one or two side’s relationship)**
+    - if we want to get first relative smaller/larger and left/right neighbors for each element
+    - if we want to get smallest/largest element in every subarray
     - notice
         - when to pop element at stack's end
         - when to add element at stack’s end
     - monotonic increasing or decreasing array will be generated
     - there’s two type of this technique
         - consider one side’s relationship
         - consider two side’s relationship
-    - can find out the left and/or right bound for each element in some condition
-        - finding the left and/or right relative smaller/larger elements for each element
-        - finding the smallest/largest element in every subarray
     - can use sentinel element at left bound or/and right bound
         - help us to handle edge case

[I]stack-queue/stack-queue.md

@@ -0,0 +1,22 @@
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        if not digits:
+            return []
+        res = []
+        num_chars = {'2': 'abc', '3': 'def', '4':'ghi', '5':'jkl', '6':'mno', '7':'pqrs', '8':'tuv', '9':'wxyz'}
+
+        def dfs(path, idx):
+            if len(path) == len(digits):
+                res.append(''.join(path))
+                return
+            for c in num_chars[digits[idx]]:
+                path.append(c)
+                dfs(path, idx + 1)
+                path.pop()
+
+        dfs([], 0)
+        return res
+                
+# time O(4**n), n is the length of digits
+# space O(n), due to recursion stack, output is O(4**n)
+# using dfs and backtracking and backtracking with constraints

[J]backtracking/[J]backtracking/17-letter-combinations-of-a-phone-number.py

@@ -0,0 +1,27 @@
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        res = []
+
+        def dfs(path, visited):
+            if len(path) == len(nums):
+                res.append(path[:])
+                return
+            for i in range(len(nums)):
+                if i not in visited:
+                    visited.add(i)
+                    path.append(nums[i])
+                    dfs(path, visited)
+                    visited.remove(i)
+                    path.pop()
+        
+        dfs([], set())
+        return res
+        
+# time O(n*n!), dfs will calls n! times and each non-leaf node traverse list costs O(n) and leaf node copy a list to answer costs O(n)
+# space O(n*n!), because answer contains n! permutations and each permutaiton can cost O(n). Besides, memory stack size is O(n)
+# using dfs and backtracking and permutation
+'''
+1. type: permutation
+2. duplicate elements: no
+3. selectable repeatedly: no
+'''

[J]backtracking/[J]backtracking/46-permutations.py

@@ -0,0 +1,24 @@
+class Solution:
+    def combine(self, n: int, k: int) -> List[List[int]]:
+        res = []
+
+        def dfs(path, idx):
+            if len(path) == k:
+                res.append(path[:])
+                return
+            for i in range(idx, n + 1):
+                path.append(i)
+                dfs(path, i + 1)
+                path.pop()
+
+        dfs([], 1)
+        return res
+    
+# time O(n!/(n-k)!k! * k)
+# space O(k), not count output
+# using dfs and backtracking and combination
+'''
+1. type: combination
+2. duplicate elements: no
+3. selectable repeatedly: no
+'''

[J]backtracking/[J]backtracking/77-combinations.py

@@ -0,0 +1,70 @@
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        res = []
+
+        def dfs(path, idx):
+            if idx == len(nums):
+                res.append(path[:])
+                return
+            dfs(path, idx + 1)
+
+            path.append(nums[idx])
+            dfs(path, idx + 1)
+            path.pop()
+        
+        dfs([], 0)
+        return res
+    
+# time O(n*(2**n)), due to each element can take or not take (2**n), and n for copy list
+# space O(n), due to recursion stack, not counting output here
+# using dfs and backtracking and subset
+'''
+1. type: subset
+2. duplicate elements: no
+3. selectable repeatedly: no
+'''
+'''
+this approach focus on considering each element:
+for cur element, 
+we don't take, then goto next element
+or we take, then goto next element
+till no more element to be considered, we record path
+'''
+
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        res = []
+
+        def dfs(path, idx):
+            if idx == len(nums):
+                res.append(path[:])
+                return
+
+            res.append(path[:])
+            for i in range(idx, len(nums)):
+                path.append(nums[i])
+                dfs(path, i + 1)
+                path.pop()
+        
+        dfs([], 0)
+        return res
+    
+# time O(n*(2**n)), due to each element can take or not take (2**n), and n for copy list
+# space O(n), due to recursion stack, not counting output here
+# using dfs and backtracking and subset
+'''
+1. type: subset
+2. duplicate elements: no
+3. selectable repeatedly: no
+'''
+'''
+this approach focus on constructing the path:
+record cur path,
+then choose a element to add in path
+
+more specific:
+we have chosen nothing, record, try to add first element
+we have chosen one element, record, try to add another element
+we have chosen two elements, record, try to add another element
+we have chosen three elements, record, try to add another element
+'''

[J]backtracking/[J]backtracking/78-subsets.py

@@ -7,26 +7,24 @@
     - making decisions
         - each round we got multi choices (must pick one)
         - each round we choose sth or not choose
-    - notice elements are duplicate or not
+    - notice elements are duplicate or unique
         - if so, we need to take care of pruning
     - notice elements can be chosen repeatedly or not
         - if not, we need to maintain a memo
     - notice that inside backtracking, we can use the boolean value as a return value to indicate whether there is a valid answer or not
 
 ```python
 
-def backtrack(res, path, count, memo, index/node):
-    if BOUND_REACHED:	
-        return
-
-    if GOAL_REACHED:
-        res.append(COPIED_PATH)
+def backtrack(res, path, count, visited, index/node):
+    if BOUND_REACHED:
+        if GOAL_REACHED:
+            RECORD_RESULT
         return
 
     for CHOCIE in CHOICES:
         if CHOICE is VALID:
             MAKE_CHOICE
-            backtrack(res, path, count, memo, index/node)
+            backtrack(res, path, count, visited, index/node)
             UNDO_CHOICE
 ```
 

[J]backtracking/backtracking.md

@@ -0,0 +1,26 @@
+class Solution:
+    def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
+        res = 0
+        rows, cols = len(matrix), len(matrix[0])
+        counts = [[- 1 for _ in range(cols)] for _ in range(rows)]
+
+        def dfs(r, c):
+            next_count = 0
+            for next_r, next_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:
+                if next_r not in range(rows) or next_c not in range(cols) or matrix[r][c] >= matrix[next_r][next_c]:
+                    continue
+                if counts[next_r][next_c] == - 1:
+                    next_count = max(next_count, dfs(next_r, next_c))
+                else:
+                    next_count = max(next_count, counts[next_r][next_c])
+            counts[r][c] = 1 + next_count
+            return counts[r][c]
+        
+        for r in range(rows):
+            for c in range(cols):
+                res = max(res, dfs(r, c))
+        return res
+    
+# time O(RC)
+# space O(RC)
+# using graph and dfs

[K]graph/[K]graph-dfs/329-longest-increasing-path-in-a-matrix.py

@@ -2,34 +2,32 @@
 
 ## intro
 
-- A graph is most commonly stored as a hashmap/list of adjacency lists/sets: for each vertex, store a list of its neighbors
+- A graph is most commonly stored as a hashmap/list of adjacency lists/sets: for each vertex, store a list/set of its neighbors
     - how to build graph is important
     - often use
         - elements inside set can be tuples
-        
         ```python
         graph = defaultdict(set)
         ```
-        
-    - tree is a special graph with properties that
+    - notice: tree is a special graph with properties that
         - connected
         - acyclic
         - non-direction edges
-        - one path/edge between any two vertices/node
+        - one path between any two vertices/nodes
 
 ## graph dfs pattern
 
 - DFS
     - time `O(|V| + |E|)`
-    - space `O(|V| + |E|)` for visited hashset, and `O(|V|)` for recursion stack
+    - space `O(|V|)` for visited hashset, and recursion stack
     - DFS is better at
         - finding nodes far away from the root
 
 ## graph bfs pattern
 
 - BFS
     - time `O(|V| + |E|)`
-    - space `O(|V| + |E|)` for visited hashset, and `O(|V|)` for queue
+    - space `O(|V|)` for visited hashset, and queue
     - tips
         - shortest distance of a to b is equal to the distance of b to a
         - sometimes can use topological sort’s idea