토마토(BFS)

문제설명

현수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자 모양 상자의 칸에 하나씩 넣어서 창고에 보관한다.

창고에 보관되는 토마토들 중에는 잘 익은 것도 있지만, 아직 익지 않은 토마토들도 있을 수 있다. 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 하나의 토마토의 인접한 곳은 왼쪽, 오른쪽, 앞, 뒤 네 방향
에 있는 토마토를 의미한다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 현수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지, 그 최소 일수를 알고 싶어 한다.

토마토를 창고에 보관하는 격자모양의 상자들의 크기와 익은 토마토들과 익지 않은 토마토들의 정보가 주어졌을 때, 며칠이 지나면 토마토들이 모두 익는지, 그 최소 일수를 구하는 프로그램을 작성하라. 단, 상자의 일부 칸에는 토마토가 들어있지 않을 수도 있다.

입력 설명

• 첫 줄에는 상자의 크기를 나타내는 두 정수 M, N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M, N ≤ 1,000 이다.
• 둘째 줄부터는 하나의 상자에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 상자에 담긴 토마토의 정보가 주어진다. 하나의 줄에는 상자 가로줄에 들어있는 토마토의 상태가 M개의 정수로 주어진다.
• 정수 1은 익은 토마토, 정수 0은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다.
  
  

출력 설명

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

입력예제

6 4
0 0 -1 0 0 0
0 0 1 0 -1 0
0 0 -1 0 0 0
0 0 0 0 -1 1

출력예제

4

내 코드

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

class Points{
    int x;
    int y;

    Points(int x, int y){
        this.x = x;
        this.y = y;
    }
}

public class Main {
    static int n, m, answer;
    static int[][] arr, dis;
    static int[] dx = {0, 1, 0, -1};
    static int[] dy = {-1, 0, 1, 0};

    int bfs(){
        Queue<Points> q = new LinkedList<>();
        // arr에 있는 1과 -1의 위치를 찾아 dis 배열에도 똑같은 위치에 초기화
        for(int i = 0 ; i < n; i++){ 
            for(int j = 0 ; j < m; j++){
                if(arr[i][j] == 1){
                    q.offer(new Points(i,j)); // 1인 부분부터 시작할 수 있도록 큐에 넣음
                    dis[i][j] = 1;
                }
              	else if(arr[i][j] == -1)
                  dis[i][j] = -1;
            }
        }
        // 큐를 활용한 BFS
        while(!q.isEmpty()){
            int len = q.size();
            for(int i = 0; i < len; i++){
                Points tmp = q.poll(); 
                dis[tmp.x][tmp.y] = 1;
                for(int j = 0; j < 4; j++){
                    int px = tmp.x + dx[j];
                    int py = tmp.y + dy[j];
                    if(px >= 0 && px < n && py >= 0 && py < m 
                    && arr[px][py] == 0 && dis[px][py] != 1){
                        dis[px][py] = 1;
                        q.offer(new Points(px, py));
                    }
                }
            }
            answer++;
        }
      	for(int i = 0; i < n; i++){
          for(int j =0; j < m; j++){
            if(dis[i][j] == 0)
              return -1;
          }
        }
      	return answer -1;
    }

    public static void main(String[] args) {
        Main t = new Main();
        Scanner kb = new Scanner(System.in);
        m = kb.nextInt();
        n = kb.nextInt();
        answer = 0;
        arr = new int[n][m];
        dis = new int[n][m];
        for(int i = 0 ; i < arr.length; i++){
            for(int j = 0; j < arr[0].length; j++){
                arr[i][j] = kb.nextInt();
            }
        }

        System.out.println(t.bfs());
      	
    }
}

• BFS를 활용하여 풀어보았다.
• 입력 값에 주어진 arr 배열과 크기가 같은 dis라는 2차원 배열을 만들어 arr에서 1과 -1인 부분을 dis에서도 1과 -1로 초기화 해준다.
• if(px >= 0 && px < n && py >= 0 && py < m && arr[px][py] == 0 && dis[px][py] != 1)조건에서 마지막 조건인 dis[px][py] != 1 부분을 초반에 캐치하지 못하여 테스트가 계속 실패했었다.
• 만약 dis[px][py] != 1 조건을 작성하지 않는다면 무한루프에 빠지게 될 수 있다. 해당 조건을 통해 이미 이전 for문을 통해 해당 위치가 익은 토마토인지 덜 익은 토마토인지 체크를 해줘야 한다.(그렇지 않는다면 똑같은 Points들이 또 큐에 들어가 무한반복이 된다.)