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.
