SEA5650_[모의 SW 역량테스트] 핀볼 게임

https://www.swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRF8s6ezEDFAUo

문제정리

1. 삼각형(1,2,3,4) , 사각형(5) , 웜홀(6,7,8,9,10) , 블랙홀(-1)

2. 핀볼

(1) 게임판 위에서 핀볼 하나가 상, 하, 좌, 우 중 한 방향으로 움직인다

(2) 핀볼은 블록이나 웜홀 또는 블랙홀을 만나지 않는 한 현재 방향을 유지하면서 계속 직진한다

(3) 블록의 수평면이나 수직면, 벽을 만날 경우 방향을 바꿔 반대 방향으로 돌아온다

(4) 경사면을 만날 경우에는 직각으로 진행 방향이 꺾이게 된다

(5) 웜홀에 빠지면 동일한 숫자를 가진 다른 반대편 웜홀로 빠져 나오게 되며 진행방향은 그대로 유지된다

(6) 핀볼이 블랙홀을 만나면 핀볼이 사라지게 되어 게임은 끝나게 된다

(7) 핀볼이 출발 위치로 돌아오면 게임은 끝난다

3. 점수는 벽이나 블록에 부딪힌 횟수가 된다(웜홀은 아니다)

4. 블랙홀에 빠져서 게임이 끝나더라도, 획득한 점수는 남아있게 된다

5. 게임판 위에서 출발 위치와 진행 방향을 임의로 선정 가능할 때, 게임에서 얻을 수 있는 점수의 최댓값을 구하여라

6. 단 블록, 웜홀 또는 블랙홀이 있는 위치에서는 출발할 수 없다

문제 issue

1. 헷갈리는 구현이라서 빡 집중 해야한다

2. 핀볼의 위치가 바뀔때 뿐만 아니라 방향이 바뀔때 핀볼의 위치를 다시 원래 상태로 해야한다

3. 처음에 소스코드를 구성하고 답이 틀리거나 에러가 뜨면 바로 디버깅을 시작하는 습관을 갖도록 해야겠다...

(1) map에 마킹을 안해서 디버깅이 어렵다고 생각하더라도 어느 부분에서 내가 원하는 값이 나오는가??를 어디에서 검사해야할까??를 계속 생각해봐야 겠다...

해결흐름

1. map에서 0인곳의 위치를 큐에 저장한다 , 웜홀은 list에 웜홀의 번호, 위치r c를 저장한다

2. 큐에 있는 위치 하나에서 4방향으로 나눠서 검사한다

3. ball_r , ball_c를 해당방향(dir)로 이동 시킨다

4. 종료하는 경우를 검사한다

5. 크게 벽을 만날 경우와 벽이 아닌 경우로 나눈다(범위를 넘어가는 경우와 아닌경우)

6. 벽을 만날 경우 score++해주고 어느벽이냐에 따라서 방향을 갱신해준다

7. 벽이 아닐 경우는 블록 혹은 웜홀이다

8. 블록은 score++해주고 그때의 블록 번호와 방향에 따라서 방향을 갱신해준다

9. 웜홀은 list에서 웜홀의 번호는 같고 위치는 다른 짝 웜홀을 찾아서 ball_r , ball_c를 갱신한다

10. max 값을 갱신한다

소스코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class Solution {
 
    static class zero {
        int r;
        int c;
 
        public zero(int r, int c) {
            super();
            this.r = r;
            this.c = c;
        }
    }
 
    static class warm_hole {
        int hole_nubmer;
        int hole_r;
        int hole_c;
 
        public warm_hole(int hole_nubmer, int hole_r, int hole_c) {
            super();
            this.hole_nubmer = hole_nubmer;
            this.hole_r = hole_r;
            this.hole_c = hole_c;
        }
    }
 
    public static void main(String[] args) throws Exception {
        // input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int test_case = Integer.parseInt(br.readLine().trim());
        for (int tc = 1; tc <= test_case; tc++) {
            int N = Integer.parseInt(br.readLine().trim());
            int[][] map = new int[N][N];
            Queue<zero> q = new LinkedList<zero>();
            List<warm_hole> list = new ArrayList<warm_hole>();
            for (int i = 0; i < N; i++) {
                StringTokenizer st = new StringTokenizer(br.readLine().trim());
                for (int j = 0; j < N; j++) {
                    int number = Integer.parseInt(st.nextToken());
                    map[i][j] = number;
                    if (number == 0) {
                        q.add(new zero(i, j));
                    } else if (number == 6 || number == 7 || number == 8 || number == 9 || number == 10) {
                        list.add(new warm_hole(number, i, j));
                    }
                }
            }
 
            // start
            int[] dr = { -1, 0, 1, 0 };
            int[] dc = { 0, 1, 0, -1 };
            int max = Integer.MIN_VALUE;
            while (!q.isEmpty()) {
                zero z = q.poll();
                int zero_r = z.r;
                int zero_c = z.c;
                int ball_r = z.r;
                int ball_c = z.c;
                // 0:위, 1:오른쪽, 2:아래, 3:왼쪽
                for (int i = 0; i < 4; i++) {
                    int score = 0;
                    int dir = i;
                    ball_r = z.r;
                    ball_c = z.c;
                    while (true) {
                        // 이동
                        ball_r += dr[dir];
                        ball_c += dc[dir];
                        // 종료하는 경우
                        if(ball_r == zero_r && ball_c == zero_c)
                            break;
                        if (ball_r >= 0 && ball_r < N && ball_c >= 0 && ball_c < N && map[ball_r][ball_c] == -1)
                            break;
                        // 벽
                        if (ball_r < 0 || ball_r >= N || ball_c < 0 || ball_c >= N) {
                            score++;
                            if (ball_r < 0) {
                                dir = 2;
                            } else if (ball_r >= N) {
                                dir = 0;
                            } else if (ball_c < 0) {
                                dir = 1;
                            } else if (ball_c >= N) {
                                dir = 3;
                            }
                        }
                        if (ball_r >= 0 && ball_r < N && ball_c >= 0 && ball_c < N) {
                            // 블록
                            if (map[ball_r][ball_c] == 1 || map[ball_r][ball_c] == 2 || map[ball_r][ball_c] == 3
                                    || map[ball_r][ball_c] == 4 || map[ball_r][ball_c] == 5) {
                                score++;
                                if (map[ball_r][ball_c] == 1) {
                                    if (dir == 0) {
                                        dir = 2;
                                    } else if (dir == 1) {
                                        dir = 3;
                                    } else if (dir == 2) {
                                        dir = 1;
                                    } else if (dir == 3) {
                                        dir = 0;
                                    }
                                } else if (map[ball_r][ball_c] == 2) {
                                    if (dir == 0) {
                                        dir = 1;
                                    } else if (dir == 1) {
                                        dir = 3;
                                    } else if (dir == 2) {
                                        dir = 0;
                                    } else if (dir == 3) {
                                        dir = 2;
                                    }
                                } else if (map[ball_r][ball_c] == 3) {
                                    if (dir == 0) {
                                        dir = 3;
                                    } else if (dir == 1) {
                                        dir = 2;
                                    } else if (dir == 2) {
                                        dir = 0;
                                    } else if (dir == 3) {
                                        dir = 1;
                                    }
                                } else if (map[ball_r][ball_c] == 4) {
                                    if (dir == 0) {
                                        dir = 2;
                                    } else if (dir == 1) {
                                        dir = 0;
                                    } else if (dir == 2) {
                                        dir = 3;
                                    } else if (dir == 3) {
                                        dir = 1;
                                    }
                                } else if (map[ball_r][ball_c] == 5) {
                                    if (dir == 0) {
                                        dir = 2;
                                    } else if (dir == 1) {
                                        dir = 3;
                                    } else if (dir == 2) {
                                        dir = 0;
                                    } else if (dir == 3) {
                                        dir = 1;
                                    }
                                }
                            }
                            // 웜홀
                            else if (map[ball_r][ball_c] == 6 || map[ball_r][ball_c] == 7 || map[ball_r][ball_c] == 8
                                    || map[ball_r][ball_c] == 9 || map[ball_r][ball_c] == 10) {
                                for (int j = 0; j < list.size(); j++) {
                                    if (map[ball_r][ball_c] == list.get(j).hole_nubmer
                                            && (ball_r != list.get(j).hole_r || ball_c != list.get(j).hole_c)) {
                                        ball_r = list.get(j).hole_r;
                                        ball_c = list.get(j).hole_c;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    if (max < score)
                        max = score;
                }
            }
            System.out.println("#" + tc + " " + max);
        } // end of tc
    } // end of main
} // end of class