题目描述
给你一个正整数 n ，你需要找到一个下标从 0 开始的数组 powers ，它包含 最少 数目的 2 的幂，且它们的和为 n 。powers 数组是 非递减 顺序的。根据前面描述，构造 powers 数组的方法是唯一的。
同时给你一个下标从 0 开始的二维整数数组 queries ，其中 queries[i] = [lefti, righti] ，其中 queries[i] 表示请你求出满足 lefti <= j <= righti 的所有 powers[j] 的乘积。
请你返回一个数组 answers ，长度与 queries 的长度相同，其中 answers[i]是第 i 个查询的答案。由于查询的结果可能非常大，请你将每个 answers[i] 都对 109 + 7 取余 。
示例 1：
输入：n = 15, queries = [[0,1],[2,2],[0,3]]
输出：[2,4,64]
解释：
对于 n = 15 ，得到 powers = [1,2,4,8] 。没法得到元素数目更少的数组。
第 1 个查询的答案：powers[0] * powers[1] = 1 * 2 = 2 。
第 2 个查询的答案：powers[2] = 4 。
第 3 个查询的答案：powers[0] * powers[1] * powers[2] * powers[3] = 1 * 2 * 4 * 8 = 64 。
每个答案对 109 + 7 取余得到的结果都相同，所以返回 [2,4,64] 。
示例 2：
输入：n = 2, queries = [[0,0]]
输出：[2]
解释：
对于 n = 2, powers = [2] 。
唯一一个查询的答案是 powers[0] = 2 。答案对 109 + 7 取余后结果相同，所以返回 [2] 。
提示：
1 <= n <= 1091 <= queries.length <= 1050 <= starti <= endi < powers.length
解法
方法一：位运算 + 模拟
我们可以使用位运算（Lowbit）来得到 \(\textit{powers}\) 数组，然后通过模拟的方式求出每个查询的答案。
首先，对于给定的正整数 \(n\)，我们通过 \(n \& -n\) 可以快速得到二进制表示中最低位的 \(1\) 对应的数值，也就是当前数的最小 \(2\) 的幂因子。对 \(n\) 反复执行这个操作并减去该值，就能依次得到所有置位的 \(2\) 的幂，形成 \(\textit{powers}\) 数组。这个数组是递增的，且长度等于 \(n\) 的二进制表示中 \(1\) 的个数。
接下来，我们需要处理每个查询。对于当前查询 \((l, r)\)，我们需要计算
\[
\textit{answers}[i] = \prod_{j=l}^{r} \textit{powers}[j]
\]
其中 \(\textit{answers}[i]\) 是第 \(i\) 个查询的答案。由于查询的结果可能非常大，我们需要对每个答案取模 \(10^9 + 7\)。
时间复杂度 \(O(m \times \log n)\)，其中 \(m\) 为数组 \(\textit{queries}\) 的长度。忽略答案的空间消耗，空间复杂度 \(O(\log n)\)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
powers = []
while n:
x = n & -n
powers.append(x)
n -= x
mod = 10**9 + 7
ans = []
for l, r in queries:
x = 1
for i in range(l, r + 1):
x = x * powers[i] % mod
ans.append(x)
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | class Solution {
public int[] productQueries(int n, int[][] queries) {
int[] powers = new int[Integer.bitCount(n)];
for (int i = 0; n > 0; ++i) {
int x = n & -n;
powers[i] = x;
n -= x;
}
int m = queries.length;
int[] ans = new int[m];
final int mod = (int) 1e9 + 7;
for (int i = 0; i < m; ++i) {
int l = queries[i][0], r = queries[i][1];
long x = 1;
for (int j = l; j <= r; ++j) {
x = x * powers[j] % mod;
}
ans[i] = (int) x;
}
return ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | class Solution {
public:
vector<int> productQueries(int n, vector<vector<int>>& queries) {
vector<int> powers;
while (n) {
int x = n & -n;
powers.push_back(x);
n -= x;
}
vector<int> ans;
const int mod = 1e9 + 7;
for (const auto& q : queries) {
int l = q[0], r = q[1];
long long x = 1;
for (int j = l; j <= r; ++j) {
x = x * powers[j] % mod;
}
ans.push_back(x);
}
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | func productQueries(n int, queries [][]int) []int {
var powers []int
for n > 0 {
x := n & -n
powers = append(powers, x)
n -= x
}
const mod = 1_000_000_007
ans := make([]int, 0, len(queries))
for _, q := range queries {
l, r := q[0], q[1]
x := 1
for j := l; j <= r; j++ {
x = x * powers[j] % mod
}
ans = append(ans, x)
}
return ans
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | function productQueries(n: number, queries: number[][]): number[] {
const powers: number[] = [];
while (n > 0) {
const x = n & -n;
powers.push(x);
n -= x;
}
const mod = 1_000_000_007;
const ans: number[] = [];
for (const [l, r] of queries) {
let x = 1;
for (let j = l; j <= r; j++) {
x = (x * powers[j]) % mod;
}
ans.push(x);
}
return ans;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | impl Solution {
pub fn product_queries(mut n: i32, queries: Vec<Vec<i32>>) -> Vec<i32> {
let mut powers = Vec::new();
while n > 0 {
let x = n & -n;
powers.push(x);
n -= x;
}
let modulo = 1_000_000_007;
let mut ans = Vec::with_capacity(queries.len());
for q in queries {
let l = q[0] as usize;
let r = q[1] as usize;
let mut x: i64 = 1;
for j in l..=r {
x = x * powers[j] as i64 % modulo;
}
ans.push(x as i32);
}
ans
}
}
|