Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum absolute difference between sum of two contiguous sub-arrays

  • Difficulty Level : Hard
  • Last Updated : 19 Nov, 2018

Given an array of integers, find two non-overlapping contiguous sub-arrays such that the absolute difference between the sum of two sub-arrays is maximum.

Example:

Input: [-2, -3, 4, -1, -2, 1, 5, -3]
Output: 12
Two subarrays are [-2, -3] and [4, -1, -2, 1, 5]

Input: [2, -1, -2, 1, -4, 2, 8]
Output: 16
Two subarrays are [-1, -2, 1, -4] and [2, 8]

Expected time complexity is O(n).

The idea is for each index i in given array arr[0…n-1], compute maximum and minimum sum subarrays that lie in subarrays arr[0…i] and arr[i+1 …n-1]. We maintain four arrays that store the maximum and minimum sums in the subarrays arr[0…i] and arr[i+1 … n-1] for every index i in the array.

leftMax[] : An element leftMax[i] of this 
            array stores the maximum value 
            in subarray arr[0..i]

leftMin[] : An element leftMin[i] of this 
            array stores the minimum value
            in subarray arr[0..i]

rightMax[] : An element rightMax[i] of this 
             array stores the maximum value 
             in subarray arr[i+1..n-1]

rightMin[] : An element rightMin[i] of this
             array stores the minimum value
             in subarray arr[i+1..n-1]

We can build above four arrays in O(n) time by using Kadane Algorithm.

    In order to calculate maximum sum subarray that lies in arr[0…i], we run Kadane Algorithm from 0 to n-1 and to find maximum sum subarray that lies in arr[i+1 … n-1], we run Kadane Algorithm from n-1 to 0.

  1. Kadane’s algorithm can be modified to find minimum absolute sum of a subarray as well. The idea is to change the sign of each element in the array and run Kadane Algorithm to find maximum sum subarray that lies in arr[0…i] and arr[i+1 … n-1]. Now invert the sign of maximum subarray sum found. That will be our minimum subarray sum. This idea is taken from here.

    Now from above four arrays, we can easily find maximum absolute difference between the sum of two contiguous sub-arrays. For each index i, take maximum of

    1. abs(max sum subarray that lies in arr[0…i] – min sum subarray that lies in arr[i+1…n-1])
    2. abs(min sum subarray that lies in arr[0…i] – max sum subarray that lies in arr[i+1…n-1])

    Below is the implementation of above idea.

    C++

    // C++ program to find two non-overlapping contiguous
// sub-arrays such that the absolute difference
// between the sum of two sub-array is maximum.
#include <bits/stdc++.h>
using namespace std;

// Find maximum subarray sum for subarray [0..i]
// using standard Kadane's algorithm. This version of
// Kadane's Algorithm will work if all numbers are
// negative.
int maxLeftSubArraySum(int a[], int size, int sum[])
{
    int max_so_far = a[0];
    int curr_max = a[0];
    sum[0] = max_so_far;

    for (int i = 1; i < size; i++)
    {
        curr_max = max(a[i], curr_max + a[i]);
        max_so_far = max(max_so_far, curr_max);
        sum[i] = max_so_far;
    }

    return max_so_far;
}

// Find maximum subarray sum for subarray [i..n]
// using Kadane's algorithm. This version of Kadane's
// Algorithm will work if all numbers are negative
int maxRightSubArraySum(int a[], int n, int sum[])
{
    int max_so_far = a[n];
    int curr_max = a[n];
    sum[n] = max_so_far;

    for (int i = n-1; i >= 0; i--)
    {
        curr_max = max(a[i], curr_max + a[i]);
        max_so_far = max(max_so_far, curr_max);
        sum[i] = max_so_far;
    }

    return max_so_far;
}

