Related Articles

Related Articles

Maximum possible array sum after performing the given operation
  • Last Updated : 05 Dec, 2019

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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


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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :