미로탐색

문제

N×M크기의 배열로 표현되는 미로가 있다.

1	0	1	1	1	1
1	0	1	0	1	0
1	0	1	0	1	1
1	1	1	0	1	1

미로에서 1은 이동할 수 있는 칸을 나타내고, 0은 이동할 수 없는 칸을 나타낸다. 이러한 미로가 주어졌을 때, (1, 1)에서 출발하여 (N, M)의 위치로 이동할 때 지나야 하는 최소의 칸 수를 구하는 프로그램을 작성하시오. 한 칸에서 다른 칸으로 이동할 때, 서로 인접한 칸으로만 이동할 수 있다.

위의 예에서는 15칸을 지나야 (N, M)의 위치로 이동할 수 있다. 칸을 셀 때에는 시작 위치와 도착 위치도 포함한다.

입력

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

출력

첫째 줄에 지나야 하는 최소의 칸 수를 출력한다. 항상 도착위치로 이동할 수 있는 경우만 입력으로 주어진다.

예제 입력 1

4 6
101111
101010
101011
111011

예제 출력 1

15

예제 입력 2

4 6
110110
110110
111111
111101

예제 출력 2

9

예제 입력 3

2 25
1011101110111011101110111
1110111011101110111011101

예제 출력 3

38

예제 입력 4

7 7
1011111
1110001
1000001
1000001
1000001
1000001
1111111

예제 출력 4

13

풀이

(1, 1)에서 출발하여 (N, M)의 위치로 이동할 때 지나야 하는 최소의 칸 수룰 구하는 문제

모든 이동의 비용이 한 칸으로 같으므로 BFS가 시작점에서 가까운 칸부터 방문한다. DFS로도 모든 경로를 탐색해 최솟값을 찾을 수는 있지만, 처음 도착했을 때의 거리가 최소라는 보장이 없고 불필요한 경로를 많이 살핀다.

위치 이동은 상하 좌우로 이동하므로

final static int[][] PATH = {{0,1}, {0,-1}, {1,0}, {-1, 0}};

를 세팅 해준다.

그리고 범위 탐색을해야하므로 dist[][] 를 추가하여 방문범위를 추가한다.

아래 처럼 미로가있다면

4 6
101111
101010
101011
111011

dist로 방문 범위를 찍어주면 아래와 같은 결과를 얻을 수 있다.

 1  0  9 10 11 12 
 2  0  8  0 12  0 
 3  0  7  0 13 14 
 4  5  6  0 14 15 

그러면 (N, M)의 위치값을 구하는 것으로 dist[n-1][m-1]의 값을 출력해준다.

BFS 핵심 코드

public static void bfs(int n, int m) {
        Queue<Edge> queue = new LinkedList<>();
        queue.offer(new Edge(0, 0));
        dist[0][0] = 1;

        while (!queue.isEmpty()) {
            Edge e = queue.poll();
            int x = e.x;
            int y = e.y;
            for (int k = 0; k < 4; k++) {
                int nx = x + PATH[k][0];
                int ny = y + PATH[k][1];
                if (0 <= nx && n > nx && 0 <= ny && m > ny) {
                    if (table[nx][ny] == 1 && dist[nx][ny] == 0) {
                        queue.offer(new Edge(nx, ny));
                        dist[nx][ny] = dist[x][y] + 1;
                    }
                }
            }
        }
    }

거리 배열이 곧 방문 표시다

시작 칸 (0,0)의 거리를 1로 놓는다. 예제 1에서는 바로 아래 (1,0)가 거리 2, 그 아래 (2,0)가 거리 3, 다시 (3,0)가 거리 4다. 큐는 먼저 들어온 칸부터 꺼내므로 거리 2의 모든 칸을 처리한 뒤 거리 3의 칸을 처리한다. 따라서 처음 방문한 칸의 거리보다 더 짧은 경로가 나중에 발견될 수 없다.

dist[nr][nc] == 0은 아직 방문하지 않은 이동 가능 칸을 뜻한다. 큐에 넣는 즉시 거리를 적어 두어 같은 칸이 여러 방향에서 중복으로 들어오지 않게 한다. 벽은 table[nr][nc] == 0이므로 통과하지 않는다. 시작과 끝도 지나는 칸 수에 포함하므로 출발 거리를 0이 아닌 1로 둔다.

각 칸은 최대 한 번 큐에 들어가고 그때 네 방향만 검사한다. 시간과 거리 배열·큐의 공간은 O(NM)이다. 도착 가능성이 보장되어 있어 dist[n−1][m−1]이 0으로 남는 경우를 별도로 처리하지 않는다. 미로를 행·열로 읽으므로 문제의 좌표 (N,M)는 배열에서 (N−1,M−1)이라는 점을 주의한다.

소스코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 2178 : 미로탐색
 */
public class Main {
    private static int[][] table;
    private static int[][] dist;
    final static int[][] PATH = {{0,1}, {0,-1}, {1,0}, {-1, 0}};
    public static class Edge {
        int x;
        int y;

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

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] splitnm = in.readLine().split(" ");
        int n = Integer.parseInt(splitnm[0]);
        int m = Integer.parseInt(splitnm[1]);

        table = new int[n][m];
        dist = new int[n][m];
        for (int i = 0; i < n; i++) {
            String[] splitLine = in.readLine().split("");
            for (int j = 0; j < splitLine.length; j++) {
                table[i][j] = Integer.parseInt(splitLine[j]);
            }
        }
        bfs(n, m);
        System.out.println(dist[n - 1][m - 1]);
        in.close();
    }

    public static void bfs(int n, int m) {
        Queue<Edge> queue = new LinkedList<>();
        queue.offer(new Edge(0, 0));
        dist[0][0] = 1;

        while (!queue.isEmpty()) {
            Edge e = queue.poll();
            int x = e.x;
            int y = e.y;
            for (int k = 0; k < 4; k++) {
                int nx = x + PATH[k][0];
                int ny = y + PATH[k][1];
                if (0 <= nx && n > nx && 0 <= ny && m > ny) {
                    if (table[nx][ny] == 1 && dist[nx][ny] == 0) {
                        queue.offer(new Edge(nx, ny));
                        dist[nx][ny] = dist[x][y] + 1;
                    }
                }
            }
        }
    }
}

백준 원문 문제