[hu6r1s] WEEK 06 Solutions

container-with-most-water/hu6r1s.py

@@ -0,0 +1,20 @@
+
+class Solution:
+    """
+    1. 브루트포스와 같이 전부 길이를 대조해보고 하면 시간복잡도가 터질 것.
+    투포인터 방식을 활용하면 됨. 투포인터에 대한 문제가 코딩테스트로 많이 나올 것 같음.
+    확실하게 공부 필요.
+    """
+    def maxArea(self, height: List[int]) -> int:
+        max_area = 0
+        start, end = 0, len(height) - 1
+        while start < end:
+            area = (end - start) * min(height[start], height[end])
+            max_area = max(area, max_area)
+
+            if height[start] <= height[end]:
+                start += 1
+            else:
+                end -= 1
+
+        return max_area

design-add-and-search-words-data-structure/hu6r1s,py

@@ -0,0 +1,35 @@
+class WordDictionary:
+    """
+    알고달레의 영상을 보고 했는데 아직 이해가 잘 되지 않음.
+    추가적인 학습 필요
+    """
+    def __init__(self):
+        self.root = {"$": True}
+
+    def addWord(self, word: str) -> None:
+        node = self.root
+        for ch in word:
+            if ch not in node:
+                node[ch] = {"$": False}
+            node = node[ch]
+        node["$"] = True
+
+    def search(self, word: str) -> bool:
+        def dfs(node, idx):
+            if idx == len(word):
+                return node["$"]
+            ch = word[idx]
+            if ch in node:
+                return dfs(node[ch], idx + 1)
+            if ch == ".":
+                if any(dfs(node[k], idx + 1) for k in node if k != "$"):
+                    return True
+            return False
+
+        return dfs(self.root, 0)
+
+
+# Your WordDictionary object will be instantiated and called as such:
+# obj = WordDictionary()
+# obj.addWord(word)
+# param_2 = obj.search(word)

longest-increasing-subsequence/hu6r1s.py

@@ -0,0 +1,40 @@
+from bisect import bisect_left
+
+class Solution:
+    """
+    뭔가 bfs 풀이 방식
+    메모리 초과
+    """
+    # def lengthOfLIS(self, nums: List[int]) -> int:
+    #     n = len(nums)
+    #     q = deque()
+    #     q.append((-1, float('-inf'), 0))  # (idx, lastValue, length)
+    #     answer = 0
+
+    #     while q:
+    #         idx, last, length = q.popleft()
+    #         answer = max(answer, length)
+
+    #         for nxt in range(idx + 1, n):
+    #             if nums[nxt] > last:
+    #                 q.append((nxt, nums[nxt], length + 1))
+
+    #     return answer
+
+    # def lengthOfLIS(self, nums: List[int]) -> int:
+    #     dp = [1] * len(nums)
+    #     for cur in range(1, len(nums)):
+    #         for pre in range(cur):
+    #             if nums[pre] < nums[cur]:
+    #                 dp[cur] = max(1 + dp[pre], dp[cur])
+    #     return max(dp)
+
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        sub = []
+        for num in nums:
+            index = bisect_left(sub, num)
+            if index == len(sub):
+                sub.append(num)
+            else:
+                sub[index] = num
+        return len(sub)

valid-parentheses/hu6r1s.py

@@ -0,0 +1,23 @@
+class Solution:
+    """
+    1. 스택을 활용한 분기 처리
+    여는 괄호일 때는 스택에 무조건 넣어준다.
+    닫는 괄호일 때는 대, 중, 소 괄호에 맞춰서 분기를 해줘야 한다.
+    스택이 있고, 스택의 마지막이 해당 괄호의 여는 괄호이면 빼내준다.
+    이외는 닫힌 괄호가 먼저 나오는 것이기 때문에 False를 반환해준다.
+    전형적인 스택 문제로 O(n)의 시간복잡도를 가진다.
+    """
+    def isValid(self, s: str) -> bool:
+        stack = []
+        for word in s:
+            if word == "(" or word == "{" or word == "[":
+                stack.append(word)
+            elif stack and word == ")" and stack[-1] == "(":
+                stack.pop()
+            elif stack and word == "]" and stack[-1] == "[":
+                stack.pop()
+            elif stack and word == "}" and stack[-1] == "{":
+                stack.pop()
+            else:
+                return False
+        return True if not stack else False