[alphaorderly] WEEK 10 Solutions

[alphaorderly]

답안 제출 문제

• 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]

🏷️ 알고리즘 패턴 분석

course-schedule/alphaorderly.py

"""
시간복잡도: O(n + m)
공간복잡도: O(n + m)

- 각 과목의 진입 차수(in_degree)를 계산한다.
- 각 과목의 인접 리스트(graph)를 구성한다.
- 진입 차수가 0인 과목을 큐에 추가한다.
- 큐에서 과목을 하나씩 꺼내고, 그 과목을 선수과목으로 가지는 모든 과목의 진입 차수를 1씩 감소시킨다.
- 진입 차수가 0이 된 과목을 큐에 추가한다.
- 큐를 모두 처리한 후, 방문한 과목의 수가 전체 과목 수와 같은지 확인한다.
"""
class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        in_degree = [0] * numCourses
        graph = defaultdict(list)
        entered_courses = 0

        for s, e in prerequisites:
            in_degree[s] += 1
            graph[e].append(s)

        queue = deque([])

        for course, count in enumerate(in_degree):
            if count == 0:
                queue.append(course)
                entered_courses += 1

        while queue:
            course = queue.popleft()

            for next_course in graph[course]:
                in_degree[next_course] -= 1
                if in_degree[next_course] == 0:
                    entered_courses += 1
                    queue.append(next_course)

        return entered_courses == numCourses

• 패턴: Breadth-First Search, Topological Sort, Hash Map / Hash Set
• 설명: 그래프의 위상 정렬 방식으로 진입 차수를 이용해 순서를 해결한다. 큐를 이용한 BFS 방식으로 사이클 여부를 판단하고, 선수과목 그래프를 구성한다.

📊 시간/공간 복잡도 분석

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

풀이 1: Solution.canFinish — Time: O(n + m) / Space: O(n + m)

	복잡도
Time	O(n + m)
Space	O(n + m)

피드백: 그래프 인접 리스트와 진입 차수를 이용해 사이클 여부를 판단하는 표준 풀이이다.

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

풀이 2: Solution.canFinish — Time: O(n + m) / Space: O(n + m)

	복잡도
Time	O(n + m)
Space	O(n + m)

피드백: 임의의 추가 제약 없이도 동작하는 위상 정렬 풀이이다.

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

💡 풀이에 시간/공간 복잡도를 주석으로 남겨보세요!

[dalestudy]

📊 alphaorderly 님의 학습 현황

이번 주 제출 문제

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

누적 학습 요약

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

문제 풀이 현황

카테고리	진행도	완료
Array	■■■■■■□	9 / 10 (Medium 6, Easy 3)
String	■■■■■■□	9 / 10 (Medium 5, Hard 1, Easy 3)
Dynamic Programming	■■■■■■□	9 / 11 (Easy 1, Medium 8)
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	2,429	236	2,665	$0.000216

[dalestudy]

🏷️ 알고리즘 패턴 분석

invert-binary-tree/alphaorderly.py

# 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

"""
시간복잡도: O(n)
공간복잡도: O(h) - 트리의 높이(h)만큼 재귀 호출이 쌓인다.

- 루트 노드부터 시작해, 왼쪽과 오른쪽 자식을 각각 재귀적으로 반전한다.
- 재귀 함수는 현재 노드가 None이면 바로 None을 반환한다.
- 왼쪽과 오른쪽 자식을 반전한 결과를 각각 root.right, root.left로 할당하여 두 자식을 서로 바꾼다.
- 최종적으로 반전된 루트 노드를 반환한다.
"""
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

• 패턴: Depth-First Search, Recursive, Binary Tree
• 설명: 코드는 재귀적으로 트리의 자식을 방문하며 각 노드의 왼쪽/오른쪽을 서로 반전시키는 DFS 성격의 재귀 패턴으로 구현되었다. 트리 구조를 탐색하며 부분 문제를 해결해 전체 트리를 반전한다.

📊 시간/공간 복잡도 분석

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

풀이 1: Solution.invertTree — Time: O(n) / Space: O(h)

	복잡도
Time	O(n)
Space	O(h)

피드백: 트리의 모든 노드를 한 번씩 방문하여 자식 노드를 스왑한다.

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

풀이 2: Solution.invertTree — Time: O(n) / Space: O(h)

	복잡도
Time	O(n)
Space	O(h)

피드백: 재귀 깊이가 트리의 높이에 비례한다.

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

💡 풀이에 시간/공간 복잡도를 주석으로 남겨보세요!

