[Baekjoon Online Judge] 7569번: 토마토

7569번: 토마토

요구사항

 - 토마토는 격자모양 상자의 칸에 하나씩 넣은 다음, 상자들을 수직으로 쌓아 올려서 창고에 보관한다.

 - 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다.

 - 하나의 토마토에 인접한 곳은 위, 아래, 왼쪽, 오른쪽, 앞, 뒤 여섯 방향에 있는 토마토를 의미한다.

 - 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다.

 - 철수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지 그 최소 일수를 알고 싶어 한다.

입력

 - 첫 줄에는 상자의 크기를 나타내는 두 정수 M,N과 쌓아올려지는 상자의 수를 나타내는 H가 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M ≤ 100, 2 ≤ N ≤ 100, 1 ≤ H ≤ 100 이다. 둘째 줄부터는 가장 밑의 상자부터 가장 위의 상자까지에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 하나의 상자에 담긴 토마토의 정보가 주어진다. 각 줄에는 상자 가로줄에 들어있는 토마토들의 상태가 M개의 정수로 주어진다. 정수 1은 익은 토마토, 정수 0 은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다. 이러한 N개의 줄이 H번 반복하여 주어진다. 토마토가 하나 이상 있는 경우만 입력으로 주어진다.

출력

 - 여러분은 토마토가 모두 익을 때까지 최소 며칠이 걸리는지를 계산해서 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

---

[Baekjoon Online Judge] 7576번: 토마토

기존의 토마토는 x, y축만 존재하는 격자상자였지만 이번 문제는 x, y, z까지 3차원의 토마토 상자가 익는 일 수를 확인하는 문제이다. 기존의 문제에서 추가적인 z축을 추가하여 문제를 수정하였고, 쉽게 해결 할 수 있었다.

 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.LinkedList;
import java.util.Queue;

public class Baekjoon7569 {

    static int[][][] map;
    static int[] xMove = {-1, 1, 0, 0, 0, 0};
    static int[] yMove = {0, 0, -1, 1, 0, 0};
    static int[] zMove = {0, 0, 0, 0, 1, -1};
    static int m, n, h;

    static class Location {
        int x, y, z;
        public Location(int x, int y, int z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }
    }

    private static void bfs() {
        Queue<Location> queue = new LinkedList<>();

        for (int i = 0; i < h; i++)
            for (int j = 0; j < n; j++)
                for (int k = 0; k < m; k++)
                    if (map[i][j][k] == 1) queue.add(new Location(j, k, i));

        while (!queue.isEmpty()) {
            Location location = queue.poll();
            int pollX = location.x;
            int pollY = location.y;
            int pollZ = location.z;

            for (int i = 0; i < 6; i++) {
                int x = pollX + xMove[i];
                int y = pollY + yMove[i];
                int z = pollZ + zMove[i];

                if (isLocation(x, y, z)) {
                    queue.add(new Location(x, y, z));
                    map[z][x][y] = map[pollZ][pollX][pollY] + 1;
                }
            }
        }
    }

    private static boolean isLocation(int x, int y, int z) {
        if (x >= 0 && y >= 0 && z >= 0 && x < n && y < m && z < h && map[z][x][y] == 0) return true;
        return false;
    }

    private static int getMax() {
        int max = 0;

        for (int i = 0; i < h; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < m; k++) {
                    if (map[i][j][k] == 0) return -1;

                    max = Math.max(max, map[i][j][k]);
                }
            }
        }
        return max - 1;
    }

    public static void main(String[] args) throws IOException {

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));

        String[] input = bufferedReader.readLine().split(" ");
        m = Integer.parseInt(input[0]); // y
        n = Integer.parseInt(input[1]); // x
        h = Integer.parseInt(input[2]); // z
        map = new int[h][n][m]; // z, x, y

        for (int i = 0; i < h; i++) {
            for (int j = 0; j < n; j++) {
                String[] s = bufferedReader.readLine().split(" ");
                for (int k = 0; k < m; k++) {
                    map[i][j][k] = Integer.parseInt(s[k]);
                }
            }
        }

        bfs();
        bufferedWriter.write(String.valueOf(getMax()));

        bufferedWriter.flush();
        bufferedReader.close();
        bufferedWriter.close();
    }
}