[yuseok89] WEEK 11 Solutions

[yuseok89]

답안 제출 문제

• Binary Tree Maximum Path Sum #287
• Graph Valid Tree #262
• Merge Intervals #278
• Missing Number #235
• Reorder List #247

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

binary-tree-maximum-path-sum/yuseok89.py

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

        ans = float('-inf')

        def get_max(cur: Optional[TreeNode]) -> int:
            nonlocal ans

            if cur is None:
                return 0

            left_max = get_max(cur.left)
            right_max = get_max(cur.right)

            ans = max(ans, cur.val, cur.val + left_max, cur.val + right_max, cur.val +left_max + right_max)

            return max(cur.val, cur.val + max(left_max, right_max))

        get_max(root)

        return ans

• 패턴: Depth-First Search, Dynamic Programming, Binary Search
• 설명: 트리의 각 노드에서 좌우 자식의 최대 합을 재귀적으로 계산하며, 글로벌 최댓값을 갱신하는 방식은 DFS로 트리를 순회하고, 각 노드의 정보를 재활용해 최댓값을 누적하는 DP적 패턴과 같이 작동합니다. 또한 부분해를 합으로 고려하는 구조는 트리에서의 최적해 구성의 DP 성질을 반영합니다.

📊 시간/공간 복잡도 분석

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

피드백: 각 노드에서 왼쪽/오른쪽 자식에서의 최대 증가분을 구하고, 이를 이용해 현재 노드를 포함한 경로의 최대 합과 리턴 값을 계산한다.

개선 제안: 현재 구현은 전형적인 DFS 방식으로 동작하며, 공간 복잡도는 재귀 호출 깊이에 따라 좌우 깊이의 합 중 최댓값인 h에 비례한다. 필요 시 순회 방식으로의 변환이나 tail recursion 최적화를 고려해도 된다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

merge-intervals/yuseok89.py

# TC: O(NlogN)
# SC: O(N)
class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:

        ans = list()

        intervals.sort(key=lambda x:x[0])

        ans.append([intervals[0][0]])

        end = intervals[0][1]

        for idx in range(1, len(intervals)):
            if intervals[idx][0] <= end:
                end = max(end, intervals[idx][1])
            else:
                ans[-1].append(end)
                ans.append([intervals[idx][0]])
                end = intervals[idx][1]

        ans[-1].append(end)

        return ans

• 패턴: Greedy, Sort
• 설명: Intervals 정렬 후 겹치는 구간을 하나의 구간으로 합치는 과정을 사용하므로 Greedy 패턴으로 분류되며, 먼저 시작점을 기준으로 정렬하는 전략이 핵심입니다. 또한 투포인터처럼 현재 구간의 끝과 다음 구간의 시작을 비교해 확장 여부를 결정합니다.

📊 시간/공간 복잡도 분석

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

피드백: 정렬과 선형 순회로 겹치는 구간들을 합친다. 시작점 정렬이 핵심이다.

개선 제안: 현재 구현은 기본적인 풀이로 적절하다. 필요 시 예외 처리나 비어있는 입력에 대한 방어 코드를 추가할 수 있다.

[dalestudy]

📊 yuseok89 님의 학습 현황

이번 주 제출 문제

문제	난이도	유형 분석
binary-tree-maximum-path-sum	Hard	✅ 의도한 유형
merge-intervals	Medium	✅ 의도한 유형
missing-number	Easy	✅ 의도한 유형
reorder-list	Medium	✅ 의도한 유형

누적 학습 요약

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

문제 풀이 현황

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

---

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

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

요청	입력 토큰	출력 토큰	합계	비용
1	1,471	183	1,654	$0.000147
2	1,470	222	1,692	$0.000162
3	1,469	158	1,627	$0.000137
합계	4,410	563	4,973	$0.000446

[dalestudy]

🏷️ 알고리즘 패턴 분석

missing-number/yuseok89.py

# TC: O(N)
# SC: O(1)
class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        total = n * (n + 1) // 2

        for num in nums:
            total -= num

        return total

• 패턴: Greedy, Bit Manipulation, Dynamic Programming, Hash Map / Hash Set, Divide and Conquer, Two Pointers, Sliding Window, Backtracking, DFS, BFS, Union Find, Trie, Heap / Priority Queue, Monotonic Stack, Binary Search
• 설명: 해당 코드는 수의 합 공식을 이용해 누락된 숫자를 구하는 방식으로 전체 합에서 배운 값들을 차감하는 아이디어를 사용한다. 문제의 시간복잡도는 O(N), 공간복잡도는 O(1)로 구현된다.

📊 시간/공간 복잡도 분석

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

피드백: 등차수열의 합 공식을 이용해 한 번의 순회로 누락 숫자를 구한다.

개선 제안: 현재 구현이 간단하고 효율적이다. 입력에 빈 배열 등의 특수 케이스를 가정하지 않는다면 추가 방어가 필요할 수 있다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

reorder-list/yuseok89.py

