Skip to content

Commit bf00301

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3098 (#3311)
No.3098.Find the Sum of Subsequence Powers
1 parent a76d40a commit bf00301

File tree

10 files changed

+271
-20
lines changed

10 files changed

+271
-20
lines changed

‎solution/2800-2899/2844.Minimum Operations to Make a Special Number/README.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -144,18 +144,18 @@ public:
144144
int n = num.size();
145145
int f[n][25];
146146
memset(f, -1, sizeof(f));
147-
function<int(int, int)> dfs = [&](int i, int k) -> int {
147+
auto dfs = [&](auto&& dfs, int i, int k) -> int {
148148
if (i == n) {
149149
return k == 0 ? 0 : n;
150150
}
151151
if (f[i][k] != -1) {
152152
return f[i][k];
153153
}
154-
f[i][k] = dfs(i + 1, k) + 1;
155-
f[i][k] = min(f[i][k], dfs(i + 1, (k * 10 + num[i] - '0') % 25));
154+
f[i][k] = dfs(dfs, i + 1, k) + 1;
155+
f[i][k] = min(f[i][k], dfs(dfs, i + 1, (k * 10 + num[i] - '0') % 25));
156156
return f[i][k];
157157
};
158-
return dfs(0, 0);
158+
return dfs(dfs, 0, 0);
159159
}
160160
};
161161
```

‎solution/2800-2899/2844.Minimum Operations to Make a Special Number/README_EN.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -141,18 +141,18 @@ public:
141141
int n = num.size();
142142
int f[n][25];
143143
memset(f, -1, sizeof(f));
144-
function<int(int, int)> dfs = [&](int i, int k) -> int {
144+
auto dfs = [&](auto&& dfs, int i, int k) -> int {
145145
if (i == n) {
146146
return k == 0 ? 0 : n;
147147
}
148148
if (f[i][k] != -1) {
149149
return f[i][k];
150150
}
151-
f[i][k] = dfs(i + 1, k) + 1;
152-
f[i][k] = min(f[i][k], dfs(i + 1, (k * 10 + num[i] - '0') % 25));
151+
f[i][k] = dfs(dfs, i + 1, k) + 1;
152+
f[i][k] = min(f[i][k], dfs(dfs, i + 1, (k * 10 + num[i] - '0') % 25));
153153
return f[i][k];
154154
};
155-
return dfs(0, 0);
155+
return dfs(dfs, 0, 0);
156156
}
157157
};
158158
```

‎solution/2800-2899/2844.Minimum Operations to Make a Special Number/Solution.cpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -4,17 +4,17 @@ class Solution {
44
int n = num.size();
55
int f[n][25];
66
memset(f, -1, sizeof(f));
7-
function<int(int, int)> dfs = [&](int i, int k) -> int {
7+
auto dfs = [&](auto&& dfs, int i, int k) -> int {
88
if (i == n) {
99
return k == 0 ? 0 : n;
1010
}
1111
if (f[i][k] != -1) {
1212
return f[i][k];
1313
}
14-
f[i][k] = dfs(i + 1, k) + 1;
15-
f[i][k] = min(f[i][k], dfs(i + 1, (k * 10 + num[i] - '0') % 25));
14+
f[i][k] = dfs(dfs, i + 1, k) + 1;
15+
f[i][k] = min(f[i][k], dfs(dfs, i + 1, (k * 10 + num[i] - '0') % 25));
1616
return f[i][k];
1717
};
18-
return dfs(0, 0);
18+
return dfs(dfs, 0, 0);
1919
}
2020
};

‎solution/3000-3099/3098.Find the Sum of Subsequence Powers/README.md

+89-1
Original file line numberDiff line numberDiff line change
@@ -84,11 +84,14 @@ tags:
8484

8585
### 方法一：记忆化搜索
8686

87-
我们设计一个函数 $dfs(i, j, k, mi)$，表示当前处理到第 $i$ 个元素，上一个选取的是第 $j$ 个元素，还需要选取 $k$ 个元素，当前的最小差值为 $mi$ 时，能量和的值。那么答案就是 $dfs(0, n, k, +\infty)$。
87+
由于题目涉及子序列元素的最小差值，我们不妨对数组 $\textit{nums}$ 进行排序，这样可以方便我们计算子序列元素的最小差值。
88+
89+
接下来，我们设计一个函数 $dfs(i, j, k, mi)$，表示当前处理到第 $i$ 个元素，上一个选取的是第 $j$ 个元素，还需要选取 $k$ 个元素，当前的最小差值为 $mi$ 时，能量和的值。那么答案就是 $dfs(0, n, k, +\infty)$。（若上一个选取的是第 $n$ 个元素，表示之前没有选取过元素）
8890

8991
函数 $dfs(i, j, k, mi)$ 的执行过程如下：
9092

9193
- 如果 $i \geq n$，表示已经处理完了所有的元素，如果 $k = 0$，返回 $mi$，否则返回 $0$；
94+
- 如果剩余的元素个数 $n - i$ 不足 $k$ 个，返回 $0$；
9295
- 否则，我们可以选择不选取第 $i$ 个元素，可以获得的能量和为 $dfs(i + 1, j, k, mi)$；
9396
- 也可以选择选取第 $i$ 个元素。如果 $j = n$，表示之前没有选取过元素，那么可以获得的能量和为 $dfs(i + 1, i, k - 1, mi)$；否则，可以获得的能量和为 $dfs(i + 1, i, k - 1, \min(mi, \text{nums}[i] - \text{nums}[j]))$。
9497
- 我们累加上述结果，并对 $10^9 + 7$ 取模后返回。
@@ -108,6 +111,8 @@ class Solution:
108111
def dfs(i: int, j: int, k: int, mi: int) -> int:
109112
if i >= n:
110113
return mi if k == 0 else 0
114+
if n - i < k:
115+
return 0
111116
ans = dfs(i + 1, j, k, mi)
112117
if j == n:
113118
ans += dfs(i + 1, i, k - 1, mi)
@@ -140,6 +145,9 @@ class Solution {
140145
if (i >= nums.length) {
141146
return k == 0 ? mi : 0;
142147
}
148+
if (nums.length - i < k) {
149+
return 0;
150+
}
143151
long key = (1L * mi) << 18 | (i << 12) | (j << 6) | k;
144152
if (f.containsKey(key)) {
145153
return f.get(key);
@@ -157,6 +165,42 @@ class Solution {
157165
}
158166
```
159167

168+
#### C++
169+
170+
```cpp
171+
class Solution {
172+
public:
173+
int sumOfPowers(vector<int>& nums, int k) {
174+
unordered_map<long long, int> f;
175+
const int mod = 1e9 + 7;
176+
int n = nums.size();
177+
sort(nums.begin(), nums.end());
178+
auto dfs = [&](auto&& dfs, int i, int j, int k, int mi) -> int {
179+
if (i >= n) {
180+
return k == 0 ? mi : 0;
181+
}
182+
if (n - i < k) {
183+
return 0;
184+
}
185+
long long key = (1LL * mi) << 18 | (i << 12) | (j << 6) | k;
186+
if (f.contains(key)) {
187+
return f[key];
188+
}
189+
long long ans = dfs(dfs, i + 1, j, k, mi);
190+
if (j == n) {
191+
ans += dfs(dfs, i + 1, i, k - 1, mi);
192+
} else {
193+
ans += dfs(dfs, i + 1, i, k - 1, min(mi, nums[i] - nums[j]));
194+
}
195+
ans %= mod;
196+
f[key] = ans;
197+
return f[key];
198+
};
199+
return dfs(dfs, 0, n, k, INT_MAX);
200+
}
201+
};
202+
```
203+
160204
#### Go
161205
162206
```go
@@ -173,6 +217,9 @@ func sumOfPowers(nums []int, k int) int {
173217
}
174218
return 0
175219
}
220+
if n-i < k {
221+
return 0
222+
}
176223
key := mi<<18 | (i << 12) | (j << 6) | k
177224
if v, ok := f[key]; ok {
178225
return v
@@ -191,6 +238,47 @@ func sumOfPowers(nums []int, k int) int {
191238
}
192239
```
193240

241+
#### TypeScript
242+
243+
```ts
244+
function sumOfPowers(nums: number[], k: number): number {
245+
const mod = BigInt(1e9 + 7);
246+
nums.sort((a, b) => a - b);
247+
const n = nums.length;
248+
const f: Map<bigint, bigint> = new Map();
249+
function dfs(i: number, j: number, k: number, mi: number): bigint {
250+
if (i >= n) {
251+
if (k === 0) {
252+
return BigInt(mi);
253+
}
254+
return BigInt(0);
255+
}
256+
if (n - i < k) {
257+
return BigInt(0);
258+
}
259+
const key =
260+
(BigInt(mi) << BigInt(18)) |
261+
(BigInt(i) << BigInt(12)) |
262+
(BigInt(j) << BigInt(6)) |
263+
BigInt(k);
264+
if (f.has(key)) {
265+
return f.get(key)!;
266+
}
267+
let ans = dfs(i + 1, j, k, mi);
268+
if (j === n) {
269+
ans += dfs(i + 1, i, k - 1, mi);
270+
} else {
271+
ans += dfs(i + 1, i, k - 1, Math.min(mi, nums[i] - nums[j]));
272+
}
273+
ans %= mod;
274+
f.set(key, ans);
275+
return ans;
276+
}
277+
278+
return Number(dfs(0, n, k, Number.MAX_SAFE_INTEGER));
279+
}
280+
```
281+
194282
<!-- tabs:end -->
195283

196284
<!-- solution:end -->

‎solution/3000-3099/3098.Find the Sum of Subsequence Powers/README_EN.md

+95-7
Original file line numberDiff line numberDiff line change
@@ -82,18 +82,21 @@ tags:
8282

8383
### Solution 1: Memoization Search
8484

85-
We design a function $dfs(i, j, k, mi)$, which represents the energy sum value when we are currently processing the $i$-th element, the last selected element is the $j$-th element, we still need to select $k$ elements, and the current minimum difference is $mi$. The answer is $dfs(0, n, k, +\infty)$.
85+
Given the problem involves the minimum difference between elements of a subsequence, we might as well sort the array $\textit{nums}$, which facilitates the calculation of the minimum difference between subsequence elements.
86+
87+
Next, we design a function $dfs(i, j, k, mi)$, representing the value of the energy sum when processing the $i$-th element, the last selected element is the $j$-th element, $k$ more elements need to be selected, and the current minimum difference is $mi$. Therefore, the answer is $dfs(0, n, k, +\infty)$ (If the last selected element is the $n$-th element, it indicates that no element has been selected before).
8688

8789
The execution process of the function $dfs(i, j, k, mi)$ is as follows:
8890

89-
- If $i \geq n$, it means that all elements have been processed. If $k = 0$, return $mi$, otherwise return $0$;
90-
- Otherwise, we can choose not to select the $i$-th element, and the energy sum obtained is $dfs(i + 1, j, k, mi)$;
91-
- We can also choose to select the $i$-th element. If $j = n$, it means that no element has been selected before, and the energy sum obtained is $dfs(i + 1, i, k - 1, mi)$; otherwise, the energy sum obtained is $dfs(i + 1, i, k - 1, \min(mi, \text{nums}[i] - \text{nums}[j]))$.
92-
- We add up the above results, take the modulus of $10^9 + 7$, and return.
91+
- If $i \geq n$, it means all elements have been processed. If $k = 0$, return $mi$; otherwise, return $0$.
92+
- If the remaining number of elements $n - i$ is less than $k$, return $0$.
93+
- Otherwise, we can choose not to select the $i$-th element, and the energy sum obtained is $dfs(i + 1, j, k, mi)$.
94+
- We can also choose to select the $i$-th element. If $j = n$, it means no element has been selected before, then the energy sum obtained is $dfs(i + 1, i, k - 1, mi)$; otherwise, the energy sum obtained is $dfs(i + 1, i, k - 1, \min(mi, \text{nums}[i] - \text{nums}[j]))$.
95+
- We add up the above results and return the result modulo $10^9 + 7$.
9396

94-
To avoid repeated calculations, we can use the method of memoization search to save the calculated results.
97+
To avoid repeated calculations, we can use memoization, saving the results that have already been calculated.
9598

96-
The time complexity is $O(n^4 \times k)$, and the space complexity is $O(n^4 \times k)$. Where $n$ is the length of the array.
99+
The time complexity is $O(n^4 \times k)$, and the space complexity is $O(n^4 \times k)$. Here, $n$ is the length of the array.
97100

98101
<!-- tabs:start -->
99102

@@ -106,6 +109,8 @@ class Solution:
106109
def dfs(i: int, j: int, k: int, mi: int) -> int:
107110
if i >= n:
108111
return mi if k == 0 else 0
112+
if n - i < k:
113+
return 0
109114
ans = dfs(i + 1, j, k, mi)
110115
if j == n:
111116
ans += dfs(i + 1, i, k - 1, mi)
@@ -138,6 +143,9 @@ class Solution {
138143
if (i >= nums.length) {
139144
return k == 0 ? mi : 0;
140145
}
146+
if (nums.length - i < k) {
147+
return 0;
148+
}
141149
long key = (1L * mi) << 18 | (i << 12) | (j << 6) | k;
142150
if (f.containsKey(key)) {
143151
return f.get(key);
@@ -155,6 +163,42 @@ class Solution {
155163
}
156164
```
157165

166+
#### C++
167+
168+
```cpp
169+
class Solution {
170+
public:
171+
int sumOfPowers(vector<int>& nums, int k) {
172+
unordered_map<long long, int> f;
173+
const int mod = 1e9 + 7;
174+
int n = nums.size();
175+
sort(nums.begin(), nums.end());
176+
auto dfs = [&](auto&& dfs, int i, int j, int k, int mi) -> int {
177+
if (i >= n) {
178+
return k == 0 ? mi : 0;
179+
}
180+
if (n - i < k) {
181+
return 0;
182+
}
183+
long long key = (1LL * mi) << 18 | (i << 12) | (j << 6) | k;
184+
if (f.contains(key)) {
185+
return f[key];
186+
}
187+
long long ans = dfs(dfs, i + 1, j, k, mi);
188+
if (j == n) {
189+
ans += dfs(dfs, i + 1, i, k - 1, mi);
190+
} else {
191+
ans += dfs(dfs, i + 1, i, k - 1, min(mi, nums[i] - nums[j]));
192+
}
193+
ans %= mod;
194+
f[key] = ans;
195+
return f[key];
196+
};
197+
return dfs(dfs, 0, n, k, INT_MAX);
198+
}
199+
};
200+
```
201+
158202
#### Go
159203
160204
```go
@@ -171,6 +215,9 @@ func sumOfPowers(nums []int, k int) int {
171215
}
172216
return 0
173217
}
218+
if n-i < k {
219+
return 0
220+
}
174221
key := mi<<18 | (i << 12) | (j << 6) | k
175222
if v, ok := f[key]; ok {
176223
return v
@@ -189,6 +236,47 @@ func sumOfPowers(nums []int, k int) int {
189236
}
190237
```
191238

239+
#### TypeScript
240+
241+
```ts
242+
function sumOfPowers(nums: number[], k: number): number {
243+
const mod = BigInt(1e9 + 7);
244+
nums.sort((a, b) => a - b);
245+
const n = nums.length;
246+
const f: Map<bigint, bigint> = new Map();
247+
function dfs(i: number, j: number, k: number, mi: number): bigint {
248+
if (i >= n) {
249+
if (k === 0) {
250+
return BigInt(mi);
251+
}
252+
return BigInt(0);
253+
}
254+
if (n - i < k) {
255+
return BigInt(0);
256+
}
257+
const key =
258+
(BigInt(mi) << BigInt(18)) |
259+
(BigInt(i) << BigInt(12)) |
260+
(BigInt(j) << BigInt(6)) |
261+
BigInt(k);
262+
if (f.has(key)) {
263+
return f.get(key)!;
264+
}
265+
let ans = dfs(i + 1, j, k, mi);
266+
if (j === n) {
267+
ans += dfs(i + 1, i, k - 1, mi);
268+
} else {
269+
ans += dfs(i + 1, i, k - 1, Math.min(mi, nums[i] - nums[j]));
270+
}
271+
ans %= mod;
272+
f.set(key, ans);
273+
return ans;
274+
}
275+
276+
return Number(dfs(0, n, k, Number.MAX_SAFE_INTEGER));
277+
}
278+
```
279+
192280
<!-- tabs:end -->
193281

194282
<!-- solution:end -->

‎solution/3000-3099/3098.Find the Sum of Subsequence Powers/Solution.cpp

+31
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
class Solution {
2+
public:
3+
int sumOfPowers(vector<int>& nums, int k) {
4+
unordered_map<long long, int> f;
5+
const int mod = 1e9 + 7;
6+
int n = nums.size();
7+
sort(nums.begin(), nums.end());
8+
auto dfs = [&](auto&& dfs, int i, int j, int k, int mi) -> int {
9+
if (i >= n) {
10+
return k == 0 ? mi : 0;
11+
}
12+
if (n - i < k) {
13+
return 0;
14+
}
15+
long long key = (1LL * mi) << 18 | (i << 12) | (j << 6) | k;
16+
if (f.contains(key)) {
17+
return f[key];
18+
}
19+
long long ans = dfs(dfs, i + 1, j, k, mi);
20+
if (j == n) {
21+
ans += dfs(dfs, i + 1, i, k - 1, mi);
22+
} else {
23+
ans += dfs(dfs, i + 1, i, k - 1, min(mi, nums[i] - nums[j]));
24+
}
25+
ans %= mod;
26+
f[key] = ans;
27+
return f[key];
28+
};
29+
return dfs(dfs, 0, n, k, INT_MAX);
30+
}
31+
};

‎solution/3000-3099/3098.Find the Sum of Subsequence Powers/Solution.go

+3
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,9 @@ func sumOfPowers(nums []int, k int) int {
1111
}
1212
return 0
1313
}
14+
if n-i < k {
15+
return 0
16+
}
1417
key := mi<<18 | (i << 12) | (j << 6) | k
1518
if v, ok := f[key]; ok {
1619
return v

0 commit comments

Comments
 (0)