Merge branch 'DaleStudy:main' into main

Author: HC-kang

clone-graph/jaejeong1.java

@@ -0,0 +1,56 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+
+// 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 {
+  // 풀이: BFS 방식으로 그래프를 순회하면서 현재 노드에 연결된 노드들을 복제 여부에 따라 복제 또는 연결 처리해준다
+  // TC: O(N)
+  // SC: O(N)
+  public Node cloneGraph(Node node) {
+    if (node == null) {
+      return null;
+    }
+
+    Map<Node, Node> cloneMap = new HashMap<>();
+    Node clone = new Node(node.val);
+    cloneMap.put(node, clone);
+
+    Queue<Node> queue = new LinkedList<>();
+    queue.add(node);
+
+    while (!queue.isEmpty()) {
+      Node current = queue.poll();
+
+      for (Node neighbor : current.neighbors) {
+        if (!cloneMap.containsKey(neighbor)) {
+          cloneMap.put(neighbor, new Node(neighbor.val));
+          queue.add(neighbor);
+        }
+        cloneMap.get(current).neighbors.add(cloneMap.get(neighbor));
+      }
+    }
+    return clone;
+  }
+}

clone-graph/kayden.py

@@ -0,0 +1,28 @@
+from typing import Optional
+from collections import deque
+
+
+class Solution:
+    # 시간복잡도: O(N) node 개수: N
+    # 공간복잡도: O(N)
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if node:
+            visited = {}
+            copy = Node(val=node.val)
+            visited[copy.val] = copy
+            q = deque()
+            q.append((copy, node))
+
+            while q:
+                cur, node = q.popleft()
+
+                for idx, next_node in enumerate(node.neighbors):
+                    if next_node.val not in visited:
+                        new = Node(val=next_node.val)
+                        visited[new.val] = new
+                        q.append((new, next_node))
+                    cur.neighbors.append(visited[next_node.val])
+
+            return copy
+
+        return node

clone-graph/wogha95.js

@@ -0,0 +1,74 @@
+/**
+ * TC: O(V + E)
+ * 모든 정점를 방문하게 되고
+ * 방문한 정점에서 연결된 간선을 queue에 추가하는 반복문을 실행합니다.
+ * 따라서 시간복잡도는 정점 + 간선에 선형적으로 비례합니다.
+ *
+ * SC: O(V + E)
+ * memory, visitedNodeVal 에서 V만큼 데이터 공간을 가집니다.
+ * 그리고 queue에서 최대 모든 간선 갯수 * 2 만큼 갖게 됩니다.
+ * 따라서 O(V + 2E) = O(V + E)로 계산했습니다.
+ *
+ * V: vertex, E: edge
+ */
+
+/**
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function (node) {
+  if (!node) {
+    return null;
+  }
+
+  const memory = new Map();
+  const visitedNodeVal = new Set();
+
+  return bfsClone(node);
+
+  // 1. bfs로 순회하면서 deep clone한 graph의 head를 반환
+  function bfsClone(start) {
+    const queue = [start];
+    const clonedHeadNode = new _Node(start.val);
+    memory.set(start.val, clonedHeadNode);
+
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visitedNodeVal.has(current.val)) {
+        continue;
+      }
+
+      const clonedCurrentNode = getCloneNode(current.val);
+
+      for (const neighbor of current.neighbors) {
+        const clonedNeighborNode = getCloneNode(neighbor.val);
+        clonedCurrentNode.neighbors.push(clonedNeighborNode);
+
+        queue.push(neighbor);
+      }
+
+      visitedNodeVal.add(current.val);
+    }
+
+    return clonedHeadNode;
+  }
+
+  // 2. memory에 val에 해당하는 node 반환 (없을 경우 생성)
+  function getCloneNode(val) {
+    if (!memory.has(val)) {
+      const node = new _Node(val);
+      memory.set(val, node);
+      return node;
+    }
+
+    return memory.get(val);
+  }
+};

longest-common-subsequence/kayden.py

@@ -1,17 +1,33 @@
-# 시간복잡도: O(N)
-# 공간복잡도: O(N)
 class Solution:
-    def longestConsecutive(self, nums: List[int]) -> int:
-        nums = set(nums)
-        answer = 0
+    # 시간복잡도: O(A*B)
+    # 공간복잡도: O(A*B)
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        a = len(text1)
+        b = len(text2)
 
-        for num in nums:
-            if num - 1 not in nums:
-                length = 1
+        lcs = [[0]*(b+1) for _ in range(a+1)]
 
-                while num + length in nums:
-                    length += 1
+        for i in range(1, a+1):
+            for j in range(1, b+1):
+                if text1[i-1] == text2[j-1]:
+                    lcs[i][j] = lcs[i-1][j-1] + 1
+                lcs[i][j] = max(lcs[i][j], lcs[i-1][j], lcs[i][j-1])
 
-                answer = max(answer, length)
+        return lcs[a][b]
 
-        return answer
+    # 시간복잡도: O(A*B)
+    # 공간복잡도: O(A)
+    def longestCommonSubsequence2(self, text1: str, text2: str) -> int:
+        n = len(text1)
+        lcs = [0]*n
+        longest = 0
+        for ch in text2:
+            cur = 0
+            for i in range(n):
+                if cur < lcs[i]:
+                    cur = lcs[i]
+                elif ch == text1[i]:
+                    lcs[i] = cur + 1
+                    longest = max(longest, cur+1)
+
+        return longest

longest-common-subsequence/wogha95.js

@@ -0,0 +1,46 @@
+/**
+ * 알고달레 풀이 참고해서 풀었습니다.
+ * @see https://www.algodale.com/problems/longest-common-subsequence/
+ *
+ * DP + 2차원 배열을 이용한 풀이
+ * 행은 text1, 열은 text2에 대응하고
+ * index는 text의 처음부터 몇개 문자를 사용할건지 의미합니다.
+ * 마지막 문자가 동일하다면 dp[index1][index2] = dp[index1 - 1][index2 - 1] + 1
+ * 마지막 문자가 다르다면 dp[index1][index2] = Math.max(dp[index1 - 1][index2], dp[index1][index2 - 1])
+ *
+ * TC: O(T1 * T2)
+ * 2차원 배열을 순회
+ *
+ * SC: O(T1 * T2)
+ * 2차원 배열 생성
+ *
+ * T1: text1.length, T2: text2.length
+ */
+
+/**
+ * @param {string} text1
+ * @param {string} text2
+ * @return {number}
+ */
+var longestCommonSubsequence = function (text1, text2) {
+  const LENGTH1 = text1.length;
+  const LENGTH2 = text2.length;
+  const memory = Array.from({ length: LENGTH1 + 1 }, () =>
+    Array.from({ length: LENGTH2 + 1 }, () => 0)
+  );
+
+  for (let index1 = 1; index1 <= LENGTH1; index1++) {
+    for (let index2 = 1; index2 <= LENGTH2; index2++) {
+      if (text1[index1 - 1] === text2[index2 - 1]) {
+        memory[index1][index2] = memory[index1 - 1][index2 - 1] + 1;
+      } else {
+        memory[index1][index2] = Math.max(
+          memory[index1 - 1][index2],
+          memory[index1][index2 - 1]
+        );
+      }
+    }
+  }
+
+  return memory[LENGTH1][LENGTH2];
+};

