【每日力扣36】最大子序和

一饭名厨姚鲲鲲

于 2022-01-29 23:44:06 发布

阅读量658

点赞数

分类专栏： # 【算法】动态规划 # 【算法】数组文章标签： leetcode 算法动态规划 c++ 数组

本文链接：https://blog.csdn.net/micah_yaokunkun/article/details/122749070

版权

算法同时被 3 个专栏收录

42 篇文章 0 订阅

订阅专栏

【算法】数组

15 篇文章 0 订阅

订阅专栏

【算法】动态规划

4 篇文章 0 订阅

订阅专栏

一、题目[LeetCode-53]

给你一个整数数组 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 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4

二、思路

动态规划

与《day35 买卖股票的最佳时机》相似，对于本题的数组，也可以使用动态规划。每当遍历到数组nums的第i个数nums[i]时，有“加”和“不加”两种状态。设dp[i][0]表示当遍历到nums[i]时“选择不加”的状态下的最大累积值，dp[i][0]表示当遍历到nums[i]时“选择加”的状态下的最大累积值。然后便可推导动态规划转移方程。

若参照《day2 买卖股票的最佳时机II》，对于dp[i][0]，它的取值则有两种情况：

上一个数nums[i-1]没有选择加上
上一个数nums[i-1]选择加上

由于dp[i][0]表示不加nums[i]，因此可以简单的选取dp[i-1][0]和dp[i-1][1]的最大值： dp[i][0] = max(dp[i-1][0], dp[i-1][1])

对于dp[i][1]，同理对应两种情况：

上一个数nums[i-1]没有选择加上
上一个数nums[i-1]选择加上

如果是类似于《day2 买卖股票的最佳时机II》，对于“选择是否加上nums中的数的次数”没有任何限制，那么这里也是直接简单的选取dp[i-1][0] + nums[i]和dp[i-1][1] + nums[i]的最大值：dp[i][1] = max(dp[i-1][0]+nums[i], dp[i-1][1]+nums[i])

但是本题是类似于《day35 买卖股票的最佳时机》，对于“选择加上nums[i]”有着限制：只能加一次连续地加，对于“上一次nums[i-1]没有加选择在nums[i]加”的情况只允许出现一次。因此对于dp[i][1]，只会有这两种情况：

上一个数nums[i-1]没有加上，并且之前的所有nums[0, i-2]都没有加，此时可以确定：dp[i-1][0]=0
上一个数nums[i-1]加上了，这时简单地将dp[i-1][1]加上nums[i]即可

因此：dp[i][1] = max(nums[i], dp[i-1][1] + nums[i])

综上所述，本题的状态转移方程为

dp[i][0] = max(dp[i-1][0]+nums[i], dp[i-1][1]+nums[i])

dp[i][1] = max(nums[i], dp[i-1][1]+nums[i])

对于初始条件，dp[0][0]=0，dp[0][1]=nums[i]

但不同于《day35 买卖股票的最佳时机》，本题在nums中所有的数必须至少选择加上一个。存在这种特殊情况：nums所有的数全为负数，此时算法会选择全都不加，返回dp[0][0]=0。但是我们这时候必须加上一个数，所以在最后我们额外讨论这种情况：再次遍历nums，找出所有数（此时均为负数）中的最大者返回即可。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        if(n == 1)
            return nums[0];//数组只有一个元素（除了直接返回别无选择）的退化情况
        vector<vector<int>> dp(n);
        for(int i = 0; i < n; i++)
            dp[i] = vector<int> (2);//创建动态规划数组
        dp[0][0] = 0;
        dp[0][1] = nums[0];//初始化动态规划数组
        for(int i = 1; i < n; i++)
        {
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]);//对应当遍历到nums第i个数后选择不加nums[i]的状态
            dp[i][1] = max(nums[i], dp[i-1][1] + nums[i]);//对应当遍历到nums第i个数后选择加上nums[i]的状态
        }
        if(dp[n-1][0] == 0)//如果nums全为负数，上面算法会选择“全都不加”，这时dp[n-1][0]==0，但是题目要求必须加最少其中一个
        {    //因此这种情况下，我们就找数组nums中值最大的负数，返回它即可
            int max = nums[0];
            for(int i = 1; i < n; i++)
            {
                if(nums[i] > max)
                    max = nums[i];
            }
            return max;
        }    
        return max(dp[n-1][0], dp[n-1][1]);
    }
};

