63.UniquePaths II---dp

题目链接

题目大意：与62题类似，只是这个题中间有障碍。

法一：dfs，依旧超时。代码如下：

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        boolean vis[][] = new boolean[obstacleGrid.length][obstacleGrid[0].length];
        int f[][] = {{1, 0}, {0, 1}};
        //如果起始格子就是障碍，则表示不能正常到达目的地
        if(obstacleGrid[0][0] == 1) {
            return 0;
        }
        return dfs(obstacleGrid, 0, 0, 0, f, vis);
    }
    public static int dfs(int[][] obstacleGrid, int x, int y, int cnt, int f[][], boolean vis[][]) {
        if(x == obstacleGrid.length - 1 && y == obstacleGrid[0].length - 1 && obstacleGrid[x][y] == 0) {
            cnt++;
            return cnt;
        }
        for(int i = 0; i < 2; i++) {
            int cnt_x = x + f[i][0];
            int cnt_y = y + f[i][1];
            if(cnt_x < obstacleGrid.length && cnt_y < obstacleGrid[0].length && vis[cnt_x][cnt_y] == false && obstacleGrid[cnt_x][cnt_y] == 0) {
                vis[cnt_x][cnt_y] = true;
                cnt = dfs(obstacleGrid, cnt_x, cnt_y, cnt, f, vis);
                vis[cnt_x][cnt_y] = false;
            } 
        }
        return cnt;
    }

法二：dp，模仿62题的dp，只是这里要考虑障碍。代码如下（耗时2ms）：

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //如果起始位置或结束位置是1，则直接不通
        if(obstacleGrid[0][0] == 1 || obstacleGrid[obstacleGrid.length - 1][obstacleGrid[0].length - 1] == 1) {
            return 0;
        }
        int dp[][] = new int[obstacleGrid.length][obstacleGrid[0].length];
        //初始化第一列
        for(int i = 0; i < obstacleGrid.length; i++) {
            if(obstacleGrid[i][0] == 0) {
                dp[i][0] = 1;
            }
            else {//第一列，一旦碰到一个障碍1，则第一列障碍下面的所有都是障碍，不通
                for(; i < obstacleGrid.length; i++) {
                    dp[i][0] = 0;
                }
                break;
            }
        }
        //初始化第一行
        for(int i = 0; i < obstacleGrid[0].length; i++) {
            if(obstacleGrid[0][i] == 0) {
                dp[0][i] = 1;
            }
            else {//第一行，一旦碰到一个障碍1，则第一行障碍后面的所有都是障碍，不通
                for(; i < obstacleGrid[0].length; i++) {
                    dp[0][i] = 0;
                }
                break;
            }
        }
        //计算dp
        for(int i = 1; i < obstacleGrid.length; i++) {
            for(int j = 1; j < obstacleGrid[0].length; j++) {
                if(obstacleGrid[i][j] == 1) {//如果当前格是障碍，则不可通
                    dp[i][j] = 0;
                }
                else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[obstacleGrid.length - 1][obstacleGrid[0].length - 1];
    }

 法三：一维dp，与62题很类似，但是要比62题难思考一点，因为要考虑障碍的问题，而且没有初始化，直接从0开始遍历的。代码如下（耗时1ms）：

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if(obstacleGrid[0][0] == 1 || obstacleGrid[obstacleGrid.length - 1][obstacleGrid[0].length - 1] == 1) {
            return 0;
        }
        int[] dp = new int[obstacleGrid[0].length];
        dp[0] = 1;
        //从0开始遍历，否则会漏掉第一列，因为其实第一列并没有初始化
        for(int i = 0; i < obstacleGrid.length; i++) {
            for(int j = 0; j < obstacleGrid[0].length; j++) {
                //遇到障碍则赋0
                if(obstacleGrid[i][j] == 1) {
                    dp[j] = 0;
                }
                //由于j是从0开始，所以只考虑>0的情况
                else if(j > 0){
                    dp[j] += dp[j - 1];
                }
            }
        }
        return dp[obstacleGrid[0].length - 1];
    }