From 33aebaf3e1f077af39473bc0703d3ece99c42b5b Mon Sep 17 00:00:00 2001
From: river <bluuminn@gmail.com>
Date: Sun, 1 Mar 2026 23:40:51 +0900
Subject: [PATCH 1/3] contains-duplicate solution

---
 contains-duplicate/riveroverflows.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 contains-duplicate/riveroverflows.py

diff --git a/contains-duplicate/riveroverflows.py b/contains-duplicate/riveroverflows.py
new file mode 100644
index 0000000000..7d93da6339
--- /dev/null
+++ b/contains-duplicate/riveroverflows.py
@@ -0,0 +1,14 @@
+from typing import List
+
+
+class Solution:
+    """
+    TC: O(n)
+      - set(nums): n개 원소를 해시셋에 삽입, 각 삽입 평균 O(1) → O(n)
+      - len()은 내부 size 필드 반환이므로 O(1)
+
+    SC: O(n)
+      - set이 최대 n개 원소를 저장
+    """
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)

From 4701189d14903f0375f71c303c3e4182cc1cfefd Mon Sep 17 00:00:00 2001
From: river <bluuminn@gmail.com>
Date: Mon, 2 Mar 2026 21:02:43 +0900
Subject: [PATCH 2/3] two sum solution
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- contains duplicate 풀이 과정 추가
---
 contains-duplicate/riveroverflows.py | 14 ++++++++---
 two-sum/riveroverflows.py            | 35 ++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 two-sum/riveroverflows.py

diff --git a/contains-duplicate/riveroverflows.py b/contains-duplicate/riveroverflows.py
index 7d93da6339..e95cf495e3 100644
--- a/contains-duplicate/riveroverflows.py
+++ b/contains-duplicate/riveroverflows.py
@@ -3,12 +3,20 @@
 
 class Solution:
     """
+    풀이:
+    - nums를 set으로 변환하면 중복이 제거된다.
+    - set의 길이와 원본 리스트의 길이가 다르면 중복이 존재한다는 뜻.
+
     TC: O(n)
-      - set(nums): n개 원소를 해시셋에 삽입, 각 삽입 평균 O(1) → O(n)
-      - len()은 내부 size 필드 반환이므로 O(1)
+      - set(nums): 리스트의 모든 원소를 순회하면서 set에 삽입. O(n)
+        - set 삽입은 해시 기반이라 평균 O(1), n개 원소니까 O(n)
+      - len(set(nums)): set의 길이 조회. O(1)
+      - len(nums): 리스트의 길이 조회. O(1)
+      - 종합: O(n) + O(1) + O(1) = O(n)
 
     SC: O(n)
-      - set이 최대 n개 원소를 저장
+      - set(nums): 중복이 없는 경우 최대 n개의 원소를 저장. O(n)
+      - 그 외 변수 없음
     """
     def containsDuplicate(self, nums: List[int]) -> bool:
         return len(set(nums)) != len(nums)
diff --git a/two-sum/riveroverflows.py b/two-sum/riveroverflows.py
new file mode 100644
index 0000000000..a061993c9b
--- /dev/null
+++ b/two-sum/riveroverflows.py
@@ -0,0 +1,35 @@
+from typing import List
+
+
+class Solution:
+    """
+    풀이:
+    - 배열을 한 번 순회하면서, 각 숫자에 대해
+      "나와 더해서 target이 되는 짝(complement)"이
+      이미 등장했는지를 dict로 확인한다.
+    - dict에 {숫자: 인덱스}를 저장해두면, complement 조회가 O(1)이므로 전체 O(n).
+    - complement를 먼저 확인하고, 그 다음에 현재 숫자를
+      dict에 넣기 때문에 같은 값이 두 번 나오는 경우
+      (예: [3,3], target=6)에도 정상 동작한다.
+
+    TC: O(n)
+      - for 루프: nums의 모든 원소를 최대 한 번 순회. O(n)
+        - complement 계산 (target - num): O(1)
+        - dict에서 complement 존재 여부 확인 (in 연산): 해시 기반이라 평균 O(1)
+        - dict에 현재 숫자 삽입: 평균 O(1)
+      - 최악의 경우(답이 마지막 쌍): n번 반복. 최선의 경우(답이 첫 두 원소): 2번 반복
+
+    SC: O(n)
+      - nummap(dict): 최악의 경우 n-1개의 원소를 저장 (마지막 원소 직전까지 다 넣음). O(n)
+      - complement, i, num: 입력 크기와 무관한 상수. O(1)
+    """
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        nummap = dict()
+
+        for i, num in enumerate(nums):
+            complement = target - num
+
+            if complement in nummap:
+                return [nummap[complement], i]
+
+            nummap[num] = i

From 8b3836fdc1ed47a893b7e57136181158f94775ff Mon Sep 17 00:00:00 2001
From: river <bluuminn@gmail.com>
Date: Wed, 4 Mar 2026 23:58:18 +0900
Subject: [PATCH 3/3] top k frequent elements solution

---
 top-k-frequent-elements/riveroverflows.py | 44 +++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 top-k-frequent-elements/riveroverflows.py

diff --git a/top-k-frequent-elements/riveroverflows.py b/top-k-frequent-elements/riveroverflows.py
new file mode 100644
index 0000000000..94e26a639c
--- /dev/null
+++ b/top-k-frequent-elements/riveroverflows.py
@@ -0,0 +1,44 @@
+from typing import List
+
+
+class Solution:
+    """
+    풀이:
+    - 빈도수 세기 + Bucket Sort를 조합해서 정렬 없이 O(n)에 상위 k개를 뽑는다.
+    - 1단계: nums를 순회하며 각 숫자의 등장 횟수를 dict로 센다.
+    - 2단계: 빈도수를 인덱스로 하는 버킷 배열을 만든다.
+      빈도수는 최대 len(nums)이므로 배열 크기가 고정됨.
+    - 3단계: 버킷 배열을 뒤에서부터(높은 빈도수부터) 순회하며 k개를 수집한다.
+    - 정렬(O(n log n)) 대신 버킷의 인덱스 자체가 정렬 역할을 하므로 O(n).
+
+    TC: O(n)
+      - 빈도수 세기: nums를 한 번 순회. O(n).
+      - 버킷 배열 생성: 고유 원소 수만큼 순회. 최악 O(n).
+      - 상위 k개 수집: 버킷 배열을 뒤에서부터 순회. 최악 O(n).
+      - 종합: O(n).
+
+    SC: O(n)
+      - counts(dict): 최악 n개의 고유 원소. O(n).
+      - bucket(list of lists): 크기 n+1. O(n).
+      - answer(list): 최대 k개. O(k) ≤ O(n).
+      - 종합: O(n).
+    """
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        counts = dict()
+        for num in nums:
+            if num not in counts:
+                counts[num] = 0
+            counts[num] += 1
+
+        bucket = [[] for _ in range(len(nums) + 1)]
+        for num, cnt in counts.items():
+            bucket[cnt].append(num)
+
+        answer = []
+        for cnt_list in reversed(bucket):
+            if not cnt_list:
+                continue
+            for num in cnt_list:
+                answer.append(num)
+                if len(answer) == k:
+                    return answer