Given an array arr[] of size N, the task is to find the maximum sum of the elements of the array after applying the given operation any number of times. In a single operation, choose an index 1 ≤ i < N and multiply both arr[i] and arr[i – 1] by -1.
Examples:
Input: arr[] = {-10, 5, -4}
Output: 19
Perform the operation for i = 1 and
the array becomes {10, -5, -4}
Perform the operation for i = 2 and
the array becomes {10, 5, 4}
10 + 5 + 4 = 19Input: arr[] = {10, -4, -8, -11, 3}
Output: 30
Approach: This problem can be solved using dynamic programming. Since it is useless to choose and flip the same arr[i], we will consider flipping at most once for each element of the array in order from the left. Let dp[i][0] represents the maximum possible sum up to the ith index without flipping the ith index. dp[i][1] represents the maximum possible sum up to the ith index with flipping the ith index. So, dp(n, 0) is our required answer.
Base conditions:
- dp[0][0] = 0
- dp[0][1] = INT_MIN
Recurrence relation:
- dp[i + 1][0] = max(dp[i][0] + arr[i], dp[i][1] – arr[i])
- dp[i + 1][1] = max(dp[i][0] – arr[i], dp[i][1] + arr[i])
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function to return the maximum possible // sum after performing the given operation int max_sum( int a[], int n) { // Dp vector to store the answer vector<vector< int > > dp(n + 1, vector< int >(2, 0)); // Base value dp[0][0] = 0, dp[0][1] = -999999; for ( int i = 0; i <= n - 1; i++) { dp[i + 1][0] = max(dp[i][0] + a[i], dp[i][1] - a[i]); dp[i + 1][1] = max(dp[i][0] - a[i], dp[i][1] + a[i]); } // Return the maximum sum return dp[n][0]; } // Driver code int main() { int a[] = { -10, 5, -4 }; int n = sizeof (a) / sizeof (a[0]); cout << max_sum(a, n); return 0; } |
Java
// Java implementation of the approach class GFG { // Function to return the maximum possible // sum after performing the given operation static int max_sum( int a[], int n) { // Dp vector to store the answer int [][]dp = new int [n + 1 ][ 2 ]; // Base value dp[ 0 ][ 0 ] = 0 ; dp[ 0 ][ 1 ] = - 999999 ; for ( int i = 0 ; i <= n - 1 ; i++) { dp[i + 1 ][ 0 ] = Math.max(dp[i][ 0 ] + a[i], dp[i][ 1 ] - a[i]); dp[i + 1 ][ 1 ] = Math.max(dp[i][ 0 ] - a[i], dp[i][ 1 ] + a[i]); } // Return the maximum sum return dp[n][ 0 ]; } // Driver code public static void main(String[] args) { int a[] = { - 10 , 5 , - 4 }; int n = a.length; System.out.println(max_sum(a, n)); } } // This code is contributed by 29AjayKumar |
Python3
# Python implementation of the approach # Function to return the maximum possible # sum after performing the given operation def max_sum(a, n): # Dp vector to store the answer dp = [[ 0 for i in range ( 2 )] for j in range (n + 1 )] # Base value dp[ 0 ][ 0 ] = 0 ; dp[ 0 ][ 1 ] = - 999999 ; for i in range ( 0 , n): dp[i + 1 ][ 0 ] = max (dp[i][ 0 ] + a[i], dp[i][ 1 ] - a[i]); dp[i + 1 ][ 1 ] = max (dp[i][ 0 ] - a[i], dp[i][ 1 ] + a[i]); # Return the maximum sum return dp[n][ 0 ]; # Driver code if __name__ = = '__main__' : a = [ - 10 , 5 , - 4 ]; n = len (a); print (max_sum(a, n)); # This code is contributed by 29AjayKumar |
C#
// C# implementation of the approach using System; class GFG { // Function to return the maximum possible // sum after performing the given operation static int max_sum( int []a, int n) { // Dp vector to store the answer int [,]dp = new int [n + 1, 2]; // Base value dp[0, 0] = 0; dp[0, 1] = -999999; for ( int i = 0; i <= n - 1; i++) { dp[i + 1, 0] = Math.Max(dp[i, 0] + a[i], dp[i, 1] - a[i]); dp[i + 1, 1] = Math.Max(dp[i, 0] - a[i], dp[i, 1] + a[i]); } // Return the maximum sum return dp[n, 0]; } // Driver code public static void Main(String[] args) { int []a = { -10, 5, -4 }; int n = a.Length; Console.WriteLine(max_sum(a, n)); } } // This code is contributed by PrinciRaj1992 |
19
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.