Merge branch 'DaleStudy:main' into main

Author: gitsunmin

container-with-most-water/EGON.py

@@ -0,0 +1,47 @@
+from typing import List
+from unittest import TestCase, main
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        return self.solveWithTwoPointer(height)
+
+    """
+    Runtime: 527 ms (Beats 47.12%)
+    Time Complexity: O(n)
+        - 투 포인터의 총합 조회 범위가 height의 길이와 같으므로 O(n)
+        - area 갱신을 위한 계산에서 항이 2개인 max와 항이 2개인 min 중첩에 O(2) * O(2)
+        > O(n) * O(4) ~= O(n)
+
+    Memory: 29.61 MB (Beats 38.93%)
+    Space Complexity: O(1)
+        > 정수형 변수들만 사용했으므로 O(1)
+    """
+    def solveWithTwoPointer(self, height: List[int]) -> int:
+        left, right = 0, len(height) - 1
+        area = 0
+        while left < right:
+            area = max(area, (right - left) * min(height[right], height[left]))
+
+            if height[left] <= height[right]:
+                left += 1
+            else:
+                right -= 1
+
+        return area
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        height = [1, 8, 6, 2, 5, 4, 8, 3, 7]
+        output = 49
+        self.assertEqual(Solution.maxArea(Solution(), height), output)
+
+    def test_2(self):
+        height = [1, 1]
+        output = 1
+        self.assertEqual(Solution.maxArea(Solution(), height), output)
+
+
+if __name__ == '__main__':
+    main()

container-with-most-water/HC-kang.ts

@@ -0,0 +1,21 @@
+/**
+ * https://leetcode.com/problems/container-with-most-water/
+ * T.C. O(n)
+ * S.C. O(1)
+ */
+function maxArea(height: number[]): number {
+  let [res, i, j] = [0, 0, height.length - 1];
+
+  while (i < j) {
+    const volume = Math.min(height[i], height[j]) * (j - i);
+    res = Math.max(res, volume);
+
+    if (height[i] < height[j]) {
+      i++;
+    } else {
+      j--;
+    }
+  }
+
+  return res;
+}

container-with-most-water/flynn.cpp

@@ -0,0 +1,41 @@
+/**
+ * 풀이
+ * - container의 밑변이 넓고 높이가 높을 수록 저장하는 물의 양이 많습니다
+ * - 따라서 밑변이 가장 넓은 container부터 탐색하면 탐색 효율을 높일 수 있다는 생각을 했습니다
+ * - 양 끝에서부 two pointer를 이용하여 탐색을 시작합니다
+ * - lo, hi 중에서 높이가 더 낮은 pointer를 안쪽으로 이동시킵니다
+ * - 왜냐하면 높이가 더 낮은 pointer를 이동시켰을 때 기존 container보다 더 높이가 높은 container를 만들 수 있는 가능성이 생기기 때문입니다
+ * 
+ * Big O
+ * - N: 주어진 배열 height의 크기
+ * 
+ * - Time complexity: O(N)
+ *   - 배열 height를 조회하므로 전체 실행시간 또한 N에 비례하여 선형적으로 증가합니다
+ * 
+ * - Space complexity: O(1)
+ */
+
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int n = height.size();
+        int lo = 0;
+        int hi = n - 1;
+
+        int res = 0;
+        while (lo < hi) {
+            int w = hi - lo;
+            int h = min(height[lo], height[hi]);
+            
+            res = max(res, w * h);
+
+            if (height[lo] > height[hi]) {
+                --hi;
+            } else {
+                ++lo;
+            }
+        }
+
+        return res;
+    }
+};

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

@@ -0,0 +1,86 @@
+from unittest import TestCase, main
+
+
+class Node:
+
+    def __init__(self, key):
+        self.key = key
+        self.isWordEnd = False
+        self.children = {}
+
+
+class Trie:
+    WILD_CARD = '.'
+
+    def __init__(self):
+        self.root = Node(None)
+
+    def insert(self, word: str) -> None:
+        curr_node = self.root
+        for char in word:
+            if char not in curr_node.children:
+                curr_node.children[char] = Node(char)
+
+            curr_node = curr_node.children[char]
+        curr_node.isWordEnd = True
+
+    def search(self, node: Node, word: str, idx: int) -> bool:
+        if idx == len(word):
+            return node.isWordEnd
+
+        for idx in range(idx, len(word)):
+            if word[idx] == self.WILD_CARD:
+                for child in node.children.values():
+                    if self.search(child, word, idx + 1) is True:
+                        return True
+                else:
+                    return False
+
+            if word[idx] in node.children:
+                return self.search(node.children[word[idx]], word, idx + 1)
+            else:
+                return False
+
+
+"""
+Runtime: 1810 ms (Beats 22.46%)
+Time Complexity:
+    > addWord: word의 길이만큼 순회하므로 O(L)
+    > search:
+        - word의 평균 길이를 W이라하면,
+        - '.'가 포함되어 있지 않는 경우 O(W), early return 가능하므로 upper bound
+        - '.'가 포함되어 있는 경우, 해당 노드의 child만큼 재귀, trie의 평균 자식 수를 C라 하면 O(W) * O(C), early return 가능하므로 upper bound
+            - trie의 평균 자식 수는 addWord의 실행횟수 C'에 선형적으로 비레(겹치는 char가 없는 경우 upper bound)
+        > O(W) * O(C) ~= O(W) * O(C') ~= O(W * C'), upper bound
+
+Memory: 66.78 MB (Beats 12.26%)
+Space Complexity: O(1)
+    > addWord: 
+        - 삽입한 word의 평균 길이 L만큼 Node가 생성 및 Trie에 추가, O(L)
+        - addWord의 실행횟수 C'에 비례, O(C')
+        > O(L) * O(C') ~= O(L * C')
+    > search:
+        > 만들어진 Trie와 패러미터 word, 정수 변수 idx를 사용하므로 O(1)
+    
+"""
+class WordDictionary:
+
+    def __init__(self):
+        self.trie = Trie()
+
+    def addWord(self, word: str) -> None:
+        self.trie.insert(word)
+
+    def search(self, word: str) -> bool:
+        return self.trie.search(self.trie.root, word, 0)
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        wordDictionary = WordDictionary()
+        wordDictionary.addWord("at")
+        self.assertEqual(wordDictionary.search(".at"), False)
+
+
+if __name__ == '__main__':
+    main()

