Open In App

# Maximum even sum subsequence of length K

Given an array arr[] consisting of N positive integers, and an integer K, the task is to find the maximum possible even sum of any subsequence of size K. If it is not possible to find any even sum subsequence of size K, then print -1.

Examples:

Input: arr[] ={4, 2, 6, 7, 8}, K = 3
Output: 18
Explanation: Subsequence having maximum even sum of size K( = 3 ) is {4, 6, 8}.
Therefore, the required output is 4 + 6 + 8 = 18.

Input: arr[] = {5, 5, 1, 1, 3}, K = 3
Output: -1

Naive Approach: The simplest approach to solve this problem to generate all possible subsequences of size K from the given array and print the value of the maximum possible even sum the possible subsequences of the given array.

Time Complexity: O(K * NK)
Auxiliary Space: O(K)

Efficient Approach: To optimize the above approach the idea is to store all even and odd numbers of the given array into two separate arrays and sort both these arrays. Finally, use the Greedy technique to calculate the maximum sum even subsequence of size K. Follow the steps below to solve the problem:

• Initialize a variable, say maxSum to store the maximum even sum of a subsequence of the given array.
• Initialize two arrays, say Even[] and Odd[] to store all the even numbers and odd numbers of the given array respectively.
• Traverse the given array and store all the even numbers and odd numbers of the given array into Even[] and Odd[] array respectively.
• Sort Even[] and Odd[] arrays.
• Initialize two variables, say i and j to store the index of Even[] and Odd[] array respectively.
• Traverse Even[], Odd[] arrays and check the following conditions:
• If K % 2 == 1 then increment the value of maxSum by Even[i].
• Otherwise, increment the value of  maxSum by max(Even[i] + Even[i – 1], Odd[j] + Odd[j – 1]).
• Finally, print the value of maxSum.

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 even sum of any``// subsequence of length K``int` `evenSumK(``int` `arr[], ``int` `N, ``int` `K)``{` `    ``// If count of elements``    ``// is less than K``    ``if` `(K > N) {``        ``return` `-1;``    ``}` `    ``// Stores maximum``    ``// even subsequence sum``    ``int` `maxSum = 0;` `    ``// Stores Even numbers``    ``vector<``int``> Even;` `    ``// Stores Odd numbers``    ``vector<``int``> Odd;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If current element``        ``// is an odd number``        ``if` `(arr[i] % 2) {` `            ``// Insert odd number``            ``Odd.push_back(arr[i]);``        ``}``        ``else` `{` `            ``// Insert even numbers``            ``Even.push_back(arr[i]);``        ``}``    ``}` `    ``// Sort Odd[] array``    ``sort(Odd.begin(), Odd.end());` `    ``// Sort Even[] array``    ``sort(Even.begin(), Even.end());` `    ``// Stores current index``    ``// Of Even[] array``    ``int` `i = Even.size() - 1;` `    ``// Stores current index``    ``// Of Odd[] array``    ``int` `j = Odd.size() - 1;` `    ``while` `(K > 0) {` `        ``// If K is odd``        ``if` `(K % 2 == 1) {` `            ``// If count of elements``            ``// in Even[] >= 1``            ``if` `(i >= 0) {` `                ``// Update maxSum``                ``maxSum += Even[i];` `                ``// Update i``                ``i--;``            ``}` `            ``// If count of elements``            ``// in Even[] array is 0.``            ``else` `{``                ``return` `-1;``            ``}` `            ``// Update K``            ``K--;``        ``}` `        ``// If count of elements``        ``// in Even[] and odd[] >= 2``        ``else` `if` `(i >= 1 && j >= 1) {` `            ``if` `(Even[i] + Even[i - 1]``                ``<= Odd[j] + Odd[j - 1]) {` `                ``// Update maxSum``                ``maxSum += Odd[j] + Odd[j - 1];` `                ``// Update j.``                ``j -= 2;``            ``}``            ``else` `{` `                ``// Update maxSum``                ``maxSum += Even[i] + Even[i - 1];` `                ``// Update i``                ``i -= 2;``            ``}` `            ``// Update K``            ``K -= 2;``        ``}` `        ``// If count of elements``        ``// in Even[] array >= 2.``        ``else` `if` `(i >= 1) {` `            ``// Update maxSum``            ``maxSum += Even[i] + Even[i - 1];` `            ``// Update i.``            ``i -= 2;` `            ``// Update K.``            ``K -= 2;``        ``}` `        ``// If count of elements``        ``// in Odd[] array >= 1``        ``else` `if` `(j >= 1) {` `            ``// Update maxSum``            ``maxSum += Odd[j] + Odd[j - 1];` `            ``// Update i.``            ``j -= 2;` `            ``// Update K.``            ``K -= 2;``        ``} ``else` `{``           ``return` `-1;``        ``}``    ``}` `    ``return` `maxSum;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 4, 10, 3, 5 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `K = 3;``    ``cout << evenSumK(arr, N, K);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the``    ``// maximum even sum of any``    ``// subsequence of length K``    ``static` `int` `evenSumK(``int` `arr[], ``int` `N, ``int` `K)``    ``{` `        ``// If count of elements``        ``// is less than K``        ``if` `(K > N) {``            ``return` `-``1``;``        ``}` `        ``// Stores maximum even``        ``// subsequence sum``        ``int` `maxSum = ``0``;` `        ``// Stores Even numbers``        ``ArrayList Even = ``new` `ArrayList();` `        ``// Stores Odd numbers``        ``ArrayList Odd = ``new` `ArrayList();` `        ``// Traverse the array``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// If current element``            ``// is an odd number``            ``if` `(arr[i] % ``2` `== ``1``) {` `                ``// Insert odd number``                ``Odd.add(arr[i]);``            ``}``            ``else` `{` `                ``// Insert even numbers``                ``Even.add(arr[i]);``            ``}``        ``}` `        ``// Sort Odd[] array``        ``Collections.sort(Odd);` `        ``// Sort Even[] array``        ``Collections.sort(Even);` `        ``// Stores current index``        ``// Of Even[] array``        ``int` `i = Even.size() - ``1``;` `        ``// Stores current index``        ``// Of Odd[] array``        ``int` `j = Odd.size() - ``1``;` `        ``while` `(K > ``0``) {` `            ``// If K is odd``            ``if` `(K % ``2` `== ``1``) {` `                ``// If count of elements``                ``// in Even[] >= 1``                ``if` `(i >= ``0``) {` `                    ``// Update maxSum``                    ``maxSum += Even.get(i);` `                    ``// Update i``                    ``i--;``                ``}` `                ``// If count of elements``                ``// in Even[] array is 0.``                ``else` `{``                    ``return` `-``1``;``                ``}` `                ``// Update K``                ``K--;``            ``}` `            ``// If count of elements``            ``// in Even[] and odd[] >= 2``            ``else` `if` `(i >= ``1` `&& j >= ``1``) {``                ``if` `(Even.get(i) + Even.get(i - ``1``)``                    ``<= Odd.get(j) + Odd.get(j - ``1``)) {` `                    ``// Update maxSum``                    ``maxSum += Odd.get(j) + Odd.get(j - ``1``);` `                    ``// Update j``                    ``j -= ``2``;``                ``}``                ``else` `{` `                    ``// Update maxSum``                    ``maxSum += Even.get(i) + Even.get(i - ``1``);` `                    ``// Update i``                    ``i -= ``2``;``                ``}` `                ``// Update K``                ``K -= ``2``;``            ``}` `            ``// If count of elements``            ``// in Even[] array >= 2.``            ``else` `if` `(i >= ``1``) {` `                ``// Update maxSum``                ``maxSum += Even.get(i) + Even.get(i - ``1``);` `                ``// Update i``                ``i -= ``2``;` `                ``// Update K``                ``K -= ``2``;``            ``}` `            ``// If count of elements``            ``// in Odd[] array >= 1``            ``else` `if` `(j >= ``1``) {` `                ``// Update maxSum``                ``maxSum += Odd.get(j) + Odd.get(j - ``1``);` `                ``// Update i.``                ``j -= ``2``;` `                ``// Update K.``                ``K -= ``2``;``            ``}``            ``else``             ``return` `-``1``;``        ``}``        ``return` `maxSum;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``2``, ``4``, ``10``, ``3``, ``5` `};``        ``int` `N = arr.length;``        ``int` `K = ``3``;` `        ``System.out.println(evenSumK(arr, N, K));``    ``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the``# maximum even sum of any``# subsequence of length K`  `def` `evenSumK(arr, N, K):` `    ``# If count of elements``    ``# is less than K``    ``if` `(K > N):``        ``return` `-``1` `    ``# Stores maximum``    ``# even subsequence sum``    ``maxSum ``=` `0` `    ``# Stores Even numbers``    ``Even ``=` `[]` `    ``# Stores Odd numbers``    ``Odd ``=` `[]` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):` `        ``# If current element``        ``# is an odd number``        ``if` `(arr[i] ``%` `2``):` `            ``# Insert odd number``            ``Odd.append(arr[i])` `        ``else``:` `            ``# Insert even numbers``            ``Even.append(arr[i])` `    ``# Sort Odd[] array``    ``Odd.sort(reverse``=``False``)` `    ``# Sort Even[] array``    ``Even.sort(reverse``=``False``)` `    ``# Stores current index``    ``# Of Even[] array``    ``i ``=` `len``(Even) ``-` `1` `    ``# Stores current index``    ``# Of Odd[] array``    ``j ``=` `len``(Odd) ``-` `1` `    ``while` `(K > ``0``):` `        ``# If K is odd``        ``if` `(K ``%` `2` `=``=` `1``):` `            ``# If count of elements``            ``# in Even[] >= 1``            ``if` `(i >``=` `0``):` `                ``# Update maxSum``                ``maxSum ``+``=` `Even[i]` `                ``# Update i``                ``i ``-``=` `1` `            ``# If count of elements``            ``# in Even[] array is 0.``            ``else``:``                ``return` `-``1` `            ``# Update K``            ``K ``-``=` `1` `        ``# If count of elements``        ``# in Even[] and odd[] >= 2``        ``elif` `(i >``=` `1` `and` `j >``=` `1``):``            ``if` `(Even[i] ``+` `Even[i ``-` `1``] <``=``                    ``Odd[j] ``+` `Odd[j ``-` `1``]):` `                ``# Update maxSum``                ``maxSum ``+``=` `Odd[j] ``+` `Odd[j ``-` `1``]` `                ``# Update j.``                ``j ``-``=` `2` `            ``else``:` `                ``# Update maxSum``                ``maxSum ``+``=` `Even[i] ``+` `Even[i ``-` `1``]` `                ``# Update i``                ``i ``-``=` `2` `            ``# Update K``            ``K ``-``=` `2` `        ``# If count of elements``        ``# in Even[] array >= 2.``        ``elif` `(i >``=` `1``):` `            ``# Update maxSum``            ``maxSum ``+``=` `Even[i] ``+` `Even[i ``-` `1``]` `            ``# Update i.``            ``i ``-``=` `2` `            ``# Update K.``            ``K ``-``=` `2` `        ``# If count of elements``        ``# in Odd[] array >= 2``        ``elif` `(j >``=` `1``):` `            ``# Update maxSum``            ``maxSum ``+``=` `Odd[j] ``+` `Odd[j ``-` `1``]` `            ``# Update i.``            ``j ``-``=` `2` `            ``# Update K.``            ``K ``-``=` `2``            ` `        ``else``:``          ``return` `-``1``;` `    ``return` `maxSum`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``2``, ``4``, ``9``]``    ``N ``=` `len``(arr)``    ``K ``=` `3` `    ``print``(evenSumK(arr, N, K))` `# This code is contributed by ipg2016107`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `    ``// Function to find the``    ``// maximum even sum of any``    ``// subsequence of length K``    ``static` `int` `evenSumK(``int``[] arr, ``int` `N, ``int` `K)``    ``{``        ``// If count of elements``        ``// is less than K``        ``if` `(K > N) {``            ``return` `-1;``        ``}` `        ``// Stores maximum even``        ``// subsequence sum``        ``int` `maxSum = 0;` `        ``// Stores Even numbers``        ``List<``int``> Even = ``new` `List<``int``>();` `        ``// Stores Odd numbers``        ``List<``int``> Odd = ``new` `List<``int``>();` `        ``// Traverse the array``        ``for` `(``int` `l = 0; l < N; l++) {``            ``// If current element``            ``// is an odd number``            ``if` `(arr[l] % 2 == 1) {``                ``// Insert odd number``                ``Odd.Add(arr[l]);``            ``}``            ``else` `{``                ``// Insert even numbers``                ``Even.Add(arr[l]);``            ``}``        ``}` `        ``// Sort Odd[] array``        ``Odd.Sort();` `        ``// Sort Even[] array``        ``Even.Sort();` `        ``// Stores current index``        ``// Of Even[] array``        ``int` `i = Even.Count - 1;` `        ``// Stores current index``        ``// Of Odd[] array``        ``int` `j = Odd.Count - 1;` `        ``while` `(K > 0) {``            ``// If K is odd``            ``if` `(K % 2 == 1) {``                ``// If count of elements``                ``// in Even[] >= 1``                ``if` `(i >= 0) {``                    ``// Update maxSum``                    ``maxSum += Even[i];` `                    ``// Update i``                    ``i--;``                ``}` `                ``// If count of elements``                ``// in Even[] array is 0.``                ``else` `{``                    ``return` `-1;``                ``}` `                ``// Update K``                ``K--;``            ``}` `            ``// If count of elements``            ``// in Even[] and odd[] >= 2``            ``else` `if` `(i >= 1 && j >= 1) {``                ``if` `(Even[i] + Even[i - 1]``                    ``<= Odd[j] + Odd[j - 1]) {``                    ``// Update maxSum``                    ``maxSum += Odd[j] + Odd[j - 1];` `                    ``// Update j``                    ``j -= 2;``                ``}``                ``else` `{``                    ``// Update maxSum``                    ``maxSum += Even[i] + Even[i - 1];` `                    ``// Update i``                    ``i -= 2;``                ``}` `                ``// Update K``                ``K -= 2;``            ``}` `            ``// If count of elements``            ``// in Even[] array >= 2.``            ``else` `if` `(i >= 1) {``                ``// Update maxSum``                ``maxSum += Even[i] + Even[i - 1];` `                ``// Update i``                ``i -= 2;` `                ``// Update K``                ``K -= 2;``            ``}` `            ``// If count of elements``            ``// in Odd[] array >= 2``            ``else` `if` `(j >= 1) {``                ``// Update maxSum``                ``maxSum += Odd[j] + Odd[j - 1];` `                ``// Update i.``                ``j -= 2;` `                ``// Update K.``                ``K -= 2;``            ``}``            ``else``             ``return` `-1;``        ``}``        ``return` `maxSum;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = { 2, 4, 10, 3, 5 };``        ``int` `N = arr.Length;``        ``int` `K = 3;``        ``Console.WriteLine(evenSumK(arr, N, K));``    ``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output

`18`

Time Complexity: O(N * log N)
Auxiliary Space: O(N)