[Swift]LeetCode576. 出界的路径数 | Out of Boundary Paths

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

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

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

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

There is an m by n grid with a ball. Given the start coordinate (i,j) of the ball, you can move the ball to adjacent cell or cross the grid boundary in four directions (up, down, left, right). However, you can at most move Ntimes. Find out the number of paths to move the ball out of grid boundary. The answer may be very large, return it after mod 109 + 7. 

Example 1:

Input: m = 2, n = 2, N = 2, i = 0, j = 0
Output: 6
Explanation:

Example 2:

Input: m = 1, n = 3, N = 3, i = 0, j = 1
Output: 12
Explanation:

Note:

1. Once you move the ball out of boundary, you cannot move it back.
2. The length and height of the grid is in range [1,50].
3. N is in range [0,50].

---

给定一个 m × n 的网格和一个球。球的起始坐标为 (i,j) ，你可以将球移到相邻的单元格内，或者往上、下、左、右四个方向上移动使球穿过网格边界。但是，你最多可以移动 N 次。找出可以将球移出边界的路径数量。答案可能非常大，返回 结果 mod 109 + 7 的值。

示例 1：

输入: m = 2, n = 2, N = 2, i = 0, j = 0
输出: 6
解释:

示例 2：

输入: m = 1, n = 3, N = 3, i = 0, j = 1
输出: 12
解释:

说明:

1. 球一旦出界，就不能再被移动回网格内。
2. 网格的长度和高度在 [1,50] 的范围内。
3. N 在 [0,50] 的范围内。

 

---

44ms

class Solution {
    func findPaths(_ m: Int, _ n: Int, _ N: Int, _ i: Int, _ j: Int) -> Int {
        var dp = [[[Int]]](repeating: [[Int]](repeating: [Int](repeating: -1, count: N+1), count: n), count: m)
        return findPaths(m, n, N, i, j, &dp)
    }
    
    func findPaths(_ m: Int, _ n: Int, _ N: Int, _ i: Int, _ j: Int, _ dp: inout [[[Int]]]) -> Int {
        // print("\(i), \(j), \(N)")
        let minMoves = min(min(i+1, m-i), min(j+1, n-j))
        if minMoves > N { return 0 }
        if dp[i][j][N] > -1 { return dp[i][j][N] }
        if dp[m-i-1][j][N] > -1 { return dp[m-i-1][j][N] }
        if dp[i][n-j-1][N] > -1 { return dp[i][n-j-1][N] }
        if dp[m-i-1][n-j-1][N] > -1 { return dp[m-i-1][n-j-1][N] }
        var res = 0
        for (d_i, d_j) in [(-1, 0), (1, 0), (0, -1), (0, 1)] {
            let next_i = i + d_i
            let next_j = j + d_j
            if next_i < 0 || next_i >= m || next_j < 0 || next_j >= n {
                res += 1
            } else {
                res += findPaths(m, n, N-1, next_i, next_j, &dp)
                res = res % 1000000007
            }
        }
        
        dp[i][j][N] = res 
        return res
    }
}

---

104ms

class Solution {    
    private let dirs = [[-1, 0], [1, 0], [0, -1], [0, 1]]
    private let mod = 1000000000 + 7
    
    func findPaths(_ m: Int, _ n: Int, _ N: Int, _ i: Int, _ j: Int) -> Int {
        var memo: [[[Int]]] = Array(repeating: Array(repeating: Array(repeating: -1, count: N + 1), count: n), count: m)
        return dfs(m, n, N, i, j, &memo)
    }
    
    private func dfs(_ m: Int, _ n: Int, _ N: Int, _ i: Int, _ j: Int, _ memo: inout [[[Int]]]) -> Int {
        if i < 0 || i >= m || j < 0 || j >= n {
            return 1
        }
        if N == 0 { return 0 }
        if memo[i][j][N] != -1 { return memo[i][j][N] }
        memo[i][j][N] = 0
        for dir in dirs {
            let x = i + dir[0]
            let y = j + dir[1]
            memo[i][j][N] = (memo[i][j][N] + dfs(m, n, N - 1, x, y, &memo) % mod) % mod
        }
        return memo[i][j][N]
    }
}

---

180ms

class Solution {
    func findPaths(_ m: Int, _ n: Int, _ N: Int, _ i: Int, _ j: Int) -> Int {
        let M = 1000000000 + 7
        let memoZero = Array(repeating: Array(repeating: 0, count: n), count: m)
        var memo = memoZero
        memo[i][j] = 1
        var count = 0
        for _ in 0..<N {
            var temp = memoZero
            for x in 0..<m {
                for y in 0..<n {
                    let curr = memo[x][y]
                    if x == m - 1 { count += curr }
                    if y == n - 1 { count += curr }
                    if x == 0 { count += curr }
                    if y == 0 { count += curr }
                    count %= M
                    temp[x][y] += x > 0 ? memo[x - 1][y]: 0
                    temp[x][y] += x < m - 1 ? memo[x + 1][y]: 0
                    temp[x][y] += y > 0 ? memo[x][y - 1]: 0
                    temp[x][y] += y < n - 1 ? memo[x][y + 1]: 0
                    temp[x][y] %= M
                }
            }
            memo = temp
        }
        return count
    }
}

---

Runtime: 332 ms

Memory Usage: 19 MB

class Solution {
    func findPaths(_ m: Int, _ n: Int, _ N: Int, _ i: Int, _ j: Int) -> Int {
        var res:Int = 0
        var dp:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:n),count:m)
        dp[i][j] = 1
        var dirs:[[Int]] = [[0,-1],[-1,0],[0,1],[1,0]]
        for k in 0..<N
        {
            var t:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:n),count:m)
            for r in 0..<m
            {
                for c in 0..<n
                {
                    for dir in dirs
                    {
                        var x:Int = r + dir[0]
                        var y:Int = c + dir[1]
                        if x < 0 || x >= m || y < 0 || y >= n
                        {
                            res = (res + dp[r][c]) % 1000000007
                        }
                        else
                        {
                            t[x][y] = (t[x][y] + dp[r][c]) % 1000000007
                        }
                    }
                }
            }
            dp = t
        }
        return res
    }
}