Minimum Non-Zero Product of the Array Elements

Minimum Non-Zero Product of the Array Elements - Problem

You are given a positive integer p. Consider an array nums (1-indexed) that consists of the integers in the inclusive range [1, 2^p - 1] in their binary representations. You are allowed to do the following operation any number of times:

Choose two elements x and y from nums.
Choose a bit in x and swap it with its corresponding bit in y. Corresponding bit refers to the bit that is in the same position in the other integer.

For example, if x = 1101 and y = 0011, after swapping the 2nd bit from the right, we have x = 1111 and y = 0001.

Find the minimum non-zero product of nums after performing the above operation any number of times. Return this product modulo 10^9 + 7.

Note: The answer should be the minimum product before the modulo operation is done.

Input & Output

Example 1 — Basic Case

$ Input: p = 1

› Output: 1

💡 Note: Array is [1], so the product is 1

Example 2 — Small Array

$ Input: p = 2

› Output: 6

💡 Note: Array is [1,2,3]. Optimal: swap to get [1,2,3] or [3,2,1]. Product = 1×2×3 = 6

Example 3 — Larger Case

$ Input: p = 3

› Output: 1512

💡 Note: Array is [1,2,3,4,5,6,7]. After optimal swaps: many 1s, many 6s, one 7. Product = 6³ × 7 = 1512

Constraints

1 ≤ p ≤ 60

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18

The key insight is that through bit swapping, we can create an optimal configuration with many 1s and many (2^p-2)s to minimize the product. Best approach uses mathematical formula: (2^p-2)^(2^(p-1)-1) × (2^p-1) with fast exponentiation. Time: O(log p), Space: O(1)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(2^(2^p)) Space: O(2^p)

Generate the array [1, 2, ..., 2^p-1], then try all possible ways to swap bits between pairs of numbers to find the configuration that gives minimum product. This involves exploring all possible states.

Mathematical Greedy Approach

⏱️ Time: O(log p) Space: O(1)

The key insight is that to minimize the product, we want as many 1s as possible and the remaining numbers to be as large as possible. Through bit swapping, we can achieve a configuration with many 1s and many (2^p-2)s, with exactly one (2^p-1).

Brute Force Simulation — Algorithm Steps

Generate array [1, 2, ..., 2^p-1]
Try all possible bit swaps between pairs
Calculate product for each configuration
Return minimum product mod 10^9+7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Array

Create [1, 2, 3, ..., 2^p-1]

Try Swaps

Attempt all possible bit swaps

Find Minimum

Calculate product for each configuration

Code -

solution.c — C

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

long long powMod(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp >> 1;
        base = (base * base) % mod;
    }
    return result;
}

int solution(int p) {
    long long MOD = 1000000007LL;
    
    if (p == 1) {
        return 1;
    }
    
    long long maxVal = (1LL << p) - 1;
    long long count = (1LL << (p - 1)) - 1;
    
    // Product = (2^p - 2)^(2^(p-1) - 1) * (2^p - 1)
    long long result = powMod(maxVal - 1, count, MOD);
    result = (result * maxVal) % MOD;
    return result;
}

int main() {
    int p;
    scanf("%d", &p);
    printf("%d\n", solution(p));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(2^p))

Exponential number of possible bit swap configurations

✓ Linear Growth

Space Complexity

O(2^p)

Store the array of 2^p-1 numbers

✓ Linear Space

23.0K Views

Medium Frequency

~35 min Avg. Time

890 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler