Merge pull request #1214 from seungriyou/main

[seungriyou] Week 02 Solutions

Author: seungriyou

3sum/seungriyou.py

@@ -0,0 +1,85 @@
+# https://leetcode.com/problems/3sum/
+
+from typing import List
+
+
+class Solution:
+    def threeSum_slower(self, nums: List[int]) -> List[List[int]]:
+        """
+        [Complexity]
+            - TC: O(n^2)
+            - SC: O(n)
+
+        [Approach]
+            two sum 문제에서 고정된 하나의 값만 추가해서 풀 수 있다.
+            정렬을 한 차례하면, duplicated triplet 처리가 가능하다.
+        """
+
+        n = len(nums)
+        nums.sort()
+
+        def two_sum(fixed_idx):
+            remains = {}
+            fixed_val = nums[fixed_idx]
+            res = set()
+
+            for i in range(fixed_idx + 1, n):
+                num = nums[i]
+                if num in remains:
+                    res.add((nums[fixed_idx], nums[remains[num]], nums[i]))
+                remains[-fixed_val - nums[i]] = i
+
+            return res
+
+        res = set()
+        for i in range(n - 2):
+            if ts := two_sum(i):
+                res |= set(ts)
+
+        return [list(r) for r in res]
+
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        """
+        [Complexity]
+            - TC: O(n^2)
+            - SC: O(1) (res 제외한 extra space)
+
+        [Approach]
+            정렬 후, 하나의 값을 고정해두고 two pointer를 사용하는 방식을 적용할 수 있다.
+            이때 매 turn에서 중복 원소를 고려해서 미리 이동하면 duplicated triplet을 방지할 수 있다.
+        """
+
+        n = len(nums)
+        res = []
+
+        # nums 오름차순 정렬
+        nums.sort()
+
+        for i in range(n - 2):  # -- 하나의 값 고정
+            # 고정한 값이 이전에 나왔던 값이면 빠르게 넘어가기
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            # 고정된 값보다 큰 값 범위에서, 양 끝에서부터 좁혀오며 확인
+            j, k = i + 1, n - 1
+            while j < k:
+                _sum = nums[i] + nums[j] + nums[k]
+
+                # (1) _sum이 0보다 크면 k를 왼쪽으로 한 칸 이동
+                if _sum > 0:
+                    k -= 1
+                # (2) _sum이 0보다 작으면 j를 오른쪽으로 한 칸 이동
+                elif _sum < 0:
+                    j += 1
+                # (3) _sum이 0이라면 res에 추가
+                else:
+                    triplet = [nums[i], nums[j], nums[k]]
+                    res.append(triplet)
+
+                    # 중복 원소 건너뛰기 (j는 오른쪽으로, k는 왼쪽으로)
+                    while j < k and nums[j] == triplet[1]:
+                        j += 1
+                    while j < k and nums[k] == triplet[2]:
+                        k -= 1
+
+        return res

climbing-stairs/seungriyou.py

@@ -0,0 +1,24 @@
+# https://leetcode.com/problems/climbing-stairs/
+
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        """
+        [Complexity]
+            - TC: O(n)
+            - SC: O(1)
+
+        [Approach]
+            dp[i] = i-th step을 오를 때, 가능한 distinct ways의 수
+                  = dp[i - 1] + dp[i - 2]
+            이때, dp[i - 1]과 dp[i - 2]만 필요하므로, O(1) space로 optimize 가능하다.
+                prev1 = dp[i - 1]
+                prev2 = dp[i - 2]
+            첫 번째 계단을 오르는 방법에는 1개가 있으므로, 초깃값은 다음과 같이 설정할 수 있다.
+                prev1 = 1
+                prev2 = 0
+        """
+
+        prev1, prev2 = 1, 0
+        for _ in range(n):
+            prev1, prev2 = prev1 + prev2, prev1
+        return prev1

product-of-array-except-self/seungriyou.py