design-add-and-search-words-data-structure/HC-kang.ts

@@ -0,0 +1,102 @@
+/**
+ * https://leetcode.com/problems/design-add-and-search-words-data-structure
+ */
+// Using Trie
+class WordDictionary {
+  constructor(private root: Record<string, any> = {}) {}
+
+  /**
+   * T.C. O(L) L: length of a word
+   * S.C. O(L)
+   */
+  addWord(word: string): void {
+    let node = this.root;
+    for (const char of word) {
+      if (!node[char]) {
+        node[char] = {};
+      }
+      node = node[char];
+    }
+    node['isEnd'] = true;
+  }
+
+  /**
+   * T.C. O(N) - there are only 2 dots in the word(26 * 26 * N)
+   * S.C. O(N * L) N: number of words, L: length of a word
+   */
+  search(word: string): boolean {
+    return this.dfs(word, this.root);
+  }
+
+  private dfs(word: string, node: Record<string, any>): boolean {
+    for (let i = 0; i < word.length; i++) {
+      if (word[i] === '.') {
+        for (const key in node) {
+          if (this.dfs(word.slice(i + 1), node[key])) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (!node[word[i]]) {
+        return false;
+      }
+      node = node[word[i]];
+    }
+    return !!node['isEnd'];
+  }
+}
+
+// Using Array and Set
+class WordDictionary {
+  constructor(
+    private words: Set<string>[] = Array.from({ length: 25 }, () => new Set())
+  ) {}
+
+  /**
+   * T.C. O(1)
+   * S.C. O(N * L)
+   */
+  addWord(word: string): void {
+    this.words[word.length - 1].add(word);
+  }
+
+  /**
+   * T.C. O(N * L) N: number of words, L: length of a word
+   * S.C. O(1)
+   */
+  search(word: string): boolean {
+    const hasDot = word.indexOf('.') !== -1;
+    const set = this.words[word.length - 1];
+
+    if (!hasDot) {
+      return set.has(word);
+    }
+
+    for (const w of set) {
+      let i = 0;
+      while (i < word.length) {
+        if (word[i] == '.') {
+          i++;
+          continue;
+        }
+        if (word[i] !== w[i]) {
+          break;
+        }
+        i++;
+      }
+
+      if (i === word.length) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * var obj = new WordDictionary()
+ * obj.addWord(word)
+ * var param_2 = obj.search(word)
+ */

design-add-and-search-words-data-structure/flynn.cpp

@@ -0,0 +1,85 @@
+/**
+ * 풀이
+ * - Trie 구조를 활용하여 풀이할 수 있습니다
+ * - wildcard인 '.'에 대한 처리가 필요합니다
+ * 
+ * Big O
+ * - N: 주어지는 문자열 word의 길이
+ * - M: 현재 WordDictionary에 저장되어 있는 TrieNode의 수
+ * 
+ * - void addWord(string word)
+ *   - Time complexity: O(N)
+ *   - Space complexity: O(N)
+ *     - 최악의 경우 word의 모든 문자에 대해 새로운 TrieNode를 추가해야 합니다
+ * 
+ * - bool search(string word)
+ * - bool _search(string word, int idx, TrieNode* node)
+ *   - Time complexity: best O(N), worst O(M) < O(26^N)
+ *     - wildcard 사용 및 기존에 저장된 word의 상태에 따라 달라집니다
+ *   - Space complexity: O(N)
+ *     - _search가 재귀적으로 호출되므로 재귀 호출 스택의 깊이만큼 추가적인 공간이 사용됩니다
+ *     - 재귀 호출 스택의 깊이는 현재 찾는 word의 길이에 선형적으로 비례합니다
+ */
+
+class TrieNode {
+public:
+    array<TrieNode*, 27> links;
+    bool word;
+
+    TrieNode(): word(false) {
+        links.fill(nullptr);
+    }
+};
+
+class WordDictionary {
+public:
+    WordDictionary(): root(new TrieNode()) {}
+    
+    void addWord(string word) {
+        TrieNode* current = root;
+        
+        for (char c : word) {
+            if (current->links[c - 'a'] == nullptr) {
+                current->links[c - 'a'] = new TrieNode();
+            }
+            current = current->links[c - 'a'];
+        }
+
+        current->word = true;
+    }
+    
+    bool search(string word) {
+        return _search(word, 0, root);
+    }
+    
+private:
+    TrieNode* root;
+
+    bool _search(string word, int idx, TrieNode* node) {
+        if (node == nullptr) return false;
+
+        if (word.size() == idx) return node->word;
+
+        char c = word[idx];
+
+        if (c != '.') {
+            TrieNode* next_node = node->links[c - 'a'];
+            int next_idx = idx + 1;
+
+            return _search(word, next_idx, next_node);
+        } else {
+            for (TrieNode* next_node : node->links) {
+                int next_idx = idx + 1;
+                if (_search(word, next_idx, next_node)) return true;
+            }
+            return false;
+        }
+    }
+};
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary* obj = new WordDictionary();
+ * obj->addWord(word);
+ * bool param_2 = obj->search(word);
+ */