Java aplicación LeetCode 576 de número límites ruta (DFS || DP)

576. El número de rutas fuera de los límites

Para una malla dada y una bola de m × n. Las coordenadas iniciales de la pelota es (i, j), se puede mover a la bola de células adyacentes, o hacia arriba, moviendo el balón a través del límite de malla a la izquierda, y las direcciones bajo, la derecha. Sin embargo, puede mover hasta N veces. Averiguar el número de carriles se puede mover fuera de los límites de la pelota. La respuesta puede ser muy grande, el valor de retorno es el resultado mod 109 + 7.

Ejemplo 1:

Entrada: m = 2, n = 2 , N = 2, i = 0, j = 0
de la salida: 6
Explicación:

Ejemplo 2:

Entrada: m = 1, n = 3 , N = 3, i = 0, j = 1
de la salida: 12
Explicación:

Descripción:

Una vez que la bola fuera de límites, que no se puede mover de nuevo en la red.
La gama de la longitud y la altura de la rejilla [1,50] de.
N en el intervalo [0,50] de.
PD:
La pequeña serie tradicional de DFS
jefes hizo programación dinámica

class Solution {
    private Integer[][][] cache;
    
    public int findPaths(int m, int n, int N, int i, int j) {
        cache = new Integer[m][n][N+1];
        return dfs(m,n,N,j,i);
    }
    
    private int dfs(int rows,int cols,int times,int x,int y) { 
        if (isOutOfBoundary(x,y,rows,cols)) {
            return 1;
        }
        if (0 == times) {
            return 0;
        } 
        if (null != cache[y][x][times]) {
            return cache[y][x][times];
        }
        int res = (((dfs(rows,cols,times-1,x+1,y) + dfs(rows,cols,times-1,x-1,y)) % 1000000007) + ((dfs(rows,cols,times-1,x,y+1) + dfs(rows,cols,times-1,x,y-1)) % 1000000007)) % 1000000007;
        cache[y][x][times] = res;
        return res;
    }
    
    private boolean isOutOfBoundary(int x,int y,int rows,int cols) {
        return x < 0 || x >= cols || y < 0 || y >= rows;
    }
}

class Solution {
    public int findPaths(int m, int n, int N, int i, int j) {
 if(N <= 0) return 0;
        int mod = 1000000007;
        int ret = 0;
        int[][] dp = new int[m][n]; // 保存第k步的结果
        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        
        for(int k = 1; k <= N; ++k) {
            int[][] temp = new int[m][n]; // 保存第k-1步的结果
            for(int x = 0; x < m; ++x) {
                for(int y = 0; y < n; ++y) {
                    for(int[] dir : dirs) {
                        int nx = x + dir[0];
                        int ny = y + dir[1];
                        if(nx < 0 || nx >= m || ny < 0 || ny >= n)
                            temp[x][y] += 1;
                        else
                            temp[x][y] = (dp[nx][ny] + temp[x][y]) % mod;
                    }
                }
            }
            dp = temp;
        }
        
        return dp[i][j];
    }
}