高频10. 最大子数组和 及其变形题的各种解法 Java codetop 字节变体 美团变体

题目描述

最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

各种解法

1. 动态规划

解题思路

• 动态规划的 f(i) 表示 nums[i] 结尾的连续子数组的最大和
• 状态转移方程为 f(i)=max{f(i-1)+nums[i], nums[i]}
• 最后在以各个数字结尾的结果中找出最大的

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int dp_0 = nums[0];
        int dp_1 = 0;
        int res = dp_0; // 存结果
        for(int i=1; i<n;i++){
            dp_1 = Math.max(nums[i], nums[i]+dp_0);
            dp_0 = dp_1;
            res = Math.max(res, dp_0);
        }
        return res;
    }
}

• 因为当前状态只跟上一个状态有关，所以没有必要用数组进行存储。只需要几个变量就可以了。最终的结果用 res 变量进行更新即可。

2. 分治

解题思路

• 变量说明
  • lSum表示 [l, r] 内以 l 为左端点的最大子数组和
  • rSum表示 [l, r] 内以 r 为右端点的最大子数组和
  • mSum表示 [l, r] 内的最大子数组和
  • iSum表示 [l, r] 的区间和
• 变量的维护
  • iSum为左右子区间的 iSum 之和
  • lSum 有两种可能，等于左子区间的 lSum，或者等于左子区间的 iSum加上右子区间的 lSum，两者的大者。
  • rSum 有两种可能，等于右子区间的 rSum，或等于右子区间的 iSum 加上左子区间的 rSum，两者的大者
  • 基于上面的3个值，来计算 mSum。可能不跨越m，就是左子区间和右子区间的mSum之一，也有可能跨越m，就是左子区间的rSum和右子区间的lSum求和，三者的最大值。

class Solution {
    public class Status {
        public int lSum, rSum, mSum, iSum;

        public Status(int lSum, int rSum, int mSum, int iSum) {
            // 左端点为l的最大子数组和
            this.lSum = lSum;
            // 右端点为r的最大子数组和
            this.rSum = rSum;
            // l,r之间的最大子数组和
            this.mSum = mSum;
            // l,r之间的累加和
            this.iSum = iSum;
        }
    }

    public int maxSubArray(int[] nums) {
        return getInfo(nums, 0, nums.length - 1).mSum;
    }

    public Status getInfo(int[] a, int l, int r) {
        if (l == r) {
            return new Status(a[l], a[l], a[l], a[l]);
        }
        // 从中间分治
        int m = (l + r) >> 1;
        Status lSub = getInfo(a, l, m);
        Status rSub = getInfo(a, m + 1, r);
        // 把两边的结果合并
        return pushUp(lSub, rSub);
    }

    public Status pushUp(Status l, Status r) {
        int iSum = l.iSum + r.iSum;
        int lSum = Math.max(l.lSum, l.iSum + r.lSum);
        int rSum = Math.max(r.rSum, r.iSum + l.rSum);
        int mSum = Math.max(Math.max(l.mSum, r.mSum), l.rSum + r.lSum);
        return new Status(lSum, rSum, mSum, iSum);
    }
}

变形题

1. 要求返回有最大子数组和的具体子数组

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int dp_0 = nums[0];
        int dp_1 = 0;
        int res = dp_0; // 存结果
        int endIndex = 0; // 最大和的子数组的结尾索引
        for(int i=1; i<n;i++){
            dp_1 = Math.max(nums[i], nums[i]+dp_0);
            dp_0 = dp_1;
            if(dp_0 > res){
                res = dp_0; // 最大的和
                endIndex = i; // 更新最大的和的结束索引
            }
        }
        StringBuilder sb = new StringBuilder();
        int sum = 0;
        int beginIndex = endIndex;
        while(sum != res){
            sb.insert(0, nums[beginIndex]+" ");
            sum += nums[beginIndex];
            beginIndex--;
        }
        System.out.println(sb.toString());
        System.out.println("开始索引为"+(beginIndex+1)+"，结束索引为"+endIndex);
        return res;
    }
}

解题思路

• 动态规划在每次更新res的时候，记录下结束的索引，动态规划完成后，更新得到最大子数组和的子数组的结束索引。
• 然后向前累加找到 结果和 的开始索引，最终输出子数组。

2. 字节 抖音电商 后端实习 2021.12.10 变式

题目描述

给一个数组，以及一个数：如 [1, 3, 4, 3, 9, 1]， k = 12, 返回其中最短的，大于等于 k 的子数组。若无满足条件则返回 0

Input: [1, 3, 4, 3, 9, 1] ，12
Output: 2 // 因为最短的是 [3, 9] 长度 2

public int minsubarraylen(int[] nums, int k)
{
    int left = 0;
    int sum = 0;
    int minlength = Integer.MAX_VALUE; // 最短的长度，用于更新
    for(int right=0;right<nums.length;right++)
    {
        sum += nums[right];
        while(left<=right && sum>=k){ // 如果此时right的位置已经让sum>=k了，借助left压缩区间
            minlength = Math.min(minlength, (right-left+1));
            sum-=nums[left++];
        }
    }
    return minlength==Integer.MAX_VALUE?0:minlength;
}

解题思路

• 滑动窗口的解法。首先right指针向右移动，直到满足sum>=k的条件。
• 满足条件之后，让left向右，压缩空间，期望找到最小的子数组。
• 在滑动窗口的过程中更新最小长度。

3. 美团 2022/3/5 变式 可翻转部分数组

题目描述

如：-1 3 -5 2 -1 3，返回7 ，反转 -5 到 3 的部分数组

解题思路

• 一开始想的是翻转需要有一头一尾的被反转子数组索引，这就是O(n^2)，再乘上每次求最大子数组和的时间复杂度是O(n)。真就是$O(n^3)$吗？？