[Lyla] Week 13

insert-interval/pmjuu.py

@@ -0,0 +1,32 @@
+'''
+시간 복잡도: O(n)
+공간 복잡도: O(n)
+'''
+from typing import List
+
+
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        n = len(intervals)
+        start, end = newInterval
+        i = 0
+        result = []
+
+        # before merging
+        while i < n and intervals[i][1] < start:
+            result.append(intervals[i])
+            i += 1
+
+        # merge
+        while i < n and intervals[i][0] <= end:
+            start = min(start, intervals[i][0])
+            end = max(end, intervals[i][1])
+            i += 1
+        result.append([start, end])
+
+        # after merging
+        while i < n:
+            result.append(intervals[i])
+            i += 1
+
+        return result

kth-smallest-element-in-a-bst/pmjuu.py

@@ -0,0 +1,25 @@
+'''
+시간 복잡도: O(n)
+공간 복잡도: O(n)
+'''
+from typing import Optional
+
+# 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 kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        def inorder_traversal(node):
+            if node:
+                inorder_traversal(node.left)
+                values.append(node.val)
+                inorder_traversal(node.right)
+
+        values = []
+        inorder_traversal(root)
+
+        return values[k - 1]

lowest-common-ancestor-of-a-binary-search-tree/pmjuu.py

@@ -0,0 +1,22 @@
+'''
+시간 복잡도: O(h) (h = 트리 높이)
+공간 복잡도: O(1)
+'''
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        node = root
+
+        while node:
+            if p.val < node.val and q.val < node.val:
+                node = node.left
+            elif node.val < p.val and node.val < q.val:
+                node = node.right
+            else:
+                return node

meeting-rooms/pmjuu.py

@@ -0,0 +1,52 @@
+'''
+시간 복잡도: O(n log n)
+공간 복잡도: O(1)
+'''
+import unittest
+from typing import List
+
+class Interval(object):
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+
+class Solution:
+    def can_attend_meetings(self, intervals: List[Interval]) -> bool:
+        intervals.sort(key=lambda x:x.start)
+
+        for i in range(len(intervals) - 1):
+            if intervals[i + 1].start < intervals[i].end:
+                return False
+
+        return True
+
+class TestCanAttendMeetings(unittest.TestCase):
+    def setUp(self):
+        self.solution = Solution()
+
+    def test_case_1(self):
+        intervals = [Interval(0, 30), Interval(5, 10), Interval(15, 20)]
+        self.assertFalse(self.solution.can_attend_meetings(intervals))
+
+    def test_case_2(self):
+        intervals = [Interval(5, 8), Interval(9, 15)]
+        self.assertTrue(self.solution.can_attend_meetings(intervals))
+
+    def test_case_3(self):
+        intervals = []
+        self.assertTrue(self.solution.can_attend_meetings(intervals))
+
+    def test_case_4(self):
+        intervals = [Interval(1, 5)]
+        self.assertTrue(self.solution.can_attend_meetings(intervals))
+
+    def test_case_5(self):
+        intervals = [Interval(0, 5), Interval(5, 10), Interval(10, 15)]
+        self.assertTrue(self.solution.can_attend_meetings(intervals))
+
+    def test_case_6(self):
+        intervals = [Interval(1, 3), Interval(2, 6), Interval(8, 10)]
+        self.assertFalse(self.solution.can_attend_meetings(intervals))
+
+if __name__ == "__main__":
+    unittest.main()