题目
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。链接
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6
进阶:
如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。
动态规划标签下频率第二高的题目。
解题过程
暴力解法
简单写一下暴力解法的代码，复杂度O(N²)，Swift不会超时，Python超时。。
Swift:
class Solution {
func maxSubArray(_ nums: [Int]) -> Int {
if nums.count == 0 { return 0 }
var res = Int.min
for i in 0.. int:
size = len(nums)
if size == 0:
return 0
res = float('-inf')
for i in range(size):
total = 0
for j in range(i, size):
total += nums[j]
res = max(total, res)
return res
动态规划方法
第一期说到的动态规划问题的思考步骤：
- 定义状态
- 思考状态转移方程
- 确定边界
- 结果输出
从题目来看，强调的是连续子数组，那么可以把状态设置为连续的子数组中的最大值。因为不需要获得具体数组范围，所以不需要二维表。只需要记录当前下标数字为结尾的连续子数组最大和，即dp[i]表示以nums[i]结尾的数组中和最大值。
状态定义好后，需要考虑转移方程了，如何把当前的状态交个它的子状态和当前值来决定？已知的是子数组的和最大值，而当前下标的值nums[i]必须要有，所以只需要考虑子数组的和最大值dp[i - 1]是否对结果有帮助，即是否为正数。
dp[i] = max(dp[i - 1] + nums[i], nums[i])
然后再考虑边界问题，我们要初始化最初的dp，既然转移方程中存在i - 1，那么边界就是i - 1 >= 0。结果输出比较简单，直接看完整代码即可。
Swift:
class Solution {
func maxSubArray(_ nums: [Int]) -> Int {
/*
状态：dp[i]表示以下标i数字为结尾的子数组最大和
转移方程：dp[i] = max(dp[i - 1] + nums[i], nums[i])
边界：i >= 1
结果输出：res = max(dp[i], res)
*/
if nums.count == 0 { return 0 }
var dp = Array(repeating: Int.min, count: nums.count)
var res = Int.min
for i in 0.. int:
size = len(nums)
if size == 0:
return 0
dp = [ float('-inf') for _ in nums ]
res = float('-inf')
for i in range(size):
if i == 0:
dp[i] = nums[i]
else:
dp[i] = max(dp[i - 1] + nums[i], nums[i])
res = max(dp[i], res)
return res
以上代码可以进行空间优化，只需要知道当前下标位置的子数组的最大和即可，无须存储所有下标的最大和，那么dp可以直接用一个int来处理：
Swift:
class Solution {
func maxSubArray(_ nums: [Int]) -> Int {
if nums.count == 0 { return 0 }
var res = Int.min
var dp = Int.min
for i in 0.. int:
size = len(nums)
if size == 0:
return 0
dp = float('-inf')
res = float('-inf')
for i in range(size):
if i == 0:
dp = nums[i]
else:
dp = max(dp + nums[i], nums[i])
res = max(dp, res)
return res
值得一提的是，两种dp方式对于Swift来说，提升几乎看不出，而对于Python来说，性能提升了非常多，怀疑是Swift内部优化过，而Python的生成器对性能有不少影响，纯属猜测。
................................................
本来写了贪心法和分治法的讲解和图示，结果可能页面停留时间太长，发布的时候并没有保存，心态炸裂，只贴一下代码吧。
................................................
贪心法
Swift:
class Solution {
func maxSubArray(_ nums: [Int]) -> Int {
if nums.count == 0 { return 0 }
var total = 0
var res = Int.min
for i in 0.. int:
size = len(nums)
if size == 0:
return 0
total = 0
res = float('-inf')
for i in range(size):
total += nums[i]
res = max(total, res)
if total < 0:
total = 0
return res
分治法
Swift:
class Solution {
func maxSubArray(_ nums: [Int]) -> Int {
if nums.count == 0 { return 0 }
return helper(nums, 0, nums.count - 1)
}
func helper(_ nums: [Int], _ left: Int, _ right: Int) -> Int {
if left == right {
return nums[left]
}
let mid = (left + right) / 2
// 左侧
let leftMax = helper(nums, left, mid)
// 右侧
let rightMax = helper(nums, mid + 1, right)
// 中间
/// 从中间点向左求最大和
var midMaxL = Int.min
var total = 0
for i in (left...mid).reversed() {
//// 必须包含中间点，所以不是贪心算法，无须total归零
total += nums[i]
midMaxL = max(total, midMaxL)
}
/// 从中间向右求最大和
var midMaxR = Int.min
total = 0
for i in (mid + 1)...right {
total += nums[i]
midMaxR = max(total, midMaxR)
}
let midMax = midMaxL + midMaxR
var res = max(leftMax, rightMax)
res = max(res, midMax)
return res
}
}
Python3:
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
size = len(nums)
if size == 0:
return 0
return self.__helper(nums, 0, size - 1)
def __helper(self, nums, left, right):
if left == right:
return nums[left]
mid = (left + right) // 2
leftMax = self.__helper(nums, left, mid)
rightMax = self.__helper(nums, mid + 1, right)
midMaxL = float('-inf')
total = 0
for i in range(mid, left - 1, -1):
total += nums[i]
midMaxL = max(total, midMaxL)
total = 0
midMaxR = float('-inf')
for i in range(mid + 1, right + 1):
total += nums[i]
midMaxR = max(total, midMaxR)
midMax = midMaxL + midMaxR
res = max(leftMax, rightMax)
res = max(res, midMax)
return res