Merge pull request soapyigu#346 from soapyigu/BFS

BFS Updates

Author: soapyigu

BFS/ShortestPathGetFood.swift

@@ -0,0 +1,61 @@
+/**
+ * Question Link: https://leetcode.com/problems/shortest-path-to-get-food/
+ * Primary idea: BFS to go over all possible word paths until the cell is food, avoid hitting the obstacle.
+ * 
+ * Time Complexity: O(nm), Space Complexity: O(nm)
+ */
+
+class ShortestPathGetFood {
+    func getFood(_ grid: [[Character]]) -> Int {
+        let m = grid.count, n = grid[0].count
+        var isVisited = Array(repeating: Array(repeating: false, count: n), count: m)
+        
+        let start = findStart(grid)
+        
+        isVisited[start.0][start.1] = true
+        var queue = [Point(i: start.0, j: start.1, len: 0)]
+        
+        while !queue.isEmpty {
+            let point = queue.removeFirst()
+            
+            if grid[point.i][point.j] == "#" {
+                return point.len
+            }
+            
+            for dir in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
+                let (x, y) = (point.i + dir.0, point.j + dir.1)
+                
+                guard x >= 0 && x < m && y >= 0 && y < n && !isVisited[x][y] else {
+                    continue
+                }
+                
+                if grid[x][y] == "X" {
+                    continue
+                }
+                
+                isVisited[x][y] = true
+                queue.append(Point(i: x, j: y, len: point.len + 1))
+            }
+        }
+        
+        return -1
+    }
+    
+    private func findStart(_ grid: [[Character]]) -> (Int, Int) {
+        for i in 0..<grid.count {
+            for j in 0..<grid[0].count {
+                if grid[i][j] == "*" {
+                    return (i, j)
+                }
+            }
+        }
+        
+        return (-1, -1)
+    }
+    
+    struct Point {
+        var i: Int
+        var j: Int
+        var len: Int
+    }
+}

BFS/ShortestPathGridObstaclesElimination.swift

@@ -0,0 +1,63 @@
+/**
+ * Question Link: https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/
+ * Primary idea: BFS to go over all possible word paths until the end. Choose the path only the remaining elimination number is greater.
+ * 
+ * Time Complexity: O(nmk), Space Complexity: O(nm)
+ */
+
+class ShortestPathGridObstaclesElimination {
+    func shortestPath(_ grid: [[Int]], _ k: Int) -> Int {
+        let m = grid.count, n = grid[0].count
+        var remainings = Array(repeating: Array(repeating: -1, count: n), count: m)
+        
+        remainings[0][0] = k
+        var queue = [Point(i: 0, j: 0, remain: k)]
+        var count = 0
+        
+        if k > m + n - 2 {
+            return m + n - 2;
+        }
+        
+        while !queue.isEmpty {
+            
+            let currentPoints = queue
+            queue.removeAll()
+            
+            for point in currentPoints {
+                if point.i == m - 1 && point.j == n - 1 {
+                    return count
+                }
+            
+                for dir in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
+                    let (x, y) = (point.i + dir.0, point.j + dir.1)
+                
+                    guard x >= 0 && x < m && y >= 0 && y < n else {
+                        continue
+                    }
+                
+                    if grid[x][y] == 1 && point.remain <= 0 {
+                        continue
+                    }
+                    
+                    let remain = grid[x][y] == 1 ? point.remain - 1 : point.remain
+                    // only choose the path if remainings are greater
+                    if remainings[x][y] >= remain {
+                        continue
+                    }
+                    
+                    remainings[x][y] = remain
+                    queue.append(Point(i: x, j: y, remain: remain))
+                }
+            }
+            count += 1
+        }
+        
+        return -1
+    }
+    
+    struct Point {
+        var i: Int
+        var j: Int
+        var remain: Int
+    }
+}