动态规划的优化

同理于《day2 买卖股票的最佳时机II》《day35 买卖股票的最佳时机》，上述思路可以优化：算法不使用数组的实现形式，直接使用两个变量dp0,dp1进行n-1次迭代。将空间复杂度由O(n)优化至O(1)。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        if(n == 1)
            return nums[0];//数组只有一个元素（除了直接返回别无选择）的退化情况
        int dp0 = 0;
        int dp1 = nums[0];//初始化两个变量
        for(int i = 1; i < n; i++)
        {
            dp0 = max(dp0, dp1);//对应当遍历到nums第i个数后选择不加nums[i]的状态
            dp1 = max(nums[i], dp1 + nums[i]);//对应当遍历到nums第i个数后选择加上nums[i]的状态
        }
        if(dp0 == 0)//如果nums全为负数，上面算法会选择“全都不加”，这时dp0==0，但是题目要求必须加最少其中一个
        {    //因此这种情况下，我们就找数组nums中值最大的负数，返回它即可
            int max = nums[0];
            for(int i = 1; i < n; i++)
            {
                if(nums[i] > max)
                    max = nums[i];
            }
            return max;
        }    
        return max(dp0, dp1);
    }
};

三、官方题解（来源：力扣（LeetCode））

方法一：动态规划（更简洁的思路）

假设 nums 数组的长度是 n，下标从 0 到 n−1。

我们用 f(i) 代表以第 i 个数结尾的「连续子数组的最大和」，那么很显然我们要求的答案就是：

$\max_{0\leq i\leq n-1}\{f(i)\}$

因此我们只需要求出每个位置的 f(i)，然后返回 f 数组中的最大值即可。那么我们如何求 f(i) 呢？我们可以考虑 nums[i] 单独成为一段还是加入 f(i−1) 对应的那一段，这取决于 nums[i] 和 f(i−1)+nums[i] 的大小，我们希望获得一个比较大的，于是可以写出这样的动态规划转移方程：

f(i)=max{f(i−1)+nums[i],nums[i]}

不难给出一个时间复杂度 O(n)、空间复杂度 O(n) 的实现，即用一个 f 数组来保存 f(i) 的值，用一个循环求出所有 f(i)。考虑到 f(i) 只和 f(i−1) 相关，于是我们可以只用一个变量 pre 来维护对于当前 f(i) 的 f(i−1) 的值是多少，从而让空间复杂度降低到 O(1)，这有点类似「滚动数组」的思想。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre = 0, maxAns = nums[0];
        for (const auto &x: nums) {
            pre = max(pre + x, x);
            maxAns = max(maxAns, pre);
        }
        return maxAns;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/maximum-subarray/solution/zui-da-zi-xu-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度

时间复杂度：O(n)，其中 n 为 nums 数组的长度。我们只需要遍历一遍数组即可求得答案。
空间复杂度：O(1)。我们只需要常数空间存放若干变量。

方法二：分治、线段树

这个分治方法类似于「线段树求解最长公共上升子序列问题」的 pushUp 操作。也许读者还没有接触过线段树，没有关系，方法二的内容假设你没有任何线段树的基础。当然，如果读者有兴趣的话，推荐阅读线段树区间合并法解决多次询问的「区间最长连续上升序列问题」和「区间最大子段和问题」，还是非常有趣的。

我们定义一个操作 get(a, l, r) 表示查询 a 序列 [l,r] 区间内的最大子段和，那么最终我们要求的答案就是 get(nums, 0, nums.size() - 1)。如何分治实现这个操作呢？对于一个区间 [l,r]，我们取 m=⌊(l+r)/2⌋，对区间 [l,m] 和 [m+1,r] 分治求解。当递归逐层深入直到区间长度缩小为 1 的时候，递归「开始回升」。这个时候我们考虑如何通过 [l,m] 区间的信息和 [m+1,r] 区间的信息合并成区间 [l,r] 的信息。最关键的两个问题是：

