[Chanz] WEEK 04 Solutions

combination-sum/Chanz82.py

@@ -0,0 +1,22 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+
+        result = []
+        combination = []
+        def find_target(start, combination, target):
+
+            if target == 0 : # 조합 생성 완료.
+                result.append(combination.copy()) # pop 때문에 복사해서 append해야 함.
+                return
+
+            elif target < 0 or start >= len(candidates):
+                return
+
+            combination.append(candidates[start])
+            find_target(start, combination, target-candidates[start]) # 현재 원소를 더 뽑는 경우
+            combination.pop() # 현재 원소는 다시 조합에서 제거 후, 다음 원소를 뽑음
+            find_target(start+1, combination, target) # 다음 원소를 뽑는 경우
+
+        find_target(0, combination, target)
+
+        return result

find-minimum-in-rotated-sorted-array/Chanz82.py

@@ -0,0 +1,15 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+
+        left = 0
+        right = len(nums) - 1
+
+        while left < right:
+            mid = (left + right) // 2
+
+            if nums[right] < nums[mid]: # right 와 mid 사이에 최소 값이 존재
+                left = mid + 1
+            else:
+                right = mid
+
+        return nums[left]

maximum-depth-of-binary-tree/Chanz82.py

@@ -0,0 +1,25 @@
+# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
+
+        max_depth = 0
+        def dfs(cur_node, cur_depth):
+            nonlocal max_depth
+            if cur_node == None:
+                return 
+            cur_depth += 1
+            max_depth = max(max_depth, cur_depth)
+
+            dfs(cur_node.left, cur_depth)
+            dfs(cur_node.right, cur_depth)
+            return
+
+        dfs(root, 0)
+        return max_depth
+

merge-two-sorted-lists/Chanz82.py

@@ -0,0 +1,33 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+
+        if not list1:
+            return list2
+        if not list2: 
+            return list1
+
+        cursor = ListNode()
+        result = cursor
+        cursor.next = list1
+
+        while cursor.next:
+            while list2 and list2.val <= cursor.next.val:
+                temp_1 = cursor.next
+                temp_2 = list2.next
+
+                cursor.next = list2
+                list2.next = temp_1
+                list2 = temp_2
+
+            cursor = cursor.next
+
+        if list2:
+            cursor.next = list2
+
+        return result.next
+

number-of-1-bits/Chanz82.py

@@ -0,0 +1,13 @@
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+
+        # 공간복잡도 : 변수 2개 및 상수만 사용하므로, O(1)
+        # 시간복잡도 : bit counting한 이후에 n을 1/2하므로 O(logn)
+        bit_count = 0
+        while n > 0:
+            if n % 2 == 1:
+                bit_count += 1
+            n //= 2
+
+        return bit_count
+

valid-palindrome/Chanz82.py

@@ -0,0 +1,19 @@
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+
+        # 공간 복잡도 : 문자열의 길이만큼만 공간을 사용합니다. 따라서 O(n)
+        # 시간 복잡도 : 문자열의 길이 만큼 순회를 1번 하고, 이후에 한번 더 순회를 하나 길이의 1/2 까지만 순회를 합니다. O(n)
+        alpha_num_str = ""
+        for ch in s:
+            if ch.isalnum():
+                alpha_num_str += ch.lower()
+
+        end_idx = len(alpha_num_str) - 1
+        for idx, ch in enumerate(alpha_num_str):
+            if idx >= end_idx:
+                return True
+            if ch != alpha_num_str[end_idx]:
+                return False
+            end_idx -= 1
+        return True
+

word-search/Chanz82.py

@@ -0,0 +1,32 @@
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+
+        def dfs(current, word_idx):
+            x, y = current
+
+            if word_idx == len(word):
+                return True
+
+            if x < 0 or x >= len(board) or y < 0 or y >= len(board[0]): 
+                return False
+
+            if board[x][y] != word[word_idx] :
+                return False
+
+            tmp = board[x][y]
+            board[x][y] = '#'
+
+            found = (dfs((x-1, y), word_idx+1) or
+                     dfs((x+1, y), word_idx+1) or
+                     dfs((x, y-1), word_idx+1) or
+                     dfs((x, y+1), word_idx+1))
+
+            board[x][y] = tmp
+
+            return found
+
+        for x, rows in enumerate(board):
+            for y, cell in enumerate(rows):
+                if dfs((x, y), 0) == True : 
+                    return True
+        return False