LeetCode9_数组最大连续子序和（暴力、贪心、分治、动态规划）

最新推荐文章于 2022-10-27 17:29:32 发布

原创最新推荐文章于 2022-10-27 17:29:32 发布 · 456 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #算法 #leetcode #java #贪心、分治

easy code 专栏收录该内容

115 篇文章

订阅专栏

本文介绍了解决最大子序和问题的多种方法，包括暴力解法、贪心算法、分治法及动态规划等。其中，重点讲解了贪心算法的思想与实现细节。

一、题目描述

梦的开始！！

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

示例:

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

进阶:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、我的解答

开始按着贪心的方式，不通过，因为此题目涉及有全是负数的情况（未改进前，只适合正数负数都存在的情况）

解题方法

暴力方法，复杂度为O(n^3)、优化后为O(n^2)
在线处理（贪心），复杂度为 O（n）
分治
动态规划

暴力的就不多说了，完善后的在线处理思路
在这里插入图片描述

对于全是负数的情况，需要找出最大的值即可，因为负数加上一个负数，只会越来越小
对于负数和正数都存在的情况，设置最大子序和 max > res 时更新 res
- 当max > 0时，不断地向后求最大子序和
- 当max <0时，需要将max置为0，从下一位重新开始求子序和，直到循环结束

代码

class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length == 1){
            return nums[0];
        }
        
        //对于全是负数的情况，需要单独处理，找出最大值
        int max_fu = nums[0];
        for(int j = 0;j<nums.length;j++){
            if(nums[j] > 0 ){
                break;
            }
            else{
                if(max_fu < nums[j]){
                    max_fu = nums[j];
                }
                if(j == nums.length - 1){
                    return max_fu;
                }

            }
        }
        //正负都存在
        int max = 0;
        int res = 0;
        for(int i = 0;i<nums.length;i++){
            
            max += nums[i];
            if(max > res){
                res = max;
            }
            else if(max < 0 ){
                max = 0;
            }
            

          
        }
        return res;



    }
}

或者

class Solution {
    public int maxSubArray(int[] nums) {
        int len = nums.length;
        if(len == 1){
            return nums[0];
        }
        int res = nums[0];
        int value = 0;
        for(int i = 0;i<len;i++){
            value += nums[i];
            if(value > 0){
                res = Math.max(res,value);
            }
            else{
                value = 0;
                res = Math.max(res,nums[i]);
            }
        }
        return res;
    }
}

三、题解

3.1题解1贪心

同上述解答思想

贪心贪的是哪里呢？

如果 -2 1 在一起，计算起点的时候，一定是从1开始计算，因为负数只会拉低总和，这就是贪心贪的地方！
局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。
全局最优：选取最大“连续和”
局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。

从代码角度上来讲：遍历nums，从头开始用count累积，如果count一旦加上nums[i]变为负数，那么就应该从nums[i+1]开始从0累积count了，因为已经变为负数的count，只会拖累总和。

这相当于是暴力解法中的不断调整最大子序和区间的起始位置。

那有同学问了，区间终止位置不用调整么？如何才能得到最大“连续和”呢？

区间的终止位置，其实就是如果count取到最大值了，及时记录下来了。例如如下代码：

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

class Solution {
    public int maxSubArray(int[] nums) {
        //只有一个元素的情况也适用
        int ans = nums[0];
        int sum = 0;
        for(int num: nums) {
            //局部最优
            if(sum > 0) {
                sum += num;
            } else {
                sum = num;
            }
            //更新最大子序和
            ans = Math.max(ans, sum);
        }
        return ans;
    }
}

3.2题解2之分治

分治法的思路是这样的，其实也是分类讨论。

连续子序列的最大和主要由这三部分子区间里元素的最大和得到：

第 1 部分：子区间 [left, mid]；
第 2 部分：子区间 [mid + 1, right]；
第 3 部分：包含子区间 [mid , mid + 1] 的子区间，即 nums[mid] 与 nums[mid + 1] 一定会被选取。
对这三个部分求最大值即可。

说明：考虑第 3 部分跨越两个区间的连续子数组的时候，由于 nums[mid] 与 nums[mid + 1] 一定会被选取，可以从中间向两边扩散，扩散到底选出最大值，具体请见「参考代码 6」。

public class Solution {

    public int maxSubArray(int[] nums) {
        int len = nums.length;
        if (len == 0) {
            return 0;
        }
        return maxSubArraySum(nums, 0, len - 1);
    }

	// 其实还是类似于贪心
    private int maxCrossingSum(int[] nums, int left, int mid, int right) {
        // 一定会包含 nums[mid] 这个元素
        int sum = 0;
        int leftSum = Integer.MIN_VALUE;
        // 左半边包含 nums[mid] 元素，最多可以到什么地方
        // 走到最边界，看看最值是什么
        // 计算以 mid 结尾的最大的子数组的和
        for (int i = mid; i >= left; i--) {
            sum += nums[i];
            if (sum > leftSum) {
                leftSum = sum;
            }
        }
        sum = 0;
        int rightSum = Integer.MIN_VALUE;
        // 右半边不包含 nums[mid] 元素，最多可以到什么地方
        // 计算以 mid+1 开始的最大的子数组的和
        for (int i = mid + 1; i <= right; i++) {
            sum += nums[i];
            if (sum > rightSum) {
                rightSum = sum;
            }
        }
        return leftSum + rightSum;
    }

	// 三部分最大的部分
    private int maxSubArraySum(int[] nums, int left, int right) {
        if (left == right) {
            return nums[left];
        }
        int mid = (left + right) >>> 1;
        return max3(maxSubArraySum(nums, left, mid),
                maxSubArraySum(nums, mid + 1, right),
                maxCrossingSum(nums, left, mid, right));
    }
	// 三个数最大值
    private int max3(int num1, int num2, int num3) {
        return Math.max(num1, Math.max(num2, num3));
    }
}

3.3题解3之动态规划

动态规划和递归恰恰是相反的，前者是自底向上求解，后者是自上向下求解。

动态规划中包含3个重要的概念：

最优子结构
边界
状态转移公式

以跳台阶为例，最优子结构为f(10)=f(9) + f(8)，边界是f(1)=1, f(2)=2，状态转移公式f(n)=f(n-1) + f(n-2)

// Kadane算法（和动态规划思想类似）扫描一次整个数列的所有数值，
// 在每一个扫描点计算以该点数值为结束点的子数列的最大和（正数和）。
// 该子数列由两部分组成：以前一个位置为结束点的最大子数列、该位置的数值。
// 因为该算法用到了“最佳子结构”（以每个位置为终点的最大子数列都是基于其前一位置的最大子数列计算得出,
// 该算法可看成动态规划的一个例子。
// 状态转移方程：sum[i] = max{sum[i-1]+a[i],a[i]}
// 其中(sum[i]记录以a[i]为子序列末端的最大序子列连续和)
。

class Solution {
    public int maxSubArray(int[] nums) {
        int [] dp = new int[nums.length];
        dp[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
        }
        int ans = dp[0];
        for (int i : dp) {
            ans = Math.max(i, ans);
        }
        return ans;
    }
}