[BaekJoon/백준] 20056번 마법사 상어와 파이어볼

 

 

난 벡터를 새로 갈아치울 때 보통 그냥 temp에 새로 만들어 놓고

 

Original_v = temp_v 이렇게 사용하곤 한다.

좋은 방법은 아니겠지만..

 

 

A방법으로 했다가, B로 바꿨다.

 

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;


int N, M, K;

int mx[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int my[8] = {0, 1, 1, 1, 0, -1, -1, -1};


int main() {
    
    
    cin >> N >> M >> K;
        
    vector<vector<int>> FIRE;
    
    
    for(int i = 0; i < M; i++) {
        int a, b, c, d, e;
        cin >> a >> b >> c >> d >> e;
        
        FIRE.push_back({a, b, c, d, e});
    }
    
    
    while(K--) {
        
        int F_SIZE = FIRE.size();
        
        for(int i = 0; i < F_SIZE; i++) {
            
            
            int r = FIRE[i][0];
            int c = FIRE[i][1];
            
            int s = FIRE[i][3];
            int d = FIRE[i][4];
            
            
            // 맵이 이어져있는 것에 대한 처리
            r = (r + (mx[d] * s)) % N;
            c = (c + (my[d] * s)) % N;
            
            if(r < 0)
                r = N - (abs(r) % N);
            if(c < 0)
                c = N - (abs(c) % N);
            
            
            FIRE[i][0] = r;
            FIRE[i][1] = c;
            
            // r, c인 [i][0], [i][1]은 움직여준 상태
            
        }
        
        
        vector<vector<int>> NEW_FIRE;
        
        
        vector<vector<int>> CAL(N*N, vector<int>(4, 0)); // {질량, 속력, 방향계산, 갯수, 원래방향}
        
        for(int i = 0; i < F_SIZE; i++) {
            
            int r = FIRE[i][0];
            int c = FIRE[i][1];
            
            CAL[r * N + c][0] += FIRE[i][2]; // 질량 누적
            CAL[r * N + c][1] += FIRE[i][3]; // 속력 누적
            
            if(FIRE[i][4] % 2 == 0) // 짝수
                CAL[r * N + c][2]++;
            else // 홀수
                CAL[r * N + c][2]--;
            
            CAL[r * N + c][3]++; // 갯수 누적
            
            CAL[r * N + c][4] = FIRE[i][4]; // 한개일 때를 대비해 계속 가져가야하는 방향 저장

            
        }
        
        
        for(int i = 0; i < N * N; i++) {
                        
            int ss = CAL[i][3];
            
            if(ss == 1) {
                
                NEW_FIRE.push_back({(i / N), (i % N), CAL[i][0], CAL[i][1], CAL[i][4]});

                
            } else if(ss > 1) {
                
                CAL[i][0] = CAL[i][0] / 5;
                CAL[i][1] = CAL[i][1] / ss;
                
                int DIFF = 1;
                
                if(CAL[i][2] % ss == 0 && CAL[i][2] != 0) // 두번쨰 조건은,, +1 -1 해서 0이 된 경우가 있을 수 있기 때문이다..
                    DIFF = 0; // 다 짝수 아니면 홀수다.
                
                if(CAL[i][0] == 0)
                    continue;
                    
                for(int j = 0; j < 4; j++) {
                    NEW_FIRE.push_back({i / N, i % N, CAL[i][0], CAL[i][1], j * 2 + DIFF});
                }
                
                
            }
        }
        
        FIRE = NEW_FIRE;
        
    }
    
    int T = 0;
    for(int i = 0; i < FIRE.size(); i++) {
        T += FIRE[i][2];
    }
    
    cout << T << "\n";
    
}

 

도중에 막혀서, 10분간 머리 식히고

처음부터 다시 문제점을 찾아나가니까 금방 해결할 수 있었다.

 

 

무언가에 너무 매몰되어 있을 수도 있으니,

이렇게 한걸음 물러서서 잠깐 환기시키고 다시 진행하는게 확실히 좋은 방법임을 다시한번 느낀다.

 

---

started at 19:57

ended at 22:21