Merge pull request #1073 from dusunax/main

[SunaDu] Week 13

Author: dusunax

insert-interval/dusunax.py

@@ -0,0 +1,60 @@
+'''
+# 57. Insert Interval
+
+## A. insert first, merge later
+- use binary search to find the index of the new interval.(bisect_left)
+- insert the new interval into the list.
+- iterate through the list and merge the intervals.
+
+## B. insert, merge, insert
+- inserting the intervals into the result list until finding the correct index of the new interval.
+- merge the overlapping intervals than insert the newInterval into the result list.
+- insert the remaining intervals into the result list.
+'''
+class Solution:
+    '''
+    # A. insert first, merge later
+    - TC: O(n)
+    - SC: O(n)
+    '''
+    def insertUsingBisectLeftToFindIndex(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        start_idx = bisect_left([interval[0] for interval in intervals], newInterval[0]) # TC: O(log n)
+        
+        intervals.insert(start_idx, newInterval) # TC: O(n)
+
+        result = []  # SC: O(n)
+        for interval in intervals: # TC: O(n)
+            if not result or result[-1][1] < interval[0]:
+                result.append(interval)
+            else:
+                result[-1][1] = max(result[-1][1], interval[1])
+            
+        return result
+    
+    '''
+    # B. insert, merge, insert
+    - TC: O(n)
+    - SC: O(n)
+    '''
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        result = [] # SC: O(n)
+        i = 0
+        n = len(intervals)
+
+        # 1. insert until finding the correct index of newInterval
+        while i < n and intervals[i][1] < newInterval[0]: # TC: O(n)
+            result.append(intervals[i])
+            i += 1
+
+        # merge overapping intervals & insert newInterval
+        while i < n and intervals[i][0] <= newInterval[1]: # TC: O(n)
+            newInterval[0] = min(newInterval[0], intervals[i][0])
+            newInterval[1] = max(newInterval[1], intervals[i][1])
+            i += 1
+        result.append(newInterval)
+        
+        while i < n: # TC: O(n)
+            result.append(intervals[i])
+            i += 1
+        
+        return result

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

@@ -0,0 +1,63 @@
+'''
+# 230. Kth Smallest Element in a BST
+
+BST에서 k 번째의 값 찾기
+
+- Inorder Traversal: 이진 탐색 트리를 중위 순회하면 트리의 모든 값을 오름 차순으로 방문할 수 있다.
+  - 중위 순회: 왼쪽 자식 -> 루트 -> 오른쪽 자식
+- k번째 가장 작은 값을 구하면 방문을 중단한다.
+'''
+class Solution:
+    '''
+    ## 1. count를 사용하여 k번째 가장 작은 값을 찾는 방법
+    - 중위 순회를 하면서 노드를 방문하고, 방문한 횟수를 세서 k번째 값을 찾습니다.
+    - 순회를 중단하는 방식으로 메모리를 절약합니다.
+    TC: O(n)
+    SC: O(h) - 재귀 호출 스택 공간 (h는 트리의 높이)
+    '''
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        count = 0
+        result = None
+
+        def inorder(node):
+            nonlocal count, result 
+
+            if not node:
+                return
+            
+            inorder(node.left)
+
+            count += 1
+            if count == k:
+                result = node.val
+                return
+
+            inorder(node.right)
+        
+        inorder(root)
+
+        return result
+    
+    '''
+    ## 2. 순회 결과를 리스트에 저장하여 가장 작은 값을 찾는 방법
+    - 순회 결과를 리스트에 저장하여 가장 작은 값을 찾습니다.
+    - 메모리를 더 많이 사용하지만, 코드가 더 간결합니다.
+    TC: O(n)
+    SC: O(n)
+    '''
+    def kthSmallestWithResultList(self, root: Optional[TreeNode], k: int) -> int:
+        result = []
+
+        def inorder(node):
+            if not node:
+                return
+            if len(result) > k:
+                return node
+
+            inorder(node.left)
+            result.append(node.val)
+            inorder(node.right)
+        
+        inorder(root)
+
+        return result[k - 1]

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

@@ -0,0 +1,65 @@
+'''
+# 235. Lowest Common Ancestor of a Binary Search Tree
+
+## 기본적인 LCA 찾기 문제이다.
+- LCA는 두 노드의 최저 공통 조상이다.
+- 두 노드를 descendants로 가진 노드이며, 두 노드도 포함된다.
+
+### LCA와 이진 탐색 트리 BST, 일반 이진트리 BT
+BST는 부모의 정렬 조건이 있고, BT는 부모의 정렬 조건이 없다.
+BST는 이진 탐색을 진행하지만, BT는 구조적 단서가 없으므로 모든 경로를 탐색해야 한다.(Post-order DFS)
+따라서 BT의 시간 복잡도는 O(N)이다.
+
+- BT의 LCA 찾기 문제: [236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)
+
+## Approach
+- p, q가 현재 노드보다 작으면, 왼쪽으로 이동
+- p, q가 현재 노드보다 크면, 오른쪽으로 이동
+- p, q가 현재 노드에서 양쪽으로 분리되어 나간다면, 현재 노드가 LCA이다.
+
+### 재귀와 반복문
+재귀는 함수 호출마다 call stack 프레임이 생긴다.(push/pop)
+오버헤드가 발생하여 공간 복잡도가 O(H)이다.
+인터프리터는 특성상 재귀 성능 호출이 비교적 좋지 않다.
+또한 트리가 매우 깊어서 H가 큰 경우, Stack Overflow 발생 가능성이 있다.
+
+## 시간 & 공간 복잡도
+
+```
+TC: O(H)
+SC: O(1)
+```
+
+### TC is O(H):
+- 트리의 높이만큼 반복문을 돌리므로, O(H)이다.
+
+### SC is O(1):
+- 추가 공간 사용 없음
+- 만약 재귀로 풀이한다면, 함수 호출마다 콜스택 공간이 생기므로 O(H)이다.
+'''
+class Solution:
+    '''
+    반복문 Top-down
+    TC: O(H)
+    SC: O(1)
+    '''
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        while root:
+            if p.val < root.val and q.val < root.val:
+                root = root.left
+            elif p.val > root.val and q.val > root.val:
+                root = root.right
+            else:
+                return root 
+    '''
+    재귀 Bottom-up
+    TC: O(H)
+    SC: O(H)
+    '''
+    def lowestCommonAncestorBottomUp(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if p.val < root.val and q.val < root.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        elif p.val > root.val and q.val > root.val:
+            return self.lowestCommonAncestor(root.right, p, q)
+        else:
+            return root

meeting-rooms/dusunax.py

@@ -0,0 +1,32 @@
+'''
+# 252. Meeting Rooms
+
+- 각 회의는 시작 시간과 종료 시간을 가진다.
+- 회의 시간이 겹치는 경우 회의를 진행할 수 없다.
+- 회의 시간이 겹치지 않는 경우 회의를 진행할 수 있다.
+
+## 풀이
+
+- intervals를 시작 시간으로 정렬한다.
+- 시간 겹침 여부를 확인한다.
+- 겹치는 경우 False, 겹치지 않는 경우 True를 반환한다.
+
+## 시간 복잡도
+
+### TC is O(n log n)
+- 정렬 시간: O(n log n)
+- 겹침 여부 확인 시간: O(n)
+
+### SC is O(1)
+- 추가 사용 공간 없음
+
+'''
+class Solution:
+    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
+        intervals.sort(key=lambda x: x[0])
+
+        for i in range(1, len(intervals)):
+            if intervals[i][0] < intervals[i-1][1]:
+                return False
+            
+        return True