【代码随想录】刷题Day39

灼榆

已于 2023-06-12 20:28:00 修改

阅读量960

点赞数

文章标签：算法 c++ leetcode 动态规划

于 2023-05-27 11:16:52 首次发布

本文链接：https://blog.csdn.net/m0_63488627/article/details/130897985

版权

刷题专栏收录该内容

47 篇文章 3 订阅

订阅专栏

文章介绍了使用动态规划解决两种路径问题：不同路径问题，考虑了有无障碍物的情况，以及寻找最小路径和的问题。在每种情况下，都通过初始化二维数组并计算当前位置的路径值来找到解决方案。关键在于更新dp数组，考虑当前位置的路径来源于上一个位置或左边位置的路径之和或最小值。

摘要由CSDN通过智能技术生成

1.不同路径

62. 不同路径

1.dp数组为二维数组，首先我们得知道dp[i][j]的含义，由于求的就是不同路径，那么数组对应的就是，从开始到ij位置下拥有的不用路径。

2.由于关系可知，其实当前位置的路径是左边和上面的和，dp的条件就是：dp[i][j]=dp[i-1][j]+dp[i][j-1];

3.初始化时，我们需注意，第一行与第一列都只有一条路能走，那么初始化第一行与第一列都为1

4.最后返回结果在dp[m-1][n-1];

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i<n;i++)
            dp[0][i]=1;
        for(int i=0;i<m;i++)
            dp[i][0]=1;
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

2.不同路径 II

63. 不同路径 II

大致思路其实与上一题基本一致。只不过需要对被阻塞的地方对应的dp数组位置数据进行调整。

1.初始化时，如果遇到阻塞，之后的数据一律为0，因为无法走到了

2.由于关系可知，其实当前位置的路径是左边和上面的和，如果没有阻塞dp的条件就是：dp[i][j]=dp[i-1][j]+dp[i][j-1];如果阻塞了，那么dp[i][j]=0

3.最后返回结果在dp[m-1][n-1];

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        vector<vector<int>> dp(obstacleGrid.size(),vector<int>(obstacleGrid[0].size(),0));
        for(int i=0;i<obstacleGrid.size();i++)
        {
            if(obstacleGrid[i][0]==1)
                break;
            dp[i][0]=1;
        }
        for(int i=0;i<obstacleGrid[0].size();i++)
        {
            if(obstacleGrid[0][i]==1)
                break;
            dp[0][i]=1;
        }
        for(int i=1;i<obstacleGrid.size();i++)
        {
            for(int j=1;j<obstacleGrid[0].size();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.size()-1][obstacleGrid[0].size()-1];
    }
};

3.最小路径和

64. 最小路径和

本题思路其实也和上面差不多

1.dp数组为二维数组，dp数组表示开始到当前位置的最小路径

2.初始化时，第一行与第一列都只有一条路能走，dp当前位置数据为dp上一次位置的数据加上grid数组当前位置的和

3.由于关系可知，其实当前位置的路径最小和是左边和上面之中较小的那一个加上当前位置路径的大小，条件为dp[i][j]=grid[i][j]+min(dp[i-1][j],dp[i][j-1]);

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        vector<vector<int>> dp(grid.size(),vector<int>(grid[0].size(),0));
        dp[0][0]=grid[0][0];
        for(int i=1;i<grid.size();i++)
            dp[i][0]=grid[i][0]+dp[i-1][0];
        for(int i=1;i<grid[0].size();i++)
            dp[0][i]=grid[0][i]+dp[0][i-1];
        for(int i=1;i<grid.size();i++)
        {
            for(int j=1;j<grid[0].size();j++)
                dp[i][j]=grid[i][j]+min(dp[i-1][j],dp[i][j-1]);
        }
        return dp[grid.size()-1][grid[0].size()-1];
    }
};