Find Sum of Array Product of Magical Sequences

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n^m * m)

n^m combinations, each requiring m operations to calculate product and bit counting

✓ Linear Growth

Space Complexity

O(m)

Space for storing current combination of size m

✓ Linear Space

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

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
✓ 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)	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) — Algorithm Steps

Generate all combinations of m indices from range [0, n-1]
For each combination, calculate 2^seq[0] + 2^seq[1] + ... + 2^seq[m-1]
Count the number of set bits in the binary representation
If set bits count equals k, calculate the product and add to result
Return the final sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible sequences of m indices

Calculate Binary Sum

For each sequence, compute 2^seq[0] + 2^seq[1] + ...

Count Set Bits

Check if binary representation has exactly k ones

Calculate Product

If valid, multiply nums values and add to result

Code -

solution.c — C

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

#define MOD 1000000007

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

void generateCombinations(int* nums, int n, int start, int* currentSeq, 
                        int seqLen, int remaining, int k, long long* result) {
    if (remaining == 0) {
        // Calculate binary sum
        unsigned long long binarySum = 0;
        for (int i = 0; i < seqLen; i++) {
            binarySum += (1ULL << currentSeq[i]);
        }
        // Count set bits
        if (popcount(binarySum) == k) {
            // Calculate product
            long long product = 1;
            for (int i = 0; i < seqLen; i++) {
                product = (product * nums[currentSeq[i]]) % MOD;
            }
            *result = (*result + product) % MOD;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        currentSeq[seqLen] = i;
        generateCombinations(nums, n, i, currentSeq, seqLen + 1, remaining - 1, k, result);
    }
}

int findSumOfMagicalSequences(int* nums, int numsSize, int m, int k) {
    long long result = 0;
    int* currentSeq = (int*)malloc(m * sizeof(int));
    
    generateCombinations(nums, numsSize, 0, currentSeq, 0, m, k, &result);
    
    free(currentSeq);
    return (int)result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^m * m)

n^m combinations, each requiring m operations to calculate product and bit counting

✓ Linear Growth

Space Complexity

O(m)

Space for storing current combination of size m

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler