Merge branch 'DaleStudy:main' into main

Author: Jay-Mo-99

container-with-most-water/HerrineKim.js

@@ -0,0 +1,26 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function (height) {
+  let maxWater = 0;
+  let left = 0;
+  let right = height.length - 1;
+
+  while (left < right) {
+    const lowerHeight = Math.min(height[left], height[right]);
+    const width = right - left;
+    maxWater = Math.max(maxWater, lowerHeight * width);
+
+    if (height[left] < height[right]) {
+      left++;
+    } else {
+      right--;
+    }
+  }
+
+  return maxWater;
+};

container-with-most-water/jinah92.py

@@ -0,0 +1,15 @@
+# O(1) spaces, O(N) times
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        max_area = 0
+        start, end = 0, len(height)-1
+
+        while start != end:
+            # start, end 포인터에서 물의 넓이 계산 및 최대값 계산
+            max_area = max((end-start)*min(height[start], height[end]), max_area)
+            if height[start] < height[end]:
+                start += 1
+            elif height[start] >= height[end]:
+                end -= 1
+        
+        return max_area

design-add-and-search-words-data-structure/jinah92.py

@@ -0,0 +1,23 @@
+# 공간복잡도 O(n): dictionary 멤버로 set을 사용
+# 시간복잡도 O(n*p): 삽입연산은 O(1)을 사용
+import re
+
+class WordDictionary:
+
+    def __init__(self):
+        self.dictionary = set()
+
+    def addWord(self, word: str) -> None:
+        self.dictionary.add(word)
+
+    def search(self, word: str) -> bool:
+        if '.' in word:
+            pattern = re.compile(word)
+            # O(n) times
+            for item in self.dictionary:
+                # O(p) times : 패턴의 길이(p)
+                if pattern.fullmatch(item):
+                    return True
+            return False
+        else:
+            return word in self.dictionary

longest-increasing-subsequence/jinah92.py

@@ -0,0 +1,12 @@
+# 공간 복잡도: O(n) => nums 길이만큼 dp 배열 길이만큼의 공간 사용
+# 시간 복잡도: O(n^2) => 외부 반복문은 O(N), 내부 반복문은 O(N) 시간이 소요되므로 총 O(N*N) = O(N^2) 소요
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        dp = [1] * len(nums)
+
+        for cur in range(1, len(nums)):
+            for prev in range(cur):
+                if nums[cur] > nums[prev]:
+                    dp[cur] = max(dp[prev]+1, dp[cur])
+        
+        return max(dp)

valid-parentheses/HerrineKim.js

@@ -0,0 +1,33 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+// 스택을 사용하여 괄호의 유효성을 검사
+// 괄호가 열리면 스택에 추가하고 닫히면 스택에서 마지막 요소를 꺼내서 짝이 맞는지 확인
+// 스택이 비어있으면 유효한 괄호 문자열
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function (s) {
+  const bracketStack = [];
+  const bracketPairs = {
+    ')': '(',
+    '}': '{',
+    ']': '['
+  };
+
+  for (const char of s) {
+    if (char in bracketPairs) {
+      const lastChar = bracketStack.pop();
+
+      if (lastChar !== bracketPairs[char]) {
+        return false;
+      }
+    } else {
+      bracketStack.push(char);
+    }
+  }
+
+  return bracketStack.length === 0;
+};

valid-parentheses/jinah92.py

@@ -0,0 +1,20 @@
+# O(s) 공간 복잡도 : 입력문자열 s 길이에 따라 최대 s 깊이의 stack 생성
+# O(s) 시간 복잡도 : 문자열 s 길이에 따라 for문 반복
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = []
+        pairs = {'[': ']', '(': ')', '{': '}'}
+
+        for i, ch in enumerate(s):
+            if ch == '(' or ch == '{' or ch == '[':
+                stack.append(ch)
+            else:
+                # '(', '[', '{' 문자가 앞에 없이 ')', ']', '}' 문자가 오는 경우
+                if not stack:
+                    return False
+                lastCh = stack.pop()
+                # pair가 맞지 않는 문자인 경우
+                if pairs[lastCh] != ch:
+                    return False
+        # stack에 값이 비지 않은 경우, pair가 맞지 않음
+        return not stack