반응형

마법사 상어와 파이어볼

티어 : Gold 4
시간 제한 : 1 초
메모리 제한 : 512 MB
알고리즘 분류 : 구현, 시뮬레이션

 

문제

어른 상어가 마법사가 되었고, 파이어볼을 배웠다.

마법사 상어가 크기가 N×N인 격자에 파이어볼 M개를 발사했다. 가장 처음에 파이어볼은 각자 위치에서 이동을 대기하고 있다. i번 파이어볼의 위치는 (ri, ci), 질량은 mi이고, 방향은 di, 속력은 si이다. 위치 (r, c)는 r행 c열을 의미한다.

격자의 행과 열은 1번부터 N번까지 번호가 매겨져 있고, 1번 행은 N번과 연결되어 있고, 1번 열은 N번 열과 연결되어 있다.

파이어볼의 방향은 어떤 칸과 인접한 8개의 칸의 방향을 의미하며, 정수로는 다음과 같다.

마법사 상어가 모든 파이어볼에게 이동을 명령하면 다음이 일들이 일어난다.

  1. 모든 파이어볼이 자신의 방향 di로 속력 si칸 만큼 이동한다.
    • 이동하는 중에는 같은 칸에 여러 개의 파이어볼이 있을 수도 있다.
  2. 이동이 모두 끝난 뒤, 2개 이상의 파이어볼이 있는 칸에서는 다음과 같은 일이 일어난다.
    1. 같은 칸에 있는 파이어볼은 모두 하나로 합쳐진다.
    2. 파이어볼은 4개의 파이어볼로 나누어진다.
    3. 나누어진 파이어볼의 질량, 속력, 방향은 다음과 같다.
      1. 질량은 ⌊(합쳐진 파이어볼 질량의 합)/5⌋이다.
      2. 속력은 ⌊(합쳐진 파이어볼 속력의 합)/(합쳐진 파이어볼의 개수)⌋이다.
      3. 합쳐지는 파이어볼의 방향이 모두 홀수이거나 모두 짝수이면, 방향은 0, 2, 4, 6이 되고, 그렇지 않으면 1, 3, 5, 7이 된다.
    4. 질량이 0인 파이어볼은 소멸되어 없어진다.

마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 구해보자.

 

입력

첫째 줄에 N, M, K가 주어진다.

둘째 줄부터 M개의 줄에 파이어볼의 정보가 한 줄에 하나씩 주어진다. 파이어볼의 정보는 다섯 정수 ri, ci, mi, si, di로 이루어져 있다.

서로 다른 두 파이어볼의 위치가 같은 경우는 입력으로 주어지지 않는다.

 

출력

마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 출력한다.

 

제한

  • 4 ≤ N ≤ 50
  • 0 ≤ M ≤ N2
  • 1 ≤ K ≤ 1,000
  • 1 ≤ ri, ci ≤ N
  • 1 ≤ mi ≤ 1,000
  • 1 ≤ si ≤ 1,000
  • 0 ≤ di ≤ 7

 

예제 입출력


Algorithm

구현 - Simulation
1. 리스트에 명령들 담음
2. 모든 파이어볼 이동
    ☞ graph에 각 칸마다 존재하는 파이어볼의 개수 갱신
3. 그래프 전체를 보면서 값이 2 이상인 경우 질량, 속력, 방향 계산해 명령을 담는 리스트에 추가
    ☞ 질량이 0이면 추가하지 않음
4. K번째 명령이 끝아면 질량의 총합 구함

 

Code

import sys
input = sys.stdin.readline

N, M, K = map(int, input().split())
graph = [[[] for _ in range(N)] for _ in range(N)]
orders = []
for _ in range(M):
    r, c, m, s, d = map(int, input().split())
    orders.append((r-1, c-1, m, s, d))
    graph[r-1][c-1].append((m, s, d))

