diff --git a/clone-graph/hu6r1s.py b/clone-graph/hu6r1s.py
new file mode 100644
index 000000000..bae60f776
--- /dev/null
+++ b/clone-graph/hu6r1s.py
@@ -0,0 +1,28 @@
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+
+        visited = [None] * 101
+        
+        def dfs(n):
+            if visited[n.val] is not None:
+                return visited[n.val]
+            
+            copy = Node(n.val, [])
+            visited[n.val] = copy
+            
+            for nei in n.neighbors:
+                copy.neighbors.append(dfs(nei))
+            return copy
+
+        return dfs(node)
diff --git a/longest-common-subsequence/hu6r1s.py b/longest-common-subsequence/hu6r1s.py
new file mode 100644
index 000000000..77de1c6fa
--- /dev/null
+++ b/longest-common-subsequence/hu6r1s.py
@@ -0,0 +1,15 @@
+class Solution:
+  """
+  문제의 힌트에서 DP를 활용하는 것을 확인
+  """
+  def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+    dp = [[0] * (len(text2)+1) for _ in range(len(text1)+1)]
+
+    for i in range(1, len(text1)+1):
+        for j in range(1, len(text2)+1):
+            if text1[i-1] == text2[j-1]:
+                dp[i][j] = dp[i-1][j-1] + 1
+            else:
+                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+    
+    return dp[-1][-1]
diff --git a/longest-repeating-character-replacement/hu6r1s.py b/longest-repeating-character-replacement/hu6r1s.py
new file mode 100644
index 000000000..d18f9af88
--- /dev/null
+++ b/longest-repeating-character-replacement/hu6r1s.py
@@ -0,0 +1,18 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        counts = {}
+        left = 0
+        max_count = 0
+        res = 0
+
+        for right in range(len(s)):
+            counts[s[right]] = counts.get(s[right], 0) + 1
+            max_count = max(max_count, counts[s[right]])
+
+            while (right - left + 1) - max_count > k:
+                counts[s[left]] -= 1
+                left += 1
+
+            res = max(res, right - left + 1)
+
+        return res
diff --git a/palindromic-substrings/hu6r1s.py b/palindromic-substrings/hu6r1s.py
new file mode 100644
index 000000000..8f3993439
--- /dev/null
+++ b/palindromic-substrings/hu6r1s.py
@@ -0,0 +1,13 @@
+class Solution:
+  """
+  브루트포스로 모두 탐색하면서 집어넣는 방법
+  O(n^2)
+  """
+  def countSubstrings(self, s: str) -> int:
+      cnt = []
+      for i in range(len(s)):
+          for j in range(i, len(s)):
+              sub = s[i:j+1]
+              if sub and sub == sub[::-1]:
+                  cnt.append(sub)
+      return len(cnt)
diff --git a/reverse-bits/hu6r1s.py b/reverse-bits/hu6r1s.py
new file mode 100644
index 000000000..c418dccc3
--- /dev/null
+++ b/reverse-bits/hu6r1s.py
@@ -0,0 +1,6 @@
+class Solution:
+    """
+    binary로 변환 후 zfill로 32자리를 맞춰주고 reverse시킨다.
+    """
+    def reverseBits(self, n: int) -> int:
+        return int(bin(n)[2:].zfill(32)[::-1], 2)