1、JZ42 ——连续子数组的最大和

要求：

输入一个长度为n的整型数组nums，数组中的一个或连续多个整数组成一个子数组，子数组最小长度为1。求所有子数组的和的最大值。

输入：[1,-2,3,10,-4,7,2,-5]

返回值：18

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

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

典型的动态规划问题。题目有一个进阶的要求，我们先解决空间复杂度为O(n)，再在这基础上进行优化就会通透很多了。

我们通过4个步骤来进行分析：

1、确定dp数组（dp table）以及下标的含义：

        用dp[i] 表示代表以第 i 个数结尾的「连续子数组的最大和」。

只需要求出每个位置的 dp[i]，然后返回dp数组中的最大值即可。

2、确定递推公式

dp[i - 1] + nums[i] 和 nums[i] 的大小，我们希望获得一个比较大的，于是可以写出这样的动态规划转移方程：

  dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);

3、dp数组如何初始化

        dp数组的初始化要根据dp的含义来确定，因此我们可以确定dp[0] = nums[0]。因为我们要求每个dp[i]的最大值，所以其余全部初始化为最小值就好辣，在js中-Infinity表示负无穷，我们可以用它来初始化。

4、确定遍历顺序

        由转移方程我们可以知道，dp[i]是由dp[i-1]推出来的，所哟从前向后遍历就好辣~

分析完了，这样不难给出一个时间复杂度 O(n)、空间复杂度 O(n) 的实现，即用一个dp数组来保存 dp[i]的值，用一个循环求出所有dp[i]。

空间复杂度为O(n)的完整代码：

var maxSubArray = function (nums) {
            let dp = new Array(nums.length).fill(-Infinity);
            dp[0] = nums[0];
            let max = dp[0]; // 记录dp数组中的最大值
            for (let i = 1; i < nums.length; i++) {
                dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
                max = Math.max(max, dp[i]);
            }
            // console.log(dp);
            return max;
};

考虑到dp[i]只和dp[i-1]相关，于是我们可以只用一个变量pre来维护对于当前dp[i] 的dp[i-1]的值是多少，从而让空间复杂度降低到 O(1)，这有点类似「滚动数组」的思想。

空间复杂度为O(1)的完整代码：

var maxSubArray = function (nums) {
                let pre = nums[0],max = pre;
                for (let i = 1; i < nums.length; i++) {
                    pre = Math.max(pre+nums[i],nums[i]);
                    max = Math.max(max,pre);
                }
                // console.log(dp);
                return max;
};

2、连续子数组的最大和（进阶版）

要求：

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

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

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

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

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

输入：[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]

dp[i]=max(dp[i−1]+array[i],array[i])，这是最基本的求连续子数组的最大和。

但是题目要求需要返回长度最长的一个，我们则每次用left、right记录该子数组的起始，需要更新最大值的时候（要么子数组和更大，要么子数组和相等的情况下区间要更长）顺便更新最终的区间首尾，这样我们的区间长度就是最长的。

完整代码：

function FindGreatestSumOfSubArray(array) {
            // write code here
            let dp = new Array(array.length).fill(-Infinity);
            dp[0] = array[0];
            let max = dp[0];
            // 滑动区间
            let left = 0,right = 0;
            // 记录最大的区间
            let maxL = 0,maxR = 0;
            for (let 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] > max || dp[i] == max && (right-left+1) > (maxR-maxL+1)){
                    max = dp[i];
                    maxL = left;
                    maxR = right;
                }
            }
            // console.log(dp);
            // 取数组
            let resArr = new Array(maxR-maxL+1);
            for(let i = maxL;i<= maxR;i++){
                resArr[i- maxL] = array[i];
            }
            return resArr;
}