[2023-08-16] wooyeol #112

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())

BOJ/빙산/wooyeol.py

@@ -0,0 +1,99 @@
+"""
+ 빙산
+ https://www.acmicpc.net/problem/2573
+
+ 풀이시간
+ 10:33 ~ 14:12 (풀이 실패) + 4시간 (풀이 성공)
+
+ 접근법
+ 무슨 알고리즘으로 풀이 할 수 있을까? BFS
+
+ 시간 초과와 메모리 초과로 실패했습니다. -> 리뷰를 보며 다시 풀이를 진행하여 풀이해낼 수 있었습니다.
+
+ - 빙산 테이블을 만들면서 빙산의 위치를 덱에 기억시켜놓고 첫 요소를 기점으로 BFS로 진행합니다.
+ - BFS 연산을 거치며 해당 빙산 주변 바다의 갯수를 통해 빙산의 높이를 조절합니다.
+ - 하나의 빙산 덩어리는 첫 요소를 기점으로 BFS를 진행하였을 때 모든 요소를 탐색 할 수 있습니다. 
+ - 혹시라도 빙산의 위치를 저장시킨 덱의 요소를 다 검사하였을 때 한 번 더 BFS 탐색을 한다면 두 개의 빙산 덩어리가 발생하였다는 것 이므로 현재 연도를 반환
+ - 만약 BFS 연산이 일어나지 않았다면 0개의 덩어리라는 것이므로 0을 반환
+"""
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+R, C = map(int, input().split())
+
+iceberg_queue: deque = deque()
+
+iceberg: list = list()
+
+# 빙산 데이터 입력 받기
+for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ iceberg_queue.append((0, r, c))
+ iceberg.append(data)
+
+
+def bfs(x: int, y: int):
+ q: deque = deque([(x, y)])
+ visited[x][y] = True
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ while q:
+ x, y = q.popleft()
+
+ # 4방향으로 탐색
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 방문 빙산인지 확인
+ if (0 <= nx < R) and (0 <= ny < C) and not visited[nx][ny]:
+ # 주변에 바다가 있는지 확인하고 해당 칸이 바다인지도 확인
+ if iceberg[nx][ny] == 0 and iceberg[x][y] != 0:
+ iceberg[x][y] -= 1
+
+ # 주변에 바다가 아닌 빙산이 있다면 다음 탐색을 위해 큐에 삽입
+ if iceberg[nx][ny] != 0:
+ visited[nx][ny] = True
+ q.append((nx, ny))
+
+ # 4방향으로 바다를 검사했음에도 빙산이 녹지 않았다면 빙산 덱에 추가
+ if iceberg[x][y] != 0:
+ iceberg_queue.append((current_year + 1, x, y))
+
+ return 1
+
+
+current_year = 0
+while True:
+ cnt = 0
+ visited = [[False] * C for _ in range(R)]
+
+ # print(f"\niceberg queue : {iceberg_queue}")
+ # print(f"current_year : {current_year}\n")
+ # for row in iceberg:
+ # print(*row)
+
+ while iceberg_queue and iceberg_queue[0][0] == current_year:
+ y, r, c = iceberg_queue.popleft()
+ if iceberg[r][c] and not visited[r][c]:
+ cnt += bfs(r, c)
+
+ # 빙산 덩어리 갯수가 2개 이상이 된다면 종료
+ if cnt > 1:
+ print(current_year)
+ break
+ # 빙산 덩어리가 0개가 된다면 종료
+ elif cnt == 0:
+ print(0)
+ break
+ # 빙산 덩어리가 1개라면 다시 다음해로 이동
+ current_year += 1

BOJ/빙산/wooyeol2.py

@@ -0,0 +1,110 @@
+# 메모리 초과로 인하여 실패나는 코드
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def check_cycle(R: int, C: int, start_point: tuple, iceberg_count: int, iceberg: list):
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+ count: int = 1
+ visited = [[False] * C for _ in range(R)]
+ s_queue = deque([start_point])
+
+ while s_queue:
+ tx, ty = s_queue.popleft()
+ visited[tx][ty] = True
+ for dtx, dty in directions:
+ ntx, nty = tx + dtx, ty + dty
+
+ # 범위 검증
+ if 0 <= ntx < R and 0 <= nty < C:
+ if not visited[ntx][nty] and iceberg[ntx][nty]:
+ s_queue.append((ntx, nty))
+ count += 1
+
+ # 하나의 점으로부터 bfs 탐색을 했을 때 모든 점이 카운트 되지 않았다면 2개 이상의 cycle이 생긴 것으로 확인
+ if iceberg_count != count:
+ return True
+ return False
+
+
+def solution(R: int, C: int, iceberg: list, queue: deque):
+ iceberg_count = len(queue)
+
+ pre_year: int = 0
+
+ directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+
+ record_iceberg: list = [item[:] for item in iceberg]
+
+ while queue:
+ year, x, y = queue.popleft()
+
+ if year > pre_year:
+ iceberg = [item[:] for item in record_iceberg]
+ start_point = (x, y)
+
+ # 2개 이상의 덩어리가 생겼는지 확인
+ if check_cycle(R, C, start_point, iceberg_count, iceberg):
+ return year + 1
+
+ # 4방향으로 탐색하며 빙산 값 업데이트
+ temp_count = 0
+ for dx, dy in directions:
+ nx, ny = x + dx, y + dy
+
+ # 범위 검증
+ if 0 <= nx < R and 0 <= ny < C:
+ # 0이라면
+ if iceberg[nx][ny] == 0:
+ # 낮아지는 빙하 갯수 카운트
+ temp_count += 1
+
+ # 업데이트 된 빙산 높이 업데이트
+ record_iceberg[x][y] = max(0, iceberg[x][y] - temp_count)
+
+ # 작업 큐 업데이트
+ if record_iceberg[x][y]:
+ queue.append(((year + 1), x, y))
+ else:
+ iceberg_count -= 1
+
+ pre_year = year
+
+ # print()
+ # print(queue)
+ # for tr in iceberg:
+ # print(*tr)
+ # print()
+ # for tf in record_iceberg:
+ # print(*tf)
+ # print()
+
+ return 0
+
+
+def main():
+ R, C = map(int, input().split())
+
+ queue: deque = deque()
+
+ iceberg: list = list()
+
+ # 빙산 데이터 입력 받기
+ for r in range(R):
+ data = list(map(int, input().split()))
+ checksum = sum(data)
+ # 빙산의 높이 값이 존재한다면
+ if checksum > 0:
+ for c in range(C):
+ # 작업 큐 업데이트 (year, row, col)
+ if data[c] != 0:
+ queue.append((0, r, c))
+ iceberg.append(data)
+
+ return solution(R, C, iceberg, queue)
+
+
+print(main())