// The function finds two non-overlapping contiguous
// sub-arrays such that the absolute difference
// between the sum of two sub-array is maximum.
int findMaxAbsDiff(int arr[], int n)
{
    // create and build an array that stores
    // maximum sums of subarrays that lie in
    // arr[0...i]
    int leftMax[n];
    maxLeftSubArraySum(arr, n, leftMax);

    // create and build an array that stores
    // maximum sums of subarrays that lie in
    // arr[i+1...n-1]
    int rightMax[n];
    maxRightSubArraySum(arr, n-1, rightMax);

    // Invert array (change sign) to find minumum
    // sum subarrays.
    int invertArr[n];
    for (int i = 0; i < n; i++)
        invertArr[i] = -arr[i];

    // create and build an array that stores
    // minimum sums of subarrays that lie in
    // arr[0...i]
    int leftMin[n];
    maxLeftSubArraySum(invertArr, n, leftMin);
    for (int i = 0; i < n; i++)
        leftMin[i] = -leftMin[i];

    // create and build an array that stores
    // minimum sums of subarrays that lie in
    // arr[i+1...n-1]
    int rightMin[n];
    maxRightSubArraySum(invertArr, n - 1, rightMin);
    for (int i = 0; i < n; i++)
        rightMin[i] = -rightMin[i];

    int result = INT_MIN;
    for (int i = 0; i < n - 1; i++)
    {
        /* For each index i, take maximum of
        1. abs(max sum subarray that lies in arr[0...i] -
            min sum subarray that lies in arr[i+1...n-1])
        2. abs(min sum subarray that lies in arr[0...i] -
            max sum subarray that lies in arr[i+1...n-1]) */
        int absValue = max(abs(leftMax[i] - rightMin[i + 1]),
                        abs(leftMin[i] - rightMax[i + 1]));
        if (absValue > result)
            result = absValue;
    }

    return result;
}

// Driver program
int main()
{
    int a[] = {-2, -3, 4, -1, -2, 1, 5, -3};

    int n = sizeof(a) / sizeof(a[0]);

    cout << findMaxAbsDiff(a, n);

    return 0;
}

    Java

    // Java program to find two non-overlapping
// contiguous sub-arrays such that the 
// absolute difference
import java.util.*;

class GFG {
    
    // Find maximum subarray sum for subarray
    // [0..i] using standard Kadane's algorithm.
    // This version of Kadane's Algorithm will 
    // work if all numbers are negative.
    static int maxLeftSubArraySum(int a[], int size, 
                                          int sum[])
    {
        int max_so_far = a[0];
        int curr_max = a[0];
        sum[0] = max_so_far;

        for (int i = 1; i < size; i++) {
            curr_max = Math.max(a[i], curr_max + a[i]);
            max_so_far = Math.max(max_so_far, curr_max);
            sum[i] = max_so_far;
        }

        return max_so_far;
    }

    // Find maximum subarray sum for subarray [i..n]
    // using Kadane's algorithm. This version of Kadane's
    // Algorithm will work if all numbers are negative
    static int maxRightSubArraySum(int a[], int n, int sum[])
    {
        int max_so_far = a[n];
        int curr_max = a[n];
        sum[n] = max_so_far;

        for (int i = n - 1; i >= 0; i--) {
            curr_max = Math.max(a[i], curr_max + a[i]);
            max_so_far = Math.max(max_so_far, curr_max);
            sum[i] = max_so_far;
        }

        return max_so_far;
    }

    // The function finds two non-overlapping contiguous
    // sub-arrays such that the absolute difference
    // between the sum of two sub-array is maximum.
    static int findMaxAbsDiff(int arr[], int n)
    {
        // create and build an array that stores
        // maximum sums of subarrays that lie in
        // arr[0...i]
        int leftMax[] = new int[n];
        maxLeftSubArraySum(arr, n, leftMax);

        // create and build an array that stores
        // maximum sums of subarrays that lie in
        // arr[i+1...n-1]
        int rightMax[] = new int[n];
        maxRightSubArraySum(arr, n - 1, rightMax);

        // Invert array (change sign) to find minumum
        // sum subarrays.
        int invertArr[] = new int[n];
        for (int i = 0; i < n; i++)
            invertArr[i] = -arr[i];

        // create and build an array that stores
        // minimum sums of subarrays that lie in
        // arr[0...i]
        int leftMin[] = new int[n];
        maxLeftSubArraySum(invertArr, n, leftMin);
        for (int i = 0; i < n; i++)
            leftMin[i] = -leftMin[i];

        // create and build an array that stores
        // minimum sums of subarrays that lie in
        // arr[i+1...n-1]
        int rightMin[] = new int[n];
        maxRightSubArraySum(invertArr, n - 1, rightMin);
        for (int i = 0; i < n; i++)
            rightMin[i] = -rightMin[i];

        int result = -2147483648;
        for (int i = 0; i < n - 1; i++) {
            
        /* For each index i, take maximum of
        1. abs(max sum subarray that lies in arr[0...i] -
            min sum subarray that lies in arr[i+1...n-1])
        2. abs(min sum subarray that lies in arr[0...i] -
            max sum subarray that lies in arr[i+1...n-1]) */
            int absValue = Math.max(Math.abs(leftMax[i] - rightMin[i + 1]),
                                    Math.abs(leftMin[i] - rightMax[i + 1]));
            if (absValue > result)
                result = absValue;
        }

        return result;
    }
    
