@@ -0,0 +1,5 @@
+"""
+프로그래머스. 이중 우선순위 큐
+https://school.programmers.co.kr/learn/courses/30/lessons/42628
+유형: Priority Queue
+"""
@@ -43,27 +43,30 @@ def solution(jobs):
 """
 import heapq
 
-
 def solution(jobs):
-   answer = 0
-   now = 0  # 현재시간
-   i = 0  # 처리개수
-   start = -1  # 마지막 완료시간
-   heap = []
+   jobs.sort()     # 요청시간 기준 정렬
+   job_len = len(jobs)
+   i = 0           # jobs 인덱스
+   end_time = 0    # 현재 시간
+   return_time = 0 # 작업 반환 시간
+   count = 0       # 작업 처리한 개수
 
-   while i < len(jobs):
-       for job in jobs:
-           if start < job[0] <= now:
-               heapq.heappush(heap, [job[1], job[0]])
+   heap = []
 
-       if heap:
-           current = heapq.heappop(heap)
-           start = now
-           now += current[0]
-           answer += now - current[1]  # 요청으로부터 처리시간
+   while count < job_len:
+       # 현재 시간에 요청된 작업 처리
+       while i < job_len and jobs[i][0] <= end_time:
+           heapq.heappush(heap, (jobs[i][1], jobs[i][0], i))  # 소요시간, 요청시간, 작업번호 순서
            i += 1
-       else:
-           now += 1
 
-   return answer // len(jobs)
+       # 대기 큐에 작업이 있다면, 시간을 업데이트한다.
+       if len(heap) > 0:
+           work_time, start_time, num = heapq.heappop(heap)
+           end_time += work_time
+           return_time += end_time - start_time
+           count += 1
+       else:
+           # 대기 큐가 비었다면, 다음 작업이 올 때까지 기다려야 한다.
+           end_time = jobs[i][0]
 
+   return return_time // job_len
@@ -0,0 +1,72 @@
+"""
+프로그래머스. 디스크 컨트롤러
+https://school.programmers.co.kr/learn/courses/30/lessons/42627
+유형: Priority Queue
+"""
+"""
+풀이1
+"""
+import heapq
+
+def solution(jobs):
+   jobs.sort()     # 요청시간 기준 정렬
+   job_len = len(jobs)
+   i = 0           # jobs 인덱스
+   end_time = 0    # 현재 시간
+   return_time = 0 # 작업 반환 시간
+   count = 0       # 작업 처리한 개수
+
+   heap = []
+
+   while count < job_len:
+       # 현재 시간에 요청된 작업 처리
+       while i < job_len and jobs[i][0] <= end_time:
+           heapq.heappush(heap, (jobs[i][1], jobs[i][0], i))  # 소요시간, 요청시간, 작업번호 순서
+           i += 1
+
+       # 대기 큐에 작업이 있다면, 시간을 업데이트한다.
+       if len(heap) > 0:
+           work_time, start_time, num = heapq.heappop(heap)
+           end_time += work_time
+           return_time += end_time - start_time
+           count += 1
+       else:
+           # 대기 큐가 비었다면, 다음 작업이 올 때까지 기다려야 한다.
+           end_time = jobs[i][0]
+
+   return return_time // job_len
+
+
+"""
+풀이2
+출처: https://velog.io/@kiwoong96/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4PythonLevel3-%EB%94%94%EC%8A%A4%ED%81%AC-%EC%BB%A8%ED%8A%B8%EB%A1%A4%EB%9F%AC
+"""
+import heapq
+
+def solution(jobs):
+   jobs.sort()     # 요청시간 기준 정렬
+   job_len = len(jobs)
+   i = 0           # jobs 인덱스
+   end_time = 0    # 현재 시간
+   return_time = 0 # 작업 반환 시간
+   count = 0       # 작업 처리한 개수
+
+   heap = []
+
+   while count < job_len:
+       # 현재 시간에 요청된 작업 처리
+       while i < job_len and jobs[i][0] <= end_time:
+           heapq.heappush(heap, (jobs[i][1], jobs[i][0], i))  # 소요시간, 요청시간, 작업번호 순서
+           i += 1
+
+       # 대기 큐에 작업이 있다면, 시간을 업데이트한다.
+       if len(heap) > 0:
+           work_time, start_time, num = heapq.heappop(heap)
+           end_time += work_time
+           return_time += end_time - start_time
+           count += 1
+       else:
+           # 대기 큐가 비었다면, 다음 작업이 올 때까지 기다려야 한다.
+           end_time = jobs[i][0]
+
+   return return_time // job_len
@@ -0,0 +1,100 @@
+"""
+BOJ #2468. 안전 영역 (실버2)
+https://www.acmicpc.net/problem/2468
+유형: Graph, DFS, BFS
+"""
+
+"""
+DFS 풀이
+"""
+import sys
+sys.setrecursionlimit(100000)
+
+input = sys.stdin.readline
+
+
+directions = [(-1, 0), (0, 1), (1, 0), (0, -1)]
+def dfs(x, y):
+    visited[x][y] = True
+    for dx, dy in directions:
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < N and 0 <= ny < N and \
+                not visited[nx][ny] and map[nx][ny] > h:
+            dfs(nx, ny)
+
+
+N = int(input())
+map = [list(map(int, input().split())) for _ in range(N)]
+max_height = 0
+
+# 맵 내의 최대값 구하기
+for m in map:
+    max_height = max(max_height, max(m))
+
+answer = 0
+
+for h in range(0, max_height + 1): # 물이 잠기지 않는 상황을 고려하여 0부터 시작한다.
+    visited = [[False for _ in range(N)] for _ in range(N)]
+    count = 0
+
+    for i in range(N):
+        for j in range(N):
+            if not visited[i][j] and map[i][j] > h:
+                dfs(i, j)
+                count += 1
+
+    answer = max(answer, count)
+
+print(answer)
+
+"""
+BFS 풀이
+"""
+from collections import deque
+
+n = int(input())
+graph = []
+maxNum = 0
+
+for i in range(n):
+    graph.append(list(map(int, input().split())))
+    for j in range(n):
+        if graph[i][j] > maxNum:
+            maxNum = graph[i][j]
+
+dx = [0, 0, 1, -1]
+dy = [1, -1, 0, 0]
+
+
+def bfs(a, b, value, visited):
+    q = deque()
+    q.append((a, b))
+    visited[a][b] = 1
+
+    while q:
+        x, y = q.popleft()
+
+        for i in range(4):
+            nx = x + dx[i]
+            ny = y + dy[i]
+            if 0 <= nx < n and 0 <= ny < n:
+                if graph[nx][ny] > value and visited[nx][ny] == 0:
+                    visited[nx][ny] = 1
+                    q.append((nx, ny))
+
+
+result = 0
+for i in range(maxNum):
+    visited = [[0] * n for i in range(n)]
+    cnt = 0
+
+    for j in range(n):
+        for k in range(n):
+            if graph[j][k] > i and visited[j][k] == 0:
+                bfs(j, k, i, visited)
+                cnt += 1
+
+    if result < cnt:
+        result = cnt
+
+print(result)
@@ -0,0 +1,103 @@
+"""
+PGS #81032. 거리두기 확인하기 (Level 2)
+https://school.programmers.co.kr/learn/courses/30/lessons/81302
+유형: Brute Force, Graph, BFS
+"""
+
+"""
+풀이1: 완전 탐색
+"""
+
+
+def solution(places):
+    def is_safe(place):
+        for i in range(5):
+            for j in range(5):
+                if place[i][j] != 'P':
+                    continue
+
+                for dx, dy in dirs:
+                    ni, nj = i + dx, j + dy
+                    if not (0 <= ni < 5 and 0 <= nj < 5):
+                        continue
+                    if place[ni][nj] != 'P':
+                        continue
+
+                    dist = abs(dx) + abs(dy)
+                    if dist == 1:
+                        return 0  # 거리 1에서 바로 P면 위반
+                    elif dist == 2:
+                        # 파티션 여부 확인
+                        if dx == 0:  # 수평
+                            if place[i][j + dy // 2] != 'X':
+                                return 0
+                        elif dy == 0:  # 수직
+                            if place[i + dx // 2][j] != 'X':
+                                return 0
+                        else:  # 대각선
+                            if place[i][nj] != 'X' or place[ni][j] != 'X':
+                                return 0
+        return 1
+
+    dirs = [
+        (-1, 0), (1, 0), (0, -1), (0, 1),  # 거리 1
+        (-2, 0), (2, 0), (0, -2), (0, 2),  # 일직선 거리 2
+        (-1, -1), (-1, 1), (1, -1), (1, 1)  # 대각선 거리 2
+    ]
+
+    answer = []
+    for place in places:
+        answer.append(is_safe(place))
+
+    return answer
+
+
+"""
+풀이2: BFS
+"""
+from collections import deque
+
+
+def bfs(p):
+    start = []
+
+    for i in range(5):  # 시작점이 되는 P 좌표 구하기
+        for j in range(5):
+            if p[i][j] == 'P':
+                start.append([i, j])
+
+    for s in start:
+        queue = deque([s])  # 큐에 초기값
+        visited = [[0] * 5 for i in range(5)]  # 방문 처리 리스트
+        distance = [[0] * 5 for i in range(5)]  # 경로 길이 리스트
+        visited[s[0]][s[1]] = 1
+
+        while queue:
+            y, x = queue.popleft()
+
+            dx = [-1, 1, 0, 0]  # 좌우
+            dy = [0, 0, -1, 1]  # 상하
+
+            for i in range(4):
+                nx = x + dx[i]
+                ny = y + dy[i]
+
+                if 0 <= nx < 5 and 0 <= ny < 5 and visited[ny][nx] == 0:
+
+                    if p[ny][nx] == 'O':
+                        queue.append([ny, nx])
+                        visited[ny][nx] = 1
+                        distance[ny][nx] = distance[y][x] + 1
+
+                    if p[ny][nx] == 'P' and distance[y][x] <= 1:
+                        return 0
+    return 1
+
+
+def solution(places):
+    answer = []
+
+    for i in places:
+        answer.append(bfs(i))
+
+    return answer