[dolphinflow86] WEEK 08 Solutions

[dolphinflow86]

답안 제출 문제

• Reverse Bits #234
• Longest Repeating Character Replacement #244
• Clone Graph #259
• Palindromic Substrings #267
• Longest Common Subsequence #274

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

clone-graph/dolphinflow86.py

# N is the number of nodes, and E is the number of edges.
# TC: O(N + E) - visits each node and edge once
# SC: O(N) - uses a hash map for cloned nodes and the recursion stack

"""
# Definition for a Node.
class Node:
    def __init__(self, val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []
"""

from typing import Optional


class Solution:

    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
        if not node:
            return None

        cloned = {}

        def dfs(curr):
            if curr in cloned:
                return cloned[curr]

            copy = Node(curr.val)
            cloned[curr] = copy

            for neighbor in curr.neighbors:
                copy.neighbors.append(dfs(neighbor))

            return copy

        return dfs(node)

• 패턴: Depth-First Search, Hash Map / Hash Set
• 설명: 그래프의 각 노드를 깊이 우선 탐색으로 방문하며 노드 복제본을 해시맵에 매핑한다. 중복 방문 방지와 그래프 전체 탐색에 해시맵과 재귀 스택을 사용한다.

📊 시간/공간 복잡도 분석

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

피드백: 딥카피 시 각 노드를 고유 키로 매핑해 중복 생성 없이 그래프를 복제합니다. 이로써 모든 간선은 한 번씩 처리되고, 재방문 방지를 위한 해시맵이 필요합니다.

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

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

[dalestudy]

📊 dolphinflow86 님의 학습 현황

이번 주 제출 문제

문제	난이도	유형 분석
clone-graph	Medium	✅ 의도한 유형
longest-common-subsequence	Medium	✅ 의도한 유형
longest-repeating-character-replacement	Medium	✅ 의도한 유형
palindromic-substrings	Medium	✅ 의도한 유형
reverse-bits	Easy	✅ 의도한 유형

누적 학습 요약

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

문제 풀이 현황

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

---

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

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

요청	입력 토큰	출력 토큰	합계	비용
1	1,976	236	2,212	$0.000193

[dalestudy]

🏷️ 알고리즘 패턴 분석

longest-common-subsequence/dolphinflow86.py

# M is the length of text1, and N is the length of text2.
# TC: O(M * N) - fills a 2D DP table of size (M+1) x (N+1)
# SC: O(M * N) - uses a 2D array to store intermediate DP values
class Solution:

    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m, n = len(text1), len(text2)
        dp = [[0] * (n + 1) for _ in range(m + 1)]

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if text1[i - 1] == text2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

        return dp[m][n]

• 패턴: Dynamic Programming
• 설명: 두 문자열의 부분수열 길이를 2D DP 테이블로 구하는 전형적인 다이나믹 프로그래밍 문제로, 각 상태가 부분문자열의 최댓값을 저장하며 점화식으로 해결합니다.

📊 시간/공간 복잡도 분석

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

피드백: 2D DP 배열을 사용해 모든 부분문자열 쌍에 대한 최장 부분수열 길이를 누적적으로 구합니다.

개선 제안: 메모리 사용을 줄이려면 행 하나씩만 유지하는 최적화가 가능하지만, 이해도와 일반성 측면에서 현재 구현이 적절합니다.

[dalestudy]

🏷️ 알고리즘 패턴 분석

longest-repeating-character-replacement/dolphinflow86.py

# N is the length of string s, and K is the allowed replacements.
# TC: O(N) - single pass with sliding window
# SC: O(1) - hash table stores at most 26 uppercase English letters
class Solution:

    def characterReplacement(self, s: str, k: int) -> int:
        count = {}
        max_freq = 0
        left = 0
        max_length = 0

        for right in range(len(s)):
            count[s[right]] = count.get(s[right], 0) + 1
            max_freq = max(max_freq, count[s[right]])

            while (right - left + 1) - max_freq > k:
                count[s[left]] -= 1
                left += 1

            max_length = max(max_length, right - left + 1)

        return max_length

• 패턴: Sliding Window, Hash Map / Hash Set
• 설명: 문자 교체 횟수를 최소화하며 윈도우를 확장/축소하는 슬라이딩 윈도우 기법이 핵심이다. 해시 맵으로 문자 빈도를 추적하고, 현재 윈도우의 최대 빈도와 비교해 허용된 교체 수를 초과하면 좌측 포인터를 이동한다.

📊 시간/공간 복잡도 분석

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

피드백: 윈도우의 길이가 k 교체 조건을 만족하는지 확인하며 최댓값을 갱신합니다. 해시맵으로 문자별 빈도수를 추적합니다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

palindromic-substrings/dolphinflow86.py

# N is the length of string s.
# TC: O(N^2) - expands around each center (2N - 1 possible centers)
# SC: O(1) - uses only constant extra space
class Solution:

    def expand_around_center(self, s: str, left: int, right: int) -> int:
        sub_count = 0

        while left >= 0 and right < len(s) and s[left] == s[right]:
            sub_count += 1
            left -= 1
            right += 1

        return sub_count

    def countSubstrings(self, s: str) -> int:
        count = 0

        for i in range(len(s)):
            count += self.expand_around_center(s, i, i)
            count += self.expand_around_center(s, i, i + 1)

        return count

• 패턴: Two Pointers, Monotonic Stack, Hash Map / Hash Set
• 설명: 가운데를 중심으로 좌우로 확장하는 방식으로 팰린드롬 부분 문자열을 탐색합니다(센터 확장). 두 가지 중심(같은 문자, 인접한 문자 두 개)에서 확장을 반복하며 부분문자열 개수를 셉니다. 이는 Sliding Window와는 다르고, 중앙 확장 로직으로 두 포인터를 좌우로 이동시키는 패턴에 해당합니다.

📊 시간/공간 복잡도 분석

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

피드백: 각 중심으로 양쪽으로 확장하며 팰린드롬 개수를 누적합니다. 보조 배열 없이 상수 공간으로 구현했습니다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

reverse-bits/dolphinflow86.py

# 1) Iterate 32 times, getting the last bit of n and putting it to res using bitwise operators.
# TC: O(1)
# SC: O(1)
class Solution:
    def reverseBits(self, n: int) -> int:
        res = 0
        for _ in range(32):
            bit = n & 1
            res = (res << 1) | bit
            n >>= 1
        return res

• 패턴: Bit Manipulation
• 설명: 주어진 코드는 비트를 추출하고 재배치하여 비트 역순을 만드므로 Bit Manipulation 패턴에 해당합니다. 고정된 반복(32회)로 비트를 시프트/비트연산으로 처리합니다.

📊 시간/공간 복잡도 분석

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

피드백: 고정된 32비트 순서를 따라 비트를 반전시키는 간단한 루프 방식입니다.

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

[daehyun99]

안녕하세요! 이번 주도 고생 많으셨습니다!!