From 8a33c869ff8aeee088fc118ecc0e0fac43af59cb Mon Sep 17 00:00:00 2001
From: hu6r1s <darmaa333@gmail.com>
Date: Wed, 22 Oct 2025 14:39:46 +0900
Subject: [PATCH 1/5] feat: Solve counting-bits problem

---
 counting-bits/hu6r1s.py | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 counting-bits/hu6r1s.py

diff --git a/counting-bits/hu6r1s.py b/counting-bits/hu6r1s.py
new file mode 100644
index 000000000..3961d77d9
--- /dev/null
+++ b/counting-bits/hu6r1s.py
@@ -0,0 +1,6 @@
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        ans = []
+        for i in range(n+1):
+            ans.append(bin(i)[2:].count("1"))
+        return ans

From 8fefbebdd55cecb21457c4075573885b63a2b745 Mon Sep 17 00:00:00 2001
From: hu6r1s <darmaa333@gmail.com>
Date: Thu, 23 Oct 2025 11:19:13 +0900
Subject: [PATCH 2/5] feat: Solve binary-tree-level-order-traversal problem

---
 binary-tree-level-order-traversal/hu6r1s.py | 27 ++++++++++++++++
 graph-valid-tree/hu6r1s.py                  | 18 +++++++++++
 number-of-islands/hu6r1s.py                 | 36 +++++++++++++++++++++
 3 files changed, 81 insertions(+)
 create mode 100644 binary-tree-level-order-traversal/hu6r1s.py
 create mode 100644 graph-valid-tree/hu6r1s.py
 create mode 100644 number-of-islands/hu6r1s.py

diff --git a/binary-tree-level-order-traversal/hu6r1s.py b/binary-tree-level-order-traversal/hu6r1s.py
new file mode 100644
index 000000000..13997ca6e
--- /dev/null
+++ b/binary-tree-level-order-traversal/hu6r1s.py
@@ -0,0 +1,27 @@
+# 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
+from collections import deque
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root:
+            return []
+
+        queue = deque([root])
+        result = []
+        while queue:
+            tmp = []
+            for _ in range(len(queue)):
+                node = queue.popleft()
+                tmp.append(node.val)
+
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+            result.append(tmp)
+        return result
diff --git a/graph-valid-tree/hu6r1s.py b/graph-valid-tree/hu6r1s.py
new file mode 100644
index 000000000..76f4e5f12
--- /dev/null
+++ b/graph-valid-tree/hu6r1s.py
@@ -0,0 +1,18 @@
+if len(edges) != n - 1:
+            return False
+
+        graph = [[] for _ in range(n)]
+        for node, adj in edges:
+            graph[node].append(adj)
+            graph[adj].append(node)
+
+        visited = set()
+
+        def dfs(node):
+            visited.add(node)
+            for adj in graph[node]:
+                if adj not in visited:
+                    dfs(adj)
+
+        dfs(0)
+        return len(visited) == n
diff --git a/number-of-islands/hu6r1s.py b/number-of-islands/hu6r1s.py
new file mode 100644
index 000000000..d472e6f84
--- /dev/null
+++ b/number-of-islands/hu6r1s.py
@@ -0,0 +1,36 @@
+from collections import deque
+
+class Solution:
+    """
+    문제를 보니 바로 그래프 탐색이 떠올라서 bfs 알고리즘을 사용해서 구현
+    백준 문제에서 많이 풀어보던건데 너무 오래 되어 계속 헷갈렸음
+    다시 공부해야함
+    """
+    def numIslands(self, grid: List[List[str]]) -> int:        
+        def bfs(grid, i, j):
+            queue = deque()
+            queue.append([i, j])
+            grid[i][j] = "0"
+            while queue:
+                x, y = queue.popleft()
+                for k in range(4):
+                    nx = x + dx[k]
+                    ny = y + dy[k]
+                    if nx < 0 or nx >= n or ny < 0 or ny >= m:
+                        continue
+                    if grid[nx][ny] == "0":
+                        continue
+                    grid[nx][ny] = "0"
+                    queue.append([nx, ny])
+            
+
+        dx = [-1, 1, 0, 0]
+        dy = [0, 0, -1, 1]
+        n, m = len(grid), len(grid[0])
+        cnt = 0
+        for i in range(n):
+            for j in range(m):
+                if grid[i][j] == "1":
+                    bfs(grid, i, j)
+                    cnt += 1
+        return cnt

