diff --git a/woogieon8on/chap10/boj/1325.py b/woogieon8on/chap10/boj/1325.py
new file mode 100644
index 0000000..f35499e
--- /dev/null
+++ b/woogieon8on/chap10/boj/1325.py
@@ -0,0 +1,41 @@
+from collections import deque
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+computer = [[] for _ in range(n+1)] # 각 컴퓨터가 해킹할 수 있는 컴퓨터 리스트
+
+for _ in range(m):
+    a, b = map(int,input().split())
+    computer[b].append(a) # A가 B를 신뢰함 -> B를 해킹하면 A도 해킹 가능
+
+def bfs(i):
+    visited = [0] * (n + 1)
+    queue = deque([i])
+    visited[i] = 1
+    cnt = 1 # 해킹할 수 있는 컴퓨터 수 (자기 자신 포함)
+
+    while queue:
+        x = queue.popleft()
+
+        for nx in computer[x]: # 해당 컴퓨터와 신뢰 관계에 있는 모든 컴퓨터
+            if not visited[nx]: # 방문하지 않은 경우
+                queue.append(nx) # 큐에 추가
+                visited[nx] = 1 # 방문 처리
+                cnt += 1 # 해킹할 수 있는 컴퓨터 수 증가
+
+    return cnt
+
+answer = [] # 해킹할 수 있는 컴퓨터 수가 최대인 컴퓨터 리스트
+max_hack = 0 # 최대 해킹 수
+
+for i in range(1, n+1):
+    result = bfs(i)
+    if max_hack < result: # 최대 해킹 수가 더 높은 경우 갱신
+        max_hack = result
+        answer.clear() # 기존 답 리스트 초기화
+        answer.append(i) # 리스트에 추가
+    elif max_hack == result: # 최대 해킹 수가 동일한 경우
+        answer.append(i) # 기존 답 리스트 초기화 없이 리스트에 추가
+
+print(*answer)
\ No newline at end of file
diff --git a/woogieon8on/chap10/boj/1446.py b/woogieon8on/chap10/boj/1446.py
new file mode 100644
index 0000000..ebeee8e
--- /dev/null
+++ b/woogieon8on/chap10/boj/1446.py
@@ -0,0 +1,35 @@
+import heapq
+import sys
+input = sys.stdin.readline
+INF = int(1e9)
+
+n, d = map(int, input().split())
+
+graph = [[] for i in range(d+1)]
+distance = [INF] * (d+1)
+
+for i in range(d): # 고속도로 길이를 구성하는 0부터 d까지 모든 수를 각각 하나의 노드라고 가정
+    graph[i].append((i+1, 1)) # 각 노드의 가중치 1로 설정
+
+for _ in range(n): # 기존 그래프에 지름길 추가
+    start, destination, length = map(int, input().split())
+    if destination<=d: # 도착 지점이 고속도로 끝(d)보다 큰 경우는 제외
+        graph[start].append((destination, length))
+
+def dijkstra(start): # 다익스트라 알고리즘
+    q = []
+    heapq.heappush(q, (0, start))
+    distance[start] = 0
+
+    while q:
+        dist, now = heapq.heappop(q)
+
+        for i in graph[now]: # 현재 노드와 연결된 다른 인접한 노드들 확인
+            cost = distance[now] + i[1]
+            if cost < distance[i[0]]: # 지름길을 거쳐 다른 노드로 이동할 때 거리가 더 짧은 경우
+                distance[i[0]] = cost
+                heapq.heappush(q, (cost, i[0]))
+
+dijkstra(0)
+
+print(distance[d])
\ No newline at end of file
diff --git a/woogieon8on/chap10/boj/14502.py b/woogieon8on/chap10/boj/14502.py
new file mode 100644
index 0000000..0520eaa
--- /dev/null
+++ b/woogieon8on/chap10/boj/14502.py
@@ -0,0 +1,64 @@
+from collections import deque
+import copy
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+graph = []
+dx = [0, 0, 1, -1]
+dy = [1, -1, 0, 0]
+
+# 바이러스는 벽(1)을 제외한 모든 영역을 향하여 BFS를 통해 자신을 감염시킴
+def bfs():
+    queue = deque()
+    tmp_graph = copy.deepcopy(graph) # 원래의 graph 유지
+
+    # 바이러스(2)를 큐에 넣음
+    for i in range(n):
+        for j in range(m):
+            if tmp_graph[i][j] == 2:
+                queue.append((i, j))
+
+    # 감염 시작
+    while queue:
+        x, y = queue.popleft()
+
+        for i in range(4):
+            nx = x + dx[i]
+            ny = y + dy[i]
+
+            if nx < 0 or nx >= n or ny < 0 or ny >= m: # 범위 확인
+                continue
+            if tmp_graph[nx][ny] == 0: # 감염 가능 여부, 즉 해당 칸이 0인지 확인
+                tmp_graph[nx][ny] = 2
+                queue.append((nx, ny))
+
+    global answer
+    cnt = 0
+
+    # 안전 영역(0) 카운트
+    for i in range(n):
+        cnt += tmp_graph[i].count(0)
+
+    answer = max(answer, cnt) # 안전 영역 크기 최대값 갱신
+
+# 벽을 세우고, 3개의 벽을 모두 세워 안전 영역이 확정되면 그 개수를 세기 위해 BFS 사용
+def makeWall(cnt):
+    if cnt == 3: # 3개의 벽을 모두 세우면 BFS 사용하여 바이러스 감염 시작
+        bfs()
+        return
+    
+    # 벽을 세우는 모든 경우의 수 검토(백트래킹)
+    for i in range(n):
+        for j in range(m):
+            if graph[i][j] == 0: # 벽 설치 가능 여부 확인
+                graph[i][j] = 1 # 벽 설치
+                makeWall(cnt+1) # 두번째 벽 설치하기 위해 makeWall() 재귀 호출
+                graph[i][j] = 0 # 벽 제거
+
+for i in range(n):
+    graph.append(list(map(int, input().split())))
+
+answer = 0
+makeWall(0)
+print(answer)
\ No newline at end of file
diff --git a/woogieon8on/chap10/boj/2660.py b/woogieon8on/chap10/boj/2660.py
new file mode 100644
index 0000000..16ffbe3
--- /dev/null
+++ b/woogieon8on/chap10/boj/2660.py
@@ -0,0 +1,44 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+n = int(input())
+members = [[] for _ in range(n+1)] # 회원별 친구 리스트
+count = [0] * (n+1)
+
+while True:
+    a, b = map(int, input().split())
+    if a == -1 and b == -1: # 마지막 줄
+        break
+    else:
+        members[a].append(b)
+        members[b].append(a)
+
+def bfs(v):
+    queue = deque()
+    queue.append([v, 0]) # 회원 번호, 현재 깊이 큐에 추가
+    visited[v] = True
+
+    while queue:
+        x, y = queue.popleft()
+
+        for i in members[x]: # 현재 회원과 친구 관계인 모든 회원들
+            if not visited[i]: # 방문하지 않은 경우
+                visited[i] = True
+                queue.append([i, y+1]) # 깊이를 1 증가시켜 큐에 추가
+
+    count[v] = y # bfs 종료 후 해당 회원의 최대 깊이를 점수로 저장
+
+for i in range(1, n+1):
+    visited = [False] * (n+1)
+    bfs(i) # 각 회원에 대해 bfs 수행
+
+count.pop(0) # 회원번호 0 제거
+answer = [] # 회장 후보 리스트
+
+for i in range(n): # 최소 점수 가진 회원 찾기
+    if count[i] == min(count):
+        answer.append(i+1)
+
+print(min(count), count.count(min(count))) # 최소 점수와 그 점수를 가진 회원 수 출력
+print(*answer) # 회장 후보 회원 번호 출력
\ No newline at end of file
diff --git a/woogieon8on/chap10/boj/5567.py b/woogieon8on/chap10/boj/5567.py
new file mode 100644
index 0000000..4c9823e
--- /dev/null
+++ b/woogieon8on/chap10/boj/5567.py
@@ -0,0 +1,32 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+n = int(input())
+m = int(input())
+graph = [[0] * (n+1) for i in range(n+1)] # 친구 관계 그래프
+visited = [0 for _ in range(n+1)] # 방문 여부 -> 상근이와의 거리
+
+for i in range(m):
+    a,b = map(int, input().split())
+    graph[a].append(b)
+    graph[b].append(a)
+
+def bfs(x):
+    queue = deque([x]) # x: 시작점
+    visited[x] = 1
+
+    while queue:
+        friend_num = queue.popleft()
+        for people_num in graph[friend_num]: # 해당 친구에게 연결된 모든 사람에 대해
+            if visited[people_num] == 0: # 아직 방문하지 않은 경우
+                queue.append(people_num) # 큐에 추가
+                visited[people_num] = visited[friend_num] + 1 # 상근이로부터의 거리 기록
+
+bfs(1) # 1번 인덱스: 상근이
+result = 0
+for i in range(2, n+1):
+    if 0 < visited[i] <= 3: # 상근이로부터의 거리가 3 이하인 친구들만 추가
+        result += 1
+        
+print(result)
\ No newline at end of file
diff --git a/woogieon8on/chap3/boj/1080.py b/woogieon8on/chap3/boj/1080.py
new file mode 100644
index 0000000..94250ed
--- /dev/null
+++ b/woogieon8on/chap3/boj/1080.py
@@ -0,0 +1,24 @@
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+a = [list(map(int, list(input().strip()))) for _ in range(n)]
+b = [list(map(int, list(input().strip()))) for _ in range(n)]
+count = 0
+
+# 3x3 크기의 부분 행렬에 있는 모든 원소 뒤집는 메소드
+def convert(x, y, a):
+    for i in range(x, x+3):
+        for j in range(y, y+3):
+            a[i][j] = 1 - a[i][j] # 0 -> 1, 1 -> 0
+
+# convert 메소드 유의하여 범위 설정
+for i in range(n-2):
+    for j in range(m-2):
+        count += 1
+        convert(i, j, a)
+
+if a != b: # A를 B로 바꿀 수 없다면 -1 출력
+    print(-1)
+else:
+    print(count)
\ No newline at end of file
diff --git a/woogieon8on/chap3/boj/11000.py b/woogieon8on/chap3/boj/11000.py
new file mode 100644
index 0000000..35e8264
--- /dev/null
+++ b/woogieon8on/chap3/boj/11000.py
@@ -0,0 +1,25 @@
+import sys
+import heapq
+imput = sys.stdin.readline
+
+n = int(input())
+time = [] # 강의 시간 정보 리스트
+
+for _ in range(n):
+    time.append(list(map(int, input().split())))
+
+time.sort(key = lambda x: (x[0], x[1])) # 강의 시작하는 시간 기준으로 정렬
+
+heap = [time[0][1]] # 첫 번째 강의의 종료 시간 힙에 추가
+for i in range(1,n):
+    # heap[0]: 가장 빨리 끝나는 강의의 종료 시간
+    # time[i][0]: 현재 강의의 시작 시간
+    # 가장 빨리 끝나는 강의의 종료 시간보다 현재 강의의 시작 시간이 크거나 같은 경우
+    # -> 강의실 재사용 가능
+    if heap[0] <= time[i][0]:
+        # 힙에서 가장 빨리 끝나는 강의의 종료 시간 제거
+        # 현재 강의의 종료 시간 힙에 추가하여 가장 빨리 끝나는 강의의 종료 시간 업데이트
+        heapq.heappop(heap)
+    heapq.heappush(heap, time[i][1])
+
+print(len(heap)) # 필요한 강의실 수
\ No newline at end of file
diff --git a/woogieon8on/chap4/boj/20006.py b/woogieon8on/chap4/boj/20006.py
new file mode 100644
index 0000000..f5a3e0c
--- /dev/null
+++ b/woogieon8on/chap4/boj/20006.py
@@ -0,0 +1,31 @@
+p, m = map(int,input().split())
+
+rooms = []
+
+for i in range(p):
+    l, n = input().split()
+
+    # 첫 플레이어 방 만들기
+    if not rooms:
+        rooms.append([[int(l),n]])
+        continue
+	
+    enter = False
+    for room in rooms:
+        # 입장 가능한 방이 있으면 입장
+        if len(room) < m and room[0][0] - 10 <= int(l) <= room[0][0] + 10:
+            room.append([int(l),n])
+            enter = True
+            break
+	# 입장 가능한 방이 없는 경우 방 만들기
+    if not enter:
+        rooms.append([[int(l),n]])
+
+for room in rooms :
+    if len(room) == m:
+        print('Started!')
+    else:
+        print('Waiting!')
+
+    for l, n in room:
+        print(l, n)
\ No newline at end of file
diff --git a/woogieon8on/chap4/boj/2852.py b/woogieon8on/chap4/boj/2852.py
new file mode 100644
index 0000000..e9dc9b3
--- /dev/null
+++ b/woogieon8on/chap4/boj/2852.py
@@ -0,0 +1,30 @@
+N = int(input())
+
+score = {1: 0, 2: 0} # 득점 현황
+scoreTime = {1: 0, 2: 0} # 득점 시간
+leadTime = {1: 0, 2: 0} # 이기고 있던 시간
+lead = 0 # 리드중인 팀 / 0: 동점 상황
+
+for i in range(N):
+    # team, time 모두 int 형식으로 변환
+    team, time = input().split()
+    team = int(team)
+    minute, second = map(int, time.split(':'))
+    time = minute*60 + second
+    score[team] += 1
+
+    # 동점 상황에서 특정 팀이 득점한 경우
+    if lead == 0: 
+        scoreTime[team] = time
+        lead = team
+    # 입력받은 득점으로 동점이 된 경우
+    elif lead != 0 and score[1] == score[2]:
+        leadTime[lead] = time - scoreTime[lead] # 이기고 있던 시간 = 입력받은 득점 시간 - 이기고 있던 팀의 득점 시간
+        lead = 0
+
+# 입력 종료 후 이긴 팀이 있는 경우
+if lead != 0:
+    leadTime[lead] += 60*48 - scoreTime[lead] # (경기 종료 시간 - 이긴 팀의 득점 시간) 추가
+
+print("%02d:%02d" %(leadTime[1]//60, leadTime[1]%60))
+print("%02d:%02d" %(leadTime[2]//60, leadTime[2]%60))
\ No newline at end of file
diff --git a/woogieon8on/chap4/boj/8979.py b/woogieon8on/chap4/boj/8979.py
new file mode 100644
index 0000000..a918865
--- /dev/null
+++ b/woogieon8on/chap4/boj/8979.py
@@ -0,0 +1,19 @@
+N, K = map(int, input().split())
+
+medals = []
+for i in range(N):
+  medals.append(list(map(int, input().split()))) # 국가-메달 리스트 입력받기
+
+medals.sort() # 국가 순서로 정렬
+
+kCountry, kGold, kSilver, kBronze = medals[K-1] # K번째 국가 메달 리스트
+rank = 1
+
+for country, gold, silver, bronze in medals :
+  if country == K :
+    continue
+  # K번째 국가보다 잘한 국가 발견하면 등수 + 1
+  if gold > kGold or gold == kGold and silver > kSilver or gold == kGold and silver == kSilver and bronze > kBronze :
+    rank += 1
+
+print(rank)
\ No newline at end of file
diff --git a/woogieon8on/chap5/boj/1012.py b/woogieon8on/chap5/boj/1012.py
new file mode 100644
index 0000000..a1e3df2
--- /dev/null
+++ b/woogieon8on/chap5/boj/1012.py
@@ -0,0 +1,46 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+T = int(input())
+
+dx = [-1, 1, 0, 0]
+dy = [0, 0, -1, 1]
+
+def bfs(x, y):
+  queue = deque()
+  queue.append((x,y))
+
+  while queue:
+    x, y = queue.popleft()
+
+    for i in range(4):
+      nx = x + dx[i]
+      ny = y + dy[i]
+
+      if nx < 0 or ny < 0 or nx >=N or ny >= M: # 범위를 벗어나는 경우 무시
+        continue
+
+      if matrix[nx][ny] == 1: # 새로운 위치에 배추가 존재하는 경우 큐에 추가
+        queue.append((nx,ny))
+        matrix[nx][ny] = 0 # 0: 이미 방문한 셀
+
+  return
+
+for _ in range(T):
+  M, N, K = map(int, input().split())
+  matrix = [[0]*M for _ in range(N)]
+
+  for i in range(K):
+    x, y = map(int, input().split())
+    matrix[y][x] = 1
+
+  cnt = 0
+  for i in range(N):
+    for j in range(M):
+      if matrix[i][j] ==1: # 배추가 존재하는 경우 bfs 호출
+        bfs(i, j)
+        cnt +=1 # bfs 호출할 때 마다 카운터 증가
+                # 카운터: bfs 호출 횟수 -> 배추가 모여있는 구역의 개수
+
+  print(cnt)
\ No newline at end of file
diff --git a/woogieon8on/chap5/boj/12851.py b/woogieon8on/chap5/boj/12851.py
new file mode 100644
index 0000000..38adcdb
--- /dev/null
+++ b/woogieon8on/chap5/boj/12851.py
@@ -0,0 +1,27 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+N, K= map(int, input().split())
+queue = deque()
+queue.append(N)
+
+way = [0]*100001 # 각 위치까지의 시간 배열
+cnt, result = 0,0
+
+while queue:
+    a =  queue.popleft()
+    temp = way[a]
+
+    if a == K: # 수빈이와 동생이 만난 경우
+        result = temp # temp(=way[a]) 값이 최소 시간
+        cnt += 1 # 최소 시간으로 동생을 찾는 방법 개수 + 1
+        continue
+    
+    for i in [a-1, a+1, a*2]: # 수빈이가 걷거나 순간이동 해서 도착하는 다음 위치에 대하여
+        if 0 <= i < 100001 and (way[i] == 0 or way[i] == way[a] + 1): # 범위 안에 있으면서, 아직 방문하지 않았거나 해당 위치까지의 시간이 동일한 경우
+            way[i] = way[a] + 1 # 해당 위치까지의 시간을 1 증가시킨 후 큐에 추가
+            queue.append(i) 
+
+print(result)
+print(cnt)
\ No newline at end of file
diff --git a/woogieon8on/chap5/boj/14888.py b/woogieon8on/chap5/boj/14888.py
new file mode 100644
index 0000000..13ed707
--- /dev/null
+++ b/woogieon8on/chap5/boj/14888.py
@@ -0,0 +1,30 @@
+N = int(input())
+nums = list(map(int, input().split()))
+op = list(map(int, input().split()))
+
+maxNum = -1e9
+minNum = 1e9
+
+def dfs(i, num, add, sub, mul, div):
+    global maxNum, minNum # 최댓값, 최솟값 전역변수 선언
+
+    if i == N: # N개의 수 모두 연산 완료
+        maxNum = max(num, maxNum) # 최댓값 업데이트
+        minNum = min(num, minNum) # 최솟값 업데이트
+        return
+    
+    # 덧셈, 뺄셈, 곱셈, 나눗셈 재귀적으로 호출
+    # 연산자 우선순위 무시하고 앞에서부터 연산 진행
+    if add > 0: # 덧셈
+        dfs(i + 1, num + nums[i], add - 1, sub, mul, div)
+    if sub > 0: # 뺄셈
+        dfs(i + 1, num - nums[i], add, sub - 1, mul, div)
+    if mul > 0: # 곱셈
+        dfs(i + 1, num * nums[i], add, sub, mul - 1, div)
+    if div > 0: # 나눗셈
+        dfs(i + 1, int(num / nums[i]), add, sub, mul, div - 1) # // 연산자 사용해봤는데 결과 오류남ㅜㅜ
+
+dfs(1, nums[0], op[0], op[1], op[2], op[3])
+
+print(maxNum)
+print(minNum)
\ No newline at end of file
diff --git a/woogieon8on/chap5/boj/18352.py b/woogieon8on/chap5/boj/18352.py
new file mode 100644
index 0000000..e64c8fd
--- /dev/null
+++ b/woogieon8on/chap5/boj/18352.py
@@ -0,0 +1,40 @@
+from collections import deque
+
+n, m, k, x = map(int, input().split())
+
+graph = {} # node, edge로 구성된 2차원 배열 생성
+distance = {} # 거리 배열 생성
+visited = {} # 방문 유무 배열 생성
+for i in range(n+1):
+    graph[i] = []
+    distance[i] = 0
+    visited[i] = 0
+for _ in range(m):
+    a, b = map(int, input().split())
+    graph[a].append(b)
+
+# bfs 알고리즘 구현
+def bfs(start):
+    nodes = []
+    queue = deque([start]) # 큐 구현 위해 deque 라이브러리 사용!
+    distance[start] = 0 # 출발 도시로부터의 거리: 0
+    visited[start] = 1
+
+    while queue:
+        now = queue.popleft() # deque: 앞 뒤로 요소를 추가하고 삭제할 수 있는 자료구조
+        for i in graph[now]:
+            if visited[i] == 0:
+                visited[i] = 1
+                queue.append(i) # 현재 노드가 방문한 노드 queue에 추가
+                distance[i] = distance[now] + 1
+                if distance[i] == k: # 최단 거리가 k인 노드 출력에 추가
+                    nodes.append(i)
+
+    if len(nodes) == 0: # 출력할 노드가 하나도 존재하지 않으면 -1 출력
+        print(-1)
+    else:
+        nodes.sort() # 출력 노드 오름차순 정렬
+        for i in nodes:
+            print(i)
+
+bfs(x) # 출발 노드 x
\ No newline at end of file
diff --git a/woogieon8on/chap5/boj/2644.py b/woogieon8on/chap5/boj/2644.py
new file mode 100644
index 0000000..2a8c4ce
--- /dev/null
+++ b/woogieon8on/chap5/boj/2644.py
@@ -0,0 +1,35 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+n = int(input())
+a, b = map(int, input().split())
+m = int(input())
+
+graph = [[] for _ in range(n+1)]
+visited = [ 0 for _ in range(n+1)] # 방문 횟수 -> 촌수
+
+for i in range(m):
+    x, y = map(int, input().split())
+    graph[x].append(y)
+    graph[y].append(x)
+
+def bfs(a, b):
+    queue = deque([a])
+    visited[a] = 0 # 시작 사람의 촌수 = 0
+
+    while queue:
+        people = queue.popleft()
+
+        if people == b: # b: 목표 사람
+                        # 큐에서 꺼낸 사람과 목표 사람이 일치하면 촌수 반환
+            return visited[b]
+        
+        for i in graph[people]:
+            if visited[i] == 0: # 아직 방문하지 않은 사람인 경우 큐에 추가
+                queue.append(i)
+                visited[i] = visited[people] + 1 # 해당 사람 촌수 1 중가시켜 촌수 배열에 저장
+
+    return -1 # 촌수를 계산할 수 없는 경우 -1 반환
+
+print(bfs(a, b))
\ No newline at end of file
diff --git a/woogieon8on/chap6/boj/10825.py b/woogieon8on/chap6/boj/10825.py
new file mode 100644
index 0000000..a71a843
--- /dev/null
+++ b/woogieon8on/chap6/boj/10825.py
@@ -0,0 +1,14 @@
+N = int(input())
+
+students = []
+for _ in range(N):
+    students.append(input().split())
+
+# 기본 형식: sort(key = lamda x: (정렬 대상))
+# 리스트의 각 원소가 튜퓰 형태로 존재할 때, 우선순위를 정하여 정렬 가능
+# 오름차순: 생략 ex) int(x[2])
+# 내림차순: 변수 앞에 - 붙이기 ex) -int(x[1])
+students.sort(key = lambda x:(-int(x[1]),int(x[2]),-int(x[3]),x[0]))
+
+for student in students:
+    print(student[0])
\ No newline at end of file
diff --git a/woogieon8on/chap6/boj/1715.py b/woogieon8on/chap6/boj/1715.py
new file mode 100644
index 0000000..c602dbb
--- /dev/null
+++ b/woogieon8on/chap6/boj/1715.py
@@ -0,0 +1,18 @@
+N = int(input())
+
+cards = []
+for _ in range(N):
+    cards.append(int(input()))
+
+cards.sort() # 카드 묶음 오름차순 정렬
+
+compare = 0
+i = 0
+while i < (N - 1):
+    if i == 0:
+        compare = cards[i] + cards[i + 1]
+    else:
+        compare += compare + cards[i + 1] # 작은 묶음부터 합치기
+    i = i + 1
+
+print(compare)
\ No newline at end of file
diff --git a/woogieon8on/chap6/boj/18310.py b/woogieon8on/chap6/boj/18310.py
new file mode 100644
index 0000000..877509c
--- /dev/null
+++ b/woogieon8on/chap6/boj/18310.py
@@ -0,0 +1,9 @@
+N = int(input())
+house = list(map(int, input().split()))
+
+# 모든 집까지의 거리의 총합
+# : 안테나를 모든 집들 중 중간에 위치한 집에 설치한 경우 최소
+house.sort()
+antenna = house[int((N - 1) / 2)] # 안테나를 설치할 수 있는 위치 값으로 여러 개의 값이 도출될 경우 가장 작은 값 출력
+
+print(antenna)
\ No newline at end of file
diff --git a/woogieon8on/chap7/boj/19637.py b/woogieon8on/chap7/boj/19637.py
new file mode 100644
index 0000000..4655593
--- /dev/null
+++ b/woogieon8on/chap7/boj/19637.py
@@ -0,0 +1,25 @@
+import sys
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+titles = [input().split() for _ in range(n)]
+titles.sort(key = lambda x: int(x[1])) # 칭호를 전투력에 따라 오름차순 정렬
+
+chars = [int(input().strip()) for _ in range(m)] # 각 캐릭터의 전투력을 정수 리스트로 생성
+
+for char in chars:
+
+    low = 0
+    high = len(titles) - 1 # 이진 탐색 끝점: 칭호 마지막 인덱스
+    result = 0 # 결과값 인덱스
+
+    while low <= high:
+        mid = (low + high)//2
+
+        if int(titles[mid][1]) >= char: # 중간 칭호의 전투력보다 캐릭터의 전투력이 낮거나 같은 경우
+            result = mid # 결과값을 중간 인덱스로 갱신
+            high = mid - 1
+        else:
+            low = mid + 1
+
+    print(titles[result][0]) # 캐릭터의 칭호 출력
\ No newline at end of file
diff --git a/woogieon8on/chap7/boj/2110.py b/woogieon8on/chap7/boj/2110.py
new file mode 100644
index 0000000..a674c74
--- /dev/null
+++ b/woogieon8on/chap7/boj/2110.py
@@ -0,0 +1,29 @@
+n, c = map(int, input().split())
+
+houses = []
+for _ in range(n):
+    houses.append(int(input()))
+houses.sort()
+
+# 공유기 설치 간격을 이진탐색의 초기 범위로 지정
+start = 1
+end = houses[n-1] - houses[0]
+
+result = 0
+# 이진 탐색
+while(start <= end):
+    router = 1
+    lastRouter = houses[0] # 마지막으로 공유기를 설치한 집
+    mid = (start + end) // 2
+    for house in houses:
+        if house - lastRouter >= mid: # 마지막으로 공유기를 설치한 집과의 거리가 공유기 설치 간격보다 크거나 같은 경우
+            router += 1 # 해당 집에 공유기 설치
+            lastRouter = house
+
+    if router < c: # 공유기의 총 개수가 설치하고자 하는 공유기의 개수보다 적은 경우
+        end = mid - 1 # 공유기 설치 간격 감소
+    else:
+        result = mid
+        start = mid + 1 # 공유기 설치 간격 증가
+
+print(result)
\ No newline at end of file
diff --git a/woogieon8on/chap7/boj/2343.py b/woogieon8on/chap7/boj/2343.py
new file mode 100644
index 0000000..35183b0
--- /dev/null
+++ b/woogieon8on/chap7/boj/2343.py
@@ -0,0 +1,26 @@
+n, m = map(int, input().split())
+lectures = list(map(int, input().split()))
+
+# 블루레이 크기를 이진탐색의 초기 범위로 지정
+start = max(lectures) # 모든 강의를 각각 블루레이로 녹화할 경우 블루레이의 크기 최소 -> 길이가 가장 긴 강의의 길이
+end = sum(lectures) # 모든 강의를 한 번에 블루레이로 녹화할 경우 블루레이의 크기 최대 -> 모든 강의 길이의 합
+
+result = 0
+# 이진 탐색
+while(start <= end):
+    total = 0
+    bluray = 1
+    mid = (start + end) // 2
+    for lec in lectures:
+        if total + lec > mid: # 강의 길이의 총 합이 블루레이 크기보다 큰 경우
+            bluray += 1 # 블루레이 개수 1 증가
+            total = 0 # 강의 길의의 총 합 초기화
+        total += lec
+
+    if bluray > m: # 블루레이 개수가 원하는 개수보다 많은 경우
+        start = mid + 1 # 블루레이 개수 줄이기 위해 블루레이 크기 증가
+    else:
+        result = mid
+        end = mid - 1 # 블루레이 개수 늘리기 위해 블루레이 크기 감소
+
+print(result)
\ No newline at end of file
diff --git a/woogieon8on/chap7/boj/2467.py b/woogieon8on/chap7/boj/2467.py
new file mode 100644
index 0000000..1ac4ade
--- /dev/null
+++ b/woogieon8on/chap7/boj/2467.py
@@ -0,0 +1,24 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input())
+liquids = list(map(int, input().split()))
+low, high = 0, n-1
+result = [liquids[low], liquids[high]] # 결과값 리스트
+
+while low <= high:
+
+    total = liquids[low] + liquids[high] # 용액 특성값의 합
+
+    if total < 0: # 용액의 특성값들은 이미 오름차순 정렬
+                  # 특성값의 합이 0보다 작다면 low 1 증가
+        low += 1
+    elif total < 0:
+        high -= 1 # 합이 0보다 크다면 high 1 감소
+    else:
+        break # 합이 0이면 바로 결과 출력
+
+    if abs(sum(result)) >= abs(liquids[low] + liquids[high]): # '현재 결과값의 절대값'보다 '변경된 low와 high 합의 절대값'이 작거나 같은 경우
+        result = [liquids[low], liquids[high]] # 결과값 갱신
+
+print(result[0], result[1])
\ No newline at end of file
diff --git a/woogieon8on/chap7/boj/2512.py b/woogieon8on/chap7/boj/2512.py
new file mode 100644
index 0000000..9ed82b0
--- /dev/null
+++ b/woogieon8on/chap7/boj/2512.py
@@ -0,0 +1,29 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input())
+budgets = list(map(int, input().split()))
+m = int(input())
+
+result = 0  # 배정된 예산들 중 최댓값
+start, end = 1, max(budgets) # 이진 탐색 끝점: 가장 큰 예산 요청
+
+# 이진 탐색
+while start <= end:
+
+    mid = (start + end) // 2
+    total = 0  # 예산의 합
+
+    for budget in budgets:
+        if budget > mid: # 예산 요청이 중간값보다 큰 경우
+            total += mid # 중간값을 더함
+        else: 
+            total += budget # 예산 요청이 중간값보다 작기 때문에 예산 요청을 더함
+
+    if total <= m:  # 예산의 합이 총 예산보다 작거나 같은 경우
+        result = mid # 결과값을 중간값으로 갱신
+        start = mid + 1
+    else:  
+        end = mid - 1
+
+print(result)
\ No newline at end of file
diff --git a/woogieon8on/chap7/boj/2805.py b/woogieon8on/chap7/boj/2805.py
new file mode 100644
index 0000000..1730618
--- /dev/null
+++ b/woogieon8on/chap7/boj/2805.py
@@ -0,0 +1,23 @@
+n, m = map(int, input().split())
+trees = list(map(int, input().split()))
+
+# 이진 탐색을 위해 시작점과 끝점(가장 높이가 높은 나무) 지정
+start = 0
+end = max(trees)
+
+result = 0
+# 이진 탐색
+while(start <= end):
+    total = 0
+    mid = (start + end) // 2
+    for tree in trees:
+        if tree > mid: # (현재 나무 높이 - mid)값 만큼 나무 절단
+            total += tree - mid
+    
+    if total < m: # 절단한 나무 길이의 합이 가져가려는 나무의 길이보다 짧은 경우
+        end = mid - 1 # 절단 높이를 내려 절단한 나무 길이의 합 증가
+    else: # 절단한 나무 길이의 합이 충분한 경우
+        result = mid
+        start = mid + 1 # 절단 높이를 올려 절단한 나무 길이의 합 감소
+
+print(result)
\ No newline at end of file
diff --git a/woogieon8on/chap8/boj/14501.py b/woogieon8on/chap8/boj/14501.py
new file mode 100644
index 0000000..5b69fcd
--- /dev/null
+++ b/woogieon8on/chap8/boj/14501.py
@@ -0,0 +1,16 @@
+n = int(input())
+
+schedule = []
+for _ in range(n):
+    schedule.append(list(map(int, input().split())))
+
+profit = [0 for _ in range(n+1)] # i번째 날짜까지의 최대 이익
+
+for i in range(n):
+    # 상담 가능한 모든 날짜:
+    # (i일 + i번째 상담 시간)부터 마지막 날까지 
+    for j in range(i + schedule[i][0], n + 1): 
+        if profit[j] < profit[i] + schedule[i][1]: # i번째 상담을 진행했을 때 이익이 더 크다면 상담 진행   
+            profit[j] = profit[i] + schedule[i][1]
+
+print(profit[-1]) # 마지막 날짜
\ No newline at end of file
diff --git a/woogieon8on/chap8/boj/1912.py b/woogieon8on/chap8/boj/1912.py
new file mode 100644
index 0000000..241d947
--- /dev/null
+++ b/woogieon8on/chap8/boj/1912.py
@@ -0,0 +1,10 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input())
+x = list(map(int, input().split()))
+
+for i in range(1,n) :
+    x[i] = max(x[i], x[i-1] + x[i]) # 수열에서 현재 인덱스 기준으로 (현재 값)과 (이전 값 + 현재 값)을 비교하여 큰 값으로 갱신
+
+print(max(x)) # 갱신 작업이 완료된 수열에서 최댓값 출력
\ No newline at end of file
diff --git a/woogieon8on/chap8/boj/1932.py b/woogieon8on/chap8/boj/1932.py
new file mode 100644
index 0000000..cc1973a
--- /dev/null
+++ b/woogieon8on/chap8/boj/1932.py
@@ -0,0 +1,16 @@
+n = int(input())
+
+tree = []
+for _ in range(n):
+    tree.append(list(map(int, input().split())))
+
+for i in range(1, n): # 첫 번째 행 제외
+    for j in range(len(tree[i])):
+        if j == 0: # 첫 번째 열의 경우 이전 행의 첫 번째 열 선택
+            tree[i][j] = tree[i][j] + tree[i-1][j]
+        elif j == len(tree[i]) - 1: # 마지막 열의 경우 이전 행의 마지막 열 선택
+            tree[i][j] = tree[i][j] + tree[i-1][j-1]
+        else: # 나머지는 이전 행의 같은 열, (자신의 열 - 1)에 해당하는 값 중에서 최대값 선택
+            tree[i][j] = tree[i][j] + max(tree[i-1][j-1], tree[i-1][j])
+
+print(max(tree[n-1])) # 마지막 행에서 최대값 출력
\ No newline at end of file
diff --git a/woogieon8on/chap8/boj/4811.py b/woogieon8on/chap8/boj/4811.py
new file mode 100644
index 0000000..9716deb
--- /dev/null
+++ b/woogieon8on/chap8/boj/4811.py
@@ -0,0 +1,23 @@
+import sys
+input = sys.stdin.readline
+
+# w: 한 조각 | h: 반 조각
+dp = [[0 for _ in range(31)] for _ in range(31) ] # 행: 남은 w의 개수 | 열: 남은 h의 개수 -> dp[i][j]: w i개와 h j개로 만들 수 있는 경우의 수
+
+for j in range(1,31): # h만 남은 경우
+    dp[0][j] = 1 # h를 먹는 방법만 존재하기 때문에 경우의 수는 1
+
+for i in range(1,31):
+    for j in range(30):
+        if j == 0: # w만 남은 경우
+            dp[i][j] = dp[i-1][j+1] # w를 먹으면 h가 반드시 하나 생성 -> w-1 | h+1
+        else: # h가 하나라도 있는 경우
+            dp[i][j] = dp[i-1][j+1] + dp[i][j-1] # w를 먹으면 h가 하나 생성 -> w-1 | h+1
+                                                 # h를 먹으면 w는 그대로, h 하나 감소 -> w | h-1
+                                                 # 두 경우의 수를 더함
+
+while True:
+    n = int(input())
+    if n == 0: # 입력 종료
+        break
+    print(dp[n][0])
\ No newline at end of file
diff --git a/woogieon8on/chap8/boj/9655.py b/woogieon8on/chap8/boj/9655.py
new file mode 100644
index 0000000..296c2fa
--- /dev/null
+++ b/woogieon8on/chap8/boj/9655.py
@@ -0,0 +1,23 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input())
+
+if n % 2 == 0:
+    print('CY')
+else:
+    print('SK')
+
+# # DP 활용
+# N = int(input())
+# dp = [0]*1001
+
+# # SK == 0, CY == 1
+# dp[1] = 0
+# dp[2] = 1
+# dp[3] = 0
+
+# for i in range(4, N+1):
+#     dp[i] = (dp[i-1] + 1) % 2  # N이 4 이상일 때, 승자는 이전 승자와 다른 사람
+
+# print('SK' if dp[N] == 0 else 'CY')
\ No newline at end of file
diff --git a/woogieon8on/chap9/boj/11403.py b/woogieon8on/chap9/boj/11403.py
new file mode 100644
index 0000000..2c091b3
--- /dev/null
+++ b/woogieon8on/chap9/boj/11403.py
@@ -0,0 +1,31 @@
+from collections import deque
+import sys
+input = sys.stdin.readline
+
+n = int(input())
+
+# 가중치 없는 방향 그래프
+graph = [list(map(int, input().split())) for _ in range(n)]
+
+# 출력 행렬
+matrix = [[0]*n for _ in range(n)]
+
+def bfs(x): # x: 시작점
+
+    queue = deque([x])
+    visited = [False for _ in range(n)] # 방문 여부 리스트 초기화
+
+    while queue:
+        v = queue.popleft()
+
+        for i in range(n): # 현재 정점 v와 연결된 모든 정점 확인
+            if not visited[i] and graph[v][i] == 1: # 정점 i를 방문하지 않았고, v에서 i로의 간선이 존재하는 경우
+                queue.append(i) # 큐에 추가
+                visited[i] = True # 방문 표시
+                matrix[x][i] = 1 # 출력 행렬에 1 표시
+
+for i in range(n): # 각 정점에서 BFS 수행
+    bfs(i)
+
+for i in matrix: # 정답 행렬 출력
+    print(*i)
\ No newline at end of file
diff --git a/woogieon8on/chap9/boj/11404.py b/woogieon8on/chap9/boj/11404.py
new file mode 100644
index 0000000..ba1ef4a
--- /dev/null
+++ b/woogieon8on/chap9/boj/11404.py
@@ -0,0 +1,34 @@
+import sys
+input = sys.stdin.readline
+INF = int(1e9) # 무한
+
+n = int(input())
+m = int(input())
+graph = [[INF] * (n + 1) for _ in range(n + 1)] # 그래프를 표현하기 위한 2차원 리스트 + 모든 값을 무한으로 초기화
+
+# 시작 도시와 도착 도시가 같은 경우 비용은 0으로 초기화
+for a in range(1, n + 1):
+    for b in range(1, n + 1):
+        if a == b:
+            graph[a][b] = 0
+
+for _ in range(m):
+    a, b, c = map(int, input().split()) # 시작 도시 a, 도착 도시 b, 비용 c
+    # 도시와 도시를 연결하는 간선이 여러개 존재하는 경우
+    # 가장 짧은 간선 정보만 저장
+    if c < graph[a][b]:
+        graph[a][b] = c
+
+# 플로이드 알고리즘
+for k in range(1, n + 1):
+    for a in range(1, n + 1):
+        for b in range(1, n + 1):
+            graph[a][b] = min(graph[a][b], graph[a][k] + graph[k][b])
+
+for a in range(1, n + 1):
+    for b in range(1, n + 1):
+        if graph[a][b] == INF: # 도달할 수 없는 경우
+            print(0, end=" ")
+        else:
+            print(graph[a][b], end=" ")
+    print()
\ No newline at end of file
diff --git a/woogieon8on/chap9/boj/1753.py b/woogieon8on/chap9/boj/1753.py
new file mode 100644
index 0000000..d88f097
--- /dev/null
+++ b/woogieon8on/chap9/boj/1753.py
@@ -0,0 +1,38 @@
+import heapq
+import sys
+input = sys.stdin.readline
+INF = int(1e9) # 무한
+
+V, E = map(int, input().split())
+start = int(input())
+
+graph = [[] for i in range(V + 1)] # 각 노드에 연결되어 있는 노드에 대한 정보를 담는 리스트
+distance = [INF] * (V + 1) # 최단 거리 테이블을 모두 무한으로 초기화
+
+for _ in range(E):
+    u, v, w = map(int, input().split()) # u에서 v로 가는 가중치 w인 간선 존재
+    graph[u].append((v, w))
+
+def dijkstra(start): # 다익스트라 알고리즘
+    q = []
+    heapq.heappush(q, (0, start)) # 시작 노드로 가기 위한 최단 경로 0 설정 + 큐에 삽입
+    distance[start] = 0
+
+    while q:
+        dist, now = heapq.heappop(q) # 가장 최단 거리가 짧은 노드 정보 꺼내기
+        if distance[now] < dist: # 현재 노드가 이미 처리된 적이 있는 노드라면 무시
+            continue
+
+        for i in graph[now]: # 현재 노드와 연결된 다른 인접한 노드들 확인
+            cost = dist + i[1]
+            if cost < distance[i[0]]: # 현재 노드를 거쳐 다른 노드로 이동할 때 거리가 더 짧은 경우
+                distance[i[0]] = cost
+                heapq.heappush(q, (cost, i[0]))
+
+dijkstra(start)
+
+for i in range(1, V + 1):
+    if distance[i] == INF: # 경로가 존재하지 않는 경우
+        print("INF")
+    else:
+        print(distance[i])
\ No newline at end of file
diff --git a/woogieon8on/chap9/boj/1916.py b/woogieon8on/chap9/boj/1916.py
new file mode 100644
index 0000000..c0040c9
--- /dev/null
+++ b/woogieon8on/chap9/boj/1916.py
@@ -0,0 +1,38 @@
+from heapq import heappop, heappush
+import sys
+input = sys.stdin.readline
+
+n = int(input())
+m = int(input())
+
+graph = [[] for _ in range(n + 1)] # 버스 노선 그래프
+INF = 1e9
+dp = [INF for _ in range(n + 1)] # 도시에 도착하는 최소비용 리스트
+
+for i in range(m):
+    s, e, cost = map(int, input().split()) # 버스 노선 - 시작 도시, 도착 도시, 버스 비용
+    graph[s].append((e, cost))
+
+start, target = map(int, input().split()) # 출발점, 목적지
+
+def dijkstra(x): # x: 출발점
+
+    dp[x] = 0 # 출발점의 도착 비용은 0
+    heap = []
+    heappush(heap, [0, x]) # [비용, 출발점] 힙에 push
+
+    while heap:
+        cost, point = heappop(heap)
+
+        if dp[point] < cost: # 최소 비용 리스트의 해당 도시 비용이 더 적다면 무시
+            continue
+
+        for t, v in graph[point]: # 해당 좌표에서 출발하는 모든 버스 노선
+            new_cost = cost + v # 지금까지의 비용 + 해당 노선 경로
+
+            if dp[t] > new_cost: # 최소 비용 리스트에 저장된 도착 도시까지의 비용보다 계산된 비용이 더 적은 경우
+                dp[t] = new_cost # 최소 비용 갱신
+                heappush(heap, [new_cost, t]) # [계산된 비용, 도착 도시] 힙에 push
+
+dijkstra(start) # 출발점으로부터 다익스트라 알고리즘 적용
+print(dp[target]) # 목적지 최소 비용 값 출력
\ No newline at end of file
diff --git a/woogieon8on/chap9/boj/2606.py b/woogieon8on/chap9/boj/2606.py
new file mode 100644
index 0000000..851569a
--- /dev/null
+++ b/woogieon8on/chap9/boj/2606.py
@@ -0,0 +1,32 @@
+from collections import deque
+import sys
+input = sys.stdin.readline
+
+v = int(input())
+e = int(input())
+
+# 네트워크 구성 그래프
+graph = [[] for _ in range(v+1)]
+for _ in range(e):
+    a, b = map(int, input().split())
+    graph[a].append(b)
+    graph[b].append(a)
+
+
+def bfs(x):
+    queue = deque([x]) # x: 시작점
+    count = 0
+    visited[x] = True # 시작점 방문 표시
+
+    while queue:
+        node = queue.popleft()
+        for next_node in graph[node]: # 현재 컴퓨터에 연결된 모든 컴퓨터
+            if not visited[next_node]: # 방문하지 않은 컴퓨터인 경우
+                visited[next_node] = True # 방문 표시
+                queue.append(next_node) # 큐에 추가
+                count += 1 # 감염된 컴퓨터 수 증가
+
+    return count
+
+visited = [False for _ in range(v+1)] # 방문 여부 리스트 초기화
+print(bfs(1)) # 시작점: 1
\ No newline at end of file
diff --git a/woogieon8on/etc/boj/10844.py b/woogieon8on/etc/boj/10844.py
new file mode 100644
index 0000000..4ebbb14
--- /dev/null
+++ b/woogieon8on/etc/boj/10844.py
@@ -0,0 +1,22 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input())
+
+# DP 테이블 초기화
+# d[i][j]: i자리 숫자 중 마지막 자릿수가 j인 계단 수의 개수
+d = [[0] * 10 for _ in range(n+1)]
+
+for i in range(1, 10):
+    d[1][i] = 1 # 한 자리 숫자의 경우(1~9) 각 숫자는 자체로 계단 수
+    
+for i in range(2, n+1):
+    for j in range(10): # j: 마지막 자릿수(0~9)
+        if j == 0:
+            d[i][j] = d[i-1][1] # 앞자리 수가 1인 경우만 가능
+        elif 1 <= j <= 8:
+            d[i][j] = d[i-1][j-1] + d[i-1][j+1] # 앞자리 수가 j-1 또는 j+1인 경우 가능
+        else:
+            d[i][j] = d[i-1][8] # 앞자리 수가 8인 경우만 가능
+            
+print(sum(d[n]) % 1000000000) # n자리 계단 수의 총 개수를 1,000,000,000로 나눈 나머지
\ No newline at end of file
diff --git a/woogieon8on/etc/boj/1439.py b/woogieon8on/etc/boj/1439.py
new file mode 100644
index 0000000..efce14f
--- /dev/null
+++ b/woogieon8on/etc/boj/1439.py
@@ -0,0 +1,11 @@
+import sys
+input = sys.stdin.readline
+
+s = input().strip()
+cnt = 0 # 행동 횟수
+
+for i in range(len(s)-1):
+    if s[i] != s[i+1]: # 현재 문자와 다음 문자가 다른 경우 -> 뒤집기
+        cnt += 1 # 행동 횟수 증가
+
+print((cnt+1)//2) # 뒤집는 횟수 절반으로 줄여 행동 최소 횟수 도출 가능
\ No newline at end of file
diff --git a/woogieon8on/etc/boj/15903.py b/woogieon8on/etc/boj/15903.py
new file mode 100644
index 0000000..ec39c3d
--- /dev/null
+++ b/woogieon8on/etc/boj/15903.py
@@ -0,0 +1,25 @@
+import sys
+import heapq
+input = sys.stdin.readline
+
+n, m = map(int, input().split())
+
+# 최소 힙 생성
+cards = []
+
+card_list = [int(x) for x in input().split()]
+for card in card_list:
+    heapq.heappush(cards, card)
+
+for _ in range(m): # 카드 합체 m번 진행
+
+    # 가장 작은 값을 가진 카드 꺼내기
+    card1 = heapq.heappop(cards)
+    card2 = heapq.heappop(cards)
+
+    # 두 카드를 더한 값을 각 카드에 덮어쓰기
+    heapq.heappush(cards, card1 + card2)
+    heapq.heappush(cards, card1 + card2)
+
+# 최종적으로 남은 카드의 값들을 더해 결과 출력
+print(sum(cards))
\ No newline at end of file
diff --git a/woogieon8on/etc/boj/17835.py b/woogieon8on/etc/boj/17835.py
new file mode 100644
index 0000000..f66a73d
--- /dev/null
+++ b/woogieon8on/etc/boj/17835.py
@@ -0,0 +1,46 @@
+import sys
+import heapq
+input = sys.stdin.readline
+
+N, M, K = map(int, input().split())
+
+arr = [[] for _ in range(N+1)] # 도시 정보 리스트
+
+for i in range(M):
+    a, b, cost = map(int, input().split())
+    arr[b].append([a, cost]) # b 도시에서 a 도시로 이동하는 비용이 cost
+
+targets = list(map(int, input().split())) # 면접장 정보 리스트
+
+def dijkstra():
+    h = [] # 최소 힙 생성
+
+    # 모든 면접장을 시작점으로 설정
+    for t in targets:
+        heapq.heappush(h, [0, t]) # 면접장 도시는 거리 0으로 시작
+        result[t] = 0
+
+    while h:
+        cost, city = heapq.heappop(h) # 현재 힙에서 가장 작은 비용의 도시 꺼냄
+
+        if result[city] < cost: # 각 도시에 대한 최단 거리 정보가 현재 비용보다 적은 경우 무시
+            continue
+
+        for next_city, next_cost in arr[city]: # 현재 도시에서 이동할 수 있는 모든 도시
+            if cost + next_cost < result[next_city]: # 더 짧은 비용 갱신
+                result[next_city] = cost+next_cost
+                heapq.heappush(h, [cost+next_cost, next_city]) # 힙에 추가
+
+max_start, max_cost = 0, 0 # 가장 먼 도시, 그 거리
+
+result = [int(1e11)] * (N+1) # 결과 초기값 매우 큰 수(도달할 수 없는 경우)로 설정
+
+dijkstra() # 면접장에서 다른 도시로 가는 최단 거리 계산
+
+for i, r in enumerate(result): # enumerate(): 리스트의 각 요소와 그 요소의 인덱스 함께 반환
+    if r > max_cost and r != int(1e11): # 가장 큰 값 갱신(도달할 수 없는 경우 제외)
+        max_start, max_cost = i, r
+
+# 면접장에서 가장 먼 도시와 그 거리 출력        
+print(max_start)
+print(max_cost)
\ No newline at end of file
diff --git a/woogieon8on/etc/boj/2468.py b/woogieon8on/etc/boj/2468.py
new file mode 100644
index 0000000..c1b8afa
--- /dev/null
+++ b/woogieon8on/etc/boj/2468.py
@@ -0,0 +1,52 @@
+import sys
+input = sys.stdin.readline
+from collections import deque
+
+N = int(input())
+graph = [list(map(int, input().split())) for _ in range(N)]
+high = 0
+
+# 그래프 내에서 가장 높은 지점 찾기 -> 물의 높이 설정 기준
+for i in range(N):
+    for j in range(N):
+        if graph[i][j] > high:
+            high = graph[i][j]
+
+dx, dy = [0,0,-1,1], [-1,1,0,0] # 이동 벡터
+
+def bfs(i,j, high):
+    queue = deque()
+    queue.append((i,j))
+    visited[i][j] = 1 # 현재 위치 방문 처리
+
+    while queue:
+        x, y = queue.popleft()
+
+        for i in range(4): # 현재 위치에서 상하좌우로 이동 가능한 모든 위치 탐색
+            nx = dx[i] + x
+            ny = dy[i] + y
+
+            if nx < 0 or nx >= N or ny < 0 or ny >= N: # 범위 벗어나는 경우 무시
+                continue
+            
+            # 이동한 위치가 안전 영역인지 확인
+            # 방문하지 않은 곳이라면 방문 처리 후 큐에 추가
+            if graph[nx][ny] > high and visited[nx][ny] == 0:
+                visited[nx][ny] = 1
+                queue.append((nx,ny))
+
+result = 0
+for k in range(high):
+    visited = [[0] * N for _ in range(N)] # 각 물의 높이에서 방문 여부 초기화
+    ans = 0
+
+    for i in range(N):
+        for j in range(N):
+            if graph[i][j] > k and visited[i][j] == 0: # 현재 높이에서 안전한 영역 찾기
+                bfs(i,j, k) # 연결된 영역 탐색
+                ans += 1 # 안전 영역의 개수 증가
+    
+    if result < ans: # 가장 많은 안전 영역의 개수 갱신
+        result = ans
+
+print(result)
\ No newline at end of file
diff --git a/woogieon8on/etc/boj/6593.py b/woogieon8on/etc/boj/6593.py
new file mode 100644
index 0000000..01ed23f
--- /dev/null
+++ b/woogieon8on/etc/boj/6593.py
@@ -0,0 +1,66 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+# 이동 방향 (동,서,남,북,상,하)
+dx = [1, -1, 0, 0, 0, 0]
+dy = [0, 0, 1, -1, 0, 0]
+dz = [0, 0, 0, 0, -1, 1]
+
+def bfs(x, y, z, e1, e2, e3):
+    que = deque() 
+    que.append((x, y, z))  # 시작 지점 큐에 추가
+    visited[x][y][z] = 0  # 시작 지점 방문 표시 및 거리 0으로 초기화
+    
+    while que:
+        x, y, z = que.popleft()  # 큐에서 현재 위치 꺼냄
+        
+        if x == e1 and y == e2 and z == e3: # 현재 위치가 종료 지점과 동일한 경우
+            return visited[x][y][z] # 현재 위치 반환
+        
+        # 6개의 방향으로 이동 시도
+        for i in range(6):
+            nx = x + dx[i]
+            ny = y + dy[i]
+            nz = z + dz[i]
+            
+            if 0 <= nx < s and 0 <= ny < n and 0 <= nz < m: # 범위 확인
+                if visited[nx][ny][nz] == -1 and (maps[nx][ny][nz] == '.' or maps[nx][ny][nz] == 'E'): # 방문하지 않았고, 이동할 수 있는 위치인 경우
+                    que.append((nx, ny, nz))  # 큐에 다음 위치 추가
+                    visited[nx][ny][nz] = visited[x][y][z] + 1  # 이동 거리를 기록
+    
+    return -1 # 종료 지점에 도달하지 못한 경우
+
+while True:
+    
+    s, n, m = map(int, input().split())
+    
+    if s == 0 and n == 0 and m == 0: # 종료 조건
+        break
+    
+    visited = [[[-1 for _ in range(m)]for _ in range(n)]for _ in range(s)] # 방문 배열(-1: 방문하지 않음)
+    
+    maps = [] # 미로의 각 층을 저장할 배열
+    
+    for _ in range(s):
+        temp1 = []
+        for i in range(n + 1):
+            temp2 = list(input().rstrip('\n')) # 줄 바꿈 문자 제거
+            if i != n:  # 마지막 줄은 공백 줄이므로 제외
+                temp1.append(temp2)
+        maps.append(temp1)
+    
+    for i in range(s):
+        for j in range(n):
+            for k in range(m):
+                if maps[i][j][k] == 'S':
+                    x, y, z = i, j, k  # 시작 지점
+                elif maps[i][j][k] == 'E':
+                    e1, e2, e3 = i, j, k  # 종료 지점
+    
+    time = bfs(x, y, z, e1, e2, e3) # BFS 호출하여 탈출 시간 계산
+    
+    if time == -1:
+        print("Trapped!")  # 탈출할 수 없는 경우
+    else:
+        print("Escaped in", time, "minute(s).")  # 탈출에 성공한 경우
\ No newline at end of file