Merge branch 'DaleStudy:main' into main

Author: Chaedie

design-add-and-search-words-data-structure/Jay-Mo-99.py

@@ -11,20 +11,20 @@
 # solution
 이 문제는 DP로 접근했습니다.
 
-LIS(1, x)를 범위 [1, x] 내의 LIS(단, nums[x]를 반드시 포함)의 길이라고 정의하겠습니다. - (1)
-1 <= j < i 인 모든 j에 한 LIS(1, j)를 알고 있다면, LIS(1, i)는 아래와 같이 구할 수 있습니다.
-LIS(1, i) = max(LIS(1, j)) (단, j는 1 <= j < i 이고, nums[j] < nums[i]) - (2)
+LIS(0, x)를 범위 [0, x] 내의 LIS(단, nums[x]를 반드시 포함)의 길이라고 정의하겠습니다. - (1)
+1 <= j < i 인 모든 j에 한 LIS(1, j)를 알고 있다면, LIS(0, i)는 아래와 같이 구할 수 있습니다.
+LIS(0, i) = max(LIS(0, j)) (단, j는 0 <= j < i 이고, nums[j] < nums[i]) - (2)
 
-max(LIS(1, j))를 구할 때, 모든 j에 대해 탐색한다면, 전체 시간 복잡도는 O(n^2)가 되기 때문에, 시간 복잡도를 줄일 필요가 있습니다.
+max(LIS(0, j))를 구할 때, 모든 j에 대해 탐색한다면, 전체 시간 복잡도는 O(n^2)가 되기 때문에, 시간 복잡도를 줄일 필요가 있습니다.
 이 탐색 과정을 줄이기 위해, 아래의 사고 과정을 거쳤습니다.
 
 어떤 범위 내의 가장 큰 값을 O(logn) 시간에 구하기 위한 자료구조로, 인덱스 트리(혹은 세그먼트 트리)를 사용합니다.
-(이 인덱스 트리의 x번째 leaf 노드에는 LIS(1, x) 값을 저장하고, internal 노드에는 자식 노드들 중 가장 큰 값을 저장합니다.)
+(이 인덱스 트리의 x번째 leaf 노드에는 LIS(0, x) 값을 저장하고, internal 노드에는 자식 노드들 중 가장 큰 값을 저장합니다.)
 
 다만, 단순히 해당 범위 내의 가장 큰 값을 구하는 것만으로는 부족하고, nums[j] < nums[i]인 j만을 후보로 삼아야 할 텐데요,
-그러기 위해서, 인덱스 트리에 모든 leaf 노드를 미리 삽입해두는 것이 아니라 아래처럼 순차적으로 max(LIS(1, i))의 계산과 삽입을 번갈아 수행합니다.
-nums[i]의 크기가 작은 것부터 순서대로, "max(LIS(1, j))를 계산하고, leaf를 하나 삽입"하는 과정을 반복합니다.
-nums[i]보다 더 큰 값은 아직 인덱스 트리에 삽입되지 않은 상태이기 때문에, 인덱스 트리에서 구간 [1, i-1]의 최대값을 조회하면 nums[j] < num[i]인 j에 대해서만 최대값을 찾게 되므로,
+그러기 위해서, 인덱스 트리에 모든 leaf 노드를 미리 삽입해두는 것이 아니라 아래처럼 순차적으로 max(LIS(0, i))의 계산과 삽입을 번갈아 수행합니다.
+nums[i]의 크기가 작은 것부터 순서대로, "max(LIS(0, j))를 계산하고, leaf를 하나 삽입"하는 과정을 반복합니다.
+nums[i]보다 더 큰 값은 아직 인덱스 트리에 삽입되지 않은 상태이기 때문에, 인덱스 트리에서 구간 [0, i-1]의 최대값을 조회하면 nums[j] < num[i]인 j에 대해서만 최대값을 찾게 되므로,
 (2)번 과정을 O(logn) 시간에 구할 수 있습니다.
 따라서 전체 시간 복잡도는 O(nlogn)이 됩니다.
 */

longest-increasing-subsequence/forest000014.java

