从零学算法576

576.给你一个大小为 m x n 的网格和一个球。球的起始坐标为 [startRow, startColumn] 。你可以将球移到在四个方向上相邻的单元格内（可以穿过网格边界到达网格之外）。你 最多 可以移动 maxMove 次球。
给你五个整数 m、n、maxMove、startRow 以及 startColumn ，找出并返回可以将球移出边界的路径数量。因为答案可能非常大，返回对 109 + 7 取余 后的结果。
示例 1：
输入：m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
输出：6
示例 2：
输入：m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
输出：12

• 我的超时解法：虽然超时，不过可以参考一下。首先我的第一反应就是 dfs，接下来首先，入参很容易想到的就是 m，n 提供边界，maxMove 告诉你剩余的步数，curX，curY 代表当前坐标；接下来看出口，也就是什么情况有效或无效，出界有效，那么根据当前坐标即可判断是否出界，如果步数都没了还没出界那肯定就是无效了；最后看最小基本单元，因为可以上下左右移动，所以每次累加这四种可能性即可，具体代码如下

•   int mod = 100000007;
    public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
        return dfs(m, n, maxMove, startRow, startColumn) % mod;
    }
    int dfs(int m, int n, int maxMove, int curX, int curY){
    	// 出界
        if(curX < 0 || curX >= m || curY < 0 || curY >= n){
            return 1;
        }
        // 无剩余步数
        if(maxMove < 1){
            return 0;
        }
        // 最小基本单元
        int up = dfs(m, n, maxMove-1, curX-1, curY);
        int left = dfs(m, n, maxMove-1, curX, curY-1);
        int right = dfs(m, n, maxMove-1, curX, curY+1);
        int down = dfs(m, n, maxMove-1, curX+1, curY);
        return up + left + right + down;
    }
  

• 题号：576
• 参考他人解法：首先把 dfs 转换成动态规划，根据 dfs 的变化的参数定义 f[i][j][maxMove] 为在位置 (i,j) 剩余 maxMove 时的出界路径数量，这时需要分析出初始条件，状态转移方程和最小基本单元一样，他的数量等于他的上下左右但步数减少一步的路径数量，也就相当于枚举每个地方往上下左右走后的路径数量后累加。最后就是需要初始变量，不然得话一堆 0 加来加去最后谁都是 0。那么初始变量是什么，就是出界的临界点，就比如 1 x 3 的网格，如果在第一格，只要此时步数大于等于 1 ，都有三种出界的方法，也就是 上左下三种，同理得到所有初始变量即可。但是需要注意的是，由于题目说数量会过大，需要返回对 109 + 7 取余 后的结果，所以其实不能一次性加上下左右的结果，而需要每加一个可能就取余一次。

•  int mod = (int)1e9+7;
   int m, n;
   public int findPaths(int _M, int _N, int maxMove, int startRow, int startColumn) {
       m = _M;
       n = _N;
       int[][][] f = new int[m][n][maxMove+1];
       // 初始赋值
       for(int i=0;i<m;i++){
           for(int j=0;j<n;j++){
               if(i==0)add(i,j,f,maxMove);
               if(i==m-1)add(i,j,f,maxMove);
               if(j==0)add(i,j,f,maxMove);
               if(j==n-1)add(i,j,f,maxMove);
           }
       }
       for(int move = 1;move<=maxMove;move++){
           for(int i=0;i<m;i++){
               for(int j=0;j<n;j++){
               	 // 如果不在网格内了，那就相当于出界了，出界的可能已经在
                   // 最开始初始赋值时计算过了，所以就只取走完一步还在网格
                   // 内的情况
                   if(inArea(i-1,j)){
                       f[i][j][move] +=f[i-1][j][move-1];
                       f[i][j][move] %= mod;
                   }
                   if(inArea(i+1,j)){
                       f[i][j][move] +=f[i+1][j][move-1];
                       f[i][j][move] %= mod;
                   }
                   if(inArea(i,j-1)){
                       f[i][j][move] +=f[i][j-1][move-1];
                       f[i][j][move] %= mod;
                   }
                   if(inArea(i,j+1)){
                       f[i][j][move] +=f[i][j+1][move-1];
                       f[i][j][move] %= mod;
                   }
               }
           }
       }
       return f[startRow][startColumn][maxMove];
   }
   void add(int x,int y,int[][][] f,int maxMove){
       for(int move=1;move<=maxMove;move++){
           f[x][y][move]++;
       }
   }
   // 判断是否在网格内
   boolean inArea(int x,int y){
       return x>=0 && x<m && y>=0 && y<n;
   }
  

• 根据他人的题解，可以优化的还有两个点，第一就是可以改为使用二维数组，把 (i,j) 转为 i*n+j，转回来就是 k 转为 (k/n,k%n)。第二就是上下左右的移动一般会用数组表示。[[-1,0],[1,0],[0,-1],[0,1]] 就代表了上下左右。