Merge pull request #2179 from devyulbae/main

[devyulbae] Week 04~05 solutions

Author: devyulbae

best-time-to-buy-and-sell-stock/devyulbae.py

@@ -0,0 +1,32 @@
+"""
+Blind 75 - Best Time to Buy and Sell Stock
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+시간복잡도 : O(n)
+공간복잡도 : O(1)
+풀이 : 한 번의 순회로 해결
+
+prices = [7,1,5,3,6,4]
+
+price | min | max_profit
+    7   |  7  |    0
+    1   |  1  |    0
+    5   |  1  |    4
+    3   |  1  |    4
+    6   |  1  |    5
+    4   |  1  |    5
+
+"""
+from typing import List
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = prices[0]
+
+        for price in prices:
+            min_price = min(min_price, price)
+            max_profit = max(max_profit, price - min_price)
+        
+        return max_profit
+    

coin-change/devyulbae.py

@@ -0,0 +1,19 @@
+"""
+Blind 75 - Coin Change
+LeetCode Problem Link: https://leetcode.com/problems/coin-change/
+시간복잡도 : O(n*m) (n: amount, m: len(coins))
+공간복잡도 : O(n)
+
+"""
+from typing import List
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        dp = [float('inf')] * (amount + 1)
+        dp[0] = 0
+
+        for coin in coins: # 각 동전마다
+            for x in range(coin, amount + 1): # 금액 1 coin부터 amount까지
+                dp[x] = min(dp[x], dp[x - coin] + 1) # 해당 금액을 만들기 위한 최소 동전 개수 갱신
+
+        return dp[amount] if dp[amount] != float('inf') else -1 # amount를 만들 수 없는 경우 -1 반환
+    

decode-ways/devyulbae.py

@@ -1,3 +1,39 @@
+"""
+Blind75 - Decode Ways
+https://leetcode.com/problems/decode-ways/
+시간복잡도: O(n)
+공간복잡도: O(n)
+풀이 : 메모이제이션 + DFS를 활용한 재귀 풀이
+
+아..DP로는 못 풀겠어서 풀이 봤습니다. 강의나 책을 봐야겠군요
 class Solution:
     def numDecodings(self, s: str) -> int:
-        
+        dp = [0] * len(s) + [1]
+        for start in reversed(range(len(s))):
+            if s[start] == "0":
+                dp[start] = 0
+            elif start + 1 < len(s) and int(s[start : start + 2]) < 27:
+                dp[start] = dp[start + 1] + dp[start + 2]
+            else:
+                dp[start] = dp[start + 1]
+        return dp[0]
+"""
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        memo = {len(s): 1}
+
+        def dfs(start):
+            if start in memo:
+                return memo[start]
+
+            if s[start] == "0":
+                memo[start] = 0
+            elif start + 1 < len(s) and int(s[start : start + 2]) < 27:
+                memo[start] = dfs(start + 1) + dfs(start + 2)
+            else:
+                memo[start] = dfs(start + 1)
+            return memo[start]
+
+        return dfs(0)
+
+

encode-and-decode-strings/devyulbae.py

@@ -0,0 +1,24 @@
+"""
+Blind 75 - Find Minimum in Rotated Sorted Array
+LeetCode Problem Link: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
+시간복잡도 : O(log n)
+공간복잡도 : O(1)
+풀이 : 이진 탐색
+중간점 기준으로 nums[mid-1] > nums[mid] 이면 mid가 최소값
+그렇지 않으면 왼쪽 절반이 정렬되어 있는지 확인해서 왼쪽 절반 or 오른쪽 절반으로 탐색 범위를 좁혀나감
+만약 발견되지 않았다면 nums[0]이 최소값
+"""
+from typing import List
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        left, right = 1, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            if nums[mid -1] > nums[mid]:
+                return nums[mid]
+            if nums[0] < nums[mid]:
+                left = mid + 1
+            else:
+                right = mid - 1
+        return nums[0]
+

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

@@ -0,0 +1,24 @@
+"""
+Blind 75 - Group Anagrams
+LeetCode Problem: https://leetcode.com/problems/group-anagrams/
+시간복잡도 : O(N * K) (N은 strs의 길이, K는 strs 내 문자열의 최대 길이)
+공간복잡도 : O(N * K)
+풀이 : 해시맵을 이용한 풀이
+ASCII 문자를 이용하여 각 문자열의 문자 개수를 세어 이를 키로 사용하여 해시맵에 저장한다
+
+"""
+
+from typing import List
+from collections import defaultdict
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        anagrams = defaultdict(list)
+
+        for s in strs:
+            count = [0] * 26
+            for char in s:
+                count[ord(char) - ord('a')] += 1
+            anagrams[tuple(count)].append(s)
+
+        return list(anagrams.values())
+    

group-anagrams/devyulbae.py

@@ -0,0 +1,24 @@
+"""
+Blind 75 - Maximum Depth of Binary Tree
+LeetCode Problem Link: https://leetcode.com/problems/maximum-depth-of-binary-tree/
+시간복잡도 : O(n)
+공간복잡도 : O(n)
+풀이 : 재귀를 이용한 깊이 우선 탐색(DFS)
+자식 노드부터 부모 노드로 거슬러 올라가며 최대 깊이를 계산합니다.
+종료 조건 - left와 right가 모두 None인 경우 (1+max(0,0))을 반환하며 재귀가 종료됩니다.
+"""
+
+from typing import Optional
+# 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:
+        if not root:
+            return 0
+        
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
+    

implement-trie-prefix-tree/devyulbae.py

@@ -0,0 +1,35 @@
+"""
+Blind 75 - Merge Two Sorted Lists
+LeetCode Problem Link: https://leetcode.com/problems/merge-two-sorted-lists/
+시간복잡도 : O(n+m)
+공간복잡도 : O(1)
+풀이 : (알고달레 답안)
+각 링크드 리스트에 포인터를 두고, 더 작은 값을 가진 노드를 결과 리스트에 추가하다가 한 쪽 리스트가 끝나면 나머지 리스트를 결과 리스트에 추가한다.
+마지막에 첫번째 노드를 반환한다.
+"""
+from typing import Optional
+
+# 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]:
+        dummy = ListNode()
+        tail = dummy
+
+        while list1 and list2:
+            if list1.val < list2.val:
+                tail.next = list1
+                list1 = list1.next
+            else:
+                tail.next = list2
+                list2 = list2.next
+
+            tail = tail.next
+            
+        tail.next = list1 or list2
+        return dummy.next
+    

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

@@ -0,0 +1,23 @@
+"""
+Blind 75 - Word Break
+LeetCode Problem: https://leetcode.com/problems/word-break/
+시간복잡도 : O(n^2)
+공간복잡도 : O(n)
+풀이 : 다이나믹 프로그래밍을 이용한 풀이
+문자열 s의 길이를 n이라 할 때, dp[i]를 s의 처음부터 i-1번째 문자까지의 부분 문자열이 
+단어 사전에 있는 단어들로 구성될 수 있는지를 나타내는 불리언 값이라고 정의한다.
+"""
+from typing import List
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        dp = [False] * (len(s) + 1)
+        dp[0] = True
+
+        word_set = set(wordDict)
+        for i in range(1, len(s) + 1):
+            for j in range(i):
+                if dp[j] and s[j:i] in word_set: # 0~j-1까지 문자열이 단어사전에 있고, j~i-1까지 문자열이 단어사전에 있는 경우
+                    dp[i] = True
+                    break
+
+        return dp[len(s)]