[alphaorderly] WEEK 07 Solutions

[alphaorderly]

답안 제출 문제

• Reverse Linked List #223
• Longest Substring Without Repeating Characters #243
• Number of Islands #258
• Unique Paths #273
• Set Matrix Zeroes #283

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

📊 alphaorderly 님의 학습 현황

이번 주 제출 문제

문제	난이도	유형 분석
longest-substring-without-repeating-characters	Medium	✅ 의도한 유형
number-of-islands	Medium	✅ 의도한 유형
reverse-linked-list	Easy	✅ 의도한 유형
set-matrix-zeroes	Medium	✅ 의도한 유형
unique-paths	Medium	✅ 의도한 유형

누적 학습 요약

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

문제 풀이 현황

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

---

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

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

요청	입력 토큰	출력 토큰	합계	비용
1	2,225	179	2,404	$0.000183
2	3,371	216	3,587	$0.000255
3	3,352	220	3,572	$0.000256
4	3,335	212	3,547	$0.000252
5	3,335	207	3,542	$0.000250
6	3,337	241	3,578	$0.000263
7	3,335	260	3,595	$0.000271
합계	22,290	1,535	23,825	$0.001729

[alphaorderly]

2D DP에서 dp 내용을 출력하고
대각선으로 보면 Pascal Triangle이 만들어집니다.
이것대로 Combination 연산으로 하셔도 맨 아래 코드를 얻을수 있으세요!

[dalestudy]

🏷️ 알고리즘 패턴 분석

• 패턴: Sliding Window, Hash Map / Hash Set
• 설명: 두 포인터(left, right)로 연속 부분 문자열을 창/window로 확장 축소하며 서로 다른 문자만 남도록 중복 여부를 해시 맵으로 관리하는 방식이다. 이는 길이가 최대로 되는 모든 고유 부분 문자열을 찾는 일반적인 Sliding Window 패턴에 해당한다.

📊 시간/공간 복잡도 분석

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

피드백: 슬라이딩 윈도우와 해시맵(딕셔너리) 활용으로 각 문자 등장 여부를 관리한다. right 증가에 따라 중복이 생기면 left를 이동시키며 윈도우 크기를 조정한다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

• 패턴: Depth-First Search, Breadth-First Search, Hash Map / Hash Set
• 설명: 코드는 BFS와 DFS 두 가지 방식으로 섬을 탐색하며, 방문 여부를 표시하기 위해 격자 데이터를 '#''로 바꿉니다. 두 구현 모두 인접한 땅을 탐색하고 섬의 수를 증가시키는 패턴을 보이며, 방문 관리에 추가 데이터 구조를 사용하지 않는 점에서 해시 맵/세트의 직접 사용은 보조적으로 판단됩니다.

📊 시간/공간 복잡도 분석

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

풀이 1: Solution.numIslands — Time: O(m * n) / Space: O(m * n)

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 두 가지 구현이 제시되어 있으며 모두 탐색으로 모든 육지('1')를 방문한다. 방문 여부를 표시하기 위해 grid를 변형하여 추가 공간을 사용하지 않는다.

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

풀이 2: Solution.numIslands — Time: O(m * n) / Space: O(m * n)

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 재귀를 이용한 DFS로 모든 연결된 육지를 탐색한다. 스택을 사용하는 구현과 동일한 시간/공간 복잡도다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

• 패턴: Two Pointers, Linked List
• 설명: 헤드와 프리브 포인터를 이용해 linked list를 역순으로 순회하며 노드 연결을 재설정하는 전형적인 투 포인터 기법. 공간 복잡도 O(1), 반복 구조로 리스트를 한 번 순회한다.

📊 시간/공간 복잡도 분석

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

피드백: 단일 포인터를 활용해 앞 노드와 현재 노드의 연결을 역전한다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

• 패턴: Dynamic Programming, Greedy, Hash Map / Hash Set
• 설명: 이 코드는 행/열의 플래그를 첫 행/열을 임시 저장소로 활용하는 방식으로 제로를 표시하는 패턴이다. 공간을 추가로 사용하지 않고 원래 배열의 행/열을 이용해 조건을 전파하므로 일반적으로 최적화된 탐색/표시 기법으로 분류된다.

