[알고리즘] Swift -백준 #2178(미로 탐색) -BFS

문제링크

https://www.acmicpc.net/problem/2178

2178번: 미로 탐색

 

문제

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개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

출력

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

 

---

분석

nXm 사이즈의 미로 

1 = 이동할 수 있는 칸, 0 = 이동할 수 없는 칸

(1, 1)에서 출발 (n, m)의 위치로 이동할 때 지나야하는 최소의 칸수를 구하라

이동할 때는 인접한 칸으로만 이동이 가능하다

 

풀이 과정

n = 세로, m = 가로

n번 반복 = 이동가능여부

 

풀이

class Queue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        self.enQueue = queue
    }
    
    func push(_ element: T) {
        enQueue.append(element)
    }
    
    func pop() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }

    func front() -> T? {
        let newQue = deQueue.reversed() + enQueue
        return newQue.first
    }
}

let input = readLine()!.split(separator: " ").map{ Int($0)!}
let n = input[0] //세로
let m = input[1] //가로

var checkArr = [[Bool]](repeating: Array(repeating: false, count: m), count: n)
var distance = [[Int]](repeating: Array(repeating: 0, count: m), count: n)
var arr = [[Int]]()

for _ in 0..<n {
    arr.append(Array(readLine()!).map {Int(String($0))!})
}

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

func isValid(y: Int, x: Int) -> Bool {
    return 0 <= y && y <= n-1 && 0 <= x && x <= m-1 ? true : false
}

func bfs(y: Int, x: Int) {
    checkArr[y][x] = true
    distance[y][x] = 1
    
    let q = Queue<[Int]>([])
    q.push([y, x])
    
    while !q.isEmpty {
        let pop = q.pop()
        let y = pop[0]
        let x = pop[1]
        
        for k in 0..<4 {
            let nextY = y + dy[k]
            let nextX = x + dx[k]
            
            if isValid(y: nextY, x: nextX) && !checkArr[nextY][nextX] && arr[nextY][nextX] == 1 {
                distance[nextY][nextX] = distance[y][x] + 1
                checkArr[nextY][nextX] = true
                q.push([nextY, nextX])
            }
        }
    }
}

bfs(y: 0, x: 0)
print(distance[n-1][m-1])

distance라는 배열을 만들어서 최단 거리의 값을 저장시킨다.
목적지에 도달했을 때의 값을 구한다.

 

결과

 

 

 

 

---

📂  정리

이번 문제는 시작 위치와 도착 위치가 주어졌을 때

도착 위치까지 가는 최소 거리를 구하는 문제이다.

최소 루트의 길찾기 문제

 

일단 먼저 빠르게 목적지까지 도달해야하기 떄문에 깊이 탐색(DFS)이 아닌 너비 탐색(BFS)로 구현하였다.

그리고 새로운 배열을 만들어 최단 거리의 값을 더해주어 저장해놓고

마지막 도착 위치에서의 값을 출력해준다.