Merge branch 'DaleStudy:main' into main

Author: gitsunmin

container-with-most-water/TonyKim9401.java

@@ -0,0 +1,24 @@
+// TC:
+// SC:
+class Solution {
+    public int maxArea(int[] height) {
+        int max = 0;
+
+        int start = 0;
+        int end = height.length-1;
+
+        while (start < end) {
+            int heightLeft = height[start];
+            int heightRight = height[end];
+
+            int hei = Math.min(heightLeft, heightRight);
+            int wid = end - start;
+
+            max = Math.max(max, hei*wid);
+
+            if (heightRight > heightLeft) start += 1;
+            else end -= 1;
+        }
+        return max;
+    }
+}

container-with-most-water/haklee.py

@@ -0,0 +1,105 @@
+"""TC: O(n), SC: O(1)
+
+아이디어:
+높이 리스트 l이 주어졌다고 하자. 그리고 이 안에 있는 최대 수조 면적을 f(l)이라고 하자.
+
+  □               □   □  
+  □               □   □   □
+  □ □ □   □       □ □ □ □ □
+□ □ □ □   □   □ □ □ □ □ □ □
+□ □ □ □ □ □ □ □ □ □ □ □ □ □
+2,5,3,3,1,3,1,2,2,5,3,5,3,4
+            ^
+            l          
+
+
+그러면 다음이 항상 성립한다.
+
+- l의 양 끝의 값 중 작은 값 x가 앞쪽에 있었다고 해보자. x를 뺀 리스트 l`을 만든다.
+    - 이때 작은 값이 뒷쪽에 있었어도 일반성을 잃지 않는다.
+
+ │□               □   □  
+ │□               □   □   □
+ │□ □ □   □       □ □ □ □ □
+□│□ □ □   □   □ □ □ □ □ □ □
+□│□ □ □ □ □ □ □ □ □ □ □ □ □
+2│5,3,3,1,3,1,2,2,5,3,5,3,4
+^             ^
+x             l`
+
+
+- f(l)은 그렇다면
+    - f(l`)이거나(즉, x를 쓰지 않았거나)
+    - x를 써서 만든 수조 면적 중에 있다.
+
+- 그런데 x는 l의 양 끝 값 중에 작은 값이므로, 아래와 같은 분석을 할 수 있다.
+    1) x를 써서 만드는 수조의 높이는 아무리 높아도 x다. x보다 작아질 수는 있어도, x보다 커질 수는 없다.
+    2) x를 써서 만드는 수조의 폭은 l의 다른쪽 끝에 있는 높이를 선택했을때 최대가 된다.
+- 그러므로, x를 써서 만들 수 있는 수조의 최대 크기는 l의 다른쪽 끝에 있는 높이를 선택한 경우 나온다.
+
+위의 내용을 아래의 설명을 통해 시각적으로 확인할 수 있다.
+
+- 양 끝을 선택한 경우 x로 만들 수 있는 최대 면적이다.
+
+ │□               □   □  
+ │□               □   □   □
+ │□ □ □   □       □ □ □ □ □
+■│■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
+■│■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
+2│5,3,3,1,3,1,2,2,5,3,5,3,4
+^                         ^
+
+- x는 그대로 둔 채 다른쪽 끝을 안쪽으로 더 이동하면 수조 높이는 동일한데 폭은 더 작아진다.
+
+ │□               □   □  
+ │□               □   □   □
+ │□ □ □   □       □ □ □ □ □
+■│■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ □
+■│■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ □
+2│5,3,3,1,3,1,2,2,5,3,5,3,4
+^                     ^
+
+- 심지어 x보다 작은 높이 값을 선택한 경우 수조 높이도 작아지고 폭도 작아지는 일이 일어난다.
+
+ │□               □   □  
+ │□               □   □   □
+ │□ □ □   □       □ □ □ □ □
+□│□ □ □   □   □ □ □ □ □ □ □
+■│■ ■ ■ ■ ■ ■ □ □ □ □ □ □ □
+2│5,3,3,1,3,1,2,2,5,3,5,3,4
+
+
+즉, 위의 내용을 종합하면 다음을 확인할 수 있다.
+- f(l) = max( (l의 양 끝 높이를 선택해서 만든 수조 넓이), f(l`) )
+- 그런데 f(l`)도 f(l)을 구한 것과 같은 방식으로 구할 수 있다. 즉, 새로 만들어진 l`의 양 끝 높이 중
+  짧은 쪽을 뺀 리스트 l``을 만들어서 위의 과정을 반복할 수 있다.
+- 즉, f(l)은 아래의 과정을 반복하여 구할 수 있다.
+    - l의 양 끝 높이를 써서 수조 넓이를 구하고, 기존 최대 넓이와 비교하여 더 큰 값을 최대 넓이에 대입한다.
+    - l에서 짧은 쪽 높이를 뺀다.
+    - 위 과정을 l에 아이템이 하나만 남을 때까지 반복.
+
+
+SC:
+- 투 포인터를 써서 l의 시작, 끝 인덱스를 관리하면 O(1).
+- 수조 최대 넓이값 관리, O(1).
+- 종합하면 O(1).
+
+TC:
+- 리스트의 양 끝 높이를 통해 면적 구하기, O(1).
+- 포인터 이동 O(1).
+- 포인터 이동시 두 포인터 사이의 거리가 1씩 항상 감소하므로 위 과정을 최대 n-2번 반복.
+- 종합하면 O(n). 
+"""
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        max_area = -1
+        s, e = 0, len(height) - 1
+        while s < e:
+            max_area = max(max_area, (e - s) * min(height[s], height[e]))
+            if height[s] > height[e]:
+                e -= 1
+            else:
+                s += 1
+        return max_area

container-with-most-water/jaejeong1.java

@@ -0,0 +1,31 @@
+class SolutionMaxArea {
+  public int maxArea(int[] height) {
+    // A와 B 간 면적 = (A와 B의 X축 차이) * (A와 B Y축 중 더 작은 Y축 길이)
+    // 1번째 풀이 방법: 선택할 수 있는 모든 경우에 대해 위 값을 구한다, 시간복잡도: O(N^2) / 공간복잡도: O(1)
+    // (최종) 2번째 풀이 방법: 양쪽 끝에서 투포인터로 좁혀오면서 면적을 구한다, 시간복잡도: O(N) / 공간복잡도: O(1)
+    // 전체 너비를 고려하면서 움직여야한다.
+    // 매번 면적을 계산하고, 더 크면 저장한다.
+    // lt와 rt 중 더 낮은쪽을 좁힌다
+
+    var lt = 0;
+    var rt = height.length-1;
+    var maxArea = 0;
+
+    while(lt < rt) {
+      var x = rt - lt;
+      var y = Math.min(height[lt], height[rt]);
+      var currentArea = x * y;
+      if (maxArea < currentArea) {
+        maxArea = currentArea;
+      }
+
+      if (height[lt] < height[rt]) {
+        lt++;
+      } else {
+        rt--;
+      }
+    }
+
+    return maxArea;
+  }
+}

container-with-most-water/kayden.py

@@ -0,0 +1,17 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(N)
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        l, r = 0, len(height) - 1
+        answer = 0
+
+        while l < r:
+
+            if height[l] < height[r]:
+                answer = max(answer, (r - l) * height[l])
+                l += 1
+            else:
+                answer = max(answer, (r - l) * height[r])
+                r -= 1
+
+        return answer

container-with-most-water/sunjae95.js

@@ -0,0 +1,28 @@
+/**
+ * @description
+ * brainstorming:
+ * 1. brute force -> time limited
+ * 2. two pointer
+ *
+ * n: length of height
+ * time complexity: O(n)
+ * space complexity: O(1)
+ */
+var maxArea = function (height) {
+  let answer = 0;
+  let start = 0;
+  let end = height.length - 1;
+
+  while (start !== end) {
+    const w = end - start;
+    const h = Math.min(height[start], height[end]);
+    answer = Math.max(answer, w * h);
+    if (height[start] >= height[end]) {
+      end--;
+    } else if (height[start] < height[end]) {
+      start++;
+    }
+  }
+
+  return answer;
+};

container-with-most-water/wogha95.js

