14-mj111

[mjj111]

🔗 문제 링크

백준 - 원판 돌리기
https://www.acmicpc.net/problem/17822

✔️ 소요된 시간

1시간

✨ 수도 코드

해당 문제는,
주어진 원판에서 회전시키고, 인접한 점수끼리 없애던지,
회전 시키고, 인접한 점수가 없으면 평균으로 치환하며
최종 원판에서 적힌 점수의 합을 출력하는 문제입니다.

먼저 원판 점수들을 입력받습니다.

        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        T = Integer.parseInt(st.nextToken());

        arr = new int[N+1][M];

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

이후 주어진 값에 따라 회전을 시켜줍니다.

        int remainCnt = N*M;
        for(int i=0; i<T; ++i) {
            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 r=x; r<=N; r+=x) {
                arr[r] = rotate(r, d, k);
            }

회전판에서 아직 숫자가 남아잇는지 확인합니다.
만약 숫자가 남아있고,
인접한 같은 숫자가 존재한다면 0으로 만들어줍니다.

            // 수가 남아있는지 확인하기
            if(remainCnt > 0) {
                zeroNum = 0;
                total = 0;
                cnt = 0;
                boolean[][] zero = makeZero(arr);

만약 만약 숫자가 남아있고,
인접한 같은 숫자가 없다면 평균값으로 치환해 줍니다.

                if(zeroNum == 0) {
                    double avg = (double)total / (double)cnt;

                    for(int r=1; r<=N; ++r) {
                        for(int c=0; c<M; ++c) {
                            if(arr[r][c] == 0) continue;
                            if((double)arr[r][c] < avg) arr[r][c]++;
                            else if((double)arr[r][c] > avg) arr[r][c]--;
                        }
                    }
                }
                else {
                    for(int r=1; r<=N; ++r) {
                        for (int c = 0; c < M; ++c) {
                            if(zero[r][c]) arr[r][c] = 0;
                        }
                    }

                }
            }
        }

주어진 회전을 다 마쳤으면, 회전판에 있는 숫자들의 합을 출력해줍니다.

        int ans = 0;
        for(int r=1; r<=N; ++r) {
            for(int c=0; c<M; ++c) {
                ans += arr[r][c];
            }
        }

        System.out.println(ans);
    }

원판의 숫자를 돌리는 방법은 간단합니다.
주어진 시계방향에 맞춰 주어진 만큼 이동시킵니다.

    static int[] rotate(int r, int d, int k) {
        int[] newArr = new int[M];
        if(d == 0) { // 시계방향
            for(int i=0; i<M; ++i) {
                newArr[i] = arr[r][(i+M-k) % M];
            }
        } else {
            for(int i=0; i<M; ++i) {
                newArr[i] = arr[r][(i+k) % M];
            }
        }

        return newArr;
    }

인접한 숫자를 찾아 0으로 만드는 작업은
열에서 먼저 인접을 확인하고, 이후 행에서 인접을 확인하여 0으로 치환해주면 됩니다.

    static boolean[][] makeZero(int[][] arr) {
        boolean[][] zero = new boolean[N+1][M];
        for(int i=1; i<=N; ++i) {
            for(int j=0; j<M; ++j) {
                if(arr[i][j] == 0) continue;

                cnt++;
                total += arr[i][j];

                if(arr[i][j] == arr[i][(j+1)%M]) {
                    zero[i][j] = zero[i][(j+1)%M] = true;
                    zeroNum++;
                }

                if(i<N && arr[i][j] == arr[i+1][j]) {
                    zero[i][j] = zero[i+1][j] = true;
                    zeroNum++;

📚 새롭게 알게된 내용

빡구현에서 주어진 순서대로 차근차근 구현할 때
메인 메서드에서 일단 임의의 메서드를 호출하도록 하고나서 이후에 자세한 구현을 하는 방식으로 하는게 가장 빠른 방법인 것 같습니다.

[gjsk132]

인접한 값이 있었는지 없었는지 확인하는 과정을 boolean으로 처리하려했는데...
마지막 예제에서 적용되지 않는 부분이 생겨서, 그냥 zero_cnt(zeroNum)을 만들어서 해주니까 바로 통과됐습니다!

전체 코드

import sys
sys.setrecursionlimit(100000)
input = open("input.txt").readline

N, M, T = map(int, input().split())

target = [list(map(int,input().split())) for _ in range(N)]

offset = [(1, 0), (0,1), (-1,0), (0,-1)]

for _ in range(T):

    # 돌리기
    disk, dir, cnt = map(int,input().split())
    cnt = cnt if dir else M-cnt

    for i in range(disk, N+1, disk):
        target[i-1] = target[i-1][cnt:] + target[i-1][:cnt]

    # 인접 없애기
    
    def dfs(x, y, num):
        
        zero_cnt = 0

        for dx, dy in offset:

            nx = x + dx
            ny = (y + dy + M)%M
            
            if nx < 0 or nx == N or target[nx][ny] == 0:
                continue

            if target[nx][ny] == num:
                
                if not target[x][y]:
                    zero_cnt += 1

                zero_cnt += 1
                target[x][y] = 0
                target[nx][ny] = 0
                zero_cnt += dfs(nx, ny, num)

        return zero_cnt


    zero_cnt = 0

    for i in range(N):

        for j in range(M):
            if not target[i][j] == 0:
                zero_cnt += dfs(i, j, target[i][j])
                
    # 인접 없을 시, 평균해서 값 변경하기
    if not zero_cnt:

        left_cnt = sum([sum([0 if j==0 else 1 for j in i])for i in target])
        
        if not left_cnt:
            break
        
        total = sum([sum(i) for i in target]) / left_cnt

        for k1, v1 in enumerate(target):
            for k2, v2 in enumerate(v1):
                if 0 < v2 < total:
                    target[k1][k2] += 1
                elif v2 > total:
                    target[k1][k2] -= 1

print(sum([sum(i) for i in target]))

[9kyo-hwang]

전 풀다가 정신 나가서 PR 보고 다 갈아엎었는데도 통과가 안되네요 ㅎ...
조만간 다시 트라이해보겠읍니다....