BOJ 20056

마법사 상어와 파이어볼 성공

 

 

1 초

512 MB

13402

5276

3173

35.720%

문제

어른 상어가 마법사가 되었고, 파이어볼을 배웠다.

마법사 상어가 크기가 N×N인 격자에 파이어볼 M개를 발사했다. 가장 처음에 파이어볼은 각자 위치에서 이동을 대기하고 있다. i번 파이어볼의 위치는 (ri, ci), 질량은 mi이고, 방향은 di, 속력은 si이다. 위치 (r, c)는 r행 c열을 의미한다.

격자의 행과 열은 1번부터 N번까지 번호가 매겨져 있고, 1번 행은 N번과 연결되어 있고, 1번 열은 N번 열과 연결되어 있다.

파이어볼의 방향은 어떤 칸과 인접한 8개의 칸의 방향을 의미하며, 정수로는 다음과 같다.

7	0	1
6		2
5	4	3

마법사 상어가 모든 파이어볼에게 이동을 명령하면 다음이 일들이 일어난다.

1. 모든 파이어볼이 자신의 방향 di로 속력 si칸 만큼 이동한다.
   • 이동하는 중에는 같은 칸에 여러 개의 파이어볼이 있을 수도 있다.
2. 이동이 모두 끝난 뒤, 2개 이상의 파이어볼이 있는 칸에서는 다음과 같은 일이 일어난다.
   1. 같은 칸에 있는 파이어볼은 모두 하나로 합쳐진다.
   2. 파이어볼은 4개의 파이어볼로 나누어진다.
   3. 나누어진 파이어볼의 질량, 속력, 방향은 다음과 같다.
      1. 질량은 ⌊(합쳐진 파이어볼 질량의 합)/5⌋이다.
      2. 속력은 ⌊(합쳐진 파이어볼 속력의 합)/(합쳐진 파이어볼의 개수)⌋이다.
      3. 합쳐지는 파이어볼의 방향이 모두 홀수이거나 모두 짝수이면, 방향은 0, 2, 4, 6이 되고, 그렇지 않으면 1, 3, 5, 7이 된다.
   4. 질량이 0인 파이어볼은 소멸되어 없어진다.

마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 구해보자.

입력

첫째 줄에 N, M, K가 주어진다.

둘째 줄부터 M개의 줄에 파이어볼의 정보가 한 줄에 하나씩 주어진다. 파이어볼의 정보는 다섯 정수 ri, ci, mi, si, di로 이루어져 있다.

서로 다른 두 파이어볼의 위치가 같은 경우는 입력으로 주어지지 않는다.

출력

마법사 상어가 이동을 K번 명령한 후, 남아있는 파이어볼 질량의 합을 출력한다.

제한

• 4 ≤ N ≤ 50
• 0 ≤ M ≤ N2
• 1 ≤ K ≤ 1,000
• 1 ≤ ri, ci ≤ N
• 1 ≤ mi ≤ 1,000
• 1 ≤ si ≤ 1,000
• 0 ≤ di ≤ 7

풀이

단순 구현문제이므로 문제에 나온대로 구현하면 된다.

파이어볼은 요소가 5개나 되기 때문에 구조체나 클래스로 구현하는게 적합하다고 생각해

struct fb{
    int r,c,m,d,s;
};

 이렇게 객체단위로 사용할 수 있도록 구조체로 만들어주었다.

 

격자무늬 판은 파이어볼이 여러개 들어가 있을때도 쉽게 나타내 줄 수 있게 하기 위해

이차원 벡터로 만들어주었다.

 

vector<fb>v[51][51];

파이어볼이 움직이는 경우는

(현재의 좌표(x값, y값 따로) +  변화량 * 속도) % N 을 해준 경우에서

0이하일 경우에만 N을 따로 더해주고, 0 초과일 경우에는 따로 계산을 해주지 않아도 된다.

while(!v[i][j].empty()){
                    auto move_fb = v[i][j][v[i][j].size()-1];
                    v[i][j].pop_back();
                    int nx = (move_fb.r+dx[move_fb.d]*move_fb.s)%N;
                    int ny = (move_fb.c+dy[move_fb.d]*move_fb.s)%N;
                    if(nx <= 0) nx += N;
                    if(ny <= 0) ny += N;
                    move_fb.r = nx; move_fb.c = ny;
                    q.push(move_fb);
                }