@@ -0,0 +1,33 @@
+/**
+ * TC: O(H)
+ * SC: O(1)
+ * H: height.length
+ */
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function (height) {
+  let maximumWater = 0;
+  let left = 0;
+  let right = height.length - 1;
+
+  // 1. 투포인터를 이용하여 양끝에서 모입니다.
+  while (left < right) {
+    // 2. 최대 너비값을 갱신해주고
+    const h = Math.min(height[left], height[right]);
+    const w = right - left;
+
+    maximumWater = Math.max(maximumWater, w * h);
+
+    // 3. 왼쪽과 오른쪽 높이 중 더 낮은 쪽의 pointer를 옮깁니다.
+    if (height[left] < height[right]) {
+      left += 1;
+    } else {
+      right -= 1;
+    }
+  }
+
+  return maximumWater;
+};

design-add-and-search-words-data-structure/TonyKim9401.java

@@ -0,0 +1,56 @@
+// SC: O(n)
+// -> n is the length of the given String
+// TC: O(n * 26)
+// -> n is the length of the given String * the number of alphabets
+class TrieNode {
+    TrieNode[] childNode;
+    boolean isEndOfWord;
+
+    public TrieNode() {
+        childNode = new TrieNode[26];
+        isEndOfWord = false;
+    }
+}
+
+class WordDictionary {
+
+    private TrieNode root;
+
+    public WordDictionary() {
+        root = new TrieNode();
+    }
+
+    public void addWord(String word) {
+        TrieNode node = root;
+
+        for (char c : word.toCharArray()) {
+            int idx = c - 'a';
+            if (node.childNode[idx] == null) {
+                node.childNode[idx] = new TrieNode();
+            }
+            node = node.childNode[idx];
+        }
+        node.isEndOfWord = true;
+    }
+
+    public boolean search(String word) {
+        return searchInNode(word.toCharArray(), 0, root);
+    }
+
+    private boolean searchInNode(char[] word, int idx, TrieNode node) {
+        if (idx == word.length) return node.isEndOfWord;
+
+        char c = word[idx];
+
+        if (c == '.') {
+            for (TrieNode child : node.childNode) {
+                if (child != null && searchInNode(word, idx+1, child)) return true;
+            }
+            return false;
+        } else {
+            int childIdx = c - 'a';
+            if (node.childNode[childIdx] == null) return false;
+            return searchInNode(word, idx+1, node.childNode[childIdx]);
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+"""search시: TC: O(n), SC: O(n)
+
+word의 max length가 w, `addWord`를 통해 만들어진 노드 개수가 n개라고 하자.
+
+아이디어:
+`implement-trie-prefix-tree` 문제에서 구현한 trie에서 search 부분만 recursive한 dfs 구현으로 수정.
+
+SC:
+- trie의 노드 개수 O(n).
+- dfs시 스택 깊이는 최대 w. 즉, O(w). 그런데 스택 깊이는 노드 개수보다 클 수 없다. 즉, O(w) < O(n).
+- 종합하면, O(n) + O(w) < O(n) + O(n) = O(n).
+
+TC:
+- 최악의 경우 모든 노드 순회. O(n).
+
+"""
+
+
+class WordDictionary:
+
+    def __init__(self):
+        self.next: dict[str, WordDictionary] = {}
+        self.end: bool = False
+
+    def addWord(self, word: str) -> None:
+        cur = self
+
+        for c in word:
+            cur.next[c] = cur.next.get(c, WordDictionary())
+            cur = cur.next[c]
+
+        cur.end = True
+
+    def search(self, word: str) -> bool:
+        cur = self
+
+        return self._search(cur, word, 0)
+
+    def _search(self, trie, word: str, ind: int) -> bool:
+        if ind == len(word):
+            return trie.end
+
+        c = word[ind]
+
+        if c == ".":
+            return any(
+                [self._search(node, word, ind + 1) for node in trie.next.values()]
+            )
+
+        if c not in trie.next:
+            return False
+
+        return self._search(trie.next[c], word, ind + 1)
+
+
+# Your WordDictionary object will be instantiated and called as such:
+# obj = WordDictionary()
+# obj.addWord(word)
+# param_2 = obj.search(word)