[ICE0208] WEEK 06 Solutions

container-with-most-water/ICE0208.py

@@ -0,0 +1,18 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        left, right = 0, len(height) - 1
+
+        most_water_size = 0
+        while (left < right):
+            left_h, right_h = height[left], height[right]
+
+            current_size = (right-left) * min(left_h, right_h)
+            most_water_size = max(most_water_size, current_size)
+
+            if left_h < right_h:
+                left += 1
+            else:
+                right -= 1
+
+
+        return most_water_size

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

@@ -0,0 +1,47 @@
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.is_end = False
+
+
+class WordDictionary:
+
+    def __init__(self):
+        self.root = TrieNode()
+
+    def addWord(self, word: str) -> None:
+        current = self.root
+
+        for char in word:
+            if char not in current.children:
+                current.children[char] = TrieNode()
+
+            current = current.children[char]
+
+        current.is_end = True
+
+    def search(self, word: str) -> bool:
+        def dfs(index: int, node: TrieNode) -> bool:
+            # 패턴을 모두 확인했을 때 실제 단어의 끝인지 확인한다.
+            if index == len(word):
+                return node.is_end
+
+            char = word[index]
+
+            # '.'은 현재 노드의 모든 자식 문자와 대응될 수 있다.
+            if char == ".":
+                for child in node.children.values():
+                    if dfs(index + 1, child):
+                        return True
+
+                return False
+
+            # 일반 문자는 해당 자식 노드만 확인한다.
+            child = node.children.get(char)
+
+            if child is None:
+                return False
+
+            return dfs(index + 1, child)
+
+        return dfs(0, self.root)

longest-increasing-subsequence/ICE0208.py

@@ -0,0 +1,12 @@
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        # dp[i] : i를 마지막으로 했을 때 가장긴 증가 부분수열
+        dp = [0] * len(nums)
+
+        for i in range(0, len(nums)):
+            dp[i] = 1
+            for j in range(0, i):
+                if nums[j] < nums[i]:
+                    dp[i] = max(dp[i], dp[j] + 1)
+
+        return max(dp)

spiral-matrix/ICE0208.py

@@ -0,0 +1,45 @@
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        VISIT_NUM = 10000
+
+        total = sum(map(lambda k: len(k), matrix))
+        answer = []
+
+        def isVisit(i, j):
+            return matrix[i][j] == VISIT_NUM
+
+        def setVisit(i, j):
+            matrix[i][j] = VISIT_NUM
+
+        def inRange(i, j):
+            if not (0<=i<len(matrix)):
+                return False
+            if not (0<=j<len(matrix[0])):
+                return False
+            return True
+
+        i, j = 0, 0
+        answer.append(matrix[0][0])
+        setVisit(0, 0)
+        while len(answer) < total:
+            while inRange(i, j+1) and not isVisit(i, j+1):
+                answer.append(matrix[i][j+1])
+                setVisit(i, j+1)
+                j += 1
+
+            while inRange(i+1, j) and not isVisit(i+1, j):
+                answer.append(matrix[i+1][j])
+                setVisit(i+1, j)
+                i += 1
+
+            while inRange(i, j-1) and not isVisit(i, j-1):
+                answer.append(matrix[i][j-1])
+                setVisit(i, j-1)
+                j -= 1
+
+            while inRange(i-1, j) and not isVisit(i-1, j):
+                answer.append(matrix[i-1][j])
+                setVisit(i-1, j)
+                i -= 1
+
+        return answer

valid-parentheses/ICE0208.java

@@ -0,0 +1,37 @@
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public boolean isValid(String s) {
+        Deque<Character> stack = new ArrayDeque<>();
+        Map<Character, Character> mapping = new HashMap<>();
+        mapping.put(')', '(');
+        mapping.put('}', '{');
+        mapping.put(']', '[');
+
+        for (Character c : s.toCharArray()) {
+            // 열린 괄호일 때, 스택에 push
+            if (c=='(' || c=='{' || c == '[') {
+                stack.push(c);
+                continue;
+            }
+
+            // 닫힌 괄호일 때, 스택에서 pop한 뒤, 비교
+            // 스택이 비어있으면 탈락
+            if (stack.isEmpty()) {
+                return false;
+            }
+            Character popedC = stack.pop();
+            Character target = mapping.get(c);
+            // 같은 종류의 괄호가 아니면 탈락
+            if (!target.equals(popedC)) {
+                return false;
+            }
+        }
+
+        // 마지막에 스택이 비어있어야 성공
+        return stack.isEmpty();
+    }
+}