LintCode: 41. 连续子数组的最大和(最大子数组I) VS 42. 最大子数组II

题目：

方法一：考虑所有情况，时间复杂度O(n^2)。

public int FindGreatestSumOfSubArray(int[] array) {
        if(array.length<=0) return 0;
        int maxOfAllSubArray=Integer.MIN_VALUE;
        for(int i=0;i<array.length-1;i++){
            int max=maxofSubArray(array,i,array.length);
            if(maxOfAllSubArray<max){
                maxOfAllSubArray=max;
            }
        }
        return maxOfAllSubArray;
    }

    public int maxofSubArray(int[]array,int begin,int end){
        int cal=array[begin];
        int max=array[begin];
        for(int i=begin+1;i<end;i++){
            cal+=array[i];
            if(cal>max)
                max=cal;
        }
        return max;
    }

方法二：动态规划

dp[i]：以array[i]为末尾元素的子数组的和的最大值，子数组的元素的相对位置不变

dp[i]=max（dp[i-1]+array[i], array[i]）

最后返回最大的值即可。

public int maxSubArray1(int[] nums) {
        // write your code here
        int len=nums.length;
        int max=-Integer.MAX_VALUE;
        int[] dp=new int[len+1];
        //dp[i]表示以i结尾的子数组的最大和
        for(int i=1;i<=len;i++){
            dp[i]=Math.max(dp[i-1]+nums[i-1],nums[i-1]);
            if(dp[i]>max){
                max=dp[i];
            }
        }
        return max;
    }

题目：

方法：继续使用上题方法二中的动态规划思想。

1. 创建两个长度为nums.length+1的dp数组，含义分别为从左往右和从右往左遍历数组。每个数组left[i]记录从0到当前位置i下的最大子数组之和
2. 最后求两个子数组的和最大，就是找left[]从0-i,right[]从i+1到length最大数之和。

public class Solution {
    /*
     * @param nums: A list of integers
     * @return: An integer denotes the sum of max two non-overlapping subarrays
     */
    public int maxTwoSubArrays(List<Integer> nums) {
        // write your code here
        int len=nums.size();
        int[] LeftToRight=new int[len+1];  //从左往右遍历的dp
        int[] RightToLeft=new int[len+1];  //从右往左遍历的dp
        int max0=nums.get(0);
        int max1=nums.get(nums.size()-1);
        //从左往右遍历
        for(int i=1;i<=nums.size();i++){
            LeftToRight[i]=Math.max(LeftToRight[i-1]+nums.get(i-1),nums.get(i-1));
        }
        //从右往左遍历
        for(int i=nums.size()-1;i>=0;i--){
            RightToLeft[i]=Math.max(RightToLeft[i+1]+nums.get(i),nums.get(i));
        }
        int max=Integer.MIN_VALUE;
        for(int i=1;i< nums.size();i++){
            for(int j=i;j<nums.size();j++){
                if((LeftToRight[i]+RightToLeft[j])>max)
                    max=LeftToRight[i]+RightToLeft[j];
            }
        }
        return max;
    }
}