【Leetcode041】 最大子数组和

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 <= 105
-104 <= nums[i] <= 104

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

方法一：贪心法

1.1 思路分析

暴力解法：算出所有子序列的和，然后取最大值，时间复杂度O(n²)，本文不做介绍了。

贪心法：

1. 定义当前子序列和cur，最优子序列和res，cur初始为0， res初始为Integer.MIN_VALUE最小值；
2. 遍历数组，如果cur>0，将当前元素加到cur，否则cur放弃之前的数，将当前元素值赋值给cur；
3. 遍历的同时不断选出最大值，赋值给res

贪心思想：拿到新的，判断是否丢弃对自身不利的

1.2 代码实现

class Solution {
    /**贪心法 */
    public int maxSubArray(int[] nums) {
        // 1. 特判
        if (nums.length == 1) return nums[0];
        // 2. 逐个向后加，如果和为负数则抛弃，从当前位置重新开始
        //    cur保存当前和, res保存最大值
        // 注意res应该初始化成极小的数
        int cur=0, res=Integer.MIN_VALUE;
        for (int num: nums){
            if (cur > 0){  // 当前和大于0
                cur += num;
            }else {
                cur = num;
            }
            res = Math.max(res, cur);
        }
        return res;
    }
}

1.3 测试结果

1.4 复杂度

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

方法二：动态规划

2.1 思路分析

看了人家的题解才明白，字数太多，三言两语又叙述不清，直接把人家的截图搬来了
感谢力扣liweiwei1419

2.2 代码实现

不优化空间版：

class Solution {
    /**动态规划--不优化空间版 */
    public int maxSubArray(int[] nums) {
        // 特判
        if (nums.length==1) return nums[0]; 

        // 以nums[i]为结尾的最大和
        int[] dp = new int[nums.length];
        int res = nums[0];  // 注意别漏掉第一个元素
        dp[0] = nums[0];
        for (int i=1; i<nums.length; i++){
            if (dp[i-1]>0){
                dp[i] = dp[i-1] + nums[i];
            }else {
                dp[i] = nums[i];
            }
            res = Math.max(dp[i], res);
        }
        return res;
    }
}

优化空间版：

class Solution {
    /**动态规划--优化空间版 */
    public int maxSubArray(int[] nums) {
        // 特判
        if (nums.length==1) return nums[0]; 

        int pre = nums[0];
        int res = nums[0];  // 注意别漏掉第一个元素

        for (int i=1; i<nums.length; i++){
            pre = Math.max(nums[i], pre+nums[i]);
            res = Math.max(res, pre);
        }
        return res;
    }
}

2.3 测试结果

不优化空间版：

优化空间版：

2.4 复杂度

• 时间复杂度：O(n)
• 空间复杂度：O(n),未优化空间；O(1),优化空间。

方法三：分治法

3.1 思路分析

还不会，直接上官方题解吧。答题就是分为中点两侧和包含中点的三段子序列。从n个往下分，分到1个再返回，不断比较大小合并。

3.2 代码实现

class Solution {    
    /**分治法 */
    public class Status {
        public int lSum, rSum, mSum, iSum;

        public Status(int lSum, int rSum, int mSum, int iSum) {
            this.lSum = lSum;
            this.rSum = rSum;
            this.mSum = mSum;
            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);
    }
}

3.3 测试结果

3.4 复杂度

• 时间复杂度：O(logn)–>O(n)
• 空间复杂度：O(logn)