[Helena] Week 14

binary-tree-level-order-traversal/yolophg.py

@@ -0,0 +1,36 @@
+# Time Complexity: O(n) -> visit each node exactly once.
+# Space Complexity: O(n) -> in the worst case, the queue holds all nodes at the last level.
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+
+        # list to store level order traversal.
+        ans = [] 
+
+        # if the tree is empty, return an empty list.
+        if root is None:
+            return ans 
+
+        # queue to process nodes level by level.
+        q = deque([root]) 
+
+        while q:
+            # list to store values of nodes at the current level.
+            t = [] 
+
+            # process all nodes at this level.
+            for _ in range(len(q)):  
+                # pop the first node from the queue.
+                node = q.popleft()  
+                # add node's value to the list.
+                t.append(node.val) 
+
+                if node.left:
+                    q.append(node.left) 
+                if node.right:
+                    q.append(node.right) 
+
+            # add current level values to the result list.
+            ans.append(t) 
+
+        return ans

counting-bits/yolophg.py

@@ -0,0 +1,18 @@
+# Time Complexity: O(n) -> iterate from 1 to n, updating arr[] in O(1) for each i.
+# Space Complexity: O(n) -> store results in an array of size (n+1).
+
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        # make an array of size (n+1), initialized with 0s.
+        arr = [0] * (n + 1)  
+
+        # loop from 1 to n
+        for i in range(1, n + 1):  
+            if i % 2 == 0:
+                # even number -> same count as i//2
+                arr[i] = arr[i // 2]  
+            else:
+                # odd number -> one more bit than i//2
+                arr[i] = arr[i // 2] + 1  
+
+        return arr

house-robber-ii/yolophg.py

@@ -0,0 +1,32 @@
+# Time Complexity: O(n) -> iterate through the houses twice, each in O(n) time.
+# Space Complexity: O(1) -> use a few extra variables, no additional data structures.
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:        
+        if not nums:
+            return 0
+        if len(nums) == 1:
+            return nums[0]
+
+        # track the max money from two houses before and last house.
+        var1, var2 = 0, 0  
+
+        # robbing from first house to second-last house (excluding last house)
+        for i in nums[:-1]:
+            # store previous max before updating.
+            temp = var1  
+            # either rob this house or skip it.
+            var1 = max(var2 + i, var1)  
+            # move to the next house.
+            var2 = temp  
+
+        # same logic, but robbing from second house to last house.
+        vaar1, vaar2 = 0, 0  
+
+        for i in nums[1:]:
+            temp = vaar1
+            vaar1 = max(vaar2 + i, vaar1)
+            vaar2 = temp
+
+        # take the max of both cases.
+        return max(var1, vaar1)  

meeting-rooms-ii/yolophg.py

@@ -0,0 +1,22 @@
+ # Time Complexity: O(n log n) -> sorting takes O(n log n), and heap operations take O(log n) per interval.
+ # Space Complexity: O(n) -> in the worst case, store all meetings in the heap.
+
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:        
+        if not intervals:
+            return 0
+
+        # sort meetings by start time.
+        intervals.sort() 
+
+        # heap to keep track of meeting end times.
+        min_heap = [] 
+
+        for start, end in intervals:
+            if min_heap and min_heap[0] <= start:
+                # remove the meeting that has ended.
+                heapq.heappop(min_heap) 
+            # add the current meeting's end time.
+            heapq.heappush(min_heap, end) 
+
+        return len(min_heap) 

word-search-ii/yolophg.py

@@ -0,0 +1,45 @@
+# Time Complexity: O(m * n * 4^l) -> each cell can explore up to 4 directions recursively, where l is the max word length.
+# Space Complexity: O(w * l) -> storing words in a dictionary-based Trie.
+
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:    
+        # trie-like dictionary to store words    
+        d = {} 
+
+        # build the trie
+        for word in words:
+            cur = d
+            for c in word:
+                if c not in cur:
+                     # create a new node
+                    cur[c] = {} 
+                cur = cur[c]
+            # mark the end of the word
+            cur["*"] = word  
+
+        # right, down, up, left
+        directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]  
+
+        # backtracking function
+        def dfs(i, j, cur, seen):
+            result = set()
+            if "*" in cur:
+                # found a word, add it
+                result = {cur["*"]}  
+
+            for x, y in directions:
+                ni, nj = i + x, j + y
+                if 0 <= ni < len(board) and 0 <= nj < len(board[0]) and (ni, nj) not in seen and board[ni][nj] in cur:
+                    result.update(dfs(ni, nj, cur[board[ni][nj]], seen | {(ni, nj)}))
+
+            return result
+
+        result = set()
+
+        # start dfs search from every cell in the board
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                if board[i][j] in d:
+                    result.update(dfs(i, j, d[board[i][j]], {(i, j)}))
+
+        return list(result)