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

You are given an integer array nums and a positive integer k.

Return the sum of the maximum and minimum elements of all subsequences of nums with at most k elements.

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

Note: A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: Subsequences of size ≤ 1: [2] gives 2+2=4, [1] gives 1+1=2. Total: 4+2=6

Example 2 — Multiple Sizes

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

› Output: 24

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

Example 3 — Edge Case

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

› Output: 10

💡 Note: Only one subsequence [5], max=5, min=5, so 5+5=10

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ k ≤ nums.length
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to use combinatorics after sorting to count how many times each element appears as maximum or minimum in subsequences. The brute force approach generates all subsequences (exponential time), while the optimal approach sorts the array and mathematically calculates each element's contribution. Best approach is sort and count with Time: O(n²), Space: O(1).

Common Approaches

✓ Stack

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

Generate All Subsequences

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

Generate every possible subsequence of size 1 to k, find the maximum and minimum element in each subsequence, and sum all these values together.

Sort and Count Contributions

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

Sort the array and use combinatorics to calculate how many subsequences each element appears in as the maximum or minimum element, then sum all contributions.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

const int MOD = 1000000007;
long long total = 0;

void generateSubsequences(int* nums, int numsSize, int idx, int* current, int currentSize, int sizeLimit) {
    if (currentSize > 0) {
        long long minVal = current[0];
        long long maxVal = current[0];
        for (int i = 1; i < currentSize; i++) {
            if (current[i] < minVal) minVal = current[i];
            if (current[i] > maxVal) maxVal = current[i];
        }
        total = (total + minVal + maxVal) % MOD;
    }
    
    if (currentSize >= sizeLimit || idx >= numsSize) {
        return;
    }
    
    for (int i = idx; i < numsSize; i++) {
        current[currentSize] = nums[i];
        generateSubsequences(nums, numsSize, i + 1, current, currentSize + 1, sizeLimit);
    }
}

long long solution(int* nums, int numsSize, int k) {
    total = 0;
    int* current = (int*)malloc(k * sizeof(int));
    generateSubsequences(nums, numsSize, 0, current, 0, k);
    free(current);
    return (total % MOD + MOD) % MOD;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* end = strchr(ptr, ']');
        if (end) *end = '\0';
        
        if (strlen(ptr) > 0) {
            char* token = ptr;
            while (token && *token) {
                while (*token == ' ') token++;
                if (*token == '\0') break;
                
                char* comma = strchr(token, ',');
                if (comma) *comma = '\0';
                
                nums[numsSize++] = (int)strtol(token, NULL, 10);
                
                if (comma) {
                    token = comma + 1;
                } else {
                    break;
                }
            }
        }
    }
    
    int k;
    scanf("%d", &k);
    
    long long result = solution(nums, numsSize, k);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

420 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