[Swift]LeetCode63. 不同路径 II | Unique Paths II

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9921730.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

Note: m and n will be at most 100.

Example 1:

Input:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
Output: 2
Explanation:
There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right

---

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

说明：m 和 n 的值均不超过 100。

示例 1:

输入:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

---

12ms

class Solution {
    func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
        let rowCount = obstacleGrid.count
        let colCount = obstacleGrid.first?.count ?? 0
        guard rowCount > 0, colCount > 0 else { return 0 }
        var paths = Array(repeating: Array(repeating: 0, count: colCount), count: rowCount)
        
        if obstacleGrid[0][0] != 1 {
            paths[0][0] = 1
        }
        for i in 1..<rowCount {
            if obstacleGrid[i][0] != 1 {
                paths[i][0] = paths[i-1][0]
            }
        }
        
        for i in 1..<colCount {
            if obstacleGrid[0][i] != 1 {
                paths[0][i] = paths[0][i-1]
            }
        }
        
        for r in 1..<rowCount {
            for c in 1..<colCount {
                if obstacleGrid[r][c] != 1 {
                    paths[r][c] = paths[r-1][c] + paths[r][c-1]
                } else {
                    paths[r][c] = 0
                }
            }
        }
        
        return paths[rowCount-1][colCount-1]
    }
}

---

16ms

class Solution {
    func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
        
        let m = obstacleGrid.count
        if m == 0 { return 0 }
        let n = obstacleGrid[0].count
        if n == 0 { return 0 }
                
        var f = [[Int]](repeating: [Int](repeating: 0, count: n), count: m)
        
        for i in 0..<m {
            if obstacleGrid[i][0] == 1 {
                break
            } else {
                f[i][0] = 1
            }
        }
        
        for i in 0..<n {
            if obstacleGrid[0][i] == 1 {
                break
            } else {
                f[0][i] = 1
            }
        }
        
        for i in 1..<m {
            for j in 1..<n {
                
                if obstacleGrid[i][j] == 1 {
                    f[i][j] = 0
                } else {
                    f[i][j] = f[i - 1][j] + f[i][j - 1]
                }
            }
        }
        
        return f[m - 1][n - 1]
    }
}

---

16ms

class Solution {
    func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
        guard obstacleGrid.count > 0 && obstacleGrid[0].count > 0 else {
            return 0
        }
        var m = obstacleGrid.count, n = obstacleGrid[0].count
        var dp = [[Int]](repeating: [Int](repeating: 0, count: n), count: m)
        for i in 0..<m {
            if obstacleGrid[i][0] == 1 {
                for k in i..<m {
                    dp[k][0] = 0
                }
                break
            } else {
                dp[i][0] = 1
            }
        }
        for j in 0..<n {
            if obstacleGrid[0][j] == 1 {
                for k in j..<n {
                    dp[0][k] = 0
                }
                break
            } else {
                dp[0][j] = 1
            }
            
        }

        for i in 1..<m {
            for j in 1..<n {
                if obstacleGrid[i][j] == 1 {
                    dp[i][j] = 0
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
                }
                
            }
        }

        return dp[m - 1][n - 1]
    }
}

---

20ms

class Solution {
    func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
        guard obstacleGrid.count > 0 && obstacleGrid[0].count>0 else {
            return 0
        }
 
        let rowCount = obstacleGrid.count
        let colCount = obstacleGrid[0].count
        var dp = [[Int]](repeating:[Int](repeating:1, count:colCount), count:rowCount)
        var occupiedRow = false
        var occupiedCol = false
        for row in 0..<rowCount {
           if obstacleGrid[row][0] == 1 || occupiedRow {
               occupiedRow = true
               dp[row][0] = 0
           } 
        }
            
        for col in 0..<colCount {
           if obstacleGrid[0][col] == 1 || occupiedCol {
               occupiedCol = true
               dp[0][col] = 0
           } 
        }
        
        for i in 1..<rowCount {
            for j in 1..<colCount{
                if obstacleGrid[i][j] == 1 {
                    dp[i][j] = 0
                } else {
                    dp[i][j] =  (obstacleGrid[i-1][j] == 1 ? 0 : dp[i-1][j]) + (obstacleGrid[i][j-1] == 1 ? 0 : dp[i][j-1])
                }    
            }
        }
        
        return dp[rowCount-1][colCount-1]    
    }
}

---

24ms

class Solution {
    func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
        var Result = Array(repeating: Array(repeating: 0, count:obstacleGrid[0].count)
        , count: obstacleGrid.count)
        if obstacleGrid.count == 0 || obstacleGrid[0].count == 0 || obstacleGrid[0][0] == 1 {
            return 0
        }
        // 设置边界值，碰到障碍物后都无路径
        for i in 0..<obstacleGrid.count {
             if obstacleGrid[i][0] == 1 {
                 break
             }
             Result[i][0] = 1
        }
        // 设置边界值，碰到障碍物后都无路径
        for j in 0..<obstacleGrid[0].count {
            if obstacleGrid[0][j] == 1 {
                break
            }
            Result[0][j] = 1
        }

        // 动态规划求出路径（迭代法）
        for i in 1..<obstacleGrid.count {
            for j in 1..<obstacleGrid[0].count {
                if obstacleGrid[i][j] == 0 {
                    Result[i][j] = Result[i-1][j] + Result[i][j-1]
                } else { // 障碍物无路劲
                    Result[i][j] = 0
                }
            }
        }
        return Result[Result.count - 1][Result[0].count - 1]
    }
}

---

24ms

class Solution {
    func uniquePathsWithObstacles(_ obstacleGrid: [[Int]]) -> Int {
        let R = obstacleGrid.count
        let C = obstacleGrid[0].count
        var obstacleGrid = obstacleGrid

        // If the starting cell has an obstacle, then simply return as there would be
        // no paths to the destination.
        if obstacleGrid[0][0] == 1 {
            return 0
        }

        // Number of ways of reaching the starting cell = 1.
        obstacleGrid[0][0] = 1

        // Filling the values for the first column
        for i in 1..<R {
            obstacleGrid[i][0] = (obstacleGrid[i][0] == 0 && obstacleGrid[i - 1][0] == 1) ? 1 : 0
        }

        // Filling the values for the first row
        for i in 1..<C {
            obstacleGrid[0][i] = (obstacleGrid[0][i] == 0 && obstacleGrid[0][i - 1] == 1) ? 1 : 0
        }

        // Starting from cell(1,1) fill up the values
        // No. of ways of reaching cell[i][j] = cell[i - 1][j] + cell[i][j - 1]
        // i.e. From above and left.
        for i in 1..<R {
            for j in 1..<C {
                if obstacleGrid[i][j] == 0 {
                    obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1]
                } else {
                    obstacleGrid[i][j] = 0
                }
            }
        }

        // Return value stored in rightmost bottommost cell. That is the destination.
        return obstacleGrid[R - 1][C - 1]
    }
}