[sangbeenmoon] WEEK 10 Solutions

[sangbeenmoon]

답안 제출 문제

• Course Schedule #261
• Jump Game #276
• Search In Rotated Sorted Array #246

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

course-schedule/sangbeenmoon.py

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        # 0 -> 아직 미방문. 1 -> 방문중. 2 -> 방문 완료 && 사이클 없음.
        visited = [0] * numCourses
        graph = [[] for _ in range(numCourses)] 

        for prereq in prerequisites:
            src, dest = prereq[0], prereq[1]
            graph[src].append(dest)
        
        def go(cur: int) -> bool:
            visited[cur] = 1
            for next in graph[cur]:
                if visited[next] == 1:
                    return True
                if visited[next] == 0 and go(next):
                    return True

            visited[cur] = 2
            return False

        for cur in range(numCourses):
            if go(cur):
                return False

        return True

• 패턴: Depth-First Search, Backtracking, Greedy
• 설명: 그래프의 사이클 여부를 DFS로 탐색하고 방문 상태를 추적한다. 사이클 존재 여부를 검사하는 로직은 DFS 기반의 탐색(backtracking) 패턴과 연결되며, 전체 그래프 순회를 통해 위상 정렬 없이 사이클 유무를 판단한다.

📊 시간/공간 복잡도 분석

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

피드백: 깊이 우선 탐색으로 사이클이 있으면 False를 반환하고, 없으면 True를 반환한다. 방문 상태 배열로 사이클 여부를 추적한다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

jump-game/sangbeenmoon.py

# 탑다운
# 재귀 깊이가 n 까지 깊어질 수 있어서 비효율적.

class Solution:
    def canJump(self, nums: List[int]) -> bool:

        # memo[i] = i 번째에서 도달할 수 있는 최대 인덱스.
        memo = [0] * len(nums)

        def go(cur : int) -> int:
            if cur >= len(nums) - 1:
                return -1
            if memo[cur] != 0:
                return memo[cur]

            max_jump = nums[cur]

            if max_jump == 0:
                return cur


            for jump in range(max_jump,0,-1):
                res = go(cur + jump)
                if res == -1:
                    return -1
                memo[cur] = max(memo[cur], res)

            return memo[cur]

        return True if go(0) == -1 else False

# 바텀업

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        n = len(nums)
        dp = [False] * n              # dp[i] = i에서 마지막까지 갈 수 있는가
        dp[n - 1] = True

        for i in range(n - 2, -1, -1):
            max_reach = min(i + nums[i], n - 1)
            for j in range(i + 1, max_reach + 1):
                if dp[j]:
                    dp[i] = True
                    break             # 하나만 찾으면 충분
            # 못 찾으면 dp[i]는 초기값 False 그대로

        return dp[0]

• 패턴: Dynamic Programming, Backtracking, Divide and Conquer
• 설명: 탑다운 구조의 재귀/메모이제이션과 바텀업 DP로 각 위치에서의 도달 가능 여부를 계산하므로 DP 패턴이 주된 특징입니다. 재귀적 탐색에서 가지치기 없이도 해결되지만 메모이제이션으로 중복을 줄이고, 바텀업에서도 DP 배열로 상태를 갱신합니다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(n^2)
Space	O(n)

피드백: 탑다운은 중간에 불필요한 재귀 깊이가 커질 수 있으며 바텀업은 역방향으로 점프 가능 여부를 확인한다.

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

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

[dalestudy]

📊 sangbeenmoon 님의 학습 현황

이번 주 제출 문제

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

누적 학습 요약

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

문제 풀이 현황

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

---

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

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

요청	입력 토큰	출력 토큰	합계	비용
1	1,346	155	1,501	$0.000129

[dalestudy]

🏷️ 알고리즘 패턴 분석

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

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) - 1

        while left <= right:

            mid = (left + right) // 2

            if nums[left] == target:
                return left
            if nums[right] == target:
                return right
            if nums[mid] == target:
                return mid            

            if nums[left] <= nums[mid]:
                if nums[left] < target and target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1    
            elif nums[mid] < target and target < nums[right]:
                left = mid + 1
            else:
                right = mid - 1

        return -1

• 패턴: Binary Search, Two Pointers
• 설명: 회전 정렬 배열에서 목표값을 찾기 위해 중간 인덱스와 왼쪽/오른쪽 경계 값을 비교하며 범위를 반으로 줄이는 이분 탐색 패턴으로 구현되어 있습니다.

📊 시간/공간 복잡도 분석

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

피드백: 중간값을 기준으로 어느 부분이 정렬되어 있는지 판단하고 타겟 위치를 재귀적/반복적으로 탐색한다.

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

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

[alphaorderly]

효율적인 사이클 탐색 알고리즘을 사용하셨네요
깔끔한 코드 잘 보고 갑니다.

[alphaorderly]

해당 문제는 DP로도 접근이 가능하지만 놀랍게 그리디하게도 풀수 있으세요!

[ICE0208]

수고하셨습니다!

[ICE0208]

DFS로 탐색하면서 사이클 여부를 판별하는 방법이군요!
좋은 풀이 잘 보고 갑니다 👍