[hu6r1s] Week 10 Solutions

course-schedule/hu6r1s.py

@@ -0,0 +1,37 @@
+from collections import defaultdict
+
+class Solution:
+    # def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+    #     for pre_x, pre_y in prerequisites:
+    #         if [pre_y, pre_x] in prerequisites:
+    #             return False
+    #     return True
+
+
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        d = defaultdict(list)
+
+        for x, y in prerequisites:
+            d[x].append(y)
+
+        visited = set()
+        finished = set()
+
+        def dfs(course):
+            if course in visited:
+                return False
+            if course in finished:
+                return True
+
+            visited.add(course)
+            for v in d[course]:
+                if not dfs(v):
+                    return False
+            visited.remove(course)
+            finished.add(course)
+            return True
+
+        for course in list(d):
+            if not dfs(course):
+                return False
+        return True

invert-binary-tree/hu6r1s.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
+        root.left, root.right = root.right, root.left
+        self.invertTree(root.left)
+        self.invertTree(root.right)
+        return root

jump-game/hu6r1s.py

@@ -0,0 +1,29 @@
+class Solution:
+    # def canJump(self, nums: List[int]) -> bool:
+    #     if len(nums) == 1:
+    #         return True
+
+    #     idx = 0
+    #     while idx < len(nums):
+    #         if idx == len(nums) - 1:
+    #             return True
+    #         if nums[idx] == 0:
+    #             return False
+
+    #         idx += nums[idx]
+    #     return False
+
+
+    def canJump(self, nums: List[int]) -> bool:
+        maxReach = 0
+        for i, num in enumerate(nums):
+            if i > maxReach:
+                return False
+            maxReach = max(maxReach, i + num)
+        return True
+"""
+while idx < len(nums)
+if nums[idx] == 0
+break
+idx += nums[idx]
+"""

merge-k-sorted-lists/hu6r1s.py

@@ -0,0 +1,69 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+import heapq
+class Solution:
+    """
+    브루트포스
+    """
+    # def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+    #     dummy = curr = ListNode()
+    #     while any(lists):
+    #         val, idx = min((li.val, idx) for idx, li in enumerate(lists) if li)
+    #         curr.next = ListNode(val)
+    #         curr = curr.next
+    #         lists[idx] = lists[idx].next
+    #     return dummy.next
+
+    """
+    최소힙 활용
+    """
+    # def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+    #     heap = [(li.val, idx) for idx, li in enumerate(lists) if li]
+    #     heapq.heapify(heap)
+
+    #     dummy = curr = ListNode()
+    #     while heap:
+    #         val, idx = heapq.heappop(heap)
+    #         curr.next = ListNode(val)
+    #         curr = curr.next
+
+    #         lists[idx] = lists[idx].next
+    #         if lists[idx]:
+    #             heapq.heappush(heap, (lists[idx].val, idx))
+    #     return dummy.next
+
+    """
+    분할정복과 재귀 활용
+    """
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        def mergeTwoLists(li1, li2):
+            dummy = node = ListNode(-1)
+            while li1 and li2:
+                if li1.val < li2.val:
+                    node.next = li1
+                    li1 = li1.next
+                else:
+                    node.next = li2
+                    li2 = li2.next
+                node = node.next
+            node.next = li1 if li1 else li2
+            return dummy.next
+
+        if len(lists) == 0:
+            return None
+
+        def dfs(low, high):
+            if low == high:
+                return lists[low]
+            if low + 1 == high:
+                return mergeTwoLists(lists[low], lists[high])
+
+            mid = (low + high) // 2
+            li1 = dfs(low, mid)
+            li2 = dfs(mid + 1, high)
+            return mergeTwoLists(li1, li2)
+
+        return dfs(0, len(lists) - 1)

search-in-rotated-sorted-array/hu6r1s.py

@@ -0,0 +1,3 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        return nums.index(target) if target in nums else -1