【剑指Offer】个人学习笔记_47_礼物的最大价值

刷题日期：下午8:10 2021年5月11日星期二

个人刷题记录，代码收集，来源皆为leetcode

经过多方讨论和请教，现在打算往Java方向发力

主要答题语言为Java

题目：

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

难度中等136

在一个 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

题目分析

根据提示，格子最大为200 * 200，也不能算作是路径最大问题。

这种题型就能算作是动态规划了吧，每一步都要考虑下一步选哪里才能最大，从左上到右下。

可以用循环或者递归来解。

初始解答：

先尝试用循环：

class Solution {
    public int maxValue(int[][] grid) {
        int x = 0, y = 0, res = 0;//行，列，结果，初始位置不确定是不是这里
        while(x != grid.length - 1 || y != grid[0].length - 1) {
            res += grid[x][y]; //获得礼物
            //到边缘的情况
            if(x == grid.length - 1){
                y++;
                break;
            }
            if(y == grid[0].length - 1){
                x++;
                break;
            }
            //在循环内说明还没到右下角
            if(grid[x + 1][y] >= grid[x][y + 1]) x++;
            else y++;
        }
        res += grid[x][y]; //右下角
        return res;
    }
}

能跑的通示例但是，执行结果：解答错误

显示详情 添加备注

输入：[[1,2,5],[3,2,1]]

输出：6

预期结果：9

还是有问题的，不纠结了，思路应该是没问题的，学习他人

看评论区说递归会超时

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length, n = grid[0].length; //获得矩阵长宽
        int[] dp = new int[n + 1]; //定义数组，为啥是n+1
        for(int i = 1; i <= m; i++) {
            for(int j = 1; j <= n; j++) {
                //两层遍历，在每一层里都更新了dp
                dp[j] = Math.max(dp[j], dp[j - 1]) + grid[i - 1][j - 1];
            }
        }
        return dp[n];
    }
}

这个其实没太看懂，只知道一直在更新dp，每一层都算一遍。

执行结果：通过

显示详情 添加备注

执行用时：2 ms, 在所有 Java 提交中击败了98.61%的用户

内存消耗：41 MB, 在所有 Java 提交中击败了87.03%的用户

学习K神的解法

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length, n = grid[0].length; //长宽
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                //两层遍历
                if(i == 0 && j == 0) continue; //起点
                if(i == 0) grid[i][j] += grid[i][j - 1]; //顶
                else if(j == 0) grid[i][j] += grid[i - 1][j];//左
                else grid[i][j] += Math.max(grid[i][j - 1], grid[i - 1][j]); //判断
            }
        }
        return grid[m - 1][n - 1];
    }
}

可以说是相当直观了，怪不得能算简单题，能想到代码的思路基本就能写出来，好好学习

执行结果：通过

显示详情 添加备注

执行用时：3 ms, 在所有 Java 提交中击败了83.97%的用户

内存消耗：41.3 MB, 在所有 Java 提交中击败了28.62%的用户

事先处理边缘的代码，更直观简洁

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length, n = grid[0].length; //长宽
        for(int j = 1; j < n; j++) {
            grid[0][j] += grid[0][j - 1];//相当于把一整行都挨个加上去了
        }
        for(int i = 1; i < m; i++) {
            grid[i][0] += grid[i - 1][0];//相当于把一整列都挨个加上去了
        }
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                grid[i][j] += Math.max(grid[i - 1][j], grid[i][j - 1]);
            }
        }
        //原来Java也可以不用括号靠缩减来写循环和判断啊
        return grid[m - 1][n - 1];
    }
}

执行结果：通过

显示详情 添加备注

执行用时：3 ms, 在所有 Java 提交中击败了83.97%的用户

内存消耗：40.7 MB, 在所有 Java 提交中击败了98.79%的用户

学习他人：

方法一:

mata川L5 （编辑过）2020-03-08 来字节和孙哥做兄弟，最基础的dp题，转移方程：

f(i, j) = max{f(i - 1, j), f(i, j - 1)} + grid[i][j]

然后可以用滚动数组的技巧把空间复杂度优化成O(N)

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        int[] dp = new int[n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                dp[j] = Math.max(dp[j], dp[j - 1]) + grid[i - 1][j - 1];
            } 
        }

        return dp[n];
    }
}

方法二：

爱吃喵酱的花椒L1 2021-02-19 简单题我重拳出击

class Solution {
    public int maxValue(int[][] grid) {
        int m=grid.length,n=grid[0].length;
        int[][] dp=new int[m][n];
        dp[0][0]=grid[0][0];
        for(int i=1;i<m;++i)
            dp[i][0]=dp[i-1][0]+grid[i][0];
        for(int i=1;i<n;++i)
            dp[0][i]=dp[0][i-1]+grid[0][i];
        for(int i=1;i<m;++i)
          for(int j=1;j<n;++j){
              dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+grid[i][j];
          }
          return dp[m-1][n-1];
    }
}

方法三：

K神：

作者：jyd
链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/mian-shi-ti-47-li-wu-de-zui-da-jie-zhi-dong-tai-gu/
来源：力扣（LeetCode）

动态规划：

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(i == 0 && j == 0) continue;
                if(i == 0) grid[i][j] += grid[i][j - 1] ;
                else if(j == 0) grid[i][j] += grid[i - 1][j];
                else grid[i][j] += Math.max(grid[i][j - 1], grid[i - 1][j]);
            }
        }
        return grid[m - 1][n - 1];
    }
}

以上代码逻辑清晰，和转移方程直接对应，但仍可提升效率：当 grid 矩阵很大时， i=0 或 j = 0的情况仅占极少数，相当循环每轮都冗余了一次判断。因此，可先初始化矩阵第一行和第一列，再开始遍历递推。

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        for(int j = 1; j < n; j++) // 初始化第一行
            grid[0][j] += grid[0][j - 1];
        for(int i = 1; i < m; i++) // 初始化第一列
            grid[i][0] += grid[i - 1][0];
        for(int i = 1; i < m; i++)
            for(int j = 1; j < n; j++) 
                grid[i][j] += Math.max(grid[i][j - 1], grid[i - 1][j]);
        return grid[m - 1][n - 1];
    }
}

总结

以上就是本题的内容和学习过程了，动态规划的题目首先应该想明白转移方程，而不是凭感觉就开始编程。

K神针滴强。

欢迎讨论，共同进步。