[Lv.2] 프로그래머스 - 행렬 테두리 회전하기 : Java

프로그래머스

 

 

 

이해하기

matrix 배열을 만들어두고, queries를 하나씩 돌아가며 직접 배열을 회전시키려 하였다.

처음 풀이했던 방법은 Queue를 하나 만들어서 해당 테두리의 숫자들을 저장시켜두고, 한 칸씩 옮겨서 Queue 값을 poll하여 넣어주는 것이었다.

 

1시간 동안 고민하면서 구현하고 테스트 코드까지 통과했길래 제출했더니 18.2점...  

import java.util.*;

class Solution {
    public int[] solution(int rows, int columns, int[][] queries) {
        List<Integer> list = new ArrayList<>();
        int[][] matrix = new int[rows][columns];
        int num = 1;
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                matrix[i][j] = num++;
            }
        }
        
        for (int i = 0; i < queries.length; i++) {
            int[] start = new int[]{queries[i][0] - 1, queries[i][1] - 1};
            int[] end = new int[]{queries[i][2] - 1, queries[i][3] - 1};
            
            Queue<Integer> queue = new LinkedList<>();
            
            // 오른쪽
            for (int j = start[1]; j <= end[1]; j++) {
                queue.offer(matrix[start[0]][j]);
            }
            
            // 아래쪽
            for (int j = start[0] + 1; j <= end[0]; j++) {
                queue.offer(matrix[j][end[1]]);
            }
            
            // 왼쪽
            for (int j = end[1] - 1; j >= start[1]; j--) {
                queue.offer(matrix[end[0]][j]);
            }
            
            // 위쪽
            for (int j = end[0] - 1; j >= start[0] + 1; j--) {
                queue.offer(matrix[j][start[0]]);
            }
            
            int min = Integer.MAX_VALUE;
            
            for (int q : queue) {
                min = Math.min(min, q);
            }
            
            // 한 칸씩 이동하여 숫자 넣기
            // 오른쪽
            for (int j = start[1] + 1; j <= end[1]; j++) {
                matrix[start[0]][j] = queue.poll();
            }
            
            // 아래쪽
            for (int j = start[0] + 1; j <= end[0]; j++) {
                matrix[j][end[1]] = queue.poll();
            }
            
            // 왼쪽
            for (int j = end[1] - 1; j >= start[1]; j--) {
                matrix[end[0]][j] = queue.poll();
            }
            
            // 위쪽
            for (int j = end[0] - 1; j >= start[0]; j--) {
                matrix[j][start[1]] = queue.poll();
            }
            
            list.add(min);
        }
        
        
        return list.stream().mapToInt(n -> n).toArray();
    }
}

 

결국 블로그 참고...⬇️

[프로그래머스] 행렬 테두리 회전하기 (Java)

 

예시를 가지고 생각해보았다.

먼저 8, 9를 오른쪽으로 민다면, 10이라는 숫자가 matrix에서 사라질테니 따로 저장해 두어야 한다. ➡️

그 다음 8이 2개가 되었으니 해당 자리를 새로운 숫자로 채워야 한다. ⬆️

마찬가지로 26이 2개가 되었으니 해당 자리를 새로운 숫자로 채워야 한다. ⬅️

그 다음 28이 2개가 되었으니 해당 자리를 새로운 숫자로 채워야 한다. ⬇️

 

여기까지 하면 빨간색 16 자리가 문제가 된다. 다음 숫자를 내려서 가져오자니 9가 중복이 되고, 그대로 두면 16이 중복이 된다. 이 때 아까 저장해 두었던 10을 넣어주면 된다.

 

순서를 다시 정리하면 ➡️⬆️⬅️⬇️ + 미리 저장해 둔 수 넣어주기!

 

 

문제풀이

import java.util.*;

class Solution {
    public int[] solution(int rows, int columns, int[][] queries) {
        int[] answer = new int[queries.length];
        int idx = 0;
        
        int num = 1;
        int[][] matrix = new int[rows][columns];
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                matrix[i][j] = num++;
            }
        }
        
        for (int[] query : queries) {
            int x1 = query[0] - 1;
            int y1 = query[1] - 1;
            int x2 = query[2] - 1;
            int y2 = query[3] - 1;
            
            int firstNum = matrix[x1][y2];
            int min = firstNum;
            
            // 오른쪽 이동
            for (int i = y2 - 1; i >= y1; i--) {
                min = Math.min(min, matrix[x1][i]);
                matrix[x1][i + 1] = matrix[x1][i];
            }
            
            // 위쪽 이동
            for (int i = x1 + 1; i <= x2; i++) {
                min = Math.min(min, matrix[i][y1]);
                matrix[i - 1][y1] = matrix[i][y1];
            }
            
            // 왼쪽 이동
            for (int i = y1 + 1; i <= y2; i++) {
                min = Math.min(min, matrix[x2][i]);
                matrix[x2][i - 1] = matrix[x2][i];
            }
            
            // 아래쪽 이동
            for (int i = x2 - 1; i > x1; i--) {
                min = Math.min(min, matrix[i][y2]);
                matrix[i + 1][y2] = matrix[i][y2];
            }
            
            matrix[x1 + 1][y2] = firstNum;
            
            answer[idx++] = min;
        }
        
        return answer;
    }
}