53.最大子序和+动态规划+分治法

53.最大子序和

双指针滑动窗口法–从前往后遍历

法一：52 ms 15.2 MB Python3

思路：滑动窗口，i,j,记录当前子序端点，lsum：当前子序和。
if lsum<0: break可理解为，一个小于0的序列没资格加入其它序列，没资格与后续序列拼接。

我之前的疑惑：j+=1.

当lsum<0时，说明新添加的nums[j-1]使得之前序列nums[i:j-1](前闭后开）<0，说明之前的序列没法’消化‘nums[j-1]这个负数。所以此时开始抛去前边元素lsum-=nums[i]来试图使子序列可消化nums[j-1]这个负数。（例如：[-9,-3,13,-2],抛去 -9 则可消化 -2.）

j+=1下一个元素j只有当lsum>0时才可被纳入子序列中。所以子序列滑动窗口的移动轨迹已搞清楚。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if len(nums)==1:
            return nums[0]
        i,j=0,0
        lsum=0
        mx=nums[0]
        while i<len(nums):
            while j<len(nums):
                if lsum<0:
                    break
                lsum+=nums[j]
                if lsum>mx:
                    mx=lsum
                j+=1#记录后续元素位置，之前子序列与其无关
                """
                注释部分不影响结果，也不影响逻辑
                if lsum<0:
                	break
                """
            lsum-=nums[i]
            i+=1
        return mx

动态规划法

最大子序和（暴力法 + 分治法 + DP）- Python3

法二：暴力动态规划法，性能优秀。48 ms 15.1 MB Python3

思路：lsum存储当前>0的子序列和。mx存储列表前半部份nums[0,i]中的某个子序列和（其为最大值）。
这种思路中最大子序列成为了黑箱，当然也可记录，把max函数拆分即可。

法一法二的区别与联系：
法二在每轮都获得mx=max(mx,lsum)的情况下，使得其可以在lsum<0时，直接令lsum=nums[j]，而不用一步步试探性的lsum-=nums[i]抛去前边元素,再重新比较（进入while循环，执行if lsum<0:break)。
lsum=nums[i]#本句即可抛却前述负数子序列，从新记录。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        lsum=nums[0]
        mx=lsum
        for i in range(1,len(nums)):
            if lsum<0:
                lsum=nums[i]#本句即可抛却前述负数子序列，从新记录。
                mx=max(mx,lsum)
            else:
                lsum+=nums[i]
                mx=max(mx,lsum)#可提出公共部分
        return mx
        """动态规划思想：前后子序列的递推关系。
        #if lsum>0:等价于
        if lsum+nums[i]>nums[i]:
        	lsum+=nums[i]
		else:
			lsum=nums[i]
		mx=max(mx,lsum)
        """

分治法

法三：分治法，思路优秀，性能一般。120 ms 15.4 MB Python3

