Merge branch 'DaleStudy:main' into main

Author: eunhwa99

clone-graph/EcoFriendlyAppleSu.kt

@@ -0,0 +1,47 @@
+package leetcode_study
+
+/*
+* Graph Node 복사 문제
+* queue를 사용해 문제 해결
+* 새로 생성한 Node에 대해 방문처리를 하지 않을 경우 무한 Loop에 빠지게됨 -> 각 노드가 양방향을 가리키고 있기 때문.
+* 따라서, Map 자료구조를 사용해 Map<기존 Node, 복사 Node>의 모습으로 Key-Value 쌍으로 방문처리를 표현
+*
+* 시간 복잡도: O(n)
+* -> graph의 Node를 한 번씩 방문하여 복사하는 과정: O(n)
+* 공간 복잡도:
+* -> 복사된 Node를 매핑하는 Map 자료구조의 크기: O(n)
+* -> BFS를 사용한 queue size: O(n)
+* -> 새로 생성된 Node의 neighbor list: O(n)
+* */
+fun cloneGraph(node: Node?): Node? {
+    if (node == null) return null
+    if (node.neighbors.isEmpty()) return Node(1)
+
+    // Map< 기존 Node, 복사 Node>
+    val nodeMap = mutableMapOf<Node, Node>()
+
+    val queue = ArrayDeque<Node>()
+    queue.add(node)
+    nodeMap[node] = Node(node.`val`)
+
+    while (queue.isNotEmpty()) {
+        val current = queue.removeFirst()
+        val clonedNode = nodeMap[current]!! // 현재 노드의 복제본
+
+        for (neighbor in current.neighbors) {
+            if (neighbor == null) continue
+
+            // 해당 이웃이 아직 복사되지 않았다면 복사하여 맵에 저장하고 큐에 추가
+            if (!nodeMap.containsKey(neighbor)) {
+                nodeMap[neighbor] = Node(neighbor.`val`)
+                queue.add(neighbor)
+            }
+
+            // 복제된 현재 노드의 이웃 리스트에 복제된 이웃 노드를 추가
+            // 양방향을 따질 필요 없이 내부 neighbor node list에 모든 노드가 있음
+            clonedNode.neighbors.add(nodeMap[neighbor])
+        }
+    }
+    return nodeMap[node]
+}
+

clone-graph/dusunax.py

