[코드트리] 싸움땅 - 시뮬레이션 (기출문제)

삼성 SW 역량테스트 2022 하반기 기출

싸움땅

인기 게임인 싸움땅은 다음과 같은 방식으로 진행됩니다. 게임은 n * n 크기의 격자에서 진행되며, 각각의 격자에는 무기들이 있을 수 있습니다. 초기에는 무기들이 없는 빈 격자에 플레이어들이 위치하며 각 플레이어는 초기 능력치를 가집니다. 각 플레이어의 초기 능력치는 모두 다릅니다. 게임은 다음과 같은 방식으로 진행됩니다.

아래 그림에서 빨간색 배경의 숫자는 총의 경우 공격력을, 플레이어의 경우 초기 능력치를 의미하며, 노란색 배경의 숫자는 플레이어의 번호를 의미합니다.

하나의 라운드는 다음의 과정에 걸쳐 진행됩니다.

 

1-1. 첫 번째 플레이어부터 순차적으로 본인이 향하고 있는 방향대로 한 칸만큼 이동합니다. 만약 해당 방향으로 나갈 때 격자를 벗어나는 경우에는 정반대 방향으로 방향을 바꾸어서 1만큼 이동합니다.

 

(중략)

 

k 라운드 동안 게임을 진행하면서 각 플레이어들이 획득한 포인트를 출력하는 프로그램을 작성해보세요.

입력 형식

첫 번째 줄에 n, m, k가 공백을 사이에 두고 주어집니다. n은 격자의 크기, m은 플레이어의 수, k는 라운드의 수를 의미합니다.

이후 n개의 줄에 걸쳐 격자에 있는 총의 정보가 주어집니다. 각 줄에는 각각의 행에 해당하는 n개의 수가 공백을 사이에 두고 주어집니다. 숫자 0은 빈 칸, 0보다 큰 값은 총의 공격력을 의미합니다.

이후 m개의 줄에 걸쳐 플레이어들의 정보 x, y, d, s가 공백을 사이에 두고 주어집니다. (x, y)는 플레이어의 위치, d는 방향, s는 플레이어의 초기 능력치를 의미하고 각 플레이어의 초기 능력치는 모두 다릅니다. 방향 d는 0부터 3까지 순서대로 ↑, →, ↓, ←을 의미합니다.

각 플레이어의 위치는 겹쳐져 주어지지 않으며, 플레이어의 초기 위치에는 총이 존재하지 않습니다.

• 2 ≤ n ≤ 20
• 1 ≤ m ≤ min(n2,30)
• 1 ≤ k ≤ 500
• 1 ≤ 총의 공격력 ≤ 100,000
• 1 ≤ s ≤ 100
• 1 ≤ x, y ≤ n

출력 형식

k 라운드 동안 게임을 진행하면서 각 플레이어들이 획득한 포인트를 공백을 사이에 두고 출력하세요.

---

 

삼성 빡구현문제 재밌네요...

 

알고리즘은 특별한 거 없이 차근차근 구현해내면 되는 문제라서 쉬웠고

1시간만에 구현은 끝냈는데,,

사소한거 몇 개 놓치는 바람에 디버깅도 1시간 정도 걸림ㅋㅋ

그래도 해설 안보고 풀어내서 왕뿌듯!!!!!!

 

 

 

 

나의 풀이

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int n;
int m;
int k;
int map[21][21][10]; // 총 맵(최대 공격력인 총부터 내림차순)
int pMap[21][21];  // 플레이어 좌표, 값은 플레이어 번호
int pInfo[401][2]; //d는 방향, s는 플레이어의 초기 능력치
int pGun[401]; // 플레이어의 총 정보
int point[401]; // 플레이어 포인트 정보
int px[4] = {-1,0,1,0};
int py[4] = {0,1,0,-1}; // 0:↑, 1:→, 2:↓, 3:←
int loserGun;

bool desc(int a, int b) {
    return a > b;
}

void checkGun(int player, int x, int y){
    if(map[x][y][0]==0) return;
    if(pGun[player] >= map[x][y][0]){
        return;
    }
    else{
        int low = pGun[player];
        pGun[player] = map[x][y][0];
        map[x][y][0] = low;
        sort(map[x][y], map[x][y]+10, desc);
    }
    return;
}

