[Java]백준 16927 배열 돌리기 2

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    static int N;
    static int M;
    static int R;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        R = Integer.parseInt(st.nextToken());

        int[][] NM = new int[N][M];
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                NM[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        for (int d = 0; d < Math.min(M, N) / 2; d++) { // M, N 중 최솟값의 절반만큼 수행
            rotate(d, N - d, d, M - d, NM);
        }

        System.out.print(toStringInt2(NM));  // 정답 출력
    }

    /*
     * [조건]
     * 시간제한 : 1초 / 메모리 제한 : 512MB
     * N, M < 300, R < 10^9, 1 < 원소 < 10^8
     * min(N, M) % 2 = 0(M + N은 짝수)
     * [풀이]
     * 2(m + n) 크기의 배열에 원소들을 담고, R % 2(m + n)의 값만큼 반시계 방향으로 이동하면 해당위치 값을 구할 수 있다.
     * 모든 깊이에서 해당 로직을 수행하기 위해 (n / 2 <= 1)가 될때까지 위 로직을 수행한다.
     */
    static void rotate(int n0, int n1, int m0, int m1, int[][] NM) {


        // 배열 크기는 전체 길이에서 네 귀퉁이를 한번씩 빼주기
        int[] arr = new int[(n1 - n0 + m1 - m0) * 2 - 4];

        // 배열에 반시계방향으로 원소 담기
        getArrElement(n0, n1, m0, m1, arr, NM);

        // 배열 값 이동시키기
        int l = arr.length;
        int[] newArr = new int[l];
        int p = R % l;  // 최적화를 위해 R을 행렬의 길이로 나눈 나머지를 구해서 이동시키기
        for (int i = 0; i < l; i++) {  //
            int np = i - p >= 0? i - p : i - p + l;
            newArr[i] = arr[np];
        }

        // 이동한 값 배열에 넣기
        setArrElement(n0, n1, m0, m1, newArr, NM);
    }

    static int[] dr = {1, 0, -1, 0};  // d = 0 : 하 -> d = 1 : 상 -> d = 2 : 좌 -> d = 3 : 우
    static int[] dc = {0, 1, 0, -1};

    /*
     * 1차원 배열로 하 -> 우 -> 상 -> 좌 순으로 2차원 배열 채우기
     */
    static void setArrElement(int n0, int n1, int m0, int m1, int[] arr, int[][] NM) {
        // 시작점에서부터 하 -> 우 -> 상 -> 좌 순으로 탐색
        int[] p = {n0, m0};
        NM[n0][m0] = arr[0];  // 1차원 배열로 2차원 배열 채우기
        int l = 1;
        int d = 0;
        while (l < arr.length) {  // 1차원 배열의 길이가 다 채워질때까지 수행
            int[] np = {p[0] + dr[d], p[1] + dc[d]};
            if (n0 > np[0] || np[0] >= n1 || m0 > np[1] || np[1] >= m1) {  // 해당 꼭지점을 벗어날 경우 방향 전환
                d++;  // 방향 전환
                np = new int[] {p[0] + dr[d], p[1] + dc[d]};  // 방향 전환 후 np 덮어쓰기
            }
            NM[np[0]][np[1]] = arr[l];  // 1차원 배열로 2차원 배열 채우기
            l++;  // while문 탈출조건
            p = np;  // 위치 다음으로 변경
        }
    }

    /*
     * 2차원 배열로 하 -> 우 -> 상 -> 좌 순으로 1차원 배열 채우기
     */
    static void getArrElement(int n0, int n1, int m0, int m1, int[] arr, int[][] NM) {
        // 시작점에서부터 하 -> 우 -> 상 -> 좌 순으로 탐색
        int[] p = {n0, m0};
        arr[0] = NM[n0][m0];  // 2차원 배열로 1차원 배열 채우기
        int l = 1;
        int d = 0;
        while (l < arr.length) {
            int[] np = {p[0] + dr[d], p[1] + dc[d]};
            if (n0 > np[0] || np[0] >= n1 || m0 > np[1] || np[1] >= m1) {
                d++;
                np = new int[] {p[0] + dr[d], p[1] + dc[d]};
            }
            arr[l] = NM[np[0]][np[1]];  // 2차원 배열로 1차원 배열 채우기
            l++;
            p = np;
        }
    }

    /*
     * 2차원 배열 출력하기
     */
    static String toStringInt2(int[][] int2) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < int2.length; i++) {
            for (int j : int2[i]) sb.append(j + " ");
            if (i != int2.length - 1) sb.append("\n");
        }
        return sb.toString();
    }
}