# 상, 우상향, 우, 우하향, 하, 좌하향, 좌, 좌상향
directions = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
for count in range(K):
    # 파이어볼 이동
    for r, c, m, s, d in orders:
        dx = directions[d][0] * s
        dy = directions[d][1] * s
        graph[r][c] = graph[r][c][1:]
        graph[(r+dx)%N][(c+dy)%N].append((m, s, d))
      
    orders = []
    for x in range(N):
        for y in range(N):
            # 파이어볼이 1개인 칸은 다음 명령에 추가
            if len(graph[x][y]) == 1:
                m, s, d = graph[x][y][0]
                orders.append((x, y, m, s, d))
            # 파이어볼이 2개 이상인 칸에서
            elif len(graph[x][y]) > 1:
                # 질량, 속력, 방향 구하기
                sum_m = 0
                sum_s = 0
                check_d = [0, 0]
                for m, s, d in graph[x][y]:
                    sum_m += m
                    sum_s += s
                    check_d[d%2] += 1
                    
                m = sum_m // 5
                # 질량이 0인 파이어볼 소멸
                if m == 0:
                    graph[x][y] = []
                    continue
                
                s = sum_s // len(graph[x][y])
                
                # 파이어볼 뱡향이 모두 홀수이거나 짝수이면 0, 2, 4, 6
                graph[x][y] = []
                if check_d[0] * check_d[1] == 0:
                    for d in range(0, 7, 2):
                        orders.append((x, y, m, s, d))
                        graph[x][y].append((m, s, d))
                else:
                    for d in range(1, 8, 2):
                        orders.append((x, y, m, s, d))
                        graph[x][y].append((m, s, d))

# graph에 있는 질량의 합 구하기
answer = 0
for x in range(N):
    for y in range(N):
        for m, s, d in graph[x][y]:
            answer += m
print(answer)

메모리: 31860 KB
시간: 1236 ms

반응형

'백준 > Python' 카테고리의 다른 글

[백준 1158] 요세푸스 문제 Python  (0) 2022.04.21
[백준 10845] 큐 Python  (0) 2022.04.20
[백준 2636] 치즈 Python  (0) 2022.04.20
[백준 1743] 음식물 피하기 Python  (0) 2022.04.15
[백준 18429] 근손실 Python  (0) 2022.04.15
반응형

치즈

티어 : Gold 5
시간 제한 : 1 초
메모리 제한 : 128 MB
알고리즘 분류 : 구현, 그래프 이론, 그래프 탐색, 너비 우선 탐색, 시뮬레이션

 

문제

아래 <그림 1>과 같이 정사각형 칸들로 이루어진 사각형 모양의 판이 있고, 그 위에 얇은 치즈(회색으로 표시된 부분)가 놓여 있다. 판의 가장자리(<그림 1>에서 네모 칸에 X친 부분)에는 치즈가 놓여 있지 않으며 치즈에는 하나 이상의 구멍이 있을 수 있다.

이 치즈를 공기 중에 놓으면 녹게 되는데 공기와 접촉된 칸은 한 시간이 지나면 녹아 없어진다. 치즈의 구멍 속에는 공기가 없지만 구멍을 둘러싼 치즈가 녹아서 구멍이 열리면 구멍 속으로 공기가 들어가게 된다. <그림 1>의 경우, 치즈의 구멍을 둘러싼 치즈는 녹지 않고 ‘c’로 표시된 부분만 한 시간 후에 녹아 없어져서 <그림 2>와 같이 된다.

 

<그림 1> 원래 치즈 모양

다시 한 시간 후에는 <그림 2>에서 ‘c’로 표시된 부분이 녹아 없어져서 <그림 3>과 같이 된다.

<그림 2> 한 시간 후의 치즈 모양
<그림 3> 두 시간 후의 치즈 모양

<그림 3>은 원래 치즈의 두 시간 후 모양을 나타내고 있으며, 남은 조각들은 한 시간이 더 지나면 모두 녹아 없어진다. 그러므로 처음 치즈가 모두 녹아 없어지는 데는 세 시간이 걸린다. <그림 3>과 같이 치즈가 녹는 과정에서 여러 조각으로 나누어 질 수도 있다.

입력으로 사각형 모양의 판의 크기와 한 조각의 치즈가 판 위에 주어졌을 때, 공기 중에서 치즈가 모두 녹아 없어지는 데 걸리는 시간과 모두 녹기 한 시간 전에 남아있는 치즈조각이 놓여 있는 칸의 개수를 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에는 사각형 모양 판의 세로와 가로의 길이가 양의 정수로 주어진다. 세로와 가로의 길이는 최대 100이다. 판의 각 가로줄의 모양이 윗 줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다. 치즈가 없는 칸은 0, 치즈가 있는 칸은 1로 주어지며 각 숫자 사이에는 빈칸이 하나씩 있다.

 

