Maximum and Minimum Sums of at Most Size K Subsequences

Maximum and Minimum Sums of at Most Size K Subsequences - Problem

You're given an integer array nums and a positive integer k. Your task is to find the sum of maximum and minimum elements from all possible subsequences that have at most k elements.

A subsequence is a sequence that can be derived from the array by deleting some or no elements without changing the order of the remaining elements. For example, from array [3,1,4], valid subsequences include [3], [1,4], [3,1,4], etc.

For each valid subsequence, you need to:
• Find its maximum element
• Find its minimum element
• Add both to your running total

Since the answer can be very large, return it modulo 10⁹ + 7.

Example: For nums = [1,2,3] and k = 2:
• Subsequence [1]: max=1, min=1, contributes 2
• Subsequence [2]: max=2, min=2, contributes 4
• Subsequence [3]: max=3, min=3, contributes 6
• Subsequence [1,2]: max=2, min=1, contributes 3
• Subsequence [1,3]: max=3, min=1, contributes 4
• Subsequence [2,3]: max=3, min=2, contributes 5
Total: 2+4+6+3+4+5 = 24

Input & Output

example_1.py — Python

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

› Output: 24

💡 Note: Valid subsequences: [1]→2, [2]→4, [3]→6, [1,2]→3, [1,3]→4, [2,3]→5. Total: 2+4+6+3+4+5=24

example_2.py — Python

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

› Output: 6

💡 Note: Valid subsequences: [5]→10, [-2]→-4. Total: 10+(-4)=6

example_3.py — Python

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

› Output: 2

💡 Note: Only one subsequence [1] with max=1, min=1. Total: 1+1=2

Constraints

1 ≤ nums.length ≤ 20
1 ≤ k ≤ nums.length
-10⁵ ≤ nums[i] ≤ 10⁵
Answer fits in 32-bit signed integer after taking modulo

Visualization

Tap to expand

Understanding the Visualization

Rank Players

Sort players by skill level: [1, 2, 3]

Calculate Championships

For each player, count teams where they're the star (highest) or rookie (lowest)

Distribute Prizes

Multiply each player's score by number of teams they impact

Sum Total

Add all prize money: 4 + 8 + 12 = 24

Key Takeaway

🎯 Key Insight: Instead of generating all subsequences, calculate each element's total impact using its position in the sorted array and combinatorial formulas.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses combinatorial mathematics instead of generating all subsequences. Sort the array, then for each element, calculate how many subsequences it appears as maximum and minimum using combination formulas. This avoids the exponential time complexity of brute force while achieving O(n log n + n×k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n * n)	O(k)	Generate all possible subsequences of size ≤ k and calculate max/min contributions
Combinatorial Mathematics (Optimal)	O(n log n + n*k)	O(n)	Calculate contribution of each element as max/min using combinatorics

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all possible subsequences of the array with size ≤ k
For each subsequence, find its maximum and minimum elements
Add max + min to the total sum
Return the sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with array [1,2,3] and k=2

Generate

Use bitmasks to generate all subsequences

Filter

Keep only subsequences with size ≤ k

Calculate

Find max and min for each valid subsequence

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#define MOD 1000000007

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

int solution(int* nums, int n, int k) {
    long long total = 0;
    
    // Generate all subsequences using bit manipulation
    for (int mask = 1; mask < (1 << n); mask++) {
        int subsequence[20];
        int size = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[size++] = nums[i];
            }
        }
        
        // Only consider subsequences with at most k elements
        if (size <= k) {
            int maxVal = subsequence[0];
            int minVal = subsequence[0];
            for (int i = 1; i < size; i++) {
                maxVal = max(maxVal, subsequence[i]);
                minVal = min(minVal, subsequence[i]);
            }
            total = (total + maxVal + minVal) % MOD;
        }
    }
    
    return total;
}

int main() {
    int nums[] = {1, 2, 3};
    int n = 3, k = 2;
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n subsequences to generate, O(n) to find max/min in each

⚠ Quadratic Growth

Space Complexity

O(k)

Space for storing current subsequence during generation

✓ Linear Space

28.9K Views

Medium Frequency

~25 min Avg. Time

847 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 (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler