Subsequence of Size K With the Largest Even Sum

Subsequence of Size K With the Largest Even Sum - Problem

Given an integer array nums and an integer k, you need to find a subsequence of exactly k elements that produces the largest even sum.

A subsequence maintains the relative order of elements from the original array, but you can skip any elements you don't need. Your goal is to select exactly k numbers that:

✅ Have the maximum possible sum
✅ The sum is even
✅ Contain exactly k elements

Return the largest even sum possible, or -1 if no such subsequence exists.

Example: For nums = [4, 1, 5, 3, 1] and k = 3, you could pick [4, 5, 3] with sum = 12 (even), but the optimal answer is [4, 5, 1] with sum = 10 (even and maximum possible even sum with 3 elements).

Input & Output

example_1.py — Basic Case

$ Input: nums = [4, 1, 5, 3, 1], k = 3

› Output: 12

💡 Note: We can select [4, 5, 3] which gives sum = 12 (even). This is the maximum even sum possible with 3 elements.

example_2.py — Requires Swapping

$ Input: nums = [4, 1, 5, 3, 1], k = 4

› Output: 14

💡 Note: Taking the 4 largest gives [4, 5, 3, 1] with sum = 13 (odd). We swap the smallest odd (1) with the largest even from remaining (none available), or swap smallest even (4) with largest odd (1), but that decreases sum. Best is [5, 3, 1, 1] = 10, but [4, 5, 3, 1] = 13 is odd. We need [4, 5, 3, 1] → swap 1 with remaining even numbers, but there are none. So we try [5, 3, 1, 1] = 10, then swap to get [4, 5, 3, 2] if 2 existed. Actually, the optimal is [4, 5, 3, 1] = 13 but it's odd. We need to check swaps: replace 1 with remaining even (none), or replace 4 with remaining odd (1), giving [1, 5, 3, 1] = 10. The answer should be 14 by including a different combination.

example_3.py — No Valid Solution

$ Input: nums = [1, 3, 5], k = 2

› Output: -1

💡 Note: All numbers are odd. Any sum of 2 numbers will be even (odd + odd = even). Best is [5, 3] = 8.

Visualization

Tap to expand

Understanding the Visualization

Survey the Cave

Sort all treasures by value (descending) to know what's available

Greedy Collection

Take the k most valuable treasures first - maximize raw value

Check the Curse

If total value is even, escape immediately! If odd, you're trapped...

Smart Exchange

Make the smallest possible trade with remaining treasures to break the curse while keeping value as high as possible

Key Takeaway

🎯 Key Insight: The greedy approach works because we can always 'fix' an odd sum by making minimal swaps between the smallest selected element of one parity and the largest unselected element of opposite parity, ensuring we maintain near-optimal value while satisfying the even sum constraint.

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * k)

We generate C(n,k) combinations and spend O(k) time calculating each sum

✓ Linear Growth

Space Complexity

O(k)

Space needed to store current combination and recursion stack

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
-10⁵ ≤ nums[i] ≤ 10⁵
The result will fit in a 64-bit signed integer

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a greedy approach with smart swapping. Sort numbers in descending order, select the k largest elements greedily. If the sum is even, return it. If odd, make the minimal swap between selected/unselected elements to convert to even while maximizing the sum. Time complexity: O(n log n) due to sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(C(n,k) * k)	O(k)	Generate all possible subsequences of size k and find the maximum even sum
Greedy with Smart Swapping (Optimal)	O(n log n)	O(n)	Sort elements, pick k largest greedily, then make optimal swaps to ensure even sum

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all combinations of k elements from nums
Calculate the sum for each combination
Filter combinations with even sums
Return the maximum even sum, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to choose k elements

Calculate Sums

Sum up elements in each combination

Filter Even Sums

Keep only combinations with even sums

Find Maximum

Return the largest even sum found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int maxEvenSum = -1;

void generateCombinations(int* nums, int n, int k, int start, int* current, int currentSize) {
    if (currentSize == k) {
        int sum = 0;
        for (int i = 0; i < k; i++) {
            sum += current[i];
        }
        if (sum % 2 == 0 && sum > maxEvenSum) {
            maxEvenSum = sum;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = nums[i];
        generateCombinations(nums, n, k, i + 1, current, currentSize + 1);
    }
}

int largestEvenSum(int* nums, int n, int k) {
    maxEvenSum = -1;
    int* current = (int*)malloc(k * sizeof(int));
    generateCombinations(nums, n, k, 0, current, 0);
    free(current);
    return maxEvenSum;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * k)

We generate C(n,k) combinations and spend O(k) time calculating each sum

✓ Linear Growth

Space Complexity

O(k)

Space needed to store current combination and recursion stack

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
-10⁵ ≤ nums[i] ≤ 10⁵
The result will fit in a 64-bit signed integer

43.6K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler