每日一题 day 49 (DP topic)

最新推荐文章于 2025-12-14 19:30:20 发布

原创最新推荐文章于 2025-12-14 19:30:20 发布 · 348 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #leetcode #算法

LeetCode Learning 专栏收录该内容

60 篇文章

订阅专栏

本文探讨了在给定网格中机器人避开障碍到达终点的独特路径数量问题，通过四种不同动态规划方法（包括单层循环、合并两层循环、空间优化等）来求解。详细介绍了每种方法的代码实现和适用场景。

文章目录

problem
approach 1 `DP`
approach 2 `DP merge two loop`
approach 3 `others dp`
approach 4 `others dp, less space`

problem

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 space is marked as 1 and 0 respectively in the grid.

Example 1:

在这里插入图片描述

Input: obstacleGrid = [[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

Example 2:

在这里插入图片描述

Input: obstacleGrid = [[0,1],[0,0]]
Output: 1

approach 1 `DP`

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<vector<int>> dp = vector<vector<int>>(m, vector<int>(n, 1));
        if(obstacleGrid[0][0])return 0;//c1
        if(m==n && n==1)return obstacleGrid[0][0]==1 ? 0 : 1;//c2
        bool flag1 = false, flag2 = false;
        for(int i=0; i<m; i++){
            if(flag1) dp[i][0]=0;
            if(obstacleGrid[i][0])
                dp[i][0]=0,flag1=true;
        }
        for(int i=0; i<n; i++){
            if(flag2) dp[0][i]=0;
            if(obstacleGrid[0][i])
                dp[0][i]=0,flag2=true;
        }
        if(min(m, n)==1 && (flag1 || flag2))return 0;//c3
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                if(obstacleGrid[i][j]){
                    dp[i][j]=0;
                    continue;
                }
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

approach 2 `DP merge two loop`

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 1));
        if(obstacleGrid[0][0])return 0;//c1
        bool flag1 = false, flag2 = false;
        
        int cnt=0;
        int lens = min(m, n);
        for(; cnt < lens; cnt++){
            if(flag1)dp[cnt][0]=0;
            if(flag2)dp[0][cnt]=0;
            if(obstacleGrid[cnt][0])
                dp[cnt][0]=0,flag1=true;
            if(obstacleGrid[0][cnt])
                dp[0][cnt]=0,flag2=true;
        }
        for(; cnt < m; cnt++){
            if(flag1) dp[cnt][0]=0;
            if(obstacleGrid[cnt][0])
                dp[cnt][0]=0,flag1=true;
        }
        for(; cnt < n; cnt++){
            if(flag2) dp[0][cnt]=0;
            if(obstacleGrid[0][cnt])
                dp[0][cnt]=0,flag2=true;
        }
        if(min(m, n)==1 && (flag1 || flag2))return 0;//c2
        
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                if(obstacleGrid[i][j]){
                    dp[i][j]=0;
                    continue;
                }
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

approach 3 `others dp`

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
        dp[0][1] = 1;
        for(int i=1; i<=m; i++){
            for(int j=1; j<=n; j++){
                if(!obstacleGrid[i-1][j-1])
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m][n];
    }
};

approach 4 `others dp, less space`

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<int> dp(n, 0);
        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-1];
            }
        }
        return dp[n-1];
    }
};