Merge branch 'DaleStudy:main' into main

Author: devyejin

clone-graph/hu6r1s.py

@@ -0,0 +1,28 @@
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+
+        visited = [None] * 101
+        
+        def dfs(n):
+            if visited[n.val] is not None:
+                return visited[n.val]
+            
+            copy = Node(n.val, [])
+            visited[n.val] = copy
+            
+            for nei in n.neighbors:
+                copy.neighbors.append(dfs(nei))
+            return copy
+
+        return dfs(node)

clone-graph/njngwn.java

@@ -0,0 +1,40 @@
+/*
+// 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 {
+    HashMap<Node, Node> nodeMap = new HashMap<>(); // key: original Node, value: copied Node
+
+    public Node cloneGraph(Node node) {
+        if (node == null) return null;
+
+        if (nodeMap.containsKey(node)) {
+            return nodeMap.get(node);
+        }
+
+        Node newNode = new Node(node.val);
+        nodeMap.put(node, newNode);
+
+        for (Node neighborNode : node.neighbors) {
+            newNode.neighbors.add(cloneGraph(neighborNode));
+        }
+
+        return newNode;
+    }
+}

longest-common-subsequence/hu6r1s.py

@@ -0,0 +1,15 @@
+class Solution:
+  """
+  문제의 힌트에서 DP를 활용하는 것을 확인
+  """
+  def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+    dp = [[0] * (len(text2)+1) for _ in range(len(text1)+1)]
+
+    for i in range(1, len(text1)+1):
+        for j in range(1, len(text2)+1):
+            if text1[i-1] == text2[j-1]:
+                dp[i][j] = dp[i-1][j-1] + 1
+            else:
+                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+    
+    return dp[-1][-1]

longest-common-subsequence/jinvicky.java

@@ -0,0 +1,40 @@
+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 = 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 + 1][j + 1] = Math.max(dp[i][j + 1], dp[i + 1][j]);
+                }
+            }
+        }
+
+        return dp[m][n];
+    }
+
+    // -1을 참조해 이전 케이스를 재사용하는 경우는 1부터 m,n까지 하면 그렇게 할 수 있다.
+    public int longestCommonSubsequence2(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
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);  // 위 or 왼쪽 중 큰 값
+                }
+            }
+        }
+
+        return dp[m][n];
+    }
+}

longest-repeating-character-replacement/chordpli.py

@@ -0,0 +1,23 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        start, max_len, max_freq = 0, 0, 0
+
+        window = {}
+        for end in range(len(s)):
+            char = s[end]
+            window[char] = window.get(char, 0) + 1
+            max_freq = max(max_freq, window[char])
+
+            while (end - start + 1) - max_freq > k:
+                left_char = s[start]
+                window[left_char] -= 1
+                start += 1
+
+            max_len = end - start + 1 if end - start + 1 > max_len else max_len
+
+        return max_len
+
+
+if __name__ == "__main__":
+    s = Solution()
+    print(s.characterReplacement('ABAB', 2))

longest-repeating-character-replacement/hu6r1s.py

@@ -0,0 +1,18 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        counts = {}
+        left = 0
+        max_count = 0
+        res = 0
+
+        for right in range(len(s)):
+            counts[s[right]] = counts.get(s[right], 0) + 1
+            max_count = max(max_count, counts[s[right]])
+
+            while (right - left + 1) - max_count > k:
+                counts[s[left]] -= 1
+                left += 1
+
+            res = max(res, right - left + 1)
+
+        return res

longest-repeating-character-replacement/njngwn.java

@@ -0,0 +1,48 @@
+// Time Complexity: O(n), n: s.length()
+// Space Complexity: O(1)
+class Solution {
+    public int characterReplacement(String s, int k) {
+        int[] charFreqArr = new int[26]; // s consists of only uppercase English letters
+        int maxFreq = 0;
+        int maxLength = 0;
+
+        for (int left = 0, right = 0; right < s.length(); right++) {
+            char letter = s.charAt(right);
+            int letterIdx = letter-'A';
+
+            charFreqArr[letterIdx]++;
+            maxFreq = Math.max(maxFreq, charFreqArr[letterIdx]);
+
+            // when left idx moves rightward? -> k + maxFreq < size of sliding window
+            // here, we don't neet to recalculate maxFreq because the point is to calculate 'best' maxFreq
+            if (maxFreq + k < right-left+1) {
+                char leftChar = s.charAt(left);
+                charFreqArr[leftChar-'A']--;
+                left++;
+            }
+
+            maxLength = Math.max(maxLength, right-left+1);
+        }
+
+        return maxLength;
+    }
+}
+
+// AABABBA, k=1, maxFreq=1, maxLength=1
+// l
+// r
+
+// AABABBA, k=1, maxFreq=2, maxLength=2
+// lr
+
+// AABABBA, k=1, maxFreq=2, maxLength=3
+// l r
+
+// AABABBA, k=1, maxFreq=3, maxLength=4
+// l  r
+
+// AABABBA, k=1, maxFreq=3, maxLength=4 ==> fail
+// l   r
+
+// AABABBA, k=1, maxFreq=3
+//  l   r

palindromic-substrings/hu6r1s.py

@@ -0,0 +1,13 @@
+class Solution:
+  """
+  브루트포스로 모두 탐색하면서 집어넣는 방법
+  O(n^2)
+  """
+  def countSubstrings(self, s: str) -> int:
+      cnt = []
+      for i in range(len(s)):
+          for j in range(i, len(s)):
+              sub = s[i:j+1]
+              if sub and sub == sub[::-1]:
+                  cnt.append(sub)
+      return len(cnt)

palindromic-substrings/jangwonyoon.js

@@ -0,0 +1,96 @@
+/**
+ * @param {string} s
+ * @return {number}
+ *
+ * 풀이 방법 1
+ *
+ * 1. brute force 를 사용해서 모든 경우의 수를 구한다.
+ * 2. 투포인터를 통해 isPalindrome 을 확인한다.
+ *
+ * 복잡성
+ *
+ * Time Complexity: O(n^2)
+ * Space Complexity: O(1)
+ */
+
+/**
+ * isPalindrome 함수
+ */
+function isPalindrome(s) {
+    let left = 0;
+    let right = s.length - 1;
+
+    while (left < right) {
+        if (s[left] !== s[right]) return false;
+        left++;
+        right--;
+    }
+
+    return true;
+}
+
+var countSubstrings = function(s) {
+    let count = 0;
+
+    // 모든 경우의 수를 구한다.
+    for (let start = 0; start < s.length; start++) {
+        for (let end = start; end < s.length; end++) {
+            const subStr = s.slice(start, end + 1);
+
+            // isPalindrome 함수를 통해 팰린드롬인지 확인한다.
+            if (isPalindrome(subStr)) {
+                count++;
+            }
+        }
+    }
+
+    return count;
+};
+
+/**
+ * 풀이 방법 2
+ *
+ * 1. dfs를 통해 모든 경우의 수를 구한다.
+ * 2. isPalindrome 함수를 통해 팰린드롬인지 확인한다.
+ *
+ * 복잡성
+ *
+ * Time Complexity: O(n^2)
+ * Space Complexity: O(1)
+ */
+
+function isPalindrome(s) {
+    let left = 0;
+    let right = s.length - 1;
+
+    while (left < right) {
+        if (s[left] !== s[right]) return false;
+        left++;
+        right--;
+    }
+
+    return true;
+}
+
+var countSubstrings = function(s) {
+    let count = 0;
+
+    function dfs(startIdx) {
+        // 모든 시작점 탐색 완료
+        if (startIdx === s.length) return;
+
+        // 현재 시작점에서 가능한 모든 끝점 확인
+        for (let end = startIdx; end < s.length; end++) {
+            const sub = s.slice(startIdx, end + 1);
+            if (isPalindrome(sub)) {
+                count++;
+            }
+        }
+
+        // 다음 시작점으로 이동
+        dfs(startIdx + 1);
+    }
+
+    dfs(0);
+    return count;
+};

palindromic-substrings/njngwn.java

@@ -0,0 +1,36 @@
+// Time Complexity: O(n*n), n: s.length()
+// Space Complexity: O(1)
+class Solution {
+    public int countSubstrings(String s) {
+        int cnt = 0;
+
+        for (int i = 0; i < s.length(); i++, cnt++) {   // i: center of palindrom
+            // odd number palindrom: e.g. aba
+            int left = i-1, right = i+1;
+
+            while (left >= 0 && right < s.length()) {
+                if (s.charAt(left) != s.charAt(right)) {
+                    break;
+                }
+                cnt++;
+                left--;
+                right++;
+            }
+
+            // even number palindrom: e.g. abba
+            left = i;
+            right = i+1;
+
+            while (left >= 0 && right < s.length()) {
+                if (s.charAt(left) != s.charAt(right)) {
+                    break;
+                }
+                cnt++;
+                left--;
+                right++;
+            }
+        }
+
+        return cnt;
+    }
+}