18-yuyu0830

[yuyu0830]

🔗 문제 링크

2048 (Easy) (12100)

✔️ 소요된 시간

3시간
구현 문제는 귀찮네요

✨ 수도 코드

❓ 문제

2048 게임을 만들자!
1 < n < 20 의 숫자 n 과 n * n 사이즈의 게임 판 m 가 주어진다. 움직임에 관한 룰은 문제를 참고하자
기존 2048의 움직임마다 생성되는 추가 블럭이 없다고 했을 때, 5번 움직임 이내에서 최대로 만들 수 있는 수의 값을 구하자

❗ 풀이

로직은 단순하다! 직접 움직여보고 최대 값을 구하면 된다. 주석이 많은 것 에서 볼 수 있다시피 좀 귀찮긴 하다..

전체 로직

재귀 함수를 통해 백트래킹을 구현했다. 여기서 함수 하나에 움직이는 파트와 재귀 파트를 넣자니 너무 길어서 움직임 함수 move 와 재귀 함수 f 를 별도로 구현했다.

재귀 파트

재귀는 별 어려운 부분이 없지만 백트래킹을 구현하기 위해 움직임 파트에서 움직임이 없다고 판단되면 더 이상 탐색하지 않는 로직을 구현했다.

움직임 구현

재귀 파트에서 움직임 함수로 현재 m의 상태 와 움직일 방향 d 를 전달한다. d 방향으로 2048 게임의 룰에 맞춰 이동한다.

여기서 움직이는 방향을 기준으로 각 줄마다 독립적으로 연산이 가능하다. 굳이 옆 줄까지 신경쓰지 않아도 되니 예시에서는 한 줄씩 다루도록 하자

여기서 탐색 방향은 움직이는 방향 d의 역방향으로 탐색하면 된다.

첫 숫자의 경우 더 연산할 방향이 없으니 굳이 안해도 된다.

이렇게 n - 1번만 연산하면 된다.

1번 칸 부터 탐색하자.

현재 탐색중인 칸 을 a 라고 하자. 현재 탐색중인 칸이 0인 경우에는 그냥 넘어가면 된다. 1번 칸은 0이니 넘어가자

2번 칸은 0이 아니다. 만약 0이 아닌 경우에는 a를 움직일 수 있는 칸 까지 방향 d 대로 움직여야한다. 어디까지 움직일지 임시로 탐색할 칸을 g 라고 하자. g는 기존 탐색 방향의 반대로 탐색하게 된다.

이 순서대로 어디까지 움직일지 탐색을 하는데, 만약 0이면 패스한다.

하지만 0이 아니면 어떻게 이동을 할지 계산해야한다. (움직임 방향의 역 방향으로 연산했기 때문에 여기서 만난 값의 앞은 더 이상 0이 없기 때문에 움직일 필요가 없다). 만약 현재 탐색 중인 값과 같은 값이면 더할 수 있다. 이미 더했으면 더 이상 더할 수 없기 때문에 방문 현황을 visited 배열을 통해 체크하자.

예시의 경우는 값이 다르기 때문에 탐색 중인 값 바로 전까지 이동해야한다.

이렇게 이동하면 된다!

위의 경우의 수를 전부 지키면서 5번 재귀하면 된다!

#include <iostream>

using namespace std;

int map[21][21] = {0, };
int n, ans = 0;
int dir[4][2] = {
    {0, 1},
    {0, -1},
    {1, 0},
    {-1, 0}
};

bool isin(int t) { return t >= 0 && t < n; }

