[코드트리] 합쳐지는 구슬들 Python

# n, m, t 입력
n, m, t = map(int, input().split())
# grid
grid = [
    [[] for _ in range(n)]
    for _ in range(n)
]
# mapper
mapper = {
    'U':0,
    'R':1,
    'D':2,
    'L':3
}
for i in range(1, m+1):
    # r, c, d, w 입력
    r, c, d, w = input().split()
    r, c, w = int(r)-1, int(c)-1, int(w)
    grid[r][c].append([i, mapper[d], w])

# 함수들
# get_new(x, y)
def get_new(x, y):
    
    # max_num, sum_weight
    max_num, sum_weight = 0, 0
    
    # 겹친 구슬 중에서
    for marble in next_grid[x][y]:
        # sum_weight
        sum_weight += marble[2]
        # 구슬의 숫자가 max_num보다 크면
        if marble[0] > max_num:
            max_num, max_num_dir = marble[0], marble[1]
    
    return max_num, max_num_dir, sum_weight

# merge()
def merge():
    # next_grid를 돌면서
    for i in range(n):
        for j in range(n):
            # 2개 이상의 구슬을 발견하면
            if len(next_grid[i][j]) >= 2:
                # new_num, new_dir, new_weight
                new_num, new_dir, new_weight = get_new(i, j)

                # 비워주고
                next_grid[i][j] = []
                # 새로운 값으로 채워주기
                next_grid[i][j].append([new_num, new_dir, new_weight])

# in_range(x, y)
def in_range(x, y):
    return 0 <= x < n and 0 <= y < n

# simulate(x, y)
def simulate(x, y):
    # curr_num, curr_dir, curr_weight
    curr_num, curr_dir, curr_weight = grid[x][y][0][0], grid[x][y][0][1], grid[x][y][0][2]
    
    # dxs, dys
    dxs, dys = [-1, 0, 1, 0], [0, 1, 0, -1]
    # nx, ny
    nx, ny = x + dxs[curr_dir], y + dys[curr_dir]
    # 범위 내에 있다면
    if in_range(nx, ny):
        # 해당 방향으로 전진
        next_grid[nx][ny].append([curr_num, curr_dir, curr_weight])
    # 범위 밖이라면,
    else:
        # 방향 바꿔주기
        next_grid[x][y].append([curr_num, (curr_dir + 2) % 4, curr_weight])

# 설계
# t초간 진행
for _ in range(t):
    
    # next_grid
    next_grid = [
        [[] for _ in range(n)]
        for _ in range(n)
    ]

    # grid를 돌면서
    for i in range(n):
        for j in range(n):
            # 구슬이 있으면
            if grid[i][j]:
                # simulate
                simulate(i, j)
    
    # 만난 구슬들 합쳐주기
    merge()

    # next_grid를 grid에 복사
    for i in range(n):
        for j in range(n):
            grid[i][j] = next_grid[i][j]

# cnt, max_weight
cnt, max_weight = 0, 0
# grid를 돌면서
for i in range(n):
    for j in range(n):
        # 구슬이 있다면
        if grid[i][j]:
            # cnt, max_weight update
            cnt, max_weight = cnt + 1, max(max_weight, grid[i][j][0][2])
# 출력
print(cnt, max_weight)