@@ -0,0 +1,55 @@
+# https://leetcode.com/problems/product-of-array-except-self/
+
+from typing import List
+
+class Solution:
+    def productExceptSelf1(self, nums: List[int]) -> List[int]:
+        """
+        [Complexity]
+            - TC: O(n)
+            - SC: O(n)
+
+        [Approach]
+            division operation 없이 각 원소마다 자기 자신을 제외한 모든 값의 곱을 구해야하므로, 다음의 순서로 수행할 수 있다.
+                1) 왼쪽 방향으로 순회하면서 각 원소보다 왼쪽에 있는 값들의 곱으로 left 배열 채우기
+                2) 오른쪽 방향으로 순회하면서 각 원소보다 오른쪽에 있는 값들의 곱으로 right 배열 채우기
+                3) left와 right 배열의 원소마다 곱을 구해서 결과 배열 반환하기
+        """
+        n = len(nums)
+
+        left = [1] * n
+        for i in range(1, n):
+            left[i] = left[i - 1] * nums[i - 1]
+
+        right = [1] * n
+        for i in range(n - 2, -1, -1):
+            right[i] = right[i + 1] * nums[i + 1]
+
+        return [l * r for l, r in zip(left, right)]
+
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        """
+        [Complexity]
+            - TC: O(n)
+            - SC: O(n) (O(1) extra space)
+
+        [Approach]
+            follow up 조건을 위해서는 첫 번째 풀이처럼 left, right 배열을 두면 안 되고, res 배열에서 값을 업데이트 해나가야 한다.
+            이때, O(1) space를 위해서 변수 prev를 사용하여, 순회 진행 방향 기준 이전 값들의 곱을 트래킹해나가면 된다.
+                1) nums를 왼쪽 방향으로 순회하면서 res 및 prev 값 업데이트
+                2) nums를 오른쪽 방향으로 순회하면서 res 및 prev 값 업데이트
+        """
+        n = len(nums)
+        res = []
+
+        prev = 1
+        for i in range(n):
+            res.append(prev)
+            prev *= nums[i]
+
+        prev = 1
+        for i in range(n - 1, -1, -1):
+            res[i] *= prev
+            prev *= nums[i]
+
+        return res

valid-anagram/seungriyou.py

@@ -0,0 +1,41 @@
+# https://leetcode.com/problems/valid-anagram/
+
+class Solution:
+    def isAnagram1(self, s: str, t: str) -> bool:
+        """
+        [Complexity]
+            - TC: O(nlogn)
+            - SC: O(n)
+        """
+        return sorted(s) == sorted(t)
+
+    def isAnagram2(self, s: str, t: str) -> bool:
+        """
+        [Complexity]
+            - TC: O(n)
+            - SC: O(n)
+        """
+        from collections import Counter
+
+        return Counter(s) == Counter(t)
+
+    def isAnagram(self, s: str, t: str) -> bool:
+        """
+        [Complexity]
+            - TC: O(n)
+            - SC: O(n)
+        """
+        from collections import defaultdict
+
+        cnt = defaultdict(int)
+
+        for _s in s:
+            cnt[_s] += 1
+        for _t in t:
+            cnt[_t] -= 1
+
+        for k, v in cnt.items():
+            if v != 0:
+                return False
+
+        return True

validate-binary-search-tree/seungriyou.py

@@ -0,0 +1,72 @@
+# https://leetcode.com/problems/validate-binary-search-tree/
+
+from typing import Optional
+import math
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isValidBST1(self, root: Optional['TreeNode']) -> bool:
+        """
+        [Complexity]
+            - TC: O(n) (모든 node 한 번씩 방문)
+            - SC: O(h) (recursion call stack) (balanced tree라면 O(logn), skewed tree라면 O(n))
+
+        [Approach]
+            valid한 BST는 다음을 만족해야 하므로 recursion을 이용해서 풀 수 있다.
+                1) left subtree는 less than key
+                2) right subtree는 greater than key
+                3) left & right subtree도 BST
+            이때, 각 subtree를 recursive 하게 타고 들어가서 확인하려면, 각 단계에서 node, min floor val, max ceil val이 필요하고
+            각 단계(= is_valid_subtree())는 다음과 같이 분기를 나눠 진행할 수 있다.
+                1) node가 None일 때 (base condition): True 반환
+                2) 현재 노드의 값인 node.val이 min floor ~ max ceil 범위에 해당하지 않을 때: False 반환
+                3) 그 외: left subtree와 right subtree도 valid 한지 재귀적으로 확인
+        """
+
+        def is_valid_subtree(node, floor, ceil):
+            if not node:
+                return True
+
+            if not (floor < node.val < ceil):
+                return False
+
+            return is_valid_subtree(node.left, floor, node.val) and is_valid_subtree(node.right, node.val, ceil)
+
+        return is_valid_subtree(root, -math.inf, math.inf)
+
+    def isValidBST(self, root: Optional['TreeNode']) -> bool:
+        """
+        [Complexity]
+            - TC: O(n) (모든 node 한 번씩 방문)
+            - SC: O(n) (recursion call stack O(h) + path O(n))
+
+        [Approach]
+            inorder traversal 후, 원소가 모두 항상 strictly ascending sorted 되어 있는지 확인하면 된다.
+        """
+
+        path = []
+        is_asc = True
+
+        def inorder(node):
+            nonlocal is_asc
+
+            if not node:
+                return
+
+            inorder(node.left)
+
+            # path에 원소가 asc 정렬되지 않은 채로 들어간다면, is_asc = False로 변경
+            if path and path[-1] >= node.val:
+                is_asc = False
+            path.append(node.val)
+
+            inorder(node.right)
+
+        inorder(root)
+
+        return is_asc