连续子数组的最大和（二）

剑指offer的一道经典题目，难度中等。

描述

输入一个长度为n的整型数组array，数组中的一个或连续多个整数组成一个子数组，找到一个具有最大和的连续子数组。

1.子数组是连续的，比如[1,3,5,7,9]的子数组有[1,3]，[3,5,7]等等，但是[1,3,7]不是子数组

2.如果存在多个最大和的连续子数组，那么返回其中长度最长的，该题数据保证这个最长的只存在一个

3.该题定义的子数组的最小长度为1，不存在为空的子数组，即不存在[]是某个数组的子数组

4.返回的数组不计入空间复杂度计算

数据范围:

1<=n<=105

−100<=a[i]<=100

要求:时间复杂度O(n)，空间复杂度O(n)

进阶:时间复杂度O(n)，空间复杂度O(1)

示例1

输入：

[1,-2,3,10,-4,7,2,-5]

返回值：

[3,10,-4,7,2]

说明：

经分析可知，输入数组的子数组[3,10,-4,7,2]可以求得最大和为18，故返回[3,10,-4,7,2]   

示例2

输入：

[1]

返回值：

[1]

示例3

输入：

[1,2,-3,4,-1,1,-3,2]

返回值：

[1,2,-3,4,-1,1]

说明：

经分析可知，最大子数组的和为4，有[4],[4,-1,1],[1,2,-3,4],[1,2,-3,4,-1,1]，故返回其中长度最长的[1,2,-3,4,-1,1]   

示例4

输入：

[-2,-1]

返回值：

[-1]

说明：

子数组最小长度为1，故返回[-1]   

需要的知识点：动态规划

动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果。这和我们之前讲的分治法是有区别的。

分治法的基本思想是将一个问题分解成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。分治法的一个关键特征是子问题是相互独立的，一个子问题的解不会影响另一个子问题的解。典型例子包括快速排序、归并排序等。

动态规划也是通过把原问题分解为相对简单的子问题来求解。但是，与分治法不同的是，动态规划通常用于存在重叠子问题的情况，也就是说，在解决问题的过程中，相同的子问题会被多次遇到。为了避免重复计算这些子问题，动态规划会保存已经解决过的子问题的答案，并在需要时重用这些答案。这种方法也被称为“记忆化”（Memoization）。此外，动态规划还适用于具有最优子结构的问题，这意味着问题的最优解可以从其子问题的最优解构造出来。常见的动态规划应用有背包问题、最长公共子序列问题等。

尽管两者都涉及到将问题分解成更小的部分来解决，但动态规划特别强调对重叠子问题的优化处理以及利用最优子结构来构建全局最优解。因此，虽然动态规划有时可能看起来像是用了分治的思想，但它实际上是一种不同的方法，更加注重于效率上的优化和子问题间的依赖关系。

思路：

因为要求的是连续子数组，我们如果求得了当前子数组的和，再往后看一个元素：我们先加上它，再拿加上后的子数组值和它自己做比较，如果它自己更大，那就将它设为新一个子数组的起点。否则它就加在我们的原子数组上。

我们可以新建一个dp数组，dp[i]就表示到这点时的最大连续子数组和。每到一个新的点，我们就进行一次赋值：dp[i]=max(dp[i−1]+array[i],array[i])

又因为题目要求的是返回长度更长的子数组，所以我们用left、right记录该子数组的起始，当需要更新最大值时，我们再更新left、right值即可

具体做法：

• 第一步：创建动态规划辅助数组，记录到下标i为止的最大连续子数组和，下标为0的时候，肯定等于原数组下标为0的元素。
• 第二步：准备左右区间双指针记录每次连续子数组的首尾，再准备两个双指针记录最大和且区间最长的连续子数组的首尾。
• 第三步：遍历数组，对于每个元素用上述状态转移公式记录其dp值，更新区间首尾（如果需要）。
• 第四步：出现一个最大值。且区间长度更大的时候，更新记录最长区间的双指针。
• 第五步：根据记录的最长子数组的位置取数组。 

Java实现代码：

import java.util.*;
public class Solution {
    public int[] FindGreatestSumOfSubArray (int[] array) {
        //记录到下标i为止的最大连续子数组和
        int[] dp = new int[array.length];
        dp[0] = array[0];
        int maxsum = dp[0];
        //滑动区间
        int left = 0, right = 0; 
        //记录最长的区间
        int resl = 0, resr = 0; 
        for(int i = 1; i < array.length; i++){
            right++;
            //状态转移：连续子数组和最大值
            dp[i] = Math.max(dp[i - 1] + array[i], array[i]); 
            //区间新起点
            if(dp[i - 1] + array[i] < array[i])
                left = right;
            //更新最大值
            if(dp[i] > maxsum || dp[i] == maxsum && (right - left + 1) > (resr - resl + 1)){ 
                maxsum = dp[i];
                resl = left;
                resr = right;
            }
        }
        //取数组
        int[] res = new int[resr - resl + 1];
        for(int i = resl; i <= resr; i++) 
            res[i - resl] = array[i];
        return res;
    }
}

复杂度分析：

• 时间复杂度：O(n)，其中nn为数组长度，两次遍历，最坏情况下单独遍历两次数组
• 空间复杂度：O(n)，动态规划辅助数组长度为n

进阶方法：

其实你可以发现我们在求dp[i]时要用到的只有dp[i-1]。所以我们可以用变量x和y来替代它们来节省算法的空间。

Java实现代码：

import java.util.*;
public class Solution {
    public int[] FindGreatestSumOfSubArray (int[] array) {
        int x = array[0];
        int y = 0;
        int maxsum = x;
        //滑动区间
        int left = 0, right = 0; 
        //记录最长的区间
        int resl = 0, resr = 0; 
        for(int i = 1; i < array.length; i++){
            right++;
            //状态转移：连续子数组和最大值
            y = Math.max(x + array[i], array[i]); 
            //区间新起点
            if(x + array[i] < array[i]) 
                left = right;
            //更新最大值
            if(y > maxsum || y == maxsum && (right - left + 1) > (resr - resl + 1)){ 
                maxsum = y;
                resl = left;
                resr = right;
            }
            //更新x的状态
            x = y; 
        }
        //取数组
        int[] res = new int[resr - resl + 1];
        for(int i = resl; i <= resr; i++) 
            res[i - resl] = array[i];
        return res;
    }
}

复杂度分析：

• 时间复杂度：O(n)O(n)，两次遍历，最坏情况下遍历两次数组
• 空间复杂度：O(1)O(1)，常数级变量，无额外辅助空间