📊 시간/공간 복잡도 분석

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

피드백: 첫 행/열을 마커로 활용하는 표준 최적화 방법을 택했다. 초기 상태를 따로 확인하여 경계 케이스를 처리한다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

• 패턴: Dynamic Programming, Combinatorial, Memoization
• 설명: 다양한 구현에서 2D/1D DP를 이용한 최단 경로의 경우의 수를 계산하고, 재귀+캐시(메모이제이션) 패턴으로 중복 계산을 줄이는 사례가 포함되어 있습니다. 또한 재귀 기반의 상향식 DP를 보완하는 memoization 기법이 사용됩니다.

📊 시간/공간 복잡도 분석

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

풀이 1: Solution.uniquePaths — Time: O(m * n) / Space: O(m * n)

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 여러 접근 방식이 포함되어 있지만 각각의 구현은 서로 다른 공간/시간 특성을 가진다. 문제에 따라 선택적으로 사용할 수 있다.

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

풀이 2: Solution.uniquePaths — Time: O(m * n) / Space: O(n)

	복잡도
Time	O(m * n)
Space	O(n)

피드백: 행마다 열의 경로를 누적 업데이트하여 공간을 줄인다.

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

풀이 3: Solution.uniquePaths — Time: O(1) / Space: O(1)

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

피드백: 팩토리얼 기반의 조합 계산으로 시간 복잡도는 입력에 따라 달라지지만 일반적으로 상수 계수의 차이가 있다.

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

풀이 4: Solution.uniquePaths — Time: O(m * n) / Space: O(m * n)

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 재귀 기반의 방법으로 중복되는 부분 문제를 저장해 효율을 유지한다.

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

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

[parkhojeong]

수고하셨습니다. 풀이와 관계 없는 커밋은 정리 부탁드립니다.

[parkhojeong]

left를 하나씩 옮기지 않고 중복되는 인덱스 바로 다음으로 옮겨주는 방식으로 최적화 해볼 수 있을 거 같네요

[parkhojeong]

row_check, col_check가 어떤 의미인지 알기는 어려운 거 같아서 적절한 네이밍 해주시면 좋을 거 같습니다.

[parkhojeong]

오 이렇게도 풀 수 있군요. 패턴이 있는 거 같아 보이긴 했는데 수식 도출이 잘 안되더라구요. 이런 풀이 아이디어는 어떻게 얻으셨는지 궁금하네요.

[parkhojeong]

첫 노드를 가리키는 head가 순회하는 노드로 사용되어서 실제로는 두 가지 의미를 가지는 거 같습니다. 순회 중인 노드를 위한 별도의 변수를 사용하는게 어떨까요?

[dalestudy]

🏷️ 알고리즘 패턴 분석

longest-substring-without-repeating-characters/alphaorderly.py

"""
Time Complexity: O(n)
Space Complexity: O(n)

Approach:
- Use a defaultdict to track the count of each character in the current window.
- Maintain two pointers, 'left' and 'right', to represent the sliding window over the string.
- As we iterate over the string with 'right', increment the count for the current character.
- If a duplicate character appears in the window (count > 1), move the 'left' pointer forward and decrement counts until there are no duplicates.
- After adjusting, update 'ans' with the maximum length found for a window with all unique characters.
"""
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        count = defaultdict(int)
        ans = left = 0

        for right, val in enumerate(s):
            count[val] += 1

            while count[val] > 1:
                count[s[left]] -= 1
                left += 1

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

        return ans

• 패턴: Sliding Window, Hash Map / Hash Set
• 설명: 두 포인터(left, right)로 부분 문자열 창을 확장/축소하며 중복 문자를 해시 맵으로 추적한다. 중복 발생 시 창을 좌측으로 좁혀 길이가 서로 다른 부분 문자열의 최대 길이를 구한다.

📊 시간/공간 복잡도 분석

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

피드백: 현재 구현은 투 포인터와 해시맵으로 모든 문자를 한 번씩 방문하므로 최악의 경우 선형 시간과 선형 공간이 필요합니다.

개선 제안: 고려해볼 만한 대안: 카운트 대신 인덱스 저장 방식으로 구현하면 불필요한 카운트를 줄이고, 딕셔너리 대신 배열 기반 인덱스 매핑을 사용해 상수 공간에 가깝게 최적화 가능.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

number-of-islands/alphaorderly.py

"""
Time Complexity: O(m * n)
Space Complexity: O(m * n)

### BFS Approach ###

Approach:
- Use BFS to traverse all parts of each island in the grid.
- Employ a queue to process all adjacent land cells iteratively.
- Use a 'bound' helper function to check if a cell is within the grid bounds.
- In 'island_marker', mark visited '1's with '#' to avoid revisiting.
- For every cell in the grid, when a land cell ('1') is encountered, initiate BFS and increment the island count.
"""
class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        DIR = [[0, 1], [1, 0], [-1, 0], [0, -1]]
        ROW = len(grid)
        COL = len(grid[0])

        def bound(row: int, col: int) -> bool:
            return 0 <= row < ROW and 0 <= col < COL

        def island_marker(row: int, col: int) -> None:
            q = deque([(row, col)])
            grid[row][col] = "#"

            while q:
                r, c = q.popleft()

                for dr, dc in DIR:
                    tr, tc = r + dr, c + dc

                    if not bound(tr, tc) or grid[tr][tc] != "1":
                        continue

                    grid[tr][tc] = "#"
                    q.append((tr, tc))

        ans = 0

        for r in range(ROW):
            for c in range(COL):
                if grid[r][c] == "1":
                    island_marker(r, c)
                    ans += 1

        return ans

"""
Time Complexity: O(m * n)
Space Complexity: O(m * n)

### DFS Approach ###

Approach:
- Use DFS to traverse all parts of each island in the grid.
- Visitation is done recursively rather than with a stack, so stack comment is removed for clarity.
- Use a 'bound' helper function to check if a cell is within the grid bounds.
- In 'island_marker', mark visited '1's with '#' to avoid revisiting.
- For every cell in the grid, when a land cell ('1') is encountered, initiate DFS and increment the island count.
"""
class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        DIR = [[0, 1], [1, 0], [-1, 0], [0, -1]]
        ROW = len(grid)
        COL = len(grid[0])

        def bound(row: int, col: int) -> bool:
            return 0 <= row < ROW and 0 <= col < COL

        def island_marker(row: int, col: int) -> None:
            grid[row][col] = '#'

            for dr, dc in DIR:
                tr, tc = row + dr, col + dc
                if bound(tr, tc) and grid[tr][tc] == '1':
                    island_marker(tr, tc)

        ans = 0

        for r in range(ROW):
            for c in range(COL):
                if grid[r][c] == "1":
                    island_marker(r, c)
                    ans += 1

        return ans

• 패턴: Depth-First Search, Breadth-First Search, Hash Map / Hash Set
• 설명: 코드에서 섬을 모양대로 탐색하며 인접한 땅을 방문 처리한다. DFS 구현은 재귀로, BFS 구현은 큐로 너비 우선 탐색을 이용한다. 방문 여부는 '#''로 마킹하는 방식으로 관리되며, 같은 원소를 다시 방문하지 않는다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 두 가지 구현이 제시되었고, 둘 다 전체 격자를 한 번 이상 탐색합니다. 추가 메모리 사용은 BFS가 큰 차지입니다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

reverse-linked-list/alphaorderly.py

"""
Time Complexity: O(n)
Space Complexity: O(1)

- We use a while loop to traverse the linked list.
- We use a prev pointer to store the previous node.
- We use a head pointer to store the current node.
- We use a old_next pointer to store the next node.
- We use a prev, head = head, old_next to update the prev and head pointers.
- We return the prev pointer.
"""

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev = None

        while head:
            prev, head.next, head = head, prev, head.next

        return prev

• 패턴: Two Pointers, Linked List, Greedy, Dynamic Programming
• 설명: 헤드와 프리브 포인터를 이용해 단방향 연결리스트를 역순으로 순회하면서 포인터를 업데이트하는 방식으로 구현되어 있습니다. 한 번의 순회로 O(n) 시간, O(1) 추가 공간으로 역순 리스트를 만듭니다.

