IT recording...

[BOJ] 17822 원판돌리기 - Java 본문

Algorithm

[BOJ] 17822 원판돌리기 - Java

I-one 2022. 4. 26. 22:23

https://www.acmicpc.net/problem/17822

 

17822번: 원판 돌리기

반지름이 1, 2, ..., N인 원판이 크기가 작아지는 순으로 바닥에 놓여있고, 원판의 중심은 모두 같다. 원판의 반지름이 i이면, 그 원판을 i번째 원판이라고 한다. 각각의 원판에는 M개의 정수가 적혀

www.acmicpc.net

[풀이]

1. 원판 돌리기

static void rotate(int n,int d,int K){
    if(d==0){ //시계방향
        for(int k=0;k<K;k++){
            int tmp = Map[n][M];
            for(int j=M;j>=2;j--){
                Map[n][j] = Map[n][j-1];
            }
            Map[n][1] = tmp;
        }
    }
    else if(d==1){ //반시계방향
        for(int k=0;k<K;k++){
            int tmp = Map[n][1];
            for(int j=1;j<M;j++){
                Map[n][j] = Map[n][j+1];
            }
            Map[n][M] = tmp;
        }
    }
}

2. 인접한 수 확인은 문제에 주어진 조건 그대로 하드코딩했다. (구현 문제에서 이렇게 다 주면 생각하지말고, 그냥 하드코딩 다 때려박는게 마음 편하다!!)  -> remove함수

  • (i, 1)은 (i, 2), (i, M)과 인접하다.
  • (i, M)은 (i, M-1), (i, 1)과 인접하다.
  • (i, j)는 (i, j-1), (i, j+1)과 인접하다. (2 ≤ j ≤ M-1)
  • (1, j)는 (2, j)와 인접하다.
  • (N, j)는 (N-1, j)와 인접하다.
  • (i, j)는 (i-1, j), (i+1, j)와 인접하다. (2 ≤ i ≤ N-1)

3. 하나라도 변한게 있으면 (flag==true) Copy를 그대로 Map에 넣는다.

변한게 없으면 평균 구해서 갱신한다. -> 주의) 평균 구할 때 double로 소숫점 살려야함

 

[코드]

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    static StringTokenizer st;
    static int N,M,T;
    static int[][] Map;

    public static void main(String[] args) throws Exception{
        //System.setIn(new FileInputStream("src/main/java/input.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

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

        for(int t=0;t<T;t++){
            st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            int d = Integer.parseInt(st.nextToken());
            int k = Integer.parseInt(st.nextToken());
            for(int n=1;n<N+1;n++){
                if(n%x==0){ //x의배수이면
                    rotate(n,d,k);
                }
            }
            remove();
        }

        int total = 0;
        for(int i=1;i<N+1;i++){
            for(int j=1;j<M+1;j++) {
                total += Map[i][j];
            }
        }
        System.out.println(total);

    }
    static void printMap(){
        System.out.println("======");
        for(int i=1;i<N+1;i++){
            for(int j=1;j<M+1;j++) {
                System.out.print(Map[i][j]+" ");
            }
            System.out.println();
        }
    }
    static void remove(){
        boolean flag = false;
        int[][] Copy = new int[N+1][M+1];
        for(int[] c:Copy){
            Arrays.fill(c,-1);
        }

        int total = 0;
        for(int i=1;i<N+1;i++){
            for(int j=1;j<M+1;j++){
                total += Map[i][j];
                if(i==1){
                    if(Map[i][j]==Map[2][j] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[2][j] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0){
                            Copy[i][j] = Map[i][j];
                        }
                    }
                }
                else if(i==N){
                    if(Map[i][j]==Map[N-1][j] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[N-1][j] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                }
                else{
                    if(Map[i][j]==Map[i-1][j] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i-1][j] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                    if(Map[i][j]==Map[i+1][j] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i+1][j] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                }
                //
                if(j==1){
                    if(Map[i][j]==Map[i][2] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i][2] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                    if(Map[i][j]==Map[i][M] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i][M] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                }
                else if(j==M){
                    if(Map[i][j]==Map[i][M-1] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i][M-1] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                    if(Map[i][j]==Map[i][1] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i][1] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                }
                else{
                    if(Map[i][j]==Map[i][j-1] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i][j-1] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                    if(Map[i][j]==Map[i][j+1] && Map[i][j]!=0){
                        flag = true;
                        Copy[i][j] = 0;
                        Copy[i][j+1] = 0;
                    }
                    else{
                        if(Copy[i][j]!=0) {
                            Copy[i][j] = Map[i][j];
                        }
                    }
                }
            }
        }

        if (flag) { //같은 수가 하나라도 있으면
            for(int i=1;i<N+1;i++){
                for(int j=1;j<M+1;j++){
                    Map[i][j] = Copy[i][j];
                }
            }
        }
        else{ //같은 수가 없으면 평균 구해서 갱신
            int count = 0;
            for(int i=1;i<N+1;i++){
                for(int j=1;j<M+1;j++){
                    if(Map[i][j]>0){
                        count++;
                    }
                }
            }
            for(int i=1;i<N+1;i++){
                for(int j=1;j<M+1;j++){
                    if(Map[i][j]!=0){
                        if(Map[i][j]>(double)total/count){ //double로 평균 구하기
                            Map[i][j]-=1;
                        }
                        else if(Map[i][j]<(double)total/count){
                            Map[i][j]+=1;
                        }
                    }

                }
            }
        }
    }

    static void rotate(int n,int d,int K){
        if(d==0){ //시계방향
            for(int k=0;k<K;k++){
                int tmp = Map[n][M];
                for(int j=M;j>=2;j--){
                    Map[n][j] = Map[n][j-1];
                }
                Map[n][1] = tmp;
            }
        }
        else if(d==1){ //반시계방향
            for(int k=0;k<K;k++){
                int tmp = Map[n][1];
                for(int j=1;j<M;j++){
                    Map[n][j] = Map[n][j+1];
                }
                Map[n][M] = tmp;
            }
        }
    }
}

[느낀점]

소요시간 : 1h정도

구현 문제임을 알아채고 범위같은거는 머리로 생각안하고 그냥 하드코딩 했다.

훨씬 좋다. 앞으로도 이런거는 생각하지말고 (내 생각 개입 XXX!) 문제에서 준대로 넣자

 

'Algorithm' 카테고리의 다른 글

[BOJ] 2629 양팔저울 - Java  (0) 2022.05.11
[BOJ] 17825 주사위윷놀이 - Java  (0) 2022.04.28
[BOJ] 17837 새로운게임2 - Java  (0) 2022.04.26
[BOJ] 17779 게리맨더링 2 -Java  (0) 2022.04.25
[BOJ] 16236 아기상어 - Java  (0) 2022.04.24
Comments