longest-consecutive-sequence/kayden.py

@@ -0,0 +1,17 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(N)
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        nums = set(nums)
+        answer = 0
+
+        for num in nums:
+            if num - 1 not in nums:
+                length = 1
+
+                while num + length in nums:
+                    length += 1
+
+                answer = max(answer, length)
+
+        return answer

longest-repeating-character-replacement/jaejeong1.java

@@ -0,0 +1,31 @@
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+  public int characterReplacement(String s, int k) {
+    // 풀이: 슬라이딩 윈도우를 활용해 부분 문자열을 구한다
+    // 종료 인덱스를 증가시키고, 부분 문자열 길이에서 가장 많이 들어있는 문자의 수를 뺀 값이 k보다 큰지 비교한다.
+    // 크다면, 시작 인덱스를 증가시킨다.
+    // 끝까지 반복하면서 최대 길이를 저장했다가 반환한다.
+    // TC: O(N)
+    // SC: O(N)
+    var maxLength = 0;
+    var start = 0;
+    var end = 0;
+    Map<Character, Integer> countByChar = new HashMap<>();
+
+    while (end < s.length()) {
+      countByChar.put(s.charAt(end), countByChar.getOrDefault(s.charAt(end), 0) + 1);
+
+      while ((end - start + 1 - Collections.max(countByChar.values())) > k) {
+        countByChar.put(s.charAt(start), countByChar.get(s.charAt(start)) - 1);
+        start += 1;
+      }
+      maxLength = Math.max(end - start + 1, maxLength);
+      end++;
+    }
+
+    return maxLength;
+  }
+}

longest-repeating-character-replacement/kayden.py

@@ -0,0 +1,23 @@
+from collections import defaultdict
+
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(N)
+    def characterReplacement(self, s: str, k: int) -> int:
+
+        n = len(s)
+        l, r = 0, 1
+
+        d = defaultdict(int)
+        d[s[l]] += 1
+
+        longest = 1
+        while l < r and r < n:
+            d[s[r]] += 1
+            if r-l+1 - max(d.values()) > k:
+                d[s[l]] -= 1
+                l += 1
+            longest = max(longest, r-l+1)
+            r += 1
+
+        return longest

longest-repeating-character-replacement/mangodm-web.py

@@ -0,0 +1,26 @@
+from collections import defaultdict
+
+
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        """
+        - Idea: 슬라이딩 윈도우를 이용해 현재 윈도우 내에서 가장 자주 나타나는 문자의 개수를 추적한다.
+          최대 k개의 문자를 바꿨을 때, 모든 문자가 같은 부분 문자열의 최대 길이를 계산한다.
+          윈도우가 유효하지 않으면, 왼쪽 포인터를 이동시켜 윈도우 크기를 조정한다.
+        - Time Complexity: O(n), n은 문자열의 길이다. 각 문자를 한번씩 순회하고, 슬라이딩 윈도우를 조정한다.
+        - Space Complexity: O(26) = O(1), 슬라이딩 윈도우 내에 포함된 문자의 개수를 세기 위한 공간으로, 최대 알파벳 문자의 개수(26개)만큼 늘어날 수 있다.
+        """
+        result = 0
+        counter = defaultdict(int)
+        left = 0
+
+        for right in range(len(s)):
+            counter[s[right]] = counter[s[right]] + 1
+
+            while (right - left + 1) - max(counter.values()) > k:
+                counter[s[left]] -= 1
+                left += 1
+
+            result = max(result, right - left + 1)
+
+        return result