45 连续子数组的最大和--剑指offer--python实现

最新推荐文章于 2021-06-01 17:32:11 发布

csdn_SUSAN

最新推荐文章于 2021-06-01 17:32:11 发布

阅读量439

点赞数

分类专栏：剑指offer+LeetCode 文章标签：连续子数组最大和剑指offer python实现

本文链接：https://blog.csdn.net/CSDN_SUSAN/article/details/102980079

版权

剑指offer+LeetCode 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

本文探讨了一维模式识别中的经典问题——计算连续子向量的最大和，尤其是在数组包含正负数时的解决方案。介绍了三种解决策略：三重遍历、找规律一次遍历和动态规划，对比了它们的时间复杂度与空间复杂度，最终推荐使用动态规划作为最优解。

摘要由CSDN通过智能技术生成

1. 题目描述

描述：HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。
给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

2. 题目解析

2.1 考察问题

此问题考察数组遍历，找求和规律。
最简单办法，两层遍历，枚举所有可能情况，比较得到最大和。时间复杂度 $O(n^2)$ ，空间复杂度 $O (1)$
进一步优化，问题中有一个特点：数组一定是有正有负的。说明最大和一定大于0，利用这个特点，后边通过遍历一次求的max。
如果没有有正有负的特点，那么动态规划，是解决该问题的终极最简办法。

2.2 解决办法

三重遍历，枚举比较
此方法想法简单，外层遍历子数组长度；中层遍历所有该长度的子数组和，比较得到最大值；最内层遍历求该长度连续子数组和。
时间复杂度 $O(n^3)$ ，空间复杂度 $O (1)$
到这里，时间复杂度太高
找规律一次遍历
由于数组中元素有正有负，则取一个变量记录当前子数组的和curSum，每次考察curSum，当大于零则直接加下一个元素array[i]，小于等于0则更新curSum=array[i]，每次比较更新最大值max。
时间复杂度为 $O (n)$ ，空间复杂度为 $O (1)$
动态规划
动态规划光用脑子想不大好明白，可以用笔画一画。
数组元素为n个，则将问题划分为n个步骤。每一步都考察加上array[i]的连续数组和（类似curSum）与 array[i]的大小比较，更新连续子数组和，然后更新全局的最大值。
以数组[6, -3, -2, 7, -15, 1, 2, 2]为例：

初始状态(i = 0)：

F（0）=6
res=6

i=1：

F（1）=max（F（0）-3，-3）=max（6-3，3）=3
res=max（F（1），res）=max（3，6）=6

i=2：

F（2）=max（F（1）-2，-2）=max（3-2，-2）=1
res=max（F（2），res）=max（1，6）=6

i=3：

F（3）=max（F（2）+7，7）=max（1+7，7）=8
res=max（F（2），res）=max（8，6）=8

i=4：

F（4）=max（F（3）-15，-15）=max（8-15，-15）=-7
res=max（F（4），res）=max（-7，8）=8

3. 代码实现

3.1 三重遍历

class Solution:
    def FindGreatestSumOfSubArray(self, array):
        # write code here
        maxSum = -9999
        for i in range(1, len(array) + 1):
            # for j in range(0, len(array)):
            maxSum = max(maxSum, max([sum(array[j:j+i]) for j in range(0, len(array))])) ### 看起来貌似两重遍历，其实是三重遍历
        return maxSum

3.2 找规律一次遍历

class Solution:
    def FindGreatestSumOfSubArray(self, array):
        # write code here
        curSum = 0
        maxSum = -99999 ### 取一个足够小的值即可
        for num in array:
            if curSum <= 0:### 真正用代码实现的时候，我发现这行代码其实等价于 curSum + num <= num，和动态规划一个意思。
                curSum = num
            else:
                curSum = curSum + num          
            if curSum > maxSum:
                maxSum = curSum
        return maxSum

3.3 动态规划

class Solution:
    def FindGreatestSumOfSubArray(self, array):
        curSum = array[0]
        maxSum = array[0]
        for i in range(1, len(array)):
            curSum = max(curSum+array[i], array[i])
            maxSum = max(curSum, maxSum)
        return maxSum

4. 心得

所有涉及到n个步骤考察的问题，可以考虑贪心算法，动态规划或者干脆回溯算法枚举所有可能情况。
这个问题是动态规划的典型问题，可能方法2并不容易想到，但是当写完动态规划的时候，回头看方法2就一目了然了。
可以继续看一下最大子矩阵和，https://www.nowcoder.com/questionTerminal/a5a0b05f0505406ca837a3a76a5419b3