[yuseok89] WEEK 10 Solutions

[yuseok89]

답안 제출 문제

• Course Schedule #261
• Invert Binary Tree #226
• Jump Game #276
• Merge K Sorted Lists #286
• Search In Rotated Sorted Array #246

작성자 체크 리스트

• Projects의 오른쪽 버튼(▼)을 눌러 확장한 뒤, Week를 현재 주차로 설정해주세요.
• 문제를 모두 푸시면 프로젝트에서 Status를 In Review로 설정해주세요.
• 코드 검토자 1분 이상으로부터 승인을 받으셨다면 PR을 병합해주세요.

검토자 체크 리스트

Important

본인 답안 제출 뿐만 아니라 다른 분 PR 하나 이상을 반드시 검토를 해주셔야 합니다!

• 바로 이전에 올라온 PR에 본인을 코드 리뷰어로 추가해주세요.
• 본인이 검토해야하는 PR의 답안 코드에 피드백을 주세요.
• 토요일 전까지 PR을 병합할 수 있도록 승인해주세요.

[dalestudy]

🏷️ 알고리즘 패턴 분석

invert-binary-tree/yuseok89.py

# TC: O(N)
# SC: 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:

        if not root:
            return None
        else:
            cur_node = TreeNode(root.val)

            cur_node.right = self.invertTree(root.left)
            cur_node.left = self.invertTree(root.right)

            return cur_node

• 패턴: Binary Search, Depth-First Search, Divide and Conquer
• 설명: 이 코드는 이진트리의 자식 노드를 서로 바꿔 트리를 반전시키는 재귀적 분할 처리로서, DFS 방식으로 각 서브트리를 처리하며 분할해서 해결하는 패턴을 사용합니다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(N)	O(n)	✅
Space	O(N)	O(h)	❌

피드백: 트리의 각 노드를 한 번씩 방문하여 자식 정보를 교환하므로 시간 복잡도는 O(n)이고, 재귀 호출 스택의 깊이에 비례하는 공간 복잡도 O(h)이다.

개선 제안: 현재 구현이 적절해 보입니다.

[dalestudy]

📊 yuseok89 님의 학습 현황

이번 주 제출 문제

문제	난이도	유형 분석
course-schedule	Medium	✅ 의도한 유형
invert-binary-tree	Easy	✅ 의도한 유형
jump-game	Medium	✅ 의도한 유형
merge-k-sorted-lists	Hard	✅ 의도한 유형
search-in-rotated-sorted-array	Medium	✅ 의도한 유형

누적 학습 요약

• 풀이한 문제: 44 / 75개
• 이번 주 유형 일치율: 100% (5문제 중 5문제 일치)

문제 풀이 현황

카테고리	진행도	완료
Array	■■■■■■□	9 / 10 (Medium 6, Easy 3)
Dynamic Programming	■■■■■■□	9 / 11 (Easy 1, Medium 8)
String	■■■■■■□	8 / 10 (Medium 4, Hard 1, Easy 3)
Matrix	■■■■■□□	3 / 4 (Medium 3)
Binary	■■■■□□□	3 / 5 (Easy 2, Medium 1)
Graph	■■■■□□□	4 / 8 (Medium 4)
Linked List	■■■■□□□	3 / 6 (Easy 3)
Heap	■■□□□□□	1 / 3 (Medium 1)
Tree	■■□□□□□	4 / 14 (Medium 3, Easy 1)
Interval	□□□□□□□	0 / 5 ← 아직 시작 안 함

---

🤖 이 댓글은 GitHub App을 통해 자동으로 작성되었습니다.

🔢 API 사용량 (gpt-5-nano)

요청	입력 토큰	출력 토큰	합계	비용
1	347	37	384	$0.000032
2	1,876	192	2,068	$0.000171
3	1,805	208	2,013	$0.000173
합계	4,028	437	4,465	$0.000376

[alphaorderly]

앞의 if가 이미 리턴을 하고 있어서 else 를 크게 쓰지 않으셔도 되지 않을까? 라는 생각이 듭니다!
또한 cur_node 를 만들지 않으시고 root를 직접 바꾸셔도 정답처리 되실거에요!

[yuseok89]

좋네요 !
감사합니다 🙏

[dalestudy]

🏷️ 알고리즘 패턴 분석

course-schedule/yuseok89.py

# TC: O(N)
# SC: O(N)
class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:

        prereq_dict = defaultdict(set)
        in_deg = [0] * numCourses
        is_completed = set()

        for prereq in prerequisites:
            prereq_dict[prereq[1]].add(prereq[0])
            in_deg[prereq[0]] += 1

        while True:
            course_list = []

            for idx in range(numCourses):
                if idx not in is_completed and in_deg[idx] == 0:
                    course_list.append(idx)

            if len(course_list) == 0:
                break

            for course in course_list:
                is_completed.add(course)

                for nxt in prereq_dict[course]:
                    in_deg[nxt] -= 1

        for idx in range(numCourses):
            if idx not in is_completed:
                return False

        return True

• 패턴: Depth-First Search, Greedy, Dynamic Programming, Hash Map / Hash Set
• 설명: 그래프의위상정렬 아이디어로 선행관계 제거하며 사이클이 있는지 확인하는 패턴으로 동작합니다. 구현은 indegree 기반으로 0인 노드를 차례대로 처리하는 방식이라 위상정렬의 전형적 흐름을 보이고, 부트스트랩 과정에서 우선순위를 선택하는 점이 그리디하게 해석될 수 있습니다. 또한 방문 여부를 집합으로 관리합니다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(N)	O(V + E)	❌
Space	O(N)	O(V + E)	❌

피드백: 진입 차수 배열과 그래프 표현으로 모든 정점이 차수 0이 되는 시점을 차례로 제거하며 사이클 여부를 판단합니다.

개선 제안: 현재 구현이 적절해 보입니다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

invert-binary-tree/yuseok89.py

# TC: O(N)
# SC: O(logN)
# 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 = self.invertTree(root.right), self.invertTree(root.left)

        return root

• 패턴: Binary Search, Depth First Search, Divide and Conquer
• 설명: 주어진 코드는 재귀적으로 트리의 좌우 자식을 서로 뒤집는 방식으로 동작합니다. 분할된 서브트리에 대해 재귀적으로 처리하고, 각 재귀에서 좌우를 교환하는 과정이 Divide and Conquer 및 DFS 형태를 보입니다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(N)	O(n)	✅
Space	O(logN)	O(h)	❌

피드백: 모든 노드를 한 번씩 방문하고 호출 스택 깊이는 트리의 높이와 같음

개선 제안: 현재 구현이 적절해 보입니다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

jump-game/yuseok89.py

# TC: O(N)
# SC: O(1)
class Solution:
    def canJump(self, nums: List[int]) -> bool:

        n = len(nums)
        m, idx = 0, 0

        while idx <= m and idx < n:
            m = max(m, idx + nums[idx])
            idx += 1

        return m >= n - 1

• 패턴: Greedy, Two Pointers
• 설명: 이 코드는 현재 인덱스까지 도달 가능한 최대 도달 위치를 추적하며, 각 위치에서 앞으로 도달할 수 있는 범위를 확장하는 방식으로 최댓값을 갱신한다. 단일 루프(선형)로 가능한지 여부를 판단하므로 Greedy 패턴에 속하고, 양 끝을 매개로 하는 탐색의 흐름이 Two Pointers와 유사하게 동작한다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(N)	O(n)	✅
Space	O(1)	O(1)	✅

피드백: 그리디 방식으로 한 번의 순회로 해결 가능하고, 추가 공간은 상수에 가깝습니다.

개선 제안: 현재 구현이 적절해 보입니다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

merge-k-sorted-lists/yuseok89.py

# TC: O(NlogN)
# SC: O(N)
# 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]:

        ret_head = ListNode()
        cur = ret_head

        heap = []
        for i, node in enumerate(lists):
            if node is not None:
                heapq.heappush(heap, (node.val, i, node))

        while heap:
            val, i, node = heapq.heappop(heap)
            cur.next = node
            cur = cur.next

            if node.next is not None:
                heapq.heappush(heap, (node.next.val, i, node.next))

        return ret_head.next

• 패턴: Heap / Priority Queue, Divide and Conquer
• 설명: 여러 개의 정렬된 리스트를 힙으로 병합하는 방식으로 최소 원소를 매번 꺼내는 패턴이다. 각 리스트 원소를 힙에 담아 순차적으로 연결하므로 우선순위 큐의 활용이 핵심이다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(NlogN)	O(N log k)	❌
Space	O(N)	O(k)	❌

피드백: 총 노드 수를 N이라 할 때 각 삽입/삭제가 로그 k 이므로 전체 시간은 O(N log k), 힙은 리스트 수 k 만큼 사용

개선 제안: 현재 구현이 적절해 보입니다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

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

# TC: O(logN)
# SC: O(1)
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        n = len(nums)
        l, r = 0, n - 1

        while l < r:
            m = (l + r) // 2

            if nums[m] > nums[r]:
                l = m + 1
            else:
                r = m

        if target >= nums[0]:
            r = (l + n - 1) % n
            l = 0
        else:
            r = n - 1

        while l <= r:
            m = (l + r) // 2

            if nums[m] == target:
                return m
            elif nums[m] < target:
                l = m + 1
            else:
                r = m - 1

        return -1

• 패턴: Binary Search, Two Pointers
• 설명: 구현은 회전된 정렬 배열에서 목표값을 이진 탐색으로 찾는 과정을 두 단계로 구성합니다. 먼저 회전 위치를 찾기 위해 이진 탐색의 특성을 이용하고, 그 후 구간을 나누어 이진 탐색으로 타깃을 검색합니다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(logN)	O(log n)	✅
Space	O(1)	O(1)	✅

피드백: 회전 여부를 판단해 분할 구간을 좁혀가며 이분 탐색을 수행합니다.

개선 제안: 현재 구현이 적절해 보입니다.

[alphaorderly]

정말 깔끔하게 잘 해결해 주셨는데요!
제 생각에 is_completed에 수료를 완료한 과목의 갯수만 기록해도 가능하지 않을까? 라는 생각이 들었어요
어떤지 한번 생각해보시면 더욱 좋을것 같습니다!

[yuseok89]

덕분에 많은 공부가 되네요
감사합니다 !

[alphaorderly]

상당히 깔끔한 그리디네요! 잘 보고 갑니다

[alphaorderly]

깔끔하게 잘 해결해 주셨는데요, 해당 문제는 단일 while로도 해결 가능하답니다!
한번 시도해보시면 좋을것 같아요

[yuseok89]

그렇네요 감사합니다 !

[JeonJe]

r = (l + n - 1) % n에서 % n의 역할이 조금 더 쉽게 읽히면 좋겠다는 생각이 들었습니다. 회전이 없어서 피벗이 0일 때 l - 1 = -1이 되는 걸 n - 1로 돌려막는 용도로 보이는데, 처음 읽으면 왜 모듈러가 나오는지 한 번 되짚어봐야 하더라고요. 첫 루프가 끝난 l에 이름을 붙이고 두 분기에서 l, r을 둘 다 명시해주면 코드가 좀 더 길어지더라도 읽기는 쉬워질 것 같아요. 예를 들어

  pivot = l
  if target >= nums[0]:
      l, r = 0, (pivot - 1 if pivot else n - 1)
  else:
      l, r = pivot, n - 1

[JeonJe]

라운드마다 for idx in range(numCourses)로 전체 과목을 다시 훑고 있어서, 라운드 수 × 과목 수만큼 계산이 예상됩니다. 선수관계가 0 → 1 → 2 → ...처럼 한 줄로 이어지면 라운드가 과목 수만큼 생기는데, 제약 상한인 2000과목이면 라운드가 2001회 돌고 스캔이 400만 번 일어나서 O(V² + E)에 가까울 것 같아요.

in_deg가 감소하는 그 자리에서 0이 됐는지 바로 판정해두면 "다음에 처리할 과목을 찾는" 단계가 통째로 없어지고, 각 과목과 각 간선을 한 번씩만 보게 되어 O(V + E)로 줄일 수 있지 않을까 합니다.

[yuseok89]