# TC: O(N)
# SC: O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reorderList(self, head: Optional[ListNode]) -> None:
        """
        Do not return anything, modify head in-place instead.
        """

        if not head or not head.next:
            return

        def rec(right: Optional[ListNode]) -> Optional[ListNode]:
            if not right:
                return head

            left = rec(right.next)

            if not left:
                return None

            if left == right or left.next == right:
                right.next = None
                return None

            nxt_left = left.next
            left.next = right
            right.next = nxt_left

            return nxt_left

        rec(head)

• 패턴: Recursion, Two Pointers, Linked List
• 설명: 재귀를 이용해 리스트의 끝에서부터 왼쪽 포인터를 움직이며 노드를 재배치하는 방식으로, 두 포인터가 서로 인접할 때 종료 조건을 걸고 연결을 재구성합니다. 부분적으로 재귀 깊이를 통해 리스트를 반전된 방향으로 순회하며 O(N) 시간, O(1) 추가 공간 특성을 갖습니다.

📊 시간/공간 복잡도 분석

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

피드백: 전형적인 위상 정렬/데이터 구조 조합으로 재배치한다. 재귀와 포인터 조작으로 in-place를 달성한다.

개선 제안: 현재 구현은 재귀를 이용해 오른쪽 부분을 순회하며 재배치를 시도한다. 구현의 복잡도가 다소 높으므로 반복적 접근으로 리팩토링을 고려해볼 수 있다.

[alphaorderly]

엄청 깔끔하게 해결하셨네요, 잘 보고 갑니다!

[alphaorderly]

구현 상당히 깔끔하게 잘 하셨네요

[alphaorderly]

와우 엄청 깔끔하게 잘 푸셨네요

[dolphinflow86]

수고많으셨습니다!

[dolphinflow86]

@yuseok89 요거 재귀 호출인데 공간 복잡도가 재귀 호출 깊이만큼이라 O(N) 까지 깊어집니다.
한번 확인해보시면 좋을 것 같아요!

[yuseok89]

리뷰 감사합니다 🙏

[dolphinflow86]

@yuseok89 여기도 공간복잡도가 스택 깊이만큼 깊어지는 부분 확인 해 보시면 좋을 것 같습니다~!

[yuseok89]

공간복잡도 계산 하면서 재귀부분을 자꾸 빼먹네요.
리뷰 감사합니다 🙏

[dalestudy]

🏷️ 알고리즘 패턴 분석

reorder-list/yuseok89.py

# TC: O(N)
# 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 reorderList(self, head: Optional[ListNode]) -> None:
        """
        Do not return anything, modify head in-place instead.
        """

        if not head or not head.next:
            return

        def rec(right: Optional[ListNode]) -> Optional[ListNode]:
            if not right:
                return head

            left = rec(right.next)

            if not left:
                return None

            if left == right or left.next == right:
                right.next = None
                return None

            nxt_left = left.next
            left.next = right
            right.next = nxt_left

            return nxt_left

        rec(head)

• 패턴: Two Pointers, Recursion, Linked List
• 설명: 재귀를 이용해 리스트의 좌측 노드와 우측 노드를 교차로 연결하는 방식으로, 재귀 호출로 좌측 포인터를 얻고 좌우를 번갈아 붙여 리스트를 재배치한다. 연결 순서를 재구성하는 연산은 순차적으로 진행되며, 재귀 깊이와 포인터 조작이 핵심 포인트다.

📊 시간/공간 복잡도 분석

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

피드백: 재귀를 이용해 오른쪽 부분의 노드를 따라가며 왼쪽 부분과 연결을 구성한다. 재귀 깊이가 O(n)까지 증가하므로 공간 복잡도는 스택 깊이에 의해 결정된다.

개선 제안: 고려해볼 만한 대안: 재귀 대신 두 포인터(빠른/느린)로 중간을 분리하고, 뒤에서부터 연결하기보다 배열에 노드를 모아 역순으로 연결하는 방식으로 공간 사용을 줄일 수 있다. 또한 tail 포인터를 유지해 불필요한 노드 재할당 없이 O(1) 공간으로 구현 가능하다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

binary-tree-maximum-path-sum/yuseok89.py

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

        ans = float('-inf')

        def get_max(cur: Optional[TreeNode]) -> int:
            nonlocal ans

            if cur is None:
                return 0

            left_max = get_max(cur.left)
            right_max = get_max(cur.right)

            ans = max(ans, cur.val, cur.val + left_max, cur.val + right_max, cur.val +left_max + right_max)

            return max(cur.val, cur.val + max(left_max, right_max))

        get_max(root)

        return ans

• 패턴: Binary Search, Depth-First Search, Dynamic Programming, Tree Traversal
• 설명: 주어진 코드는 이진 트리에서 모든 경로의 합을 탐색하며, 자식 노드의 정보를 재귀적으로 합산해 최댓값을 업데이트한다. 각 노드에서 좌우 서브트리 정보를 활용해 최댓 경로를 계산하는 방식은 DFS와 DP의 혼합 패턴으로 볼 수 있다.

📊 시간/공간 복잡도 분석

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

피드백: 전위 탐색과 재귀를 이용해 자식 노드의 최대 증가 합을 합산하고, 현재 노드에서 형성 가능한 최대 경로를 갱신한다.

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