Merge remote-tracking branch 'origin/main'

# Conflicts:
#	longest-common-subsequence/jinvicky.java

Author: jinvicky

container-with-most-water/jinvicky.java

@@ -11,7 +11,7 @@ public int maxArea(int[] height) {
 
         while (start < end) {
             int y = Math.min(height[start], height[end]); // y축은 더 작은 값으로 설정
-            int x = Math.abs(start - end);
+            int x = Math.abs(start - end); // end - start도 가능
             int calculatedArea = x * y;
             area = Math.max(area, calculatedArea);
 

linked-list-cycle/jinvicky.java

@@ -0,0 +1,18 @@
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    /**
+     * 문제에서 말하는 pos는 설명을 돕는 사이클 발생 위치이지 코드 상에서 사용하지 않는다.
+     */
+    public boolean hasCycle(ListNode head) {
+        Set<Integer> set = new HashSet<>();
+        while(head != null) {
+            // set에서 이미 존재하는 숫자가 있으면 바로 return true;
+            // set.add() 메서드는 추가 성공 시 true, 이미 존재하는 숫자면 추가하지 못하고 false를 반환한다.
+            if(!set.add(head.val)) return true;
+            head = head.next;
+        }
+        return false;
+    }
+}

longest-common-subsequence/jinvicky.java

@@ -2,17 +2,20 @@ class Solution {
     public int longestCommonSubsequence(String text1, String text2) {
         int m = text1.length();
         int n = text2.length();
-        int[][] dp = new int[m + 1][n + 1];
 
-        for (int i = 1; i <= m; i++) {
-            for (int j = 1; j <= n; j++) {
-                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
-                    dp[i][j] = dp[i - 1][j - 1] + 1;  // 문자가 같으면 대각선 값 + 1
+        int[][] dp = new int[m+1][n+1];
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                // DP 계산을 +1로 했어야 했는데 이전 케이스를 재사용하는 -1로만 접근해서 범위 에러가 많이 났었다.
+                if (text1.charAt(i) == text2.charAt(j)) {
+                    dp[i + 1][j + 1] = dp[i][j] + 1;
                 } else {
-                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);  // 위 or 왼쪽 중 큰 값
+                    dp[i + 1][j + 1] = Math.max(dp[i][j + 1], dp[i + 1][j]);
                 }
             }
         }
+
         return dp[m][n];
     }
 }

longest-substring-without-repeating-characters/jinvicky.java

@@ -0,0 +1,33 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    /**
+     * 초기에 중복체크를 위해 HashSet으로 풀었다가 예외 케이스가 발생해서 이전 문자의 인덱스 위치를 알아야 함을 깨닫고
+     * HashMap으로 문자:인덱스 쌍을 저장했다.
+     * 자료구조와 반복문의 흐름은 맞았으나 중복 발견 시 left를 Math.max()로 2가지 케이스를 모두 비교하지 않아서 문제 발생
+     * 기존 left와 해당 문자의 마지막 인덱스 중 더 큰값을 선택한다.
+     */
+    public int lengthOfLongestSubstring(String s) {
+        if (s == null || s.isEmpty()) return 0;
+
+        Map<Character, Integer> last = new HashMap<>();
+        int left = 0, maxLen = 0;
+
+        for (int right = 0; right < s.length(); right++) {
+            char ch = s.charAt(right);
+
+            // VIP:: left를 오른쪽으로 밀거나(left+=) left를 유지한다.
+            // 왜 left를 가능한 한 오른쪽으로 업데이트할까? -> 그래야 중복 제거된 온전한 슬라이딩 윈도우를 유지할 수 있기 때문이다.
+            // abba의 경우 두번째 b, 두번째 a가 이에 해당한다.
+            // last(b) = max(0, 1+1=2) -> 2
+            // last(a) = max(2, 0+1=1) -> 2
+            if (last.containsKey(ch)) {
+                left = Math.max(left, last.get(ch) + 1);
+            }
+            maxLen = Math.max(maxLen, right - left + 1);
+            last.put(ch, right); // 방금 문자의 '마지막 위치' 갱신
+        }
+        return maxLen;
+    }
+}

maximum-product-subarray/jinvicky.java

