BOJ 8972 - 미친 아두이노

문제

백준 온라인 저지 - 8972번

풀이 과정

플레이어와 미친 아두이노의 동작을 시뮬레이션하는 구현 문제입니다.

조건이 많은 구현문제이기 때문에 모듈화에 신경을 많이 써서 해결했습니다.
플레이어와 로봇의 위치를 나타내는 객체를 게임판과 별도로 선언하고 게임판 이동, 게임 종류 유무를 판단해줬습니다.
문제 구현하면서 python 에서 제공하는 any 함수를 알게되었습니다.
Javascript 의 some 고차함수와 유사한데 콜백을 인자로 받지 않아 사용방법이 좀 다르다는 차이점이 있습니다.

이외에도 플레이어와 로봇이 이동할 때 각 위치에서 여러개의 로봇이나 플레이어가
파괴되기 전 동시에 위치할 수 있기 때문에 deque 를 이용해서 관리했습니다.

코드

import sys
from collections import deque

R, C = list(map(int, sys.stdin.readline().split()))
board = [list(sys.stdin.readline().strip()) for _ in range(R)]
commands = list(map(int, sys.stdin.readline().strip()))

dx = [0, 1, 1, 1, 0, 0, 0, -1, -1, -1]
dy = [0, -1, 0, 1, -1, 0, 1, -1, 0, 1]


def pre_processing():
    game_map = [[deque() for _ in range(C)] for _ in range(R)]
    meta = {
        'I': [],
        'R': []
    }

    for x in range(R):
        for y in range(C):
            if not board[x][y] == '.':
                game_map[x][y].append(board[x][y])
                meta[board[x][y]].append([x, y])

    return meta, game_map


def move_jongsu(command, meta, game_map):
    x, y, = meta['I'][0]
    nx, ny = x + dx[command], y + dy[command]

    game_map[x][y].popleft()
    game_map[nx][ny].append('I')
    meta['I'] = [[nx, ny]]


def next_position(robot, jongsu):
    min_dist, position = sys.maxsize, None

    for i in range(1, 10):
        if i == 5:
            continue

        nx, ny = robot[0] + dx[i], robot[1] + dy[i]
        if 0 <= nx < R and 0 <= ny < C:
            dist = abs(jongsu[0] - nx) + abs(jongsu[1] - ny)
            if min_dist > dist:
                min_dist = dist
                position = [nx, ny]

    return position


def move_robots(meta, game_map):
    jongsu = meta['I'][0]
    robots = meta['R']
    moved_robots = []

    for robot in robots:
        next_xy = next_position(robot, jongsu)

        game_map[robot[0]][robot[1]].popleft()
        game_map[next_xy[0]][next_xy[1]].append('R')
        moved_robots.append(next_xy)

    meta['R'] = moved_robots


def allowed_to_continue(jongsu, game_map):
    x, y = jongsu
    if any(map(lambda e: e == 'R', game_map[x][y])):
        return False

    return True


def explode_robots(game_map, meta):
    survived_robots = []

    for x in range(R):
        for y in range(C):
            if len(game_map[x][y]) > 0:
                if game_map[x][y][0] == 'R':
                    if len(game_map[x][y]) == 1:
                        survived_robots.append([x, y])
                    else:
                        game_map[x][y].clear()

    meta['R'] = survived_robots


def run(command, meta, game_map):
    move_jongsu(command, meta, game_map)
    if not allowed_to_continue(meta['I'][0], game_map):
        return False

    move_robots(meta, game_map)
    if not allowed_to_continue(meta['I'][0], game_map):
        return False

    explode_robots(game_map, meta)

    return True


def solution():
    meta, game_map = pre_processing()

    for turn, command in enumerate(commands):
        survive = run(command, meta, game_map)
        if not survive:
            print(f"kraj {turn + 1}")
            return

    for x in range(R):
        for y in range(C):
            token = '.' if not game_map[x][y] else game_map[x][y][0]
            sys.stdout.write(f"{token}")
        sys.stdout.write("\n")


solution()