Maximum possible array sum after performing the given operation

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^th index. dp[i][1] represents the maximum possible sum up to the i^th index with flipping the i^th 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.