LeetCode-53-最大子序和
LeetCode-53-最大子序和
题意描述：
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
进阶: 如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。
示例：
示例 1：
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
解题思路：
Alice：这道题目也很熟悉啊。
Bob: 对啊，大二的算法课讲动态规划的话基本上一定会讲这个例子的。
Alice: 动态规划 ？ Dynamic planning ? ?
Bob： 对啊，我们先来看看题目吧。求一个连续子数组的最大和，我们可以暴力求解。
Alice: 那样的话，要写一个双层循环了，外面的 i 从 0 到数组末尾， 里面的 j 从 i+1 到数组末尾。
Bob: 我们可以用前序和来省略一些计算，前序和是这样的，假如我们有一个数组[1,2,3,4] 这个数组对应的前序和数组就是[1, 3, 6, 10] 前序和数组中第 i 个元素就是 原数组 中前 i 个元素的和。这样的话，如果我们想要求原数组中 第 j 个元素到第 k 个元素的和，只要用前序和数组中的 第 k 个元素减去 第 j-1 个元素就可以了。
Alice: 这样就能省略计算吗 ？
Bob: 对啊，还是拿[1, 2, 3, 4]来举例子吧， 假如我要算[1, 2] 的和，要计算 1 + 2 ，要计算[1, 2, 3] 的和就要计算1+ 2 + 3，1 + 2 就被重复计算了呀。用前序和算的话，每个元素都只被加了一次，求任意的子数组的和只要一个减法就够了。
Alice： 但是前序和也是O(n^2) 的两重循环啊。
Bob: 是啊，虽然减少了计算量，不过前序和 + 暴力求解应该还是会超时的。
Alice: 这题不是动态规划吗 ？ 你还记得动态规划的写法吗 ？
Bob: 不记得了，不过我们可以现写一个啊。
Alice: 我记得动态规划的核心就是递推公式，递推公式有点像数学里面的那个 归纳法 里面的那个从 n 推出 n+1 的情况。
Bob: 从 n 推出 n + 1 ?? 假设我们现在已经求出了前 n 个元素的最大子序和，把第 n+1 个 元素加上 ？？
Alice: 不对呀，最大子序和要求的是连续的子数组啊， 前 n 个元素对应的最大子序和 对应的子数组不一定是 以 第 n 个元素结尾的啊。
Bob: 是啊，那就假设我们已经求出了 以 第 n 个元素为结尾的子数组的最大子序和吧，然后现在我们面对一个选择。
Alice: 对于以 第 n+1 个元素为结尾的子数组的子序和 要不要加上 前面 n 个元素的最大子序和 ？ 以第 n+1 个元素为结尾的子序和既可以是 只有 第 n+1 个元素， 也可以是连接上 前面的一些元素。
Bob: 对，如果 以第 n 个元素为结尾的子数组的最大子序和 <= 0 就不加了，加了也只能减小以第 n+1 个元素为结尾的子序和。
Alice: w(ﾟДﾟ)w 我们已经把递推公式写出来了。
if dp[n] > 0：
dp[n+1] = dp[n] + nums[n+1]
else:
dp[n+1] = nums[n+1]
Bob: w(ﾟДﾟ)w 对啊，(๑•̀ㅂ•́)و✧
Alice: 动态规划就是O(n)的了，好快啊。那你会写什么 更精妙的 分治法吗？
Bob: (・ω・｀ll) 明天就会写了。
代码：
Python 方法一 ： 动态规划
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
if len(nums) == 0:
// 若nums 长度为0，那么最大子序和一定是0
return 0
else:
answers = [x for x in nums]
// answers[x] 用来记录 以 nums[x] 为结尾的前面的子数组的最大子序和
for x in range(1, len(nums)):
if answers[x-1] <= 0:
// 如果以nums[x-1]为结尾的子数组的最大子序和是个负数，那么以nums[x]为结尾的子数组的最大子序和就是 nums[x] 自身
answers[x] = nums[x]
else:
answers[x] = answers[x-1] + nums[x]
// 否则以nums[x] 为结尾的子数组的最大子序和应该加上以nums[x-1]为结尾的子数组的最大子序和，就是延续。
return max(answers)
Python 方法二： 前序和 + 暴力求解，确认超时 ！！！
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
if len(nums) == 0:
return 0
else:
preSums = [0]
preSum = 0
for x in range(0, len(nums)):
preSum += nums[x]
preSums.append(preSum)
ret = nums[0]
for x in range(0, len(preSums)):
for z in range(x+1, len(preSums)):
if(preSums[z] - preSums[x] > ret):
ret = preSums[z] - preSums[x]
return ret
Java 方法一： 动态规划
class Solution {
public int maxSubArray(int[] nums) {
if(nums.length == 0){
return 0;
}else{
int subsequenceSum = nums[0]; // 记录以nums[x]为结尾元素的子数组的最大子序和
int ret = subsequenceSum; // nums数组的最大子序和
for(int i=1; i<nums.length; ++i){
if(subsequenceSum <= 0){ // 动态规划之核心的递推公式
subsequenceSum = nums[i];
}else{
subsequenceSum += nums[i];
}
if(subsequenceSum > ret){ // “打擂台”得到一个最大值
ret = subsequenceSum;
}
}
return ret;
}
}
}
c++ 方法一： 动态规划
class Solution {
public:
int maxSubArray(vector<int>& nums) {
if(nums.size() == 0){
return 0;
}else{
int subSum = nums[0];
int maxSubSum = subSum;
for(int i=1; i<nums.size(); ++i){
if(subSum <= 0){
subSum = nums[i];
}else{
subSum += nums[i];
}
if(maxSubSum < subSum){
maxSubSum = subSum;
}
}
return maxSubSum;
}
}
};
易错点：
- 一些测试样例：
[-2,1,-3,4,-1,2,1,-5,4]
[0]
[1,2,3]
[-1,-2, -3]
[-2, 1, 0, 4]
- 暴力方法可能会超时，不过可以用 数组的 前序和 来试一试。
总结：
最大子序和，将前面积累的和为负的子数组抛弃，将新的元素作为子序和的开头。此之谓，当断而断。