Skip to content
Related Articles

Related Articles

Maximum possible array sum after performing the given operation

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 29 May, 2022

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 = 19
Input: 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: 

  1. dp[0][0] = 0
  2. dp[0][1] = INT_MIN

Recurrence relation:  

  1. dp[i + 1][0] = max(dp[i][0] + arr[i], dp[i][1] – arr[i])
  2. 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

Javascript




<script>
// javascript implementation of the approach    // Function to return the maximum possible
    // sum after performing the given operation
    function max_sum(a , n) {
        // Dp vector to store the answer
        var dp = Array(n + 1).fill().map(()=>Array(2).fill(0));
 
        // Base value
        dp[0][0] = 0;
        dp[0][1] = -999999;
 
        for (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
     
        var a = [ -10, 5, -4 ];
        var n = a.length;
 
        document.write(max_sum(a, n));
 
// This code is contributed by todaysgaurav
</script>

Output: 

19

 

Time Complexity: O(N), as we are using a loop to traverse N times so it will cost us O(N) time.
Auxiliary Space: O(N), as we are using  extra space for DP.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!