코딩테스트/구현(Implementation)

[Java] 백준 16926번 : 배열 돌리기 1

sujin7837 2022. 1. 21. 23:34
반응형

문제

크기가 N×M인 배열이 있을 때, 배열을 돌려보려고 한다. 배열은 다음과 같이 반시계 방향으로 돌려야 한다.

A[1][1] ← A[1][2] ← A[1][3] ← A[1][4] ← A[1][5]
   ↓                                       ↑
A[2][1]   A[2][2] ← A[2][3] ← A[2][4]   A[2][5]
   ↓         ↓                   ↑         ↑
A[3][1]   A[3][2] → A[3][3] → A[3][4]   A[3][5]
   ↓                                       ↑
A[4][1] → A[4][2] → A[4][3] → A[4][4] → A[4][5]

예를 들어, 아래와 같은 배열을 2번 회전시키면 다음과 같이 변하게 된다.

1 2 3 4       2 3 4 8       3 4 8 6
5 6 7 8       1 7 7 6       2 7 8 2
9 8 7 6   →   5 6 8 2   →   1 7 6 3
5 4 3 2       9 5 4 3       5 9 5 4
 <시작>         <회전1>        <회전2>

배열과 정수 R이 주어졌을 때, 배열을 R번 회전시킨 결과를 구해보자.

입력

첫째 줄에 배열의 크기 N, M과 수행해야 하는 회전의 수 R이 주어진다.

둘째 줄부터 N개의 줄에 배열 A의 원소 Aij가 주어진다.

출력

입력으로 주어진 배열을 R번 회전시킨 결과를 출력한다.

제한

  • 2 ≤ N, M ≤ 300
  • 1 ≤ R ≤ 1,000
  • min(N, M) mod 2 = 0
  • 1 ≤ Aij ≤ 108

예제 입력 1

4 4 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

예제 출력 1

3 4 8 12
2 11 10 16
1 7 6 15
5 9 13 14

예제 입력 2

5 4 7
1 2 3 4
7 8 9 10
13 14 15 16
19 20 21 22
25 26 27 28

예제 출력 2

28 27 26 25
22 9 15 19
16 8 21 13
10 14 20 7
4 3 2 1

예제 입력 3

2 2 3
1 1
1 1

예제 출력 3

1 1
1 1

 

소스코드 1

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	private static int N, M, R;
	private static int[][] arr;
	private static int[][] result;
	
	public static void rotate() {
		int startR=0, startC=0;
		int size = Math.min(N, M) / 2;	// 회전시킬 둘레의 개수
		int sizeR=N, sizeC=M;	// sizeR : 둘레의 행 길이, sizeC : 둘레의 열 길이
		
		for(int i=0;i<size;i++) {
			for(int dir=0;dir<4;dir++) {
				if(dir==0) {	// 아래 방향 이동
					for(int r=1;r<=sizeR-1;r++) {
						result[startR+r][startC]=arr[startR+r-1][startC];
					}
					startR+=sizeR-1;
				} else if(dir==1) {	// 오른쪽 방향 이동
					for(int c=1;c<=sizeC-1;c++) {
						result[startR][startC+c]=arr[startR][startC+c-1];
					}
					startC+=sizeC-1;
				} else if(dir==2) {	// 위 방향 이동
					for(int r=1;r<=sizeR-1;r++) {
						result[startR-r][startC]=arr[startR-r+1][startC];
					}
					startR-=sizeR-1;
				} else if(dir==3) {	// 왼쪽 방향 이동
					for(int c=1;c<=sizeC-1;c++) {
						result[startR][startC-c]=arr[startR][startC-c+1];
					}
					startR+=1;	// 다음 둘레의 시작 행
					startC-=sizeC-2;	// 다음 둘레의 시작 열
					sizeR-=2;	// 다음 둘레의 행 길이
					sizeC-=2;	// 다음 둘레의 열 길이
				}
			}
		}
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		R = sc.nextInt();
		
		arr = new int[N][M];
		result = new int[N][M];
		
		for(int r=0;r<N;r++) {
			for(int c=0;c<M;c++) {
				arr[r][c] = sc.nextInt();
			}
		}
		for(int i=0;i<R;i++) {
			rotate();	// 회전
			for(int j=0;j<result.length;j++) {	// 회전된 배열 result를 arr에 복사
				System.arraycopy(result[j], 0, arr[j], 0, result[j].length);
			}
		}
		for(int []row:result) {
			for(int c:row) {
				System.out.print(c+" ");
			}
			System.out.println();
		}
	}
}

 

소스코드2

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

public class Main {

	private static int N, M, R;
	private static int[][] arr;
	private static int[][] result;
	
	public static void main(String[] args) throws NumberFormatException, IOException {

		BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		String s=bf.readLine();
		StringTokenizer st=new StringTokenizer(s, " ");
		N=Integer.parseInt(st.nextToken());
		M=Integer.parseInt(st.nextToken());
		R=Integer.parseInt(st.nextToken());
		arr=new int[N][M];
		int cnt=Math.min(N,  M) / 2;
		
		for(int r=0;r<N;r++) {
			s=bf.readLine();
			st=new StringTokenizer(s, " ");
			for(int c=0;c<M;c++) arr[r][c]=Integer.parseInt(st.nextToken());
		}
		
		for(int d=0;d<cnt;d++) {
			for(int ro=0;ro<R;ro++) {
				rotate(d);
			}
		}
		
//		 결과 출력
		for(int[] r:arr) {
			for(int c:r) System.out.print(c+" ");
			System.out.println();
		}
	}
	
	public static void rotate(int d) {
		int keep=arr[d][d];
		for(int c=d+1;c<M-d;c++) {
			arr[d][c-1]=arr[d][c];
		}
		for(int r=d+1;r<N-d;r++) {
			arr[r-1][M-d-1]=arr[r][M-d-1];
		}
		for(int c=M-d-2;c>=d;c--) {
			arr[N-d-1][c+1]=arr[N-d-1][c];
		}
		for(int r=N-d-2;r>=d+1;r--) {
			arr[r+1][d]=arr[r][d];
		}
		arr[d+1][d]=keep;
	}
}

 

반응형