    // driver code
    public static void main(String[] args)
    {
        int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 };
        int n = a.length;
        System.out.print(findMaxAbsDiff(a, n));
    }
}

// This code is contributed by Anant Agarwal.

    Python3

     
# Python3 program to find two non-
# overlapping contiguous sub-arrays
# such that the absolute difference
# between the sum of two sub-array is maximum.

# Find maximum subarray sum for
# subarray [0..i] using standard
# Kadane's algorithm. This version 
# of Kadane's Algorithm will work if 
# all numbers are negative.
def maxLeftSubArraySum(a, size, sum):

    max_so_far = a[0]
    curr_max = a[0]
    sum[0] = max_so_far

    for i in range(1, size):
    
        curr_max = max(a[i], curr_max + a[i])
        max_so_far = max(max_so_far, curr_max)
        sum[i] = max_so_far
    
    return max_so_far

# Find maximum subarray sum for
# subarray [i..n] using Kadane's
# algorithm. This version of Kadane's
# Algorithm will work if all numbers are negative
def maxRightSubArraySum(a, n, sum):

    max_so_far = a[n]
    curr_max = a[n]
    sum[n] = max_so_far

    for i in range(n - 1, -1, -1):
    
        curr_max = max(a[i], curr_max + a[i])
        max_so_far = max(max_so_far, curr_max)
        sum[i] = max_so_far

    return max_so_far

# The function finds two non-overlapping
# contiguous sub-arrays such that the
# absolute difference between the sum
# of two sub-array is maximum.
def findMaxAbsDiff(arr, n):

    # create and build an array that 
    # stores maximum sums of subarrays 
    # that lie in arr[0...i]
    leftMax = [0 for i in range(n)]
    maxLeftSubArraySum(arr, n, leftMax)

    # create and build an array that stores
    # maximum sums of subarrays that lie in
    # arr[i+1...n-1]
    rightMax = [0 for i in range(n)]
    maxRightSubArraySum(arr, n-1, rightMax)

    # Invert array (change sign) to 
    # find minumum sum subarrays.
    invertArr = [0 for i in range(n)]
    for i in range(n):
        invertArr[i] = -arr[i]

    # create and build an array that stores
    # minimum sums of subarrays that lie in
    # arr[0...i]
    leftMin = [0 for i in range(n)]
    maxLeftSubArraySum(invertArr, n, leftMin)
    for i in range(n):
        leftMin[i] = -leftMin[i]

    # create and build an array that stores
    # minimum sums of subarrays that lie in
    # arr[i+1...n-1]
    rightMin = [0 for i in range(n)]
    maxRightSubArraySum(invertArr, n - 1, rightMin)
    for i in range(n):
        rightMin[i] = -rightMin[i]

    result = -2147483648
    for i in range(n - 1):
    
        ''' For each index i, take maximum of
        1. abs(max sum subarray that lies in arr[0...i] -
            min sum subarray that lies in arr[i+1...n-1])
        2. abs(min sum subarray that lies in arr[0...i] -
            max sum subarray that lies in arr[i+1...n-1]) '''
        absValue = max(abs(leftMax[i] - rightMin[i + 1]),
                       abs(leftMin[i] - rightMax[i + 1]))
        if (absValue > result):
            result = absValue
    
    return result
    
# Driver Code
a = [-2, -3, 4, -1, -2, 1, 5, -3]
n = len(a)
print(findMaxAbsDiff(a, n))

# This code is contributed by Anant Agarwal.

    C#

    // C# program to find two non-overlapping 
// contiguous sub-arrays such that the
// absolute difference
using System;
class GFG {
    
// Find maximum subarray sum for subarray
// [0..i] using standard Kadane's algorithm.
// This version of Kadane's Algorithm will
// work if all numbers are negative.
static int maxLeftSubArraySum(int []a, int size, 
                                      int []sum)
{
    int max_so_far = a[0];
    int curr_max = a[0];
    sum[0] = max_so_far;
 
    for (int i = 1; i < size; i++)
    {
        curr_max = Math.Max(a[i], curr_max + a[i]);
        max_so_far = Math.Max(max_so_far, curr_max);
        sum[i] = max_so_far;
    }
 
    return max_so_far;
}
 
// Find maximum subarray sum for subarray
// [i..n] using Kadane's algorithm. 
// This version of Kadane's Algorithm will
// work if all numbers are negative
static int maxRightSubArraySum(int []a, int n,
                                    int []sum)
{
    int max_so_far = a[n];
    int curr_max = a[n];
    sum[n] = max_so_far;
 
    for (int i = n-1; i >= 0; i--)
    {
        curr_max = Math.Max(a[i], curr_max + a[i]);
        max_so_far = Math.Max(max_so_far, curr_max);
        sum[i] = max_so_far;
    }
 
    return max_so_far;
}
 
// The function finds two non-overlapping
// contiguous sub-arrays such that the 
// absolute difference between the sum 
// of two sub-array is maximum.
static int findMaxAbsDiff(int []arr, int n)
{
    // create and build an array that stores
    // maximum sums of subarrays that lie in
    // arr[0...i]
    int []leftMax=new int[n];
    maxLeftSubArraySum(arr, n, leftMax);
 
    // create and build an array that stores
    // maximum sums of subarrays that lie in
    // arr[i+1...n-1]
    int []rightMax=new int[n];
    maxRightSubArraySum(arr, n-1, rightMax);
 
    // Invert array (change sign) to find minumum
    // sum subarrays.
    int []invertArr=new int[n];
    for (int i = 0; i < n; i++)
        invertArr[i] = -arr[i];
 
    // create and build an array that stores
    // minimum sums of subarrays that lie in
    // arr[0...i]
    int []leftMin=new int[n];
    maxLeftSubArraySum(invertArr, n, leftMin);
    for (int i = 0; i < n; i++)
        leftMin[i] = -leftMin[i];
 
    // create and build an array that stores
    // minimum sums of subarrays that lie in
    // arr[i+1...n-1]
    int []rightMin=new int[n];
    maxRightSubArraySum(invertArr, n - 1, rightMin);
    for (int i = 0; i < n; i++)
        rightMin[i] = -rightMin[i];
 
    int result = -2147483648;
    for (int i = 0; i < n - 1; i++)
    {
        /* For each index i, take maximum of
        1. abs(max sum subarray that lies in arr[0...i] -
            min sum subarray that lies in arr[i+1...n-1])
        2. abs(min sum subarray that lies in arr[0...i] -
            max sum subarray that lies in arr[i+1...n-1]) */
        int absValue = Math.Max(Math.Abs(leftMax[i] - rightMin[i + 1]),
                               Math.Abs(leftMin[i] - rightMax[i + 1]));
        if (absValue > result)
            result = absValue;
    }
 
    return result;
}

//driver code
public static void Main()
{
    int []a= {-2, -3, 4, -1, -2, 1, 5, -3};
    int n = a.Length;
    Console.Write(findMaxAbsDiff(a, n));
}
}

//This code is contributed by Anant Agarwal.

    PHP

    <?php 
// PHP program to find two non-overlapping 
// contiguous sub-arrays such that the 
// absolute difference between the sum of
// two sub-array is maximum.

// Find maximum subarray sum for subarray 
// [0..i] using standard Kadane's algorithm. 
// This version of Kadane's Algorithm will 
// work if all numbers are negative
function maxLeftSubArraySum(&$a, $size, &$sum)
{
    $max_so_far = $a[0];
    $curr_max = $a[0];
    $sum[0] = $max_so_far;

    for ($i = 1; $i < $size; $i++)
    {
        $curr_max = max($a[$i], 
                        $curr_max + $a[$i]);
        $max_so_far = max($max_so_far, 
                          $curr_max);
        $sum[$i] = $max_so_far;
    }

    return $max_so_far;
}

// Find maximum subarray sum for subarray 
// [i..n] using Kadane's algorithm. This 
// version of Kadane's Algorithm will work
// if all numbers are negative
function maxRightSubArraySum(&$a, $n, &$sum)
{
    $max_so_far = $a[$n];
    $curr_max = $a[$n];
    $sum[$n] = $max_so_far;

    for ($i = $n - 1; $i >= 0; $i--)
    {
        $curr_max = max($a[$i],
                        $curr_max + $a[$i]);
        $max_so_far = max($max_so_far,
                          $curr_max);
        $sum[$i] = $max_so_far;
    }

    return $max_so_far;
}

