[Java]Programmers 빛의 경로 사이클

// d :  0 ->  1 ->  2 ->  3 (진입방향 int로 변경)
// D :  L ->  U ->  R ->  D (진입방향 좌 -> 상 -> 우 -> 하)
// R :  0 -> -1 ->  0 ->  1 (상하방향 움직임)
// C : -1 ->  0 ->  1 ->  0 (좌우방향 움직임)
int[] dr = {0, -1, 0, 1};
int[] dc = {-1, 0, 1, 0};
int d; // 초기 진입하는 방향
switch(g) { // g : 현재 격자 칸에 적힌 알파벳

    // 'S' : 그대로 진행
    case 'S': break;

    // 'R' : 현재 방향에서 1 증가시킴
    case 'R': d++; d %= 4; break;

    // 'L' : 현재 방향에서 1 감소시킴, 0보다 작아질 수 있으니 Modular로 회전
    case 'L': d--; d += 4; d %= 4; break;
}

int nr = r + dr[d]; // 다음 위치로 이동
nr += R; nr %= R; // 벽 크기만큼 더해준 뒤, 모듈러 연산을 통해 반대쪽 위치로 이동
int nc = c + dc[d]; // 다음 위치로 이동
nc += C; nc %= C; // 벽 크기만큼 더해준 뒤, 모듈러 연산을 통해 반대쪽 위치로 이동

import java.util.*;

class Solution {

    // 격자 크기
    int R, C;

    // 정답을 담을 동적 배열
    List<Integer> answer = new ArrayList<>();

    public int[] solution(String[] grid) {

        // 격자 크기 초기화
        R = grid.length; C = grid[0].length();

        // String[] 배열로부터 char[][] 배열 생성
        char[][] grid_ = new char[R][C];
        for (int i = 0; i < R; i++) grid_[i] = grid[i].toCharArray();

        // 방문처리를 위한 배열 생성
        boolean[][][] visited = new boolean[R][C][4];

        // 각 격자 4방향 탐색
        for (int r = 0; r < R; r++) {
            for (int c = 0; c < C; c++) {
                for (int d = 0; d < 4; d++) {

                    // 방문한 방향의 빛은 재탐색하지 않음
                    if (visited[r][c][d]) continue;

                    // DFS 수행(현재 위치 및 방향에서 1번 이동한 후 다음위치부터 DFS)
                    dfs(new int[] {r, c, d}, move(grid_[r][c], r, c, d), grid_, visited);
                }
            }
        }

        // 동적배열 정렬 후 정적배열로 변환
        answer.sort(Comparator.naturalOrder());
        int[] ret = new int[answer.size()];
        for (int i = 0; i < answer.size(); i++) ret[i] = answer.get(i);
        return ret;
    }

    // 깊이우선 탐색
    void dfs(int[] start, int[] current, char[][] grid_, boolean[][][] visited) {

        // 스택을 활용한 깊이우선 탐색
        Stack<int[]> s = new Stack<>();

        // 처음 위치 방문처리 후 스택에 삽입
        visited[current[0]][current[1]][current[2]] = true;
        s.push(new int[] {current[0], current[1], current[2], 1});

        // 스택이 빌때까지 완전탐색 수행
        while (!s.isEmpty()) {
            current = s.pop();

            // 시작지점으로 돌아오면 DFS 종료
            if (start[0] == current[0] && start[1] == current[1] && start[2] == current[2]) {
                answer.add(current[3]);
                return;
            }

            // 다음위치로 이동
            int[] next = move(grid_[current[0]][current[1]], current[0], current[1], current[2]);

            // 방문처리 후 스택에 삽입
            visited[next[0]][next[1]][next[2]] = true;
            s.push(new int[] {next[0], next[1], next[2], current[3] + 1});
        }
    }

    // 빛의 이동 구현(현재위치, 방향, 알파벳을 토대로 다음 빛의 위치와 이동방향 반환)
    int[] dr = {0, -1, 0, 1};
    int[] dc = {-1, 0, 1, 0};
    int[] move(char g, int r, int c, int d) {

        // 방향 전환
        switch(g) {
            case 'S': break;
            case 'R': d++; d %= 4; break;
            case 'L': d--; d += 4; d %= 4; break;
        }

        // 벽에 닿을 때 처리
        int nr = r + dr[d]; nr += R; nr %= R;
        int nc = c + dc[d]; nc += C; nc %= C;

        return new int[] {nr, nc, d};
    }
}