[backjoon]21610 마법사 상어와 비바라기 java

요청사항에 따라 구현하였다.

구현 중에 주의해야할 부분은 구름은 경계를 넘나들어서 나머지 연산을 이용하여 올바르게 값을 넣어주어야하고.

바로 직전에 구름이 있던 자리엔 구름이 생기면 안 되기에 이 점도 유의해줘야한다.

 

 

import java.io.*;
import java.util.*;
 
class Main {
    static int N;
    static int[][] map;
    static ArrayList<Dot> cloud;//, ↙  ←, ↖, ↑, ↗, →, ↘, ↓
    static int[][] dirs = {{1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1},{1, 1}, {1, 0}};
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        st = new StringTokenizer(br.readLine());
        
        N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        
        map = new int[N][N];
        
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                int cur = Integer.parseInt(st.nextToken());
                map[i][j] = cur;
            }w
        }
        
        //비구름 최초 위치.
        cloud = new ArrayList<>();
        cloud.add(new Dot(N-1, 0));
        cloud.add(new Dot(N-1, 1));
        cloud.add(new Dot(N-2, 0));
        cloud.add(new Dot(N-2, 1));
        
        while(M-- >0) {
            st = new StringTokenizer(br.readLine());
            int d = Integer.parseInt(st.nextToken()) % 8;
            int s = Integer.parseInt(st.nextToken());
            
            //구름 이둉
            ArrayList<Dot> result = move(d, s);
            boolean[][] marked = new boolean[N][N];
            //구름 칸 비 내리기 + 1
            for(Dot dot : result) {
                map[dot.row][dot.col] += 1;
                marked[dot.row][dot.col]  = true;
            }
            //구름 칸에 물복사버그 : 대각선 방향으로 거리가 1인 칸에 물이 있는 바구니의 수 만큼 바구니의 물 양이 증가. 대각선 원형이 아니다.
            for(Dot dot : result) {
                
                int[] dirction = {0, 2, 4, 6};
                
                for(int i = 0; i < 4; i++) {
                    int curD = dirction[i];
                    int nextR = dot.row + dirs[curD][0];
                    int nextC = dot.col + dirs[curD][1];
                    
                    if(nextR< 0 || nextC < 0 || nextR >= N || nextC >= N) continue;
                    if(map[nextR][nextC] > 0) map[dot.row][dot.col]++;
                }
            }
            //구름 찾기.
            cloud = new ArrayList<>();
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if(map[i][j] < 2) continue;
                    if(marked[i][j]) continue;
                    marked[i][j] = true;
                    cloud.add(new Dot(i, j));
                    map[i][j] -= 2;
                }
            }
 
        }
        int answer = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                answer += map[i][j];
            }
        }
        System.out.println(answer);
    }
    public static ArrayList<Dot> move(int d, int s) {
        ArrayList<Dot> result = new ArrayList<>();
        for(Dot cur : cloud) {
            int nextR = cur.row + dirs[d][0]*s;
            int nextC = cur.col + dirs[d][1]*s;
            
            nextR = (nextR + 100*N) % N;
            nextC = (nextC + 100*N) % N;
            result.add(new Dot(nextR, nextC));
        }
        return result;
    }
}
class Dot{
    int row;
    int col;
    Dot(int r, int c){
        this.row = r;
        this.col = c;
    }
}