cloneGraph solution

Author: jinvicky

clone-graph/jinvicky.java

@@ -0,0 +1,26 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public Node cloneGraph(Node node) {
+        if (node == null) return null;
+
+        Map<Node, Node> map = new HashMap<>();
+        return clone(node, map);
+    }
+
+    private Node clone(Node node, Map<Node, Node> map) {
+        if (map.containsKey(node)) {
+            return map.get(node);
+        }
+
+        Node clonedNode = new Node(node.val);
+        map.put(node, clonedNode);
+
+        for (Node neighbor : node.neighbors) {
+            clonedNode.neighbors.add(clone(neighbor, map));
+        }
+
+        return clonedNode;
+    }
+}

maximum-product-subarray/jinvicky.java

@@ -1,4 +1,5 @@
 class Solution {
+    // 최소값은 음수가 곱해질 때 최대값이 될 수 있기 때문에 최소, 최대를 각각 dp[]로 관리해야 한다.
     public int maxProduct(int[] nums) {
         if (nums.length == 1)
             return nums[0];
@@ -15,6 +16,11 @@ public int maxProduct(int[] nums) {
 
         for (int i = 1; i < len; i++) {
             // 후보 3을 준비
+            /**
+             * 현재 인덱스값 (justNum)
+             * 이전 인덱스 최소값 x 현재 인덱스 값 (reverse)
+             * 이전 인덱스 최대값 x 현재 인덱스 값 (keep)
+             */
             int justNum = nums[i];
             // 계속 더한 값
             int keep = justNum * max[i-1];

palindromic-substrings/jinvicky.java

@@ -0,0 +1,62 @@
+
+
+class Solution {
+
+    public int countSubstrings(String s) {
+        int n = s.length();
+        int count = 0;
+
+        // 홀수와 짝수 통합 처리 (0부터 2n-1까지)
+        for (int center = 0; center < 2 * n - 1; center++) {
+            int left = center / 2;
+            int right = left + center % 2;
+
+            while (left >= 0 && right < n && s.charAt(left) == s.charAt(right)) {
+                count++;
+                left--;
+                right++;
+            }
+        }
+
+        return count;
+    }
+
+    // 더 가독성이 좋은 풀이
+
+    /**
+     * 1. 회문의 중심을 명확하게 분리한다.
+     * 2. c는 회문의 중심후보가 된다. 1글자짜리 중심이거나 혹은 두 글자짜리 회문의 왼쪽 중심이다.
+     * 3. c를 홀수 길이 회문의 중심으로 설정한다 -> expand(s,c,c)
+     * 4. c부터 c+1까지 짝수 길이 회문의 왼쪽 중심으로 설정한다 -> expand(s,c,c+1)
+     *
+     * 이렇게 하는 이유는 ABA와 ABBA 두 가지 경우를 모두 커버하기 위해서이다.
+     */
+    public int countSubstrings2(String s) {
+        int n = s.length();
+        int count = 0;
+        for (int c = 0; c < n; c++) {
+            count += expand(s, c, c);     // 홀수 길이 중심
+            count += expand(s, c, c + 1); // 짝수 길이 중심
+        }
+        return count;
+    }
+
+    private int expand(String s, int L, int R) {
+        int add = 0;
+        while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
+            add++;
+            L--;
+            R++;
+        }
+        return add;
+    }
+
+    /**
+     *  프라이빗 메서드 "확장" 선언
+     *  1. L, R 포인터 인덱스를 받는다.
+     *  2. 두 포인터가 문자열 내 유효한 범위에 있어야 한다.
+     *  3. L과 R이 가리키는 문자가 같아야 한다.
+     *  2와 3을 모두 만족한다면 회문
+     */
+
+}

reverse-bits/jinvicky.java

@@ -0,0 +1,18 @@
+
+
+public class Solution {
+    public int reverseBits(int n) {
+        int reversed = 0;
+
+        for (int i = 0; i < 32; i++) {
+            reversed <<= 1;
+
+            int lsb_of_n = n & 1; // n이 홀수면 1, 짝수면 0을 반환
+
+            reversed |= lsb_of_n;
+
+            n >>= 1;
+        }
+        return reversed;
+    }
+}

sum-of-two-integers/jinvicky.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int getSum(int a, int b) {
+
+        while (b != 0) {
+
+            // 변수 2개와 비트 연산
+            // 1.
+            int sum = a ^ b;
+
+            // 2.
+            int carry = (a & b) << 1;
+
+            /// 3.
+            a = sum;
+            b = carry; // 한번하고 말면 b는 쓰일 일이 없는데? -> 빠뜨린 반복문이 없는지 확인한다.
+
+        }
+
+        return a;
+    }
+}