53.Maximum Subarray

题目链接：https://leetcode.com/problems/maximum-subarray/description/

题目大意：给出一串数组，找出其最大连续子序列和，例子如下：

法一（超时）：时间复杂度o(n^2)，两层for循环，记录每一个数值后的连续序列的最大和，里层for循环记录当前数值的连续序列的最大和，如果比最大值大，则记录。

这个方法可以用来解决记录最大序列和的开始和结束下标的问题，即在里层for循环中的当前数值的连续序列的最大和比最大值大时，出现调换时可以在这个步骤中记录开始和结束下标。

代码如下：

int res = Integer.MIN_VALUE;
        for(int i = 0; i < nums.length; i++) {
            int cnt = 0;
            //对于每一个数值，判断其后面的连续子序列和得到最大值
            for(int j = i; j < nums.length; j++) {
                cnt += nums[j];
                if(cnt > res) {
                    res = cnt;
                }
            }
        }
        return res;

法二（借鉴）：时间复杂度o(n)，代码如下（耗时13ms）：

        //法一
/*        
        //这里要把res赋值为最小值，以防序列中负数的出现
        int res = Integer.MIN_VALUE;
        int sum = 0;
        for(int i = 0; i < nums.length; i++) {
            if(sum < 0) {
                sum = nums[i];//如果当前值前面的sum<0，则将sum重新赋值为当前值，以此值为新的起点开始计算最大和
            }
            else {
                sum += nums[i];//否则， 将当前值加入sum中
            }
            if(sum > res) {
                res = sum;
            }
        }
        return res;*/
        //法二
        //结论：如果a[i]是负的，那么它不可能代表最优序列的起点，因为任何包含a[i]的作为起点的子序列都可以通过a[i+1]作起点而得到改进。类似地，任何负的子序列不可能是最优子序列的前缀
        //如果在内循环中检测到从a[i]到a[j]的子序列是负的，那么可以推进i到j+1。
        //在这里的运用也就是当sum<0时，即刻将sum重置为0。
        //这里一定要把res赋值为最小值，因为序列中会有负数的情况
        int res = Integer.MIN_VALUE;
        int sum = 0;
        for(int i = 0; i < nums.length; i++) {
            sum += nums[i];//System.out.println(sum);
            if(sum > res) {
                res = sum;
            }
            //这里不要用else，因为类似序列{-2,-1}这种就计算不到最后的解
            if(sum < 0) {//如果sum<0，则将sum重置，也就是发现sum<0，则说明此序列不会是最大和序列
                sum = 0;
            }
        }
        return res;

法三（借鉴）：分治，时间复杂度o(nlogn)，参考http://blog.csdn.net/silangquan/article/details/8062229， 代码如下（耗时18ms）：

    public int maxSubArray(int[] nums) {
        return solution(nums, 0, nums.length - 1);
    }
    
    public int solution(int[] a, int left, int right) {
        //处理left==right中间值情况
        if(left == right) {
            return a[left];
        }
        
        int mid = (left + right) / 2;
        //递归求左边最大和
        int maxLeft = solution(a, left, mid);
        //递归求右边最大和
        int maxRight = solution(a, mid + 1, right);
        
        //当前数组左边包含最后一个数的最大和
        int maxLeftSum = Integer.MIN_VALUE;
        int leftSum = 0;
        for(int i = mid; i >= left; i--) {
            leftSum += a[i];
            if(maxLeftSum < leftSum) {
                maxLeftSum = leftSum;
            }
        }
        
        //当前数组右边包含第一个数的最大和
        int maxRightSum = Integer.MIN_VALUE;
        int rightSum = 0;
        for(int i = mid + 1; i <= right; i++) {
            rightSum += a[i];
            if(maxRightSum < rightSum) {
                maxRightSum = rightSum;
            }
        }
        
        //左边最大和，右边最大和，包含左右两边的最大和，返回这三个值中的最大值
        int tmp = maxLeft > maxRight ? maxLeft : maxRight;
        return tmp > (maxLeftSum + maxRightSum) ? tmp : (maxLeftSum + maxRightSum);
    }