力扣--53. 最大子序和(简单题)--贪心、动规

@[TOC](力扣–53. 最大子序和(简单题)–贪心、动规)
这题刚开始的时候，没有什么头绪，想到的都是很复杂的，也不想写，就直接看了解答，才恍然大悟，有这么多种解法，算法课真的是白上了，一年时间全忘了。。。

【题目描述】

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

原题传送门

【示例】

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [0]
输出：0

示例 4：

输入：nums = [-1]
输出：-1

示例 5：

输入：nums = [-100000]
输出：-100000

提示：
$$1\le nums.length\le 3\ast 10^4$$
$$-10^5\le nums[i]\le 10^5$$

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法 求解。

由于这题自己不会写，直接看了解答。
这里附上解答链接：官方解答

【贪心】

首先是贪心法，大致的思想就是判断当前和是否大于0，如果大于0，就加上目前的值，如果小于0，就把它丢弃换成当前值。因为最终是要找到最大的和，而且序列必须是连续的，所以如果当前数之前的和是大于0，那么加上他以后，一定会比当前这个数字大。同样，加上一个小于0的数字，还不如不加。在每次遍历一个数字的时候，判断一下这个和是不是比最大和大就好了。
根据解答提供的思路，自己敲了一份代码：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()==0){
            return 0;
        }
        if(nums.size()==1){
            return nums[0];
        }
       int ans=nums[0];//最大和
       int sum=nums[0];//当前和
    for (int i=1;i<nums.size();i++){
        if(sum>0){
            sum=sum+nums[i];
            if(sum>ans){
                ans=sum;
            }
        }
        else{
            sum=nums[i];
            if(sum>ans){
                ans=sum;
            }
        }
        }
        return ans;
    }
};

执行结果：

总的来说，贪心法还是很棒的。

【动态规划】

接下来是动态规划的方法。
递归方程：
$$f(i)=max(f(i-1)+nums[i],nums[i])$$
有一说一，感觉大致的思想和贪心蛮像的，不过这里用原数组来存储每个和，减少了空间消耗。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()==0){
            return 0;
        }
        if(nums.size()==1){
            return nums[0];
        }
       for(int i=1;i<nums.size();i++){
           if(nums[i-1]>0){
               nums[i]+=nums[i-1];
           }
       }
       int ans=nums[0];
       for(int i=1;i<nums.size();i++){
           if(nums[i]>ans){
               ans=nums[i];
           }
       }
        return ans;
    }
};

运行结果：

感觉时间和空间都比贪心多一点？？？