전부 다 움직인 경우에는 이차원 벡터의 모든 인수가 빠져나간 상태이다.

이렇게 구현한 이유는 움직인 다음 바로 벡터에 넣어주면 파이어볼이 여러번 참조가 되어 한번이 아닌 여러번 움직여 질 수 있기 때문이다.

 

 그 다음에는 모든 좌표를 대상으로, 두개 이상의 파이어볼이 있을때 나눠주면 된다.

이 연산은 더하고, 나누는 것이 전부다.

 

다만 속도가 모두 홀수나, 짝수일 경우를 체크해주는것을 잊으면 안된다.

 

if(v[i][j].size() <=1) continue;
                int ms=0,ds1=0, ds2=0,ss=0,count=v[i][j].size();
                while(!v[i][j].empty()){
                    ms += v[i][j][v[i][j].size()-1].m;
                    if(v[i][j][v[i][j].size()-1].d %2 == 0)
                        ds1 += 1;
                    else
                        ds2 += 1;
                    ss += v[i][j][v[i][j].size()-1].s;
                    v[i][j].pop_back();
                }
                ms /= 5; ss /= count;
                if(ms == 0) continue;
                for(int k=0; k<4; k++){
                    fb divide_fb;
                    divide_fb.r = i; 
                    divide_fb.c = j;
                    divide_fb.m = ms;
                    divide_fb.s = ss;
                    if(ds1==0 || ds2 == 0){
                        divide_fb.d = 2*k;
                    }else{
                        divide_fb.d = 2*k+1;
                    }
                    v[i][j].push_back(divide_fb);
                }

 

 

전체 코드

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
struct fb{
    int r,c,m,d,s;
};
int N,M,K,dx[8]={-1,-1,0,1,1,1,0,-1},dy[8]={0,1,1,1,0,-1,-1,-1};
vector<fb>v[51][51];
int main(){
    cin>>N>>M>>K;
    for(int i=0; i<M; i++){
        fb new_fb;
        cin>>new_fb.r>>new_fb.c>>new_fb.m>>new_fb.s>>new_fb.d;
        v[new_fb.r][new_fb.c].push_back(new_fb);
    }
    while(K--){
        queue<fb>q;
        for(int i=1; i<=N; i++)
            for(int j=1; j<=N; j++){
                if(v[i][j].empty()) continue;
                while(!v[i][j].empty()){
                    auto move_fb = v[i][j][v[i][j].size()-1];
                    v[i][j].pop_back();
                    int nx = (move_fb.r+dx[move_fb.d]*move_fb.s)%N;
                    int ny = (move_fb.c+dy[move_fb.d]*move_fb.s)%N;
                    if(nx <= 0) nx += N;
                    if(ny <= 0) ny += N;
                    move_fb.r = nx; move_fb.c = ny;
                    q.push(move_fb);
                }
            }
        while(!q.empty()){
            v[q.front().r][q.front().c].push_back(q.front());
            q.pop();
        }
        for(int i=1; i<=N; i++)
            for(int j=1; j<=N; j++){
                if(v[i][j].size() <=1) continue;
                int ms=0,ds1=0, ds2=0,ss=0,count=v[i][j].size();
                while(!v[i][j].empty()){
                    ms += v[i][j][v[i][j].size()-1].m;
                    if(v[i][j][v[i][j].size()-1].d %2 == 0)
                        ds1 += 1;
                    else
                        ds2 += 1;
                    ss += v[i][j][v[i][j].size()-1].s;
                    v[i][j].pop_back();
                }
                ms /= 5; ss /= count;
                if(ms == 0) continue;
                for(int k=0; k<4; k++){
                    fb divide_fb;
                    divide_fb.r = i; 
                    divide_fb.c = j;
                    divide_fb.m = ms;
                    divide_fb.s = ss;
                    if(ds1==0 || ds2 == 0){
                        divide_fb.d = 2*k;
                    }else{
                        divide_fb.d = 2*k+1;
                    }
                    v[i][j].push_back(divide_fb);
                }
            }
    }
    int ans = 0;
    for(int i=1; i<=N; i++)
        for(int j=1; j<=N; j++){
            if(v[i][j].empty()) continue;
            for(auto f : v[i][j]){
                ans += f.m;
            }
        }
    cout<<ans;

}