12-wnsmir

[wnsmir]

🔗 문제 링크

이것이 코딩테스트다 p152에서 발췌하였습니다.

문제 : 미로탈출
N*M의 map이 아래의 예시처럼 주어지고, 1은 지나다닐 수 있는길, 0은 벽입니다. 오른쪽 하단 끝으로 가기까지 최단거리를 구하시오.

입력예시
5 6
101010
111111
000001
111111
111111

출력예시
10

✔️ 소요된 시간

40min

✨ 수도 코드

N M을 split으로 받아줍니다. (띄워쓰기로 구분)
이후 그래프는 띄워쓰기로 구분되어있지 않기 떼문에 그냥 input으로 받아줍니다.

dx dy를 만들어주는데, for문으로 i를 4번 돌려가며 상하좌우를 실현하기위함 입니다.

dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

for i in range(4):
   nx = x + dx[i]
   ny = y + dy[i]

저는 주로 이 방법을 사용합니다.

이후 BFS를 활용하여 벽이거나 지형을 넘어가는 좌표라면 pass
상하좌우로 이동한 길이 1이라면 지나갈 수 있는 길이라 판단하고 이전 길의 값에 1을 더한 값으로 업데이트 합니다.

bfs가 한단계씩 길을 넓혀가기 떄문에 최단거리에 유용하다 판단되어 bfs를 사용하였습니다. (가중치도 0)

[kangrae-jo]

미로 찾기 오랜만에 해봐서 재밌네요! 저도 queue로 구현했습니다.

꽤 빨리 완성했었는데... 스페이스로 구분되지 않는 입력을 복사 붙여넣기를해서...
cin 이 인식을 못해서 출력이 안되는 겁니다 ㅋㅋㅋㅋㅋ
저는 제 로직이 잘못되서 무한루프인 줄 알고 한참 고민했었습니다.

(그리고 미로를 탈출할 수 없는 경우 등은 무시했습니다!)

CPP CODE

#include <iostream>
#include <queue>
#include <vector>

#define WALL 0
#define PATH 1
#define VISITED 2

using namespace std;

int N, M;
int offset[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

bool isMoveable(vector<vector<int>>& maze, int x, int y) {
    return 0 <= x && x < M && 0 <= y && y < N && maze[y][x] == PATH;
}

int main() {
    cin >> N >> M;

    vector<vector<int>> maze(N, vector<int>(M));
    for (int y = 0; y < N; y++) {
        for (int x = 0; x < M; x++) {
            cin >> maze[y][x];
        }
    }

    queue<pair<int, int>> q;
    q.push(make_pair(0, 0));
    maze[0][0] = VISITED;

    int minDistance = 1;
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            int y = q.front().first;
            int x = q.front().second;
            q.pop();

            if (x == M - 1 && y == N - 1) {
                cout << minDistance;
                return 0;
            }

            for (int dir = 0; dir < 4; dir++) {
                int y_ = y + offset[dir][0];
                int x_ = x + offset[dir][1];

                if (isMoveable(maze, x_, y_)) {
                    q.push(make_pair(y_, x_));
                    maze[y_][x_] = VISITED;
                }
            }
        }
        minDistance++;
    }

    cout << -1;

    return 0;
}

[g0rnn]

오랜만에 미로찾기 문제 잘 풀었습니다. 미로찾기만큼 자료구조와 알고리즘 스킬을 적절히 사용할 수 있는 문제 유형은 또 없는것 같네요.

남들이 bfs로 풀거 같아 dfs로 구현해보았습니다. 최단 길이를 구할 때엔 dfs가 효율적이지 않으나 뭐 지금은 그런건 의미가 없는 것 같아서 dfs를 선택했습니다.

근데 코드를 완성하고 정답이 나오지 않아서 한참을 고민하다 강래님처럼 입력 문제였음을 확인했습니다..

bool canMove(int x, int y) {
    return 0 <= x && x < m && 0 <= y && y < n
           && map[y][x] == 1;
}

void dfs(int x, int y, int cnt) {
    if (x == m - 1 && y == n - 1) {
        minimum = min(minimum, cnt);
        return;
    }

    for (auto &dir: offset) {
        int nx = x + dir[0];
        int ny = y + dir[1];
        if (canMove(nx, ny)) {
            map[ny][nx] = 2;
            dfs(nx, ny, cnt + 1);
            map[ny][nx] = 1;
        }
    }
}

[kokeunho]

저도 BFS로 풀어보았습니다.
map 입력 받는 부분이 평소 풀던 문제랑 조금 달라서
새로운 방법을 배울 수 있었습니다.
항상 nextInt()로 정수값을 입력 받았는데
해당 문제처럼 띄워쓰기가 없는 입력의 경우
nextLine()으로 문자열을 입력받고 charAt(j) (j번째 문자열)로 분리하는 방법을 사용해야 했습니다.
저도 다음 문제 미로 찾기 한번 해봐야겠습니다
이번 PR도 수고많으셨습니다.

java code

import java.util.*;

public class Main {
    static int n, m;
    static int[][] map;
    static int[][] distance;
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        map = new int[n][m];
        distance = new int[n][m];

        sc.nextLine();

        for (int i = 0; i < n; i++) {
            String line = sc.nextLine();
            for (int j = 0; j < m; j++) {
                map[i][j] = line.charAt(j) - '0';
                distance[i][j] = -1;
            }
        }
        bfs(0, 0);

        System.out.println(distance[n-1][m-1]);

    }

    public static void bfs(int sx, int sy) {
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{sx, sy});
        distance[sx][sy] = 1;

        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int x = current[0];
            int y = current[1];

            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];

                if (nx >= 0 && nx < n && ny >= 0 && ny < m && map[nx][ny] == 1 && distance[nx][ny] == -1) {
                    distance[nx][ny] = distance[x][y] + 1;
                    queue.offer(new int[]{nx, ny});
                }
            }
        }
    }
}