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 **i ^{th}** index without flipping the

**i**index.

^{th}**dp[i][1]**represents the maximum possible sum up to the

**i**index with flipping the

^{th}**i**index. So, dp(n, 0) is our required answer.

^{th}**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; ` `} ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

**Output:**

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.

## Recommended Posts:

- Maximum score possible after performing given operations on an Array
- Count of distinct possible strings after performing given operations
- Maximum count of values of S modulo M lying in a range [L, R] after performing given operations on the array
- Maximum possible GCD after replacing at most one element in the given array
- Maximum value obtained by performing given operations in an Array
- Maximum sum increasing subsequence from a prefix and a given element after prefix is must
- Maximum subarray sum in an array created after repeated concatenation
- Maximum sum subarray after altering the array
- Maximum Sum possible by selecting X elements from a Matrix based on given conditions
- Maximum sum possible for a sub-sequence such that no two elements appear at a distance < K in the array
- Maximum Subarray Sum possible by replacing an Array element by its Square
- Maximum sum subarray having sum less than or equal to given sum using Set
- Maximize sum of remaining elements after every removal of the array half with greater sum
- Sum of products of all possible K size subsets of the given array
- Maximize Sum possible from an Array by the given moves
- Minimum possible sum of prices of a Triplet from the given Array
- Maximum Subarray Sum after inverting at most two elements
- Maximum sum possible for every node by including it in a segment of N-Ary Tree
- Maximum subsequence sum possible by multiplying each element by its index
- Check if N can be converted to the form K power K by the given operation

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.