Merge pull request #2527 from liza0525/main

[liza0525] WEEK 06 Solutions

Author: liza0525

container-with-most-water/liza0525.py

@@ -29,3 +29,36 @@ def maxArea(self, height: List[int]) -> int:
             )
 
         return result_area
+
+
+# 7기 풀이
+# 시간 복잡도: O(n)
+# - two point 알고리즘을 이용하기 때문에 heights 변수의 길이인 n에 시간복잡도가 정해짐
+# 공간 복잡도: O(1)
+# - 몇 개의 변수만 사용함
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        # 양 끝 포인터 지정
+        start, end = 0, len(height) - 1
+
+        # max_area는 현재 포인터들을 이용했을 때의 넓이 계산
+        # 이때 높이는 작은 쪽으로 선택하여 계산해야 함
+        max_area = min(height[start], height[end]) * (end - start)
+
+        # start가 end보다 작을 때 루프 돌기
+        while start < end:
+            # 문제의 핵심 아이디어는, 높이가 큰 쪽을 움직이면 얻을 수 있는 최선이 현재보다 클 수 없다.
+            # 이는, start의 높이와 end의 높이 중 큰 쪽의 포인터를 고정하여 움직여야 한다는 것
+            # (물의 높이는 작은 쪽에 의해 정해지는데, 큰 쪽 포인터를 움직이면 x 길이만 짧아지게 되어 오히려 넓이이 줄어듦)
+            if height[start] < height[end]:
+                # start 쪽의 높이가 낮으면 start를 움직임
+                start += 1
+            else:
+                # end 쪽의 높이가 낮으면 end를 움직임
+                end -= 1
+
+            # 포인터를 옮기고 난 후의 넓이를 계산하여, 기존의 max_area와 비교하여 큰 쪽으로 업데이트
+            curr_area = min(height[start], height[end]) * (end - start)
+            max_area = max(max_area, curr_area)
+        
+        return max_area

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

@@ -0,0 +1,80 @@
+# 7기 풀이
+
+# 클래스 공간 복잡도: O(W * L)
+#  - W는 word의 개수, L는 word의 평균 길이.
+
+# addWord 메서드
+# 시간 복잡도: O(L)
+# - L는 word의 길이. word의 길이만큼 탐색하며 insert함
+# 공간 복잡도: O(L)
+# - L는 word의 길이. 길이만큼 재귀 스택이 쌓임
+
+# search 메서드
+# 시간 복잡도: O(W * L)
+# - W는 이미 삽입된 단어의 개수, L는 word의 평균 길이.
+# - 최악인 조건은 word의 모든 문자들이 '.'일 때
+# 공간 복잡도: O(L)
+# - L는 word의 길이. 길이만큼 재귀 스택이 쌓임
+
+
+DELIMITER = "$"  # 끝맺음을 나타내는 DELIMITER로 "$"를 사용
+
+
+class WordDictionary:
+    def __init__(self):
+        self.word_dict = {}
+
+    def addWord(self, word: str) -> None:
+        # 재귀를 이용해 단어를 각 문자별로 insert
+        def _add_word(curr_dict, word):
+            if not word:
+                # 끝맺음을 나타내는 DELIMITER로 "$"를 사용
+                curr_dict[DELIMITER] = {}
+                return
+
+            s = word[0]  # word의 첫번째 문자
+            if s not in curr_dict:  # curr에 없는 경우에는 새로 key를 만든다.
+                curr_dict[s] = {}
+
+            # 다음 문자를 저장하기 위한 dictionary와
+            # 해당 depth에서 확인한 문자를 제외한 나머지 문자열을 가지고 다음 작업 수행
+            _add_word(curr_dict[s], word[1:])
+
+        _add_word(self.word_dict, word)
+
+
+    def search(self, word: str) -> bool:
+        # 재귀를 이용해 단어를 각 문자별로 뎁스를 타고 내려가 search
+        def _search(curr_dict, word): 
+            if not word:
+                # 더이상 검색할 문자열이 없을 땐
+                # DELIMITER의 존재 여부를 보고 return
+                return DELIMITER in curr_dict
+
+            s = word[0]
+            if s != '.' and s not in curr_dict:
+                # 와일드 카드 문자가 아니면서, 찾으려는 문자가 dictionary에 없으면
+                # insert가 된 적이 없는 단어이므로 False로 early return
+                return False
+            elif s == '.':
+                # 와일드 카드 문자이면 curr_dict에 있는 모든 문자열을 가지고 다음 depth를 확인한다.
+                for k in curr_dict.keys():
+                    is_valid = _search(curr_dict[k], word[1:])
+                    if is_valid:
+                        # 하나라도 True라면 search 결과가 유효하기 때문에 
+                        # True로 early return
+                        return True
+                # 모든 문자열을 탐색하고도 결과가 없다면 False return
+                return False
+            else:
+                # 그 외의 경우는 일반 문자열 탐색을 해야 하므로
+                # 자식 문자열이 있는 curr_dict[s]와
+            # 해당 depth에서 확인한 문자를 제외한 나머지 문자열을 가지고 다음 작업 수행
+                return _search(curr_dict[s], word[1:])
+
+        return _search(self.word_dict, word)
+
+# Your WordDictionary object will be instantiated and called as such:
+# obj = WordDictionary()
+# obj.addWord(word)
+# param_2 = obj.search(word)