@@ -0,0 +1,24 @@
+package leetcode_study
+
+/*
+* 주어진 문자열에서 반복되는 문자를 포함하지 않은 가장 긴 부분 문자열의 길이를 구하는 문제
+* 이중 반복문을 사용해 바깥 반복문에선 시작 문자를 내부 반복문에선 그 다음 문자를 순회하며 중복된 문자가 발견되었을 때, 반복문 탈출하는 방법으로 문제 해결
+* 시간 복잡도: O(n^2)
+* -> 이중 반복 과정
+* 공간 복잡도: O(n)
+* -> 중복되지 않은 문자열을 담을 공간 필요
+* */
+fun lengthOfLongestSubstring(s: String): Int {
+    var maximumLength = 0
+    for (start in s.indices) {
+        val tempList = mutableListOf<Char>()
+        for (end in start until s.length) {
+            if (tempList.contains(s[end])) {
+                break // escape loop
+            }
+            tempList.add(s[end])
+            maximumLength = max(tempList.size, maximumLength)
+        }
+    }
+    return maximumLength
+}

longest-substring-without-repeating-characters/EcoFriendlyAppleSu.kt

@@ -0,0 +1,36 @@
+        #해석
+        # 
+
+
+        #Big O
+        #- N: str s의 길이
+
+        #Time Complexity: O(N) 
+        #- start,end: 각각 최대 N번 움직임 -> O(N)
+        #- set의 삽입, 삭제 -> O(1)
+
+        #Space Complexity: O(N)
+        #- chars: 최악의 경우 chars는 s의 모든 char을 저장한다 -> O(N)
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        max_len = 0
+        chars = set() #현 윈도우 내 중복 없이 존재하는 문자들을 저장하는 set
+        start, end = 0, 0 # 슬라이딩 윈도우의 start 인덱스, end 인덱스 
+        #end가 s의 마지막 인덱스에 도달할때까지 반복 
+        while end < len(s): 
+            #s[end]가 chars에 존재하면 
+            if s[end] in chars: 
+                #chars의 s[start]를 제거 
+                chars.remove(s[start]) 
+                #start를 오른쪽으로 이동, 윈도우 축소  
+                start += 1 
+            else: #s[end] 가 chars에 존재하지 않으면 
+                chars.add(s[end]) #해당 s[end]를 chars에 추가해준다
+                end += 1 #end를 오른쪽으로 옮겨 윈도우 확장 
+                max_len = max(end - start, max_len) #start-end 계산하여 update 
+        return max_len
+    
+mySolution = Solution()
+mySolution.lengthOfLongestSubstring("pwwkew")
+

longest-substring-without-repeating-characters/Jay-Mo-99.py

@@ -0,0 +1,64 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+
+// 🌟 sliding window technique
+
+// Time Complexity: O(n)
+// Why it's O(n)
+// - The end pointer iterates over the string exactly once (O(n)).
+// - The start pointer also only moves forward without re-processing elements (O(n)).
+// - Therefore, the total amount of work done is proportional to the length of the string (n).
+// - So, even though there is a while loop inside the for loop, the total work done (number of operations) is still linear, O(n), because the start and end pointers together move across the string just once.
+// - This is the key reason why the time complexity is O(n), even with nested loops.
+
+// Space Complexity: O(k), where k k is the length of the longest substring without repeating characters.
+// In the worst case, k = n, so O(n)
+
+var lengthOfLongestSubstring = function (s) {
+  let start = 0;
+  let longest = 0;
+  let subString = new Set();
+
+  for (let end = 0; end < s.length; end++) {
+    while (subString.has(s[end])) {
+      // Shrink the window by moving start
+      subString.delete(s[start]);
+      start += 1;
+    }
+
+    subString.add(s[end]);
+    longest = Math.max(longest, end - start + 1);
+  }
+
+  return longest;
+};
+
+// 🛠️ Solution 1
+// Time Complexity: O(n^2), where n is the length of the string s
+// Space Complexity: O(k), where k is the length of the longest substring without repeating characters (k ≤ n)
+
+// why the space complexity is not just O(n):
+// - Saying O(n) is technically correct in the worst case,
+// - but it hides the fact that the actual space usage is proportional to the length of the longest substring without repeats,
+// - which could be much smaller than n in many practical cases (e.g., for a string like "aaabbbccc").
+
+// var lengthOfLongestSubstring = function (s) {
+//   let longest = 0;
+
+//   for (let i = 0; i < s.length; i++) {
+//     let subString = new Set();
+
+//     for (let j = i; j < s.length; j++) {
+//       if (subString.has(s[j])) {
+//         break;
+//       } else {
+//         subString.add(s[j]);
+//         longest = Math.max(longest, j - i + 1);
+//       }
+//     }
+//   }
+//   return longest;
+// };
+

