leetcode -Unique Paths （DP系列）

leetcode 62. Unique Paths

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

Above is a 7 x 3 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

Example 1:

Input: m = 3, n = 2
Output: 3
Explanation:
From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
1. Right -> Right -> Down
2. Right -> Down -> Right
3. Down -> Right -> Right

Example 2:

Input: m = 7, n = 3
Output: 28

参考博客：

https://blog.csdn.net/u014627099/article/details/79759025

解题思路：

确定DP的四要素：

1.state：f[x][y]表示从起点到(x,y）的路径数。

2.function：（研究倒数第一步）f[x][y]=f[x-1][y]+f[x][y-1]

3.初始化：第一行和第一列   f[i][0]=1  f[0][i]=1

4.answer:f[n-1][m-1]

实现：

class Solution {
    public int uniquePaths(int m, int n) {
        //起点到(m,n)的路径=起点到(m,n-1)+起点到(m-1,n)的路径
        int[][] total=new int[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(i==0||j==0){
                    total[i][j]=1;
                }else{
                    total[i][j]=total[i-1][j]+total[i][j-1];
                }
            }
        }
        return total[m-1][n-1];
        
    }
}

leetcode 63. Unique Paths II

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

Note: m and n will be at most 100.

Example 1:

Input:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
Output: 2
Explanation:
There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right

解题思路：

确定DP的四要素：

1.state：f[x][y]表示从起点到(x,y）的路径数。

2.function：（研究倒数第一步）f[x][y]=f[x-1][y]+f[x][y-1]，但是需要加判断条件，如果obstacleGrid[x][y]=0,即某个格子被挡住了，则起点到这个格子的路径数f[x][y]=0;

3.初始化：第一行和第一列   f[i][0]=1  f[0][i]=1

（1）初始化也需要加判断条件，如果obstacleGrid[x][y]=0,即某个格子被挡住了，则起点到这个格子的路径数f[x][y]=0，因为初始化的是第一行和第一列，所以一旦该行或者列前面有一个格子被挡住，则后面的格子的路径数都是0。

（2）我们需要设置一个flag标志来确定第一行或第一列前面是否已经出现了障碍，如果出现，则后面的路径数都是0；

（3）如果格子的最开始0,0位置就已经有障碍了，则整个大方格的所有小格子路径数也都为0；

4.answer:f[n-1][m-1]

实现1：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m=obstacleGrid.length;
        int n=obstacleGrid[0].length;
        int[][] ret=new int[m][n];
        boolean flag=false;
        for(int i=0;i<m;i++){
            if(obstacleGrid[i][0]==1||flag){
                ret[i][0]=0;
                flag=true;
            }else{
                ret[i][0]=1;
            }
        }
        flag=false;
        if(ret[0][0]==0){
            flag=true;
        }
        for(int j=1;j<n;j++){
            if(obstacleGrid[0][j]==1||flag){
                ret[0][j]=0;
                flag=true;
            }else{
                ret[0][j]=1;
            }  
        }
        
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++)
                if(obstacleGrid[i][j]==1){
                     ret[i][j]=0;
                }else{
                    ret[i][j]=ret[i-1][j]+ret[i][j-1];
                }    
        }
        return ret[m-1][n-1];
    }
}

 

空间优化：转为一维dp

实现2：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //转为一维dp问题
        int m=obstacleGrid.length;
        int n=obstacleGrid[0].length;
        int[] dp=new int[n];
        dp[0]=1;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++ ){
                if(obstacleGrid[i][j]==1){
                    dp[j]=0;
                }else if(j>0){
                    dp[j]=dp[j]+dp[j-1];
                }
            }
        }
        return dp[n-1];
    }
}