Skip to content

Commit 98cf993

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.3098,3102 (#2526)
1 parent d39d700 commit 98cf993

File tree

12 files changed

+651
-19
lines changed

12 files changed

+651
-19
lines changed

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

Lines changed: 119 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -66,24 +66,138 @@
6666

6767
## 解法
6868

69-
### 方法一
69+
### 方法一：记忆化搜索
70+
71+
我们设计一个函数 $dfs(i, j, k, mi)$，表示当前处理到第 $i$ 个元素，上一个选取的是第 $j$ 个元素，还需要选取 $k$ 个元素，当前的最小差值为 $mi$ 时，能量和的值。那么答案就是 $dfs(0, n, k, +\infty)$。
72+
73+
函数 $dfs(i, j, k, mi)$ 的执行过程如下：
74+
75+
- 如果 $i \geq n$，表示已经处理完了所有的元素，如果 $k = 0$，返回 $mi$，否则返回 $0$；
76+
- 否则，我们可以选择不选取第 $i$ 个元素，可以获得的能量和为 $dfs(i + 1, j, k, mi)$；
77+
- 也可以选择选取第 $i$ 个元素。如果 $j = n$，表示之前没有选取过元素，那么可以获得的能量和为 $dfs(i + 1, i, k - 1, mi)$；否则，可以获得的能量和为 $dfs(i + 1, i, k - 1, \min(mi, \text{nums}[i] - \text{nums}[j]))$。
78+
- 我们累加上述结果，并对 $10^9 + 7$ 取模后返回。
79+
80+
为了避免重复计算，我们可以使用记忆化搜索的方法，将已经计算过的结果保存起来。
81+
82+
时间复杂度 $O(n^5)$，空间复杂度 $O(n^5)$。其中 $n$ 为数组的长度。
7083

7184
<!-- tabs:start -->
7285

7386
```python
74-
87+
class Solution:
88+
def sumOfPowers(self, nums: List[int], k: int) -> int:
89+
@cache
90+
def dfs(i: int, j: int, k: int, mi: int) -> int:
91+
if i >= n:
92+
return mi if k == 0 else 0
93+
ans = dfs(i + 1, j, k, mi)
94+
if j == n:
95+
ans += dfs(i + 1, i, k - 1, mi)
96+
else:
97+
ans += dfs(i + 1, i, k - 1, min(mi, nums[i] - nums[j]))
98+
ans %= mod
99+
return ans
100+
101+
mod = 10**9 + 7
102+
n = len(nums)
103+
nums.sort()
104+
return dfs(0, n, k, inf)
75105
```
76106

77107
```java
78-
108+
class Solution {
109+
private Map<Long, Integer> f = new HashMap<>();
110+
private final int mod = (int) 1e9 + 7;
111+
private int[] nums;
112+
113+
public int sumOfPowers(int[] nums, int k) {
114+
Arrays.sort(nums);
115+
this.nums = nums;
116+
return dfs(0, nums.length, k, Integer.MAX_VALUE);
117+
}
118+
119+
private int dfs(int i, int j, int k, int mi) {
120+
if (i >= nums.length) {
121+
return k == 0 ? mi : 0;
122+
}
123+
long key = (1L * mi) << 18 | (i << 12) | (j << 6) | k;
124+
if (f.containsKey(key)) {
125+
return f.get(key);
126+
}
127+
int ans = dfs(i + 1, j, k, mi);
128+
if (j == nums.length) {
129+
ans += dfs(i + 1, i, k - 1, mi);
130+
} else {
131+
ans += dfs(i + 1, i, k - 1, Math.min(mi, nums[i] - nums[j]));
132+
}
133+
ans %= mod;
134+
f.put(key, ans);
135+
return ans;
136+
}
137+
}
79138
```
80139

81140
```cpp
82-
141+
class Solution {
142+
public:
143+
int sumOfPowers(vector<int>& nums, int k) {
144+
unordered_map<long long, int> f;
145+
const int mod = 1e9 + 7;
146+
int n = nums.size();
147+
sort(nums.begin(), nums.end());
148+
function<int(int, int, int, int)> dfs = [&](int i, int j, int k, int mi) {
149+
if (i >= n) {
150+
return k == 0 ? mi : 0;
151+
}
152+
long long key = (1LL * mi) << 18 | (i << 12) | (j << 6) | k;
153+
if (f.contains(key)) {
154+
return f[key];
155+
}
156+
long long ans = dfs(i + 1, j, k, mi);
157+
if (j == n) {
158+
ans += dfs(i + 1, i, k - 1, mi);
159+
} else {
160+
ans += dfs(i + 1, i, k - 1, min(mi, nums[i] - nums[j]));
161+
}
162+
ans %= mod;
163+
f[key] = ans;
164+
return f[key];
165+
};
166+
return dfs(0, n, k, INT_MAX);
167+
}
168+
};
83169
```
84170
85171
```go
86-
172+
func sumOfPowers(nums []int, k int) int {
173+
const mod int = 1e9 + 7
174+
sort.Ints(nums)
175+
n := len(nums)
176+
f := map[int]int{}
177+
var dfs func(i, j, k, mi int) int
178+
dfs = func(i, j, k, mi int) int {
179+
if i >= n {
180+
if k == 0 {
181+
return mi
182+
}
183+
return 0
184+
}
185+
key := mi<<18 | (i << 12) | (j << 6) | k
186+
if v, ok := f[key]; ok {
187+
return v
188+
}
189+
ans := dfs(i+1, j, k, mi)
190+
if j == n {
191+
ans += dfs(i+1, i, k-1, mi)
192+
} else {
193+
ans += dfs(i+1, i, k-1, min(mi, nums[i]-nums[j]))
194+
}
195+
ans %= mod
196+
f[key] = ans
197+
return ans
198+
}
199+
return dfs(0, n, k, math.MaxInt)
200+
}
87201
```
88202

89203
<!-- tabs:end -->

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

Lines changed: 119 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -62,24 +62,138 @@
6262

6363
## Solutions
6464

65-
### Solution 1
65+
### Solution 1: Memoization Search
66+
67+
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)$.
68+
69+
The execution process of the function $dfs(i, j, k, mi)$ is as follows:
70+
71+
- If $i \geq n$, it means that all elements have been processed. If $k = 0$, return $mi$, otherwise return $0$;
72+
- Otherwise, we can choose not to select the $i$-th element, and the energy sum obtained is $dfs(i + 1, j, k, mi)$;
73+
- 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]))$.
74+
- We add up the above results, take the modulus of $10^9 + 7$, and return.
75+
76+
To avoid repeated calculations, we can use the method of memoization search to save the calculated results.
77+
78+
The time complexity is $O(n^5)$, and the space complexity is $O(n^5)$. Where $n$ is the length of the array.
6679

