[dahyeong-yun] WEEK 09 Solutions

[dahyeong-yun]

답안 제출 문제

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

작성자 체크 리스트

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

검토자 체크 리스트

Important

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

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

[dalestudy]

📊 dahyeong-yun 님의 학습 현황

이번 주 제출 문제

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

누적 학습 요약

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

문제 풀이 현황

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

---

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

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

요청	입력 토큰	출력 토큰	합계	비용
1	887	101	988	$0.000085
2	1,886	118	2,004	$0.000141
3	2,209	205	2,414	$0.000192
합계	4,982	424	5,406	$0.000419

[dalestudy]

🏷️ 알고리즘 패턴 분석

linked-list-cycle/dahyeong-yun.java

/**
 * TC : O(n)
 *   - 전체 리스트를 한번 순회하므로 O(n)
 * SC : O(n)
 *   - 최대 n개의 노드를 Set에 저장하므로 O(n)
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> seen = new HashSet<>();
        for(ListNode cur = head; cur !=null; cur = cur.next) {
            if(!seen.add(cur)) return true;
        }
        return false;
    }
}

/**
 * TC : O(n)
 *   - fast가 slow를 따라잡을 때까지 최악의 경우 2n번 노드를 순회하고, slow는 n번 순회하므로 O(n)
 * SC : O(1)
 *   -  slow, fast가 모두 포인터만을 사용하므로 O(1)
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow = head;   
        ListNode fast = head;

        while(fast != null && fast.next != null) {
            slow = slow.next; 
            fast = fast.next.next;

            if(slow == fast) {
                return true;
            }
        }
        return false;
    }
}

• 패턴: Hash Map / Hash Set, Two Pointers, Floyd’s Cycle Detection
• 설명: 첫 번째 함수는 해시셋으로 이미 본 노드를 기억하는 Hash Map / Hash Set 패턴을 사용하고, 두 번째 함수는 느린 포인터와 빠른 포인터를 이용한 Two Pointers(플로이드 사이클 검출) 방식으로 순회하며 순환 여부를 판단합니다.

📊 시간/공간 복잡도 분석

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

풀이 1: Solution.hasCycle — Time: ✅ O(n) → O(n) / Space: ✅ O(n) → O(n)

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

피드백: 해시 세트를 사용해 이미 방문한 노드를 기록하므로 최악의 경우 n개의 노드 공간이 필요하다.

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

풀이 2: Solution.hasCycle — Time: ✅ O(n) → O(n) / Space: ✅ O(1) → O(1)

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

피드백: 추가 자료구조 없이 고정된 두 포인터만으로 사이클 여부를 판단한다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

maximum-product-subarray/dahyeong-yun.java

/**
 * TC : O(n)
 *   - nums 배열의 길이만큼 순회하므로 O(n)
 * SC : O(1)
 *   - int 변수만 사용하고 있으므로 O(1)
 */
class Solution {
    public int maxProduct(int[] nums) {
        int len = nums.length;
        if(len == 1) return nums[0];
        
        int answer = nums[0];
        int max = nums[0];
        int min = nums[0];
        
        for(int i = 1; i < len; i++) {
            int current = nums[i];
            int productFromMax = max * nums[i];
            int productFromMin = min * nums[i];

            max = Math.max(Math.max(current, productFromMax), productFromMin);
            min = Math.min(Math.min(current, productFromMax), productFromMin);

            answer = Math.max(max, answer);
        }
        
        return answer;
    }
}

• 패턴: Dynamic Programming, Bit Manipulation
• 설명: 연속 부분 배열의 최대 곱을 현재 위치에서의 최대/최소 곱으로 갱신하는 방식으로 DP 패턴을 사용합니다. 각 스텝에서 최대/최소 곱의 후보를 비교하여 전진하며, 부분 문제 결과를 이용해 전체 해를 구합니다.

📊 시간/공간 복잡도 분석

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

피드백: 현재 배열 길이만큼 순회하고 상수 공간으로 동작한다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

pacific-atlantic-water-flow/dahyeong-yun.java

/**
 * heights 의 행의 갯수 m, 열의 갯수를 n 이라 할 때,
 * 
 * TC : O
 *   - m * n 만큼 순회 하므로 O(m * n)
 * SC : O(m * n)
 *   - m * n 크기의 boolean 배열을 2개 사용하므로 O(m * n) 
 * 
*
 * [최악의 콜스택 깊이 O(m * n) 예시 행렬 (4x4, 총 16개 셀)]
 * 
 * 숫자가 1부터 16까지 1씩 증가하며 단 하나의 경로로만 이어지는 형태:
 * 
 *  (0,0) [ 1] -> [ 2] -> [ 3] -> [ 4]
 *                                  |
 *  (1,0) [ 8] <- [ 7] <- [ 6] <- [ 5]
 *          |
 *  (2,0) [ 9] -> [10] -> [11] -> [12]
 *                                  |
 *  (3,0) [16] <- [15] <- [14] <- [13]
 * 
 * - (0, 0)에서 Pacific DFS 시작 시:
 *   1 -> 2 -> 3 -> ... -> 15 -> 16 까지 리턴 없이 단일 경로로 쭉 재귀 호출됨.
 * - 결과: 16(m * n)개의 함수 호출 프레임이 스택에 동시에 쌓여 최대 깊이 도달.
 */