思路：左边最大序列和，右边最大序列和，中间最大序列和。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if len(nums)==1:
            return nums[0]
        else:
            max_left=self.maxSubArray(nums[:len(nums)//2])
            max_right=self.maxSubArray(nums[len(nums)//2:])
        temp=max_l=nums[len(nums)//2-1]
        for i in range(len(nums)//2-2,-1,-1):
            temp+=nums[i]
            max_l=max(temp,max_l)
        temp=max_r=nums[len(nums)//2]
        for i in range(len(nums)//2+1,len(nums)):
            temp+=nums[i]
            max_r=max(max_r,temp)
        mx=max_r+max_l
        return max(max_right,max_left,mx)

也可让tmp=0,循环从len(nums)//2-1,len(nums)//2开始。

max_l = nums[len(nums) // 2 - 1]
        tmp = 0
        for i in range(len(nums) // 2 - 1, -1, -1):
            tmp += nums[i]
            max_l = max(tmp, max_l)
        max_r = nums[len(nums) // 2]
        tmp = 0
        for i in range(len(nums) // 2, len(nums)):
            tmp += nums[i]
            max_r = max(tmp, max_r)

动态规划详解

转载于：详细解读动态规划的实现, 易理解

解题思路：
示例: [a, b , c, d , e]
解答这类题目, 省略不掉遍历, 因此我们先从遍历方式说起

通常我们遍历子串或者子序列有三种遍历方式
以某个节点为开头的所有子序列: 如 [a]，[a, b]，[ a, b, c] … 再从以 b 为开头的子序列开始遍历 [b] [b, c]。
根据子序列的长度为标杆，如先遍历出子序列长度为 1 的子序列，在遍历出长度为 2 的 等等。
以子序列的结束节点为基准，先遍历出以某个节点为结束的所有子序列，因为每个节点都可能会是子序列的结束节点，
因此要遍历下整个序列，如: 以 b为结束点的所有子序列: [a , b] [b] 以 c 为结束点的所有子序列: [a, b, c] [b, c] [ c ]。

第一种遍历方式通常用于暴力解法, 第二种遍历方式 leetcode (5. 最长回文子串 ) 中的解法就用到了。

第三种遍历方式 因为可以产生递推关系, 采用动态规划时, 经常通过此种遍历方式, 如 背包问题, 最大公共子串 , 这里的动态规划解法也是以先遍历出 以某个节点为结束节点的所有子序列 的思路

对于刚接触动态规划的, 我感觉熟悉第三种遍历方式是需要抓住的核心

因为我们通常的惯性思维是以子序列的开头为基准，先遍历出以 a 为开头的所有子序列，再遍历出以 b 为开头的…
但是动态规划为了找到不同子序列之间的递推关系，恰恰是以子序列的结束点为基准的，这点开阔了我们的思路。

max_ending_here即lsum.存储以num[i]为终止点的序列最大值。
max_so_far即mx,存储num[0:i+1]序列中某一子序列的最大值。

即可想像有这样一个数组，每个位置上存储的都是以该位置为终止点的序列最大值（即max_ending_here),而max_so_far则是从这么多最大值中选出更大值。

相当于从历史长河中的所有高光点中选出最高光的，从所有伟大人物中选出最伟大的即毛教员。

max_ending_here每个点（阶段）的局部最优解。max_so_far到现在为止的最优解。

动态规划，状态转移方程的实例。

// Kadane算法扫描一次整个数列的所有数值，
// 在每一个扫描点计算以该点数值为结束点的子数列的最大和（正数和）。
// 该子数列由两部分组成：以前一个位置为结束点的最大子数列、该位置的数值。
// 因为该算法用到了“最佳子结构”（以每个位置为终点的最大子数列都是基于其前一位置的最大子数列计算得出, 
// 该算法可看成动态规划的一个例子。
// 状态转移方程：sum[i] = max{sum[i-1]+a[i],a[i]}   
// 其中(sum[i]记录以a[i]为子序列末端的最大序子列连续和)

function  maxSubArray2  ( nums ) {
    if (!nums.length) {
        return;
    };
    // 在每一个扫描点计算以该点数值为结束点的子数列的最大和（正数和）。
    let max_ending_here = nums[0];
    let max_so_far = nums[0];

    for (let i = 1; i < nums.length; i ++ ) {
        // 以每个位置为终点的最大子数列 都是基于其前一位置的最大子数列计算得出,

        max_ending_here = Math.max ( nums[i], max_ending_here + nums[i]);
        max_so_far = Math.max ( max_so_far, max_ending_here);
    };

    return max_so_far;
};

第二块代码和 第一块代码 思路实现是完全一样的，但是如果第一次看到这类题目，直接阅读 第二块代码，理解起来很难，尤其是 如果改成 if (sum > 0 ) 对于刚接触的这题目的比较不好理解。

var maxSubArray = function(nums) {
    let ans = nums[0];
    let sum = 0;
    for(let num of nums) {
        // if(sum > 0) { 可以写成这样
        if(sum + num > num ){
            sum = sum + num;
        } else {
            sum = num;
        }
        ans = Math.max(ans, sum);
    };
    return ans;
};