【leetcode.53】最大子序和

                                                   最大子序和

一、要求

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

示例:

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

进阶:

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

---

二、解法

（1）暴力破解法，时间复杂度为O(n^3)，在LeetCode上提交后，直接显示超时，但确实是最容易想到的方法。

public int maxSubArray(int[] nums) {
        int len = nums.length;
        int maxSum = nums[0];
        int sum = 0;
        for (int i = 0; i < len; i++) {
            for (int j = i; j < len; j++) {
                sum = 0;
                for (int k = i; k <= j; k++) {
                    sum += nums[k];
                }
                if (sum > maxSum) {
                    maxSum = sum;
                }
            }
        }
        return maxSum;
    }

（2）暴力破解法改进，上一个方法存在重复计算，这一次我们用个变量暂存之前的运算结果，此时的时间复杂度可缩小为O(n^2)。

public int maxSubArray(int[] nums) {
        int len = nums.length;
        int maxSum = nums[0];
        int sum = 0;
        for (int i = 0; i < len; i++) {
            sum = 0;
            for (int j = i; j < len; j++) {
                sum = sum + nums[j];
                if (sum > maxSum) {
                    maxSum = sum;
                }
            }
        }
        return maxSum;
    }

（3）动态规划法，可将时间复杂度缩小到O(n)。

假设sum（i，j）表示nums数组中从i到j的元素之和，那么我们必须遵循的条件是sum（i，j-1）>0，我们可以认为sum（i，j）有可能是最大子序和，需要和其他满足这个条件的情况进行比较。如果sum（i，j-1）<0，我们就抛弃nums[i]到nums[j-1]之间的元素（两端也抛弃，抛弃之前，先与最大值进行比较，防止出现数组全负数的情况）。再从nums[j]开始，即求sum（j，k）的最大值，如果sum（i，k-1）<0，我们就再从nums[k]开始，以此类推。

由于不需要像以前动态规划需要保存之前运算的结果，而仅需要保存上一次运行的结果，因此，空间复杂度也很小。

public int maxSubArray(int[] nums) {
        int len = nums.length;
        int maxSum = nums[0];
        int cur = nums[0];
        for (int i = 1; i < len; i++) {
            if (cur > 0) {
                cur += nums[i];
            } else {
                cur = nums[i];
            }
            if (cur > maxSum) {
                maxSum = cur;
            }
        }
        return maxSum;
    }