[essaysir] WEEK 08 Solutions

clone-graph/essaysir.java

@@ -0,0 +1,52 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
+
+class Solution {
+    public Node cloneGraph(Node node) {
+        if ( node == null ) return null;
+        // 똑같은 그래프를 만드는 게 목적
+        // node.val -> 숫자( id 로 생각 )
+        // neighbors -> 인접한 id 들
+
+        Map<Integer, Node> cloned = new HashMap<>();
+        cloned.put(node.val, new Node(node.val));
+
+        Queue<Node> queue = new ArrayDeque<>();
+        queue.offer(node);
+
+        while( !queue.isEmpty()){
+            Node curNode = queue.poll();
+            Node cloneNode = cloned.get(curNode.val);
+
+            for ( Node nei : curNode.neighbors ){
+                List<Node> curs = nei.neighbors;
+
+                if (!cloned.containsKey(nei.val)) {
+                    cloned.put(nei.val, new Node(nei.val));
+                    queue.offer(nei);
+                }
+
+                cloneNode.neighbors.add(cloned.get(nei.val));
+            }
+        }
+
+        return cloned.get(node.val);
+    }
+}

longest-common-subsequence/essaysir.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+        int n = text1.length(), m = text2.length();
+        int[][] dp = new int[n + 1][m + 1];   // 0행/0열은 자동으로 0
+
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        return dp[n][m];
+    }
+}

longest-repeating-character-replacement/essaysir.java

@@ -0,0 +1,26 @@
+class Solution {
+    public int characterReplacement(String s, int k) {
+        Map<Character, Integer> count = new HashMap<>();
+        int left = 0;
+        int answer = 0;
+        int size = 0;
+
+        for (int right = 0; right < s.length(); right++) {
+            // 1) right 문자를 윈도우에 넣는다
+            count.merge(s.charAt(right), 1, Integer::sum);
+            size ++;
+            // 2) 윈도우가 조건을 어기는 동안 left를 오른쪽으로 민다
+            int maxCount = Collections.max(count.values());
+            while ( size - maxCount  > k ) {
+                count.merge(s.charAt(left), -1, Integer::sum);
+                size --;
+                left++;
+            }
+
+            // 3) 지금 윈도우는 유효하니까 답 갱신
+            answer = Math.max(answer,size);
+        }
+
+        return answer;
+    }
+}

palindromic-substrings/essaysir.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int countSubstrings(String s) {
+        // 해당 substring 을 했을 때, 몇 개의 palidrome 이 존재하는 가 ?
+        int answer = 0;
+
+        for ( int lt = 0; lt < s.length(); lt++){
+            for ( int rt = lt+1; rt <= s.length(); rt++){
+                String curStr = s.substring(lt,rt);
+                if (validatePalindrome(curStr)){
+                    answer++;
+                }
+            }
+
+        }
+        return answer;
+    }
+
+    private boolean validatePalindrome(String s){
+        int len = s.length();
+        for ( int i = 0; i < len/2; i++){
+            if ( s.charAt(i) != s.charAt(len -i -1)){
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

reverse-bits/essaysir.java

@@ -0,0 +1,9 @@
+class Solution {
+    public int reverseBits(int n) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 32; i++) {
+            sb.append((n >>> i) & 1);   // i번째 비트를 꺼내서 뒤에 붙임
+        }
+        return Integer.parseUnsignedInt(sb.toString(), 2);  // 2진 문자열 → int
+    }
+}