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

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

**Auxiliary Space:** O(N)

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live**