[8804who] WEEK 10 solutions

course-schedule/8804who.py

@@ -0,0 +1,26 @@
+from collections import deque
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        pre = [0 for _ in range(numCourses)]
+        graph = [[] for _ in range(numCourses)]
+        for start, end in prerequisites:
+            pre[end]+=1
+            graph[start].append(end)
+
+        q = deque()
+
+        for i in range(numCourses):
+            if pre[i] == 0:
+                q.append(i)
+
+        while q:
+            n = q.popleft()
+            numCourses -= 1
+
+            for post in graph[n]:
+                pre[post] -= 1
+                if pre[post] == 0:
+                    q.append(post)
+
+        return numCourses == 0
+

invert-binary-tree/8804who.py

@@ -0,0 +1,14 @@
+# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root:
+            return None
+        root.left, root.right = root.right, root.left
+        root.right = self.invertTree(root.right)
+        root.left = self.invertTree(root.left)
+        return root

jump-game/8804who.py

@@ -0,0 +1,10 @@
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        max_pos = 0
+        for i in range(len(nums)):
+            if max_pos < i:
+                return False
+            if i+nums[i] > max_pos:
+                max_pos = i+nums[i]
+        return True
+

merge-k-sorted-lists/8804who.py

@@ -0,0 +1,29 @@
+import heapq
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        heap = []
+
+        for node in lists:
+            if not node:
+                continue
+            while True:
+                heapq.heappush(heap, node.val)
+                node = node.next
+                if not node:
+                    break
+
+        def makeNode():
+            node = ListNode()
+            if not heap:
+                return None
+            node.val = heapq.heappop(heap)
+            node.next = makeNode()
+            return node
+
+        return makeNode()
+

search-in-rotated-sorted-array/8804who.py

@@ -0,0 +1,21 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        start, end = 0, len(nums)-1
+        while start <= end:
+            mid = start+(end-start)//2
+
+            if nums[mid] == target:
+                return mid
+
+            if nums[start] <= nums[mid]:
+                if nums[start] <= target < nums[mid]:
+                    end = mid-1
+                else:
+                    start = mid+1
+            else:
+                if nums[mid] < target <= nums[end]:
+                    start = mid+1
+                else:
+                    end = mid-1
+        return -1
+