longest-increasing-subsequence/liza0525.py

@@ -0,0 +1,25 @@
+# 7기 풀이
+# 시간 복잡도: O(n^2)
+# - 각 원소마다 이전 인덱스들을 모두 확인하므로 이중 for문을 돌아야 함
+# 공간 복잡도: O(n)
+# - dp 계산을 위한 리스트는 nums의 길이에 의존
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        # 각 인덱스에서의 최대 길이를 저장하는 dp 리스트
+        dp = [1 for _ in range(len(nums))]
+
+        for i in range(1, len(nums)):
+            # i 인덱스까지의 최대 길이를 계산 하기 위해
+            # 이전 인덱스들 중 가장 긴 길이를 찾아내어 저장하는 장식이다.
+            max_lis = 1
+            for j in range(0, i):
+                # j 인덱스의 의미는 i보다 이전 인덱스 탐방하기 위함
+                if nums[j] < nums[i]:  # 이전 인덱스(j 인덱스)에 있는 값이 i 인덱스의 값보다 작다면
+                    # 기존의 max_lis와 j 인덱스까지의 최대 길이 값 + 1(i 인덱스 포함한 길이)를 비교하여
+                    # 더 큰 수를 max_list에 업데이트 해준다.
+                    max_lis = max(max_lis, dp[j] + 1)
+            
+            # 계산된 max_lis를 dp[i]에 업데이트
+            dp[i] = max_lis
+
+        return max(dp)

spiral-matrix/liza0525.py

