【每日一题Day140】剑指 Offer 47. 礼物的最大价值 | 动态规划 记忆化搜索

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

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

找回了点自信

动态规划

• 思路：动态规划

  这题动态规划还是挺明显的，到达每个格子所能获得的最大价值由其上面的格子获得的价值和其左边的格子获得的价值的最大值决定，因此可以定义状态dp[i][j]为到达格子grid[i][j]所获得的最大价值，最后返回dp[m-1][n-1]即可

  • 状态转移方程为
    $$dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+grid[i][j];$$

• 实现

  实现时防止越界，扩一行一列

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

  • 复杂度
    • 时间复杂度：$O(nm)$
    • 空间复杂度：$O(nm)$

• 空间优化：

  • 每一行的状态只依赖于前一行的状态，因此可以用两个长度为n+1的数组实现

    class Solution {
        public int maxValue(int[][] grid) {
            int m = grid.length, n = grid[0].length;
            int[][] dp = new int[2][n + 1];
            for (int i = 0; i < m; i++){
                for (int j = 0; j < n; j++){   
                    dp[(i + 1) % 2][j + 1] = Math.max(dp[(i + 1) % 2][j], dp[i % 2][j + 1]) + grid[i][j];
                }
            }
            return dp[m % 2][n];
        }
        public int dfs(int[][] grid, int i, int j, int sum){
            if (i == grid.length || j == grid[0].length){
                return sum;
            }
            sum += grid[i][j];
            int right = dfs(grid, i, j + 1, sum);
            int left = dfs(grid, i + 1, j, sum);
            return Math.max(left, right);
        }
    }
    

    • 复杂度
      • 时间复杂度：$O(nm)$
      • 空间复杂度：$O(n)$

  • 一个长度为n+1的一维数组

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

    • 复杂度
      • 时间复杂度：$O(nm)$
      • 空间复杂度：$O(n)$

  • 原地修改：

    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++){   
                    grid[i][j] += Math.max(i > 0 ? grid[i - 1][j] : 0, j > 0 ? grid[i][j - 1] : 0);
                }
            }
            return grid[m - 1][n - 1];
        }
    
    }
    

记忆化搜索

• 思路

  • 由于右下角的价值和与左边的价值和和上面的价值和的最大值相关，并且整个回溯过程有大量重复递归调用的，因此可以采用记忆化搜索和dp的方法实现
  • 定义 $f(grid,i,j)$ 表示到达第$i$行第$j$列格子时，获得的最大价值，那么 $f(grid,m-1,n-1)$ 即为最终结果
  • 使用dp数组记录已经搜索过的方案数，$dp[i][j]$数组的含义同f函数

• 实现

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

  • 复杂度

    • 时间复杂度：$O(2^{n+m})$

    • 空间复杂度：$O(m+n)$