@@ -0,0 +1,33 @@
+class Solution {
+    public int maxProduct(int[] nums) {
+        if (nums.length == 1)
+            return nums[0];
+        if (nums.length == 2) {
+            return Math.max(nums[0], Math.max(nums[0] * nums[1], nums[1]));
+        }
+
+        int len = nums.length;
+        int[] max = new int[len];
+        int[] min = new int[len];
+        int overall = 0;
+
+        max[0] = min[0] = overall = nums[0];
+
+        for (int i = 1; i < len; i++) {
+            // 후보 3을 준비
+            int justNum = nums[i];
+            // 계속 더한 값
+            int keep = justNum * max[i-1];
+            // 이전 최소에 음수 곱해서 리버스
+            int reverse = justNum * min[i-1];
+
+            // max와 min 배열을 업데이트
+            max[i] = Math.max(justNum, Math.max(keep, reverse));
+            min[i] = Math.min(justNum, Math.min(keep, reverse));
+
+            // overall을 업데이트, 누적 비교로 최대 전역 유지
+            overall = Math.max(overall, max[i]);
+        }
+        return overall;
+    }
+}

number-of-islands/jinvicky.java

@@ -0,0 +1,128 @@
+public class jinvicky {
+}
+
+/**
+ * 일관성을 위해 모든 변수들을 메서드 내 lv로 선언해서 푸는 것으로 한다.
+ * dfs를 설계할 때 특히 반환 타입에 약한데 void인가 int,booelan 등 기타 타입인가를 확실히 하기 위해 별도 예제로 풀었다.
+ * 또한 의도적으로 기존 grid를 1 -> 0으로 바꾸어 섬을 없애지 않고 공간복잡도가 증가하더라도 학습을 위해 방문 배열을 별도로 선언해 방문 여부를 체크했다.
+ */
+class Solution {
+    public int numIslands1(char[][] grid) {
+        if (grid == null || grid.length == 0) return 0;
+        int rows = grid.length, cols = grid[0].length;
+        boolean[][] visited = new boolean[rows][cols];
+
+        int count = 0;
+        for (int r = 0; r < rows; r++) {
+            for (int c = 0; c < cols; c++) {
+                if (grid[r][c] == '1' && !visited[r][c]) {
+                    int size = dfsByInt(grid, visited, r, c, rows, cols);
+                    if (size > 0) count++; // 크기가 양수면 섬 1개
+                }
+            }
+        }
+        return count;
+    }
+
+    // dfs는 해당 섬의 넓이를 반환
+    private int dfsByInt(char[][] grid, boolean[][] visited, int r, int c, int rows, int cols) {
+        if (r < 0 || c < 0 || r >= rows || c >= cols) return 0; // 범위를 벗어났다.
+        if (grid[r][c] == '0' || visited[r][c]) return 0; // 문제의 조건에 맞지 않거나, 이미 방문했다.
+
+        visited[r][c] = true; // 방문 처리
+        int area = 1;
+
+        area += dfsByInt(grid, visited, r + 1, c, rows, cols);
+        area += dfsByInt(grid, visited, r - 1, c, rows, cols);
+        area += dfsByInt(grid, visited, r, c + 1, rows, cols);
+        area += dfsByInt(grid, visited, r, c - 1, rows, cols);
+
+        return area;
+    }
+
+    public int numIslands(char[][] grid) {
+        if (grid == null || grid.length == 0) return 0;
+        int rows = grid.length, cols = grid[0].length;
+
+        boolean[][] visited = new boolean[rows][cols];
+        int count = 0;
+
+        for (int r = 0; r < rows; r++) {
+            for (int c = 0; c < cols; c++) {
+                if (grid[r][c] == '1' && !visited[r][c]) {
+                    dfs(grid, visited, r, c, rows, cols);
+                    count++; // 섬 하나 탐색 끝나면 +1
+                }
+            }
+        }
+        return count;
+    }
+
+    private void dfs(char[][] grid, boolean[][] visited, int r, int c, int rows, int cols) {
+        if (r < 0 || c < 0 || r >= rows || c >= cols) return; // 그리드 범위를 벗어나면 종료
+        if (grid[r][c] == '0' || visited[r][c]) return; // 물이거나 이미 방문한 섬이라면 종료
+
+        visited[r][c] = true; // 방문 처리
+
+        // 상하좌우 DFS
+        dfs(grid, visited, r + 1, c, rows, cols);
+        dfs(grid, visited, r - 1, c, rows, cols);
+        dfs(grid, visited, r, c + 1, rows, cols);
+        dfs(grid, visited, r, c - 1, rows, cols);
+    }
+
+    /**
+     * void 반환의 dfs면 return;
+     * int 반환의 dfs면 return 0;
+     * bool 반환의 dfs면 return false;
+     *
+     * 1. 리턴값 없이 넘겨받은 상태만 갱신
+     * void dfs(Node node) {
+     *     if (범위 밖 || 조건 불만족 || 이미 방문) return;
+     *
+     *     방문 처리(node);
+     *
+     *     for (이웃 nei : node) {
+     *         dfs(nei);
+     *     }
+     * }
+     *
+     * 2. 최대/최소 값을 정수로 반환
+     * int dfs(Node node) {
+     *     if (범위 밖 || 조건 불만족) return 0;
+     *
+     *     방문 처리(node);
+     *
+     *     int result = 1; // 자기 자신 포함
+     *     for (이웃 nei : node) {
+     *         result += dfs(nei);
+     *     }
+     *     return result;
+     * }
+     * 3. 조건 만족 여부
+     * boolean dfs(Node node) {
+     *     if (목표 도달) return true;
+     *     if (범위 밖 || 조건 불만족) return false;
+     *
+     *     방문 처리(node);
+     *
+     *     for (이웃 nei : node) {
+     *         if (dfs(nei)) return true;
+     *     }
+     *     return false;
+     * }
+     *
+     * 4. 메모이제이션/DP 결합
+     * int dfs(Node node, Map<Node,Integer> memo) {
+     *     if (memo.containsKey(node)) return memo.get(node);
+     *     if (기저 조건) return 1;
+     *
+     *     int best = 0;
+     *     for (이웃 nei : node) {
+     *         best = Math.max(best, 1 + dfs(nei, memo));
+     *     }
+     *     memo.put(node, best);
+     *     return best;
+     * }
+     */
+}

