Leetcode63. 不同路径 II -代码随想录

meeiuliuus

已于 2024-06-19 22:05:54 修改

阅读量369

点赞数 6

分类专栏： # leetcode ---medium 文章标签：算法 leetcode 动态规划

于 2024-02-20 11:05:12 首次发布

本文链接：https://blog.csdn.net/qq_52313711/article/details/136185612

版权

leetcode ---medium 专栏收录该内容

172 篇文章 0 订阅

订阅专栏

文章介绍了如何通过类Solution中的方法，利用动态规划算法计算给定二维障碍网格中从左上角到右下角的唯一无阻碍路径数量。初始化时处理边界情况，遇到障碍则路径数为0，否则递推更新路径计数。

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

题目：

代码（首刷自解 2024年2月20日）：

初始化时注意若有阻碍，则后面都为0

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        /*dp数组表示路径条数*/
        vector<vector<int>> dp(m, vector<int>(n, 0));
        /*初始化*/
        for (int i = 0; i < m && obstacleGrid[i][0] != 1; ++i) dp[i][0] = 1;
        for (int i = 0; i < n && obstacleGrid[0][i] != 1; ++i) dp[0][i] = 1;

        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                if (obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                    cout<<"!dp["<<i<<"]["<<j<<"] = "<<dp[i][j]<<"   ";
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];//递推公式
                    cout<<"dp["<<i<<"]["<<j<<"] = "<<dp[i][j]<<"   ";
                }
            }
            cout<<endl;
        }
        return dp[m - 1][n - 1];
    }
};

代码（二刷自解2024年6月19日 bugfree go）

func uniquePathsWithObstacles(obstacleGrid [][]int) int {
    // dp[i][j] 表示到第i行第j列有多少种方法,如果obstacleGrid[i][j] = 1,则对应的dp[i][j] = 0
    m, n := len(obstacleGrid), len(obstacleGrid[0])
    dp := make([][]int, m)
    for i := range dp {
        dp[i]  = make([]int, n)
    }
    for i := 0; i < m && obstacleGrid[i][0] != 1; i++ {
        dp[i][0] = 1
    }
    for j := 0; j < n && obstacleGrid[0][j] != 1; j++ {
        dp[0][j] = 1
    }
    for i := 1; i < m; i++ {
        for j := 1; j < n; j++{
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
            if obstacleGrid[i][j] == 1 {
                dp[i][j] = 0
            }
        }
    }
    return dp[m - 1][n - 1]
}