class Solution {
    int [][] heights;
    int rowLimit = 0;
    int colLimit = 0;
    int[][] directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

    public List<List<Integer>> pacificAtlantic(int[][] heights) {   
        this.heights = heights;
        this.rowLimit = heights.length;
        this.colLimit = heights[0].length;    

        boolean[][] pacific = new boolean[rowLimit][colLimit];
        boolean[][] atlantic = new boolean[rowLimit][colLimit];

        for(int row = 0; row < rowLimit; row++) {
            dfs(row, 0, heights[row][0], pacific);
            dfs(row, colLimit - 1, heights[row][colLimit - 1], atlantic);
        }

        for(int col = 0; col < colLimit; col++) {
            dfs(0, col, heights[0][col], pacific);
            dfs(rowLimit - 1, col, heights[rowLimit - 1][col], atlantic);
        }

        List<List<Integer>> answer = new ArrayList<>();
        for(int row = 0; row < rowLimit; row++) {
            for(int col = 0; col < colLimit; col++) {
                if(pacific[row][col] && atlantic[row][col]) {
                    List<Integer> comb = List.of(row, col);
                    answer.add(comb);
                }
                
            }
        }
        return answer;
    }

    public void dfs(int row, int col, int prevHeight, boolean[][] oceanFlag) {
        if(row < 0 || col < 0 || row >= rowLimit || col >= colLimit) return; 
        if(oceanFlag[row][col] || this.heights[row][col] < prevHeight) return;

        oceanFlag[row][col] = true;

        for(int[] d : directions) {
            dfs(row + d[0], col + d[1], this.heights[row][col], oceanFlag);
        }
    }
}

• 패턴: Depth-First Search, Backtracking
• 설명: 코드는 각 바다에서 도달 가능한 칸을 DFS로 탐색하고, 두 해안으로 침투 가능한지 여부를 flags에 표시합니다. 재귀적 DFS 호출 및 방문 체크로 탐색 공간을 순차적으로 탐색하는 구조입니다.

📊 시간/공간 복잡도 분석

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

피드백: 각 셀마다 한 번씩 DFS가 호출되어 각 방향 배열에 방문 여부를 기록한다. 두 번의 DFS 탐색으로 전체 격자를 커버하므로 시간과 공간 복잡도는 격자 크기에 비례한다.

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

[dalestudy]

🏷️ 알고리즘 패턴 분석

sum-of-two-integers/dahyeong-yun.java

/**
 * TC : O(1)
 *   - carry가 매번 발생해도 int primitives의 비트 수가 32이므로 최대 32번 반복
 * SC : O(1)
 */
class Solution {
    public int getSum(int a, int b) {
        while(b != 0) {
            int carry = (a & b) << 1;
            a = a ^ b;
            b = carry;
        }
        return a;
    }
}

• 패턴: Bit Manipulation
• 설명: 두 정수의 합을 비트 연산으로 구현한 코드로, 비트 연산으로 자리 올림(carry)과 합을 반복적으로 처리하는 비트 패턴이다. 반복은 carry가 0이 될 때까지 진행되며, 결국 합이 만들어진다.

📊 시간/공간 복잡도 분석

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

피드백: 비트 연산만으로 합을 구하는 루프를 사용했고, 32비트 정수 한계 내에서 carry가 끝나도록 구현되어 있습니다.

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

[njngwn]

2가지 방법으로 풀어보신게 좋네요!! 코드도 깔끔하구요 👍

[njngwn]

이 코드가 없어도 어차피 반복문을 안돌고 answer가 반환될 것 같은데, 굳이 넣으신 이유가 있을까요?

[njngwn]

dfs에 매개변수로 넘기는 것도 고려해보면 좋을 것 같습니다!
코딩테스트에서는 상관없거나 조금 과할 수도 있을 것 같긴 한데,

• dfs가 외부 상태(this.heights 등)에 의존하지 않게 되어서, 이 Solution 인스턴스가 재사용되거나 여러 스레드에서 동시에 호출될 때 상태가 꼬일 위험이 없어질 것 같습니다.
• 또 dfs 시그니처만 봐도 이 함수가 뭘 필요로 하는지 바로 드러나서, 나중에 이 함수만 따로 읽거나 테스트할 때도 더 편할 것 같습니다.

다만 파라미터가 늘어나는 트레이드오프는 있어서, 지금처럼 코딩테스트용으로 1회성 로직이면 지금 방식도 충분히 괜찮을 것 같네요!

[njngwn]

알고리즘 설명이 되어있어 좋네요! 수고 많으셨습니다!!