每日一题 day 49 (DP topic)

最新推荐文章于 2024-11-04 12:20:00 发布

NP_hard

最新推荐文章于 2024-11-04 12:20:00 发布

阅读量284

点赞数

分类专栏： LeetCode Learning 文章标签：动态规划 leetcode 算法

本文链接：https://blog.csdn.net/np_hard/article/details/123443383

版权

LeetCode Learning 专栏收录该内容

60 篇文章 0 订阅

订阅专栏

文章目录

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];
    }
};