19-fnhid

[Fnhid]

🔗 문제 링크

뱀

✔️ 소요된 시간

30분

✨ 수도 코드

자료구조 중 큐를 연습해 볼 수 있는 구현 문제를 가져왔습니다.

이 문제는 뱀 게임에서, 사과의 위치와 방향 전환 정보(회전 시점, 회전 방향)를 제공하면, 몇 초만에 게임이 끝나는지 알아내는 문제입니다.

뱀은 1초에 한 칸 움직이고, 명령어 정보에 따라 회전합니다.

뱀이 몸통, 벽에 부딫히면 게임이 끝납니다.

2차원 배열로 게임 판의 정보(빈 공간, 사과, 몸통)를 저장하였고,

c++의 STL인 queue를 이용하여 뱀의 위치 정보를 저장하였습니다.

뱀의 머리가 새로 이동하면, 그 부분의 좌표를 큐에 push하고,
사과를 먹지 않았다면 길이가 유지되어야 하기 때문에 꼬리였던 부분의 좌표를 pop하였습니다.

수도 코드

함수 main
    N, K 입력
    N x N 크기 보드 생성

    K번 반복:
        사과 좌표 r, c 입력
        보드[r-1][c-1]에 사과 표시

    L 입력
    명령어 목록 생성
    L번 반복:
        시간, 방향 문자 입력
        명령어 목록에 {시간, 방향 문자} 저장

    결과 = solve(N, 명령어 목록, 보드)
    결과 출력

함수 solve(N, 명령어 목록, 보드)
    시간 = 0
    방향 = 0
    명령어_순번 = 0

    머리_좌표 = {0, 0}
    몸통_큐 생성, {0, 0} 추가
    보드[0][0]에 몸통 표시

    무한 반복:
        시간 1 증가
        머리_좌표를 현재 방향으로 이동

        만약 머리가 벽 또는 자기 몸에 닿으면:
            반복 중단

        만약 이동한 칸에 사과가 없으면:
            꼬리_좌표 = 몸통_큐의 맨 앞
            몸통_큐에서 제거
            보드에서 꼬리_좌표를 빈 칸으로

        몸통_큐에 새 머리_좌표 추가
        보드에서 새 머리_좌표를 몸통으로

        만약 현재 시간에 실행할 명령어가 있으면:
            만약 명령이 'D'이면, 방향을 오른쪽으로
            아니면, 방향을 왼쪽으로
            명령어_순번 1 증가

    시간 반환

📚 새롭게 알게된 내용

[froglike6]

저도 비슷한 방식으로 큐를 사용해 이 문제를 해결했습니다. 뱀과 방향을 각각 큐에 넣어 작동하도록 구현했습니다.

import sys
from collections import deque
input = sys.stdin.readline

n = int(input())
k = int(input())
apple = [tuple(map(int,input().split())) for _ in range(k)]
l = int(input())
turn = deque()
for _ in range(l):
    x, c = input().split()
    turn.append((int(x), c))
    
direction = [(0, 1), (1, 0), (0, -1), (-1, 0)]
dirIndex = 0

snake = deque([(1, 1)])
occupied = {(1, 1)}
time = 0

while True:
    time += 1
    headX, headY = snake[0]
    x, y = direction[dirIndex]
    nx, ny = headX+x, headY+y
    if not(1<=nx<=n and 1<=ny<=n) or (nx, ny) in occupied:
        break
    snake.appendleft((nx, ny))
    occupied.add((nx, ny))
    
    if (nx, ny) in apple:
        apple.remove((nx, ny))
    else:
        tmpX, tmpY = snake.pop()
        occupied.remove((tmpX, tmpY))
    if turn and turn[0][0] == time:
        _, c = turn.popleft()
        if c == "L":
            dirIndex = (dirIndex-1)%4
        else:
            dirIndex = (dirIndex+1)%4
print(time)

[dohyeondol1]

큐를 사용해서 푸는 발상이 재밌네요..
구조체나 enum을 사용하는건 익숙치 않아서 로우하게 짰습니다.

enum에 대해선 잘 모르는데, 유현님이 조금 알려주실 수 있나요?

C++

#include <iostream>
#include <vector>
#include <queue>
#include <deque>
using namespace std;

