[ SWEA 1873 ] 상호의 배틀필드 (C++)

SW Expert Academy의 상호의 배틀필드(1873 / D3) 문제이다.

[ 문제풀이 ]

1) 이 문제는 주어진 명령에 맞게 탱크의 진행방향과, 맵의 상태를 잘 조절해가면서 진행해나가야 하는 문제이다.

   가장 핵심은 탱크의 진행방향이라고 생각한다.

   처음 입력 받을 때, 탱크의 생김새를 보고 현재 탱크가 바라보고 있는 곳을 진행방향으로 설정해주자.

   첫 진행방향을 설정했다면, 이제부터는 명령어들을 해결해보자.

    'U' / 'D' / 'L' / 'R'의 명령어가 나온다면 명령어가 가르키는 해당 방향으로 탱크의 방향을 바꾼 후, 그 방향으로 전진할 수

   있다면 전진을 하고, 그렇지 않다면 제자리에서 방향만 바꿔줘야 한다.

   여기서 전진할 수 없다는 것은, 전진하려는 칸이 맵의 범위를 벗어난 경우, 벽돌인 경우, 강철인경우, 물인 경우에는

   전진을 할 수 없다. 즉, 평지일 때만 탱크는 전진이 가능하다.

   'S'의 명령어가 나오게 된다면, 포탄을 발사하는데, 현재 탱크가 바라보고 있는 방향을 포탄을 발사하게 된다.

   포탄은 중간에 강철로 된 벽을 만나게 되면 그 자리에서 소멸하게 되고, 맵 밖으로 나가도 소멸되고, 벽돌로 만들어진

   벽에 부딪히면 그 벽돌로 만들어진 지형을 평지로 만들고 소멸하게 된다.

  

[ 소스코드 ]

#include<iostream>
#include<vector>
#include<cstring>
 
#define endl "\n"
#define MAX 20
using namespace std;
 
int H, W, N;
char MAP[MAX][MAX];
 
vector<char> Cmd;
pair<pair<int, int>, int> Tank;
 
int dx[] = { 0, 0, 1, -1 };
int dy[] = { 1, -1, 0, 0 };
 
void Initialize()
{
    Tank.first.first = Tank.first.second = Tank.second = -1;
    Cmd.clear();
    memset(MAP, 0, sizeof(MAP));
}
 
void Input()
{
    cin >> H >> W;
    for (int i = 0; i < H; i++)
    {
        for (int j = 0; j < W; j++)
        {
            cin >> MAP[i][j];
            if (MAP[i][j] == '<' || MAP[i][j] == '>' || MAP[i][j] == '^' || MAP[i][j] == 'v')
            {
                Tank.first.first = i;
                Tank.first.second = j;
                if (MAP[i][j] == '<') Tank.second = 1;
                else if (MAP[i][j] == '>') Tank.second = 0;
                else if (MAP[i][j] == '^') Tank.second = 3;
                else if (MAP[i][j] == 'v') Tank.second = 2;
            }
        }
    }
    cin >> N;
    for (int i = 0; i < N; i++)
    {
        char A; cin >> A;
        Cmd.push_back(A);
    }
}
 
void Shooting()
{
    int x = Tank.first.first;
    int y = Tank.first.second;
    int dir = Tank.second;
 
    int nx = x + dx[dir];
    int ny = y + dy[dir];
    while (1)
    {
        if (nx < 0 || ny < 0 || nx >= H || ny >= W) break;
 
        if (MAP[nx][ny] == '#') break;
        else if (MAP[nx][ny] == '*')
        {
            MAP[nx][ny] = '.';
            break;
        }
        else
        {
            nx = nx + dx[dir];
            ny = ny + dy[dir];
        }
    }
}
 
void Solution()
{
    for (int i = 0; i < Cmd.size(); i++)
    {
        char C = Cmd[i];
 
        if (C == 'S') Shooting();
        else if (C == 'U')
        {
            Tank.second = 3;
            int x = Tank.first.first;
            int y = Tank.first.second;
            int nx = x + dx[Tank.second];
            int ny = y + dy[Tank.second];
 
            if (nx < 0 || ny < 0 || nx >= H || ny >= W)
            {
                MAP[x][y] = '^';
            }
            else
            {
                if (MAP[nx][ny] == '.')
                {
                    Tank.first.first = nx;
                    Tank.first.second = ny;
                    MAP[nx][ny] = '^';
                    MAP[x][y] = '.';
                }
                else MAP[x][y] = '^';
            }
        }
        else if (C == 'D')
        {
            Tank.second = 2;
            int x = Tank.first.first;
            int y = Tank.first.second;
            int nx = x + dx[Tank.second];
            int ny = y + dy[Tank.second];
 
            if (nx < 0 || ny < 0 || nx >= H || ny >= W)
            {
                MAP[x][y] = 'v';
            }
            else
            {
                if (MAP[nx][ny] == '.')
                {
                    Tank.first.first = nx;
                    Tank.first.second = ny;
                    MAP[nx][ny] = 'v';
                    MAP[x][y] = '.';
                }
                else MAP[x][y] = 'v';
            }
        }
        else if (C == 'L')
        {
            Tank.second = 1;
            int x = Tank.first.first;
            int y = Tank.first.second;
            int nx = x + dx[Tank.second];
            int ny = y + dy[Tank.second];
 
            if (nx < 0 || ny < 0 || nx >= H || ny >= W)
            {
                MAP[x][y] = '<';
            }
            else
            {
                if (MAP[nx][ny] == '.')
                {
                    Tank.first.first = nx;
                    Tank.first.second = ny;
                    MAP[nx][ny] = '<';
                    MAP[x][y] = '.';
                }
                else MAP[x][y] = '<';
            }
        }
        else if (C == 'R')
        {
            Tank.second = 0;
            int x = Tank.first.first;
            int y = Tank.first.second;
            int nx = x + dx[Tank.second];
            int ny = y + dy[Tank.second];
 
            if (nx < 0 || ny < 0 || nx >= H || ny >= W)
            {
                MAP[x][y] = '>';
            }
            else
            {
                if (MAP[nx][ny] == '.')
                {
                    Tank.first.first = nx;
                    Tank.first.second = ny;
                    MAP[nx][ny] = '>';
                    MAP[x][y] = '.';
                }
                else MAP[x][y] = '>';
            }
        }
    }
}
 
void Print()
{
    for (int i = 0; i < H; i++)
    {
        for (int j = 0; j < W; j++)
        {
            cout << MAP[i][j];
        }
        cout << endl;
    }
}
 
void Solve()
{
    int Tc; cin >> Tc;
    for (int T = 1; T <= Tc; T++)
    {
        Initialize();
        Input();
        Solution();
 
        cout << "#" << T << " ";
        Print();
    }
}
 
int main(void)
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
//    freopen("Input.txt", "r", stdin);
    Solve();
 
    return 0;
}