Merge branch 'DaleStudy:main' into main

Author: jylee2033

best-time-to-buy-and-sell-stock/Cyjin-jani.js

@@ -0,0 +1,43 @@
+// naive하게 풀면, time limit 초과함
+// O(n^2) 풀이가 되기 때문..
+const maxProfit_naive = function (prices) {
+  let profit = 0;
+
+  for (let i = 0; i < prices.length - 1; i++) {
+    const buy = prices[i];
+    for (let j = i + 1; j < prices.length; j++) {
+      const newProfit = prices[j] - buy;
+      if (newProfit > profit) {
+        profit = newProfit;
+      }
+    }
+  }
+
+  return profit;
+};
+
+// 투포인터 사용하여 풀기
+// tc: O(n)
+// sc: O(1)
+const maxProfit = function (prices) {
+  let buyIdx = 0;
+  let sellIdx = 1;
+  let profit = 0;
+
+  while (sellIdx < prices.length) {
+    let buyPrice = prices[buyIdx];
+    let sellPrice = prices[sellIdx];
+
+    // 더 낮은 가격에 매수 가능한 날을 찾으면 바로 거기서부터 재탐색
+    if (buyPrice > sellPrice) {
+      buyIdx = sellIdx;
+    } else {
+      let newProfit = sellPrice - buyPrice;
+      profit = Math.max(profit, newProfit);
+    }
+
+    sellIdx++;
+  }
+
+  return profit;
+};

best-time-to-buy-and-sell-stock/liza0525.py

@@ -23,3 +23,25 @@ def maxProfit(self, prices: List[int]) -> int:
 
         # 최종적으로 기록된 max_profit이 답
         return max_profit
+
+
+# 7기 풀이
+# 시간 복잡도: O(n)
+#  - prices의 길이 n만큼 순회
+# 공간 복잡도: O(1)
+#  - 상수만 사용
+class Solution:
+    # 첫날부터 매일의 가격이 최소인지, 최대인지를 판단하여 가장 큰 이익을 낼 수 있는 값을 계산한다.
+    # 첫날부터 시간 순서대로 확인해야 함(기간 중 가장 최댓값이 가장 최솟값보다 빠를 수도 있기 때문)
+    def maxProfit(self, prices: List[int]) -> int:
+        min_sell_price = 10 ** 4  # 문제 조건에서 10의 4승이 최대라고 하여 이를 min_sell_price의 초기값으로
+        max_profit = 0
+
+        for price in prices:
+            # 매일 순회하며 지나간 시간들 중에 가장 작은 price인지 확인하여 업데이트
+            min_sell_price = min(min_sell_price, price)
+
+            # 매일 순회하며 오늘 얻을 수 있는 profit과 이전에 얻었던 max_profit을 비교하여 업데이트
+            max_profit = max(max_profit, price - min_sell_price)
+
+        return max_profit

encode-and-decode-strings/liza0525.py

@@ -0,0 +1,28 @@
+# 7기 풀이
+# 시간 복잡도: O(n)
+#  - 인코딩 디코딩 모두 문자열 리스트의 길이에 따라 시간 복잡도가 결정됨
+# 공간 복잡도: O(1)
+#  - 정답 변수인 res를 제외하고는 변수만 쓰임
+
+
+DELIMITER = "^"
+
+
+class Solution:
+    def encode(self, strs):
+        # DELIMITER를 사이에 두고 단어의 글자 수와 단어를 concat해서 저장한다.
+        # 예) ["cat", "is", "cute"] -> "3^cat2^is4^cute"
+        # 이렇게 해야 글자 수를 예측하고 split하기 쉬워진다. 
+        return "".join(map(lambda x: f"{len(x)}{DELIMITER}{x}", strs))
+
+    def decode(self, s):
+        res = []
+        i = 0
+        while i < len(s):
+            # i번째 글자로부터 첫번째 DELIMITER가 나오는 인덱스를 j라고 칭함
+            j = s.index(DELIMITER, i)
+            word_len = int(s[i:j])  # DELIMITER 앞의 글자는 '글자 수'이므로 int로 변환
+            word = s[j + 1:j + word_len + 1]  # i번째부터 글자 수 만큼 잘라서 word를 찾음
+            res.append(word)
+            i = j + word_len + 1  # 자른 이후의 index를 새로운 i로 설정하여 다음 글자 찾음
+        return res

group-anagrams/Cyjin-jani.js

@@ -0,0 +1,95 @@
+const isAnagram = function (s, t) {
+  if (s.length !== t.length) return false;
+
+  const data = new Map();
+
+  for (let char of s) {
+    data.set(char, (data.get(char) || 0) + 1);
+  }
+
+  for (let char of t) {
+    if (!data.get(char)) return false;
+    data.set(char, data.get(char) - 1);
+  }
+
+  return true;
+};
+
+// Time Limit Exceeded로 fail..
+// tc: O(n^2);
+// sc: O(n)
+const groupAnagrams_naive = function (strs) {
+  if (strs.length < 2) return [strs];
+
+  const answer = [];
+
+  while (strs.length > 0) {
+    let temp = [strs[0]];
+
+    if (strs.length < 2) return answer;
+
+    strs.splice(0, 1);
+
+    for (let j = 0; j < strs.length; j++) {
+      if (isAnagram(temp[0], strs[j])) {
+        // 같다면, temp 배열에 넣음
+        temp.push(strs[j]);
+      }
+    }
+    answer.push(temp);
+
+    temp.forEach((t) => {
+      const idx = strs.indexOf(t);
+      if (idx !== -1) {
+        strs.splice(idx, 1);
+      }
+    });
+
+    if (strs.length === 1) {
+      answer.push(strs);
+    }
+  }
+
+  return answer;
+};
+
+// splice 같은 로직이 없어서 겨우 TLE을 통과했지만 여전히 O(n²)인 점은 변함이 없음.
+const groupAnagrams_set = function (strs) {
+  const visited = new Set();
+  const answer = [];
+
+  for (let i = 0; i < strs.length; i++) {
+    if (visited.has(i)) continue;
+
+    const group = [strs[i]];
+
+    for (let j = i + 1; j < strs.length; j++) {
+      if (!visited.has(j) && isAnagram(strs[i], strs[j])) {
+        group.push(strs[j]);
+        visited.add(j);
+      }
+    }
+
+    answer.push(group);
+  }
+
+  return answer;
+};
+
+//! AI로부터 힌트를 얻어 풀어봤습니다..
+// tc: O(nlogn)
+// sc: O(n)
+const groupAnagrams = function (strs) {
+  const map = new Map();
+
+  for (const str of strs) {
+    const key = str.split('').sort().join('');
+
+    if (!map.has(key)) {
+      map.set(key, []);
+    }
+    map.get(key).push(str);
+  }
+
+  return [...map.values()];
+};