출력

첫째 줄에는 치즈가 모두 녹아서 없어지는 데 걸리는 시간을 출력하고, 둘째 줄에는 모두 녹기 한 시간 전에 남아있는 치즈조각이 놓여 있는 칸의 개수를 출력한다.

 

예제 입출력


Algorithm

DFS - 재귀, 구현
1. 1시간마다 DFS를 이용해 치즈에 구멍이 있는지 확인
    ☞ 0으로된 덩어리가 2개 이상인 경우 구멍 존재
2. 구멍이 존재하면 구멍에 해당하는 칸의 값을 H로 변경
3. graph를 한 번씩 돌면서 현재 위치가 1인데 상, 하, 좌, 우 중 한 칸이라도 0이 존재하면 이번에 삭제되는 칸
    ☞ 해당 칸의 값을 C로 변경
4. 매 번 C의 개수와 1의 개수의 차를 확인해 0인 경우 반복문 break

 

Code

def dfs(x, y, replace_value):
    
    # graph 밖으로 벗어나면 False Return
    if x < 0 or x > N-1 or y < 0 or y > M-1:
        return False
    
    # 이미 방문했던 칸이거나 0이 아니면 False Return
    if visited[x][y] or graph[x][y] != 0:
        return False
    
    # 현재 위치 방문 기록
    visited[x][y] = True
    # 구멍인 경우 H로 변경
    graph[x][y] = replace_value
    
    # 상하좌우로 이동
    dfs(x-1, y, replace_value)
    dfs(x+1, y, replace_value)
    dfs(x, y-1, replace_value)
    dfs(x, y+1, replace_value)

import sys
input = sys.stdin.readline

N, M = map(int, input().split())
sys.setrecursionlimit(N*M)
graph = []
count_cheezes = 0 # 치즈가 녹기 전 치즈조각이 놓여 있는 칸의 개수
for _ in range(N):
    graph.append(list(map(int, input().split())))
    count_cheezes += graph[-1].count(1)

num = 0
while True:

    # 구멍의 값을 H로 변경
    visited = [[False for _ in range(M)] for _ in range(N)]
    for x in range(N):
        for y in range(M):
            # x, y가 0, 0이 아니면 replace 값 H로 설정
            if x > 0 and y > 0:
                dfs(x, y, 'H')
            else:
                dfs(x, y, 0)

    # 가장자리에 있는 1을 C로 변경
    count_c = 0
    for x in range(N):
        for y in range(M):
            if graph[x][y] == 1:
                # 현재 index의 상하좌우 중 한 군데라도 0이 있으면 가장자리
                for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
                    nx = x+dx
                    ny = y+dy
                    # graph 밖으로 벗어나면 continue
                    if nx < 0 or nx > N-1 or ny < 0 or ny > M-1:
                        continue
                    
                    # nx, ny가 0이면 x, y를 C로 변경하고 break
                    if graph[nx][ny] == 0:
                        graph[x][y] = 'C'
                        count_c += 1
                        break
    
    # 현재 1인 칸과 없어질 칸의 차가 0이면 break
    if count_cheezes - count_c == 0:
        print(num+1)
        print(count_cheezes)
        break
    
    # C, H인 칸 모두 0으로 변경
    for x in range(N):
        for y in range(M):
            if graph[x][y] == 'C'or graph[x][y] == 'H':
                graph[x][y] = 0
    num += 1
    count_cheezes -= count_c

메모리: 33988 KB
시간: 148 ms

반응형
반응형
Python의 시간/메모리 제한

Python 3.7로 Code를 작성할 때 1초에 2,000만 번의 연산을 수행한다고 가정(2020년 기준)
시간 제한 1초
메모리 제한 128 MB
데이터 개수 100만 개
시간 제한이 1초, 데이터 개수가 100만개인 문제가 있다면 일반적으로 시간 복잡도는 이내의 Algorithm을 이용해 문제를 풀어야 한다.
일 때 이기 때문

 

1. 구현(Impletmentation)

: 머릿속에 알고 있는 Algorithm을 Code로 바꾸는 과정

☞ 흔히 Algorithm 대회에서의 구현 유형 문제는 풀이를 떠올리는 것은 쉽지만 Code로 옮기기 어려운 문제를 지칭한다.

