python求解连续⼦数组的最⼤和（暴⼒、动态规划、贪⼼、分
治）
⽬录
1 问题
给定⼀个整数数组 nums，到⼀个具有最⼤和的连续⼦数组（⼦数组最少包含⼀个元素），返回其最⼤和。
⽰例 1：
输⼊：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续⼦数组[4,-1,2,1] 的和最⼤，为6 。
⽰例 2：
输⼊：nums = [1]
python数组合并
输出：1
⽰例 3：
输⼊：nums = [0]
输出：0
⽰例 4：
输⼊：nums = [-1]
输出：-1
⽰例 5：
输⼊：nums = [-100000]
输出：-100000
提⽰：
1 <= nums.length <= 3 * 104
-105 <= nums[i] <= 105
进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使⽤更为精妙的分治法求解。
2 测试⽤例
nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]  # 6
# nums = [0]
# nums = [-1, -2]
# nums = [1]
# nums = [-100000]
# nums = [5, 4, -1, 7, 8]    # 23
# nums = [2, -1, 2, 1, 3, -2, 1, 2, 1, -2]  # 9
# nums = [9, -4, 2, -5, 8]        # 10
# nums = [-1,-2]
3 求解
3.1 暴⼒1
解析：
分别计算⼦数组个数为1，2,...n 时最⼤⼦数组和。每个⼦数组和都计算⼀遍。
代码：
# 我的题解: 暴⼒⽅法超时
"""
举例，不断取最⼤                          max
-2  1  -3  4  -1  2  1  -5  4      4
-
1  -2  1  3  1  3  -4  -1          3
-4  2  0  5  2  -2  -8              5
0  1  2  6  -3  2                  6
-1  3  3  1  1                      3
1  4  -
2  5                          5
2  -1  2                              2
-3  3                                  3
1                                      1
"""
def maxSubArray1(self, nums: List[int]):
arr = [num for num in nums]
max_num = max(nums)
if len(nums) == 1:
return max_num
for i in range(0, len(nums) - 1):
arr.pop(len(arr) - 1)
for j in range(len(arr)):
arr[j] = arr[j] + nums[j + 1 + i]
max_num = max(max_num, max(arr))
return max_num
3.2 暴⼒2
解析：
将数组转化为 正负......正负正 的形式，可以加快 暴⼒求解速度。代码：
# 我的题解: 暴⼒⽅法未超时
"""
1. 两个相邻的数同号可以合并
2. 如果两端有负数，去掉，保证正数占段头段尾
由此转化成正负数相间的形式
"""
"""
执⾏⽤时：3048 ms, 在所有 Python3 提交中击败了5.06%的⽤户
内存消耗：15.4 MB, 在所有 Python3 提交中击败了47.65%的⽤户
"""
def maxSubArray2(self, nums: List[int]):
# 数组中没有正数就没有合并的必要了
tag = False
for num in nums:
if num > 0:
tag = True
if not tag:
return max(nums)
# 合并相邻同号的数
i = 0
while i < len(nums) - 1:
if nums[i] * nums[i + 1] >= 0:  # 有0的话也合并
nums[i] += nums[i + 1]
nums.pop(i + 1)
continue
i += 1
# 去头尾负数
if nums[0] < 0:
nums.pop(0)
if nums[len(nums) - 1] < 0:
nums.pop(len(nums) - 1)
# 求最⼤
max_num = 0
length = len(nums)
for k in range(0, length, 2):  # 以偶数的形式迭代, 由nums[k]起始
sum_num = nums[k]
max_num = max(max_num, sum_num)
for i in range(2, length, 2):  # nums[k]后的i个数
if k + i < length:
sum_num += nums[k + i] + nums[k + i - 1]
max_num = max(max_num, sum_num)
return max_num
3.3 暴⼒3
解析：
不断在数组中加⼊⼀个新数，每加⼊⼀个新数，计算⼀下当前最⼤的⼦序和。代码：
# 我的题解：暴⼒⽅式超出时间限制，没有突破到动态规划的⽅法上是因为，复⽤了以前数列的最⼤⼦序和，⽽不是以某个数结尾的最⼤⼦序和    def maxSubArray3(self, nums: List[int]):
# 已有数组中加⼊⼀个新数后，计算该数组的最⼤⼦序和
def func(nums, num, max_num):
new_max = float("-inf")
sum_num = num
for i in range(len(nums) - 1, -1, -1):
sum_num += nums[i]
new_max = max(new_max, sum_num)
return max(max_num, num, new_max)
if len(nums) == 1:
return nums[0]
max_num = nums[0]  # 当前数组最⼤⼦序和
new_nums = []
new_nums.append(nums[0])
for i in range(1, len(nums)):
max_num = func(new_nums, nums[i], max_num)
new_nums.append(nums[i])
return max_num
3.4 动态规划
解析：
代码：
#  动态规划
"""
执⾏⽤时：44 ms, 在所有 Python3 提交中击败了57.49%的⽤户
内存消耗：15.2 MB, 在所有 Python3 提交中击败了92.81%的⽤户
"""
def maxSubArray4(self, nums: List[int]):
pre = 0  # 以某个数结尾的最⼤数组和
max_nums = nums[0]  # 当前数组的最⼤⼦序和
for num in nums:
pre = max(pre + num, num)  # 不断迭代 pre ⼗分关键
max_nums = max(max_nums, pre)
return max_nums
3.5 贪⼼算法
解析：
代码：
#  贪⼼算法
"""
如果 sum > 0，则说明 sum 对结果有增益效果，则 sum 保留并加上当前遍历数字
如果 sum <= 0，则说明 sum 对结果⽆增益效果，需要舍弃，则 sum 直接更新为当前遍历数字
"""
"""
执⾏⽤时：36 ms, 在所有 Python3 提交中击败了87.58%的⽤户
内存消耗：15.6 MB, 在所有 Python3 提交中击败了15.76%的⽤户
"""
def maxSubArray5(self, nums: List[int]):
max_nums = nums[0]
sum = 0
for num in nums:
sum = sum + num if sum > 0 else num
max_nums = max(max_nums, sum)
return max_nums
3.6 分治
解析：
代码：
#  分治
"""
lSum 表⽰ [l,r][l,r] 内以 ll 为左端点的最⼤⼦段和
rSum 表⽰ [l,r][l,r] 内以 rr 为右端点的最⼤⼦段和
mSum 表⽰ [l,r][l,r] 内的最⼤⼦段和
iSum 表⽰ [l,r][l,r] 的区间和
"""
"""
执⾏⽤时：72 ms, 在所有 Python3 提交中击败了5.01%的⽤户
内存消耗：15.4 MB, 在所有 Python3 提交中击败了42.36%的⽤户
"""
def maxSubArray6(self, nums: List[int]):
# 查询序列arr[l,r]的最⼤字段和左闭右闭
def getInfo(arr, l, r):
if l == r:
return Status(arr[l], arr[l], arr[l], arr[l])
mid = int((l + r) / 2)
lSub = getInfo(arr, l, mid)
rSub = getInfo(arr, mid + 1, r)
iSum = lSub.iSum + rSub.iSum
lSum = max(lSub.lSum, lSub.iSum + rSub.lSum)  # lSum = max(lSub.lSum, lSub.lSum + rSub.lSum)            rSum = max(lSub.rSum + rSub.iSum, rSub.rSum)
mSum = max(lSub.mSum, rSub.mSum, lSub.rSum + rSub.lSum)
return Status(lSum, rSum, mSum, iSum)
return getInfo(nums, 0, len(nums) - 1).mSum

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。