덕분에 많은 공부가 되네요
감사합니다 !

[dalestudy]

🏷️ 알고리즘 패턴 분석

course-schedule/yuseok89.py

# TC: O(V + E)
# SC: O(V + E)
class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:

        graph = [[] for _ in range(numCourses)]
        in_deg = [0] * numCourses

        for nxt, prev in prerequisites:
            graph[prev].append(nxt)
            in_deg[nxt] += 1

        queue = deque(idx for idx in range(numCourses) if in_deg[idx] == 0)
        completed = 0

        while queue:
            course = queue.popleft()
            completed += 1

            for nxt in graph[course]:
                in_deg[nxt] -= 1
                if in_deg[nxt] == 0:
                    queue.append(nxt)

        return completed == numCourses

• 패턴: BFS, Topological Sort
• 설명: 그래프의 위상 정렬(BFS 기반 큐를 이용한 순차 방문)로 사이클 여부를 판단합니다. 진입 차수, 인접 리스트를 활용해 순서대로 노드를 제거하며 모든 정점을 방문하면 가능합니다.

📊 시간/공간 복잡도 분석

ℹ️ 이 파일에는 2가지 풀이가 포함되어 있어 각각 분석합니다.

풀이 1: Solution.canFinish — Time: ❌ O(V + E) → O(N + E) / Space: ❌ O(V + E) → O(N + E)

	유저 분석	실제 분석	결과
Time	O(V + E)	O(N + E)	❌
Space	O(V + E)	O(N + E)	❌

피드백: 그래프를 구성하고 진입 차수로 큐를 관리하면서 모든 노드를 한 번씩 처리한다.

개선 제안: 현재 구현이 적절해 보입니다.

풀이 2: Solution.canFinish — Time: ❌ O(V + E) → O(N + E) / Space: ❌ O(V + E) → O(N + E)

	유저 분석	실제 분석	결과
Time	O(V + E)	O(N + E)	❌
Space	O(V + E)	O(N + E)	❌

피드백: 그래프를 구성하고 진입 차수로 큐를 관리하면서 모든 노드를 한 번씩 처리한다.

개선 제안: 현재 구현이 적절해 보입니다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

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

# TC: O(logN)
# SC: O(1)
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        n = len(nums)
        l, r = 0, n - 1


        while l <= r:
            m = (l + r) // 2

            if nums[m] == target:
                return m

            if nums[l] <= nums[m]:
                if nums[l] <= target < nums[m]:
                    r = m - 1
                else:
                    l = m + 1
            else:
                if nums[m] < target <= nums[r]:
                    l = m + 1
                else:
                    r = m - 1

        return -1

• 패턴: Binary Search, Monotonic Stack, Divide and Conquer
• 설명: 회전된 정렬 배열에서 중간값 비교로 범위를 절반씩 줄여 탐색하는 이진 탐색의 변형으로, 배열의 단조성(각 부분이 정렬됨)을 이용해 target 위치를 추정합니다. 따라서 주 패턴은 Binary Search이며, 배열의 구간 축소가 핵심입니다.

📊 시간/공간 복잡도 분석

ℹ️ 이 파일에는 2가지 풀이가 포함되어 있어 각각 분석합니다.

풀이 1: Solution.search — Time: ✅ O(logN) → O(log n) / Space: ✅ O(1) → O(1)

	유저 분석	실제 분석	결과
Time	O(logN)	O(log n)	✅
Space	O(1)	O(1)	✅

피드백: 회전된 배열에서도 중복 없이 목표를 찾기 위해 양 끝과 중간 값을 비교하며 구간을 절반으로 축소한다.

개선 제안: 현재 구현이 적절해 보입니다.

풀이 2: Solution.search — Time: ✅ O(logN) → O(log n) / Space: ✅ O(1) → O(1)

	유저 분석	실제 분석	결과
Time	O(logN)	O(log n)	✅
Space	O(1)	O(1)	✅

피드백: 회전된 배열에서도 중복 없이 목표를 찾기 위해 양 끝과 중간 값을 비교하며 구간을 절반으로 축소한다.

개선 제안: 현재 구현이 적절해 보입니다.