Given an array, arr[] and a function F(i, j). The task is to compute max{F(i, j)} over all sub-arrays [i..j].
The function F() is defined as:
Examples:
Input : arr[] = { 1, 5, 4, 7 }
Output : 6
Values of F(i, j) for all the sub-arrays:
{ 1, 5 } = |1 – 5| * (1) = 4
{ 1, 5, 4 } = |1 – 5| * (1) + |5 – 4| * (-1) = 3
{ 1, 5, 4, 7 } = |1 – 5| * (1) + |5 – 4| * (-1) + |4 – 7| * (1) = 6
{ 5, 4 } = |5 – 4| * (1) = 1
{ 5, 4, 7 } = |5 – 4| * (1) + |4 – 7| * (-1) = -2
{ 4, 7 } = |4 – 7| * (1) = 3
Max of all the above values = 6.Input : arr[] = { 1, 4, 2, 3, 1 }
Output : 3
Naive Approach: A naive approach is to traverse over all sub-arrays and calculate the maximum of function F over all the sub-arrays.
Efficient Approach: A better approach is to consider segments in F(l, r) with odd and even l separately. Two different arrays B[] and C[] can be constructed for this purpose such that:
B[i] = |arr[i] - arr[i + 1]| * (-1)i C[i] = |arr[i] - arr[i + 1]| * (-1)i + 1
Now if we observe closely, we just need to find the maximum sum subarray of the arrays B[] and C[] and final answer of the function will be the maximum among both the arrays.
Below is the implementation of the above approach:
C++
// C++ implementation of the above approach #include <bits/stdc++.h> #define MAX 100005 using namespace std; // Function to return maximum sum of a sub-array int kadaneAlgorithm( const int * ar, int n) { int sum = 0, maxSum = 0; for ( int i = 0; i < n; i++) { sum += ar[i]; if (sum < 0) sum = 0; maxSum = max(maxSum, sum); } return maxSum; } // Function to return maximum value of function F int maxFunction( const int * arr, int n) { int b[MAX], c[MAX]; // Compute arrays B[] and C[] for ( int i = 0; i < n - 1; i++) { if (i & 1) { b[i] = abs (arr[i + 1] - arr[i]); c[i] = -b[i]; } else { c[i] = abs (arr[i + 1] - arr[i]); b[i] = -c[i]; } } // Find maximum sum sub-array of both of the // arrays and take maximum among them int ans = kadaneAlgorithm(b, n - 1); ans = max(ans, kadaneAlgorithm(c, n - 1)); return ans; } // Driver code int main() { int arr[] = { 1, 5, 4, 7 }; int n = sizeof (arr) / sizeof (arr[0]); cout << maxFunction(arr, n); return 0; } |
Java
// Java implementation of the approach import java.util.*; class GFG { static int MAX = 100005 ; // Function to return maximum sum of a sub-array static int kadaneAlgorithm( int [] ar, int n) { int sum = 0 , maxSum = 0 ; for ( int i = 0 ; i < n; i++) { sum += ar[i]; if (sum < 0 ) sum = 0 ; maxSum = Math.max(maxSum, sum); } return maxSum; } // Function to return maximum value // of function F static int maxFunction( int [] arr, int n) { int []b = new int [MAX]; int []c = new int [MAX]; // Compute arrays B[] and C[] for ( int i = 0 ; i < n - 1 ; i++) { if (i % 2 == 1 ) { b[i] = Math.abs(arr[i + 1 ] - arr[i]); c[i] = -b[i]; } else { c[i] = Math.abs(arr[i + 1 ] - arr[i]); b[i] = -c[i]; } } // Find maximum sum sub-array of both of the // arrays and take maximum among them int ans = kadaneAlgorithm(b, n - 1 ); ans = Math.max(ans, kadaneAlgorithm(c, n - 1 )); return ans; } // Driver code public static void main(String[] args) { int arr[] = { 1 , 5 , 4 , 7 }; int n = arr.length; System.out.println(maxFunction(arr, n)); } } // This code is contributed by PrinciRaj1992 |
Python3
# Python3 implementation of the above approach MAX = 100005 ; # Function to return maximum # sum of a sub-array def kadaneAlgorithm(ar, n) : sum = 0 ; maxSum = 0 ; for i in range (n) : sum + = ar[i]; if ( sum < 0 ) : sum = 0 ; maxSum = max (maxSum, sum ); return maxSum; # Function to return maximum # value of function F def maxFunction(arr, n) : b = [ 0 ] * MAX ; c = [ 0 ] * MAX ; # Compute arrays B[] and C[] for i in range (n - 1 ) : if (i & 1 ) : b[i] = abs (arr[i + 1 ] - arr[i]); c[i] = - b[i]; else : c[i] = abs (arr[i + 1 ] - arr[i]); b[i] = - c[i]; # Find maximum sum sub-array of both of the # arrays and take maximum among them ans = kadaneAlgorithm(b, n - 1 ); ans = max (ans, kadaneAlgorithm(c, n - 1 )); return ans; # Driver code if __name__ = = "__main__" : arr = [ 1 , 5 , 4 , 7 ]; n = len (arr) print (maxFunction(arr, n)); # This code is contributed by Ryuga |
C#
// C# implementation of the approach using System; class GFG { static int MAX = 100005; // Function to return maximum sum of a sub-array static int kadaneAlgorithm( int [] ar, int n) { int sum = 0, maxSum = 0; for ( int i = 0; i < n; i++) { sum += ar[i]; if (sum < 0) sum = 0; maxSum = Math.Max(maxSum, sum); } return maxSum; } // Function to return maximum value // of function F static int maxFunction( int [] arr, int n) { int []b = new int [MAX]; int []c = new int [MAX]; // Compute arrays B[] and C[] for ( int i = 0; i < n - 1; i++) { if (i % 2 == 1) { b[i] = Math.Abs(arr[i + 1] - arr[i]); c[i] = -b[i]; } else { c[i] = Math.Abs(arr[i + 1] - arr[i]); b[i] = -c[i]; } } // Find maximum sum sub-array of both of the // arrays and take maximum among them int ans = kadaneAlgorithm(b, n - 1); ans = Math.Max(ans, kadaneAlgorithm(c, n - 1)); return ans; } // Driver code public static void Main(String[] args) { int []arr = { 1, 5, 4, 7 }; int n = arr.Length; Console.WriteLine(maxFunction(arr, n)); } } // This code is contributed by PrinciRaj1992 |
Javascript
<script> // JavaScript implementation of the above approach const MAX = 100005; // Function to return maximum sum of a sub-array function kadaneAlgorithm(ar, n) { let sum = 0, maxSum = 0; for (let i = 0; i < n; i++) { sum += ar[i]; if (sum < 0) sum = 0; maxSum = Math.max(maxSum, sum); } return maxSum; } // Function to return maximum // value of function F function maxFunction(arr, n) { let b = new Array(MAX), c = new Array(MAX); // Compute arrays B[] and C[] for (let i = 0; i < n - 1; i++) { if (i & 1) { b[i] = Math.abs(arr[i + 1] - arr[i]); c[i] = -b[i]; } else { c[i] = Math.abs(arr[i + 1] - arr[i]); b[i] = -c[i]; } } // Find maximum sum sub-array of both of the // arrays and take maximum among them let ans = kadaneAlgorithm(b, n - 1); ans = Math.max(ans, kadaneAlgorithm(c, n - 1)); return ans; } // Driver code let arr = [ 1, 5, 4, 7 ]; let n = arr.length; document.write(maxFunction(arr, n)); // This code is contributed by Manoj. </script> |
6
Time Complexity: O(n)
Auxiliary Space: O(MAX)
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!