[JeonJe] WEEK 10 Solutions

[JeonJe]

답안 제출 문제

• Invert Binary Tree
• Search in Rotated Sorted Array
• Course Schedule
• Jump Game
• Merge K Sorted Lists

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

invert-binary-tree/JeonJe.java

import java.util.*;

// TC: O(n)
// SC: O(n)
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        invertTree(root.left);
        invertTree(root.right);

        return root;
    }
}

• 패턴: Depth-First Search, Binary Search
• 설명: 리프까지 깊이 탐색하며 양쪽 자식 노드를 서로 교환하는 재귀 DFS 방식으로 트리를 반전시킵니다. 각 노드를 방문해 좌우를 스왕하고 하위 트리도 동일하게 재귀적으로 처리합니다.

📊 시간/공간 복잡도 분석

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

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

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

피드백: 트리의 모든 노드를 방문하며 각 노드의 좌우 자식 포인터를 교환한다. 재귀 깊이는 트리의 높이에 따라 공간이 결정된다.

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

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

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

피드백: 모든 노드를 한 번씩 방문하고 포인터를 스왑하므로 시간은 선형, 재귀 스택은 트리의 높이에 비례한다.

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

[dalestudy]

📊 JeonJe 님의 학습 현황

이번 주 제출 문제

문제	난이도	유형 분석
course-schedule	Medium	✅ 의도한 유형
invert-binary-tree	Easy	✅ 의도한 유형
search-in-rotated-sorted-array	Medium	⚠️ 유형 불일치

누적 학습 요약

• 풀이한 문제: 38 / 75개
• 이번 주 유형 일치율: 67% (3문제 중 2문제 일치)

문제 풀이 현황

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

---

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

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

요청	입력 토큰	출력 토큰	합계	비용
1	808	84	892	$0.000074
2	1,382	111	1,493	$0.000114
합계	2,190	195	2,385	$0.000188

[dalestudy]

🏷️ 알고리즘 패턴 분석

search-in-rotated-sorted-array/JeonJe.java

import java.util.*;

// TC: O(log n)
// SC: O(1)
class Solution {
    public int search(int[] nums, int target) {
        int pivot = findRotationPoint(nums);

        if (pivot > 0 && target >= nums[0]) {
            return binarySearch(nums, target, 0, pivot - 1);
        }
        return binarySearch(nums, target, pivot, nums.length - 1);
    }

    private int findRotationPoint(int[] nums) {
        int lo = 0;
        int hi = nums.length - 1;

        while (lo < hi) {
            if (nums[lo] < nums[hi]) {
                return lo;
            }

            int mid = (lo + hi) / 2;
            if (nums[lo] <= nums[mid]) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }

        return lo;
    }

    private int binarySearch(int[] nums, int target, int lo, int hi) {
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            if (nums[mid] < target) {
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }

        return -1;
    }
}

• 패턴: Binary Search, Divide and Conquer
• 설명: 배열을 두 부분으로 나눠 이진 탐색으로 타깃을 찾는 구조이며, 회전된 배열에서 피벗을 찾아 구간을 나눠 이진 탐색을 수행하는 패턴이다. 따라서 Binary Search와 Divide and Conquer에 해당한다.

📊 시간/공간 복잡도 분석

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

피드백: 피봇 찾기와 이진탐색으로 전체 복잡도를 로그스케일로 유지한다.

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

[alphaorderly]

피봇 포인트를 찾아서 하는것도 꽤 좋은 아이디어시네요!
다만 한번의 binary search로 해결하싷수도 있어요!

[JeonJe]

말씀해주신 제안을 생각해보니, mid를 기준으로 정렬된 구간을 확인하고
타깃이 해당 범위에 있는지에 따라 탐색 범위를 줄여가는 방식으로
피벗 위치를 먼저 구하지 않고도 한 번의 이진 탐색으로 해결할 수 있었네요. 감사합니다!

[alphaorderly]

해당 두 부분이 각각의 서브트리를 리턴하니까 이걸 그대로 사용해서 root.left와 root.right에 넣어도 좋지 않을까 하는 생각이 있습니다!

[JeonJe]

반환된 서브트리를 root.left와 root.right에 다시 넣을지 고민했는데,
각 서브트리를 제자리에서 변경하므로 다시 대입하지 않는 방식으로 구현했습니다.
의도를 더 명확하게 표현할 수 있는 제안 감사합니다!

[dalestudy]

🏷️ 알고리즘 패턴 분석

course-schedule/JeonJe.java

import java.util.ArrayList;
import java.util.List;

// TC: O(V + E)
// SC: O(V + E)
class Solution {
    private static final int UNVISITED = 0;
    private static final int VISITING = 1;
    private static final int VISITED = 2;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<List<Integer>> nextCourses = new ArrayList<>(numCourses);
        int[] visitState = new int[numCourses];

        for (int course = 0; course < numCourses; course++) {
            nextCourses.add(new ArrayList<>());
        }

        for (int[] dependency : prerequisites) {
            int course = dependency[0];
            int prerequisite = dependency[1];
            nextCourses.get(prerequisite).add(course);
        }

        for (int course = 0; course < numCourses; course++) {
            if (visitState[course] == UNVISITED
                    && hasCycle(course, nextCourses, visitState)) {
                return false;
            }
        }

        return true;
    }

    private boolean hasCycle(
            int course,
            List<List<Integer>> nextCourses,
            int[] visitState
    ) {
        if (visitState[course] == VISITING) {
            return true;
        }
        if (visitState[course] == VISITED) {
            return false;
        }

        visitState[course] = VISITING;

        for (int nextCourse : nextCourses.get(course)) {
            if (hasCycle(nextCourse, nextCourses, visitState)) {
                return true;
            }
        }

        visitState[course] = VISITED;
        return false;
    }
}

• 패턴: Depth-First Search, Greedy
• 설명: 코드에서 DFS를 사용해 위상 그래프의 사이클 여부를 탐지합니다. 방문 상태를 추적하며 사이클이 있으면 false를 반환하고, 사이클이 없으면 가능하다고 판단합니다. 위상 정렬-사이클 판별의 대표 패턴으로 볼 수 있습니다.

📊 시간/공간 복잡도 분석

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

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

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

피드백: 그래프를 인접 리스트로 표현하고 DFS로 사이클 여부를 검사한다. 각 노드는 한 번만 방문하므로 전체 시간은 정점/간선의 합에 비례한다.

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

풀이 2: Solution.hasCycle — Time: O(V + E) / Space: O(V + E)

	복잡도
Time	O(V + E)
Space	O(V + E)

피드백: 각 노드의 방문 상태를 세 가지로 관리하여 사이클을 검출한다. 재귀 깊이에 주의 필요.

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

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