6780
<!-- tabs:start -->
6881

6982
```python
70-
83+
class Solution:
84+
def sumOfPowers(self, nums: List[int], k: int) -> int:
85+
@cache
86+
def dfs(i: int, j: int, k: int, mi: int) -> int:
87+
if i >= n:
88+
return mi if k == 0 else 0
89+
ans = dfs(i + 1, j, k, mi)
90+
if j == n:
91+
ans += dfs(i + 1, i, k - 1, mi)
92+
else:
93+
ans += dfs(i + 1, i, k - 1, min(mi, nums[i] - nums[j]))
94+
ans %= mod
95+
return ans
96+
97+
mod = 10**9 + 7
98+
n = len(nums)
99+
nums.sort()
100+
return dfs(0, n, k, inf)
71101
```
72102

73103
```java
74-
104+
class Solution {
105+
private Map<Long, Integer> f = new HashMap<>();
106+
private final int mod = (int) 1e9 + 7;
107+
private int[] nums;
108+
109+
public int sumOfPowers(int[] nums, int k) {
110+
Arrays.sort(nums);
111+
this.nums = nums;
112+
return dfs(0, nums.length, k, Integer.MAX_VALUE);
113+
}
114+
115+
private int dfs(int i, int j, int k, int mi) {
116+
if (i >= nums.length) {
117+
return k == 0 ? mi : 0;
118+
}
119+
long key = (1L * mi) << 18 | (i << 12) | (j << 6) | k;
120+
if (f.containsKey(key)) {
121+
return f.get(key);
122+
}
123+
int ans = dfs(i + 1, j, k, mi);
124+
if (j == nums.length) {
125+
ans += dfs(i + 1, i, k - 1, mi);
126+
} else {
127+
ans += dfs(i + 1, i, k - 1, Math.min(mi, nums[i] - nums[j]));
128+
}
129+
ans %= mod;
130+
f.put(key, ans);
131+
return ans;
132+
}
133+
}
75134
```
76135