@@ -0,0 +1,81 @@
+# 7기 풀이
+# 풀이 1
+# 시간 복잡도: O(n * m)
+# - matrix의 가로, 세로 길이의 곱에 비례하여 시간복잡도가 계산됨(모든 칸을 다 돌기 때문)
+# 공간 복잡도: O(n * m)
+# - matrix를 방문할 때마다 visited를 업데이트 해주고 있어, n * m의 길이 만큼 늘어남
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        len_i = len(matrix)
+        len_j = len(matrix[0])
+        visited = set()  # 확인한 인덱스의 경우에는 tuple의 형태로 넣어주려고 함
+
+        dirs = ((0, 1), (1, 0), (0, -1), (-1, 0))  # 시계 방향을 나타내는 tuple(오른쪽, 아래쪽, 왼쪽, 위쪽 순서)
+
+        curr_dir_idx = 0  # 현재 방향을 나타내는 dirs의 index(0이면 오른쪽을 의미)
+        curr_i, curr_j = 0, 0  # 처음 시작점인 (0, 0) 인덱스를 지정 
+
+        result = []
+
+        while len(visited) < len_i * len_j:  # 모든 인덱스에 방문할 때까지 루프 돌기
+            result.append(matrix[curr_i][curr_j])  # result에 값을 먼저 넣어주고
+            visited.add((curr_i, curr_j))  # visited에 방문했다는 것을 표시
+
+            dir_i, dir_j = dirs[curr_dir_idx]  # 현재의 진행 방향 가져오기
+
+            if (
+                (curr_i + dir_i, curr_j + dir_j) in visited  # 다음 방문할 곳이 이미 방문했던 했거나
+                or not (0 <= curr_i + dir_i < len_i)  # i 인덱스 범위를 벗어나거나
+                or not (0 <= curr_j + dir_j < len_j)  # j 인덱스 범위를 벗어나면
+            ):
+                curr_dir_idx = (curr_dir_idx + 1) % 4  # 방향 index를 하나 올려서
+                dir_i, dir_j = dirs[curr_dir_idx]  # 방향을 바꿔준다.
+
+            # curr_i, curr_j를 업데이트 하여 다음 루프에서 탐방하게 한다.
+            curr_i, curr_j = curr_i + dir_i, curr_j + dir_j
+
+        return result
+
+
+# 풀이 2
+# 시간 복잡도: O(n * m)
+# - matrix의 가로, 세로 길이의 곱에 비례하여 시간복잡도가 계산됨(모든 칸을 다 돌기 때문)
+# 공간 복잡도: O(1)
+# - 변수 몇 개만 사용했음(풀이 1과의 가장 큰 차이)
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        # 각각에 대한 경계를 지정하여 계산하는 방법이다.
+        # 위, 아래, 왼쪽, 오른쪽에 대한 최초 경계 설정
+        top, bottom, left, right = 0, len(matrix) - 1, 0, len(matrix[0]) - 1
+
+        # 처음 방향 설정(오른쪽으로 가기)
+        dir_i, dir_j = 0, 1
+
+        # 처음 방문 인덱스 설정
+        curr_i, curr_j = 0, 0
+
+        result = []
+
+        # top은 bottom보다 커지면 안되고
+        # left는 right보다 커지면 안된다.
+        # 이에 따라 top <= bottom and left <= right 조건으로 루프 돌기
+        while top <= bottom and left <= right:
+            result.append(matrix[curr_i][curr_j])  # 해당 인덱스에 있는 값을 result에 넣기
+
+            if curr_i + dir_i < top:  # 1. 다음 인덱스가 top 경계를 넘어가려고 할 때
+                dir_i, dir_j = 0, 1  # 방향을 오른쪽으로 변경해주고
+                left += 1  # 지나온 인덱스들이 새로운 왼쪽 경계가 되므로, left을 하나 올려준다.
+            elif curr_i + dir_i > bottom:  # 2. 다음 인덱스가 bottom의 경계를 넘어가려고 할 때
+                dir_i, dir_j = 0, -1  # 방향을 왼쪽으로 변경해주고
+                right -= 1  # 지나온 인덱스들이 새로운 오른쪽 경계가 되므로, right를 하나 내려준다.
+            elif curr_j + dir_j < left:  # 3. 다음 인덱스가 left 경계를 넘어가려고 할 때
+                dir_i, dir_j = -1, 0  # 방향을 위쪽으로 변경해주고
+                bottom -= 1  # 지나온 인덱스들이 새로운 아랫쪽 경계가 되므로, bottom을 하나 내려준다.
+            elif curr_j + dir_j > right:  # 4. 다음 인덱스가 right 경계를 넘어가려고 할 떄
+                dir_i, dir_j = 1, 0  # 방향을 아랫쪽으로 변경해주고
+                top += 1  # 지나온 인덱스들이 새로운 윗쪽 경계가 되므로, top을 하나 올려준다.
+
+            # curr_i, curr_j를 업데이트 하여 다음 루프에서 탐방하게 한다.
+            curr_i, curr_j = curr_i + dir_i, curr_j + dir_j
+
+        return result

valid-parentheses/liza0525.py

@@ -61,3 +61,37 @@ def isValid(self, s: str) -> bool:
         if stack:
             return False
         return True
+
+
+
+# 7기 풀이
+# 시간 복잡도: O(n)
+# - s의 길이 n에 시간복잡도가 정해짐
+# 공간 복잡도: O(n)
+# - 왼쪽 괄호를 저장할 stacks(list) 변수의 길이는 s의 길이에 의해 정해짐
+# - stack의 최대 길이는 s가 모두 왼쪽 괄호로 되어 있을 때
+class Solution:
+    def isValid(self, s: str) -> bool:
+        # 오른쪽 괄호가 들어올 때의 쌍을 쉽게 찾기 위해 만든 dictionary
+        brackets = {")": "(", "}": "{", "]": "["}
+
+        # 왼쪽 괄호를 저장할 list
+        stacks = []
+
+        for ss in s:
+            if stacks and ss in brackets.keys():
+                # stacks에 괄호가 저장되어 있으면서, ss로 오른쪽 괄호가 들어오면
+                # 쌍을 비교
+                if stacks[-1] != brackets[ss]:
+                    # stacks의 마지막 문자(가장 늦게 들어온 왼쪽 괄호)와 현재 들어온 오른쪽 괄호의 쌍이 같지 않으면
+                    # 괄호의 쌍이 맞지 않으므로 False를 early return
+                    return False
+                else:
+                    # 쌍이 맞는다면 stacks에 있는 마지막 왼쪽 괄호는 더이상 비교할 필요가 없으므로 pop
+                    stacks.pop()
+            else:
+                # ss가 왼쪽 괄호인 경우엔 stacks에 쌓아준다
+                stacks.append(ss)
+
+        # 모든 쌍비교를 하고 stacks에 괄호가 남아있는 지 여부를 return
+        return not stacks