[sangbeenmoon] WEEK 08 Solutions

clone-graph/sangbeenmoon.java

@@ -0,0 +1,59 @@
+
+// Definition for a Node.
+
+import java.util.ArrayList;
+import java.util.Map;
+
+/* 
+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 Map<Node,Node> map = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+
+      if (node == null) {
+        return null;
+      }
+
+      return dfs(node);
+    }
+
+    public Node dfs(Node origin) {
+        if (map.containsKey(origin)) {
+            return map.get(origin);
+        }
+
+        if (origin == null) {
+            return null;
+        }
+
+        Node copied = new Node(origin.val);
+        map.put(origin, copied);
+
+        for (Node n : origin.neighbors) {
+            Node neighbor = dfs(n);
+            copied.neighbors.add(neighbor);
+        }
+
+        return copied;
+    }
+}

longest-common-subsequence/sangbeenmoon.java

@@ -0,0 +1,33 @@
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+
+        int dp[][] = new int[text1.length()][text2.length()];
+
+
+        for(int i = 0; i < text1.length(); i++){
+            if (text1.substring(0,i + 1).contains(String.valueOf(text2.charAt(0)))) {
+                dp[i][0] = 1;
+            }
+        }
+
+        for(int i = 0; i < text2.length(); i++){
+            if (text2.substring(0,i + 1).contains(String.valueOf(text1.charAt(0)))) {
+                dp[0][i] = 1;
+            }
+        }
+
+        for(int i = 1; i < text1.length(); i++){
+            for(int j = 1; j< text2.length(); j++){
+                if(text1.charAt(i) == text2.charAt(j)){
+                    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[text1.length() - 1][text2.length() - 1];
+
+
+    }
+}

longest-repeating-character-replacement/sangbeenmoon.java

@@ -0,0 +1,46 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+class Solution {
+
+    Map<Character, Integer> counterMap = new HashMap<>();
+
+    public int characterReplacement(String s, int k) {
+
+        int left = 0;
+        int answer = 0;
+
+        for (int right = 0; right < s.length(); right++){  
+            if(counterMap.containsKey(s.charAt(right))){
+
+                int cnt = counterMap.get(s.charAt(right));
+                counterMap.put(s.charAt(right), cnt + 1);
+            }
+            else {
+                counterMap.put(s.charAt(right), 1);
+            }
+
+            while (!isCounterOK(k)) {
+                char l = s.charAt(left);
+                int cnt = counterMap.get(l);
+                if (cnt == 1) counterMap.remove(l);
+                else counterMap.put(l, cnt - 1);
+                left++;
+            }
+            answer = Math.max(answer, right - left + 1);
+        }
+
+        return answer;
+    }
+
+    public boolean isCounterOK(int k) {
+        int maxCount = 0;
+        int totalCount = 0;
+        for (Entry<Character, Integer> entry : counterMap.entrySet()) {
+            maxCount = Math.max(maxCount, entry.getValue());
+            totalCount = totalCount + entry.getValue();
+        }
+        return totalCount - maxCount <= k;
+    }
+}

palindromic-substrings/sangbeenmoon.py

@@ -0,0 +1,36 @@
+class Solution:
+    def countSubstrings(self, s: str) -> int:
+        dp = [[0] * (len(s) + 1) for _ in range(len(s) + 1)]
+
+        def isPalindrome(start, end) -> bool:
+
+            if end - start == 0:
+                return True
+
+            if end - start == 1 :
+                return s[start] == s[end]
+
+            if dp[start][end] == 1:
+                return True
+
+            if dp[start][end] == -1:
+                return False    
+
+            if s[start] == s[end]:
+                return isPalindrome(start+1, end-1)    
+
+            return False
+
+        answer = 0
+
+        for i in range(len(s) - 1, -1, -1):
+            for j in range(i,len(s)):
+                if isPalindrome(i,j):                    
+                    dp[i][j] = 1
+                    answer += 1
+                else:
+                    dp[i][j] = -1
+
+        return answer
+
+