Minimum Subsequence in Non-Increasing Order

Minimum Subsequence in Non-Increasing Order - Problem

🎯 Find the Minimum Subsequence with Maximum Impact

You're given an array nums and need to find a special subsequence that packs the biggest punch with the smallest size!

Your mission: Find a subsequence where the sum of its elements is strictly greater than the sum of all the elements you left behind.

The twist: If multiple subsequences work, you want:

🏆 Minimum size (fewer elements preferred)
💰 Maximum sum (if sizes are equal, pick the one with larger total)
📉 Non-increasing order (return result sorted from largest to smallest)

Example: Given [4,3,10,9,8], you could pick [10,9] with sum 19, which is greater than the remaining sum [4,3,8] = 15. Perfect! ✨

The problem guarantees a unique solution exists, so no need to worry about ties!

Input & Output

example_1.py — Basic Case

$ Input: [4,3,10,9,8]

› Output: [10,9]

💡 Note: The sum of [10,9] is 19, which is greater than the sum of remaining elements [4,3,8] = 15. This is the minimum size subsequence that satisfies the condition.

example_2.py — Tie-breaking

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

› Output: [7,7,6]

💡 Note: Multiple subsequences work, but [7,7,6] has sum 20 > remaining 8, and it's the optimal choice following our criteria (minimum size, maximum sum).

example_3.py — Single Element

$ Input: [6]

› Output: [6]

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

Constraints

1 ≤ nums.length ≤ 500
1 ≤ nums[i] ≤ 100
The answer is guaranteed to be unique
The subsequence must be returned in non-increasing order

Visualization

Tap to expand

Understanding the Visualization

Arrange by Value

Line up all treasure coins from most valuable to least valuable

Greedy Selection

Pick coins one by one, always choosing the most valuable remaining coin

Check Progress

After each coin, check if you have more than the remaining treasure

Stop Condition

Stop as soon as your coins are worth more than what's left behind

Key Takeaway

🎯 Key Insight: The greedy approach works because taking the largest elements first always leads to the minimum subsequence size needed to satisfy the sum condition, automatically maximizing the sum for any given size.

Asked in

a Amazon 15 G Google 8 ⊞ Microsoft 5 f Meta 3

The optimal solution uses a greedy approach: sort the array in descending order and keep selecting the largest elements until their sum exceeds the remaining sum. This guarantees the minimum subsequence size with maximum sum, automatically satisfying all constraints in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsequences)	O(2^n)	O(2^n)	Generate all possible subsequences and find the best one that meets our criteria
Greedy Approach (Optimal)	O(n log n)	O(n)	Sort elements in descending order and greedily pick the largest elements until sum condition is met

Brute Force (Try All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation or recursion
For each subsequence, calculate its sum and the remaining elements' sum
Filter subsequences where subsequence_sum > remaining_sum
Among valid subsequences, find ones with minimum size
Among minimum-size subsequences, pick the one with maximum sum
Sort the result in non-increasing order

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsequences

Create every possible combination using bit manipulation

Check Each Combination

For each subsequence, verify if its sum > remaining sum

Find Best Match

Among valid subsequences, pick minimum size with maximum sum

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* minSubsequence(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 bestSize = INT_MAX;
    int bestSum = 0;
    int bestCount = 0;
    
    // Try all possible subsequences
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subseq[20];  // Assuming max 20 elements
        int subseqSum = 0;
        int count = 0;
        
        // Build current subsequence
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subseq[count++] = nums[i];
                subseqSum += nums[i];
            }
        }
        
        // Check if valid and better
        int remainingSum = totalSum - subseqSum;
        if (subseqSum > remainingSum) {
            if (count < bestSize || (count == bestSize && subseqSum > bestSum)) {
                for (int i = 0; i < count; i++) {
                    bestSubseq[i] = subseq[i];
                }
                bestSize = count;
                bestSum = subseqSum;
                bestCount = count;
            }
        }
    }
    
    qsort(bestSubseq, bestCount, sizeof(int), compare);
    *returnSize = bestCount;
    return bestSubseq;
}

int main() {
    int nums[100];
    int size = 0;
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = minSubsequence(nums, size, &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(2^n)

We generate 2^n subsequences, and for each we do O(n) work to calculate sums

⚠ Quadratic Growth

Space Complexity

O(2^n)

We might store all subsequences in memory to compare them

⚠ Quadratic Space

28.4K Views

Medium Frequency

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

🎯 Find the Minimum Subsequence with Maximum Impact

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler