问题：

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 10^9 + 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].

解决：

【题意】给定一个二维的数组，某个位置放个足球，每次可以在上下左右四个方向中任意移动一步，总共可以移动N步，问我们总共能有多少种移动方法能把足球移除边界。

①  动态规划，对于这种结果很大的数如果用递归解法很容易爆栈，所以最好考虑使用DP来解。

dp[k][i][j]表示总共走k步，从(i,j)位置走出边界的总路径数。对于dp[k][i][j]，走k步出边界的总路径数等于其周围四个位置的走k-1步出边界的总路径数之和，如果周围某个位置已经出边界了，那么就直接加上1，否则就在dp数组中找出该值，这样整个更新下来，我们就能得出每一个位置走任意步数的出界路径数了，最后只要返回dp[N][i][j]就是所求结果了。

class Solution { //46ms
    public int findPaths(int m, int n, int N, int i, int j) {
        long[][][] dp = new long[N + 1][m][n];
        for (int k = 1;k <= N;k ++){
            for (int x = 0;x < m;x ++){
                for (int y = 0;y < n;y ++){
                    long v1 = (x == 0) ? 1 : dp[k - 1][x - 1][y];
                    long v2 = (x == m - 1) ? 1 : dp[k - 1][x + 1][y];
                    long v3 = (y == 0) ? 1 : dp[k - 1][x][y - 1];
                    long v4 = (y == n - 1) ? 1 : dp[k - 1][x][y + 1];
                    dp[k][x][y] = (v1 + v2 + v3 + v4) % 1000000007;
                }
            }
        }
        return (int)dp[N][i][j];
    }
}

② 在discuss中看到的，dfs。

class Solution { //12ms
    public int findPaths(int m, int n, int N, int i, int j) {
        int[][][] dp = new int[m][n][N + 1];
        return dfs(dp,i,j,N) % 1000000007;
    }
    int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
    public int dfs(int[][][] dp,int i,int j,int N){
        if(i < 0 || j < 0 || i >= dp.length || j >= dp[0].length) return 1;
        if(i - N >= 0 && i + N < dp.length && j - N >= 0 && j + N < dp[0].length) return 0;
        if(N <= 0) return 0;
        if(dp[i][j][N] > 0) return dp[i][j][N];
        int count = 0;
        for(int[] dir : dirs){
            int x = i + dir[0];
            int y = j + dir[1];
            count += dfs(dp,x,y,N-1) % 1000000007;
            count %= 1000000007;
        }
        dp[i][j][N] = count;
        return count;
    }
}