leetcode 576. Out of Boundary Paths（边界外的路径）

原创于 2020-11-25 15:34:28 发布 · 524 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法

leetcode 专栏收录该内容

490 篇文章

订阅专栏

博客围绕在m*n矩阵中，从起始位置(i, j)出发，最多走N步，计算球出边界路径数的问题展开。介绍了两种算法思路，一是三维DP逆向思维，从边界外到起始点；二是DP+DFS，从起始点出发到边界外。结果需对109 + 7取模。

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 N times. 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:
在这里插入图片描述
给出一个m*n矩阵，和一个起始位置(i, j)，最多走N步，问能出边界外有多少中可能。因为可能性很多，所以结果要对10⁹+7取模。

思路：
三维DP：步数N，m， n
1.逆向思维，从(i, j)到边界外的可能数就等于边界外到(i, j)的可能数，反向走，从边界外开始，当点在边界外时，有一种可能往边界内走，点在边界内时，它有四个方向可以到达这个点。
这种方法是m*n中每个点都遍历到

    public int findPaths(int m, int n, int N, int i, int j) {
        int[][][] dp = new int[N+1][m][n];
        
        int[] dirc = new int[]{-1, 0, 1, 0, -1};
        int mod = 1000000007;
        
        for(int s = 1; s <= N; s ++) {
            for(int r = 0; r < m; r ++) {
                for(int c = 0; c < n; c ++) {
                    for(int d = 0; d < 4; d ++) {
                        int py = r + dirc[d];
                        int px = c + dirc[d+1];
                        if(px < 0 || py < 0 || px >= n || py >= m) {
                            dp[s][r][c] += 1;
                        } else {
                            dp[s][r][c] = (dp[s][r][c] + dp[s-1][py][px]) % mod;
                        }
                    }
                    
                }
                
            }
        }
        
        return dp[N][i][j];
    }

2.DP+DFS
从(i, j)出发，到每个点的上下左右，到边界外时dp+1，步数超过N时返回0
但是注意，上面的方法只有两个dp相加，所以和不会超过int的范围，但是dfs不只两个相加，所以要用long型。

    Long[][][] dp = null;
    final int mod = 1000000007;
    public int findPaths(int m, int n, int N, int i, int j) {
        dp = new Long[N+1][m][n];
        return (int)(dfs(m, n, N, i, j, 0)%mod);
    }
    
    long dfs(int m, int n, int N, int i, int j, int step) {
        if(step > N) {
            return 0;
        }
        
        if(i < 0 || j < 0 || i >= m || j >= n) {
            return 1;
        }
        
        if(dp[step][i][j] != null) {
            return dp[step][i][j];
        }
        
        int[] dir = new int[]{-1, 0, 1, 0, -1};
        long way = 0;
        for(int d = 0; d < 4; d++) {
            int tx = i + dir[d];
            int ty = j + dir[d+1];
            way += dfs(m, n, N, tx, ty, step+1) % mod;
        }
        
        dp[step][i][j] = way;
        return way;
    }