프로그래머스 - 행렬 테두리 회전하기 자바 java

실전이였다면 시간내에 못풀었을 듯. 어렵다기보단 값을 잡아나가는게 힘들었다.

사진상으로 10번 28번 26번 위치를 기억해놓고 움직인다.

​

정답

class Solution {
   public static int[] solution(int rows, int columns, int[][] queries) {
        int[] answer = new int[queries.length];

        int[][] matrix = new int[rows][columns];
        
        int value = 1;
        for(int ii = 0 ; ii < rows; ii++)
        {
            for(int jj = 0 ; jj < columns ; jj++)
                matrix[ii][jj] = (value++);
        }
        
        for(int ii = 0 ; ii < queries.length ; ii++)
        {
            int start_x = queries[ii][0]-1;
            int start_y = queries[ii][1]-1;
            int end_x = queries[ii][2]-1;
            int end_y = queries[ii][3]-1;
          
            int[] up_x = new int[end_y - start_y];
            int[] up_y = new int[end_y - start_y];
            int[] down_x = new int[end_y - start_y];
            int[] down_y = new int[end_y - start_y];
            int[] left_x = new int[end_x - start_x];
            int[] left_y = new int[end_x - start_x];
            int[] right_x = new int[end_x - start_x];
            int[] right_y = new int[end_x - start_x];
            
            int count = 0;
            for(int jj = 0 ; jj < up_x.length ; jj++)
            {
                up_x[jj] = start_x;
                up_y[jj] = start_y + count ;
                count++;
            }
            count = 1;
            for(int jj = 0 ; jj < down_x.length ; jj++)
            {
                down_x[jj] = end_x;
                down_y[jj] = start_y + count ;
                count++;
            }
            count = 1;
            for(int jj = 0 ; jj < left_x.length ; jj++)
            {
                left_x[jj] = start_x + count;
                left_y[jj] = start_y ;
                count++;
            }
            count = 0;
            for(int jj = 0 ; jj < right_x.length ; jj++)
            {
                right_x[jj] = start_x + count;
                right_y[jj] = end_y ;
                count++;
            }
            
            /* up의 모서리 기억 */
            // up -> right -> down -> left
            int up_temp = matrix[start_x][end_y];
            int right_temp = matrix[end_x][end_y];
            int down_temp = matrix[end_x][start_y];
            int min = 999999999;
            for(int aa = up_x.length -1 ; aa >= 0; aa--)
            {
            	matrix[up_x[aa]][up_y[aa]+1] = matrix[up_x[aa]][up_y[aa]];
            	if(min > matrix[up_x[aa]][up_y[aa]+1])
            		min = matrix[up_x[aa]][up_y[aa]+1];
            }
            
            for(int aa = right_x.length-1 ; aa >= 0 ; aa--)
            {
            	if(aa == 0)
            		matrix[right_x[aa]+1][right_y[aa]] = up_temp;
            	else
            		matrix[right_x[aa]+1][right_y[aa]] = matrix[right_x[aa]][right_y[aa]];    
            	
            	if(min > matrix[right_x[aa]+1][right_y[aa]])
            		min = matrix[right_x[aa]+1][right_y[aa]];
            }
            
            for(int aa = 0; aa < down_x.length ; aa++)
            {
            	if(aa == down_x.length -1)
            		matrix[down_x[aa]][down_y[aa]-1] = right_temp;
            	else
            		matrix[down_x[aa]][down_y[aa]-1] = matrix[down_x[aa]][down_y[aa]];      
            	
            	if(min > matrix[down_x[aa]][down_y[aa]-1])
            		min = matrix[down_x[aa]][down_y[aa]-1];      	
            }
            
            for(int aa = 0; aa < left_x.length ; aa++)
            {
            	if(aa == left_x.length -1)
            		matrix[left_x[aa]-1][left_y[aa]] = down_temp;
            	else
            		matrix[left_x[aa]-1][left_y[aa]] = matrix[left_x[aa]][left_y[aa]];   
            	
            	if(min > matrix[left_x[aa]-1][left_y[aa]])
            		min = matrix[left_x[aa]-1][left_y[aa]];    
            }
       
            answer[ii] = min;
        }
     
        return answer;
    }
}

https://programmers.co.kr/learn/courses/30/lessons/77485