Find the Sum of Subsequence Powers

Find the Sum of Subsequence Powers - Problem

You are given an integer array nums of length n, and a positive integer k.

The power of a subsequence is defined as the minimum absolute difference between any two elements in the subsequence.

Return the sum of powers of all subsequences of nums which have length equal to k.

Since the answer may be large, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: All subsequences of length 3: [1,2,3] (min diff = 1), [1,2,4] (min diff = 1), [1,3,4] (min diff = 1), [2,3,4] (min diff = 1). Sum = 1+1+1+1 = 4

Example 2 — Different Powers

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

› Output: 0

💡 Note: Only one subsequence [2,2] with minimum absolute difference |2-2| = 0. Sum = 0

Example 3 — Single Element

$ Input: nums = [10,7,3], k = 1

› Output: 0

💡 Note: When k=1, subsequences have only one element, so no pairs exist to calculate differences. Sum = 0

Constraints

2 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50
2 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to recognize that we need to count subsequences grouped by their minimum absolute difference. The best approach uses sorting + dynamic programming to systematically count subsequences for each possible minimum difference. Time: O(n² × k × max_diff), Space: O(n × k × max_diff)

Common Approaches

✓ Generate All Subsequences

⏱️ Time: O(C(n,k) × k²) Space: O(k)

Use backtracking to generate every possible subsequence of length k, then for each subsequence calculate the minimum absolute difference between all pairs and sum them up.

Memoized Recursion

⏱️ Time: O(n × k × max_diff × 2^n) Space: O(n × k × max_diff)

Define a recursive function that tries to build subsequences while tracking the minimum difference seen so far. Use memoization to cache results for the same position, remaining count, and current minimum difference.

Sort + Dynamic Programming

⏱️ Time: O(n² × k × max_diff) Space: O(n × k × max_diff)

Sort the array so we can systematically consider each possible minimum difference. Use dynamic programming where dp[i][j][d] represents number of ways to choose j elements ending at index i with minimum difference d.

Generate All Subsequences — Algorithm Steps

Generate all subsequences of length k using backtracking
For each subsequence, find minimum absolute difference between all pairs
Sum all the powers and return modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible subsequences of length k

Calculate

Find minimum difference in each subsequence

Sum

Add all powers together

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 1000

long long result = 0;

void backtrack(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];
        backtrack(nums, n, k, i + 1, current, currentSize + 1);
    }
}

int solution(int* nums, int n, int k) {
    result = 0;
    int* current = (int*)malloc(k * sizeof(int));
    backtrack(nums, n, k, 0, current, 0);
    free(current);
    return (int)result;
}

int parseArray(char* line, int* nums) {
    int count = 0;
    char* ptr = line;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Handle empty array case
    while (*ptr == ' ') ptr++;
    if (*ptr == ']') return 0;
    
    while (*ptr) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        
        if (*ptr == ']') break;
        
        // Parse number
        if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            nums[count] = (int)strtol(ptr, &ptr, 10);
            count++;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    char line1[10000];
    char line2[100];
    static int nums[MAX_N];
    
    // Read first line (array)
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    
    // Read second line (k)
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    int n = parseArray(line1, nums);
    int k = atoi(line2);
    
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

C(n,k) subsequences, each requiring O(k²) to find minimum difference

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth and temporary subsequence storage

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

234 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

Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler