[dolphinflow86] WEEK 09 Solutions

[dolphinflow86]

답안 제출 문제

• linked-list-cycle
• maximum-product-subarray
• minimum-window-substring
• pacific-atlantic-water-flow
• sum-of-two-integers

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

⚠️ Week 설정이 누락되었습니다

프로젝트에서 Week를 설정해주세요!

설정 방법

1. PR 우측의 Projects 섹션에서 리트코드 스터디 옆 드롭다운(▼) 클릭
2. 현재 주차를 선택해주세요 (예: Week 14(current) 또는 Week 14)

📚 자세한 가이드 보기

---

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

linked-list-cycle/dolphinflow86.py

# N is the number of nodes in the linked list.
# TC: O(N) - visits each node at most twice
# SC: O(1) - uses only two pointers without extra space

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

from typing import Optional


class Solution:

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

        slow = head
        fast = head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

            if slow == fast:
                return True

        return False

• 패턴: Two Pointers, Fast & Slow Pointers
• 설명: 헤드 포인터와 슬로우/패스트 포인터를 이용해 순환 여부를 판단하는 대표적 방법으로, 한 노드씩 느리게, 두 노드씩 빠르게 진행하며 만나는 지점을 확인합니다. 추가 공간 없이 O(N) 시간과 O(1) 공간으로 해결합니다.

📊 시간/공간 복잡도 분석

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

피드백: 두 포인터를 이용한 순회로 추가 저장 공간 없이 사이클 여부를 판별한다.

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

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

[dalestudy]

📊 dolphinflow86 님의 학습 현황

이번 주 제출 문제

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

누적 학습 요약

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

문제 풀이 현황

