15-mong3125

[mong3125]

🔗 문제 링크

토마토
이전에 승호님이 먼저 푸신 문제입니다.
같은 방법으로 푼 풀이와 다른 방법으로 푼 풀이 두 개로 나눠서 올려볼게요.

✔️ 소요된 시간

3시간정도 걸렸습니다.
두번째 방법을 생각해냈다면 더 가볍게 구현했을것 같은데 첫번째 방법으로 구현은 좀 오래걸렸네요.

✨ 수도 코드

저도 처음에 첫번째 방법으로 구현해서 백준에 통과했습니다. 하지만 제 코드는 승호님의 curQueue = !curQueue; 이 아이디어를 생각못해서 좀 더 비효율적으로 구현하다가 다른 사람들 코드를 찾다보니 두번째 방법을 찾아서 소개하고싶어서 올립니다.

첫번째 방법 (승호님과 같은 방법입니다.)

첫번째 방법보단 두번째 방법을 소개하려고 나와서 첫번째 방법은 승호님 풀이를 참고해주세요.
#42

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

public class BOJ7569_토마토 {

    static int M, N, H;
    static Queue<int[]> ripen = new LinkedList<>();   // 익은 토마토 위치
    static Queue<int[]> temp = new LinkedList<>();   // 익은 토마토 위치
    static int notRipenTomatos = 0;

    // 방향
    static int[][] directions = {
            {1, 0, 0},
            {-1, 0, 0},
            {0, 1, 0},
            {0, -1, 0},
            {0, 0, 1},
            {0, 0, -1},
    };

    // 박스
    static int[][][] box;

    // 방문 여부
    static boolean[][][] visited;
    public static void main(String[] args) throws IOException {
        // == 입력 == //
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        M = Integer.parseInt(st.nextToken());
        N = Integer.parseInt(st.nextToken());
        H = Integer.parseInt(st.nextToken());
        box = new int[H][N][M];
        visited = new boolean[H][N][M];

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

                    // 익은 토마토 위치 저장
                    if (box[i][j][k] == 1) ripen.add(new int[]{i, j, k});
                    else if (box[i][j][k] == 0) notRipenTomatos++;
                }
            }
        }

        // == 풀이 == //
        int count = 0;

        // 새로 익은 토마토가 없을때까지 반복
        while (!ripen.isEmpty()) {
            bfs();
            count++;
        }

        // 모든 토마토가 익은게 아니라면 -1 반환
        if (notRipenTomatos > 0) {
            count = 0;
        }

        System.out.println(count - 1);
    }

    public static void bfs() {
        temp.clear();

        while (!ripen.isEmpty()) {
            int[] tomato = ripen.remove();
            if (visited[tomato[0]][tomato[1]][tomato[2]]) continue;

            visited[tomato[0]][tomato[1]][tomato[2]] = true;
            ripe(tomato);
        }

        ripen.addAll(temp);
    }

    public static void ripe(int[] tomato) {
        for (int[] direction : directions) {
            int z = tomato[0] + direction[0];
            int y = tomato[1] + direction[1];
            int x = tomato[2] + direction[2];

            if (isInRange(z, y, x)) {
                if (box[z][y][x] == 0) {
                    box[z][y][x] = 1;
                    notRipenTomatos--;
                    temp.add(new int[]{z, y, x});
                }
            }
        }
    }

    public static boolean isInRange(int z, int y, int x) {
        return (x >= 0 && x < M && y >= 0 && y < N && z >= 0 && z < H);
    }
}

두번째 방법입니다.

가장 핵심이 되는 아이디어는 새롭게 토마토를 익힐때, 이전 토마토보다 1만큼 큰 수를 저장하고 나중에 (가장 큰 수 - 1)를 반환하는 방법입니다.

bfs() {
    while 익은 토마토 큐가 빌때까지 반복{
        tomato = 가장 위에있는 토마토 위치
        for 6 방향 위치로 반복문 {
            if 범위 내에 있다면 {
                if 안 익은 토마토라면 {
                    이전 토마토 +  1로 저장
                    result = max(result, 이전 토마토 + 1)
                    익지 않은 토마토 수 -= 1

                    익은 토마토 큐에 추가
                }
            }
        }
    }
}

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

public class BOJ7569_토마토 {

    static int M, N, H;
    static int[][][] box;

    static Queue<int[]> ripen = new LinkedList<>();   // 익은 토마토 위치
    static int notRipenTomatos = 0;
    static int result = 1;
    static int[][] directions = {
            {1, 0, 0},
            {-1, 0, 0},
            {0, 1, 0},
            {0, -1, 0},
            {0, 0, 1},
            {0, 0, -1},
    };

    public static void main(String[] args) throws IOException {
        // == 입력 == //
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        M = Integer.parseInt(st.nextToken());
        N = Integer.parseInt(st.nextToken());
        H = Integer.parseInt(st.nextToken());
        box = new int[H][N][M];

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

                    // 익은 토마토 위치 저장
                    if (box[i][j][k] == 1) ripen.add(new int[]{i, j, k});
                    else if (box[i][j][k] == 0) notRipenTomatos++;
                }
            }
        }

        // == 풀이 == //
        bfs();

        // 모든 토마토가 익은게 아니라면 -1 반환
        if (notRipenTomatos > 0) {
            result = 0;
        }

        // == 출력 == //
        System.out.println(result - 1);
    }

    public static void bfs() {
        while (!ripen.isEmpty()) {
            int[] tomato = ripen.remove();
            for (int[] direction : directions) {
                int z = tomato[0] + direction[0];
                int y = tomato[1] + direction[1];
                int x = tomato[2] + direction[2];

                if (isInRange(z, y, x)) {
                    if (box[z][y][x] == 0) {
                        box[z][y][x] = box[tomato[0]][tomato[1]][tomato[2]] + 1;
                        result = Math.max(result, box[z][y][x]);
                        notRipenTomatos--;

                        ripen.add(new int[]{z, y, x});
                    }
                }
            }
        }
    }

    public static boolean isInRange(int z, int y, int x) {
        return (x >= 0 && x < M && y >= 0 && y < N && z >= 0 && z < H);
    }
}

📚 새롭게 알게된 내용

• BFS에서 시행횟수를 찾을땐 배열에 점점 숫자를 키워가면서 횟수를 저장한 뒤, 마지막에 배열에서 가장 큰 수를 찾음으로써 알아낼 수 있다.

[YIM2UL2ET]

토마토 문제를 풀고 그 후에 생각만 했었던 방식을 구현한 코드네요. 개인적으로 두 번째 풀이가 더 읽기 쉬운 직관적인 BFS 풀이라 느껴집니다. 수고하셨습니다.