【Leetcode】53. 最大子序和(子序列连续)NC166 连续子数组的最大和(二) (子序列连续)

总结连续子数组最大和心得

1.Leetcode53 / NC19连续子数组的最大和

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

2.NC166 连续子数组的最大和(二)

//dp状态转移并且更新起点
if(dp[i-1]+array[i]<array[i]){
    left = i;
    right = i;
    dp[i] = array[i];
}else if(dp[i-1]+array[i]>array[i]){
    right = i;
    dp[i] = dp[i-1]+array[i];
}else if(dp[i-1]+array[i]==array[i]){
    right = i;
    dp[i] = array[i];
}
//更新区间
if(dp[i]>maxSum || (dp[i]==maxSum&&(right-left)>(maxRight-maxLeft))){
    maxSum = dp[i];
    maxLeft = left;
    maxRight = right;
}

//dp状态转移并且更新起点
dp[i] = Math.max(dp[i-1]+array[i], array[i]);
right = i;
if(dp[i-1]+array[i]<array[i]){
    left = i;
}
//更新区间
if(dp[i]>maxSum || (dp[i]==maxSum&&(right-left)>(maxRight-maxLeft))){
    maxSum = dp[i];
    maxLeft = left;
    maxRight = right;
}

3.对比总结

我们发现不管是只需要求最长子数组和的长度，还是需要求子数组本身，无非分两步走

1.状态转移
array[i] = Math.max(array[i], array[i]+array[i-1])
2.更新所有dp[i]的最大值
max = Math.max(array[i], max)

只不过后面一题，在两步走，之中多丰富了一点东西，多记录了一点东西，但说到底还是两步走
1.状态转移+更新区间
2.更新dp[i]的最大值+更新最大值区间
看下其实你会发现就多了一个记录区间和更新最大值区间

Leetcode53 / NC19连续子数组的最大和

1.问题描述

2.解决方案

解法一：dp

两份代码，第二份把Max设置为了nums[0]，省去一次判断

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()<=1) return nums[0];

        //1.边界
        int len=nums.size();
        int dp[len];
        for(int i=0;i<len;i++){
            dp[i]=nums[i];
        }

        //2.这找出了以nums[1]...nums[len-1]结尾的最大值
        int Max=-0xFFFFFF;
        for(int i=1;i<len;i++){
            dp[i]=max(dp[i],dp[i-1]+dp[i]);
            if (dp[i]>Max) Max=dp[i];
        }

        //3.以nums[1]...nums[len-1]结尾的最大值和nums[0]比较
        return Max>nums[0]?Max:nums[0];

    }
};

class Solution1 {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()<=1) return nums[0];

        //1.边界
        int len=nums.size();
        int dp[len];
        for(int i=0;i<len;i++){
            dp[i]=nums[i];
        }

        //2.这找出了以nums[0]...nums[len-1]结尾的最大值
        int Max=nums[0];
        for(int i=1;i<len;i++){
            dp[i]=max(dp[i],dp[i-1]+dp[i]);
            if (dp[i]>Max) Max=dp[i];
        }

        //3.
        return Max;

    }
};

Java精简写法

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        int max = array[0];
        for(int i=1;i<array.length;i++){
           array[i] = Math.max(array[i], array[i]+array[i-1]);
           max = Math.max(array[i], max);
        }
        return max;
    }
}

解法二：dp(官方优化)

优化在于使用pre作为之前的，dp[n-1]，非常巧妙的既节省了空间，又省去了边界的判断，在dp中，dp数组经常可以使用这种方法进行优化

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre = 0, maxAns = nums[0];
        for (const auto &x: nums) {
            pre = max(pre + x, x);
            maxAns = max(maxAns, pre);
        }
        return maxAns;
    }
};

NC166 连续子数组的最大和(二)

1.问题描述

2.解决方案

题解链接

这道题呢，其实说白了就是求最大连续子数组和的这个子数组，还要求最长，所以其实主要的状态转移肯定还是一样的，
但是需要多记录一个最长区间 + 包括上一题就需要的全程记录dp[i]的最大值的maxSum也需要记录。
主要分为两个难点：

