# Maximum possible array sum after performing the given operation

• 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] represents the maximum possible sum up to the ith index without flipping the ith index. dp[i] 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
2. dp = INT_MIN

Recurrence relation:

1. dp[i + 1] = max(dp[i] + arr[i], dp[i] – arr[i])
2. dp[i + 1] = max(dp[i] – arr[i], dp[i] + arr[i])

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``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 > dp(n + 1,``                            ``vector<``int``>(2, 0));` `    ``// Base value``    ``dp = 0, dp = -999999;` `    ``for` `(``int` `i = 0; i <= n - 1; i++) {``        ``dp[i + 1] = max(dp[i] + a[i],``                           ``dp[i] - a[i]);``        ``dp[i + 1] = max(dp[i] - a[i],``                           ``dp[i] + a[i]);``    ``}` `    ``// Return the maximum sum``    ``return` `dp[n];``}` `// Driver code``int` `main()``{``    ``int` `a[] = { -10, 5, -4 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);` `    ``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

 ``

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