《剑指offer》 -day9- 动态规划（中等）

pospre

已于 2022-04-09 11:22:30 修改

阅读量483

点赞数

分类专栏：剑指offer 文章标签：动态规划 leetcode 剑指offer

于 2021-12-09 12:18:38 首次发布

本文链接：https://blog.csdn.net/weixin_56915683/article/details/121809497

版权

剑指offer 专栏收录该内容

26 篇文章 2 订阅

订阅专栏

剑指 Offer 42. 连续子数组的最大和

题目描述

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
要求时间复杂度为 $O (n)$ 。

提示：

$1 <= arr.length <= 10^5$
$100 < = a r r [i] < = 100$

贪心 ⭐️

思路：

由于本题目只考虑 连续数组 的最大和，所以可以设置一个总和 $s u m$ ，记录目前为止的连续数组的最大和
如果当前子数组的总和已经小于0，那么不会再有“正向”贡献，需要重置 $s u m = 0;$

class Solution {
    public int maxSubArray(int[] nums) {
        int sum = 0;
        int n = nums.length;
        int res = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            sum += nums[i];
            res = Math.max(sum, res);
            if (sum < 0) { // 如果当前子数组的总和已经小于0，那么不会再有“正向”贡献，需要重置
                sum = 0;
            }
        }
        return res;
    }
}

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

这里太假了，leetcode这个时间、内存消耗果然不准。 $O (1)$ 的空间竟然比 $O (n)$ 的空间还大…

DP

DP：写法1 ⭐️

思路：

$d p [i]$ 表示以 i 结尾的连续子数组的和的最大值
int[] dp = new int[n];
递推公式
- 上一个（第 i-1）结尾的数组和大于0，加到当前元素才会有贡献：即， $d p [i] = d p [i - 1] + n u m s [i];$
- 不用考虑当前元素 nums[i]，重置 dp[i]。即， $d p [i] = n u m s [i];$
初始化： $d p [0] = n u m s [0];$

注意：不能初始化 $dp[0] = Integer.MIN_VALUE;$

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int res = nums[0];
        int[] dp = new int[n]; // dp[i]表示以i结尾的连续子数组的和的最大值
        // 3、初始化
        dp[0] = nums[0];
        // 4、遍历顺序
        for (int i = 1; i < n; i++) {
            // 2、递推公式
            if (dp[i - 1] > 0) { // 上一个（第i-1）结尾的数组和大于0，加到当前元素才会有 贡献
                dp[i] = dp[i - 1] + nums[i];
            } else { // 不用考虑当前元素 nums[i]，重置dp[i]
                dp[i] = nums[i];
            }
            res = Math.max(res, dp[i]); // 取dp[i]最大值
        }
        // 5、打印dp
        // System.out.println("nums: " + Arrays.toString(nums));
        // System.out.println("  dp: " + Arrays.toString(dp));;
        return res;
    }
}

DP：写法2

以上 dp写法1中，将 $d p [i]$ 表示以 i 结尾的连续子数组的和的最大值，需要单独处理 $d p [0]$ ，较为复杂。

这里可以通过将 定义为 dp[n+1] 可以避免单独初始化 dp[0]

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int res = nums[0];
        // 定义为 dp[n+1] 可以避免单独初始化 dp[0]
        int[] dp = new int[n + 1]; // dp[i]表示以i-1结尾的连续子数组的和的最大值
        // 3、初始化（定义dp[n+1]不必单独初始化dp[0]）
        
        // 4、遍历顺序
        for (int i = 1; i <= n; i++) {
            // 2、递推公式
            dp[i] = Math.max(dp[i - 1] + nums[i - 1], nums[i - 1]); // 上面写法的合并
            res = Math.max(res, dp[i]); // 取dp[i]最大值
        }
        // 5、打印dp
        // System.out.println("nums: " + Arrays.toString(nums));
        // System.out.println("  dp: " + Arrays.toString(dp));;
        return res;
    }
}

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

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

题目描述

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

提示：

$0 < g r i d . l e n g t h < = 200$
$0 < g r i d [0] . l e n g t h < = 200$

DP

DP：写法1

思路：

$d p [i] [j]$ 表示从(0, 0)到(i, j)可以拿到的礼物的最大价值
int[][] dp = new int[m][n];
递推公式
当前位置 (i, j) 只能从其上方或左方而来（第一行、第一列单独考虑），所以取上 2 个位置的最大值。
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
初始化

这样设 $d p [m] [n]$ 需要单独处理 $d p [i] [0]$ 和 $d p [0] [j]$ ，二者均为左（或上）方元素之和

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n]; // dp[i][j]表示从(0, 0)到(i, j)可以拿到的礼物的最大价值
        // 3、初始化
        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 j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];  
        }
        // 4、遍历顺序（从上到下，从左到右）
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                // 2、递推公式
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        // 5、打印dp
        for (int i = 0; i < m; i++) {
            System.out.println(Arrays.toString(dp[i]));
        }
        return dp[m - 1][n - 1];
    }
}

时间复杂度： $O(n^2)$
空间复杂度： $O(n^2)$

DP：写法2（`统一写法`） ⭐️

$d p [i] [j]$ 表示从(0, 0)到 (i-1, j-1) 可以拿到的礼物的最大价值，可以避免单独处理 $d p [i] [0]$ 和 $d p [0] [j]$ ，二者均为左（或上）方元素之和。

即，int[][] dp = new int[m + 1][n + 1];

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m + 1][n + 1]; // dp[i][j]表示从(0, 0)到(i-1, j-1)可以拿到的礼物的最大价值
        // 3、初始化（定义dp[m+1][n+1]可以避免单独处理dp[i][0]、dp[0][j]）
        
        // 4、遍历顺序（从上到下，从左到右）
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                // 2、递推公式
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]) + grid[i - 1][j - 1];
            }
        }
        // 5、打印dp
        for (int i = 0; i <= m; i++) {
            System.out.println(Arrays.toString(dp[i]));
        }
        return dp[m][n];
    }
}