Minimum Subsequence in Non-Increasing Order

Minimum Subsequence in Non-Increasing Order - Problem

Given the array nums, obtain a subsequence of the array whose sum of elements is strictly greater than the sum of the non-included elements in such subsequence.

If there are multiple solutions, return the subsequence with minimum size and if there still exist multiple solutions, return the subsequence with the maximum total sum of all its elements.

A subsequence of an array can be obtained by erasing some (possibly zero) elements from the array.

Note that the solution with the given constraints is guaranteed to be unique. Also return the answer sorted in non-increasing order.

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,3,10,9]

› Output: [10,9]

💡 Note: Total sum = 26. We need subsequence sum > remaining sum. Taking [10,9] gives sum=19 > remaining sum=7. This is minimum size (2) and already sorted in non-increasing order.

Example 2 — Single Element

$ Input: nums = [4,4,7,6,7]

› Output: [7,7,6]

💡 Note: Total sum = 28. Need sum > 14. Taking largest elements [7,7,6] gives sum=20 > remaining sum=8. This achieves the required condition with minimum size.

Example 3 — Edge Case

$ Input: nums = [6]

› Output: [6]

💡 Note: With only one element, we must take it. Sum=6 > remaining sum=0, so [6] is the answer.

Constraints

1 ≤ nums.length ≤ 500
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The key insight is to use a greedy approach: sort elements in descending order and pick the largest ones until the subsequence sum dominates. This naturally gives the minimum size solution with maximum sum. Best approach is Greedy with Sorting. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Subsequences

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

Generate all 2^n possible subsequences, check each one to see if its sum is greater than the remaining elements' sum, then select the one that meets the criteria (minimum size, maximum sum, non-increasing order).

Greedy with Sorting

⏱️ Time: O(n log n) Space: O(1)

Sort the array in descending order, then greedily add the largest elements to our subsequence until the subsequence sum becomes greater than the remaining sum. This ensures minimum size and maximum sum.

Brute Force - Try All Subsequences — Algorithm Steps

Step 1: Generate all possible subsequences using bit manipulation
Step 2: For each subsequence, check if its sum > remaining sum
Step 3: Among valid subsequences, pick minimum size with maximum sum
Step 4: Sort the result in non-increasing order

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all 2^n possible subsequences using bit manipulation

Check Valid

Test if subsequence sum > remaining sum

Find Best

Select minimum size with maximum sum, sorted descending

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int* solution(int* nums, int numsSize, int* returnSize) {
    int totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    
    int* bestSubseq = (int*)malloc(numsSize * sizeof(int));
    int minSize = INT_MAX;
    int maxSum = -1;
    *returnSize = 0;
    
    // Try all possible subsequences using bit manipulation
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subseq[1000];
        int subseqSize = 0;
        int subseqSum = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subseq[subseqSize++] = nums[i];
                subseqSum += nums[i];
            }
        }
        
        int remainingSum = totalSum - subseqSum;
        
        // Check if this subsequence is valid
        if (subseqSum > remainingSum) {
            // Check if this is better than current best
            if (subseqSize < minSize ||
                (subseqSize == minSize && subseqSum > maxSum)) {
                minSize = subseqSize;
                maxSum = subseqSum;
                qsort(subseq, subseqSize, sizeof(int), compare);
                for (int i = 0; i < subseqSize; i++) {
                    bestSubseq[i] = subseq[i];
                }
                *returnSize = subseqSize;
            }
        }
    }
    
    return bestSubseq;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    char *token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

Generate 2^n subsequences, each takes O(n) to process

✓ Linear Growth

Space Complexity

O(n)

Store the best subsequence found so far

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~12 min Avg. Time

890 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

Brute Force - Try All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler