53. 最大子序和

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

示例:

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

推荐参考：https://blog.csdn.net/zwzsdy/article/details/80029796；https://blog.csdn.net/u014472643/article/details/81097672

public class MaxSubArray {
    //方法一：扫描法，从头遍历数组，对于数组中每一个元素，要么加入之前的数组（加入其它组），要么自己开始（单开一组）
    //如果之前的组结果为负，则应该自己开始一个新的组，因为自己的值比加入后的值还要大。O(N)
    public int maxSubArray1(int[] array) {
        if(array.length == 0) {
            throw new IllegalArgumentException("输入参数错误");
        }
        if(array.length == 1) {
            return array[0];
        }
        int len = array.length;
        int[] res = new int[len];
        res[0] = array[0];
        int max = res[0];
        for(int i=1; i<len; i++) {
            //数组res记录连续数组的和，如果大于0，则加入该连续数组，小于0，重新开始新的连续数组
            if(res[i-1] > 0) {
                res[i] = res[i-1] + array[i];
            }else {
                res[i] = array[i];
            }
            max = Math.max(res[i], max);
        }
        return max;        
    }
    //方法二：暴力法，依次计算每个子数组的和，选择其中最大的子数组，时间复杂度为n^3
    public int maxSubArray2(int[] array) {
        if(array.length == 0) {
            throw new IllegalArgumentException("输入参数错误");
        }
        int len = array.length;
        int sum = 0;
        int max = array[0];  //只有一个元素时最大值即为该元素
        for(int i=0; i<len; i++) {
            for(int j=i; j<len; j++) {  //单个元素也是子数组，需要包括
                for(int k=i; k<=j; k++) {
                    sum += array[k];
                }
                if(sum > max) {
                    max = sum;
                }
                sum = 0;
            }
        }
        return max;
    }
    //方法二：暴力法改进，在第三层循环中，每次都要计算上次已经计算的序列，发生了重复计算，所以可以在前一次的计算的基础上
    //相加，减少一层循环，时间复杂度为n^2
    public int maxSubArray22(int[] array) {
        if(array.length == 0) {
            throw new IllegalArgumentException("输入参数错误");
        }
        int len = array.length;
        int sum = 0;
        int max = array[0];
        for(int i=0; i<len; i++) {
            for(int j=i; j<len; j++) {
                sum += array[j];
                if(sum > max) {
                    max = sum;
                }
            }
            sum = 0;
        }
        return max;
    }
    //方法三：分治法，将整个数组一直拆分至单个元素，从下往上得到最大值。
    //把数组分成两个序列，最大连续子序列和要么在左半部分，要么在右半部分，要么是横跨左右部分
    public int maxSubArray3(int[] array) {
        if(array.length == 0) {
            throw new IllegalArgumentException("输入参数错误");
        }
        return maxSubArrayPart(array, 0, array.length - 1);
    }
    private int maxSubArrayPart(int[] array, int left, int right) {
        //递归出口
        if(left == right) {
            return array[left];
        }
        int mid = (left + right) / 2;
        //左半部分最大值
        int maxLeft = maxSubArrayPart(array, left, mid);
        //右半部分最大值
        int maxRight = maxSubArrayPart(array, mid+1, right);
        
        //跨边界最大值，必定包括左半部分的最后一个元素，以及右半部分的第一个元素
        //边界以左
        int sum = 0;
        int maxLeftBorder = array[mid];
        for(int i=mid; i>=left; i--) {
            sum += array[i];
            if(sum > maxLeftBorder) {
                maxLeftBorder = sum;
            }
        }
        //边界以右
        sum = 0;
        int maxRightBorder = array[mid+1];
        for(int i=mid+1; i<=right; i++) {
            sum += array[i];
            if(sum > maxRightBorder) {
                maxRightBorder = sum;
            }
        }
        int maxBorder = maxLeftBorder + maxRightBorder;
//        return Math.max(Math.max(maxRight, maxLeft), maxBorder);  //两者皆可
        return (maxRight>maxLeft) ? (maxRight>maxBorder ? maxRight : maxBorder) 
                : (maxLeft>maxBorder ? maxLeft : maxBorder);
    }
    
    //方法四：动态规划（动态规划三要素：最优子结构(递归方程)、边界条件(终止条件)和状态转移方程(前两者总结)）
    //对于第i个元素，有两种选择，要么加入已存在的连续子数组，要么只包括自己开启新的连续子数组。判断条件是前面已经
    //存在的连续子数组和是否大于0。
    //状态转移方程：dp = max[arr[i], arr[i] + sum]
    public int maxSubArray4(int[] array) {
        //边界条件
        int sum = array[0];
        
        int result = array[0];
        for(int i=1; i<array.length; i++) {
            if(sum > 0) {
                sum += array[i];
            }else {
                sum = array[i];
            }
            if(sum > result) {
                result = sum;
            }
        }
        return result;
    }
    
}