📊 시간/공간 복잡도 분석

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

피드백: 상수 공간으로 단방향 리스트를 역전하는 표준 패턴을 사용합니다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

set-matrix-zeroes/alphaorderly.py

"""
Time Complexity: O(m * n)
Space Complexity: O(1)

Approach:
- Use the first row and first column as markers to track which rows and columns should be zeroed.
- First, check if the original first row or first column should be zeroed by scanning them separately.
- Then, scan the rest of the matrix. If an element is zero, set its corresponding first row and first column positions to zero.
- Next, iterate through the matrix (excluding the first row and column) and set elements to zero if their corresponding first row or first column are zero.
- Finally, zero the first row and/or first column if initially flagged.
"""
class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        ROW = len(matrix)
        COL = len(matrix[0])

        row_zero_check = any(matrix[0][c] == 0 for c in range(COL))
        col_zero_check = any(matrix[r][0] == 0 for r in range(ROW))

        for r in range(ROW):
            for c in range(COL):
                if matrix[r][c] == 0:
                    matrix[r][0] = 0
                    matrix[0][c] = 0

        for r in range(1, ROW):
            for c in range(1, COL):
                if matrix[r][0] == 0 or matrix[0][c] == 0:
                    matrix[r][c] = 0

        if row_zero_check:
            for c in range(COL):
                matrix[0][c] = 0

        if col_zero_check:
            for r in range(ROW):
                matrix[r][0] = 0

• 패턴: Two Pointers, Greedy, Dynamic Programming, Hash Map / Hash Set, Bit Manipulation, Divide and Conquer, Union Find, Trie, BFS, DFS, Backtracking, Heap / Priority Queue, Monotonic Stack, Binary Search, Sliding Window
• 설명: 이 코드는 공간 절약을 위해 행/열을 표시기로 재활용하는 방식으로 0의 위치를 전파한다. 행과 열 표시를 통해 제자리에서 스캔하며 조건에 맞는 원소를 0으로 설정하는 기법은 대표적인 Sliding Window가 아닌, 공간 효율적 마커 활용 패턴이다.

📊 시간/공간 복잡도 분석

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

피드백: 두 개의 플래그와 행/열 마커를 이용해 상수 공간으로 처리합니다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

unique-paths/alphaorderly.py

"""
Time Complexity: O(m * n)
Space Complexity: O(m * n)

Dynamic Programming (2D DP approach):
- Use a 2D array where maze[i][j] represents the number of unique paths to cell (i, j).
- Initialize the first row and first column with 1 (since there's only one way to reach each cell: only right moves for the first row or only down moves for the first column).
- For all other cells, maze[i][j] = maze[i-1][j] + maze[i][j-1] (sum of paths from the cell above and the cell to the left).
- Return maze[m-1][n-1] as the answer, which is the total number of unique paths.
"""
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        maze = [[1] * n for _ in range(m)]

        for i in range(1, m):
            for j in range(1, n):
                maze[i][j] = maze[i - 1][j] + maze[i][j - 1]

        return maze[m - 1][n - 1]

"""
Time Complexity: O(m * n)
Space Complexity: O(n)

Dynamic Programming (1D DP optimization):
- Use a 1D array dp of size n.
- dp[c] keeps track of the number of unique paths to column c in the current row.
- Initialize dp with 1s (the first row has only one way to reach each column).
- For every row from the second onward, update dp[c] = dp[c] + dp[c - 1] (add ways from the left neighbor to ways accumulated so far).
- Return dp[-1] as the answer, representing the number of unique paths to the bottom-right cell.
"""
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [1] * n

        for _ in range(m - 1):
            for c in range(1, n):
                dp[c] += dp[c - 1]

        return dp[-1]

"""
Time Complexity: O(m + n)
Space Complexity: O(1)

Combinatorial approach:
- The problem reduces to choosing (m-1) moves down from (m+n-2) total movements (or equivalently (n-1) moves right).
- The number of unique paths is given by the formula (m+n-2)! / [(m-1)! * (n-1)!], representing all possible orderings of down and right moves.
- Use the combinatorial (factorial) formula to compute the result efficiently.
"""
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        return comb(m + n - 2, n - 1)

