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

题目描述

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

解题思路

1：到达右下角的最大礼物数取决于你之前已经拿到了多少礼物，
即 dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+grid[i][j];

2:第一行和第一列的不能用这个公式算，不然那会越界
计算公式为
dp[0][j]=dp[0][j-1]+grid[0][j];//当在第一行,求第一行的dp
dp[i][0]=dp[i-1][0]+grid[i][0];//求第一列的dp

第一版代码，有错

class Solution {
    public int maxValue(int[][] grid) {
          int sum=grid[0][0];//最开始在左上角
          int dp[][]=new int[grid.length][grid[0].length];
          dp[0][0]=grid[0][0];
          for(int j=1;j<grid[0].length;j++)
          {
              dp[0][j]=dp[0][j-1]+grid[0][j];//当在第一行,求第一行的dp
          }

          for(int i=1;i<grid.length;i++)
          {
              dp[i][0]=dp[i-1][0]+grid[i][0];//求第一列的dp
          }

           for(int i=1;i<grid[0].length;i++)
           {
             for(int j=1;j<grid.length;j++)
             {
                dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+grid[i][j];                   
             }
           }


      return dp[grid.length-1][grid[0].length-1];
    }
}

错误分析

已经给出了提示，是数组越界
我上面的代码后面的两个for循环没有注意行对应行，列对应列，就越界了

第二版代码 提交通过

class Solution {
    public int maxValue(int[][] grid) {
          int sum=grid[0][0];//最开始在左上角
          int dp[][]=new int[grid.length][grid[0].length];
          dp[0][0]=grid[0][0];
          for(int j=1;j<grid[0].length;j++)
          {
              dp[0][j]=dp[0][j-1]+grid[0][j];//当在第一行,求第一行的dp
          }

          for(int i=1;i<grid.length;i++)
          {
              dp[i][0]=dp[i-1][0]+grid[i][0];//求第一列的dp
          }
         for(int j=1;j<grid[0].length;j++)
           {
             for(int i=1;i<grid.length;i++)
             {
                dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+grid[i][j];                   
             }
           }

 
      return dp[grid.length-1][grid[0].length-1];
    }
}

优化

为了方便计算我们还可以把dp的宽和高增加1，也就是dp的最上面一行和最左边一列不存储任何数值，他们都是0，这样是为了减少一些判断

class Solution {
    public int maxValue(int[][] grid) {
          int sum=grid[0][0];//最开始在左上角
          int dp[][]=new int[grid.length+1][grid[0].length+1];
          dp[1][1]=grid[0][0];
         for(int j=1;j<=grid[0].length;j++)
           {
             for(int i=1;i<=grid.length;i++)
             {
                dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+grid[i-1][j-1];                   
             }
           }
      return dp[grid.length][grid[0].length];
    }
}

优化二

我们再来仔细看这道题，题中没说不可以修改原来数组的值，所以我还可以使用题中的二维数组来代替二维dp数组，这样最终我们把空间复杂度从O(MN)降到O(1)。

public int maxValue(int[][] grid) {
    //边界条件判断
    if (grid == null || grid.length == 0)
        return 0;
    int m = grid.length;
    int n = grid[0].length;
    //初始化dp的最上面一行，从左到右累加
    for (int i = 1; i < n; i++) {
        grid[0][i] += grid[0][i - 1];
    }
    //初始化dp的最左边一列，从上到下累加
    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]) + grid[i][j];
        }
    }
    return grid[m - 1][n - 1];
}


作者：sdwwld
链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/shu-ju-jie-gou-he-suan-fa-dong-tai-gui-h-569o/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

递归解决

定义函数private int helper(int[][] grid, int i, int j)，表示从左上角到坐标（i,j）所得到的最大礼物价值，如果要走到坐标(i,j)，我们可以从上面坐标(i-1,j)走下来，或者从左边坐标(i,j-1)走过来，这两种方式我们选择最大的即可，这里要注意不能走到矩阵的外面。

作者：sdwwld
链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/shu-ju-jie-gou-he-suan-fa-dong-tai-gui-h-569o/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

    public int maxValue(int[][] grid) {
        //边界条件判断
        if (grid == null || grid.length == 0)
            return 0;
        return helper(grid, grid.length - 1, grid[0].length - 1);
    }


    private int helper(int[][] grid, int i, int j) {
        if (i < 0 || j < 0)
            return 0;
        return Math.max(helper(grid, i - 1, j), helper(grid, i, j - 1)) + grid[i][j];
    }


作者：sdwwld
链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/shu-ju-jie-gou-he-suan-fa-dong-tai-gui-h-569o/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

不过很遗憾的是，运行超时了，因为这里面包含了大量的重复计算，我们还可以把计算的结果用map存起来，下次用的时候查看map中是否有，如果有就直接从map中取，如果没有在计算

作者：sdwwld
链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/shu-ju-jie-gou-he-suan-fa-dong-tai-gui-h-569o/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

    public int maxValue(int[][] grid) {
        //边界条件判断
        if (grid == null || grid.length == 0)
            return 0;
        return helper(grid, grid.length - 1, grid[0].length - 1, new HashMap<>());
    }

    private int helper(int[][] grid, int i, int j, Map<String, Integer> map) {
        if (i < 0 || j < 0)
            return 0;
        String key = i + "*" + j;
        int res = map.getOrDefault(key, -1);
        //如果以前计算过，就从map中取
        if (res != -1)
            return res;
        //如果之前没有计算过，则进行计算
        res = Math.max(helper(grid, i - 1, j, map), helper(grid, i, j - 1, map)) + grid[i][j];
        //把计算的结果还存到map中
        map.put(key, res);
        return res;
    }


作者：sdwwld
链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/shu-ju-jie-gou-he-suan-fa-dong-tai-gui-h-569o/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

参考

https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/shu-ju-jie-gou-he-suan-fa-dong-tai-gui-h-569o/