e.g., 완전 탐색, 시뮬레이션

완전 탐색(Brute Forcing)
: 가능한 모든 경우의 수를 탐색하는 방법

시뮬레이션(Simulation)
: 문제에서 제시한 Algorithm을 한 단계씩 차례대로 직접 수행해야하는 문제 유형

 

2. 행렬(Matrix)

: 2차원 Data를 일종의 표와 같은 형태로 쉽게 나타내 줄 수 있도록 하는 수학 개념 중 하나 (Programming에서의 2차원 배열, 리스트)

☞ 일반적으로 Algorithm 문제에서의 2차원 공간은 행렬(Matrix)의 의미로 사용되며 Simulation 및 완전 탐색 문제에서는 2차원 공간에서의 방향 벡터가 자주 활용된다.

# 동, 북, 서, 남
dx = [0, -1, 0, 1] # 가로 축(행)
dy = [1, 0, -1, 0] # 세로 축(열)

# 현재 위치
x, y = 2, 2

for i in range(4):
# 다음 위치 -> 동, 북, 서, 남의 방향으로 1번씩 이동
nx = x + dx[i]
ny = y + dy[i]
print(nx, ny)​

 

참고

https://youtu.be/2zjoKjt97vQ

반응형

'Algorithm' 카테고리의 다른 글

[Algorithm] 삽입 정렬(Insertion Sort)  (0) 2023.04.03
[Algorithm] 버블 정렬(Bubble Sort)  (0) 2023.04.02
[Algorithm] 선택 정렬(Selection Sort)  (0) 2023.04.02
DFS/BFS  (0) 2022.04.07
[Algorithm] Greedy  (0) 2022.04.05
반응형

티어 : Gold 5
시간 제한 : 1 초
메모리 제한 : 128 MB
알고리즘 분류 : 구현, 자료 구조, 시뮬레이션, 덱, 큐

 

문제

 'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다.

게임은 NxN 정사각 보드위에서 진행되고, 몇몇 칸에는 사과가 놓여져 있다. 보드의 상하좌우 끝에 벽이 있다. 게임이 시작할때 뱀은 맨위 맨좌측에 위치하고 뱀의 길이는 1 이다. 뱀은 처음에 오른쪽을 향한다.

뱀은 매 초마다 이동을 하는데 다음과 같은 규칙을 따른다.

  • 먼저 뱀은 몸길이를 늘려 머리를 다음칸에 위치시킨다.
  • 만약 이동한 칸에 사과가 있다면, 그 칸에 있던 사과가 없어지고 꼬리는 움직이지 않는다.
  • 만약 이동한 칸에 사과가 없다면, 몸길이를 줄여서 꼬리가 위치한 칸을 비워준다. 즉, 몸길이는 변하지 않는다.

사과의 위치와 뱀의 이동경로가 주어질 때 이 게임이 몇 초에 끝나는지 계산하라.

 

입력

첫째 줄에 보드의 크기 N이 주어진다. (2 ≤ N ≤ 100) 다음 줄에 사과의 개수 K가 주어진다. (0 ≤ K ≤ 100)

다음 K개의 줄에는 사과의 위치가 주어지는데, 첫 번째 정수는 행, 두 번째 정수는 열 위치를 의미한다. 사과의 위치는 모두 다르며, 맨 위 맨 좌측 (1행 1열) 에는 사과가 없다.

다음 줄에는 뱀의 방향 변환 횟수 L 이 주어진다. (1 ≤ L ≤ 100)

다음 L개의 줄에는 뱀의 방향 변환 정보가 주어지는데,  정수 X와 문자 C로 이루어져 있으며. 게임 시작 시간으로부터 X초가 끝난 뒤에 왼쪽(C가 'L') 또는 오른쪽(C가 'D')로 90도 방향을 회전시킨다는 뜻이다. X는 10,000 이하의 양의 정수이며, 방향 전환 정보는 X가 증가하는 순으로 주어진다.

 

출력

첫째 줄에 게임이 몇 초에 끝나는지 출력한다.

 

예제 입출력


Algorithm

구현 - 시뮬레이션
1. board를 리스트로 구현
    ☞ 사과가 있는 칸은 True, 사과가 없는 칸은 False
