算法之跳到矩阵右下角位置的路径（不同路径）

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

说明：m 和 n 的值均不超过 100。

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右
   示例 2:

输入: m = 7, n = 3
输出: 28

思路：动态规划 如果要跳到位置（m,n）那么路径等于跳到（m-1,n）,(m,n-1)这两个位置路径的总和 即 f(m,n)=f(m-1,n)+f(m,n-1)

class Solution {
        int res=0;
       public int uniquePaths(int m, int n) {
           int[][]matrix=new int[m+1][n+1];
           matrix[1][1]=1;
           for(int i=1;i<=m;i++) {
               for(int j=1;j<=n;j++){
                   //看一下能不能是上面那个格子下来的
                   if(i-1>=1){
                       matrix[i][j]+=matrix[i-1][j];
                   }
                   //看一下当前位置能不能从左边过来
                   if(j-1>=1){
                       matrix[i][j]+=matrix[i][j-1];
                   }
               }
           }
           res=matrix[m][n];

           return res;
       }

   }

升级版本：如果路上有障碍呢？

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

说明：m 和 n 的值均不超过 100。

示例 1:

输入:
[
[0,0,0],
[0,1,0],
[0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

class Solution {
       public int uniquePathsWithObstacles(int[][] obstacleGrid) {
            if(obstacleGrid.length<=0){
                return 0;
            }
            int m=obstacleGrid.length;
            int n=obstacleGrid[0].length;

         //   System.out.print("m  和 n:  "+m+"  "+n+"\n");

            //只有一行
            if(m==1){
                for(int i=0;i<n;i++){
                    if(obstacleGrid[0][i]==1){
                        return 0;
                    }
                }
                return 1;
            }

            //只有一列
           if(n==1){
               for(int i=0;i<m;i++){
                   if(obstacleGrid[i][0]==1){
                       return 0;
                   }
               }
               return 1;
           }

           if(obstacleGrid[m-1][n-1]==1||obstacleGrid[0][0]==1){
                return 0;
           }




            obstacleGrid[0][0]=1;


           for(int i=0;i<m;i++){
                for (int j=0;j<n;j++){
                    //看一下当前位置能不能到达
                    if(obstacleGrid[i][j]==1){
                        obstacleGrid[i][j]=0;
                        if(i==0&&j==0){
                            obstacleGrid[i][j]=1;
                        }
                    }
                    else {

                        //能不能从上面来
                        if(i-1>=0){

                            obstacleGrid[i][j]+=obstacleGrid[i-1][j];
                     //       System.out.print("here1: "+obstacleGrid[i-1][j]+"\n");
                        }
                        //能不能从左边来
                        if(j-1>=0){
                            obstacleGrid[i][j]+=obstacleGrid[i][j-1];
                      //      System.out.print("here2: "+obstacleGrid[i][j-1]+"\n");
                        }
                    }
                }
           }

        //   System.out.print("  数组"+"\n");
//
//           for(int i=0;i<m;i++){
//               for (int j=0;j<n;j++){
//                   System.out.print(obstacleGrid[i][j]+"  ");
//               }
//               System.out.print("\n");
//
//           }



           int res=obstacleGrid[m-1][n-1];

            return res;


       }
   }