longest-substring-without-repeating-characters/Jeehay28.js

@@ -0,0 +1,37 @@
+"""
+Constraints:
+- 0 <= s.length <= 5 * 10^4
+- s consists of English letters, digits, symbols and spaces.
+
+Time Complexity: O(n)
+- 문자열을 한번만 순회
+
+Space Complexity: O(n)
+- 딕셔너리에 문자와 인덱스 저장
+
+풀이 방법:
+1. 슬라이딩 윈도우와 딕셔너리를 활용
+2. seen 딕셔너리에 각 문자의 마지막 등장 위치를 저장
+3. 중복 문자를 만나면 윈도우의 시작점(current_start)을 중복 문자 다음 위치로 이동
+4. 매 단계에서 현재 윈도우의 길이를 계산하고 최대 길이 갱신
+5. 최종적으로 가장 긴 중복 없는 부분 문자열의 길이 반환
+"""
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        seen = {}
+        current_start = 0
+        max_length = 0
+
+        for i in range(len(s)):
+            char = s[i]
+
+            if char in seen and seen[char] >= current_start:
+                current_start = seen[char] + 1
+
+            seen[char] = i
+
+            current_length = i - current_start + 1
+            max_length = max(current_length, max_length)
+        
+        return max_length

longest-substring-without-repeating-characters/KwonNayeon.py

@@ -0,0 +1,33 @@
+package leetcode_study
+
+/**
+ * 시간복잡도 : O(n) ?
+ * -
+ * 공간복잡도 : O(n)
+ * - charAndIdx 에 최대 n개의 문자에 대해서 담을 수 있으므로 O(n) 의 공간복잡도를 가집니다.
+ * */
+
+fun lengthOfLongestSubstring(s: String): Int {
+    var point = 0
+    val charAndIdx = HashMap<Char, Int>()
+    var cnt = 0
+    var maxCnt = 0
+
+    while (point < s.length) {
+        val nowChar = s[point]
+        if (nowChar !in charAndIdx.keys) {
+            charAndIdx[nowChar] = point
+            cnt += 1
+            point += 1
+        } else {
+            val prevSameCharIdx = charAndIdx[nowChar]!!
+            point = prevSameCharIdx + 1
+            charAndIdx.clear()
+            cnt = 0
+        }
+
+        maxCnt = maxOf(cnt, maxCnt)
+    }
+
+    return maxCnt
+}

longest-substring-without-repeating-characters/Real-Reason.kt

@@ -0,0 +1,28 @@
+/**
+ * 중복된 문자가 없는 가장 긴 부분 문자열 구하기
+ * 달레 알고리즘 해설을 참고하여 작성했습니다
+ * 슬라이딩 윈도우 방식 적용
+ * 알고리즘 복잡도
+ * - 시간 복잡도: O(n)
+ * - 공간 복잡도: O(n)
+ * @param s
+ */
+function lengthOfLongestSubstring(s: string): number {
+    const set = new Set<string>();
+    let start = 0;
+    let end = 0;
+    let maxLength = 0;
+
+    while (end < s.length) {
+        if (set.has(s[end])) {
+            set.delete(s[start])
+            start++
+        } else {
+            set.add(s[end])
+            maxLength = Math.max(maxLength, set.size)
+            end++
+        }
+    }
+    return maxLength
+}
+