@@ -0,0 +1,35 @@
+'''
+# 133. Clone Graph
+This is the problem for copying nodes, which helps you understand the concept of referencing a node & copying the node (creating a new node from the existing one).
+
+👉 Perform recursion DFS with the correct escape condition and handling of NoneType.
+'''
+
+"""
+# 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 node is None:
+            return None
+            
+        visited = {}
+        
+        def DFS(currNode):
+            if currNode.val in visited:
+                return visited[currNode.val]
+
+            copiedNode = Node(currNode.val)
+            visited[currNode.val] = copiedNode
+
+            for neighbor in currNode.neighbors:
+                copiedNode.neighbors.append(DFS(neighbor))
+
+            return copiedNode
+
+        return DFS(node)

clone-graph/pmjuu.py

@@ -0,0 +1,40 @@
+'''
+시간 복잡도: O(V + E)
+- 그래프의 모든 노드를 한 번씩 방문해야 하므로 O(V)
+- 각 노드의 모든 간선을 한 번씩 탐색해야 하므로 O(E)
+- 따라서 전체 시간 복잡도는 O(V + E)
+
+공간 복잡도: O(V + E)
+- 클론 노드를 저장하는 딕셔너리(clones): O(V)
+- BFS 탐색을 위한 큐(queue): O(V)
+- 복제된 그래프의 노드와 간선 저장 공간: O(V + E)
+'''
+
+from typing import Optional
+from collections import deque
+# 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 []
+
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+
+        clones = { node.val: Node(node.val) }
+        queue = deque([node])
+
+        while queue:
+            current_node = queue.popleft()
+
+            for neighbor in current_node.neighbors:
+                # add neighbors
+                if neighbor.val not in clones.keys():
+                    queue.append(neighbor)
+                    clones[neighbor.val] = Node(neighbor.val)
+                    
+                clones[current_node.val].neighbors.append(clones[neighbor.val])
+        
+        return clones[node.val]

longest-common-subsequence/Yjason-K.ts

@@ -0,0 +1,37 @@
+/**
+ * 두 문자열의 최장 공통 부분 문자열의 길이 구하기.
+ * 
+ * @param {string} text1 - 첫 번째 문자열
+ * @param {string} text2 - 두 번째 문자열
+ * @returns {number} - 최장 공통 부분 문자열의 길이
+ * 
+ * 시간 복잡도:
+ * - O(m * n) : 두 문자열의 길이를 각각 m, n이라고 할 때, DP 테이블의 모든 요소를 계산합니다.
+ * 
+ * 공간 복잡도:
+ * - O(m * n) : m+1 x n+1 크기의 2차원 DP 테이블을 생성하여 사용합니다.
+ */
+function longestCommonSubsequence(text1: string, text2: string): number {
+    const m = text1.length;
+    const n = text2.length;
+
+    // DP 테이블 생성 (m+1 x n+1 크기)
+    const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+    // DP 계산
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (text1[i - 1] === text2[j - 1]) {
+                // 문자가 일치하면 이전 값에 +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[m][n];
+}
+

longest-common-subsequence/dusunax.py

@@ -0,0 +1,27 @@
+'''
+# 1143. Longest Common Subsequence
+
+use DP table.
+
+> key: tuple(current index in text1, current index in text2)
+> value: LCS of text1[i:] and text2[j:]
+'''
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        dp = {}
+
+        def helper(i, j):
+            if i == len(text1) or j == len(text2):
+                return 0
+
+            if (i, j) in dp:
+                return dp[(i, j)]
+
+            if text1[i] == text2[j]:
+                dp[(i, j)] = 1 + helper(i + 1, j + 1)
+            else:
+                dp[(i, j)] = max(helper(i + 1, j), helper(i, j + 1))
+
+            return dp[(i, j)]
+
+        return helper(0, 0)

longest-common-subsequence/pmjuu.py

@@ -0,0 +1,20 @@
+'''
+시간 복잡도: O(m * n)
+공간 복잡도: O(n)
+'''
+
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        m, n = len(text1), len(text2)
+        prev = [0] * (n + 1)
+
+        for i in range(1, m + 1):
+            curr = [0] * (n + 1)
+            for j in range(1, n + 1):
+                if text1[i - 1] == text2[j - 1]:
+                    curr[j] = prev[j - 1] + 1
+                else:
+                    curr[j] = max(prev[j], curr[j - 1])
+            prev = curr  # 현재 행을 이전 행으로 업데이트
+
+        return prev[n]

longest-repeating-character-replacement/EcoFriendlyAppleSu.kt

@@ -0,0 +1,31 @@
+package leetcode_study
+
+/*
+* 문제를 해결에 @Dale 님의 설명 참고. Sliding Window 기법을 통해 문자열 처리
+* 시간 복잡도: O(n)
+* -> 주어진 문자열을 순회하면서 문자열 처리: O(n)
+* -> 문자의 빈도 갱신 연산: O(1)
+*
+* 공간 복잡도: O(1)
+* -> 문자의 개수를 저장하는데 Map 자료구조 사용. 최대 26개의 대문자 저장 공간 필요: O(1)
+* */
+fun characterReplacement(s: String, k: Int): Int {
+    var maxLen = 0
+    val counter = mutableMapOf<Char, Int>()
+    var start = 0
+
+    for (end in s.indices) {
+        counter[s[end]] = counter.getOrDefault(s[end], 0) + 1 // character mapping
+
+        // 부분 문자열의 길이에서 가장 많이 들어있는 글자의 수를 뺀 값이 k보다 클 경우 시작(start) 포인터를 이동
+        // k 만큼 변경했을 때, 연속할 수 있는 문자를 만들 수 있도록 조정
+        while (end - start + 1 - (counter.values.maxOrNull() ?: 0) > k) {
+            counter[s[start]] = counter.getOrDefault(s[start], 0) - 1
+            start++
+        }
+
+        // 탐색한 부분 문자열 중 가장 긴 문자열의 값을 저장
+        maxLen = maxOf(maxLen, end - start + 1)
+    }
+    return maxLen
+}

longest-repeating-character-replacement/Yjason-K.ts

@@ -0,0 +1,50 @@
+/**
+ * sliding window
+ * 문자열 k번 변경 가능한, 가장 긴 반복 문자열의 길이 구하기.
+ * @param {string} s - 문자열
+ * @param {number} k - 문자 변경 가능 횟수
+ * @return {number} - 가장 긴 부분 문자열의 길이
+ * 
+ * 시간 복접도: O(n)
+ *  - 문자길이 만큼의 1회 순회
+ * 
+ * 공간 복잡도: O(1)
+ *  - 알파벳 26개의 제한된 Map 사용
+ * 
+ */
+function characterReplacement(s: string, k: number): number {
+    // 문자의 빈도를 저장할 Map
+    const charFreq = new Map<string, number>();
+
+    // window 왼쪽 포인터
+    let left = 0;
+
+    // 최대 길이, 최대 빈도 초기화
+    let maxLength = 0;
+    let maxFreq = 0;
+
+    // 오른쪽 포인터를 0부터 이동하며 window 크기 조절
+    for (let right = 0; right < s.length; right++) {
+        const char = s[right];
+        
+        // 현재 문자의 빈도 증가
+        charFreq.set(char, (charFreq.get(char) || 0) + 1);
+
+        // 윈도우 내에서 가장 많이 등장한 문자의 빈도 갱신
+        maxFreq = Math.max(maxFreq, charFreq.get(char)!);
+
+        // 조건: (윈도우 크기 - maxFreq > k)일 때, 왼쪽 포인터 이동
+        if (right - left + 1 - maxFreq > k) {
+            const leftChar = s[left];
+            charFreq.set(leftChar, charFreq.get(leftChar)! - 1); // 왼쪽 문자 제거
+            left++; // 윈도우 축소
+        }
+
+        // 현재 윈도우 크기를 기준으로 최대 길이 갱신
+        maxLength = Math.max(maxLength, right - left + 1);
+    }
+
+    return maxLength;
+
+}
+

longest-repeating-character-replacement/dusunax.py

@@ -0,0 +1,32 @@
+'''
+# 424. Longest Repeating Character Replacement
+
+use sliding window to find the longest substring with at most k replacements.
+
+## Time and Space Complexity
+
+```
+TC: O(n)
+SC: O(1)
+```
+'''
+
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        freq = [0] * 26 # A~Z, SC: O(1)
+        left = 0
+        max_freq = 0
+        result = 0
+
+        for right in range(len(s)): # TC: O(n)
+            curr_char_index = ord(s[right]) - 65
+            freq[curr_char_index] += 1
+            max_freq = max(max_freq, freq[curr_char_index])
+            
+            if (right - left + 1) - max_freq > k:
+                freq[ord(s[left]) - 65] -= 1
+                left += 1
+
+            result = max(result, right - left + 1)
+
+        return result

longest-repeating-character-replacement/pmjuu.py

@@ -0,0 +1,26 @@
+'''
+시간복잡도: O(n)
+- 문자열의 길이만큼 한 번만 순회합니다.
+공간복잡도: O(n)
+- char_count 딕셔너리는 최대 알파벳 26개만 저장합니다.
+'''
+
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        left = 0
+        max_count = 0
+        max_length = 0
+        char_count = {}
+
+        for right in range(len(s)):
+            char_count[s[right]] = char_count.get(s[right], 0) + 1
+            max_count = max(max_count, char_count[s[right]])
+
+            # If the remaining characters exceed the allowed k changes
+            while (right - left + 1) - max_count > k:
+                char_count[s[left]] -= 1
+                left += 1
+
+            max_length = max(max_length, right - left + 1)
+
+        return max_length