LeetCode Hot100题 第53题 最大子序和题解

先贴一下这道题的题目描述：

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

示例:

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

进阶:

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

这道题最好想到的解法是用动态规划法，也就是进阶里面提到的时间复杂度为O（n）级别的解法，我们先介绍动态规划思路。

解法一：动态规划

我们很容易想到，遍历数组每个下标的时候，对于每个下标有两个选择方式，第一是将他和他的前一个下标一起，组成一个连续子数组；另一个方式时将他作为连续子数组的新起点。

我们将两种方式里能得到的较大值存进数组该下标位置，作为判断遍历到下一个下标的时候，选择哪种方式的依据，如果该值大于零，则会选择方式一，如果该值小于零，则会选择方式二，同时我们设置一个变量max，用于存放遍历中得到的最大值。

最后变量max的值，就是遍历得到的子序和的最大值，将他返回。

//i为此刻遍历到的数组的下标
nums[i - 1] > 0 ? nums[i] = nums[i] + nums[i - 1] : nums[i] = nums[i];
max = Math.max(max,nums[i]);
return max;

下面贴一下完整的代码：

class Solution {
    public int maxSubArray(int[] nums) {
        int[] arr = new int[nums.length];
        arr[0] = nums[0];
        int max = arr[0];
        for(int i = 1 ;  i < nums.length ; i ++){
            if(arr[i - 1] < 0) arr[i] = nums[i];
            else arr[i] = nums[i] + arr[i - 1];
            if(arr[i] > max) max = arr[i];
        }
        return max;
    }
}

在这段代码里另外创建了一个新的数组，用来存放每个下标位置的最大子序和，其实完全可以选择原地存放，减小空间复杂度，空间复杂度由O(n)降到O(1)，如果不希望改变传进来的数组nums，则可以选择牺牲空间的方式。

解法二：分治法

分治法的思路我没有想出来，这里借鉴的是LeetCode题解里一位大佬的思路，下面先贴一下大佬的ID和题解的网址。

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/maximum-subarray/solution/dong-tai-gui-hua-fen-zhi-fa-python-dai-ma-java-dai/

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

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

第 1 部分：子区间 [left, mid]；
第 2 部分：子区间 [mid + 1, right]；
第 3 部分：包含子区间 [mid , mid + 1] 的子区间，即 nums[mid] 与 nums[mid + 1] 一定会被选取。

对它们三者求最大值即可。

下面贴一下参考代码：

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));
    }
}