[yuseok89] WEEK 09 Solutions

[yuseok89]

답안 제출 문제

• Linked List Cycle #225
• Maximum Product Subarray #270
• Minimum Window Substring #285
• Pacific Atlantic Water Flow #260
• Sum of Two Integers #284

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

linked-list-cycle/yuseok89.py

# TC: O(N)
# SC: O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if not head or not head.next:
            return False

        slow, fast = head, head.next
        while slow != fast:
            if not fast or not fast.next:
                return False

            slow, fast = slow.next, fast.next.next

        return True

• 패턴: Two Pointers, Fast & Slow Pointers
• 설명: 해당 코드는 느린 포인터와 빠른 포인터를 이용해 순환 여부를 판별하는 전형적인 Fast & Slow Pointers 패턴이다. 두 포인터의 속도 차이를 이용해 사이클 존재 여부를 O(N) 시간, O(1) 공간으로 판단한다.

📊 시간/공간 복잡도 분석

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

피드백: 빠른 포인터와 느린 포인터를 이용해 순회하므로 추가 메모리 없이 사이클 여부를 판단할 수 있다.

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

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

[dalestudy]

📊 yuseok89 님의 학습 현황

이번 주 제출 문제

문제	난이도	유형 분석
linked-list-cycle	Easy	✅ 의도한 유형
maximum-product-subarray	Medium	✅ 의도한 유형
minimum-window-substring	Hard	✅ 의도한 유형
pacific-atlantic-water-flow	Medium	✅ 의도한 유형
sum-of-two-integers	Medium	✅ 의도한 유형

누적 학습 요약

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

문제 풀이 현황

카테고리	진행도	완료
Dynamic Programming	■■■■■■□	9 / 11 (Easy 1, Medium 8)
Array	■■■■■■□	8 / 10 (Medium 5, Easy 3)
Matrix	■■■■■□□	3 / 4 (Medium 3)
String	■■■■■□□	7 / 10 (Medium 4, Easy 3)
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	340	50	390	$0.000037
2	340	53	393	$0.000038
3	2,029	204	2,233	$0.000183
합계	2,709	307	3,016	$0.000258

[alphaorderly]

조건문 부분에 같은지 비교를 하는것도 꽤 괜찮은 아이디어시네요!
다만 아주 개인적인 의견인데, slow와 fast를 비교하는것은 참조를 비교하는거라 is를 쓰는게 더 낫지 않을까? 하는 생각이 있었어요
좋은 코드 보고 갑니다!

[yuseok89]

더 명확해지겠네요.
반영해보겠습니다.
감사합니다 !

[DaleSeo]

수고하셨습니다!

[DaleSeo]

노드가 하나뿐이고 순환이 없는 입력이라면 fast가 None으로 시작하므로, 반복문 안의 if not fast 가 곧바로 False를 반환해 줄텐데요. 그렇다면 여기서 not head.next까지 확인하는 것은 어떤 경우를 대응하기 위한 목적인가요?

[yuseok89]

조금 과하게 생각한 것 같습니다.
말씀 하신대로, not head 만으로 충분합니다.
감사합니다 !

[dalestudy]

🏷️ 알고리즘 패턴 분석

linked-list-cycle/yuseok89.py

# TC: O(N)
# SC: O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False

        slow, fast = head, head.next
        while slow is not fast:
            if not fast or not fast.next:
                return False

            slow, fast = slow.next, fast.next.next

        return True

• 패턴: Fast & Slow Pointers
• 설명: 해당 코드는 한 노드는 한 칸, 다른 노드는 두 칸씩 진행하는 두 포인터를 이용해 순환 여부를 검사하므로 Fast & Slow Pointers 패턴에 속합니다. 사이클 존재 여부를 O(N) 시간과 O(1) 공간으로 판별합니다.

📊 시간/공간 복잡도 분석

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

피드백: 해당 알고리즘은 한 번의 순회로 사이클 여부를 확인하는 일반적인 해시 없이도 가능하다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

maximum-product-subarray/yuseok89.py

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

        ans = nums[0]
        max_val, min_val = 1, 1

        for num in nums:
            temp = max_val * num
            max_val = max(temp, min_val * num, num)
            min_val = min(temp, min_val * num, num)

            ans = max(ans, max_val)

        return ans

• 패턴: Dynamic Programming, Two Pointers, Greedy
• 설명: 연속 부분 배열의 곱의 최대값을 유지하며 현재 구간의 최댓값과 최솟값을 갱신하는 방식으로, 연속 곱의 부호 변화에 대응하는 DP/상태 유지 패턴으로 풀이된다. 또한 한 번의 순회로 해결하므로 Sliding Window에 비슷한 흐름이 있지만 핵심은 부분 최댓값과 최솟값의 상태를 관리하는 동적 결정이다.

