코드트리 싸움땅 | python | just 구현

문제

링크

풀이

말그대로 빡구현 문제이다.
정말 이렇다할 테크닉이 없고 대신 2차원 전역 배열 내에서 관리되어야하는 정보들 자체가 꽤 많기 때문에 실수 없이 꼼꼼히 구현해야하는 문제이다.

사용한 배열

guns: 각 칸마다 놓여있는 총 목록 관리 (NxN)
players: 각 플레이어의 정보들을 관리하는 1차원 배열

짚고 넘어갈 점

1. 함수를 아주 잘게 나눠서 처음부터 예외처리, 설계 잘하기
2. 해당 위치에 있는 전 플레이어 정보를 얻어오기 위해 성급히 좌표를 업데이트 하면 안된다 <- 이 점 유의하기

그리고 플레이어 각각에 대하여 독립적으로 관리해야하는 경우엔 꼭 1차원 배열 안에 각 플레이어의 정보를 담아서 풀이하는 게 쉽다. 즉 1차원 배열의 인덱스가 각 플레이어의 고유한 id가 되는 격

반대로 상어시리즈나 술래잡기와 같이 같은 좌표에 있는 사물/사람을 제거하는 등의 행위가 있다면 2차원 배열 내에서 조작하는게 더 정석 풀이인듯 하다.

전체 코드

코드 트리 해설 코드 기반 + 가장 공격력이 큰 총을 갖기 위해 리스트 내림차순 정렬 후 pop(0)을 하는 대신, heapq을 사용하여 음수값을 push하고 음수값으로 pop하는 방식으로 효율성을 높였습니다 (최대힙 정렬 방식) 🙌🏻

import heapq
EMPTY = (-1, -1, -1, -1, -1, -1)

# 변수 선언 및 입력:
n, m, k = tuple(map(int, input().split()))

# 각 칸마다 놓여있는 총 목록을 관리합니다.
gun = [
    [[] for _ in range(n)]
    for _ in range(n)
]
for i in range(n):
    nums = list(map(int, input().split()))
    for j in range(n):
        # 총이 놓여 있는 칸입니다.
        if nums[j] != 0:
            heapq.heappush(gun[i][j],-1*nums[j])
            # gun[i][j].append(nums[j])

# 각 칸마다 플레이어 정보를 관리합니다.
# 순서대로 (num, x, y, d, s, a) 정보를 관리합니다.
# (x, y)위치에서 방향 d를 보고 있으며
# 초기 능력치가 s인 num번 플레이어가
# 공격력이 a인 총을 들고 있음을 뜻합니다.
# 총이 없으면 a는 0입니다.
players = []
for i in range(m):
    x, y, d, s = tuple(map(int, input().split()))
    players.append((i, x - 1, y - 1, d, s, 0))

# 입력으로 주어지는
# 방향 순서대로
# dx, dy를 정의합니다.
# ↑, →, ↓, ←
dxs = [-1, 0, 1, 0]
dys = [0, 1, 0, -1]

# 플레이어들의 포인트 정보를 기록합니다.
points = [0] * m


# (x, y)가 격자를 벗어나는지 확인합니다.
def in_range(x, y):
    return 0 <= x and x < n and 0 <= y and y < n


# 현재 (x, y)위치에서 방향 d를 보고 있을 때
# 그 다음 위치와 방향을 찾아줍니다.
def get_next(x, y, d):
    nx, ny = x + dxs[d], y + dys[d]
    # 격자를 벗어나면
    # 방향을 뒤집어
    # 반대 방향으로 한 칸 이동합니다.
    if not in_range(nx, ny):
        # 반대 방향 : 0 <. 2 / 1 <. 3
        d = (d + 2) if d < 2 else (d - 2)
        nx, ny = x + dxs[d], y + dys[d]

    return (nx, ny, d)


# 해당 칸에 있는 Player를 찾아줍니다.
# 없다면 EMPTY를 반환합니다.
def find_player(pos):
    for i in range(m):
        _, x, y, _, _, _ = players[i]
        if pos == (x, y):
            return players[i]

    return EMPTY


