Merge remote-tracking branch 'origin/main'

Author: eunhwa99

container-with-most-water/ekgns33.java

@@ -0,0 +1,83 @@
+/*
+input : array of integer height
+output : maximum amount of water a container can store.
+
+we can build container with two different line (height[i], height[j] when i < j)
+
+example
+1 8 6 2 5 4 8 3 7
+choose i = 1.
+choose j = 4
+   8 ______5 
+    amount of water == (j - i) * min(height[i], height[j])
+   = 3 * 5 = 15
+
+we have to maximize amount of water.
+
+constraints:
+1) is the input array valid?
+length of array is in range [2, 10^5]
+2) positive integers?
+no. range of height is [0, 10 ^4]
+>> check amount can be overflow. 10^4 * 10 ^ 5 = 10^9 < Integer range
+edge:
+1) if length is 2
+return min(height[0], height[1]).
+...
+
+solution 1) brute force;
+iterate through the array from index i = 0 to n-1
+     when n is the length of input array
+    iterate through the array from index j = i + 1 to n;
+        calculate the amount of water and update max amount
+ds : array
+algo : x
+tc : O(n^2) ~= 10^10 TLE
+space : O(1)
+
+solution 2) better 
+ds : array
+algo: two pointer?
+
+two variant for calculating amount of water
+1. height 2. width
+
+set width maximum at first, check heights
+    decrease width one by one
+
+    - at each step width is maximum. 
+        so we have to maximize
+        the minimum between left and right pointer
+
+use left and right pointer 
+while left < right
+
+    calculate amount 
+    compare
+    if height[left] < height[right]
+        move left by one
+    else 
+        vice versa
+
+return max
+tc : O(n)
+sc : O(1)
+
+ */
+class Solution {
+  public int maxArea(int[] height) {
+    int left = 0;
+    int right = height.length - 1;
+    int maxAmount = 0;
+    while(left < right) {
+      int curAmount = (right - left) * Math.min(height[left], height[right]);
+      maxAmount = Math.max(maxAmount, curAmount);
+      if(height[left] < height[right]) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+    return maxAmount;
+  }
+}

container-with-most-water/forest000014.java

@@ -0,0 +1,115 @@
+/*
+solution 1. brute force
+Time Complexity: O(n^2)
+Space Complexity: O(1)
+모든 선분 i에 대해, 가장 많은 물을 담을 수 있는 반대쪽 선분 j를 찾는다.
+
+
+solution 2. PQ
+Time Complexity: O(nlogn)
+- 정렬 : O(nlogn)
+- i번째 선분에 대해 (자신보다 크거나 같은) 가장 멀리있는 선분 탐색(O(logn)) * n = O(nlogn)
+Space Complexity: O(n)
+
+(사고의 흐름을 적기 위해 편의상 반말로 적었습니다... ^^)
+brute force 에서 불필요한 탐색을 줄여보자.
+일단 어떤 선분 i가 주어졌다고 가정하자. i를 한쪽 벽으로 해서 가장 많은 물을 담는 방법을 찾으려면, 반드시 나머지 모든 선분을 탐색해야만 할까?
+
+(1) 자신보다 작은 선분은 탐색하지 않는다.
+
+자신보다 큰 선분만을 탐색해도 충분하다.
+왜냐하면, 설령 자신보다 더 작은 선분 중에 정답이 있었다고 하더라도, 그 선분을 기준으로 탐색할 때 정답에 해당하는 쌍을 확인하게 될 것이기 때문이다.
+
+(2) 자신보다 크거나 같은 선분만을 탐색 대상으로 삼는다면, 가장 멀리있는 선분만 확인하면 된다.
+
+탐색 대상이 자신보다 크거나 같은 선분들이라면, 어차피 담을 수 있는 물의 높이는 자신의 높이로 일정하다.
+따라서, 멀리있는 선분일수록 더 많은 물을 담게 된다.
+즉, "자신보다 크거나 같으면서", "가장 멀리 있는(오른쪽이든 왼쪽이든)" 선분만을 후보로 삼아 확인하면 충분하다.
+(그 외의 나머지, 즉 자신보다 크거나 같으면서, 가장 멀리있지 않은 나머지 선분들은, 자연스럽게 탐색하지 않을 수 있다.)
+
+정리하자면, 주어진 선분 i에 대해서, 단 2번(오른쪽, 왼쪽)의 탐색만 하면 충분하다.
+
+(3) 내림차순 정렬과 2개의 PQ를 아래처럼 활용하면, 위 탐색을 O(logn) 시간에 수행할 수 있다.
+PQ는 각각 x 좌표 기준 max heap(가장 오른쪽의 선분을 찾기 위함), x 좌표 기준 min heap(가장 왼쪽의 선분을 찾기 위함)을 사용한다.
+선분들을 길이 내림차순으로 정렬해놓고, 하나씩 순회하면서 (say, i번째 선분), 아래 과정을 반복한다.
+- 자신보다 크거나 같으면서 가장 오른쪽으로 멀리 있는 선분의 위치를 찾아서(= 현재 PQ(max heap)의 root), 최대 물의 양을 계산한다.
+- 자신보다 크거나 같으면서 가장 왼쪽으로 멀리 있는 선분의 위치를 찾아서(= 현재 PQ(min heap)의 root), 최대 물의 양을 계산한다.
+- i번째 선분을 PQ 2개에 각각 넣는다.
+
+
+solution 3. two pointers
+(AlgoDale 풀이를 참고함)
+
+Time Complexity: O(n)
+Space Complexity: O(1)
+
+2 포인터를 활용하면, PQ도 없이 시간 복잡도를 O(n)으로 줄일 수 있었다.
+단순히 "큰 쪽을 줄이기보다는, 작은 쪽을 줄이는 게 유리하겠지" 정도의 greedy한 논리는 충분하지 않은 것 같고, 더 명확한 근거가 있을 것 같은데 시간 관계상 고민해보지는 못했다.
+
+To-Do : 풀이가 대강 이해는 되었지만, 이게 왜 되는지, 엄밀하게 이해하기 위해 PQ를 사용했던 논리를 좀 더 발전시켜볼 필요가 있다.
+
+*/
+class Solution {
+    public int maxArea(int[] height) {
+        int i = 0, j = height.length - 1;
+
+        int ans = 0;
+        while (i < j) {
+            int area = (j - i) * Math.min(height[i], height[j]);
+            if (area > ans) {
+                ans = area;
+            }
+
+            if (height[i] <= height[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+
+        return ans;
+    }
+
+    ////// 아래는 solution 2
+    private static class Tuple {
+        private int x;
+        private int h;
+
+        Tuple(int x, int h) {
+            this.x = x;
+            this.h = h;
+        }
+    }
+
+    public int maxArea2(int[] height) {
+        List<Tuple> tuples = IntStream.range(0, height.length)
+                .mapToObj(i -> new Tuple(i, height[i]))
+                .collect(Collectors.toList());
+        Collections.sort(tuples, (a, b) -> b.h - a.h);
+
+        PriorityQueue<Tuple> minPq = new PriorityQueue<>((a, b) -> a.x - b.x);
+        PriorityQueue<Tuple> maxPq = new PriorityQueue<>((a, b) -> b.x - a.x);
+
+        int ans = 0;
+        for (int i = 0; i < height.length; i++) {
+            minPq.add(tuples.get(i));
+            maxPq.add(tuples.get(i));
+
+            Tuple curr = tuples.get(i);
+
+            Tuple left = minPq.peek();
+            int leftArea = (curr.x - left.x) * curr.h;
+            if (leftArea > ans) {
+                ans = leftArea;
+            }
+
+            Tuple right = maxPq.peek();
+            int rightArea = (right.x - curr.x) * curr.h;
+            if (rightArea > ans) {
+                ans = rightArea;
+            }
+        }
+
+        return ans;
+    }
+}

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

@@ -0,0 +1,109 @@
+/**
+ design ds that supports add, find
+ find if string matches any previously added string.
+ >> some kind of dictionary
+
+ example
+ add bad
+ add dad
+ add mad
+ search pad >> false
+ search bad >> true
+ search .ad >> true . can be 'b' or 'd' or 'm'
+ search b.. >> true .. can be "ad"
+
+ constraints:
+ 1) empty string can be valid input?
+ nope. lenght of string is in range of [1, 25]
+ 2) string only contiains alphanumeric? or alphabet
+ only lowercase English letters
+ 3) how many queries can be given as input?
+ at most 10^4
+
+ solution 1) brute force
+ save to data structure. for add
+ check every character for all the saved words
+ O(kn) when k is the number of saved words,
+ n is the length of input word token
+ 25 * 25 * 10^4
+ tc : O(kn) + O(kn)
+ add : O(1)
+ search : O(kn)
+ sc : O(kn)
+
+ solution 2) trie?
+
+ save words to trie.
+ when searching
+ do bfs or backtracking dfs
+ if current charcter is . add all childs
+ else add matching childs
+ overall tc : O(sum(m)) + O(n),
+ add : O(m), when m is the length of saved word
+ search : O(n), when n is the length of searh word
+ sc : O(sum(m))
+
+ if volume of search query is much bigger than add query
+ trie solution would be better
+ O(n) search time vs O(mn) search time
+ */
+class WordDictionary {
+  class TrieNode {
+    TrieNode[] childs;
+    boolean isEnd;
+    TrieNode() {
+      childs = new TrieNode[26];
+      isEnd = false;
+    }
+  }
+  TrieNode root;
+  public WordDictionary() {
+    root = new TrieNode();
+  }
+
+  public void addWord(String word) {
+    TrieNode curNode = root;
+    for(char c : word.toCharArray()) {
+      if(curNode.childs[c-'a'] == null) {
+        curNode.childs[c-'a'] = new TrieNode();
+      }
+      curNode = curNode.childs[c-'a'];
+    }
+    curNode.isEnd = true;
+  }
+
+  public boolean search(String word) {
+    return dfsHelper(root, word, 0);
+  }
+
+  public boolean dfsHelper(TrieNode node, String word, int p) {
+    //end clause
+    if(p == word.length()) {
+      return node.isEnd;
+    }
+
+    char curC = word.charAt(p);
+    if(curC == '.') {
+      for(TrieNode next : node.childs) {
+        if(next != null) {
+          if(dfsHelper(next, word, p + 1)) return true;
+        }
+      }
+      return false;
+    } else {
+      if(node.childs[curC-'a'] != null) {
+        if(dfsHelper(node.childs[curC - 'a'], word, p + 1)) return true;
+      }
+      return false;
+    }
+
+
+  }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary obj = new WordDictionary();
+ * obj.addWord(word);
+ * boolean param_2 = obj.search(word);
+ */

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

@@ -0,0 +1,78 @@
+/*
+Time Complexity:
+- add: O(w)
+- search: O(26^2 * w) = O(w)
+Space Complexity: O(w)
+
+Trie를 활용하되, '.'의 탐색이 필요한 경우에는 for문을 사용한다.
+
+*/
+class WordDictionary {
+    class Node {
+        public char ch;
+        public boolean ends;
+        public Map<Character, Node> children;
+
+        Node() {
+            this.children = new HashMap<>();
+        }
+
+        Node(char ch) {
+            this.ch = ch;
+            this.children = new HashMap<>();
+        }
+    }
+
+    Node root;
+
+    public WordDictionary() {
+        this.root = new Node();
+    }
+
+    public void addWord(String word) {
+        Node curr = this.root;
+
+        for (int i = 0; i < word.length(); i++) {
+            char ch = word.charAt(i);
+            if (!curr.children.containsKey(ch)) {
+                curr.children.put(ch, new Node(ch));
+            }
+
+            curr = curr.children.get(ch);
+        }
+
+        curr.ends = true;
+    }
+
+    public boolean search(String word) {
+        return searchChar(word, 0, this.root);
+    }
+
+    private boolean searchChar(String word, int idx, Node curr) {
+        if (curr == null) {
+            return false;
+        } else if (idx == word.length()) {
+            return curr.ends;
+        }
+
+        char ch = word.charAt(idx);
+
+        if (ch == '.') {
+            for (Character key : curr.children.keySet()) {
+                if (searchChar(word, idx + 1, curr.children.get(key))) {
+                    return true;
+                }
+            }
+            return false;
+        } else {
+            return searchChar(word, idx + 1, curr.children.get(ch));
+        }
+    }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * WordDictionary obj = new WordDictionary();
+ * obj.addWord(word);
+ * boolean param_2 = obj.search(word);
+ */