📊 시간/공간 복잡도 분석

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

피드백: 양수/음수의 곱으로 인해 최대/최소를 함께 고려하는 표준 풀이를 사용한다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

minimum-window-substring/yuseok89.py

# TC: O(N)
# SC: O(N)
class Solution:
    def minWindow(self, s: str, t: str) -> str:

        len_s = len(s)
        len_t = len(t)

        min_len = len_s + 1
        ans_start_idx = -1
        total_cnt = 0

        t_cnt_dict = Counter(t)
        cnt_dict = defaultdict(int)

        l, r = 0, 0

        while r < len_s:

            r_c = s[r]

            if cnt_dict[r_c] < t_cnt_dict.get(r_c, 0):
                total_cnt += 1

            cnt_dict[r_c] += 1
            r += 1

            while total_cnt == len_t:
                if min_len > r - l:
                    min_len = r - l
                    ans_start_idx = l

                l_c = s[l]

                if cnt_dict[l_c] <= t_cnt_dict[l_c]:
                    total_cnt -= 1

                cnt_dict[l_c] -= 1
                l += 1

        if ans_start_idx == -1:
            return ''

        return s[ans_start_idx:ans_start_idx + min_len]

• 패턴: Sliding Window, Hash Map / Hash Set, Two Pointers
• 설명: 두 포인터(l, r)로 창을 확장하고 축소하면서 필요한 문자 개수를 해시맵으로 관리하는 표준 Sliding Window 패턴으로 풀이합니다. 해시 맵을 사용해 문자의 빈도수를 추적하고 최소 창을 갱신합니다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(N)	O(	s
Space	O(N)	O(	alphabet

피드백: 용도에 맞는 슬라이딩 윈도우 + 카운트 매핑으로 선형 시간 복잡도를 얻는다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

pacific-atlantic-water-flow/yuseok89.py

# TC: O(N*M)
# SC: O(N*M)
class Solution:
    def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:

        n = len(heights)
        m = len(heights[0])

        dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]]

        def dfs(row, col, check):
            check[row][col] = True

            for dir in dirs:
                new_row = row + dir[0]
                new_col = col + dir[1]

                if 0 <= new_row < n and 0 <= new_col < m and not check[new_row][new_col] and heights[row][col] <= heights[new_row][new_col]:
                    dfs(new_row, new_col, check)

        pac_check = [[False for _ in range(m)] for _ in range(n)]
        atl_check = [[False for _ in range(m)] for _ in range(n)]

        for row in range(1, n):
            dfs(row, 0, pac_check)

        for col in range(m):
            dfs(0, col, pac_check)

        for row in range(n - 1):
            dfs(row, m - 1, atl_check)

        for col in range(m):
            dfs(n - 1, col, atl_check)

        ans = []

        for row in range(n):
            for col in range(m):
                if pac_check[row][col] and atl_check[row][col]:
                    ans.append([row, col])

        return ans

• 패턴: Depth-First Search, Binary Search
• 설명: 유향 흐름 대신 두 해발의 경계부터 DFS로 퍼져나가며 조건을 만족하는 위치를 찾는 구조로, 두 바다에서 도달 가능한지 확인하기 위해 DFS를 사용합니다. 패턴은 DFS에 해당하며, 이 문제의 핵심은 두 방향으로의 탐색을 통한 교집합 확인입니다.

📊 시간/공간 복잡도 분석

	유저 분석	실제 분석	결과
Time	O(N*M)	O(nm)	❌
Space	O(N*M)	O(nm)	❌

피드백: 각 셀에 대해 두 방향으로 도달 가능 여부를 기록하고, 시작점에서 인접한 셀로의 흐름 조건을 재귀적으로 확장한다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

sum-of-two-integers/yuseok89.py

# TC: O(12)
# SC: O(1)
class Solution:
    def getSum(self, a: int, b: int) -> int:
        MASK = 0b111111111111

        a = a & MASK
        b = b & MASK

        while b != 0:
            c = (a & b) << 1
            a = a ^ b
            b = c & MASK

        if a > (MASK >> 1):
            a = ~(a ^ MASK)

        return a

• 패턴: Bit Manipulation, Greedy
• 설명: 두 정수의 합을 비트 연산으로 구현하는 방식으로, 비트 연산과 마스크를 이용해 합을 구하는 점에서 Bit Manipulation 패턴에 속합니다. 추가적으로 최적화된 상수 공간 사용은 문제 해결의 일반적 특징으로 보일 수 있습니다.

📊 시간/공간 복잡도 분석

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

피드백: 비트 연산으로 문자열적 구현 없이 덧셈을 구현한다.

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