bool move(int m[21][21], int d) {
    // 반환 값(e)은 움직임 여부
    bool e = false;

    // vertical : 움직임 방향이 가로인지 세로인지
    // plus : 움직임 방향이 + 방향인지 - 방향인지
    bool vertical = d < 2, plus = d % 2 == 0;

    // 한 번 더해진 부분은 다시 더해지면 안되니까 방문 처리
    bool visited[n][n];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            visited[i][j] = 0;

    for (int i = 0; i < n; i++) {
        // 현재 탐색 위치의 x, y 좌표값
        int x = vertical ? i : (plus ? 1 : n - 2);
        int y = vertical ? (plus ? 1 : n - 2) : i;

        // 탐색 범위 안에 있는 동안만 탐색
        while (isin(vertical ? y : x)) {
            // 현재 탐색 위치에 값이 있다면 이동 해야함
            if (m[x][y]) {
                // 값 저장 및 현재 탐색 위치 0으로
                int tmp = m[x][y];
                m[x][y] = 0;

                // 어디까지 이동할지 탐색할 임시 탐색 위치의 x, y 좌표값
                int tx = x - dir[d][0];
                int ty = y - dir[d][1];

                while (true) {
                    // 임시 탐색 위치에 값이 있다면
                    if (m[tx][ty]) {
                        // 값이 있고, 현재 탐색 위치와 값이 같고, 방문한 적이 없다면
                        // 임시 탐색 위치의 값에 더해짐
                        if (tmp == m[tx][ty] && !visited[tx][ty]) {
                            e = true;
                            visited[tx][ty] = true;
                            break;
                        }
                        // 값이 다르거나, 방문한 적이 있으면
                        // 임시 탐색 위치에서 한 칸 전으로 이동
                        else {
                            tx += dir[d][0];
                            ty += dir[d][1];
                            break;
                        }
                    }

                    // 더 이동 가능한지 체크
                    if (!isin(vertical ? ty - dir[d][1]: tx - dir[d][0])) 
                        break;

                    // 움직임 여부 체크
                    e = true;

                    // 임시 탐색 위치 이동
                    tx -= dir[d][0];
                    ty -= dir[d][1];
                }

                // 임시 탐색 위치까지 이동 처리
                m[tx][ty] += tmp;
                // 최대 값 처리
                ans = max(ans, m[tx][ty]);
            }

            // 현재 탐색 위치 이동
            x += dir[d][0];
            y += dir[d][1];
        }
    }

    return e;
}

void f(int m[21][21], int depth) {
    // depth가 5가 되면 탐색 종료
    if (depth == 5) return;

    int tm[21][21];

    for (int d = 0; d < 4; d++) {
        // 임시 map 생성
        for (int i = 0; i < n; i++) 
            for (int j = 0; j < n; j++) 
                tm[i][j] = m[i][j];
            
        // 만약 움직임이 없으면 굳이 더 탐색하지 않는다.
        if (move(tm, d)) 
            f(tm, depth + 1);
 
    }
}

int main() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> map[i][j];
            ans = max(ans, map[i][j]);
        }
    }

    f(map, 0);
    printf("%d\n", ans);
}

📚 새롭게 알게된 내용

구현 문제는 쉬운 척 하는 귀찮은 문제가 대부분이다

[InSange]

시간 초과가 안나는게 신기하군요
매 방향의 초기에 배열을 초기화시키고 4개의 방향을 들어왔다 나오고해야하고..
4^5의 가짓수가 되나요?
거기에 배열을 탐색하는 과정까지 쉽지않았는데 잘 보고 갑니다.

요새는 또 협업도 협업이지만 설계를 어떻게 하느냐도 따지더군요.

[yuyu0830]

시간 초과가 안나는게 신기하군요 매 방향의 초기에 배열을 초기화시키고 4개의 방향을 들어왔다 나오고해야하고.. 4^5의 가짓수가 되나요? 거기에 배열을 탐색하는 과정까지 쉽지않았는데 잘 보고 갑니다.

요새는 또 협업도 협업이지만 설계를 어떻게 하느냐도 따지더군요.

의외로 시간은 별로 문제가 없었네요..
최대 20 * 20 배열인 경우 각 줄 별로 순방향 20번, 역방향 20 * 21 / 2번 씩 20개의 줄을 연산해야하고 이걸 최악의 경우 4^5번 연산해야하는데.. 아마 예상컨데 더 이상 움직임이 없다 판단되면 재귀를 멈추게 백트래킹을 시켜둬서 그게 효과적으로 작동하지 않나 싶네요 ㅎㅎ

[seongwon030]

상하좌우 4번에 최대 5번이니까 4의 5승해서 1024번이 최대로 움직이는 횟수가 되겠네요. 말그대로 하나하나 구현하는 문제였군요. 옛날에 했던 게임이라 알고리즘 문제로 나온게 신기했습니다. 풀아 잘 보고 갑니다 !