Programmers | Level 2 | 미로 탈출
Programmers | Level 2 | 미로 탈출
Problems
- 📘 Src: Programmers
- 🗂️ Cat: Breadth-First Search
Description
1 x 1 크기의 칸들로 이루어진 직사각형 격자 형태의 미로에서 탈출하려고 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽으로 된 칸은 지나갈 수 없고 통로로 된 칸으로만 이동할 수 있습니다. 통로들 중 한 칸에는 미로를 빠져나가는 문이 있는데, 이 문은 레버를 당겨서만 열 수 있습니다. 레버 또한 통로들 중 한 칸에 있습니다. 따라서, 출발 지점에서 먼저 레버가 있는 칸으로 이동하여 레버를 당긴 후 미로를 빠져나가는 문이 있는 칸으로 이동하면 됩니다. 이때 아직 레버를 당기지 않았더라도 출구가 있는 칸을 지나갈 수 있습니다. 미로에서 한 칸을 이동하는데 1초가 걸린다고 할 때, 최대한 빠르게 미로를 빠져나가는데 걸리는 시간을 구하려 합니다.
미로를 나타낸 문자열 배열 maps가 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 만약, 탈출할 수 없다면 -1을 return 해주세요.
Constraints
- 5 ≤
maps의 길이 ≤ 100- 5 ≤
maps[i]의 길이 ≤ 100 maps[i]는 다음 5개의 문자들로만 이루어져 있습니다.- S : 시작 지점
- E : 출구
- L : 레버
- O : 통로
- X : 벽
- 시작 지점과 출구, 레버는 항상 다른 곳에 존재하며 한 개씩만 존재합니다.
- 출구는 레버가 당겨지지 않아도 지나갈 수 있으며, 모든 통로, 출구, 레버, 시작점은 여러 번 지나갈 수 있습니다.
- 5 ≤
Examples
| maps | result |
|---|---|
["SOOOL","XXXXO","OOOOO","OXXXX","OOOOE"] | 16 |
["LOOXS","OOOOX","OOOOO","OOOOO","EOOOO"] | -1 |
Solutions
Code
import java.util.*;
class Solution {
// 상하좌우로 이동하기 위한 델타 배열
private static final int[] dx = new int[]{0, 1, 0, -1}; // x 방향
private static final int[] dy = new int[]{1, 0, -1, 0}; // y 방향
public int solution(String[] maps) {
int rows = maps.length;
int cols = maps[0].length();
int[][] grid = new int[rows][cols];
boolean[][] toLever = new boolean[rows][cols];
boolean[][] toExit = new boolean[rows][cols];
int[] start = new int[2];
int[] lever = new int[2];
int[] exit = new int[2];
// 지도 초기화 및 시작, 레버, 출구 위치 찾기
for (int i = 0; i < rows; i++) {
String[] row = maps[i].split("");
for (int j = 0; j < cols; j++) {
if (row[j].equals("X")) {
toLever[i][j] = true; // 벽은 방문 불가
toExit[i][j] = true; // 벽은 방문 불가
}
if (row[j].equals("S")) {
start = new int[]{i, j}; // 시작 위치
}
if (row[j].equals("L")) {
lever = new int[]{i, j}; // 레버 위치
grid[i][j] = 1;
}
if (row[j].equals("E")) {
exit = new int[]{i, j}; // 출구 위치
grid[i][j] = 2;
}
}
}
// 시작점 -> 레버까지의 최소 시간 계산
int timeToLever = bfs(grid, toLever, rows, cols, start, lever);
if (timeToLever == -1) return -1; // 레버에 도달할 수 없으면 -1 반환
// 레버 -> 출구까지의 최소 시간 계산
int timeToExit = bfs(grid, toExit, rows, cols, lever, exit);
if (timeToExit == -1) return -1; // 출구에 도달할 수 없으면 -1 반환
// 두 경로의 시간 합산 반환
return timeToLever + timeToExit;
}
private int bfs(int[][] grid, boolean[][] marked, int rows, int cols, int[] start, int[] target) {
Deque<int[]> queue = new ArrayDeque<>();
queue.offer(new int[]{start[0], start[1], 0});
while (!queue.isEmpty()) {
int[] current = queue.poll();
int cx = current[0];
int cy = current[1];
int cs = current[2];
marked[cx][cy] = true;
for (int i = 0; i < 4; i++) {
int nx = cx + dx[i];
int ny = cy + dy[i];
int ns = cs + 1;
// 목표 지점 도달 시 시간 반환
if (isValid(nx, ny, rows, cols) && target[0] == nx && target[1] == ny) return ns;
// 유효한 범위 내에 있으며 아직 방문하지 않은 경우
if (isValid(nx, ny, rows, cols) && !isMarked(marked, nx, ny)) {
queue.offer(new int[]{nx, ny, ns});
marked[nx][ny] = true;
}
}
}
return -1; // 목표에 도달할 수 없는 경우
}
// 주어진 좌표가 유효한지 확인
private boolean isValid(int nx, int ny, int rows, int cols) {
return nx >= 0 && ny >= 0 && nx < rows && ny < cols;
}
// 방문 여부 확인
private boolean isMarked(boolean[][] marked, int nx, int ny) {
return marked[nx][ny];
}
}
Approach
이 문제는 그래프 탐색 문제로, 너비 우선 탐색(BFS)을 이용하여 미로 내에서의 최단 경로를 찾아야 합니다. 미로 내에는 시작점, 레버, 출구가 있으며, 시작점에서 레버로 이동한 뒤 레버를 당기고 출구로 이동하는 두 가지 경로를 구해야 합니다.
1. 문제 분석
주어진 미로에서 레버를 먼저 찾아 당기고, 이후 출구까지 이동해야 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽은 통과할 수 없고 통로만 이동 가능합니다. BFS를 이용해 각 칸에서 상하좌우로 이동하며, 가장 짧은 경로를 찾아가는 방식으로 최단 경로를 구할 수 있습니다. 문제는 두 가지 단계로 나뉩니다: 먼저 시작점에서 레버까지 이동, 그다음 레버에서 출구까지 이동입니다. 두 단계 중 하나라도 도달할 수 없는 경우 탈출은 불가능하므로 -1을 반환해야 합니다.
2. 접근 방식
미로 탐색을 위해 BFS를 사용하여 경로를 찾습니다. BFS는 각 칸을 순차적으로 탐색하며, 먼저 레버까지의 경로를 탐색한 뒤, 레버에서 출구까지의 경로를 탐색합니다. 각 경로에서 필요한 시간을 누적하여 반환하며, 도달할 수 없는 경우에는 -1을 반환합니다.
- 지도 초기화: 주어진
maps배열을 순회하며, 시작점(S), 레버(L), 출구(E)의 위치를 기록하고, 벽(X)을 표시하여 통과할 수 없는 칸을 설정합니다. - BFS 탐색: 시작점에서 레버까지 이동하는 최단 경로를 BFS로 탐색합니다. 그다음 레버에서 출구까지의 최단 경로를 또다시 BFS로 탐색합니다.
- 경로 유효성 확인: 각 BFS 탐색 결과, 레버 또는 출구에 도달하지 못하면
-1을 반환합니다. 두 경로 모두 성공적으로 탐색된다면, 각 경로의 시간을 더하여 최종 결과를 반환합니다.
3. 지도 초기화 및 위치 설정
가장 먼저 미로에 대한 기본 정보를 처리해야 합니다. 각 위치에 대해 시작점(S), 레버(L), 출구(E)의 좌표를 찾아 저장하고, 벽(X)은 이동이 불가능한 칸으로 설정합니다. 이를 위해 주어진 maps 배열을 순회하며 해당 칸의 정보를 저장합니다.
int rows = maps.length;
int cols = maps[0].length();
int[][] grid = new int[rows][cols]; // 지도를 저장할 배열
boolean[][] toLever = new boolean[rows][cols]; // 레버까지의 경로 방문 체크
boolean[][] toExit = new boolean[rows][cols]; // 출구까지의 경로 방문 체크
int[] start = new int[2]; // 시작 위치
int[] lever = new int[2]; // 레버 위치
int[] exit = new int[2]; // 출구 위치
for (int i = 0; i < rows; i++) {
String[] row = maps[i].split("");
for (int j = 0; j < cols; j++) {
// 벽은 방문할 수 없도록 설정
if (row[j].equals("X")) {
toLever[i][j] = true;
toExit[i][j] = true;
}
// 시작 위치 설정
if (row[j].equals("S")) {
start = new int[]{i, j};
}
// 레버 위치 설정
if (row[j].equals("L")) {
lever = new int[]{i, j};
grid[i][j] = 1;
}
// 출구 위치 설정
if (row[j].equals("E")) {
exit = new int[]{i, j};
grid[i][j] = 2;
}
}
}
이 코드는 미로에서 시작점, 레버, 출구의 위치를 찾아 각각 저장하며, 벽이 있는 칸은 방문 불가능한 상태로 설정합니다.
4. BFS 탐색을 통한 최단 경로 계산
BFS를 이용해 시작점에서 레버까지, 그리고 레버에서 출구까지의 최단 경로를 찾아야 합니다. BFS는 현재 위치에서 상하좌우로 이동하면서 가장 짧은 경로를 찾는 데 사용되며, 큐를 사용하여 너비 우선 탐색을 진행합니다. 탐색이 완료되면 걸린 시간을 반환하고, 도달할 수 없으면 -1을 반환합니다.
private int bfs(
int[][] grid, // 지도
boolean[][] marked, // 방문 체크
int rows, // 최대 행
int cols, // 최대 열
int[] start, // 시작 위치
int[] target // 타겟 위치
) {
Deque<int[]> queue = new ArrayDeque<>();
queue.offer(new int[]{start[0], start[1], 0}); // 시작점에서 탐색 시작 [시작 행, 시작 열, 시작 스텝]
while (!queue.isEmpty()) {
int[] current = queue.poll();
int cx = current[0]; // 현재 행
int cy = current[1]; // 현재 열
int cs = current[2]; // 현재 스텝
marked[cx][cy] = true; // 현재 위치 방문 처리
// 4방향 탐색 (상, 하, 좌, 우)
for (int i = 0; i < 4; i++) {
int nx = cx + dx[i];
int ny = cy + dy[i];
int ns = cs + 1;
// 목표 지점에 도달하면 걸린 시간을 반환
if (isValid(nx, ny, rows, cols) && target[0] == nx && target[1] == ny) {
return ns;
}
// 유효한 좌표이면서 아직 방문하지 않은 곳이면 큐에 추가
if (isValid(nx, ny, rows, cols) && !isMarked(marked, nx, ny)) {
queue.offer(new int[]{nx, ny, ns});
marked[nx][ny] = true; // 방문 처리
}
}
}
// 목표 지점에 도달하지 못한 경우
return -1;
}
여기서 bfs() 함수는 지정된 시작점에서 목표 지점까지의 최단 경로를 탐색합니다. 이 과정에서, 한 칸씩 이동하며 상하좌우를 검사하고, 큐를 사용해 모든 가능한 경로를 탐색합니다. 목표 지점에 도달하면 경과된 시간을 반환하고, 도달하지 못한 경우에는 -1을 반환합니다.
5. 유효한 좌표 및 방문 여부 확인
BFS 과정에서 이동할 좌표가 미로 내에서 유효한지, 그리고 이미 방문한 곳인지 확인하는 보조 함수가 필요합니다. 이를 통해 유효하지 않은 좌표로의 이동을 방지하고, 이미 방문한 곳을 다시 탐색하지 않도록 합니다.
// 주어진 좌표가 지도를 벗어나지 않는지 확인
private boolean isValid(int nx, int ny, int rows, int cols) {
return nx >= 0 && ny >= 0 && nx < rows && ny < cols;
}
// 해당 좌표가 이미 방문된 곳인지 확인
private boolean isMarked(boolean[][] marked, int nx, int ny) {
return marked[nx][ny];
}
isValid() 함수는 좌표가 미로 범위를 벗어났는지 확인하고, isMarked() 함수는 해당 좌표가 이미 방문된 곳인지 확인합니다.
6. 결과 계산 및 반환
미로 탈출 문제는 두 가지 경로(시작점에서 레버까지, 레버에서 출구까지)를 찾는 문제입니다. 두 경로의 시간을 각각 BFS로 계산한 후, 두 경로 중 하나라도 찾을 수 없으면 -1을 반환하고, 두 경로를 모두 찾으면 그 합을 반환합니다.
// 시작점 -> 레버까지의 시간 계산
int timeToLever = bfs(grid, toLever, rows, cols, start, lever);
if (timeToLever == -1) return -1; // 레버에 도달하지 못하면 탈출 불가
// 레버 -> 출구까지의 시간 계산
int timeToExit = bfs(grid, toExit, rows, cols, lever, exit);
if (timeToExit == -1) return -1; // 출구에 도달하지 못하면 탈출 불가
// 두 경로의 시간 합산하여 반환
return timeToLever + timeToExit;
이 코드에서 두 경로의 시간을 각각 계산한 뒤, 탈출할 수 없을 경우 -1을 반환하고, 성공적으로 탈출할 경우 두 경로의 시간을 합산하여 반환합니다.
Complexity
- ⏳ TC: O(n * m)
- 💾 SC: O(n * m)
미로의 모든 칸을 한 번씩 탐색하기 때문에 시간 복잡도는 미로의 크기에 비례하여 O(n * m)입니다. 여기서 n은 미로의 행(row) 수, m은 미로의 열(column) 수입니다. 공간 복잡도 역시 BFS 탐색을 위한 큐와 방문 여부를 기록하는 배열을 사용하기 때문에 O(n * m)입니다.
- Algorithm
- BFS