LintCode-Maximum Subarray II

Given an array of integers, find two non-overlapping subarrays which have the largest sum.

The number in each subarray should be contiguous.

Return the largest sum.

Note

The subarray should contain at least one number

Example

For given [1, 3, -1, 2, -1, 2], the two subarrays are [1, 3] and [2, -1, 2] or [1, 3, -1, 2] and [2], they both have the largest sum 7.

Challenge

Can you do it in time complexity O(n) ?

Analysis:

We need two non-overlapping subarrays, so there must be some point X so that the maximum subarray before X (not necessarily end at X) + the maximum subarray after X is max.

So, we first calculate the max subarray end at each point from left to right and from right to left;

Then, we account the max subarray before and after each point;

At last, we find out the result.

Solution:

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: An integer denotes the sum of max two non-overlapping subarrays
     */
    public int maxTwoSubArrays(ArrayList<Integer> nums) {
        if (nums.size()<2) return 0;
        int len = nums.size();

        //Calculate the max subarray from left to right and from right to left.
        int[] left = new int[len];
        left[0] = nums.get(0);
        for (int i=1;i<len;i++)
            left[i] = Math.max(left[i-1]+nums.get(i), nums.get(i));
        int curMax = left[0];
        for (int i=1;i<len;i++)
            if (left[i]<curMax){
                left[i] = curMax;
            } else curMax = left[i];

        int[] right = new int[len];
        right[len-1]=nums.get(len-1);
        for (int i=len-2;i>=0;i--)
            right[i] = Math.max(right[i+1]+nums.get(i),nums.get(i));
        curMax = right[len-1];
        for (int i=len-2;i>=0;i--)
            if (right[i]<curMax) right[i] = curMax;
            else curMax = right[i];

        //Find out the result.
        int res = Integer.MIN_VALUE;
        for (int i=0;i<len-1;i++)
            if (left[i]+right[i+1]>res)
                res = left[i]+right[i+1];
        return res;
    }
}