int board[101][101];
int N, K, L;
int direction = 0;
int dy[4] = {0, 1, 0, -1};
int dx[4] = {1, 0, -1, 0};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    cin >> N >> K;
    for(int i = 0; i < K; ++i) {
        int row, col;
        cin >> row >> col;
        board[row][col] = 2;
    }
    
    cin >> L;
    queue<pair<int, char>> turns;
    for(int i = 0; i < L; ++i) {
        int t;
        char d;
        cin >> t >> d;
        turns.push({t, d});
    }
    
    int time = 0;
    deque<pair<int, int>> snake;
    snake.push_back({1, 1});
    board[1][1] = 1;
        
    while(true) {
        time++;
        int headY = snake.back().first + dy[direction];
        int headX = snake.back().second + dx[direction];
        
        if(headY <= 0 || headY > N || headX <= 0 || headX > N || board[headY][headX] == 1)
            break;
        
        if(board[headY][headX] != 2) {
            auto tail = snake.front();
            board[tail.first][tail.second] = 0;
            snake.pop_front();
        }
        
        board[headY][headX] = 1;
        snake.push_back({headY, headX});
        
        if(!turns.empty() && time == turns.front().first) {
            char dir = turns.front().second;
            if(dir == 'D')
                direction = (direction + 1) % 4;
            else
                direction = (direction + 3) % 4;
            turns.pop();
        }
    }
    
    cout << time << '\n';
    return 0;
}

[Fnhid]

큐를 사용해서 푸는 발상이 재밌네요.. 구조체나 enum을 사용하는건 익숙치 않아서 로우하게 짰습니다.

enum에 대해선 잘 모르는데, 유현님이 조금 알려주실 수 있나요?

enum은 관련 있는 상수를 모아 둔 것이라고 생각하면 될 것 같습니다.

각 열거자는 위치에 따라서 자동으로 정수 값이 할당되는데,
첫 번째 열거자에는 정수 값 0이 할당되며, 각 이후 열거자에는 이전 열거자보다 1 더 큰 값이 할당됩니다.

저는 상태 값을 가독성 있게 보여주고 싶을 때 사용합니다.

enum WORDS{
  VOID, // assigned 0
  APPLE, // assigned 1
  BODY, // assigned 2
  WALL=15 // assigned 15
  BOMB, // assigned 16
} 

int board[3][5] = 1;
int board[3][5] = APPLE; // 1, 같은 코드지만 코드를 이해하기 좋음 

자료를 참고하시면 좋을 것 같습니다.

[Fnhid]

여러 열거형들의 값이 중복되는 문제나 타입 안정성 문제가 있어서 enum을 사용하기 살짝 꺼려지는 게 있었는데,

c++11부터는 enum class라는 기능을 지원하네요. 저도 enum에 대해 찾아보면서 방금 처음 알게 되었습니다.

여기를 참고해주시기 바랍니다.

[hadongun]

뱀! 친숙한 게임이네요..!>!>>!

다들 이걸 어찌 이렇게 잘 푸시는지 더욱 발전해나가는 사람이 되고자 합니다
queue를 이용해야 한다는 생각을 바로 못 해서 더욱 헤맸던게 아닌가 싶네요
여러 도움을 받아 풀어봤습니다.

Details

import sys
from collections import deque

input = sys.stdin.readline

N = int(input())
K = int(input())

apple_pos = set()
for _ in range(K):
    x, y = map(int, input().split())
    apple_pos.add((x - 1, y - 1))

L = int(input())
turn_time = deque()
turn_dir = deque()
for _ in range(L):
    t, d = input().split()
    turn_time.append(int(t))
    turn_dir.append(d)

snake = deque()
snake.append((0, 0))
visited = [[False] * N for _ in range(N)]
visited[0][0] = True

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

time_now = 0
x, y = 0, 0

while True:
    time_now += 1
    nx = x + dx[dir_idx]
    ny = y + dy[dir_idx]

    if nx < 0 or ny < 0 or nx >= N or ny >= N:
        break

    if visited[nx][ny]:
        break

    snake.appendleft((nx, ny))
    visited[nx][ny] = True

    if (nx, ny) in apple_pos:
        apple_pos.remove((nx, ny))
    else:
        tx, ty = snake.pop()
        visited[tx][ty] = False

    if turn_time and time_now == turn_time[0]:
        d = turn_dir.popleft()
        turn_time.popleft()
        if d == 'D':
            dir_idx = (dir_idx + 1) % 4
        else:
            dir_idx = (dir_idx - 1 + 4) % 4

    x, y = nx, ny

print(time_now)