Taxol

I’ve always been.

백준 16935 - 배열 돌리기 3

Updated:

Java

16935 번 - 배열 돌리기 3

문제

크기가 N×M인 배열이 있을 때, 배열에 연산을 R번 적용하려고 한다. 연산은 총 6가지가 있다.

1번 연산은 배열을 상하 반전시키는 연산이다.

1 6 2 9 8 4 → 4 2 9 3 1 8
7 2 6 9 8 2 → 9 2 3 6 1 5
1 8 3 4 2 9 → 7 4 6 2 3 1
7 4 6 2 3 1 → 1 8 3 4 2 9
9 2 3 6 1 5 → 7 2 6 9 8 2
4 2 9 3 1 8 → 1 6 2 9 8 4
   <배열>       <연산 결과>

2번 연산은 배열을 좌우 반전시키는 연산이다.

1 6 2 9 8 4 → 4 8 9 2 6 1
7 2 6 9 8 2 → 2 8 9 6 2 7
1 8 3 4 2 9 → 9 2 4 3 8 1
7 4 6 2 3 1 → 1 3 2 6 4 7
9 2 3 6 1 5 → 5 1 6 3 2 9
4 2 9 3 1 8 → 8 1 3 9 2 4
   <배열>       <연산 결과>

3번 연산은 오른쪽으로 90도 회전시키는 연산이다.

1 6 2 9 8 4 → 4 9 7 1 7 1
7 2 6 9 8 2 → 2 2 4 8 2 6
1 8 3 4 2 9 → 9 3 6 3 6 2
7 4 6 2 3 1 → 3 6 2 4 9 9
9 2 3 6 1 5 → 1 1 3 2 8 8
4 2 9 3 1 8 → 8 5 1 9 2 4
   <배열>       <연산 결과>

4번 연산은 왼쪽으로 90도 회전시키는 연산이다.

1 6 2 9 8 4 → 4 2 9 1 5 8
7 2 6 9 8 2 → 8 8 2 3 1 1
1 8 3 4 2 9 → 9 9 4 2 6 3
7 4 6 2 3 1 → 2 6 3 6 3 9
9 2 3 6 1 5 → 6 2 8 4 2 2
4 2 9 3 1 8 → 1 7 1 7 9 4
   <배열>       <연산 결과>

5, 6번 연산을 수행하려면 배열을 크기가 N/2×M/2인 4개의 부분 배열로 나눠야 한다. 아래 그림은 크기가 6×8인 배열을 4개의 그룹으로 나눈 것이고, 1부터 4까지의 수로 나타냈다.

1 1 1 1 2 2 2 2
1 1 1 1 2 2 2 2
1 1 1 1 2 2 2 2
4 4 4 4 3 3 3 3
4 4 4 4 3 3 3 3
4 4 4 4 3 3 3 3

5번 연산은 1번 그룹의 부분 배열을 2번 그룹 위치로, 2번을 3번으로, 3번을 4번으로, 4번을 1번으로 이동시키는 연산이다.

3 2 6 3 1 2 9 7 → 2 1 3 8 3 2 6 3
9 7 8 2 1 4 5 3 → 1 3 2 8 9 7 8 2
5 9 2 1 9 6 1 8 → 4 5 1 9 5 9 2 1
2 1 3 8 6 3 9 2 → 6 3 9 2 1 2 9 7
1 3 2 8 7 9 2 1 → 7 9 2 1 1 4 5 3
4 5 1 9 8 2 1 3 → 8 2 1 3 9 6 1 8
     <배열>            <연산 결과>

6번 연산은 1번 그룹의 부분 배열을 4번 그룹 위치로, 4번을 3번으로, 3번을 2번으로, 2번을 1번으로 이동시키는 연산이다.

3 2 6 3 1 2 9 7 → 1 2 9 7 6 3 9 2
9 7 8 2 1 4 5 3 → 1 4 5 3 7 9 2 1
5 9 2 1 9 6 1 8 → 9 6 1 8 8 2 1 3
2 1 3 8 6 3 9 2 → 3 2 6 3 2 1 3 8
1 3 2 8 7 9 2 1 → 9 7 8 2 1 3 2 8
4 5 1 9 8 2 1 3 → 5 9 2 1 4 5 1 9
     <배열>            <연산 결과>

접근 방법

주어진 연산에따라 그래프의 값을 변화하였다.

구현