"""
Time Complexity: O(m * n)
Space Complexity: O(m * n)

### Top down dynamic programming (with memoization) ###

Approach:
- Use recursion with memoization (via functools.cache) to store the number of unique paths to (row, col).
- The recursive function dp(row, col) returns the number of unique paths from the top-left to (row, col).
- Base case: If row == 1 or col == 1, there's only one unique path.
- Otherwise, dp(row, col) = dp(row-1, col) + dp(row, col-1).
- The answer is dp(m, n), the number of unique paths to the bottom-right cell.
"""
class Solution:
    @cache
    def uniquePaths(self, m: int, n: int) -> int:
        return 1 if (m == 1 or n == 1) else self.uniquePaths(m - 1, n) + self.uniquePaths(m, n - 1)

• 패턴: Dynamic Programming, Monotonic Stack, Hash Map / Hash Set, Greedy, Divide and Conquer, Two Pointers, Sliding Window, Fast & Slow Pointers, BFS, DFS, Backtracking, Union Find, Trie, Bit Manipulation, Heap / Priority Queue
• 설명: 주로 2D/1D DP로 문제를 해결하는 패턴이 사용되며, 최단 경로 수를 구하는 대표적인 다이나믹 프로그래밍(DP) 패턴(메모이제이션, 바텀업, 공간 최적화)과 재귀 + 메모이제이션(탐색 기반 DP)이 포함됩니다. 다른 패턴은 사용되지 않습니다.

📊 시간/공간 복잡도 분석

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 다양한 솔루션이 제시되어 있어 선택의 폭이 넓습니다. 기본 DP 접근이 가장 직관적입니다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

set-matrix-zeroes/alphaorderly.py

"""
Time Complexity: O(m * n)
Space Complexity: O(1)

Approach:
- Use the first row and first column as markers to track which rows and columns should be zeroed.
- First, check if the original first row or first column should be zeroed by scanning them separately.
- Then, scan the rest of the matrix. If an element is zero, set its corresponding first row and first column positions to zero.
- Next, iterate through the matrix (excluding the first row and column) and set elements to zero if their corresponding first row or first column are zero.
- Finally, zero the first row and/or first column if initially flagged.
"""
class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        ROW = len(matrix)
        COL = len(matrix[0])

        row_check = any(matrix[0][c] == 0 for c in range(COL))
        col_check = any(matrix[r][0] == 0 for r in range(ROW))

        for r in range(ROW):
            for c in range(COL):
                if matrix[r][c] == 0:
                    matrix[r][0] = 0
                    matrix[0][c] = 0

        for r in range(1, ROW):
            for c in range(1, COL):
                if matrix[r][0] == 0 or matrix[0][c] == 0:
                    matrix[r][c] = 0

        if row_check:
            for c in range(COL):
                matrix[0][c] = 0

        if col_check:
            for r in range(ROW):
                matrix[r][0] = 0

• 패턴: Two Pointers, Monotonic Stack, Hash Map / Hash Set, Greedy, Dynamic Programming, Binary Search, BFS, DFS, Backtracking, Divide and Conquer, Union Find, Trie, Bit Manipulation, Heap / Priority Queue
• 설명: 주어진 코드는 추가 메모리 없이 행과 열의 정보를 행/열의 첫 행과 첫 열의 마커로 재사용하는 방식으로 0으로 만드는 문제다. 이를 통해 추가 배열 없이 제로 위치를 표시하고 순차적으로 값을 바꾸는 방식은 공간 절약 패턴의 대표적인 예로 'Two Pointers'식 접근과 인덱스 마커를 활용한 제로 배치로 해석할 수 있다.

📊 시간/공간 복잡도 분석

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

피드백: 공간 절약을 위해 첫 행/열을 마커로 재활용하고 초기 상태를 확인해 제로링을 마친 뒤 다시 첫 행/열을 처리하는 방식입니다.

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

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

unique-paths/alphaorderly.py