2. 현재 뱀의 몸이 닿아있는지 여부가 담긴 snake 리스트 구현
    ☞ 몸이 닿아있으면 True, 닿아있지 않으면 False
3. 반복문 1번 돌 때마다 snake의 다음 칸 True, 첫 번째 칸 False
    ☞ 사과 먹으면 첫 번째 칸 놔두기
4. 반복문 1번 돌 때마다 초 증가   
☞ 초 == x+1이면 c의 방향으로 이동   
☞ 현재 방향 (상, 하, 좌, 우) 저장해두고
   상일 때 D이면 우, L이면 좌로 변경
    하일 때 D이면 좌, L이면 우로 변경
    좌일 때 D이면 상, L이면 하로 변경
    우일 때 D이면 하, L이면 상으로 변경
5. 다음 칸의 snake가 True이거나 board 범위 벗어나면 break

 

Code

import sys
input = sys.stdin.readline

# 현재 방향과 변경할 방향으로 인자로 줬을 때 다음 방향을 return하는 함수
def return_index(index, C):
    # 현재 방향이 상인 경우
    if index == 0:
        # C가 D이면 우로 변경
        if C == 'D':
            index = -1
        # C가 L이면 좌로 변경
        else:
            index = 2
    # 현재 방향이 하인 경우
    elif index == 1:
        # C가 D이면 좌로 변경
        if C == 'D':
            index = 2
        # C가 L이면 우로 변경
        else:
            index = -1
    # 현재 방향이 좌인 경우
    elif index == 2:
        # C가 D이면 상으로 변경
        if C == 'D':
            index = 0
        # C가 L이면 하로 변경
        else:
            index = 1
    # 현재 방향이 우인 경우
    else:
        # C가 D이면 하로 변경
        if C == 'D':
            index = 1
        # C가 L이면 상으로 변경
        else:
            index = 0
    return index

# board 구현
N = int(input())
board = [[False for _ in range(N+1)] for _ in range(N+1)]
# 뱀 리스트 구현
snake = [[False for _ in range(N+1)] for _ in range(N+1)]

# 사과 위치 저장
K = int(input())
for _ in range(K):
    x, y = map(int, input().split())
    # 사과 위치 True로 변환
    board[x][y] = True

# 뱀의 방향 변환 정보 저장
L = int(input())
move = []
for _ in range(L):
    time, direction = input().split()
    move.append((int(time), direction))

# 방향 : 상, 하, 좌, 우
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]
index = -1 # 현재 방향
x = 1 # 현재 위치
y = 1 # 현재 위치
# 현재 위치에 뱀 저장
snake[x][y] = True
snake_length = 1 # 뱀 길이
last_loc = [1, 1]
time = 1
index_record = []
while True:
    # 현재 시간이 X+1이면 C의 방향으로 방향 회전
    if move and time == move[0][0]+1:
        index = return_index(index, move[0][1])
        move = move[1:]
    
    # 현재 방향으로 이동
    nx = x+dx[index]
    ny = y+dy[index]
    
    # 다음 칸의 위치에 뱀의 몸이 있거나 board의 범위를 벗어나면 break
    if nx < 1 or nx > N or ny < 1 or ny > N or snake[nx][ny]:
        break
    
    index_record.append(index)
    
    # 다음 칸으로 뱀 이동
    snake[nx][ny] = True
    snake_length += 1
    # 사과가 있으면 사과 삭제
    if board[nx][ny]:
        board[nx][ny] = False
    else: # 사과가 없으면 첫 칸에서 뱀 삭제
        snake[last_loc[0]][last_loc[1]] = False
        snake_length -= 1

        last_loc[0] += dx[index_record[-snake_length]]
        last_loc[1] += dy[index_record[-snake_length]]
    
    # 시간 증가
    time += 1
    
    # x, y 갱신
    x = nx
    y = ny

print(time)

메모리: 30860 KB
시간: 76 ms

반응형

'백준 > Python' 카테고리의 다른 글

[백준 1748] 수 이어 쓰기 1 Python  (0) 2022.04.04
[백준 2075] N번째 큰 수 Python  (0) 2022.03.31
[백준 12904] A와 B Python  (0) 2022.03.31
[백준 14500] 테트로미노 Python  (0) 2022.03.31
[백준 1107] 리모컨 Python  (0) 2022.03.30

+ Recent posts