Maximize difference between sum of even and odd-indexed elements of a subsequence

• Difficulty Level : Expert
• Last Updated : 20 May, 2021

Given an array arr[] consisting of N positive integers, the task is to find the maximum possible difference between the sum of even and odd-indexed elements of a subsequence from the given array.

Examples:

Input: arr[] = { 3, 2, 1, 4, 5, 2, 1, 7, 8, 9 }
Output: 15
Explanation:
Considering the subsequences { 3, 1, 5, 1, 9 } from the array
Sum of even-indexed array elements = 3 + 5 + 9 = 17
Sum of odd-indexed array elements = is 1 + 1 = 2
Therefore, the difference between the sum of even and odd-indexed elements present in the subsequence = (17 – 2) = 15, which is the maximum possible.

Input: arr[] = {1, 2, 3, 4, 5, 6}
Output: 6

Naive Approach: The simplest approach to solve this problem is to generate all possible subsequences of the given array and for each subsequence, calculate the difference between the sum of even and odd indexed elements of the subsequence. Finally, print the maximum difference obtained.

Time Complexity: O(2N)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to store the local maxima at even indices of the subsequence and store the local minima at odd indices of the subsequence. Finally, print the difference between the sum of even and odd indices of the subsequence.
Follow the steps below to solve the problem:

• Initialize a variable, say maxDiff, to store the maximum difference between the sum of even and odd-indexed elements of a subsequence.
• Traverse the array arr[] and check if arr[i] > arr[i + 1] and arr[i] < arr[i – 1] or not. If found to be true, then update maxDiff += arr[i].
• Otherwise, check if arr[i] > arr[i + 1] and arr[i] < arr[i – 1] or not. If found to be true, then update maxDiff -= arr[i].
• Finally, print the value of maxDiff.

Below is the implementation of the above approach:

C++

 // C++ program to implement// the above approach #include using namespace std; // Function to find the maximum possible difference// between sum of even and odd indicesint maxPossibleDiff(vector& arr, int N){     // Convert arr[] into 1-based indexing    arr.push_back(-1);     // Reverse the array    reverse(arr.begin(), arr.end());     // Convert arr[] into 1 based index    arr.push_back(-1);     // Reverse the array    reverse(arr.begin(), arr.end());     // Stores maximum difference between    // sum of even and odd indexed elements    int maxDiff = 0;     // Traverse the array    for (int i = 1; i <= N; i++) {         // If arr[i] is local maxima        if (arr[i] > arr[i - 1]            && arr[i] > arr[i + 1]) {             // Update maxDiff            maxDiff += arr[i];        }         // If arr[i] is local minima        if (arr[i] < arr[i - 1]            && arr[i] < arr[i + 1]) {             // Update maxDiff            maxDiff -= arr[i];        }    }    cout << maxDiff;} // Driver Codeint main(){     vector arr = { 3, 2, 1, 4, 5,                        2, 1, 7, 8, 9 };     // Size of array    int N = arr.size();     // Function Call    maxPossibleDiff(arr, N);     return 0;}

Java

 // Java program to implement// the above approachimport java.util.*; class GFG{ // Function to find the maximum possible// difference between sum of even and// odd indicesstatic void maxPossibleDiff(Vector arr, int N){         // Convert arr[] into 1-based indexing    arr.add(-1);     // Reverse the array    Collections.reverse(arr);     // Convert arr[] into 1 based index    arr.add(-1);     // Reverse the array    Collections.reverse(arr);     // Stores maximum difference between    // sum of even and odd indexed elements    int maxDiff = 0;     // Traverse the array    for(int i = 1; i <= N; i++)    {                 // If arr.get(i) is local maxima        if (arr.get(i) > arr.get(i - 1) &&            arr.get(i) > arr.get(i + 1))        {                         // Update maxDiff            maxDiff += arr.get(i);        }         // If arr.get(i) is local minima        if (arr.get(i) < arr.get(i - 1) &&            arr.get(i) < arr.get(i + 1))        {                         // Update maxDiff            maxDiff -= arr.get(i);        }    }    System.out.print(maxDiff);} // Driver Codepublic static void main(String[] args){    int[] array = { 3, 2, 1, 4, 5,                    2, 1, 7, 8, 9 };    Vector v = new Vector<>();    for(int i :array)    {        v.add(i);    }         // Size of array    int N = v.size();     // Function Call    maxPossibleDiff(v, N);}} // This code is contributed by shikhasingrajput

Python3

 #Python3 program to implement#the above approach  #Function to find the maximum possible difference#between sum of even and odd indicesdef maxPossibleDiff(arr,  N):     #Convert arr[] o 1-based indexing    arr.append(-1)     #Reverse the array    arr = arr[::-1]     #Convert arr[] o 1 based index    arr.append(-1)     #Reverse the array    arr = arr[::-1]     #Stores maximum difference between    #sum of even and odd indexed elements    maxDiff = 0     #Traverse the array    for i in range(1,N+1):         #If arr[i] is local maxima        if (arr[i] > arr[i - 1] and arr[i] > arr[i + 1]):             #Update maxDiff            maxDiff += arr[i]         #If arr[i] is local minima        if (arr[i] < arr[i - 1] and arr[i] < arr[i + 1]):             #Update maxDiff            maxDiff -= arr[i]    print (maxDiff) #Driver Codeif __name__ == '__main__':     arr = [3, 2, 1, 4, 5, 2, 1, 7, 8, 9]     #Size of array    N = len(arr)     #Function Call    maxPossibleDiff(arr, N)

C#

 // C# program to implement// the above approachusing System;using System.Collections.Generic; public class GFG{ // Function to find the maximum possible// difference between sum of even and// odd indicesstatic void maxPossibleDiff(List arr, int N){         // Convert []arr into 1-based indexing    arr.Add(-1);     // Reverse the array    arr.Reverse();     // Convert []arr into 1 based index    arr.Add(-1);     // Reverse the array    arr.Reverse();     // Stores maximum difference between    // sum of even and odd indexed elements    int maxDiff = 0;     // Traverse the array    for(int i = 1; i <= N; i++)    {                 // If arr[i] is local maxima        if (arr[i] > arr[i - 1] &&            arr[i] > arr[i + 1])        {                         // Update maxDiff            maxDiff += arr[i];        }         // If arr[i] is local minima        if (arr[i] < arr[i - 1] &&            arr[i] < arr[i + 1])        {                         // Update maxDiff            maxDiff -= arr[i];        }    }    Console.Write(maxDiff);} // Driver Codepublic static void Main(String[] args){    int[] array = { 3, 2, 1, 4, 5,                    2, 1, 7, 8, 9 };    List v = new List();    foreach(int i in array)    {        v.Add(i);    }         // Size of array    int N = v.Count;     // Function Call    maxPossibleDiff(v, N);}} // This code is contributed by 29AjayKumar

Javascript


Output:
15

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up