leetcode -Unique Paths （DP系列）

最新推荐文章于 2020-12-09 08:35:19 发布

暴躁的猴子

最新推荐文章于 2020-12-09 08:35:19 发布

阅读量242

点赞数 1

CC 4.0 BY-SA版权

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/orangefly0214/article/details/88046310

leetcode 专栏收录该内容

85 篇文章

订阅专栏

本文详细解析了LeetCode第62题和第63题，通过动态规划方法求解网格中从起始点到终点的不同路径数量，包括无障碍和有障碍的情况。阐述了状态定义、状态转移方程、初始化和答案获取四个关键步骤，并提供了两种实现方式，一种使用二维数组，另一种进行空间优化，转化为一维动态规划。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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.youkuaiyun.com/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];
    }
}