我们要维护区间的哪些信息呢？

我们如何合并这些信息呢？

对于一个区间 [l,r]，我们可以维护四个量：

lSum 表示 [l,r] 内以 l 为左端点的最大子段和
rSum 表示 [l,r] 内以 r 为右端点的最大子段和
mSum 表示 [l,r] 内的最大子段和
iSum 表示 [l,r] 的区间和

以下简称 [l,m] 为 [l,r] 的「左子区间」，[m+1,r] 为 [l,r] 的「右子区间」。我们考虑如何维护这些量呢（如何通过左右子区间的信息合并得到 [l,r] 的信息）？对于长度为 1 的区间 [i,i]，四个量的值都和 nums[i] 相等。对于长度大于 1 的区间：

首先最好维护的是 iSum，区间 [l,r] 的 iSum 就等于「左子区间」的 iSum 加上「右子区间」的 iSum。
对于 [l,r] 的lSum，存在两种可能，它要么等于「左子区间」的 lSum，要么等于「左子区间」的 iSum 加上「右子区间」的 lSum，二者取大。
对于 [l,r] 的 rSum，同理，它要么等于「右子区间」的 rSum，要么等于「右子区间」的 iSum 加上「左子区间」的 rSum，二者取大。
当计算好上面的三个量之后，就很好计算 [l,r] 的 mSum 了。我们可以考虑 [l,r] 的 mSum 对应的区间是否跨越 m——它可能不跨越 m，也就是说 [l,r] 的 mSum 可能是「左子区间」的 mSum 和「右子区间」的 mSum 中的一个；它也可能跨越 m，可能是「左子区间」的 rSum 和「右子区间」的 lSum 求和。三者取大。

这样问题就得到了解决。

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

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

    Status get(vector<int> &a, int l, int r) {
        if (l == r) {
            return (Status) {a[l], a[l], a[l], a[l]};
        }
        int m = (l + r) >> 1;
        Status lSub = get(a, l, m);
        Status rSub = get(a, m + 1, r);
        return pushUp(lSub, rSub);
    }

    int maxSubArray(vector<int>& nums) {
        return get(nums, 0, nums.size() - 1).mSum;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/maximum-subarray/solution/zui-da-zi-xu-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

假设序列 a 的长度为 n。

时间复杂度：假设我们把递归的过程看作是一颗二叉树的先序遍历，那么这颗二叉树的深度的渐进上界为 O(logn)，这里的总时间相当于遍历这颗二叉树的所有节点，故渐进时间复杂度为 O(n)。
空间复杂度：递归会使用 O(logn) 的栈空间，故渐进空间复杂度为 O(logn)。

题外话

「方法二」相较于「方法一」来说，时间复杂度相同，但是因为使用了递归，并且维护了四个信息的结构体，运行的时间略长，空间复杂度也不如方法一优秀，而且难以理解。那么这种方法存在的意义是什么呢？

对于这道题而言，确实是如此的。但是仔细观察「方法二」，它不仅可以解决区间 [0, n-1]，还可以用于解决任意的子区间 [l,r] 的问题。如果我们把 [0, n-1] 分治下去出现的所有子区间的信息都用堆式存储的方式记忆化下来，即建成一颗真正的树之后，我们就可以在 O(logn) 的时间内求到任意区间内的答案，我们甚至可以修改序列中的值，做一些简单的维护，之后仍然可以在 O(logn) 的时间内求到任意区间内的答案，对于大规模查询的情况下，这种方法的优势便体现了出来。这棵树就是上文提及的一种神奇的数据结构——线段树。

四、学习心得

①动态规划的动态规划转移方程求解

本题有两种思路：

dp[i][0] = max(dp[i-1][0]+nums[i], dp[i-1][1]+nums[i])

dp[i][1] = max(nums[i], dp[i-1][1]+nums[i])

f(i)=max{f(i−1)+nums[i],nums[i]}

②线段树的思想

一饭名厨姚鲲鲲

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【每日力扣36】最大子序和

一、题目[LeetCode-53]给你一个整数数组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 &lt...
复制链接

扫一扫