Find the K-Sum of an Array - Practice Coding Problems

Find the K-Sum of an Array - Problem

Find the K-Sum of an Array

You're given an integer array nums and a positive integer k. Your task is to find the kth largest subsequence sum possible from the array.

A subsequence is formed by selecting any elements from the array while maintaining their original order (you can skip elements, but can't rearrange them). You can calculate the sum of each possible subsequence, and we want the kth largest among all these sums.

Key Points:
• The empty subsequence has a sum of 0
• Duplicate sums are counted separately for ranking
• We want the kth largest sum, not necessarily distinct

Example: For array [2, 4, -2] with k = 5:
All possible subsequence sums: [6, 4, 2, 2, 0, -2, -2, -4]
Sorted in descending order: [6, 4, 2, 2, 0, -2, -2, -4]
The 5th largest sum is 0.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 4, -2], k = 5

› Output: 2

💡 Note: All subsequence sums in descending order: [6, 4, 4, 2, 2, 0, -2, -4]. The 5th largest is 2.

example_2.py — All Positive Numbers

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

› Output: 3

💡 Note: Subsequence sums: [6, 5, 4, 3, 3, 2, 1, 0]. The 4th largest sum is 3.

example_3.py — Single Element

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

› Output: 5

💡 Note: Only two possible sums: [5, 0]. The 1st largest (maximum) is 5.

Constraints

1 ≤ nums.length ≤ 20
-10⁵ ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 2^nums.length
The kth sum is guaranteed to exist

Visualization

Tap to expand

Understanding the Visualization

Start with Maximum

Begin with the theoretical best treasure combination (all positive values)

Use Smart Queue

Use a priority queue to always explore the most promising combinations first

Generate Variants

For each combination, create variants by adding/removing one treasure at a time

Track Explored

Keep track of explored combinations to avoid revisiting the same path

Key Takeaway

🎯 Key Insight: By using a priority queue and smart state generation, we can find the kth largest sum in O(k log k) time instead of generating all 2^n subsequences!

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 15

The optimal approach uses a max-heap (priority queue) to efficiently find the k largest subsequence sums without generating all 2^n possibilities. We start with the maximum possible sum and systematically explore the next-best options by toggling elements between inclusion and exclusion, using a visited set to avoid duplicates.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue with Binary Search Optimization	O(min(2^n, k) * log(min(2^n, k)))	O(min(2^n, k))	Use max-heap to efficiently find k largest sums without generating all subsequences
Brute Force (Generate All Subsequences)	O(2^n * n)	O(2^n)	Generate all 2^n possible subsequence sums and find the kth largest

Priority Queue with Binary Search Optimization — Algorithm Steps

Separate positive and negative numbers, sort both appropriately
Calculate the maximum possible sum (sum of all positive numbers)
Use a max-heap starting with the maximum sum state
For each state, generate child states by toggling the next element
Use a set to avoid duplicate states
Extract k elements from the heap to get the kth largest sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with maximum possible sum in the heap

Pop and Explore

Pop the largest sum and generate neighbor states

Generate Neighbors

For each position, create new states by toggling inclusion

Continue Until K

Repeat until we've found the kth largest sum

Code -

solution.c — C

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

// Simplified C implementation
long long kSum(int* nums, int n, int k) {
    // For demonstration, using brute force approach in C
    // due to complexity of implementing priority queue in C
    
    int total = 1 << n;
    long long* sums = (long long*)malloc(total * sizeof(long long));
    
    // Generate all subsequence sums
    for (int mask = 0; mask < total; mask++) {
        long long currentSum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                currentSum += nums[i];
            }
        }
        sums[mask] = currentSum;
    }
    
    // Simple selection sort for top k elements
    for (int i = 0; i < k; i++) {
        for (int j = i + 1; j < total; j++) {
            if (sums[j] > sums[i]) {
                long long temp = sums[i];
                sums[i] = sums[j];
                sums[j] = temp;
            }
        }
    }
    
    long long result = sums[k - 1];
    free(sums);
    return result;
}

int main() {
    int nums[] = {2, 4, -2};
    int k = 5;
    printf("%lld\n", kSum(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(min(2^n, k) * log(min(2^n, k)))

In practice much better than brute force, as we only explore the k largest sums

⚠ Quadratic Growth

Space Complexity

O(min(2^n, k))

Space for the heap and visited set, bounded by min(2^n, k)

⚠ Quadratic Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Priority Queue with Binary Search Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler