[okyungjin] WEEK 14 Solutions (#2866)

* 338. Counting Bits

* 102. Binary Tree Level Order Traversal

* 213. House Robber II

* 252. Meeting Rooms

* 253. Meeting Rooms II

Author: okyungjin

binary-tree-level-order-traversal/okyungjin.py

@@ -0,0 +1,38 @@
+# 102. Binary Tree Level Order Traversal
+# https://leetcode.com/problems/binary-tree-level-order-traversal/
+
+"""
+문제:
+    - 이진 트리의 root가 주어질 때, 노드 값을 레벨 순서(왼쪽에서 오른쪽, 위에서 아래)로 묶어서 반환한다
+    - 결과는 레벨별 값 리스트의 리스트 (예: [[3], [9, 20], [15, 7]])
+    - 0 <= 노드 수 <= 2000
+
+복잡도:
+    n: 노드의 개수
+    Time: O(n)
+    Space: O(n)
+"""
+# 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: TreeNode | None) -> list[list[int]]:
+        if not root:
+            return []
+
+        ans = []
+        q = deque([(0, root)])
+        while q:
+            level, node = q.popleft()
+            if len(ans) == level:
+                ans.append([])
+            ans[level].append(node.val)
+            if node.left:
+                q.append((level + 1, node.left))
+            if node.right:
+                q.append((level + 1, node.right))
+
+        return ans

counting-bits/okyungjin.py

@@ -0,0 +1,25 @@
+# 338. Counting Bits
+# https://leetcode.com/problems/counting-bits/
+
+"""
+문제:
+    - 정수 n이 주어질 때, 0부터 n까지 각 i에 대해 i의 이진 표현에 포함된 1의 개수를 구한다
+    - 결과는 길이 n + 1인 배열 ans로 반환한다 (ans[i] = i의 1의 개수)
+    - 0 <= n <= 10^5
+
+복잡도:
+    n: 입력 정수 n
+    Time: O(n)
+    Space: O(1)
+"""
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        dp = [0]
+        offset = 1
+
+        for num in range(1, n + 1):
+            if num == offset * 2:
+                offset = num
+            dp.append(dp[num - offset] + 1)
+
+        return dp

house-robber-ii/okyungjin.py

@@ -0,0 +1,31 @@
+# 213. House Robber II
+# https://leetcode.com/problems/house-robber-ii/
+
+"""
+문제:
+    - 집들이 원형으로 배치되어 있고, 각 집에는 돈이 들어 있다.
+    - 인접한 두 집은 같은 날 털 수 없다.
+    - 첫 집과 마지막 집도 인접한 것으로 본다.
+    - 털 수 있는 최대 금액을 구한다.
+
+복잡도:
+    n: `nums`의 길이
+    Time: O(n)
+    Space: O(1)
+"""
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n == 1:
+            return nums[0]
+
+        def steel(start, end):
+            prev2, prev1 = 0, 0
+            for i in range(start, end):
+                cur = max(prev2 + nums[i], prev1)
+                prev2, prev1 = prev1, cur
+            return prev1
+
+        s1 = steel(0, n - 1)
+        s2 = steel(1, n)
+        return max(s1, s2)

meeting-rooms-ii/okyungjin.py

@@ -0,0 +1,40 @@
+# 253. Meeting Rooms II
+# https://www.lintcode.com/problem/919/
+
+"""
+문제:
+    - 회의 시간 구간 `[start, end)` 목록이 주어진다. (start < end)
+    - 모든 회의를 진행하는 데 필요한 최소 회의실 개수를 구한다.
+    - 한 회의가 끝나는 시각에 다른 회의가 시작하는 것은 충돌이 아니다.
+
+복잡도:
+    n: `intervals`의 길이
+    Time: O(n log n)
+    Space: O(n)
+"""
+import heapq
+
+"""
+Definition of Interval:
+class Interval(object):
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+"""
+class Solution:
+    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
+        pq = []
+        intervals.sort(key=lambda x: x.start)
+
+        for cur in intervals:
+            if pq:
+                earliest_end = pq[0]  # 열린 방들 중 가장 빨리 끝나는 시각
+                if cur.start >= earliest_end:
+                    heapq.heappop(pq)
+            heapq.heappush(pq, cur.end)
+
+        return len(pq)
+
+# print(Solution().min_meeting_rooms([Interval(0, 30), Interval(5, 10), Interval(15, 20)]))  # 2
+# print(Solution().min_meeting_rooms([Interval(0, 5), Interval(5, 10), Interval(10, 15)]))  # 1
+# print(Solution().min_meeting_rooms([Interval(1, 10), Interval(2, 7), Interval(3, 9), Interval(8, 12)]))  # 3

meeting-rooms/okyungjin.py

@@ -0,0 +1,32 @@
+# 252. Meeting Rooms
+# https://www.lintcode.com/problem/920/
+
+"""
+문제:
+    - 회의 시간 구간 `[start, end)` 목록이 주어진다. (start < end)
+    - 한 사람이 모든 회의에 참석할 수 있는지 True/False로 반환한다.
+    - 한 회의가 끝나는 시각에 다른 회의가 시작하는 것은 충돌이 아니다.
+
+복잡도:
+    n: `intervals`의 길이
+    Time: O(n log n)
+    Space: O(n)
+"""
+
+"""
+Definition of Interval:
+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.end)
+
+        last_end = 0
+        for interval in intervals:
+            if interval.start < last_end:
+                return False
+            last_end = interval.end
+        return True