Sum of Subsequence Widths - Practice Coding Problems

Sum of Subsequence Widths - Problem

Imagine you have an array of integers, and you want to explore all possible subsequences (sequences formed by removing some or no elements while maintaining order). Each subsequence has a width - the difference between its maximum and minimum elements.

Your task is to find the sum of widths of all non-empty subsequences.

Example: For array [2, 1, 3], the subsequences are:

[2] → width = 2 - 2 = 0
[1] → width = 1 - 1 = 0
[3] → width = 3 - 3 = 0
[2, 1] → width = 2 - 1 = 1
[2, 3] → width = 3 - 2 = 1
[1, 3] → width = 3 - 1 = 2
[2, 1, 3] → width = 3 - 1 = 2

Total sum = 0 + 0 + 0 + 1 + 1 + 2 + 2 = 6

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

Input & Output

example_1.py — Basic Case

$ Input: [2, 1, 3]

› Output: 6

💡 Note: Subsequences: [2]→0, [1]→0, [3]→0, [2,1]→1, [2,3]→1, [1,3]→2, [2,1,3]→2. Sum = 6

example_2.py — Single Element

$ Input: [1]

› Output: 0

💡 Note: Only one subsequence [1] with width = 1-1 = 0

example_3.py — Two Elements

$ Input: [5, 3]

› Output: 4

💡 Note: Subsequences: [5]→0, [3]→0, [5,3]→2. Sum = 4 (after modulo, but result is small)

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Sort Musicians by Height

Arrange in ascending order to establish clear max/min relationships

Calculate Individual Contributions

Each person contributes positively when tallest in group, negatively when shortest

Sum All Contributions

Add up positive and negative contributions to get total visual impact

Key Takeaway

🎯 Key Insight: Mathematical optimization transforms an exponential brute force problem into O(n log n) by calculating each element's net contribution across all subsequences.

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22

The optimal solution uses mathematical insight: after sorting the array, each element's contribution can be calculated based on how many subsequences it appears in as maximum vs minimum. Element at position i appears as maximum in 2ⁱ subsequences and as minimum in 2^(n-1-i) subsequences, giving us O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(n * 2^n)	O(n)	Generate all possible subsequences and calculate width for each
Mathematical Optimization (Optimal)	O(n log n)	O(n)	Sort array and calculate each element's contribution mathematically

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation
For each subsequence, find minimum and maximum elements
Calculate width as max - min
Add to total sum with modulo operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Representation

Each number from 1 to 2^n-1 represents a subsequence

Bit Check

Check each bit position to include/exclude elements

Width Calculation

Find min/max in each subsequence and calculate width

Code -

solution.c — C

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

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

int sumSubseqWidths(int* nums, int n) {
    const int MOD = 1000000007;
    long long total = 0;
    
    // Generate all 2^n subsequences
    for (int mask = 1; mask < (1 << n); mask++) {
        int subseq[20], count = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseq[count++] = nums[i];
            }
        }
        
        if (count > 0) {
            int maxVal = subseq[0], minVal = subseq[0];
            for (int i = 1; i < count; i++) {
                maxVal = max(maxVal, subseq[i]);
                minVal = min(minVal, subseq[i]);
            }
            total = (total + maxVal - minVal) % MOD;
        }
    }
    
    return (int)total;
}

int main() {
    int nums[20], n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", sumSubseqWidths(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n)

We generate 2^n subsequences, and for each we scan up to n elements to find min/max

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current subsequence and temporary variables

⚡ Linearithmic Space

42.0K Views

Medium-High Frequency

~18 min Avg. Time

1.9K 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