<LeetCode OJ> 64. Minimum Path Sum

最新推荐文章于 2020-08-13 09:27:45 发布

原创最新推荐文章于 2020-08-13 09:27:45 发布 · 3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #算法 #面试 #动态规划 #C++

LeetCode解题报告专栏收录该内容

144 篇文章

订阅专栏

本文解析LeetCode上的三个动态规划题目：Minimum Path Sum、Unique Paths及Unique Paths II，提供详细的解题思路与代码实现。

64. Minimum Path Sum

Total Accepted: 62294 Total Submissions: 183284 Difficulty: Medium

Given a m x n grid filled with non-negative numbers,

find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

分析：

很显然的动态规划问题。

定义子问题：令从原点（1，1）到目的点（m,n）的最小路劲和为result[m,n]
任何一个点的路劲和都是来自二维数组上一行的最小路劲和或者来自右一列的最小路劲和与当前位置的值相加的结果显然result[m,n]=min(result[m-1,n]+grid[m,n],result[m,n-1]+grid[m,n])
注意初始化问题

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int row=grid.size();//行
        int col=grid[0].size();
        vector< vector<int> >  result(row);     
        for(int i=0;i <row ;i++)     
            result[i].resize(col,0);//设置数组的大小row行，col列 
        result[0][0]=grid[0][0];//初始化    
        for(int i=1;i<col;i++)//初始化第一行
            result[0][i]=result[0][i-1]+grid[0][i];
        for(int i=1;i<row;i++)//初始化第一列
            result[i][0]=result[i-1][0]+grid[i][0];
        for(int i=1;i<row;i++)//计算中间结果
            for(int j=1;j<col;j++)
                result[i][j]=min(result[i][j-1]+grid[i][j],result[i-1][j]+grid[i][j]);
        return result[row-1][col-1];
    }
};

联动另外两个问题：

62. Unique Paths

Total Accepted: 75227 Total Submissions: 214539 Difficulty: Medium

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 3 x 7 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

分析：

定义子问题：令从原点（1，1）到目的点（m,n）的最大走法数为dp[m,n]
任何一个点都是从上面走下来和从右边走过来两种可能的和
显然dp[m,n]=dp[m-1,n]+dp[m,n-1]
最简单的动态规划问题...........

时间复杂度O(M*N)，空间复杂度O(M*N)

class Solution {    
public:    
    int uniquePaths(int m, int n) {    
        vector< vector<int> >  result(m+1);     
        for(int i=0;i <=m ;i++)     
                result[i].resize(n+1);//设置数组的大小m+1行，n+1列     
        for(int i=1;i<=n;i++)    
            result[1][i]=1;    
        for(int i=1;i<=m;i++)    
            result[i][1]=1;    
        for(int i=2;i<=m;i++)    
            for(int j=2;j<=n;j++)    
                result[i][j]=result[i-1][j]+result[i][j-1];    
        return result[m][n];    
    }    
};

63. Unique Paths II

Total Accepted: 55136 Total Submissions: 191949 Difficulty: Medium

Follow up for "Unique Paths":紧接着上一题“唯一路劲”，现在考虑有一些障碍在网格中，无法到达，请重新计算到达目的地的路线数目

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.

For example,

There is one obstacle in the middle of a 3x3 grid as illustrated below.

[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]

The total number of unique paths is 2.

Note: m and n will be at most 100.

分析：

此题与原问题相较，变得是什么？
1，此障碍物下面和右边将不在获得来自于此的数量,也可以理解为贡献为0
2，有障碍的地方也将无法到达（这一条开始时没想到，总感觉leetcode题目意思不愿意说得直接明了），也就是说此点的可到达路劲数直接为0

class Solution {  
public:  
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {  
        int m=obstacleGrid.size();  
        int n=obstacleGrid[0].size();  
        vector< vector<int> >  result(m+1);     
        for(int i=0;i <=m ;i++)     
            result[i].resize(n+1);//设置数组的大小m+1行，n+1列     
        //初始化一定要正确，否则错无赦      
        result[1][1]= obstacleGrid[0][0]==1? 0:1;      
        for(int i=2;i<=n;i++)    
            result[1][i]=obstacleGrid[0][i-1]==1?0:result[1][i-1];//由上一次来推到    
        for(int i=2;i<=m;i++)    
            result[i][1]=obstacleGrid[i-1][0]==1?0:result[i-1][1];    
              
        for(int i=2;i<=m;i++)    
            for(int j=2;j<=n;j++)    
                result[i][j]=obstacleGrid[i-1][j-1]==1?0:result[i-1][j]+result[i][j-1];  //一旦当前有石头就无法到达，直接置零  
              
        return result[m][n];  
    }  
};

注：本博文为EbowTang原创，后续可能继续更新本文。如果转载，请务必复制本条信息！

原文地址：http://blog.youkuaiyun.com/ebowtang/article/details/50640213

原作者博客：http://blog.youkuaiyun.com/ebowtang

本博客LeetCode题解索引：http://blog.youkuaiyun.com/ebowtang/article/details/50668895