<12100> 2048 (Easy)

문제 : https://www.acmicpc.net/problem/12100

째로탈출2처럼 코드가 깁니다… 째로탈출2와 마찬가지로 2차원 배열을 조작하는 부분에서 코드가 많이 길어지게 되는데 더 간결하게 만들 수 있도록 연습을 해야할 것 같습니다.
구현은 combine_map함수를 통해서 방향에 맞게 같은 숫자를 합쳐주고 move_map함수를 통해 빈공간을 제거하는것을 반복하도록 구현했습니다. Easy의 경우 5회 반복이기 때문에 대부분 시간초과 경우는 없을 것 입니다.
(테스트 케이스가 문제에 1개 밖에 없다보니 힘들었습니다… 테스트 케이스가 부족하신 분들은 문제 게시판에 가시면 더 찾아보실 수 있습니다.)

#include <iostream>
#include <algorithm>

#define MAP_MAX_SIZE 20
using namespace std;

int map[MAP_MAX_SIZE][MAP_MAX_SIZE];
int N;
int max_dp[6];

void init_map() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cin >> map[i][j];
        }
    }
}

void copy_map(int(*map)[MAP_MAX_SIZE], int(*tmp_map)[MAP_MAX_SIZE]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            tmp_map[i][j] = map[i][j];
        }
    }
}

void recovery_map(int(*map)[MAP_MAX_SIZE], int(*tmp_map)[MAP_MAX_SIZE]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            map[i][j] = tmp_map[i][j];
        }
    }
}

void combine_map(int dir) {
    // 상
    if (dir == 0) {
        for (int c = 0; c < N; c++) {
            for (int r = 0; r < N - 1; r++) {
                int data1 = map[r][c];

                if (data1 == 0) {
                    continue;
                }

                for (int k = r + 1; k < N; k++) {
                    int data2 = map[k][c];

                    if (data2 == 0) {
                        continue;
                    }
                    else {
                        if (data1 == data2) {
                            map[r][c] *= 2;
                            map[k][c] = 0;
                            r = k;
                        }
                        break;
                    }
                }
            }
        }
    }
    // 하
    else if (dir == 1) {
        for (int c = 0; c < N; c++) {
            for (int r = N-1; r > 0; r--) {
                int data1 = map[r][c];

                if (data1 == 0) {
                    continue;
                }

                for (int k = r - 1; k >= 0; k--) {
                    int data2 = map[k][c];

                    if (data2 == 0) {
                        continue;
                    }
                    else {
                        if (data1 == data2) {
                            map[r][c] *= 2;
                            map[k][c] = 0;
                            r = k;
                        }
                        break;
                    }
                }
            }
        }
    }
    // 좌
    else if (dir == 2) {
        for (int r = 0; r < N; r++) {
            for (int c = 0; c < N - 1; c++) {
                int data1 = map[r][c];

                if (data1 == 0) {
                    continue;
                }

                for (int k = c + 1; k < N; k++) {
                    int data2 = map[r][k];

                    if (data2 == 0) {
                        continue;
                    }
                    else {
                        if (data1 == data2) {
                            map[r][c] *= 2;
                            map[r][k] = 0;
                            c = k;
                        }
                        break;
                    }
                }
            }
        }
    }
    // 우
    else if (dir == 3) {
        for (int r = 0; r < N; r++) {
            for (int c = N-1; c > 0; c--) {
                int data1 = map[r][c];

                if (data1 == 0) {
                    continue;
                }

                for (int k = c - 1; k >= 0; k--) {
                    int data2 = map[r][k];

                    if (data2 == 0) {
                        continue;
                    }
                    else {
                        if (data1 == data2) {
                            map[r][c] *= 2;
                            map[r][k] = 0;
                            c = k;
                        }
                        break;
                    }
                }
            }
        }
    }
}

int move_map(int dir) {
    int max_value = 0;

    // 상
    if (dir == 0) {
        for (int c = 0; c < N; c++) {
            for (int r = 0; r < N; r++) {
                max_value = max(max_value, map[r][c]);

                if (map[r][c] == 0 && r != N - 1) {
                    for (int k = r+1; k < N; k++) {
                        if (map[k][c] != 0) {
                            map[r][c] = map[k][c];
                            map[k][c] = 0;
                            max_value = max(max_value, map[r][c]);
                            break;
                        }
                    }
                }
            }
        }
    }
    // 하
    else if (dir == 1) {
        for (int c = 0; c < N; c++) {
            for (int r = N-1; r >= 0; r--) {
                max_value = max(max_value, map[r][c]);

                if (map[r][c] == 0 && r != 0) {
                    for (int k = r - 1; k >= 0; k--) {
                        if (map[k][c] != 0) {
                            map[r][c] = map[k][c];
                            map[k][c] = 0;
                            max_value = max(max_value, map[r][c]);
                            break;
                        }
                    }
                }
            }
        }
    }
    //좌
    else if (dir == 2) {
        for (int r = 0; r < N; r++) {
            for (int c = 0; c < N; c++) {
                max_value = max(max_value, map[r][c]);

                if (map[r][c] == 0 && c != N-1) {
                    for (int k = c + 1; k < N; k++) {
                        if (map[r][k] != 0) {
                            map[r][c] = map[r][k];
                            map[r][k] = 0;
                            max_value = max(max_value, map[r][c]);
                            break;
                        }
                    }
                }
            }
        }
    }
    //우
    else if (dir == 3) {
        for (int r = 0; r < N; r++) {
            for (int c = N-1; c >= 0; c--) {
                max_value = max(max_value, map[r][c]);

                if (map[r][c] == 0 && c != 0) {
                    for (int k = c - 1; k >= 0; k--) {
                        if (map[r][k] != 0) {
                            map[r][c] = map[r][k];
                            map[r][k] = 0;
                            max_value = max(max_value, map[r][c]);
                            break;
                        }
                    }
                }
            }
        }
    }

    return max_value;
}

void dfs(int cnt, int max_value) {
    max_dp[cnt] = max(max_dp[cnt], max_value);

    if (cnt >= 5) {
        return;
    }

    // 상, 하, 좌, 우
    for (int dir = 0; dir < 4; dir++) {
        int tmp_map[MAP_MAX_SIZE][MAP_MAX_SIZE];
        copy_map(map, tmp_map);

        combine_map(dir);                  // 기울인 방향으로 합치기
        int value = move_map(dir);      // 빈칸 땡기기 & 현재 최대값 반환
        dfs(cnt + 1, value);

        recovery_map(map, tmp_map);
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin >> N;

    init_map();
    dfs(0, 0);

    cout << max_dp[5] << '\n';

    return 0;
}