Merge pull request #2330 from 8804who/main

[8804who] WEEK 14 Solutions

Author: 8804who

binary-tree-level-order-traversal/8804who.py

@@ -0,0 +1,29 @@
+from collections import deque
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        answer = []
+        
+        q = deque([(root, 0)])
+
+        while q:
+            node, depth = q.popleft()
+            if not node:
+                continue
+            
+            if len(answer)-1 < depth:
+                answer.append([])
+ 
+            answer[depth].append(node.val)
+
+            q.append((node.left, depth+1))
+            q.append((node.right, depth+1))
+
+        return answer
+    

counting-bits/8804who.py

@@ -0,0 +1,22 @@
+import math
+
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        dp = [0, 1]
+        num = 1
+        idx = 2
+
+        while idx <= n:
+            num *= 2
+            temp = idx+(num//2)
+            temp2 = temp+(num//2)
+
+            for i in range(idx, temp):
+                dp.append(dp[i-(num//2)])
+                idx += 1
+            for i in range(temp,temp2):
+                dp.append(dp[i-(num//2)]+1)
+                idx += 1
+        
+        return dp[:n+1]
+    

house-robber-ii/8804who.py

@@ -0,0 +1,15 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        nums = [0]+nums
+        dp1 = [0 for _ in range(len(nums))]
+        dp2 = [0 for _ in range(len(nums))]
+
+        dp1[1] = nums[1]
+
+        for i in range(2, len(nums)-1):
+            dp1[i] = max(dp1[i-1], dp1[i-2]+nums[i])
+        for i in range(2, len(nums)):
+            dp2[i] = max(dp2[i-1], dp2[i-2]+nums[i])
+
+        return max(max(dp1), max(dp2))
+    

word-search-ii/8804who.py

@@ -0,0 +1,40 @@
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        answer = []
+        trie = {}
+        moves = [[-1,0],[1,0],[0,-1],[0,1]]
+
+        for word in words:
+            node = trie
+            for char in word:
+                if char not in node:
+                    node[char] = {}
+                node = node[char]
+            node["$"] = word
+        
+        def dfs(y, x, node):
+            if "$" in node:
+                answer.append(node["$"])
+                del node["$"]
+
+            if 0 > y or y >= len(board) or 0 > x or x >= len(board[0]):
+                return
+
+            if board[y][x] not in node:
+                return
+
+            node = node[board[y][x]]
+
+            temp = board[y][x]
+            board[y][x] = ""
+
+            for move in moves:
+                dfs(y+move[0], x+move[1], node)
+            board[y][x] = temp
+
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                if board[i][j] in trie:
+                    dfs(i,j,trie)
+        return answer
+