Find the Sum of Subsequence Powers - Practice Coding Problems

Find the Sum of Subsequence Powers - Problem

Find the Sum of Subsequence Powers

You're given an integer array nums of length n and a positive integer k. Your task is to find all possible subsequences of length k and calculate their "power" values.

The power of a subsequence is defined as the minimum absolute difference between any two elements in that subsequence. For example, if we have a subsequence [1, 5, 3], the power would be min(|1-5|, |1-3|, |5-3|) = min(4, 2, 2) = 2.

Goal: Return the sum of powers of all subsequences that have exactly k elements. Since the answer can be very large, return it modulo 10^9 + 7.

Note: A subsequence maintains the relative order of elements from the original array but doesn't need to be contiguous.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: All 3-element subsequences: [1,2,3] (power=1), [1,2,4] (power=1), [1,3,4] (power=1), [2,3,4] (power=1). Sum = 1+1+1+1 = 4

example_2.py — Different Powers

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

› Output: 0

💡 Note: Only one 2-element subsequence: [2,2]. The power is |2-2| = 0. Sum = 0

example_3.py — Single Element

$ Input: nums = [4, 3, -1], k = 1

› Output: 0

💡 Note: Single element subsequences have no pairs to compare, so power is undefined (we return 0 by convention)

Constraints

2 ≤ nums.length ≤ 50
1 ≤ k ≤ nums.length
-10⁸ ≤ nums[i] ≤ 10⁸
The answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify Subsequences

Find all possible subsequences of length k

Calculate Powers

For each subsequence, find minimum absolute difference between any two elements

Sum All Powers

Add up all the power values to get the final result

Key Takeaway

🎯 Key Insight: Instead of generating all possible subsequences (exponential time), sort the array first and use dynamic programming to count subsequences with specific minimum differences, dramatically reducing time complexity.

Asked in

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

This problem requires calculating the sum of minimum absolute differences across all possible subsequences of length k. The optimal approach uses dynamic programming with sorting to avoid generating all combinations explicitly. Key insights: sort the array first to optimize difference calculations, then use DP to count subsequences for each possible minimum difference value, applying inclusion-exclusion principle to get exact counts.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(C(n,k) * k²)	O(k)	Generate all subsequences of length k and calculate power for each
Dynamic Programming with Sorting	O(n³ × max_diff)	O(n² × max_diff)	Sort array first, then use DP to track subsequences with their minimum differences

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all combinations of k elements from the array
For each combination, calculate all pairwise absolute differences
Find the minimum difference (power) for each combination
Sum all powers and return modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible combinations of k elements

Calculate Power

For each combination, find minimum absolute difference

Sum Results

Add all powers together

Code -

solution.c — C

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

#define MOD 1000000007

long long result = 0;

void generateSubseq(int* nums, int n, int k, int start, int* current, int currentSize) {
    if (currentSize == k) {
        if (k == 1) return;
        long long minDiff = LLONG_MAX;
        for (int i = 0; i < currentSize; i++) {
            for (int j = i + 1; j < currentSize; j++) {
                long long diff = abs(current[i] - current[j]);
                if (diff < minDiff) {
                    minDiff = diff;
                }
            }
        }
        result = (result + minDiff) % MOD;
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = nums[i];
        generateSubseq(nums, n, k, i + 1, current, currentSize + 1);
    }
}

long long sumOfPowers(int* nums, int n, int k) {
    result = 0;
    int* current = (int*)malloc(k * sizeof(int));
    generateSubseq(nums, n, k, 0, current, 0);
    free(current);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * k²)

C(n,k) combinations, each requiring k² comparisons to find minimum difference

✓ Linear Growth

Space Complexity

O(k)

Space for storing current subsequence and recursion stack

✓ Linear Space

26.4K Views

Medium Frequency

~35 min Avg. Time

856 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