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[0] 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++ program for the above approach #include <bits/stdc++.h> 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] = 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[0]);
cout << getValue(arr, N);
return 0;
} // This code is contributed by Kingash |
// 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# 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] = 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 |
# 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.
|
<script> // JavaScript program to implement // the above approach // Function to find maximum sum of
// difference between maximums and
// minimums in the splitted subarrays
function getValue(arr, N)
{
let dp = Array.from({length: N}, (_, i) => 0);
// Base Case
dp[0] = 0;
// Traverse the array
for (let i = 1; i < N; i++) {
// Stores the maximum and
// minimum elements upto
// the i-th index
let min = arr[i];
let max = arr[i];
// Traverse the range [0, i]
for (let 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 let arr = [ 8, 1, 7, 9, 2 ];
let N = arr.length;
document.write(getValue(arr, N));
</script> |
14
Time Complexity: O(N2)
Auxiliary Space: O(N)