reverse-linked-list/jinvicky.java

@@ -0,0 +1,63 @@
+import java.util.Stack;
+
+class Solution {
+    /**
+     * 리버스와 동일한 후입선출 구조를 생각했고 그래서 자료구조로 스택을 결정했다.
+     * 사이클 문제를 염두해 두고 조건을 설계했지만 사이클을 끊는 위치가 틀려서 오래 걸렸다.
+     */
+    public ListNode reverseList(ListNode head) {
+        if (head == null) return null;
+
+        Stack<ListNode> stack = new Stack<>();
+        while (head != null) {
+            stack.push(head);
+            head = head.next;
+        }
+
+        ListNode newHead = stack.pop(); // 정답 반환용
+        ListNode current = newHead; // 포인터를 갱신하면서 계산하기용 (소위 더미 포인터)
+
+        while (!stack.isEmpty()) {
+            current.next = stack.pop();
+            current = current.next; // ← 수정: 자기 자신 가리키는 대신 앞으로 이동
+        }
+        current.next = null; // 마지막 tail 정리
+        return newHead;
+    }
+
+    /**
+     * 포인터 반복문을 새로 배웠을 때 fast/slow와 같은 투 포인터 알고리즘과 헷갈렸지만 둘은 전혀 다르다.
+     * 포인터 반복문
+     * * 링크 방향 뒤집기
+     * * 3개 포인터 (prev, cur, next)
+     * * 리스트 자체 구조 변경
+     * <p>
+     * 투 포인터
+     * * 중간, 사이클, 교차점 등 탐색
+     * * 2개 포인터 (slow, fast)
+     * * 리스트 구조 그대로, 위치 정보만 얻음
+     * <p>
+     * https://bcp0109.tistory.com/142
+     */
+    public ListNode reverseListByPointer(ListNode head) {
+        ListNode prev = null;
+        ListNode cur = head;
+        while (cur != null) {
+            ListNode next = cur.next; // next라는 temp 변수를 사용해서 prev와 cur.next 값을 바꾼다.
+            cur.next = prev;
+            prev = cur;
+            cur = next;
+            // 대각선으로 / / / / 으로 변수명 암기하기
+        }
+        return prev;
+    }
+
+    public ListNode reverseListByRecursion(ListNode head) {
+        // head.next가 null인지도 확인하는 로직이 필요합니다. (nullPointerException 방지)
+        if (head == null || head.next == null) return null; // 재귀의 끝, 이제 기존 연산을 취합한다.
+        ListNode newHead = reverseListByRecursion(head.next);
+        head.next.next = head;
+        head.next = null;
+        return newHead;
+    }
+}