77136
```cpp
78-
137+
class Solution {
138+
public:
139+
int sumOfPowers(vector<int>& nums, int k) {
140+
unordered_map<long long, int> f;
141+
const int mod = 1e9 + 7;
142+
int n = nums.size();
143+
sort(nums.begin(), nums.end());
144+
function<int(int, int, int, int)> dfs = [&](int i, int j, int k, int mi) {
145+
if (i >= n) {
146+
return k == 0 ? mi : 0;
147+
}
148+
long long key = (1LL * mi) << 18 | (i << 12) | (j << 6) | k;
149+
if (f.contains(key)) {
150+
return f[key];
151+
}
152+
long long ans = dfs(i + 1, j, k, mi);
153+
if (j == n) {
154+
ans += dfs(i + 1, i, k - 1, mi);
155+
} else {
156+
ans += dfs(i + 1, i, k - 1, min(mi, nums[i] - nums[j]));
157+
}
158+
ans %= mod;
159+
f[key] = ans;
160+
return f[key];
161+
};
162+
return dfs(0, n, k, INT_MAX);
163+
}
164+
};
79165
```
80166
81167
```go
82-
168+
func sumOfPowers(nums []int, k int) int {
169+
const mod int = 1e9 + 7
170+
sort.Ints(nums)
171+
n := len(nums)
172+
f := map[int]int{}
173+
var dfs func(i, j, k, mi int) int
174+
dfs = func(i, j, k, mi int) int {
175+
if i >= n {
176+
if k == 0 {
177+
return mi
178+
}
179+
return 0
180+
}
181+
key := mi<<18 | (i << 12) | (j << 6) | k
182+
if v, ok := f[key]; ok {
183+
return v
184+
}
185+
ans := dfs(i+1, j, k, mi)
186+
if j == n {
187+
ans += dfs(i+1, i, k-1, mi)
188+
} else {
189+
ans += dfs(i+1, i, k-1, min(mi, nums[i]-nums[j]))
190+
}
191+
ans %= mod
192+
f[key] = ans
193+
return ans
194+
}
195+
return dfs(0, n, k, math.MaxInt)
196+
}
83197
```
84198

85199
<!-- tabs:end -->

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

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
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+
function<int(int, int, int, int)> dfs = [&](int i, int j, int k, int mi) {
9+
if (i >= n) {
10+
return k == 0 ? mi : 0;
11+
}
12+
long long key = (1LL * mi) << 18 | (i << 12) | (j << 6) | k;
13+
if (f.contains(key)) {
14+
return f[key];
15+
}
16+
long long ans = dfs(i + 1, j, k, mi);
17+
if (j == n) {
18+
ans += dfs(i + 1, i, k - 1, mi);
19+
} else {
20+
ans += dfs(i + 1, i, k - 1, min(mi, nums[i] - nums[j]));
21+
}
22+
ans %= mod;
23+
f[key] = ans;
24+
return f[key];
25+
};
26+
return dfs(0, n, k, INT_MAX);
27+
}
28+
};

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

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func sumOfPowers(nums []int, k int) int {
2+
const mod int = 1e9 + 7
3+
sort.Ints(nums)
4+
n := len(nums)
5+
f := map[int]int{}
6+
var dfs func(i, j, k, mi int) int
7+
dfs = func(i, j, k, mi int) int {
8+
if i >= n {
9+
if k == 0 {
10+
return mi
11+
}
12+
return 0
13+
}
14+
key := mi<<18 | (i << 12) | (j << 6) | k
15+
if v, ok := f[key]; ok {
16+
return v
17+
}
18+
ans := dfs(i+1, j, k, mi)
19+
if j == n {
20+
ans += dfs(i+1, i, k-1, mi)
21+
} else {
22+
ans += dfs(i+1, i, k-1, min(mi, nums[i]-nums[j]))
23+
}
24+
ans %= mod
25+
f[key] = ans
26+
return ans
27+
}
28+
return dfs(0, n, k, math.MaxInt)
29+
}

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

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
private Map<Long, Integer> f = new HashMap<>();
3+
private final int mod = (int) 1e9 + 7;
4+
private int[] nums;
5+
6+
public int sumOfPowers(int[] nums, int k) {
7+
Arrays.sort(nums);
8+
this.nums = nums;
9+
return dfs(0, nums.length, k, Integer.MAX_VALUE);
10+
}
11+
12+
private int dfs(int i, int j, int k, int mi) {
13+
if (i >= nums.length) {
14+
return k == 0 ? mi : 0;
15+
}
16+
long key = (1L * mi) << 18 | (i << 12) | (j << 6) | k;
17+
if (f.containsKey(key)) {
18+
return f.get(key);
19+
}
20+
int ans = dfs(i + 1, j, k, mi);
21+
if (j == nums.length) {
22+
ans += dfs(i + 1, i, k - 1, mi);
23+
} else {
24+
ans += dfs(i + 1, i, k - 1, Math.min(mi, nums[i] - nums[j]));
25+
}
26+
ans %= mod;
27+
f.put(key, ans);
28+
return ans;
29+
}
30+
}

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

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution:
2+
def sumOfPowers(self, nums: List[int], k: int) -> int:
3+
@cache
4+
def dfs(i: int, j: int, k: int, mi: int) -> int:
5+
if i >= n:
6+
return mi if k == 0 else 0
7+
ans = dfs(i + 1, j, k, mi)
8+
if j == n:
9+
ans += dfs(i + 1, i, k - 1, mi)
10+
else:
11+
ans += dfs(i + 1, i, k - 1, min(mi, nums[i] - nums[j]))
12+
ans %= mod
13+
return ans
14+
15+
mod = 10**9 + 7
16+
n = len(nums)
17+
nums.sort()
18+
return dfs(0, n, k, inf)

0 commit comments

Comments
 (0)