lintcode-medium-Maximum Subarray Difference

Given an array with integers.

Find two non-overlapping subarrays A and B, which |SUM(A) - SUM(B)|is the largest.

Return the largest difference.

 

Notice

The subarray should contain at least one number

Example

For [1, 2, -3, 1], return 6.

Challenge

O(n) time and O(n) space.

 

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: An integer indicate the value of maximum difference between two
     *          Subarrays
     */
    public int maxDiffSubArrays(int[] nums) {
        // write your code here
        
        if(nums == null || nums.length == 0)
            return 0;
        
        int size = nums.length;
        
        int sum_max = nums[0];
        int[] l2r_max = new int[size];
        l2r_max[0] = nums[0];
        int sum_min = nums[0];
        int[] l2r_min = new int[size];
        l2r_min[0] = nums[0];
        
        for(int i = 1; i < size; i++){
            if(sum_max < 0)
                sum_max = 0;
            sum_max += nums[i];
            
            if(sum_max > l2r_max[i - 1])
                l2r_max[i] = sum_max;
            else
                l2r_max[i] = l2r_max[i - 1];
                
            if(sum_min > 0)
                sum_min = 0;
            sum_min += nums[i];
            
            if(sum_min < l2r_min[i - 1])
                l2r_min[i] = sum_min;
            else
                l2r_min[i] = l2r_min[i - 1];
        }
        
        sum_max = nums[size - 1];
        int[] r2l_max = new int[size];
        r2l_max[size - 1] = nums[size - 1];
        sum_min = nums[size - 1];
        int[] r2l_min = new int[size];
        r2l_min[size - 1] = nums[size - 1];
        
        for(int i = size - 2; i >= 0; i--){
            if(sum_max < 0)
                sum_max = 0;
            
            sum_max += nums[i];
            
            if(sum_max > r2l_max[i + 1])
                r2l_max[i] = sum_max;
            else
                r2l_max[i] = r2l_max[i + 1];
            
            if(sum_min > 0)
                sum_min = 0;
            sum_min += nums[i];
            
            if(sum_min < r2l_min[i + 1])
                r2l_min[i] = sum_min;
            else
                r2l_min[i] = r2l_min[i + 1];
        }
        
        int result = Integer.MIN_VALUE;
        for(int i = 0; i < size - 1; i++){
            result = Math.max(result, Math.max(Math.abs(l2r_min[i] - r2l_max[i + 1]), Math.abs(l2r_max[i] - r2l_min[i + 1])));
            result = Math.max(result, Math.max(Math.abs(l2r_max[i] - r2l_max[i + 1]), Math.abs(l2r_min[i] - r2l_min[i + 1])));
        }
            
        return result;
    }
}