53最大子序和easy

#53easy
code1:
class Solution {
    public int maxSubArray(int[] nums) {
       int res=Integer.MIN_VALUE,curSum=0;
        for(int num:nums){
            curSum=Math.max(num+curSum,num);
            res=Math.max(curSum,res);
        }
        return res;
    }
}
code2:divide and conquer approach
public class Solution {
    public int maxSubArray(int[] nums) {
        if (nums.length == 0) return 0;
        return helper(nums, 0, nums.length - 1);
    }
    public int helper(int[] nums, int left, int right) {
        if (left >= right) return nums[left];
//int mid=left+(right-left)/2;
        int mid = (left + right) >> 1;
        int lmax = helper(nums, left, mid - 1);
        int rmax = helper(nums, mid + 1, right);
        
        int mmax = nums[mid], t = mmax;
        for (int i = mid - 1; i >= left; --i) {
            t += nums[i];
            mmax = Math.max(mmax, t);
        }
        t = mmax;
        for (int i = mid + 1; i <= right; ++i) {
            t += nums[i];
            mmax = Math.max(mmax, t);
        }
        return Math.max(mmax, Math.max(lmax, rmax));
    }
}
code3：动态规划求解，利用dp数组
//动态规划中包含3个重要的概念：
// 1.最优子结构 2.边界 3.状态转移公式 以跳台阶为例，
//最优子结构为f(10)=f(9) + f(8)，边界是f(1)=1, f(2)=2，
//状态转移公式f(n)=f(n-1) + f(n-2)
public class Solution {
    public int maxSubArray(int[] nums) {
        int len = nums.length;
        if (len == 0) {
            return 0;
        }
        int[] dp = new int[len];
        dp[0] = nums[0];

        for (int i = 1; i < len; i++) {
            if (dp[i - 1] >= 0) {
                dp[i] = dp[i - 1] + nums[i];
            } else {
                dp[i] = nums[i];
            }
        }
        // 最后不要忘记全部看一遍求最大值
        int res = dp[0];
        for (int i = 1; i < len; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}
code4:精简上面动态规划三
//既然当前状态只与上一个状态有关，我们可以将空间复杂度压缩到 O(1)O(1)O(1)
class Solution {
    public int maxSubArray(int[] nums) {
        int result = nums[0];   // 保存最大的结果
        int sum = 0;            // 保存当前的子序和
        for (int num : nums) {
            if (sum > 0) {     
// sum是正数，意味着后面有机会再创新高，可以继续加
                sum += num;
            } else {          
 // sum是负的，还不如直接从当前位重新开始算，也比(负数+当前值)要大吧
                sum = num;
            }
            result = Math.max(result, sum);   // 每一步都更新最大值
        }

        return result;
    }
}