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

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;
    }

参考方法1，方法2