Find the K-Sum of an Array

Find the K-Sum of an Array - Problem

You are given an integer array nums and a positive integer k. You can choose any subsequence of the array and sum all of its elements together.

We define the K-Sum of the array as the kth largest subsequence sum that can be obtained (not necessarily distinct).

Return the K-Sum of the array.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Note: The empty subsequence is considered to have a sum of 0.

Input & Output

Example 1 — 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,-2], so the 5th largest is 2

Example 2 — All Positive

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

› Output: 2

💡 Note: Subsequence sums: [3,2,2,2,1,1,1,0], so the 3rd largest is 2

Example 3 — Mixed Numbers

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

› Output: 4

💡 Note: Subsequence sums sorted: [6,5,4,3,1,0,-1,-2], the 3rd largest is 4

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ min(2000, 2^nums.length)

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to transform the problem by separating positive and negative numbers, then use a priority queue to generate the k largest subsequence sums efficiently. Best approach uses heap-based state generation with Time: O(k log k), Space: O(k).

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Generate All Subsequences

⏱️ Time: O(2ⁿ × n + 2ⁿ × log(2ⁿ)) Space: O(2ⁿ)

Generate every possible subsequence using bit manipulation, calculate each sum, sort all sums in descending order, and return the kth element.

Priority Queue with State Generation

⏱️ Time: O(k × log k) Space: O(k)

Transform negative numbers to positive, use a max-heap to generate subsequence sums in descending order by considering each element as either included or excluded.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_HEAP_SIZE 4000

typedef struct {
    long long sum;
    int mask;
} HeapNode;

typedef struct {
    HeapNode data[MAX_HEAP_SIZE];
    int size;
} MaxHeap;

void heapify_down(MaxHeap* heap, int idx) {
    int largest = idx;
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    
    if (left < heap->size && heap->data[left].sum > heap->data[largest].sum) {
        largest = left;
    }
    if (right < heap->size && heap->data[right].sum > heap->data[largest].sum) {
        largest = right;
    }
    
    if (largest != idx) {
        HeapNode temp = heap->data[idx];
        heap->data[idx] = heap->data[largest];
        heap->data[largest] = temp;
        heapify_down(heap, largest);
    }
}

void heapify_up(MaxHeap* heap, int idx) {
    if (idx == 0) return;
    int parent = (idx - 1) / 2;
    if (heap->data[idx].sum > heap->data[parent].sum) {
        HeapNode temp = heap->data[idx];
        heap->data[idx] = heap->data[parent];
        heap->data[parent] = temp;
        heapify_up(heap, parent);
    }
}

void push_heap(MaxHeap* heap, long long sum, int mask) {
    if (heap->size >= MAX_HEAP_SIZE) return;
    heap->data[heap->size].sum = sum;
    heap->data[heap->size].mask = mask;
    heapify_up(heap, heap->size);
    heap->size++;
}

HeapNode pop_heap(MaxHeap* heap) {
    HeapNode result = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    if (heap->size > 0) {
        heapify_down(heap, 0);
    }
    return result;
}

int is_visited(int* visited, int count, int mask) {
    for (int i = 0; i < count; i++) {
        if (visited[i] == mask) return 1;
    }
    return 0;
}

long long kSum(int* nums, int n, int k) {
    // Convert negative numbers to positive and adjust the maximum sum
    static int pos_nums[100005];
    long long max_sum = 0;
    
    for (int i = 0; i < n; i++) {
        if (nums[i] >= 0) {
            pos_nums[i] = nums[i];
            max_sum += nums[i];
        } else {
            pos_nums[i] = -nums[i];
        }
    }
    
    // Use heap to find k-th largest
    static MaxHeap heap;
    heap.size = 0;
    static int visited[MAX_HEAP_SIZE];
    int visited_count = 0;
    
    // Start with maximum possible sum
    push_heap(&heap, max_sum, 0);
    visited[visited_count++] = 0;
    
    for (int i = 0; i < k; i++) {
        if (heap.size == 0) break;
        
        HeapNode current = pop_heap(&heap);
        
        if (i == k - 1) {
            return current.sum;
        }
        
        // Generate next states by flipping bits
        for (int j = 0; j < n; j++) {
            int new_mask = current.mask | (1 << j);
            if (new_mask != current.mask && !is_visited(visited, visited_count, new_mask)) {
                long long new_sum;
                if (nums[j] >= 0) {
                    new_sum = current.sum - pos_nums[j];
                } else {
                    new_sum = current.sum - pos_nums[j];
                }
                
                push_heap(&heap, new_sum, new_mask);
                if (visited_count < MAX_HEAP_SIZE) {
                    visited[visited_count++] = new_mask;
                }
            }
        }
    }
    
    return 0;
}

int main() {
    static int nums[100005];
    int n = 0, k;
    char input[1000000];
    
    // Read array
    fgets(input, sizeof(input), stdin);
    
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\t')) ptr++;
        if (*ptr == ']') break;
        
        if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            nums[n++] = (int)strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    // Read k
    scanf("%d", &k);
    
    printf("%lld\n", kSum(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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