group-anagrams/liza0525.py

@@ -0,0 +1,19 @@
+# 7기 풀이
+# 시간 복잡도: O(n)
+#  - 입력 받은 strs 리스트의 길이 만큼 순회하므로
+# 공간 복잡도: O(1)
+#  - 결과로 반환할 result를 제외하고는 변수만 사용
+from collections import defaultdict
+
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        result = defaultdict(list)
+
+        for str_ in strs:
+            # 아나그램의 key를 동일하게 만든다. 갖고 있는 문자열의 오름차순 결과를 key로 만듦
+            anagram_key = "".join(sorted(list(str_)))
+            # 같은 key를 가진 것끼리 리스트로 묶어둔다.
+            result[anagram_key].append(str_)
+
+        return list(result.values())

implement-trie-prefix-tree/liza0525.py

@@ -0,0 +1,45 @@
+# 7기 풀이
+# Trie 전체 공간 복잡도: 공간: O(n * m)
+#   - n은 단어 수, m은 평균 단어 길이
+# 각 메서드 마다 시간 복잡도와 공간 복잡도 작성
+class Node:
+    def __init__(self, val=None):
+        self.children = {}  # 자식 노드를 담을 dictionary
+        self.is_end = False  # 현재 노드를 끝으로 하는 단어가 저장되었는지에 대한 flag
+
+
+class Trie:
+    def __init__(self):
+        self.root = Node()
+
+    def insert(self, word: str) -> None:
+        # 시간: O(m) — m은 word의 길이, 문자 하나씩 순회
+        # 공간: O(m) — 최악의 경우 m개의 새 노드 생성 (아무것도 공유 안할 때)
+        node = self.root
+        for s in word:
+            if s not in node.children:  # 아직 저장이 되지 않은 문자라면 children에 노드로써 저장해둔다.
+                node.children[s] = Node(s)
+            node = node.children[s]  # 다음 노드를 children node로 지정하여 후손까지 저장할 수 있도록 함
+        node.is_end = True  # 모든 노드를 저장한 후에는 단어의 끝을 알리도록 is_end를 True로 변경
+
+    def search(self, word: str) -> bool:
+        # 시간: O(m) — m은 word/prefix의 길이만큼 순회
+        # 공간: O(1) — 새 노드 생성 없이 포인터만 이동
+        node = self.root
+        for s in word:
+            if s not in node.children:  # 찾으려는 단어의 문자가 저장되어 있지 않으면 search 실패이므로 False 반환
+                return False
+            node = node.children[s]
+
+        return node.is_end  # 끝까지 돌아보고 해당 단어의 끝이 저장되어 있는지 아닌지를 반환하므로써 search의 성패 여부를 확인할 수 있음
+
+    def startsWith(self, prefix: str) -> bool:
+        # start with의 경우에는, search와 거의 로직이 동일하나, is_end의 여부를 볼 필요가 없으므로 모든 문자에 대한 search가 끝나면 무조건 True 반환
+        node = self.root
+        for s in prefix:
+            if s not in node.children:
+                return False
+            node = node.children[s]
+
+        return True
+

word-break/liza0525.py

@@ -0,0 +1,37 @@
+# 7기 풀이
+# 시간 복잡도: 시간복잡도: O(n * m)
+# - n은 s의 길이, m은 wordDict의 평균 단어 길이
+# - 각 인덱스마다 wordDict를 순회하므로
+# 공간 복잡도: 공간복잡도: O(n)
+# - memo에 최대 n개의 인덱스를 저장
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        memo = set()
+
+        def dfs(i):
+            if i == len(s):
+                # i가 s의 길이가 되면 모든 탐색이 성공으로 끝났기 때문에
+                # True로 반환
+                return True
+
+            memo.add(i)  # 해당 인덱스에 대해서는 방문을 했기 때문에 memo
+            for word in wordDict:
+                if i + len(word) in memo:
+                    # i + len(word)가 memoization해둔 인덱스라면 이미 성공한 케이스므로 통과
+                    continue
+
+                if i + len(word) > len(s):
+                    # i + len(word)가 len(s)보다 크면 탐색을 더이상 할 수 없으므로 continue
+                    continue
+
+                # 아직 방문을 하지 않은 index라면 단어를 slice하여 실제로 wordDict에 있는지 확인 
+                if s[i:i + len(word)] in wordDict:
+                    # 다음 인덱스 i + len(word)로 dfs 탐색
+                    check = dfs(i + len(word))
+                    if check:
+                        # 모든게 성공되었을 땐 True 반환
+                        return True
+
+            return False
+
+        return dfs(0)