1.dp状态转移并且还要更新区间

主要分为三种情况吧：
1.如果dp[i-1]+array[i]<array[i] 说明当前区间应该变为[i, i] （相当于更新left和right）
2.如果dp[i-1]+array[i]>array[i] 说明当前区间应该变为[left, i]（只更新right）
3.如果dp[i-1]+array[i]==array[i] 因为要求的是最长的子数组最大和 所以区间尽可能大 说明当前区间应该也变为[left, i] （只更新right）

//dp状态转移并且更新起点
if(dp[i-1]+array[i]<array[i]){
    left = i;
    right = i;
    dp[i] = array[i];
}else if(dp[i-1]+array[i]>array[i]){
    right = i;
    dp[i] = dp[i-1]+array[i];
}else if(dp[i-1]+array[i]==array[i]){
    right = i;
    dp[i] = array[i];
}

//dp状态转移并且更新起点
dp[i] = Math.max(dp[i-1]+array[i], array[i]);
right = i;
if(dp[i-1]+array[i]<array[i]){
    left = i;
}

2.更新所有dp[i]的最大值，也就是以每一个i结尾的最大值，并且更新最大区间

上一道题可能我们求最大值就直接maxSum = Math.max(maxSum, dp[i])
但是这一道题不一样，如果dp[i]>maxSum当然要更新最大值，但是当等于的时候，也要判断区间是不是增加了，如果增加了也要更新
所以就是如果dp[i]大于当前最大值，或者等于最大值，但是当前区间大于之前的最大区间都要更新

//更新区间
if(dp[i]>maxSum || (dp[i]==maxSum&&(right-left)>(maxRight-maxLeft))){
    maxSum = dp[i];
    maxLeft = left;
    maxRight = right;
}

3.代码实现

import java.util.*;


public class Solution {
    public int[] FindGreatestSumOfSubArray (int[] array) {
        //dp初始化
        int len = array.length;
        int[] dp = new int[len];
        dp[0] = array[0];
        
        //记录最大值
        int maxSum = dp[0];
        int maxLeft = 0;
        int maxRight = 0;
        
        //滑动区间
        int left = 0;
        int right = 0;
        
        //遍历
        for(int i=1;i<len;i++){
            //dp状态转移并且更新起点
            if(dp[i-1]+array[i]<array[i]){
                left = i;
                right = i;
                dp[i] = array[i];
            }else if(dp[i-1]+array[i]>array[i]){
                right = i;
                dp[i] = dp[i-1]+array[i];
            }else if(dp[i-1]+array[i]==array[i]){
                right = i;
                dp[i] = array[i];
            }
            //更新区间
            if(dp[i]>maxSum || (dp[i]==maxSum&&(right-left)>(maxRight-maxLeft))){
                maxSum = dp[i];
                maxLeft = left;
                maxRight = right;
            }
        }
        
        //res
        int[] res = new int[maxRight-maxLeft+1];
        for(int i = maxLeft;i<=maxRight;i++){
            res[i-maxLeft] = array[i];
        }
        return res;
    }
}

精简写法

import java.util.*;


public class Solution {
    public int[] FindGreatestSumOfSubArray (int[] array) {
        //dp初始化
        int len = array.length;
        int[] dp = new int[len];
        dp[0] = array[0];
        
        //记录最大值
        int maxSum = dp[0];
        int maxLeft = 0;
        int maxRight = 0;
        
        //滑动区间
        int left = 0;
        int right = 0;
        
        //遍历
        for(int i=1;i<len;i++){
            //dp状态转移并且更新起点
            dp[i] = Math.max(dp[i-1]+array[i], array[i]);
            right = i;
            if(dp[i-1]+array[i]<array[i]){
                left = i;
            }
            //更新区间
            if(dp[i]>maxSum || (dp[i]==maxSum&&(right-left)>(maxRight-maxLeft))){
                maxSum = dp[i];
                maxLeft = left;
                maxRight = right;
            }
        }
        
        //res
        int[] res = new int[maxRight-maxLeft+1];
        for(int i = maxLeft;i<=maxRight;i++){
            res[i-maxLeft] = array[i];
        }
        return res;
    }
}