카테고리	진행도	완료
Dynamic Programming	■■■■■■□	9 / 11 (Easy 1, Medium 8)
Array	■■■■■■□	8 / 10 (Medium 5, Easy 3)
String	■■■■■■□	8 / 10 (Medium 5, Easy 3)
Matrix	■■■■■□□	3 / 4 (Medium 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	1,284	127	1,411	$0.000115
2	1,291	143	1,434	$0.000122
3	2,206	249	2,455	$0.000210
4	2,206	256	2,462	$0.000213
5	2,206	199	2,405	$0.000190
합계	9,193	974	10,167	$0.000849

[dalestudy]

🏷️ 알고리즘 패턴 분석

maximum-product-subarray/dolphinflow86.py

# N is the length of array nums.
# TC: O(N) - single pass maintaining maximum and minimum product
# SC: O(1) - uses constant extra variables

from typing import List


class Solution:

    def maxProduct(self, nums: List[int]) -> int:
        if not nums:
            return 0

        res = nums[0]
        cur_max = nums[0]
        cur_min = nums[0]

        for i in range(1, len(nums)):
            num = nums[i]

            if num < 0:
                tmp = cur_max
                cur_max = cur_min
                cur_min = tmp

            cur_max = max(num, cur_max * num)
            cur_min = min(num, cur_min * num)

            res = max(res, cur_max)

        return res

• 패턴: Two Pointers, Dynamic Programming, Bit Manipulation
• 설명: 연속 부분배열의 곱의 최대값을 찾기 위해 현재 위치에서 양수/음수 전환 시 부호를 바꿔 가장 큰/작은 곱을 유지하는 방식으로 한 번의 순회로 해결하는 DP 성격의 풀이이며, 부호 변화에 따라 cur_max와 cur_min을 트랙킹하는 아이디어가 핵심이다.

📊 시간/공간 복잡도 분석

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

피드백: 부호가 뒤집히는 경우를 처리하기 위해 cur_max와 cur_min을 교차로 관리한다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

minimum-window-substring/dolphinflow86.py

# S and T are the lengths of strings s and t respectively.
# TC: O(S + T) - expanding and contracting sliding window with frequency counts
# SC: O(S + T) - hash tables store frequency counts of unique characters

from collections import Counter


class Solution:

    def minWindow(self, s: str, t: str) -> str:
        if not s or not t:
            return ""

        target_counts = Counter(t)
        window_counts = {}

        have = 0
        need = len(target_counts)

        res = [-1, -1]
        res_len = float("inf")
        left = 0

        for right in range(len(s)):
            char = s[right]
            window_counts[char] = window_counts.get(char, 0) + 1

            if char in target_counts and window_counts[char] == target_counts[char]:
                have += 1

            while have == need:
                if (right - left + 1) < res_len:
                    res = [left, right]
                    res_len = right - left + 1

                left_char = s[left]
                window_counts[left_char] -= 1

                if left_char in target_counts and window_counts[left_char] < target_counts[left_char]:
                    have -= 1

                left += 1

        l, r = res
        return s[l : r + 1] if res_len != float("inf") else ""

• 패턴: Sliding Window, Hash Map / Hash Set
• 설명: 문자열 s의 부분창을 좌우로 확장/축소하면서 필요한 문자 빈도수를 추적하는 슬라이딩 윈도우 패턴과, 문자 빈도수를 저장하는 해시 맵 사용으로 패턴에 해당합니다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(
Space	O(

피드백: 타겟 문자 빈도와 현재 윈도우의 빈도를 추적하고 필요한 문자 수를 관리한다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

linked-list-cycle/dolphinflow86.py

# N is the number of nodes in the linked list.
# TC: O(N) - visits each node at most twice
# SC: O(1) - uses only two pointers without extra space

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


class Solution:

    def hasCycle(self, head) -> bool:
        if not head or not head.next:
            return False

        slow = head
        fast = head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

            if slow == fast:
                return True

        return False

• 패턴: Two Pointers, Fast & Slow Pointers
• 설명: 해당 코드는 두 포인터(slow와 fast)를 이용해 순환 여부를 판별하는 Fast & Slow Pointers 기법으로 구현되었고, 같은 노드를 만나면 사이클이 존재한다는 원리로 동작합니다. 시간 복잡도는 O(N), 공간 복잡도는 O(1)입니다.

📊 시간/공간 복잡도 분석

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

피드백: 해당 구현은 Floyd의 사이클 탐지 알고리즘을 사용하여 한 번의 배열 순회를 통해 사이클 여부를 판단합니다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

maximum-product-subarray/dolphinflow86.py

# N is the length of array nums.
# TC: O(N) - single pass maintaining maximum and minimum product
# SC: O(1) - uses constant extra variables


class Solution:

    def maxProduct(self, nums) -> int:
        if not nums:
            return 0

        res = nums[0]
        cur_max = nums[0]
        cur_min = nums[0]

        for i in range(1, len(nums)):
            num = nums[i]

            if num < 0:
                tmp = cur_max
                cur_max = cur_min
                cur_min = tmp

            cur_max = max(num, cur_max * num)
            cur_min = min(num, cur_min * num)

            res = max(res, cur_max)

        return res

• 패턴: Two Pointers, Dynamic Programming, Greedy, Bit Manipulation, Hash Map / Hash Set, Divide and Conquer, Monotonic Stack, Binary Search, BFS, DFS, Backtracking, Union Find, Trie, Heap / Priority Queue
• 설명: 최대 부분배열 곱의 최대값을 구하기 위해 현재 위치에서의 최대/최소 곱을 한 번의 순회로 갱신하는 방식으로, 음수 처리 시 부호를 바꿔 두 값을 교차 비교하는 패턴이 핵심이다.

📊 시간/공간 복잡도 분석

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

피드백: 연속 구간의 최대 곱을 갱신하는 표준 해법으로, 부호 반전 시 최소값이 최대값이 된다를 이용한다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

minimum-window-substring/dolphinflow86.py

# S and T are the lengths of strings s and t respectively.
# TC: O(S + T) - expanding and contracting sliding window with frequency counts
# SC: O(S + T) - hash tables store frequency counts of unique characters


class Solution:

    def minWindow(self, s: str, t: str) -> str:
        if not s or not t:
            return ""

        target_counts = {}
        for char in t:
            target_counts[char] = target_counts.get(char, 0) + 1

        window_counts = {}

        have = 0
        need = len(target_counts)

        res = [-1, -1]
        res_len = float("inf")
        left = 0

        for right in range(len(s)):
            char = s[right]
            window_counts[char] = window_counts.get(char, 0) + 1

            if char in target_counts and window_counts[char] == target_counts[char]:
                have += 1

            while have == need:
                if (right - left + 1) < res_len:
                    res = [left, right]
                    res_len = right - left + 1

                left_char = s[left]
                window_counts[left_char] -= 1

                if (
                    left_char in target_counts
                    and window_counts[left_char] < target_counts[left_char]
                ):
                    have -= 1

                left += 1

        l, r = res
        return s[l : r + 1] if res_len != float("inf") else ""

• 패턴: Sliding Window, Hash Map / Hash Set
• 설명: 문자열 s에서 부분 문자열 창을 좌우로 확장/축소하는 슬라이딩 윈도우 기법과, 문자 등장 횟수를 세는 해시 맵을 함께 사용하여 필요한 문자 집합과 현재 창의 상태를 추적합니다.

📊 시간/공간 복잡도 분석

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

피드백: 슬라이딩 윈도우와 해시맵을 활용해 필요한 문자 수를 만족하는 최소 창을 찾는다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

pacific-atlantic-water-flow/dolphinflow86.py

# M is the number of rows, and N is the number of columns.
# TC: O(M * N) - visits each cell constant number of times via DFS
# SC: O(M * N) - stores visited sets and recursion stack for both oceans


class Solution:

    def pacificAtlantic(self, heights):
        if not heights or not heights[0]:
            return []

        rows, cols = len(heights), len(heights[0])
        pacific = set()
        atlantic = set()

        def dfs(r, c, visited, prev_height):
            if r < 0 or r >= rows or c < 0 or c >= cols:
                return

            if (r, c) in visited or heights[r][c] < prev_height:
                return

            visited.add((r, c))

            dfs(r + 1, c, visited, heights[r][c])
            dfs(r - 1, c, visited, heights[r][c])
            dfs(r, c + 1, visited, heights[r][c])
            dfs(r, c - 1, visited, heights[r][c])

        for c in range(cols):
            dfs(0, c, pacific, heights[0][c])
            dfs(rows - 1, c, atlantic, heights[rows - 1][c])

        for r in range(rows):
            dfs(r, 0, pacific, heights[r][0])
            dfs(r, cols - 1, atlantic, heights[r][cols - 1])

        return [[r, c] for r, c in pacific & atlantic]

• 패턴: DFS, Backtracking, Graph Traversal
• 설명: 코드는 깊이 우선 탐색(DFS)로 두 바다에 도달 가능한 셀을 탐색합니다. 방문 집합을 이용해 중복 탐색을 피하고, 인접 셀로의 재귀 호출을 통해 연결성을 확인합니다. 또한 두 집합의 교집합으로 최종 결과를 도출합니다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(mn)
Space	O(mn)

피드백: DFS로 각 세포에 대해 방문 여부를 추적하고, 두 해안으로부터의 도달 가능 경로를 탐색합니다. 모든 셀에 대해 한 번씩 방문하므로 시간은 행렬의 크기에 비례합니다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

sum-of-two-integers/dolphinflow86.py

# TC: O(1) - loops at most 32 times for 32-bit integer addition
# SC: O(1) - uses constant extra space


class Solution:

    def getSum(self, a: int, b: int) -> int:
        mask = 0xFFFFFFFF
        max_int = 0x7FFFFFFF

        while b != 0:
            carry = (a & b) << 1
            a = (a ^ b) & mask
            b = carry & mask

        return a if a <= max_int else ~(a ^ mask)

• 패턴: Bit Manipulation
• 설명: 두 정수의 합을 비트 연산으로 처리하며, XOR로 합을, AND와 왼시프트로 캐리를 계산하는 방식으로 구현되어 있다. 상수 시간/공간의 특성과 비트 연산 기반의 알고리즘 패턴이 핵심이다.

📊 시간/공간 복잡도 분석

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

피드백: 비트 연산과 마스크를 이용해 시프트 및 캐리 처리를 반복적으로 수행합니다. 상수 시간에 작동하도록 설계되어 있습니다.

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

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