[Chaewon-Park-STUDY] WEEK 01 Solutions

contains-duplicate/Chaewon-Park-STUDY.py

@@ -0,0 +1,13 @@
+class Solution:
+    def containsDuplicate(self, nums: list[int]) -> bool:
+        store = set()
+        # count를 쓰면 매번 전체 배열을 훑어 O(n^2) → Time out
+        # 대신 해시 기반 set을 쓰면 in 확인이 평균 O(1)이라 전체 O(n)
+        # Time: O(n), Space: O(n)
+        for elem in nums:
+            if elem in store:
+                return True
+            else:
+                store.add(elem)
+        return False
+

house-robber/Chaewon-Park-STUDY.py

@@ -0,0 +1,13 @@
+class Solution:
+    def rob(self, nums: list[int]) -> int:
+        #시간, 공간 복잡도: O(n)
+        if len(nums)==1:
+            return nums[0]
+        elif len(nums)==2:
+            return max(nums)
+        dp=nums.copy() # dp[i] = i번째 집의 money를 훔칠 때의 최대 누적 금액
+        for i in range(2,len(nums)):
+            house3 = dp[i-3] if i >= 3 else 0 #i=2일 경우에는 i-3이 존재하지 않기에 따로 처리
+            dp[i] += max(dp[i-2], house3) #인접한 집은 방문 불가
+        return max(dp)
+

longest-consecutive-sequence/Chaewon-Park-STUDY.py

@@ -0,0 +1,15 @@
+class Solution:
+    def longestConsecutive(self, nums: list[int]) -> int:
+        if not nums:
+            return 0
+        nums = sorted(set(nums))  # 처음에는 nums.sort()로 풀었지만
+        # elif문에 중복 처리 부분을 넣어야해서 set으로 중복 허용 x
+        k=len(nums)
+
+        # Space: O(n), Time: O(n log n) - 정렬 O(n log n) + DP  O(n)
+        dp=[1 for _ in range(k)] # dp[i] = nums[i]로 끝나는 연속 수열의 길이
+        for i in range(1,k):
+            if nums[i]-nums[i-1]==1:
+                dp[i]=dp[i-1]+1
+        return max(dp)
+

top-k-frequent-elements/Chaewon-Park-STUDY.py

@@ -0,0 +1,22 @@
+from collections import defaultdict #defaultdict 사용 위함
+
+class Solution:
+    def topKFrequent(self, nums: list[int], k: int) -> list[int]:
+        # 전체 시간 복잡도: O(n log n), 공간 복잡도: O(n)
+        output=[]
+        frequent=defaultdict(int) # 없는 key에 접근할시  0 생성 (리뷰 반영! )
+
+        # count로 하면 전체를 다 훑기 때문에 O(n^2)
+        # dic 사용하여 공간 복잡도: O(n)
+        for elem in nums:
+            frequent[elem] +=1 # get 대신 
+        #정렬 시 시간복잡도 최대 O(nlogn)
+        result = dict(sorted(frequent.items(), key=lambda x: x[1], reverse=True)) #내림차순 정렬
+
+        #빈도가 높은 원소 k개 추출: O(k)
+        for key in result:
+            output.append(key)
+            if len(output)==k:
+                return output
+        return output
+

two-sum/Chaewon-Park-STUDY.py

@@ -0,0 +1,32 @@
+class Solution:
+    #시간, 공간 복잡도:O(n)
+    def twoSum(self, nums: list[int], target: int) -> list[int]:
+        num_index={} #elem를 key로 바로 저장하여 시간복잡도 O(1) # 리뷰 후 수정!!: 기존에 arr로 선언하였는데 딕셔너리를 arr로 두면 변수명에 혼란이 있을 수 있기에 수정
+        for i, elem in enumerate(nums): 
+            if target -elem in num_index: #왜 num_index에서 찾는지 nums에서 찾으면 리스트라서 역시 복잡도 올라감
+            # 두 수의 합이므로 나머지 짝이 num_index에 있는지 확인
+                return [num_index[target - elem], i]
+            num_index[elem] = i #없으면 저장
+
+
+
+
+# 처음 시도 풀이 DFS(기각, runtime: 7013ms)
+# 시간 복잡도: O(n^2), 공간 복잡도: O(1)
+
+# class Solution:
+#     def twoSum(self, nums: list[int], target: int) -> list[int]:
+#         arr = []
+
+#         def dfs(start):
+#             if len(arr) == 2:
+#                 return nums[arr[0]] + nums[arr[1]] == target  #정답 발견시 True반환
+#             for i in range(start, len(nums)):
+#                 arr.append(i)
+#                 if dfs(i + 1):  # 정답이면 True를 위로 전달해 탐색 종료
+#                     return True
+#                 arr.pop()
+#             return False
+
+#         dfs(0)
+#         return arr