Codestin Search App

Find Sum of Array Product of Magical Sequences - Problem

Array Math Dynamic Programming Bit Manipulation Combinatorics Bitmask Hard

🔮 Find Sum of Array Product of Magical Sequences

You're given an array nums and two integers m and k. Your task is to find all magical sequences and calculate the sum of their array products.

A sequence seq of m indices is considered magical if:

It contains exactly m elements
Each element seq[i] is a valid index: 0 ≤ seq[i] < nums.length
The binary representation of 2^seq[0] + 2^seq[1] + ... + 2^seq[m-1] has exactly k set bits (1s)

The array product of a sequence is: nums[seq[0]] × nums[seq[1]] × ... × nums[seq[m-1]]

Example: If seq = [0, 2] and nums = [3, 1, 4], then the array product is nums[0] × nums[2] = 3 × 4 = 12.

Return the sum of array products for all valid magical sequences modulo 10^9 + 7.

Input & Output

example_1.py — Basic case

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

› Output: 34

💡 Note: Magical sequences: [0,1] (2^0+2^1=3, bits=2, product=2×3=6), [0,2] (2^0+2^2=5, bits=2, product=2×4=8), [1,2] (2^1+2^2=6, bits=2, product=3×4=12). Sum = 6+8+12 = 26. Wait, let me recalculate: For [0,1]: mask=0b11, bits=2, product=6. For [0,2]: mask=0b101, bits=2, product=8. For [1,2]: mask=0b110, bits=2, product=12. Total=26.

example_2.py — Single element

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

› Output: 6

💡 Note: For m=1, k=1, we need sequences of length 1 where 2^seq[0] has exactly 1 set bit. This is true for any single index. Sequences: [0] (product=1), [1] (product=2), [2] (product=3). Sum = 1+2+3 = 6.

example_3.py — No valid sequences

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

› Output: 0

💡 Note: For m=2, k=1, we need sequences of length 2 where the binary sum has exactly 1 set bit. The only sequence [0,1] gives 2^0+2^1=3, which has 2 set bits, not 1. Therefore, no valid magical sequences exist.

Constraints

1 ≤ nums.length ≤ 20
1 ≤ m ≤ nums.length
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁹
The array product can be very large, hence return modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Choose Items

Select exactly m items from the magical collection

Calculate Power

Sum the powers: 2^pos1 + 2^pos2 + ... + 2^posm

Count Energy Sparks

Count set bits in the binary representation of the power sum

Validate Magic

If sparks equal k, multiply item values and add to total

Key Takeaway

🎯 Key Insight: Use dynamic programming to efficiently explore all combinations while tracking both the number of selected elements and set bits, avoiding the exponential time complexity of brute force.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses dynamic programming with memoization to efficiently calculate the sum of array products for magical sequences. By tracking states (position, bitmask, count, set bits), we avoid redundant calculations and achieve much better performance than the brute force approach. The key insight is that we can build up solutions incrementally while maintaining the constraints on sequence length and set bit count.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(n * 2^n * m * k)	O(n * 2^n * m * k)	Use DP to track products and bit counts simultaneously
Brute Force (Generate All Combinations)	O(n^m * m)	O(m)	Generate all possible sequences of m indices and check each one

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Initialize DP state: dp[pos][bits][count] = sum of products
For each position, decide whether to include it or not
Track the number of set bits in current bitmask
Track the count of elements selected so far
Use memoization to avoid recalculating same states
Return the sum for states with exactly m elements and k set bits

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create memoization table for states

Recursive Choice

For each position, choose to include or exclude

Track Constraints

Monitor count of elements and set bits

Memoize Results

Store computed results to avoid recomputation

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 100000

typedef struct {
    int pos, count, bits;
    unsigned long long mask;
    long long result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

int popcount(unsigned long long x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

long long findMemo(int pos, unsigned long long mask, int count, int bits) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].pos == pos && memo[i].mask == mask && 
            memo[i].count == count && memo[i].bits == bits) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int pos, unsigned long long mask, int count, int bits, long long result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].pos = pos;
        memo[memoSize].mask = mask;
        memo[memoSize].count = count;
        memo[memoSize].bits = bits;
        memo[memoSize].result = result;
        memoSize++;
    }
}

long long dp(int pos, unsigned long long mask, int count, int bits, 
           int* nums, int n, int m, int k) {
    if (count == m) {
        return bits == k ? 1 : 0;
    }
    if (pos == n || count > m || bits > k) {
        return 0;
    }
    
    long long memoResult = findMemo(pos, mask, count, bits);
    if (memoResult != -1) {
        return memoResult;
    }
    
    // Don't take current position
    long long result = dp(pos + 1, mask, count, bits, nums, n, m, k);
    
    // Take current position
    unsigned long long newMask = mask | (1ULL << pos);
    int newBits = popcount(newMask);
    if (newBits <= k) {
        long long takeResult = dp(pos + 1, newMask, count + 1, newBits, nums, n, m, k);
        result = (result + (takeResult * nums[pos]) % MOD) % MOD;
    }
    
    addMemo(pos, mask, count, bits, result);
    return result;
}

int findSumOfMagicalSequences(int* nums, int numsSize, int m, int k) {
    memoSize = 0;
    return (int)dp(0, 0ULL, 0, 0, nums, numsSize, m, k);
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n * m * k)

We have n positions, up to 2^n possible bitmasks, m possible counts, and k possible bit counts

⚠ Quadratic Growth

Space Complexity

O(n * 2^n * m * k)

Space for memoization table storing all possible states

⚠ Quadratic Space

26.2K Views

Medium Frequency

~35 min Avg. Time

847 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

🔮 Find Sum of Array Product of Magical Sequences

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler