Longest Subsequence With Limited Sum

Longest Subsequence With Limited Sum - Problem

Array Binary Search Greedy Sorting Prefix Sum Easy

You are given an integer array nums of length n, and an integer array queries of length m.

Return an array answer of length m where answer[i] is the maximum size of a subsequence that you can take from nums such that the sum of its elements is less than or equal to queries[i].

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.

Input & Output

Example 1 — Basic Multiple Queries

$ Input: nums = [4,5,2,1], queries = [3,10,21]

› Output: [2,3,4]

💡 Note: For query 3: best subsequence is [2,1] with sum=3, count=2. For query 10: best is [4,2,1] or [5,2,1] with sum≤10, count=3. For query 21: all elements [4,5,2,1] sum=12≤21, count=4.

Example 2 — Single Element Array

$ Input: nums = [2], queries = [1,3]

› Output: [0,1]

💡 Note: For query 1: element 2>1, so no elements fit, count=0. For query 3: element 2≤3, so one element fits, count=1.

Example 3 — Small Query Limits

$ Input: nums = [10,20,30], queries = [5,15,25]

› Output: [0,1,1]

💡 Note: For query 5: no elements ≤5, count=0. For query 15: only 10≤15, count=1. For query 25: only 10≤25 (since 10+20=30>25), count=1.

Constraints

1 ≤ nums.length, queries.length ≤ 1000
1 ≤ nums[i], queries[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 12 G Google 8 M Microsoft 6

The key insight is that to maximize the count of elements with a limited sum, we should always pick the smallest elements first. The best approach sorts the array once, builds prefix sums, then uses binary search for each query. Time: O(n log n + m log n), Space: O(n).

Common Approaches

✓ One Pass Hash

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

Brute Force - Try All Subsequences

⏱️ Time: O(m × 2ⁿ × n) Space: O(1)

For each query, generate all 2^n possible subsequences of nums, calculate their sums, and count how many have sum ≤ query limit. Return the maximum count found.

Greedy - Sort and Pick Smallest

⏱️ Time: O(n log n + m × n) Space: O(1)

To maximize the count of elements with limited sum, we should always pick the smallest available elements first. Sort the array once, then for each query, iterate from smallest elements until the sum would exceed the limit.

Prefix Sum + Binary Search

⏱️ Time: O(n log n + m log n) Space: O(n)

After sorting nums in ascending order, we compute prefix sums. For each query, we use binary search on the prefix sum array to find the largest index where prefix[i] ≤ query. This gives us the maximum count efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int value;
    int index;
} Item;

typedef struct {
    Item* items;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->items = malloc(capacity * sizeof(Item));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(Item* a, Item* b) {
    Item temp = *a;
    *a = *b;
    *b = temp;
}

int compare(Item a, Item b) {
    if (a.value != b.value) return a.value - b.value;
    return a.index - b.index;
}

void heapifyUp(MinHeap* heap, int index) {
    if (index == 0) return;
    int parent = (index - 1) / 2;
    if (compare(heap->items[index], heap->items[parent]) < 0) {
        swap(&heap->items[index], &heap->items[parent]);
        heapifyUp(heap, parent);
    }
}

void heapifyDown(MinHeap* heap, int index) {
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int smallest = index;
    
    if (left < heap->size && compare(heap->items[left], heap->items[smallest]) < 0)
        smallest = left;
    if (right < heap->size && compare(heap->items[right], heap->items[smallest]) < 0)
        smallest = right;
    
    if (smallest != index) {
        swap(&heap->items[index], &heap->items[smallest]);
        heapifyDown(heap, smallest);
    }
}

void push(MinHeap* heap, Item item) {
    heap->items[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

Item pop(MinHeap* heap) {
    Item min = heap->items[0];
    heap->items[0] = heap->items[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

long long* solution(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    // Create heap and add all elements
    MinHeap* heap = createHeap(numsSize);
    for (int i = 0; i < numsSize; i++) {
        Item item = {nums[i], i};
        push(heap, item);
    }
    
    bool* marked = calloc(numsSize, sizeof(bool));
    long long* result = malloc(queriesSize * sizeof(long long));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int index = queries[q][0];
        int k = queries[q][1];
        
        // Mark element at specified index
        marked[index] = true;
        
        // Mark k smallest unmarked elements
        Item* temp = malloc(numsSize * sizeof(Item));
        int tempSize = 0;
        int count = 0;
        
        while (heap->size > 0 && count < k) {
            Item curr = pop(heap);
            temp[tempSize++] = curr;
            
            if (!marked[curr.index]) {
                marked[curr.index] = true;
                count++;
            }
        }
        
        // Put back all elements
        for (int i = 0; i < tempSize; i++) {
            push(heap, temp[i]);
        }
        
        // Calculate sum of unmarked elements
        long long total = 0;
        for (int i = 0; i < numsSize; i++) {
            if (!marked[i]) {
                total += nums[i];
            }
        }
        result[q] = total;
        
        free(temp);
    }
    
    free(heap->items);
    free(heap);
    free(marked);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

26.8K Views

Medium Frequency

~15 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