Skip to content
Related Articles
Split array into subarrays such that sum of difference between their maximums and minimums is maximum
• Last Updated : 05 May, 2021

Given an array arr[] consisting of N integers, the task is to split the array into subarrays such that the sum of the difference between the maximum and minimum elements for all the subarrays is maximum.

Examples :

Input: arr[] = {8, 1, 7, 9, 2}
Output: 14
Explanation:
Consider splitting the given array into subarrays as {8, 1} and {7, 9, 2}. Now, the difference between maximum and minimum elements are:

• {8, 1}: Difference is (8 – 1) = 7.
• {7, 9, 2}: Difference is (9 – 2) = 7.

Therefore, the sum of the difference is 7 + 7 = 14.

Input: arr[] = {1, 2, 1, 0, 5}
Output: 6

Approach: The given problem can be solved by using Dynamic Programming. Follow the steps to solve the problem:

• Initialize an array, say dp[], where dp[i] represents the maximum sum of the difference between the maximum and minimum element for all the subarray for the first i array element.
• Initialize dp as 0.
• Traverse the given array over the range [1, N – 1] and perform the following steps:
• Initialize a variable, say min as arr[i], that stores the minimum element over the range [0, i].
• Initialize a variable, say max as arr[i], that stores the maximum element over the range [0, i].
• Iterate over the range [0, i] using the variable j in the reverse order and perform the following steps:
• Update the value of min as the minimum of min and arr[j].
• Update the value of max as the minimum of max and arr[j].
• Update the value of  dp[j] to the maximum of dp[j] and (max – min + dp[i]).
• After completing the above steps, print the value of dp[N – 1] as the result.

Below is the implementation of the above approach :

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find maximum sum of``// difference between maximums and``// minimums in the splitted subarrays``int` `getValue(``int` `arr[], ``int` `N)``{``    ``int` `dp[N];``    ``memset``(dp, 0, ``sizeof``(dp));` `    ``// Base Case``    ``dp = 0;` `    ``// Traverse the array``    ``for``(``int` `i = 1; i < N; i++)``    ``{` `        ``// Stores the maximum and``        ``// minimum elements upto``        ``// the i-th index``        ``int` `minn = arr[i];``        ``int` `maxx = arr[i];` `        ``// Traverse the range [0, i]``        ``for``(``int` `j = i; j >= 0; j--)``        ``{` `            ``// Update the minimum``            ``minn = min(arr[j], minn);` `            ``// Update the maximum``            ``maxx = max(arr[j], maxx);` `            ``// Update dp[i]``            ``dp[i] = max(dp[i], maxx - minn +``                   ``((j >= 1) ? dp[j - 1] : 0));``        ``}``    ``}` `    ``// Return the maximum``    ``// sum of difference``    ``return` `dp[N - 1];``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 8, 1, 7, 9, 2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << getValue(arr, N);` `    ``return` `0;``}` `// This code is contributed by Kingash`

## Java

 `// Java program for the above approach` `import` `java.util.*;``public` `class` `Main {` `    ``// Function to find maximum sum of``    ``// difference between maximums and``    ``// minimums in the splitted subarrays``    ``static` `int` `getValue(``int``[] arr, ``int` `N)``    ``{``        ``int` `dp[] = ``new` `int``[N];` `        ``// Base Case``        ``dp[``0``] = ``0``;` `        ``// Traverse the array``        ``for` `(``int` `i = ``1``; i < N; i++) {` `            ``// Stores the maximum and``            ``// minimum elements upto``            ``// the i-th index``            ``int` `min = arr[i];``            ``int` `max = arr[i];` `            ``// Traverse the range [0, i]``            ``for` `(``int` `j = i; j >= ``0``; j--) {` `                ``// Update the minimum``                ``min = Math.min(arr[j], min);` `                ``// Update the maximum``                ``max = Math.max(arr[j], max);` `                ``// Update dp[i]``                ``dp[i] = Math.max(``                    ``dp[i],``                    ``max - min + ((j >= ``1``)``                                     ``? dp[j - ``1``]``                                     ``: ``0``));``            ``}``        ``}` `        ``// Return the maximum``        ``// sum of difference``        ``return` `dp[N - ``1``];``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``8``, ``1``, ``7``, ``9``, ``2` `};``        ``int` `N = arr.length;``        ``System.out.println(getValue(arr, N));``    ``}``}`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find maximum sum of``// difference between maximums and``// minimums in the splitted subarrays``static` `int` `getValue(``int``[] arr, ``int` `N)``{``    ``int``[] dp = ``new` `int``[N];` `    ``// Base Case``    ``dp = 0;` `    ``// Traverse the array``    ``for``(``int` `i = 1; i < N; i++)``    ``{``        ` `        ``// Stores the maximum and``        ``// minimum elements upto``        ``// the i-th index``        ``int` `min = arr[i];``        ``int` `max = arr[i];` `        ``// Traverse the range [0, i]``        ``for``(``int` `j = i; j >= 0; j--)``        ``{``            ` `            ``// Update the minimum``            ``min = Math.Min(arr[j], min);` `            ``// Update the maximum``            ``max = Math.Max(arr[j], max);` `            ``// Update dp[i]``            ``dp[i] = Math.Max(``                ``dp[i],``                ``max - min + ((j >= 1) ?``                     ``dp[j - 1] : 0));``        ``}``    ``}` `    ``// Return the maximum``    ``// sum of difference``    ``return` `dp[N - 1];``}` `// Driver Code``static` `public` `void` `Main()``{``    ``int``[] arr = { 8, 1, 7, 9, 2 };``    ``int` `N = arr.Length;``    ` `    ``Console.Write(getValue(arr, N));``}``}` `// This code is contributed by code_hunt`

## Python3

 `# python 3 program for the above approach` `# Function to find maximum sum of``# difference between maximums and``# minimums in the splitted subarrays``def` `getValue(arr, N):``    ``dp ``=` `[``0` `for` `i ``in` `range``(N)]``    ` `    ``# Traverse the array``    ``for` `i ``in` `range``(``1``, N):``      ` `        ``# Stores the maximum and``        ``# minimum elements upto``        ``# the i-th index``        ``minn ``=` `arr[i]``        ``maxx ``=` `arr[i]``        ` `        ``j ``=` `i``        ` `        ``# Traverse the range [0, i]``        ``while``(j >``=` `0``):``          ` `            ``# Update the minimum``            ``minn ``=` `min``(arr[j], minn)` `            ``# Update the maximum``            ``maxx ``=` `max``(arr[j], maxx)` `            ``# Update dp[i]``            ``dp[i] ``=` `max``(dp[i], maxx ``-` `minn ``+` `(dp[j ``-` `1``] ``if` `(j >``=` `1``) ``else` `0``))``            ``j ``-``=` `1` `    ``# Return the maximum``    ``# sum of difference``    ``return` `dp[N ``-` `1``]` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``8``, ``1``, ``7``, ``9``, ``2``]``    ``N ``=` `len``(arr)``    ``print``(getValue(arr, N))` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``
Output:
`14`

Time Complexity: O(N2)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up