주목해야 할것은 3,4번이다.
그래프를 90도로 돌린다는 것은 n x m 이 m x n이 되므로,
기존의 배열을 백업한 뒤, 새롭게 new int[m][n]하여 생성한다.
새롭게 생성한 배열에 temp 배열의 값을 대입하여 회전시키고,
n, m을 서로 변경하여 행/열 크기를 갱신해준다.

코드

import java.util.*;
import java.io.*;

public class Main {
	
    public static void main(String []args) throws IOException {        
    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	StringTokenizer stk = new StringTokenizer(br.readLine());
    	int n = stoi(stk.nextToken());
    	int m = stoi(stk.nextToken());
    	int r = stoi(stk.nextToken());
    	int arr[][] = new int[n][m];
    	for(int i = 0; i < n; i++) {
    		stk = new StringTokenizer(br.readLine());
    		for(int j = 0; j < m; j++)
    			arr[i][j] = stoi(stk.nextToken());
    	}
    	int[] oper = new int[r];
    	stk = new StringTokenizer(br.readLine());
    	for(int i = 0; i < r; i++) {
    		oper[i] = stoi(stk.nextToken());
    	}
    	int tmp;
    	int[] temp;
    	int[][] tempp;
    	for(int v : oper) {
    		switch(v) {
    		case 1:
    			for(int i = 0; i < n / 2; i++) {
    				temp = arr[i];
    				arr[i] = arr[n - i - 1];
    				arr[n - i - 1] = temp;
    			}
    			break;
    		case 2:
    			for(int i = 0; i < n; i++) {
    				for(int j = 0; j < m / 2; j++) {
    					tmp = arr[i][j];
    					arr[i][j] = arr[i][m - j - 1];
    					arr[i][m - j - 1] = tmp;
    				}
    			}
    			break;
    		case 3:
    			tempp = new int[n][m];
    			for(int i = 0; i < n; i++) {
    	    		tempp[i] = arr[i];
    	    	}
    			arr = new int[m][n];
    			for(int i = 0; i < n; i++) {
    				for(int j = 0; j < m; j++) {
    					arr[j][n - i - 1] = tempp[i][j];
    				}
    			}
    			tmp = n;
    			n = m;
    			m = tmp;
    			break;
    		case 4:
    			tempp = new int[n][m];
    			for(int i = 0; i < n; i++) {
    	    		tempp[i] = arr[i];
    	    	}
    			arr = new int[m][n];
    			for(int i = 0; i < n; i++) {
    				for(int j = 0; j < m; j++) {
    					arr[m - 1 - j][i] = tempp[i][j];
    				}
    			}
    			tmp = n;
    			n = m;
    			m = tmp;
    			break;
    		case 5:
    			tempp = new int[n/2][m/2];
    			for(int i = 0; i < n/2; i++) {
    				for(int j = 0; j < m/2; j++) {
    					tempp[i][j] = arr[i][j];				// 1 백업
    					arr[i][j] = arr[i + n/2][j];			// 4 -> 1
    					arr[i + n/2][j] = arr[i + n/2][j + m/2];// 3 -> 4
    					arr[i + n/2][j + m/2] = arr[i][j + m/2];// 2 -> 3
    					arr[i][j + m/2] = tempp[i][j];			// 1 -> 2
    				}
    			}
    			break;
    		case 6:
    			tempp = new int[n/2][m/2];
    			for(int i = 0; i < n/2; i++) {
    				for(int j = 0; j < m/2; j++) {
    					tempp[i][j] = arr[i][j];				// 1 백업
    					arr[i][j] = arr[i][j + m/2];			// 2 -> 1
    					arr[i][j + m/2] = arr[i + n/2][j + m/2];// 3 -> 2
    					arr[i + n/2][j + m/2] = arr[i + n/2][j];// 4 -> 3
    					arr[i + n/2][j] = tempp[i][j];			// 1 -> 4
    				}
    			}
    			break;
    		}
    	}
    	
    	StringBuilder sb = new StringBuilder();
    	for(int[] a : arr) {
    		for(int v : a) {
    			sb.append(v).append(" ");
    		}
    		sb.append("\n");
    	}
    	System.out.println(sb.toString());
    	br.close();
    }
    static int stoi(String str) {
    	return Integer.parseInt(str);
    }
}

총평

난이도

⭐⭐★★★

후기

큐빙 문제의 하위 문제라고 생각하는 문제였다.

개선할 점

없

You may also enjoy