# Player p의 정보를 갱신해줍니다.
def update(p):
    num, _, _, _, _, _ = p

    # Player의 위치를 찾아
    # 값을 갱신해줍니다.
    for i in range(m):
        num_i, _, _, _, _, _ = players[i]

        if num_i == num:
            players[i] = p
            break


# 플레이어 p를 pos 위치로 이동시켜줍니다.
def move(p, pos):
    num, x, y, d, s, a = p
    nx, ny = pos

    # 가장 좋은 총으로 갱신해줍니다.
    heapq.heappush(gun[nx][ny], -1*a)

    a = -1* heapq.heappop(gun[nx][ny])


    p = (num, nx, ny, d, s, a)
    update(p)


# 진 사람의 움직임을 진행합니다.
# 결투에서 패배한 위치는 pos입니다.
def loser_move(p):
    num, x, y, d, s, a = p

    # 먼저 현재 위치에 총을 내려놓게 됩니다.
    # gun[x][y].append(a)
    heapq.heappush(gun[x][y], -1*a)

    # 빈 공간을 찾아 이동하게 됩니다.
    # 현재 방향에서 시작하여
    # 90'씩 시계방향으로
    # 회전하다가
    # 비어있는 최초의 곳으로 이동합니다.
    for i in range(4):
        ndir = (d + i) % 4
        nx, ny = x + dxs[ndir], y + dys[ndir]
        if in_range(nx, ny) and find_player((nx, ny)) == EMPTY:
            p = (num, x, y, ndir, s, 0)
            move(p, (nx, ny))
            break


# p2과 p2가 pos에서 만나 결투를 진행합니다.
def duel(p1, p2, pos):
    num1, _, _, d1, s1, a1 = p1
    num2, _, _, d2, s2, a2 = p2

    # (초기 능력치 + 총의 공격력, 초기 능력치) 순으로 우선순위를 매겨 비교합니다.

    # p1이 이긴 경우
    if (s1 + a1, s1) > (s2 + a2, s2):
        # p1은 포인트를 얻게 됩니다.
        points[num1] += (s1 + a1) - (s2 + a2)
        # p2는 진 사람의 움직임을 진행합니다.
        loser_move(p2)
        # 이후 p1은 이긴 사람의 움직임을 진행합니다.
        move(p1, pos)
    # p2가 이긴 경우
    else:
        # p2는 포인트를 얻게 됩니다.
        points[num2] += (s2 + a2) - (s1 + a1)
        # p1은 진 사람의 움직임을 진행합니다.
        loser_move(p1)
        # 이후 p2는 이긴 사람의 움직임을 진행합니다.
        move(p2, pos)


# 1라운드를 진행합니다.
def simulate():
    # 첫 번째 플레이어부터 순서대로 진행합니다.
    for i in range(m):
        num, x, y, d, s, a = players[i]

        # Step 1-1. 현재 플레이어가 움직일 그 다음 위치와 방향을 구합니다.
        nx, ny, ndir = get_next(x, y, d)

        # 해당 위치에 있는 전 플레이어 정보를 얻어옵니다.
        next_player = find_player((nx, ny))

        # 현재 플레이어의 위치와 방향을 보정해줍니다.
        curr_player = (num, nx, ny, ndir, s, a)
        update(curr_player)

        # Step 2. 해당 위치로 이동해봅니다.
        # Step 2-1. 해당 위치에 플레이어가 없다면 그대로 움직입니다.
        if next_player == EMPTY:
            move(curr_player, (nx, ny))
        # Step 2-2. 해당 위치에 플레이어가 있다면 결투를 진행합니다.
        else:
            duel(curr_player, next_player, (nx, ny))


# k번에 걸쳐 시뮬레이션을 진행합니다.
for _ in range(k):
    simulate()

# 각 플레이어가 획득한 포인트를 출력합니다.
for point in points:
    print(point, end=" ")

풀면서 느낀 개인적인 생각인데, 플레이어는 총을 하나만 소지가능하다 라는 조건은 기재해두었어야 한다고 생각한다. 예외처리 고려하면서 읽다가 이부분이 명확하게 얘기되지 않아서 쓸데없는 고민하는데 시간을 많이 허비했기 때문이다.