Question

1969. 数组元素的最小非零乘积

English Version

题目描述

给你一个正整数 p 。你有一个下标从 1 开始的数组 nums ，这个数组包含范围 [1, 2p - 1] 内所有整数的二进制形式（两端都 包含）。你可以进行以下操作 任意 次：

• 从 nums 中选择两个元素 x 和 y  。
• 选择 x 中的一位与 y 对应位置的位交换。对应位置指的是两个整数 相同位置 的二进制位。

比方说，如果 x = 11_0_1 且 y = 00_1_1 ，交换右边数起第 2 位后，我们得到 x = 11_1_1 和 y = 00_0_1 。

请你算出进行以上操作 任意次 以后，nums 能得到的 最小非零 乘积。将乘积对_ _109 + 7 取余 后返回。

注意：答案应为取余 之前 的最小值。

 

示例 1：

输入：p = 1
输出：1
解释：nums = [1] 。
只有一个元素，所以乘积为该元素。

示例 2：

输入：p = 2
输出：6
解释：nums = [01, 10, 11] 。
所有交换要么使乘积变为 0 ，要么乘积与初始乘积相同。
所以，数组乘积 1 * 2 * 3 = 6 已经是最小值。

示例 3：

输入：p = 3
输出：1512
解释：nums = [001, 010, 011, 100, 101, 110, 111]
- 第一次操作中，我们交换第二个和第五个元素最左边的数位。
  - 结果数组为 [001, _1_10, 011, 100, _0_01, 110, 111] 。
- 第二次操作中，我们交换第三个和第四个元素中间的数位。
  - 结果数组为 [001, 110, 0_0_1, 1_1_0, 001, 110, 111] 。
数组乘积 1 * 6 * 1 * 6 * 1 * 6 * 7 = 1512 是最小乘积。

 

提示：

• 1 <= p <= 60

解法

方法一：贪心 + 快速幂

我们注意到，每一次操作，并不会改变元素的和，而在元素和不变的情况下，要想使得乘积最小，应该尽可能最大化元素的差值。

由于最大的元素为 $2^p - 1$，无论与哪个元素交换，都不会使得差值变大，因此我们不需要考虑与最大元素交换的情况。

对于其它的 $[1,..2^p-2]$ 的元素，我们依次将首尾元素两两配对，即 $x$ 与 $2^p-1-x$ 进行配置，那么经过若干次操作过后，每一对元素都变成了 $(1, 2^p-2)$，那么最终的乘积为 $(2^p-1) \times (2^p-2)^{2^{p-1}-1}$。

时间复杂度 $O(p)$，空间复杂度 $O(1)$。

class Solution:
  def minNonZeroProduct(self, p: int) -> int:
    mod = 10**9 + 7
    return (2**p - 1) * pow(2**p - 2, 2 ** (p - 1) - 1, mod) % mod

class Solution {
  public int minNonZeroProduct(int p) {
    final int mod = (int) 1e9 + 7;
    long a = ((1L << p) - 1) % mod;
    long b = qpow(((1L << p) - 2) % mod, (1L << (p - 1)) - 1, mod);
    return (int) (a * b % mod);
  }

  private long qpow(long a, long n, int mod) {
    long ans = 1;
    for (; n > 0; n >>= 1) {
      if ((n & 1) == 1) {
        ans = ans * a % mod;
      }
      a = a * a % mod;
    }
    return ans;
  }
}

class Solution {
public:
  int minNonZeroProduct(int p) {
    using ll = long long;
    const int mod = 1e9 + 7;
    auto qpow = [](ll a, ll n) {
      ll ans = 1;
      for (; n; n >>= 1) {
        if (n & 1) {
          ans = ans * a % mod;
        }
        a = a * a % mod;
      }
      return ans;
    };
    ll a = ((1LL << p) - 1) % mod;
    ll b = qpow(((1LL << p) - 2) % mod, (1L << (p - 1)) - 1);
    return a * b % mod;
  }
};

func minNonZeroProduct(p int) int {
  const mod int = 1e9 + 7
  qpow := func(a, n int) int {
    ans := 1
    for ; n > 0; n >>= 1 {
      if n&1 == 1 {
        ans = ans * a % mod
      }
      a = a * a % mod
    }
    return ans
  }
  a := ((1 << p) - 1) % mod
  b := qpow(((1<<p)-2)%mod, (1<<(p-1))-1)
  return a * b % mod
}

function minNonZeroProduct(p: number): number {
  const mod = BigInt(1e9 + 7);

  const qpow = (a: bigint, n: bigint): bigint => {
    let ans = BigInt(1);
    for (; n; n >>= BigInt(1)) {
      if (n & BigInt(1)) {
        ans = (ans * a) % mod;
      }
      a = (a * a) % mod;
    }
    return ans;
  };
  const a = (2n ** BigInt(p) - 1n) % mod;
  const b = qpow((2n ** BigInt(p) - 2n) % mod, 2n ** (BigInt(p) - 1n) - 1n);
  return Number((a * b) % mod);
}