【每日一题】Day0006:CSDN每日一练：不同路径 II

12月17日19点44分更新：

关于这题，昨晚睡前想到题主的思路代码上可以用递归实现；今早敲了现在补充一下。

    // 递归实现求总路径数，因为放在一个.java文件里了，为了区分方法名最后加了个1
    public static int uniquePathsWithObstacles1(int[][] obstacleGrid, int obstacleGridRowSize, int obstacleGridColSize){
        // 如果当前格值为0，那么到达该格的路径数分几种可能性
        if(obstacleGrid[obstacleGridRowSize-1][obstacleGridColSize-1] == 0) {
            // 如果当前格是起点（即左上角那格），返回1：含义为递归的结束，同时到达该格有1条路径
            if(obstacleGridRowSize == 1 && obstacleGridColSize == 1){
                return 1;
                // 如果是最上面一行，到达当前格的总路径数为其左面一格路径数
            }else if(obstacleGridRowSize == 1){
                return uniquePathsWithObstacles1(obstacleGrid,1,obstacleGridColSize-1);
                // 同理，如果是最左面一列，到达当前格的总路径数为其上面一格路径书
            }else if(obstacleGridColSize == 1){
                return uniquePathsWithObstacles1(obstacleGrid, obstacleGridRowSize - 1, 1);
            }else{
                // 其余情况为一般情况，到达该格的总路径数为该格上方一格和方面一格路径数之和
                return uniquePathsWithObstacles1(obstacleGrid,obstacleGridRowSize,obstacleGridColSize-1)+
                        uniquePathsWithObstacles1(obstacleGrid, obstacleGridRowSize - 1, obstacleGridColSize);
            }
        }else{ // 如果是障碍格那么到达路径为0
            return 0;
        }
    }

变量名和方法名太长了，不然递归做起来的代码量看起来要少一些。 

---

先放链接：

每日一练-做题每日一练-做题https://dailycode.csdn.net/practice/1779831昨天发现CSDN上也有每日一练，感觉难度相对力扣简单一些，可能更适合自己现在的状态，颇感兴趣就尝试了一下。今天C/C++这道不同路径II很有意思，做完之后用Java实现并加上注释做为自己的理解和巩固。

代码如下：

package cn.daycode.csdncode;

public class UniquePathsWithObstacles {
    public static void main(String[] args) {
        int[][] grids = {{0,0,0,0,0},{0,1,1,0,0},{0,1,0,0,0},{0,1,0,0,0},{0,0,0,0,0}};
        int row_size = grids.length;
        int col_size = grids[0].length;

        System.out.println(uniquePathsWithObstacles(grids,row_size,col_size));

    }

    public static int uniquePathsWithObstacles(int[][] obstacleGrid, int obstacleGridRowSize, int obstacleGridColSize){
        int row, col;
        int reset = 0;
        /*
        * 从第二列第二行开始，走到某格的路径数为该格上一格和左一格路径之和，以此为基础计算总路径
        * 所以要想办法分别计算出每个非障碍物格的路径求和
        * 根据只能往右走或往下走，如果第0列的某行值为1，则下面的所有值为1（障碍物）
        * 同理第0行某列为1开始，往右都赋为1
        * 将当前得到的数组全部对1异或，得到新的数组为原数组0和1对调
        * 当前的第0行和第0列都是路径数量，我们只需要从第二行第二列开始分别计算
        * 走到某格的路径数为该格上一格和左一格路径之和，最后右下角格值就是结果
        * */
        //根据只能往右走或往下走，如果第0列的某行值为1，则下面的所有值为1（障碍物）
        for (row = 0; row < obstacleGridRowSize; row++){ 
            if (reset == 1){
                obstacleGrid[row][0] = 1;
            }else{
                if (obstacleGrid[row][0] == 1) {
                    reset = 1;
                }
            }
        }
        reset = 0;
        //同理，第0行的某列为1开始，其他列都改为1
        for (col = 0; col < obstacleGridColSize; col++) { 
            if (reset == 1) {
                obstacleGrid[0][col] = 1;
            }else{
                if (obstacleGrid[0][col] == 1) {
                    reset = 1;
                }
            }
        }
        // 将修改后的数组，每一格的1改为0，0改为1，用于计算总路径
        for (row = 0; row < obstacleGridRowSize; row++) { 
            int[] line = obstacleGrid[row];
            for (col = 0; col < obstacleGridColSize; col++) {
                line[col] ^= 1;
            }
        }
        // 将每一格的值改为其左面一格和上面一格之和（从第二列第二行开始）
        for (row = 1; row < obstacleGridRowSize; row++) { 
            int[] last_line = obstacleGrid[row - 1];
            int[] line = obstacleGrid[row];
            for (col = 1; col < obstacleGridColSize; col++) {
                if(line[col] != 0) {
                    line[col] = line[col - 1] + last_line[col];
                }
            }
        }
        // 返回最右下角格最终的值就是最大路径数
        return obstacleGrid[obstacleGridRowSize - 1][obstacleGridColSize - 1];
    }
}