[dalestudy]

🏷️ 알고리즘 패턴 분석

jump-game/alphaorderly.py

"""
시간복잡도: O(n)
공간복잡도: O(1)

- 현재 위치(index)에서 갈 수 있는 가장 먼 위치(furthest)를 갱신한다.
- furthest가 현재 위치보다 작으면 도달할 수 없으므로 False를 반환한다.
- 갱신된 furthest가 마지막 인덱스 이상이 되면 True를 반환한다.
"""
class Solution:
    def canJump(self, nums: List[int]) -> bool:
        N = len(nums)
        furthest = 0

        for index, jump in enumerate(nums):
            if furthest < index:
                return False

            furthest = max(furthest, index + jump)
            if furthest >= N - 1:
                return True

        return False

• 패턴: Greedy, Binary Search
• 설명: 코드는 현재 위치에서 도달 가능한 최대 인덱스를 갱신하며, furthest가 현재 인덱스보다 작아지면 도달 불가능을 결정한다. 이는 남은 요소들 중 최적의 경로를 빠르게 판단하는 그리디 접근으로 풀이되며, 최종적으로 마지막 인덱스에 도달하는지 확인한다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(n)
Space	O(1)

피드백: 그리디 방식으로 최댓값을 갱신하며 도달 가능성을 판단한다.

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

💡 풀이에 시간/공간 복잡도를 주석으로 남겨보세요!

[dalestudy]

🏷️ 알고리즘 패턴 분석

merge-k-sorted-lists/alphaorderly.py

"""
시간복잡도: O(n log k)
공간복잡도: O(k)
- k는 연결 리스트의 개수, 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]:
        ans = ListNode()
        head = ans

        values = [(node.val, index) for index, node in enumerate(lists) if node]
        heapify(values)

        while values:
            _, index = heappop(values)

            head.next = lists[index]
            head = head.next

            lists[index] = lists[index].next
            if lists[index]:
                heappush(values, (lists[index].val, index))

        return ans.next

• 패턴: Heap / Priority Queue, Two Pointers, Greedy
• 설명: 리스트들에서 최소 원소를 매번 힙에서 꺼내고 다음 원소를 힙에 넣는 방식으로 k개의 연결 리스트를 합치는 힙 기반 병합 패턴이며, 각 원소를 차례로 처리하면서 전체를 정렬된 형태로 결과에 연결합니다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(n log k)
Space	O(k)

피드백: 힙에 각 리스트의 현재 노드를 담고, 하나씩 꺼내며 연결리스트를 구성한다.

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

💡 풀이에 시간/공간 복잡도를 주석으로 남겨보세요!

[dalestudy]

🏷️ 알고리즘 패턴 분석

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

"""
시간복잡도: O(log n)
공간복잡도: O(1)

- 회전된 정렬 배열에서 이진 탐색으로 target을 찾는다.
- mid와 target이 원래 배열의 왼쪽 절반에 있었는지, 오른쪽 절반에 있었는지를 구분한다.
    - 기준: nums[mid] > nums[N-1] 이면 mid가 왼쪽(회전되기 전 더 작은 쪽), 아니면 오른쪽.
    - target도 같은 기준으로 왼쪽/오른쪽인지 판별.
- mid와 target이 서로 다른 쪽에 있으면, target이 있는 쪽으로 포인터를 이동 (left 또는 right 값을 조정).
- mid == target 이면 mid 반환.
- 찾지 못하면 -1 반환.
"""
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        N = len(nums)
        left = 0
        right = N - 1

        while left <= right:
            mid = (left + right) // 2

            if target == nums[mid]:
                return mid

            mid_left = nums[mid] > nums[N - 1]
            target_left = target > nums[N - 1]

            if nums[mid] > target:
                if mid_left != target_left:
                    left = mid + 1
                else:
                    right = mid - 1
            elif mid_left != target_left:
                right = mid - 1
            else:
                left = mid + 1

        return -1

• 패턴: Binary Search, Two Pointers
• 설명: 회전된 정렬 배열에서 이진 탐색으로 범위를 절반씩 축소하며 target의 위치를 찾는 방식이다. left/right를 조정해 탐색 영역을 좁히는 패턴으로, 두 포인터로 구간을 관리하는 특징이 있다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(log n)
Space	O(1)

피드백: 중간 값의 위치에 따라 왼쪽/오른쪽 반쪽을 판단해 탐색 범위를 축소한다.

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

💡 풀이에 시간/공간 복잡도를 주석으로 남겨보세요!