[윤태권] Week6 문제 풀이

container-with-most-water/taekwon-dev.java

@@ -0,0 +1,28 @@
+/**
+ *  시간 복잡도: O(n)
+ *  공간 복잡도: O(1)
+ *
+ *  최대로 많은 물을 저장하기 위해 가장 우선적으로 고려해야 하는 것은 짧은 막대의 길이
+ *  따라서, 짧은 높이를 가지는 쪽의 포인터를 이동하면서 최대 저장 가능한 값을 비교
+ *
+ */
+class Solution {
+    public int maxArea(int[] height) {
+        int answer = 0;
+        int left = 0;
+        int right = height.length - 1;
+
+        while (left < right) {
+            int water = Math.min(height[left], height[right]) * (right - left);
+            answer = Math.max(answer, water);
+
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return answer;
+    }
+}

design-add-and-search-words-data-structure/taekwon-dev.java

@@ -0,0 +1,58 @@
+class WordDictionary {
+
+    private class TrieNode {
+        Map<Character, TrieNode> children = new HashMap<>();
+        boolean isEndOfWord = false;
+    }
+
+    private TrieNode root;
+
+    public WordDictionary() {
+        root = new TrieNode();
+    }
+
+    /**
+     *  시간 복잡도: O(n), n = 단어의 길이
+     *  공간 복잡도: O(n)
+     */
+    public void addWord(String word) {
+        TrieNode node = root;
+
+        for (int i = 0; i < word.length(); i++) {
+            char c = word.charAt(i);
+            node.children.putIfAbsent(c, new TrieNode());
+            node = node.children.get(c);
+        }
+        node.isEndOfWord = true;
+    }
+
+    /**
+     *  시간 복잡도: O(26^n), n = 단어의 길이
+     *  공간 복잡도: O(n)
+     */
+    public boolean search(String word) {
+        return searchInNode(word, 0, root);
+    }
+
+    private boolean searchInNode(String word, int index, TrieNode node) {
+        if (index == word.length()) {
+            return node.isEndOfWord;
+        }
+
+        char c = word.charAt(index);
+        if (c != '.') {
+            if (node.children.containsKey(c)) {
+                return searchInNode(word, index + 1, node.children.get(c));
+            } else {
+                return false;
+            }
+        } else {
+            for (TrieNode childNode : node.children.values()) {
+                if (searchInNode(word, index + 1, childNode)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}

valid-parentheses/taekwon-dev.java

@@ -0,0 +1,30 @@
+/**
+ *  시간 복잡도: O(n)
+ *  공간 복잡도: O(n)
+ */
+class Solution {
+    public boolean isValid(String s) {
+        Map<Character, Character> map = new HashMap<>(){{
+            put(')', '(');
+            put('}', '{');
+            put(']', '[');
+        }};
+
+        Deque<Character> stack = new ArrayDeque<>();
+
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (!map.containsKey(c)) {
+                stack.push(c);
+                continue;
+            }
+
+            if (stack.isEmpty() || stack.removeFirst() != map.get(c)) {
+                return false;
+            }
+        }
+
+        return stack.size() == 0;
+    }
+}