diff --git a/Class3/AC/README.md b/Class3/AC/README.md
new file mode 100644
index 0000000..e74fcfa
--- /dev/null
+++ b/Class3/AC/README.md
@@ -0,0 +1,65 @@
+# AC
+
+solved_ac[Class3] [AC](https://www.acmicpc.net/problem/5430)
+
+## 문제
+
+선영이는 주말에 할 일이 없어서 새로운 언어 AC를 만들었다. AC는 정수 배열에 연산을 하기 위해 만든 언어이다. 이 언어에는 두 가지 함수 R(뒤집기)과 D(버리기)가 있다.
+
+함수 R은 배열에 있는 수의 순서를 뒤집는 함수이고, D는 첫 번째 수를 버리는 함수이다. 배열이 비어있는데 D를 사용한 경우에는 에러가 발생한다.
+
+함수는 조합해서 한 번에 사용할 수 있다. 예를 들어, "AB"는 A를 수행한 다음에 바로 이어서 B를 수행하는 함수이다. 예를 들어, "RDD"는 배열을 뒤집은 다음 처음 두 수를 버리는 함수이다.
+
+배열의 초기값과 수행할 함수가 주어졌을 때, 최종 결과를 구하는 프로그램을 작성하시오.
+
+
+
+
+
+## 입력
+
+첫째 줄에 테스트 케이스의 개수 T가 주어진다. T는 최대 100이다.
+
+각 테스트 케이스의 첫째 줄에는 수행할 함수 p가 주어진다. p의 길이는 1보다 크거나 같고, 100,000보다 작거나 같다.
+
+다음 줄에는 배열에 들어있는 수의 개수 n이 주어진다. (0 ≤ n ≤ 100,000)
+
+다음 줄에는 [x1,...,xn]과 같은 형태로 배열에 들어있는 정수가 주어진다. (1 ≤ xi ≤ 100)
+
+전체 테스트 케이스에 주어지는 p의 길이의 합과 n의 합은 70만을 넘지 않는다.
+
+
+
+## 출력
+
+각 테스트 케이스에 대해서, 입력으로 주어진 정수 배열에 함수를 수행한 결과를 출력한다. 만약, 에러가 발생한 경우에는 error를 출력한다.
+
+
+
+
+## 예제 입력 1 
+
+```
+4
+RDD
+4
+[1,2,3,4]
+DD
+1
+[42]
+RRD
+6
+[1,1,2,3,5,8]
+D
+0
+[]
+```
+
+## 예제 출력 1 
+
+```
+[2,1]
+error
+[1,2,3,5,8]
+error
+```
diff --git a/Class3/AC/donghyeok1.py b/Class3/AC/donghyeok1.py
new file mode 100644
index 0000000..dca7c62
--- /dev/null
+++ b/Class3/AC/donghyeok1.py
@@ -0,0 +1,58 @@
+import queue
+import sys
+from collections import deque
+
+# def reverse(queue):
+#     list_len = len(queue)
+#     for i in range(list_len // 2):
+#         tmp = queue[list_len - 1 - i]
+#         queue[list_len-1-i] = queue[i]
+#         queue[i] = tmp
+
+
+def print_list(result):
+    
+    while True:
+        if result == "error":
+            print("error",end="")
+            break
+        print("[",end="")
+        for i in range(len(result)-1):
+            print(str(result[i]) + ",",end="")
+        print(str(result[len(result)-1]) + "]",end="")
+        break
+
+T = int(sys.stdin.readline())
+
+result = [[] for _ in range(T)]
+input_string = [[] for _ in range(T)]
+for i in range(T):
+    queue = deque()
+    
+    input_string[i] = list(sys.stdin.readline())
+    
+    len_list = int(sys.stdin.readline())
+    list_a = sys.stdin.readline()
+    list_a = (list_a.replace("[", "").replace(","," ").replace("]","")).split()
+    for k in range(len(list_a)):
+        queue.append(list_a[k])
+    
+    if len_list != len(list_a):
+        result[i] = "error"
+        continue    
+    for func in input_string[i]:
+        if func == "R":
+            queue.reverse()
+        elif func == "D":
+            a = len(queue)
+            if len(queue) == 0:
+                result[i] = "error"    
+                break
+            queue.popleft()
+    if result[i] != "error":
+        result[i] = queue
+    
+for j in range(T):
+    print_list(result[j])
+    print()
+
diff --git "a/Class3/\354\210\250\353\260\224\352\274\255\354\247\210/README.md" "b/Class3/\354\210\250\353\260\224\352\274\255\354\247\210/README.md"
new file mode 100644
index 0000000..70606be
--- /dev/null
+++ "b/Class3/\354\210\250\353\260\224\352\274\255\354\247\210/README.md"
@@ -0,0 +1,37 @@
+# 숨바꼭질
+
+solved_ac[Class3] [숨바꼭질](https://www.acmicpc.net/problem/1697)
+
+## 문제
+
+수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다. 순간이동을 하는 경우에는 1초 후에 2*X의 위치로 이동하게 된다.
+
+수빈이와 동생의 위치가 주어졌을 때, 수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지 구하는 프로그램을 작성하시오.
+
+
+
+## 입력
+
+첫 번째 줄에 수빈이가 있는 위치 N과 동생이 있는 위치 K가 주어진다. N과 K는 정수이다.
+
+
+
+## 출력
+
+수빈이가 동생을 찾는 가장 빠른 시간을 출력한다.
+
+
+
+
+
+## 예제 입력 1 
+
+```
+5 17
+```
+
+## 예제 출력 1 
+
+```
+4
+```
diff --git "a/Class3/\354\210\250\353\260\224\352\274\255\354\247\210/donghyeok1.py" "b/Class3/\354\210\250\353\260\224\352\274\255\354\247\210/donghyeok1.py"
new file mode 100644
index 0000000..c44dcf5
--- /dev/null
+++ "b/Class3/\354\210\250\353\260\224\352\274\255\354\247\210/donghyeok1.py"
@@ -0,0 +1,37 @@
+import sys
+from collections import deque
+
+N, K = map(int, sys.stdin.readline().split())
+visited = [False] * 100001
+
+def bfs(N, K, visited):
+    queue = deque()
+    queue.append([N, 0])
+    visited[N] = True
+    if N == K:
+        print(0)
+        return
+    
+    while queue:
+        path, second = queue.popleft()
+        
+        if K == path:
+            print(second)
+            break
+        else:
+            for edit_path in ((path + 1), (path - 1), (path * 2)):
+                if 0 <= edit_path <= 100000 and visited[edit_path] == False:
+                    queue.append([edit_path, second + 1])
+                    visited[edit_path] = True
+        
+        
+            
+        
+\
+        
+
+bfs(N, K, visited) 
+        
+        
+    
+    
diff --git "a/Class3/\354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224/README.md" "b/Class3/\354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224/README.md"
new file mode 100644
index 0000000..eca94f4
--- /dev/null
+++ "b/Class3/\354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224/README.md"	
@@ -0,0 +1,75 @@
+# 유기농 배추
+
+solved_ac[Class3] [유기농 배추](https://www.acmicpc.net/problem/1012)
+
+## 문제
+
+차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에 효과적인 배추흰지렁이를 구입하기로 결심한다. 이 지렁이는 배추근처에 서식하며 해충을 잡아 먹음으로써 배추를 보호한다. 특히, 어떤 배추에 배추흰지렁이가 한 마리라도 살고 있으면 이 지렁이는 인접한 다른 배추로 이동할 수 있어, 그 배추들 역시 해충으로부터 보호받을 수 있다. 한 배추의 상하좌우 네 방향에 다른 배추가 위치한 경우에 서로 인접해있는 것이다.
+
+한나가 배추를 재배하는 땅은 고르지 못해서 배추를 군데군데 심어 놓았다. 배추들이 모여있는 곳에는 배추흰지렁이가 한 마리만 있으면 되므로 서로 인접해있는 배추들이 몇 군데에 퍼져있는지 조사하면 총 몇 마리의 지렁이가 필요한지 알 수 있다. 예를 들어 배추밭이 아래와 같이 구성되어 있으면 최소 5마리의 배추흰지렁이가 필요하다. 0은 배추가 심어져 있지 않은 땅이고, 1은 배추가 심어져 있는 땅을 나타낸다.
+
+![캡처](https://user-images.githubusercontent.com/95459089/170838589-ac41bc36-18d4-42eb-b51d-db2ab238b103.PNG)
+
+
+## 입력
+
+입력의 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트 케이스에 대해 첫째 줄에는 배추를 심은 배추밭의 가로길이 M(1 ≤ M ≤ 50)과 세로길이 N(1 ≤ N ≤ 50), 그리고 배추가 심어져 있는 위치의 개수 K(1 ≤ K ≤ 2500)이 주어진다. 그 다음 K줄에는 배추의 위치 X(0 ≤ X ≤ M-1), Y(0 ≤ Y ≤ N-1)가 주어진다. 두 배추의 위치가 같은 경우는 없다.
+
+
+
+## 출력
+
+각 테스트 케이스에 대해 필요한 최소의 배추흰지렁이 마리 수를 출력한다.
+
+
+
+
+## 예제 입력 1 
+
+```
+2
+10 8 17
+0 0
+1 0
+1 1
+4 2
+4 3
+4 5
+2 4
+3 4
+7 4
+8 4
+9 4
+7 5
+8 5
+9 5
+7 6
+8 6
+9 6
+10 10 1
+5 5
+```
+
+## 예제 출력 1 
+
+```
+5
+1
+```
+## 예제 입력 2
+
+```
+1
+5 3 6
+0 2
+1 2
+2 2
+3 2
+4 2
+4 0
+```
+## 예제 출력 2
+
+```
+2
+```
\ No newline at end of file
diff --git "a/Class3/\354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224/donghyeok1.py" "b/Class3/\354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224/donghyeok1.py"
new file mode 100644
index 0000000..fa45d50
--- /dev/null
+++ "b/Class3/\354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224/donghyeok1.py"	
@@ -0,0 +1,43 @@
+import sys
+from collections import deque
+
+#BFS 쓸거다
+#입력 받아서 그림처럼 그래프화 함
+#1을 처음 발견하면 count += 1 하고 BFS해서 0으로 만들어버림. 그러면 visited도 사용 안해도됨  
+
+T = int(sys.stdin.readline())
+
+def bfs(graph, y, x):
+    queue = deque()
+    queue.append([y, x])
+    dx = [-1, 0, 0, 1]
+    dy = [0, 1, -1, 0]
+    #상 하 좌 우 검색
+    while queue:
+        y, x = queue.popleft()
+        for i in range(4):
+            new_y = y + dy[i]
+            new_x = x + dx[i]
+            if N > new_y >= 0 and M > new_x >= 0 and graph[new_y][new_x] == 1:
+                graph[new_y][new_x] = 0
+                queue.append([new_y, new_x])
+                
+                
+        
+
+for i in range(T):
+    M, N, K = map(int, sys.stdin.readline().split())
+    graph = [[0]*M for _ in range(N)]
+    for j in range(K):
+        x, y = map(int, sys.stdin.readline().split())
+        graph[y][x] = 1
+    count = 0
+    for y in range(N):
+        for x in range(M):
+            if graph[y][x] == 1:
+                bfs(graph, y, x)
+                count += 1
+    print(count)
+                
+    
+    
diff --git "a/Class3/\354\265\234\353\214\200 \355\236\231/README.md" "b/Class3/\354\265\234\353\214\200 \355\236\231/README.md"
new file mode 100644
index 0000000..8c84c48
--- /dev/null
+++ "b/Class3/\354\265\234\353\214\200 \355\236\231/README.md"	
@@ -0,0 +1,60 @@
+# 최대 힙
+
+solved_ac[Class3] [최대 힙](https://www.acmicpc.net/problem/11279)
+
+## 문제
+
+널리 잘 알려진 자료구조 중 최대 힙이 있다. 최대 힙을 이용하여 다음과 같은 연산을 지원하는 프로그램을 작성하시오.
+
+1. 배열에 자연수 x를 넣는다.
+2. 배열에서 가장 큰 값을 출력하고, 그 값을 배열에서 제거한다.
+
+
+프로그램은 처음에 비어있는 배열에서 시작하게 된다.
+
+
+## 입력
+
+첫째 줄에 연산의 개수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 연산에 대한 정보를 나타내는 정수 x가 주어진다. 만약 x가 자연수라면 배열에 x라는 값을 넣는(추가하는) 연산이고, x가 0이라면 배열에서 가장 큰 값을 출력하고 그 값을 배열에서 제거하는 경우이다. 입력되는 자연수는 231보다 작다.
+
+
+
+## 출력
+
+입력에서 0이 주어진 회수만큼 답을 출력한다. 만약 배열이 비어 있는 경우인데 가장 큰 값을 출력하라고 한 경우에는 0을 출력하면 된다.
+
+
+
+
+## 예제 입력 1 
+
+```
+13
+0
+1
+2
+0
+0
+3
+2
+1
+0
+0
+0
+0
+0
+```
+
+## 예제 출력 1 
+
+```
+0
+2
+1
+3
+2
+1
+0
+0
+```
+
diff --git "a/Class3/\354\265\234\353\214\200 \355\236\231/donghyeok1.py" "b/Class3/\354\265\234\353\214\200 \355\236\231/donghyeok1.py"
new file mode 100644
index 0000000..1445e57
--- /dev/null
+++ "b/Class3/\354\265\234\353\214\200 \355\236\231/donghyeok1.py"	
@@ -0,0 +1,39 @@
+import sys
+import heapq
+
+N = int(sys.stdin.readline())
+
+h = []
+result = []
+for i in range(N):
+    x = int(sys.stdin.readline())
+    heapq.heappush(h, -x)
+    #heapq 라이브러리의 heappush 함수는 파라미터를 두개 가짐
+    #첫 번째 파라미터는 append 할 list
+    #두 번째 파라미터는 append 할 value이다.
+    #이렇게 하나씩 넣게 되면 
+    #![캡처](https://user-images.githubusercontent.com/95459089/170843465-4142b916-d3eb-4f95-a0b9-2279f1bc76c5.PNG)
+    #위 그림 처럼 트리를 형성하게 됨.
+    #이렇게 형성되어 있는 트리에 어떠한 수를 삽입하게 된다면
+    #![캡처](https://user-images.githubusercontent.com/95459089/170843521-82b22d87-a8f8-4d71-8fa8-b2e5fd8a5b9e.PNG)
+    #위 그림처럼 맨 밑에서부터 부모 노드랑 비교를 해가면서 올라가게 된다. 
+    #파이썬의 heapq는 최소힙이 default이고 최대힙으로 주려면 위 코딩처럼 value값에
+    #-를 붙여서 넣어주고 pop 할때도 -를 붙여서 빼야한다.
+    #그래서 0이 나오기 전까지 heappush를 하면서 트리를 형성해주고
+    #0이 나오면 맨 위에 있는 수를 빼준다. 그것이 max이기 때문에.
+    #![캡처](https://user-images.githubusercontent.com/95459089/170843608-6f05e17d-c9f1-41de-a9b6-12512d79a24a.PNG)
+    #heappop을 해서 맨 위에 수를 제거해주면 가장 마지막 노드가 루트 노드의 위치에 오게한다.
+    #![캡처](https://user-images.githubusercontent.com/95459089/170843650-18bbbab2-cfe9-4a4e-8796-dff5d461705f.PNG)
+    #위 그림처럼 루트 노드로 보내고 바로 아래 자식 노드 두 개와 비교해서 위치 시킨다.
+    
+    if x == 0:
+        result.append(-heapq.heappop(h))
+    #0이 나오기 전까지 계속 push를 해서 트리 형성
+    #0이 나오면 루트 노드 pop
+    #그러면 다시 heapify()를 통해 트리 형성
+    #만약 트리가 비어있다면 0을 pop해줌.
+        
+for i in range(len(result)):
+    print(result[i])
+        
+    
\ No newline at end of file
diff --git "a/Class3/\355\214\251\355\206\240\353\246\254\354\226\274 0\354\235\230 \352\260\234\354\210\230/README.md" "b/Class3/\355\214\251\355\206\240\353\246\254\354\226\274 0\354\235\230 \352\260\234\354\210\230/README.md"
new file mode 100644
index 0000000..32ea4a9
--- /dev/null
+++ "b/Class3/\355\214\251\355\206\240\353\246\254\354\226\274 0\354\235\230 \352\260\234\354\210\230/README.md"	
@@ -0,0 +1,44 @@
+# 팩토리얼 0의 개수
+
+solved_ac[Class3] [팩토리얼 0의 개수](https://www.acmicpc.net/problem/1676)
+
+## 문제
+
+N!에서 뒤에서부터 처음 0이 아닌 숫자가 나올 때까지 0의 개수를 구하는 프로그램을 작성하시오.
+
+
+## 입력
+
+첫째 줄에 N이 주어진다. (0 ≤ N ≤ 500)
+
+
+
+## 출력
+
+첫째 줄에 구한 0의 개수를 출력한다.
+
+
+
+## 예제 입력 1 
+
+```
+10
+```
+
+## 예제 출력 1 
+
+```
+2
+```
+
+## 예제 입력 2 
+
+```
+3
+```
+
+## 예제 출력 2
+
+```
+0
+```
diff --git "a/Class3/\355\214\251\355\206\240\353\246\254\354\226\274 0\354\235\230 \352\260\234\354\210\230/donghyeok1.py" "b/Class3/\355\214\251\355\206\240\353\246\254\354\226\274 0\354\235\230 \352\260\234\354\210\230/donghyeok1.py"
new file mode 100644
index 0000000..20f4f51
--- /dev/null
+++ "b/Class3/\355\214\251\355\206\240\353\246\254\354\226\274 0\354\235\230 \352\260\234\354\210\230/donghyeok1.py"	
@@ -0,0 +1,26 @@
+import sys
+
+def fact(N):
+    # if N == 1:
+    #     return 1
+    # else:
+    #     return N * fact(N - 1)
+    result = 1
+    for i in range(N):
+        result *= (i+1)
+    return result
+
+#500까지 recursion 하면 recursive error 가 뜬다.
+#걍 for문 써서 하면 됨.
+        
+    
+N = int(sys.stdin.readline())
+a = fact(N)
+count = 0
+while True:
+    if a % 10 == 0:
+        a = a // 10
+        count += 1
+    else:
+        print(count)
+        break
\ No newline at end of file