Given an array arr[] consisting of N positive integers, the task is to find the maximum sum of subsequences from the given array such that elements in the subsequence are assigned positive and negative signs alternately.
Subsequence = {a, b, c, d, e, … },
Sum of the above subsequence = (a – b + c – d + e – …)
Examples:
Input: arr[] = {1, 2, 3, 4}
Output: 4
Explanation:
The subsequence having maximum sum is {4}.
The sum is 4.Input: arr[]= {1, 2, 3, 4, 1, 2 }
Output: 5
Explanation:
The subsequence having maximum sum is {4, 1, 2}.
The sum = 4 -1 + 2 = 5.
Naive Approach: The simplest approach is to generate all the subsequences of the given array and then find the sum for every subsequence and print the maximum among all the sum of the subsequences.
Time Complexity: O(N*2N)
Auxiliary Space: O(1)
Efficient Approach: To optimize the above approach, the idea is to use Dynamic Programming. Initialize an auxiliary space dp[][] of size N*2 to store the Overlapping Subproblems. In each recursive call, add arr[i] or (-1)*arr[i] to the sum with the respective flag variable that denotes whether the current element is positive or negative. Below are the steps:
- Create a 2D dp[][] array of size N*2 and initialize the array with the -1.
- Pass the variable flag that denotes the sign of the element have to pick in the next term. For Example, in the subsequence, {a, b, c}, then the maximum subsequence can be (a – b + c) or (b – c) or c. Instead of recurring for all the Overlapping Subproblems, again and again, store once in dp[][] array and use the recurring state.
- If the flag is 0 then the current element is to be considered as a positive element and if the flag is 1 then the current element is to be considered as a negative element.
- Store every result into the dp[][] array.
- Print the value of dp[N][flag] as the maximum sum after the above steps.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the // maximum sum subsequence int findMax(vector< int >& a, int dp[][2],
int i, int flag)
{ // Base Case
if (i == ( int )a.size()) {
return 0;
}
// If current state is already
// calculated then use it
if (dp[i][flag] != -1) {
return dp[i][flag];
}
int ans;
// If current element is positive
if (flag == 0) {
// Update ans and recursively
// call with update value of flag
ans = max(findMax(a, dp, i + 1, 0),
a[i]
+ findMax(a, dp,
i + 1, 1));
}
// Else current element is negative
else {
// Update ans and recursively
// call with update value of flag
ans = max(findMax(a, dp, i + 1, 1),
-1 * a[i]
+ findMax(a, dp,
i + 1, 0));
}
// Return maximum sum subsequence
return dp[i][flag] = ans;
} // Function that finds the maximum // sum of element of the subsequence // with alternate +ve and -ve signs void findMaxSumUtil(vector< int >& arr,
int N)
{ // Create auxiliary array dp[][]
int dp[N][2];
// Initialize dp[][]
memset (dp, -1, sizeof dp);
// Function Call
cout << findMax(arr, dp, 0, 0);
} // Driver Code int main()
{ // Given array arr[]
vector< int > arr = { 1, 2, 3, 4, 1, 2 };
int N = arr.size();
// Function Call
findMaxSumUtil(arr, N);
return 0;
} |
// Java program for the above approach import java.io.*;
import java.util.Arrays;
class GFG{
// Function to find the // maximum sum subsequence static int findMax( int [] a, int dp[][],
int i, int flag)
{ // Base Case
if (i == ( int )a.length)
{
return 0 ;
}
// If current state is already
// calculated then use it
if (dp[i][flag] != - 1 )
{
return dp[i][flag];
}
int ans;
// If current element is positive
if (flag == 0 )
{
// Update ans and recursively
// call with update value of flag
ans = Math.max(findMax(a, dp, i + 1 , 0 ),
a[i] + findMax(a, dp, i + 1 , 1 ));
}
// Else current element is negative
else
{
// Update ans and recursively
// call with update value of flag
ans = Math.max(findMax(a, dp, i + 1 , 1 ),
- 1 * a[i] + findMax(a, dp, i + 1 , 0 ));
}
// Return maximum sum subsequence
return dp[i][flag] = ans;
} // Function that finds the maximum // sum of element of the subsequence // with alternate +ve and -ve signs static void findMaxSumUtil( int [] arr,
int N)
{ // Create auxiliary array dp[][]
int dp[][] = new int [N][ 2 ];
// Initialize dp[][]
for ( int i = 0 ; i < N; i++)
{
for ( int j = 0 ; j < 2 ; j++)
{
dp[i][j] = - 1 ;
}
}
// Function Call
System.out.println(findMax(arr, dp, 0 , 0 ));
} // Driver Code public static void main (String[] args)
{ // Given array arr[]
int [] arr = { 1 , 2 , 3 , 4 , 1 , 2 };
int N = arr.length;
// Function call
findMaxSumUtil(arr, N);
} } // This code is contributed by sanjoy_62 |
# Python3 program for the above approach # Function to find the # maximum sum subsequence def findMax(a, dp, i, flag):
# Base Case
if (i = = len (a)):
return 0
# If current state is already
# calculated then use it
if (dp[i][flag] ! = - 1 ):
return dp[i][flag]
ans = 0
# If current element is positive
if (flag = = 0 ):
# Update ans and recursively
# call with update value of flag
ans = max (findMax(a, dp, i + 1 , 0 ),
a[i] + findMax(a, dp, i + 1 , 1 ))
# Else current element is negative
else :
# Update ans and recursively
# call with update value of flag
ans = max (findMax(a, dp, i + 1 , 1 ),
- 1 * a[i] + findMax(a, dp, i + 1 , 0 ))
# Return maximum sum subsequence
dp[i][flag] = ans
return ans
# Function that finds the maximum # sum of element of the subsequence # with alternate +ve and -ve signs def findMaxSumUtil(arr, N):
# Create auxiliary array dp[][]
dp = [[ - 1 for i in range ( 2 )]
for i in range (N)]
# Function call
print (findMax(arr, dp, 0 , 0 ))
# Driver Code if __name__ = = '__main__' :
# Given array arr[]
arr = [ 1 , 2 , 3 , 4 , 1 , 2 ]
N = len (arr)
# Function call
findMaxSumUtil(arr, N)
# This code is contributed by mohit kumar 29 |
// C# program for the above approach using System;
class GFG {
// Function to find the // maximum sum subsequence static int findMax( int [] a, int [,] dp,
int i, int flag)
{ // Base Case
if (i == ( int )a.Length)
{
return 0;
}
// If current state is already
// calculated then use it
if (dp[i, flag] != -1)
{
return dp[i, flag];
}
int ans;
// If current element is positive
if (flag == 0)
{
// Update ans and recursively
// call with update value of flag
ans = Math.Max(findMax(a, dp, i + 1, 0),
a[i] + findMax(a, dp, i + 1, 1));
}
// Else current element is negative
else
{
// Update ans and recursively
// call with update value of flag
ans = Math.Max(findMax(a, dp, i + 1, 1),
-1 * a[i] + findMax(a, dp, i + 1, 0));
}
// Return maximum sum subsequence
return dp[i, flag] = ans;
} // Function that finds the maximum // sum of element of the subsequence // with alternate +ve and -ve signs static void findMaxSumUtil( int [] arr,
int N)
{ // Create auxiliary array dp[][]
int [,] dp = new int [N, 2];
// Initialize dp[][]
for ( int i = 0; i < N; i++)
{
for ( int j = 0; j < 2; j++)
{
dp[i, j] = -1;
}
}
// Function Call
Console.WriteLine(findMax(arr, dp, 0, 0));
} // Driver Code public static void Main()
{ // Given array arr[]
int [] arr = { 1, 2, 3, 4, 1, 2 };
int N = arr.Length;
// Function call
findMaxSumUtil(arr, N);
} } // This code is contributed by code_hunt |
<script> // Javascript program for the above approach // Function to find the // maximum sum subsequence function findMax(a, dp, i, flag)
{ // Base Case
if (i == a.length)
{
return 0;
}
// If current state is already
// calculated then use it
if (dp[i][flag] != -1)
{
return dp[i][flag];
}
let ans;
// If current element is positive
if (flag == 0)
{
// Update ans and recursively
// call with update value of flag
ans = Math.max(findMax(a, dp, i + 1, 0),
a[i] + findMax(a, dp, i + 1, 1));
}
// Else current element is negative
else
{
// Update ans and recursively
// call with update value of flag
ans = Math.max(findMax(a, dp, i + 1, 1),
-1 * a[i] + findMax(a, dp, i + 1, 0));
}
// Return maximum sum subsequence
return dp[i][flag] = ans;
} // Function that finds the maximum // sum of element of the subsequence // with alternate +ve and -ve signs function findMaxSumUtil(arr, N)
{ // Create auxiliary array dp[][]
let dp = new Array(N);
// Loop to create 2D array using 1D array
for ( var i = 0; i < dp.length; i++)
{
dp[i] = new Array(2);
}
// Initialize dp[][]
for (let i = 0; i < N; i++)
{
for (let j = 0; j < 2; j++)
{
dp[i][j] = -1;
}
}
// Function Call
document.write(findMax(arr, dp, 0, 0));
} // Driver code // Given array arr[] let arr = [ 1, 2, 3, 4, 1, 2 ]; let N = arr.length; // Function call findMaxSumUtil(arr, N); // This code is contributed by splevel62 </script> |
5
Time Complexity: O(N)
Auxiliary Space: O(N)
Efficient Approach: Using the DP Tabulation method ( Iterative approach )
The approach to solving this problem is the same but the DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because the memoization method needs extra stack space for recursion calls.
Steps to solve this problem :
- Create a table DP to store the solution of the subproblems.
- Initialize the table with base cases
- Now Iterate over subproblems to get the value of the current problem from the previous computation of subproblems stored in DP.
- Return the final solution stored in dp[0]0].
Implementation :
// C++ program for above approach #include <bits/stdc++.h> using namespace std;
// Function to find the // maximum sum subsequence int findMax(vector< int >& a, int N)
{ int dp[N][2];
// Initializing the base case
dp[N-1][0] = a[N-1];
dp[N-1][1] = 0;
// iterate over subproblems to get the current value
// from previous computation stored in DP
for ( int i = N-2; i >= 0; i--) {
// Update current value in DP
dp[i][0] = max(dp[i+1][0], a[i]+dp[i+1][1]);
dp[i][1] = max(dp[i+1][1], -1*a[i]+dp[i+1][0]);
}
// return ans
return dp[0][0];
} // Driver Code int main()
{ vector< int > arr = { 1, 2, 3, 4, 1, 2 };
int N = arr.size();
// function Call
cout << findMax(arr, N);
return 0;
} // this code is contributed by bhardwajji |
import java.util.*;
public class Main {
// Function to find the maximum sum subsequence
public static int findMax(List<Integer> a, int N) {
int [][] dp = new int [N][ 2 ];
// Initializing the base case
dp[N- 1 ][ 0 ] = a.get(N- 1 );
dp[N- 1 ][ 1 ] = 0 ;
// iterate over subproblems to get the current value
// from previous computation stored in DP
for ( int i = N- 2 ; i >= 0 ; i--) {
// Update current value in DP
dp[i][ 0 ] = Math.max(dp[i+ 1 ][ 0 ], a.get(i)+dp[i+ 1 ][ 1 ]);
dp[i][ 1 ] = Math.max(dp[i+ 1 ][ 1 ], - 1 *a.get(i)+dp[i+ 1 ][ 0 ]);
}
// return ans
return dp[ 0 ][ 0 ];
}
// Driver Code
public static void main(String[] args) {
List<Integer> arr = new ArrayList<>(Arrays.asList( 1 , 2 , 3 , 4 , 1 , 2 ));
int N = arr.size();
// function Call
System.out.println(findMax(arr, N));
}
} |
# Python program for the above approach # Function to find the maximum element def findMax(a, N):
dp = [[ 0 for i in range ( 2 )] for j in range (N)]
# Initializing the base case
dp[N - 1 ][ 0 ] = a[N - 1 ]
dp[N - 1 ][ 1 ] = 0
# Iterate over subproblems to get the
# current value from previous computation
# stored in DP
for i in range (N - 2 , - 1 , - 1 ):
# Update current value in DP
dp[i][ 0 ] = max (dp[i + 1 ][ 0 ], a[i] + dp[i + 1 ][ 1 ])
dp[i][ 1 ] = max (dp[i + 1 ][ 1 ], - 1 * a[i] + dp[i + 1 ][ 0 ])
# return ans
return dp[ 0 ][ 0 ]
# Driver Code arr = [ 1 , 2 , 3 , 4 , 1 , 2 ]
N = len (arr)
print (findMax(arr, N))
|
using System;
class MaxSumSubsequence {
// Function to find the maximum sum
// of the subsequence
static int findMax( int [] a, int N)
{
int [, ] dp = new int [N, 2];
// Initializing the base case
dp[N - 1, 0] = a[N - 1];
dp[N - 1, 1] = 0;
// iterate over subproblems to get
// the current value from previous
// computation stored in DP
for ( int i = N - 2; i >= 0; i--) {
// Update current value in DP
dp[i, 0] = Math.Max(dp[i + 1, 0],
a[i] + dp[i + 1, 1]);
dp[i, 1] = Math.Max(dp[i + 1, 1],
-1 * a[i] + dp[i + 1, 0]);
}
// Return the ans
return dp[0, 0];
}
// Driver Code
static void Main()
{
int [] arr = { 1, 2, 3, 4, 1, 2 };
int N = arr.Length;
Console.WriteLine(findMax(arr, N));
}
} |
function findMax(arr, N) {
let dp = new Array(N);
for (let i = 0; i < N; i++) {
dp[i] = new Array(2);
}
// Initializing the base case
dp[N - 1][0] = arr[N - 1];
dp[N - 1][1] = 0;
// iterate over subproblems to get
// the current value from previous
// computation stored in DP
for (let i = N - 2; i >= 0; i--) {
// Update current value in DP
dp[i][0] = Math.max(dp[i + 1][0], arr[i] + dp[i + 1][1]);
dp[i][1] = Math.max(dp[i + 1][1], -1 * arr[i] + dp[i + 1][0]);
}
// Return the ans
return dp[0][0];
} // Driver Code let arr = [1, 2, 3, 4, 1, 2]; let N = arr.length; console.log(findMax(arr, N)); |
Output:
5
Time Complexity: O(N)
Auxiliary Space: O(N)