LeetCode 64/62/63. Minimum Path Sum/ Unique Paths i, ii

原创 2016年04月25日 11:01:33

1. 题目描述

1.1 62

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?

1.2 63

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.3 64

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.

2. 解题思路

这三道题目都是典型的dp 问题, 类型相似, 写出来的代码也基本相同

3. code

3.1 62

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

3.2 63

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& grid) {
        if (grid.size() == 0) return 0;
        vector<int> arr(grid[0].size(), 0);
        for (int i = 0; i != grid.size(); i++){
            for (int j = 0; j != grid[0].size(); j++){
                if (i == 0 && j == 0)
                    arr[j] = (grid[i][j] == 0);
                else if (i == 0)
                    arr[j] =  grid[i][j] ? 0 : arr[j - 1];
                else if (j == 0)
                    arr[j] =  grid[i][j] ? 0 : arr[j];
                else
                    arr[j] =  grid[i][j] ? 0 : (arr[j] + arr[j - 1]);
            }
        }
        return arr[grid[0].size() - 1];
    }
};

3.3 64

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

4. 大神解法

4.1 62

/*
This is a fundamental DP problem. First of all, let's make some observations.

Since the robot can only move right and down, when it arrives at a point, there are only two possibilities:

It arrives at that point from above (moving down to that point);
It arrives at that point from left (moving right to that point).
Thus, we have the following state equations: suppose the number of paths to arrive at a point (i, j) is denoted as P[i][j], it is easily concluded that P[i][j] = P[i - 1][j] + P[i][j - 1].

The boundary conditions of the above equation occur at the leftmost column (P[i][j - 1] does not exist) and the uppermost row (P[i - 1][j] does not exist). These conditions can be handled by initialization (pre-processing) --- initialize P[0][j] = 1, P[i][0] = 1 for all valid i, j. Note the initial value is 1 instead of 0!

Now we can write down the following (unoptimized) code.
*/
class Solution {
    int uniquePaths(int m, int n) {
        vector<vector<int> > path(m, vector<int> (n, 1));
        for (int i = 1; i < m; i++)
            for (int j = 1; j < n; j++)
                path[i][j] = path[i - 1][j] + path[i][j - 1];
        return path[m - 1][n - 1];
    }
};
/*
As can be seen, the above solution runs in O(n^2) time and costs O(m*n) space. However, you may have observed that each time when we update path[i][j], we only need path[i - 1][j] (at the same column) and path[i][j - 1] (at the left column). So it is enough to maintain two columns (the current column and the left column) instead of maintaining the full m*n matrix. Now the code can be optimized to have O(min(m, n)) space complexity.
*/
class Solution {
    int uniquePaths(int m, int n) {
        if (m > n) return uniquePaths(n, m); 
        vector<int> pre(m, 1);
        vector<int> cur(m, 1);
        for (int j = 1; j < n; j++) {
            for (int i = 1; i < m; i++)
                cur[i] = cur[i - 1] + pre[i];
            swap(pre, cur);
        }
        return pre[m - 1];
    }
};
/*
Further inspecting the above code, we find that keeping two columns is used to recover pre[i], which is just cur[i] before its update. So there is even no need to use two vectors and one is just enough. Now the space is further saved and the code also gets much shorter.
*/
class Solution {
    int uniquePaths(int m, int n) {
        if (m > n) return uniquePaths(n, m);
        vector<int> cur(m, 1);
        for (int j = 1; j < n; j++)
            for (int i = 1; i < m; i++)
                cur[i] += cur[i - 1]; 
        return cur[m - 1];
    }
}; 
/*
Well, till now, I guess you may even want to optimize it to O(1) space complexity since the above code seems to rely on only cur[i] and cur[i - 1]. You may think that 2 variables is enough? Well, it is not. Since the whole cur needs to be updated for n - 1 times, it means that all of its values need to be saved for next update and so two variables is not enough.
*/
版权声明:本文为博主原创文章,未经博主允许不得转载。

【LeetCode-面试算法经典-Java实现】【113-Path Sum II(路径和)】

【113-Path Sum II(路径和II)】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题  Given a binary tree and a sum, find al...
  • DERRANTCM
  • DERRANTCM
  • 2015年08月12日 06:23
  • 2526

【LeetCode-面试算法经典-Java实现】【064-Minimum Path Sum(最小路径和)】

【064-Minimum Path Sum(最小路径和)】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题  Given a m x n grid filled with no...
  • DERRANTCM
  • DERRANTCM
  • 2015年08月02日 06:05
  • 2303

LeetCode -- Triangle 路径求最小和( 动态规划问题)

LeetCode Problem-- Triangle 路径求最小和 动态规划问题
  • mason_mow
  • mason_mow
  • 2014年05月25日 18:10
  • 1745

【LeetCode-面试算法经典-Java实现】【120-Triangle(三角形)】

【120-Triangle(三角形)】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题  Given a triangle, find the minimum path sum...
  • DERRANTCM
  • DERRANTCM
  • 2015年08月14日 06:13
  • 2381

算法课第12周第2题——63. Unique Paths II

题目描述: Follow up for "Unique Paths": Now consider if some obstacles are added to the grids. H...
  • bwstardust
  • bwstardust
  • 2017年05月14日 22:03
  • 46

[LeetCode]62 不同的路径总数

Unique Paths(不同的路径总数)【难度:Medium】 A robot is located at the top-left corner of a m x n grid (marked ...
  • qq_14821023
  • qq_14821023
  • 2016年02月28日 13:31
  • 673

leetcode Path Sum II 关于树的后序遍历

我们利用辅助栈来进行树的houxi
  • u012724887
  • u012724887
  • 2014年09月29日 15:12
  • 255

【动态规划】minimum-path-sum

题目描述: Given a m x n grid filled with non-negative numbers, find a path from top left to bottom righ...
  • u012351768
  • u012351768
  • 2016年05月30日 19:28
  • 334

[LeetCode 62] Unique Paths(教科书般的动态规划)

题目内容62 Unique PathsA robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the ...
  • yangjin95
  • yangjin95
  • 2016年11月25日 00:01
  • 102

【LeetCode】3Sum 解题报告

这道题凭我现有知识实在解答不上来,只好网上搜索解法,才发现 K Sum 是一类问题,但是网上没有比较简洁的代码,我想对于初学者来说,可能还是想先看看这道题怎么解,然后才有兴趣去看其扩展吧。 【题目】 ...
  • ljiabin
  • ljiabin
  • 2014年10月30日 16:00
  • 28128
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:LeetCode 64/62/63. Minimum Path Sum/ Unique Paths i, ii
举报原因:
原因补充:

(最多只允许输入30个字)