Find the Sum of the Power of All Subsequences

Find the Sum of the Power of All Subsequences - Problem

You are given an integer array nums of length n and a positive integer k. Your task is to find the sum of power of all subsequences of the array.

The power of any subsequence is defined as the number of its sub-subsequences that sum to k. For example, if a subsequence is [2, 3, 5] and k = 5, then its power is the count of all combinations from [2, 3, 5] that sum to 5 (which would be [2, 3] and [5], so power = 2).

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

Example: If nums = [1, 2, 3] and k = 3, we need to:

Find all possible subsequences of [1, 2, 3]
For each subsequence, count how many of its sub-subsequences sum to 3
Sum all these counts together

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: All subsequences: [1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]. For [3]: sub-subsequences are [],[3] → power=1 (only [3] sums to 3). For [1,2]: sub-subsequences are [],[1],[2],[1,2] → power=1 (only [1,2] sums to 3). For [1,2,3]: 8 sub-subsequences, power=3 ([3],[1,2] sum to 3). Total = 1+1+3+1 = 6

example_2.py — Small Values

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

› Output: 4

💡 Note: Subsequence [2,3] appears twice (using first or second 3), each contributing 1 to power. Subsequence [2,3,3] has sub-subsequences that sum to 5: [2,3] (2 ways). Total power = 1+1+2 = 4

example_3.py — Edge Case

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

› Output: 1

💡 Note: Only one subsequence [1]. Its sub-subsequences are [] (sum=0) and [1] (sum=1). Only [1] sums to k=1, so power=1. Total=1

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
1 ≤ k ≤ 100
Answer fits in 32-bit integer after modulo operation

Visualization

Tap to expand

Understanding the Visualization

Form Committees

Each subsequence is like a committee that decides which treasure chests to consider

Create Maps

Each committee creates all possible treasure maps from their chosen chests

Count Winning Maps

For each committee, count how many maps lead to exactly k coins

Sum All Powers

Add up the power (winning map count) from all committees

Key Takeaway

🎯 Key Insight: Use dynamic programming to count element contributions across all subsequences simultaneously, avoiding the exponential cost of explicit generation.

Asked in

G Google 32 f Meta 28 a Amazon 24 ⊞ Microsoft 18

This problem requires dynamic programming to efficiently count subsequence contributions. The key insight is to track three states for each element: not selected, selected for subsequence only, or selected for both subsequence and sub-subsequence. This avoids the exponential O(4^n) brute force approach and achieves O(n²k) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n * n * k)	O(n * k)	Use 3D DP to track element contributions across all subsequences efficiently

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table dp[i][j][s] representing ways to use first i elements with j elements in subsequence summing to s
For each element, consider three transitions: skip entirely, include in subsequence only, include in both subsequence and sub-subsequence
Track the number of ways to form subsequences and their contributing sub-subsequences
Sum up all ways that result in sub-subsequences with sum k
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Start with base case: empty subsequence with sum 0

Process Element

For each element, consider three choices: skip, include in subsequence only, include in both

Update States

Update DP states based on transitions

Accumulate Result

Add contributions from states that sum to k

Code -

solution.c — C

int sumOfPower(int* nums, int numsSize, int k) {
    const int MOD = 1000000007;
    int n = numsSize;
    
    // Allocate DP table
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)calloc(k + 1, sizeof(int));
    }
    dp[0][0] = 1;
    
    long long result = 0;
    
    for (int i = 0; i < n; i++) {
        int** newDp = (int**)malloc((n + 1) * sizeof(int*));
        for (int j = 0; j <= n; j++) {
            newDp[j] = (int*)calloc(k + 1, sizeof(int));
        }
        
        for (int j = 0; j <= i; j++) {
            for (int s = 0; s <= k; s++) {
                if (dp[j][s] == 0) continue;
                
                newDp[j][s] = (newDp[j][s] + dp[j][s]) % MOD;
                newDp[j + 1][s] = (newDp[j + 1][s] + dp[j][s]) % MOD;
                
                if (s + nums[i] <= k) {
                    newDp[j + 1][s + nums[i]] = (newDp[j + 1][s + nums[i]] + dp[j][s]) % MOD;
                }
            }
        }
        
        // Free old dp and assign new one
        for (int j = 0; j <= n; j++) {
            free(dp[j]);
        }
        free(dp);
        dp = newDp;
        
        for (int j = 1; j <= i + 1; j++) {
            result = (result + dp[j][k]) % MOD;
        }
    }
    
    // Cleanup
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * n * k)

Three nested loops: n elements, up to n elements in subsequence, and sums up to k

✓ Linear Growth

Space Complexity

O(n * k)

Can be optimized to 2D by processing elements one at a time

⚡ Linearithmic Space

28.4K Views

High Frequency

~25 min Avg. Time

892 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler