剑指 Offer 47. 礼物的最大价值

一、题目

题目链接：力扣

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

示例 1:

输入: 
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 12
解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

提示：

0 < grid.length <= 200
0 < grid[0].length <= 200

---

二、题解

1、思路

🐙 动态规划

看到最大价值，就应该想到动态规划。

动态规划四大步骤：

穷举分析

[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]

无需全部穷举，我们只是为了找规律

[1]，最大价值礼物1；1

[1,3]，最大价值礼物4；1→3 

[1,3]
[1,5]，最大价值礼物9；1→3→5

[1,3]
[1,5]
[4,2]，最大价值礼物11；1→3→5→2

[1,3,1]
[1,5,1]
[4,2,1]，最大价值礼物12；1→3→5→2→1

分析找规律，拆分子问题

我们看出某单元格只可能从上边单元格或左边单元格到达，边上的只能从上方或只能从左侧到达。

最简单的边界情况

左上角元素，直接返回grid[0][0]，也就是下面的dp(0,0)=grid[0][0]。

状态转移方程

设 dp(i,j) 为从棋盘左上角走至单元格 (i,j) 的礼物最大累计价值，那么有：

当 i=0 且 j=0 时，为起始元素；dp(i,j) = g(i, j)；
当 i=0 且 j≠0 时，为矩阵第一行元素，只可从左边到达；dp(i,j) = dp(i, j-1) + grid(i, j)；
当 i≠0 且 j=0 时，为矩阵第一列元素，只可从上边到达；dp(i,j) = dp(i-1, j) + grid(i, j)；
当 i≠0 且 j≠0 时，可从左边或上边到达；dp(i,j) = max( dp(i-1, j), dp(i, j-1) ) + grid(i, j)。

注：感觉力扣对于动态规划思路不错，可借鉴。

2、代码实现

🐙 动态规划

当 i=0 且 j=0 时，为起始元素；dp(i,j) = g(i, j)；
当 i=0 且 j≠0 时，为矩阵第一行元素，只可从左边到达；dp(i,j) = dp(i, j-1) + grid(i, j)；
当 i≠0 且 j=0 时，为矩阵第一列元素，只可从上边到达；dp(i,j) = dp(i-1, j) + grid(i, j)；
当 i≠0 且 j≠0 时，可从左边或上边到达；dp(i,j) = max( dp(i-1, j), dp(i, j-1) ) + grid(i, j)。

上方，最后一条计算需要使用前面三条，注意，下标都是从1开始，因为等号右侧全部存在-1。 

图中圈是代码中上面两个for循环计算的，两个箭头是第三个for循环计算的顺序，由于只能从左侧或者上方进入，因此，这个计算顺序刚刚好，最终目的就是计算右下角的dp值。

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {
        // 0 < grid.length <= 200 无需判断等于0的情况
        int m = grid.size();
        int n = grid[0].size();

        vector<vector<int>> dp(m, vector<int>(n, 0));
        dp[0][0] = grid[0][0];

        // 左侧边界
        // 注意下标从1开始
        for(int i = 1; i < m; i++)
        {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        
        // 上方边界
        for(int j = 1; j < n; j++)
        {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }

        // 动态规划
        // 利用已经计算出来的左侧边界和上方边界，计算中间
        // 如示例代码，从5开始计算（根据上方dp和左侧dp大小）
        for(int i = 1; i < m; i++)
        {
            for(int j = 1; j < n; j++)
            {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
};

3、复杂度分析

🐙 动态规划

时间复杂度：O(mn)；

空间复杂度：O(1)。

4、运行结果

🐙 动态规划