From 7507b007166ce506a499e6a63e650acd9f1b04c3 Mon Sep 17 00:00:00 2001
From: hu6r1s <darmaa333@gmail.com>
Date: Thu, 23 Oct 2025 11:20:00 +0900
Subject: [PATCH 3/5] feat: Solve house-robber-ii problem

---
 house-robber-ii/hu6r1s.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 house-robber-ii/hu6r1s.py

diff --git a/house-robber-ii/hu6r1s.py b/house-robber-ii/hu6r1s.py
new file mode 100644
index 000000000..b512a45ad
--- /dev/null
+++ b/house-robber-ii/hu6r1s.py
@@ -0,0 +1,12 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        return max(nums[0], self.helper(nums[1:]), self.helper(nums[:-1]))
+
+
+    def helper(self, nums):
+        rob1, rob2 = 0, 0
+        for num in nums:
+            new_rob = max(rob1 + num, rob2)
+            rob1 = rob2
+            rob2 = new_rob
+        return rob2

From 5ff811201db2ed7d7c5b6e18eb7f72b913cb8001 Mon Sep 17 00:00:00 2001
From: hu6r1s <darmaa333@gmail.com>
Date: Thu, 23 Oct 2025 11:28:52 +0900
Subject: [PATCH 4/5] feat: Solve meeting-rooms-ii problem

---
 meeting-rooms-ii/hu6r1s.py | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 meeting-rooms-ii/hu6r1s.py

diff --git a/meeting-rooms-ii/hu6r1s.py b/meeting-rooms-ii/hu6r1s.py
new file mode 100644
index 000000000..c5fcdda8a
--- /dev/null
+++ b/meeting-rooms-ii/hu6r1s.py
@@ -0,0 +1,30 @@
+from typing import (
+    List,
+)
+from lintcode import (
+    Interval,
+)
+
+"""
+Definition of Interval:
+class Interval(object):
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+"""
+from heapq import heappush, heappop
+
+class Solution:
+    """
+    @param intervals: an array of meeting time intervals
+    @return: the minimum number of conference rooms required
+    """
+    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
+        # Write your code here
+        intervals.sort()
+        ends = []
+        for start, end in intervals:
+            if ends and ends[0] <= start:
+                heappop(ends)
+            heappush(ends, end)
+        return len(ends)

From 4da6e9247b079b4318781db9570e9b44e65331e4 Mon Sep 17 00:00:00 2001
From: hu6r1s <darmaa333@gmail.com>
Date: Thu, 23 Oct 2025 12:36:39 +0900
Subject: [PATCH 5/5] feat: Solve word-search-ii problem

---
 word-search-ii/hu6r1s.py | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 word-search-ii/hu6r1s.py

diff --git a/word-search-ii/hu6r1s.py b/word-search-ii/hu6r1s.py
new file mode 100644
index 000000000..614d5e923
--- /dev/null
+++ b/word-search-ii/hu6r1s.py
@@ -0,0 +1,33 @@
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        n, m = len(board), len(board[0])
+        res = set()
+
+        trie = {}
+        for word in words:
+            node = trie
+            for ch in word:
+                node = node.setdefault(ch, {})
+            node['$'] = word
+
+        def dfs(x, y, node):
+            ch = board[x][y]
+            if ch not in node:
+                return
+            nxt = node[ch]
+
+            if '$' in nxt:
+                res.add(nxt['$'])
+
+            board[x][y] = "#"
+            for dx, dy in [(1,0), (-1,0), (0,1), (0,-1)]:
+                nx, ny = x + dx, y + dy
+                if 0 <= nx < n and 0 <= ny < m and board[nx][ny] != "#":
+                    dfs(nx, ny, nxt)
+            board[x][y] = ch
+
+        for i in range(n):
+            for j in range(m):
+                dfs(i, j, trie)
+
+        return list(res)