"""
Time Complexity: O(m * n)
Space Complexity: O(m * n)

Dynamic Programming (2D DP approach):
- Use a 2D array where maze[i][j] represents the number of unique paths to cell (i, j).
- Initialize the first row and first column with 1 (since there's only one way to reach each cell: only right moves for the first row or only down moves for the first column).
- For all other cells, maze[i][j] = maze[i-1][j] + maze[i][j-1] (sum of paths from the cell above and the cell to the left).
- Return maze[m-1][n-1] as the answer, which is the total number of unique paths.
"""
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        maze = [[1] * n for _ in range(m)]

        for i in range(1, m):
            for j in range(1, n):
                maze[i][j] = maze[i - 1][j] + maze[i][j - 1]

        return maze[m - 1][n - 1]

"""
Time Complexity: O(m * n)
Space Complexity: O(n)

Dynamic Programming (1D DP optimization):
- Use a 1D array dp of size n.
- dp[c] keeps track of the number of unique paths to column c in the current row.
- Initialize dp with 1s (the first row has only one way to reach each column).
- For every row from the second onward, update dp[c] = dp[c] + dp[c - 1] (add ways from the left neighbor to ways accumulated so far).
- Return dp[-1] as the answer, representing the number of unique paths to the bottom-right cell.
"""
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [1] * n

        for _ in range(m - 1):
            for c in range(1, n):
                dp[c] += dp[c - 1]

        return dp[-1]

"""
Time Complexity: O(m + n)
Space Complexity: O(1)

Combinatorial approach:
- The problem reduces to choosing (m-1) moves down from (m+n-2) total movements (or equivalently (n-1) moves right).
- The number of unique paths is given by the formula (m+n-2)! / [(m-1)! * (n-1)!], representing all possible orderings of down and right moves.
- Use the combinatorial (factorial) formula to compute the result efficiently.
"""
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        return comb(m + n - 2, n - 1)

"""
Time Complexity: O(m * n)
Space Complexity: O(m * n)

### Top down dynamic programming (with memoization) ###

Approach:
- Use recursion with memoization (via functools.cache) to store the number of unique paths to (row, col).
- The recursive function dp(row, col) returns the number of unique paths from the top-left to (row, col).
- Base case: If row == 1 or col == 1, there's only one unique path.
- Otherwise, dp(row, col) = dp(row-1, col) + dp(row, col-1).
- The answer is dp(m, n), the number of unique paths to the bottom-right cell.
"""
class Solution:
    @cache
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 1 or n == 1:
            return 1

        return self.uniquePaths(m - 1, n) + self.uniquePaths(m, n - 1)

• 패턴: Dynamic Programming, Binary Search
• 설명: 주로 2D/1D DP로 격자 경로의 합을 구하거나 재귀+메모화로 해를 찾는 방식이 핵심이므로 Dynamic Programming이 주 패턴이고, 주어진 코드는 최단 경로와 조합 수를 DP로 정확히 계산합니다. Binary Search 패턴은 본 코드에 해당하지 않습니다.

📊 시간/공간 복잡도 분석

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

풀이 1: Solution.uniquePaths — Time: O(m * n) / Space: O(m * n)

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 2D DP 배열을 사용해 모든 경로 수를 누적 계산합니다. 직관적이지만 공간 사용이 큽니다.

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

풀이 2: Solution.uniquePaths — Time: O(m * n) / Space: O(n)

	복잡도
Time	O(m * n)
Space	O(n)

피드백: 행 순회 시 현재 열의 경로 수를 왼쪽 이웃과 합쳐 갱신하므로 추가 배열 없이도 결과를 구합니다.

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

풀이 3: Solution.uniquePaths — Time: O(1) / Space: O(1)

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

피드백: 결합 계산으로 해를 직접 구하는 방법으로 최적의 시간/공간을 제공합니다(팩토리얼 필요 시 큰 수 주의).

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

풀이 4: Solution.uniquePaths — Time: O(m * n) / Space: O(m * n)

	복잡도
Time	O(m * n)
Space	O(m * n)

피드백: 재귀 + 캐시로 중복 계산을 피하지만 스택 깊이 및 메모리 사용이 증가합니다.

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

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

[alphaorderly]

@parkhojeong
나중에 리뷰 부탁드려요! 코드 수정을 하니까 다시 취소가 되었네요