子数组的最大累加和问题

描述
给定一个数组arr，返回子数组的最大累加和
例如，arr = [1, -2, 3, 5, -2, 6, -1]，所有子数组中，[3, 5, -2, 6]可以累加出最大的和12，所以返回12.
题目保证没有全为负数的数据
[要求]
时间复杂度为O(n)O(n)，空间复杂度为O(1)O(1)

示例1
输入：
[1, -2, 3, 5, -2, 6, -1]

返回值：
12

备注：

1≤N≤10 5

题意分析
理解什么是子数组？
要求子数组最大累加和
注意题目对时间复杂度和空间复杂度的要求
时间：O（N）
空间：O（1）
注意备注信息：包含了所给数据的边界范围，这对算法的选择至关重要的。

解法一：暴力解
思路步骤：
常规思路，直接两层for循环暴力枚举
找到符合题意的最大累加和
虽然理论上可行，但是时间复杂度为O(N^2)，实际运行是无法AC的。仅仅作为一种学习思路。

class Solution {
public:
    /**
     * max sum of the subarray
     * @param arr int整型vector the array
     * @return int整型
     */
    int maxsumofSubarray(vector<int>& arr) {
        // write code here
          int result = INT32_MIN;
        int count = 0;
        for (int i = 0; i < arr.size(); i++) { // 设置起始位置
            count = 0;
            for (int j = i; j < arr.size(); j++) { // 每次从起始位置i开始遍历寻找最大值
                count += arr[j];
                result = count > result ? count : result;
            }
        }
        return result;

    }
};

复杂度分析：
时间复杂度：O(N^2) N为数组长度，俩层循环，，根据大O一般法则可知复杂度O(N^2)

空间复杂度：O(1) 常数空间

解法二：贪心

思路步骤：
怎么贪？

不妨以case:[1, -2, 3, 5, -2, 6, -1]为例

当遇到-2时，累加和反而变为负数，此种情况不可能成为最大和

因此在遇到负数时，因该重置累加和为0，继续从i+1开始计算

最后得到一个局部最大和

最终得到一个全局最大和，即是答案

请参考图解

图片说明

Java参考代码：

import java.util.*;
 
public class Solution {
    /**
     * max sum of the subarray
     * @param arr int整型一维数组 the array
     * @return int整型
     */
    public int maxsumofSubarray (int[] arr) {
        // write code here
        //存放临时答案
        int thisSum=0;
        //存放最终答案，注意初始化的值
        int ans = Integer.MIN_VALUE;
        int len = arr.length;
        for(int i=0;i<len;i++ ){
            //累加求和
            thisSum+=arr[i];
            if(thisSum>ans){
                ans = thisSum;
            }
            //贪心，负数必然会拉低序列和
            if(thisSum<0){
                thisSum=0;
            }
        }
        return ans;
    }
}

复杂度分析：
时间复杂度：O(N) N为数组长度，取决于for循环。

空间复杂度：O(1) 常数空间开销

解法三：分治思想
思路步骤：
我们的最大序列和可能会分别在前半部分和后半部分与中间部分出现。

关于前两种情况，如果只出现在前后半部分，可以递归求解得到。第三种情况：跨越输入数据的中部而位于左右俩部分之中，可以通过求出前半部分（包含该部分最后一个元素）的最大和以及后半部分（包含该部分第一个元素）的最大和得到，二者相加即可。

将目标数组一分为二：左右两部分
递归求解
计算前半部分最大和
计算后半部分最大和
计算最终全局最大和
return 答案
参考图解

图片说明
Java参考代码：

import java.util.*;
 
public class Solution {
    /**
     * max sum of the subarray
     * @param arr int整型一维数组 the array
     * @return int整型
     */
        public int maxSum(int[] a,int left,int right){
        if(left==right){
            return a[left];
        }
        int center = (left+right)/2;
        //计算前半部分最大和
        int maxLeftSum = maxSum(a,left,center);
        //计算后半部分最大和
        int maxRightSum = maxSum(a,center+1,right);
 
        //计算分界部分(前半部分)
        int maxLeftBorderfeSum = Integer.MIN_VALUE,leftBorderSum = 0;
        for(int i=center;i>=left;i--){
            leftBorderSum+=a[i];
            if(leftBorderSum>maxLeftBorderfeSum){
                maxLeftBorderfeSum = leftBorderSum;
            }
        }
        //计算分界部分(前半部分)
        int maxRightBorderSum =Integer.MIN_VALUE,rightBorderSum=0;
        for(int i=center+1;i<=right;i++){
            rightBorderSum+=a[i];
            if(rightBorderSum>maxRightBorderSum){
                maxRightBorderSum = rightBorderSum;
            }
        }
        //取全局最优
     return max3(maxLeftSum,maxRightSum,maxRightBorderSum+maxLeftBorderfeSum);
    }
    /*计算三值最大*/
    public int max3(int a,int b,int c){
       return Math.max(Math.max(a,b),c);
    }
 
 
    public int maxsumofSubarray (int[] arr) {
        // 调用
        return maxSum(arr,0,arr.length-1);
 
    }
}

复杂度分析：
时间复杂度：O(NlogN)，常数量+两层循环O(N)+递归部分的开销O(N/2),为了简化计算，这里不再给出精确的求解。2T(N/2)+O(N)且T(1)=1,显然可以得到T(2) = 4 = 22,T(4) = 12 = 4*3,显式的可以得到，若图片说明 则O(N) = N(K+1) = NlogN+N = NlogN，所以最终时间复杂度：O(NlogN)

空间复杂度：O(1)，常数空间开销。