pair<int,int> fightPlayers(int newPlayer, int x, int y){
    int stayPlayer = pMap[x][y];
    int stayPower = pInfo[stayPlayer][1] + pGun[stayPlayer];
    int newPower = pInfo[newPlayer][1] + pGun[newPlayer];
    if(stayPower == newPower){
        if(pInfo[stayPlayer][1] > pInfo[newPlayer][1]) return {stayPlayer, newPlayer};
        else return {newPlayer, stayPlayer};
    }
    if(stayPower > newPower){
        point[stayPlayer] += (stayPower-newPower);
        return {stayPlayer, newPlayer};
    }
    else{
        point[newPlayer] += (newPower-stayPower);
        return {newPlayer, stayPlayer};
    }
}

void moveLoser(int loser, int x, int y){
    loserGun = pGun[loser];
    pGun[loser] = 0;
    for(int i=0; i<10; ++i){
        if(map[x][y][i]==0) {
            map[x][y][i] = loserGun;
            break;
        }
    }
    
    sort(map[x][y], map[x][y]+10, desc); // 0인덱스가 최대 공격력인 총을 가짐
    
    for(int i=0; i<4; ++i){
        int nx = x + px[pInfo[loser][0]];
        int ny = y + py[pInfo[loser][0]];
        if(nx<1 || ny<1 || nx>n || ny>n || pMap[nx][ny]>0){
            if(pInfo[loser][0]<3) {
                pInfo[loser][0]++;
            } else pInfo[loser][0] = 0;

        }else{
            pMap[x][y] = 0;
            pMap[nx][ny] = loser;
            checkGun(loser, nx, ny);
            break;
        }
    }
    
}

void getWinner(int winner, int x, int y){
    checkGun(winner, x, y);
}

void movePlayer(){
    for(int i=1; i<=m; ++i){
        bool nextTurn = false;
        for(int a=1;a<=n; ++a){
            for(int b=1; b<=n; ++b){
                if(pMap[a][b] == i){
                    int move = pInfo[i][0];
                    int nx = a + px[move];
                    int ny = b + py[move];

                    if(nx<1 || ny<1 || nx>n || ny>n){
                        if(move==0||move==1) {
                            pInfo[i][0] += 2;
                            move += 2;
                            nx = a + px[move];
                            ny = b + py[move];
                        } else {
                            pInfo[i][0] -= 2;
                            move -= 2;
                            nx = a + px[move];
                            ny = b + py[move];
                        }
                    }
                    pMap[a][b] = 0;
                    if(pMap[nx][ny] == 0) { // 빈자리면 총 확인
                        pMap[nx][ny] = i;
                        checkGun(i, nx, ny); 
                    }
                    else{ // 플레이어가 있으면 싸움
                        pair<int,int> wl = fightPlayers(i, nx, ny);
                        moveLoser(wl.second, nx, ny); // 진 사람 이동시키기
                        getWinner(wl.first, nx, ny); // 더 좋은 총 획득
                        pMap[nx][ny] = wl.first;
                    }
                    nextTurn = true;
                    break;
                }
            }
            if(nextTurn) break;
        }
    }
}


int main() {
    int x;
    int y;
    cin >> n >> m >> k; // n 격자의 크기, m 플레이어의 수, k 라운드의 수
    for(int i=1; i<=n; ++i){
        for(int j=1; j<=n; ++j) cin>>map[i][j][0];
    }
    for(int i=1; i<=m; ++i){
        cin>>x>>y;
        pMap[x][y] = i;
        cin>>pInfo[i][0]>>pInfo[i][1];
    }

    for(int i=0; i<k; ++i){
        movePlayer();
        // cout <<"--------------point-----\n";
        // for (int i = 1; i<=m; ++i){
        // cout << point[i] << " ";
        // }

        // cout <<"-map-\n";
        // for (int i = 1; i<=n; ++i){
        //     for (int j = 1; j<=n; ++j){
        //         cout << map[i][j][0] << " ";
        //     } cout <<"\n";
        // }
        // cout <<"--player--\n";
        // for (int i = 1; i<=n; ++i){
        //     for (int j = 1; j<=n; ++j){
        //         cout << pMap[i][j] << " ";
        //     } cout <<"\n";
        // }
    }

    for (int i = 1; i<=m; ++i){
        cout << point[i] << " ";
    }
        return 0;
}