// The function finds two non-overlapping 
// contiguous sub-arrays such that the 
// absolute difference between the sum of
// two sub-array is maximum.
function findMaxAbsDiff(&$arr, $n)
{
    // create and build an array that stores
    // maximum sums of subarrays that lie in
    // arr[0...i]
    $leftMax = array_fill(0, $n, NULL);
    maxLeftSubArraySum($arr, $n, $leftMax);

    // create and build an array that stores
    // maximum sums of subarrays that lie in
    // arr[i+1...n-1]
    $rightMax = array_fill(0, $n, NULL);
    maxRightSubArraySum($arr, $n - 1, $rightMax);

    // Invert array (change sign) to 
    // find minumum sum subarrays
    $invertArr = array_fill(0, $n, NULL);
    for ($i = 0; $i < $n; $i++)
        $invertArr[$i] = -$arr[$i];

    // create and build an array that stores
    // minimum sums of subarrays that lie in
    // arr[0...i]
    $leftMin = array_fill(0, $n, NULL);
    maxLeftSubArraySum($invertArr, $n,
                       $leftMin);
    for ($i = 0; $i < $n; $i++)
        $leftMin[$i] = -$leftMin[$i];

    // create and build an array that stores
    // minimum sums of subarrays that lie in
    // arr[i+1...n-1]
    $rightMin = array_fill(0, $n, NULL);
    maxRightSubArraySum($invertArr, 
                        $n - 1, $rightMin);
    for ($i = 0; $i < $n; $i++)
        $rightMin[$i] = -$rightMin[$i];

    $result = PHP_INT_MIN;
    for ($i = 0; $i <$n - 1; $i++)
    {
        /* For each index i, take maximum of
        1. abs(max sum subarray that lies 
           in arr[0...i] - min sum subarray 
           that lies in arr[i+1...n-1])
        2. abs(min sum subarray that lies 
           in arr[0...i] - max sum subarray
           that lies in arr[i+1...n-1]) */
        $absValue = max(abs($leftMax[$i] -  
                            $rightMin[$i + 1]),
                        abs($leftMin[$i] - 
                            $rightMax[$i + 1]));
        if ($absValue > $result)
            $result = $absValue;
    }

    return $result;
}

// Driver Code
$a = array(-2, -3, 4, -1, -2, 1, 5, -3);

$n = sizeof($a);

echo findMaxAbsDiff($a, $n);

// This code is contributed
// by ChitraNayal
?>


    Output :
    12

    Time Complexity is O(n) where n is the number of elements in input array. Auxiliary Space required is O(n).

    This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

    Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above


    My Personal Notes arrow_drop_up
Previous
Longest subarray such that the difference of max and min is at-most one
Next
Maximum length subsequence with difference between adjacent elements as either 0 or 1 | Set 2
Recommended Articles
Page :
Maximum product of sum of two contiguous subarrays of an array
20, Jan 20
Difference between maximum and minimum average of all K-length contiguous subarrays
12, Jul 21
Maximum absolute difference between sum of subarrays of size K
25, Jun 20
Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Sep 20
Sum of absolute difference of maximum and minimum of all subarrays
22, Dec 21
Split array into K subarrays with minimum sum of absolute difference between adjacent elements
21, Dec 20
Partitioning into two contiguous element subarrays with equal sums
30, May 18
Count of ways to split an Array into three contiguous Subarrays having increasing Sum
15, Aug 20
Minimum absolute difference of XOR values of two subarrays
06, Sep 17
Count of contiguous subarrays possible for every index by including the element at that index
08, May 20
Maximize cost to empty an array by removing contiguous subarrays of equal elements
12, Sep 20
Maximum distance between two elements whose absolute difference is K
15, Aug 20
Split array into K subarrays such that sum of maximum of all subarrays is maximized
11, Jun 21
Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays
27, Sep 21
Calculate absolute difference between minimum and maximum sum of pairs in an array
10, Mar 21
Count of subarrays of size K having at least one pair with absolute difference divisible by K-1
30, Jun 20
Number of subarrays having absolute sum greater than K | Set-2
03, Jul 19
Maximize sum of absolute difference between adjacent elements in Array with sum K
20, Jun 20
Maximum sum contiguous nodes in the given linked list
18, Jul 19
Split array into subarrays such that sum of difference between their maximums and minimums is maximum
19, Apr 21
Differences between number of increasing subarrays and decreasing subarrays in k sized windows
16, Nov 17
Smallest number that can replace all -1s in an array such that maximum absolute difference between any pair of adjacent elements is minimum
28, Jun 21
Maximum absolute difference between distinct elements in an Array
02, Jul 20
Partition the array into two odd length groups with minimized absolute difference between their median
26, Feb 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty : Hard
Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox

Start Your Coding Journey Now!