Skip to content

Commit 8d241db

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2389
No.2389.Longest Subsequence With Limited Sum
1 parent 30f391b commit 8d241db

File tree

2 files changed

+229
-1
lines changed

2 files changed

+229
-1
lines changed

‎solution/2300-2399/2389.Longest Subsequence With Limited Sum/README.md

Lines changed: 122 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,6 +55,20 @@
5555

5656
时间复杂度 $O((n + m) \times \log n)$，空间复杂度 $O(n)$ 或 $O(\log n)$。其中 $n$ 和 $m$ 分别是数组 $nums$ 和 $queries$ 的长度。
5757

58+
**方法二：排序 + 离线查询 + 双指针**
59+
60+
与方法一类似，我们可以先对数组 $nums$ 进行升序排列。
61+
62+
接下来，我们定义一个长度与 $queries$ 相同的下标数组 $idx$，其中 $idx[i]=i$，然后我们对数组 $idx$ 按照 $queries$ 中的元素值进行升序排序。这样，我们就可以按照 $queries$ 中的元素值从小到大的顺序进行处理。
63+
64+
我们使用一个变量 $s$ 记录当前已经选择的元素的和，使用一个变量 $j$ 记录当前已经选择的元素的个数。初始时 $s = j = 0$。
65+
66+
我们遍历下标数组 $idx$，对于其中的每个下标 $i$，我们循环地将数组 $nums$ 中的元素加入到当前的子序列中，直到 $s + nums[j] \gt queries[i]$，此时 $j$ 即为满足条件的子序列的长度，我们将 $ans[i]$ 的值设为 $j$，然后继续处理下一个下标。
67+
68+
遍历完下标数组 $idx$ 后，我们即可得到答案数组 $ans$，其中 $ans[i]$ 即为满足 $queries[i]$ 的子序列的长度。
69+
70+
时间复杂度 $O(n \times \log n + m)$，空间复杂度 $O(m)$。其中 $n$ 和 $m$ 分别是数组 $nums$ 和 $queries$ 的长度。
71+
5872
<!-- tabs:start -->
5973

6074
### **Python3**
@@ -69,6 +83,22 @@ class Solution:
6983
return [bisect_right(s, q) for q in queries]
7084
```
7185

86+
```python
87+
class Solution:
88+
def answerQueries(self, nums: List[int], queries: List[int]) -> List[int]:
89+
nums.sort()
90+
m = len(queries)
91+
ans = [0] * m
92+
idx = sorted(range(m), key=lambda i: queries[i])
93+
s = j = 0
94+
for i in idx:
95+
while j < len(nums) and s + nums[j] <= queries[i]:
96+
s += nums[j]
97+
j += 1
98+
ans[i] = j
99+
return ans
100+
```
101+
72102
### **Java**
73103

74104
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -87,7 +117,7 @@ class Solution {
87117
}
88118
return ans;
89119
}
90-
120+
91121
private int search(int[] nums, int x) {
92122
int l = 0, r = nums.length;
93123
while (l < r) {
@@ -103,6 +133,29 @@ class Solution {
103133
}
104134
```
105135

136+
```java
137+
class Solution {
138+
public int[] answerQueries(int[] nums, int[] queries) {
139+
Arrays.sort(nums);
140+
int m = queries.length;
141+
Integer[] idx = new Integer[m];
142+
for (int i = 0; i < m; ++i) {
143+
idx[i] = i;
144+
}
145+
Arrays.sort(idx, (i, j) -> queries[i] - queries[j]);
146+
int[] ans = new int[m];
147+
int s = 0, j = 0;
148+
for (int i : idx) {
149+
while (j < nums.length && s + nums[j] <= queries[i]) {
150+
s += nums[j++];
151+
}
152+
ans[i] = j;
153+
}
154+
return ans;
155+
}
156+
}
157+
```
158+
106159
### **C++**
107160

108161
```cpp
@@ -122,6 +175,30 @@ public:
122175
};
123176
```
124177
178+
```cpp
179+
class Solution {
180+
public:
181+
vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {
182+
sort(nums.begin(), nums.end());
183+
int m = queries.size();
184+
vector<int> idx(m);
185+
iota(idx.begin(), idx.end(), 0);
186+
sort(idx.begin(), idx.end(), [&](int i, int j) {
187+
return queries[i] < queries[j];
188+
});
189+
vector<int> ans(m);
190+
int s = 0, j = 0;
191+
for (int i : idx) {
192+
while (j < nums.size() && s + nums[j] <= queries[i]) {
193+
s += nums[j++];
194+
}
195+
ans[i] = j;
196+
}
197+
return ans;
198+
}
199+
};
200+
```
201+
125202
### **Go**
126203

127204
```go
@@ -137,6 +214,28 @@ func answerQueries(nums []int, queries []int) (ans []int) {
137214
}
138215
```
139216

217+
```go
218+
func answerQueries(nums []int, queries []int) (ans []int) {
219+
sort.Ints(nums)
220+
m := len(queries)
221+
idx := make([]int, m)
222+
for i := range idx {
223+
idx[i] = i
224+
}
225+
sort.Slice(idx, func(i, j int) bool { return queries[idx[i]] < queries[idx[j]] })
226+
ans = make([]int, m)
227+
s, j := 0, 0
228+
for _, i := range idx {
229+
for j < len(nums) && s+nums[j] <= queries[i] {
230+
s += nums[j]
231+
j++
232+
}
233+
ans[i] = j
234+
}
235+
return
236+
}
237+
```
238+
140239
### **TypeScript**
141240

142241
```ts
@@ -166,6 +265,28 @@ function answerQueries(nums: number[], queries: number[]): number[] {
166265
}
167266
```
168267

268+
```ts
269+
function answerQueries(nums: number[], queries: number[]): number[] {
270+
nums.sort((a, b) => a - b);
271+
const m = queries.length;
272+
const idx: number[] = new Array(m);
273+
for (let i = 0; i < m; i++) {
274+
idx[i] = i;
275+
}
276+
idx.sort((i, j) => queries[i] - queries[j]);
277+
const ans: number[] = new Array(m);
278+
let s = 0;
279+
let j = 0;
280+
for (const i of idx) {
281+
while (j < nums.length && s + nums[j] <= queries[i]) {
282+
s += nums[j++];
283+
}
284+
ans[i] = j;
285+
}
286+
return ans;
287+
}
288+
```
289+
169290
### **Rust**
170291

171292
```rust

‎solution/2300-2399/2389.Longest Subsequence With Limited Sum/README_EN.md

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,22 @@ class Solution:
5353
return [bisect_right(s, q) for q in queries]
5454
```
5555

56+
```python
57+
class Solution:
58+
def answerQueries(self, nums: List[int], queries: List[int]) -> List[int]:
59+
nums.sort()
60+
m = len(queries)
61+
ans = [0] * m
62+
idx = sorted(range(m), key=lambda i: queries[i])
63+
s = j = 0
64+
for i in idx:
65+
while j < len(nums) and s + nums[j] <= queries[i]:
66+
s += nums[j]
67+
j += 1
68+
ans[i] = j
69+
return ans
70+
```
71+
5672
### **Java**
5773

5874
```java
@@ -85,6 +101,29 @@ class Solution {
85101
}
86102
```
87103

104+
```java
105+
class Solution {
106+
public int[] answerQueries(int[] nums, int[] queries) {
107+
Arrays.sort(nums);
108+
int m = queries.length;
109+
Integer[] idx = new Integer[m];
110+
for (int i = 0; i < m; ++i) {
111+
idx[i] = i;
112+
}
113+
Arrays.sort(idx, (i, j) -> queries[i] - queries[j]);
114+
int[] ans = new int[m];
115+
int s = 0, j = 0;
116+
for (int i : idx) {
117+
while (j < nums.length && s + nums[j] <= queries[i]) {
118+
s += nums[j++];
119+
}
120+
ans[i] = j;
121+
}
122+
return ans;
123+
}
124+
}
125+
```
126+
88127
### **C++**
89128

90129
```cpp
@@ -104,6 +143,30 @@ public:
104143
};
105144
```
106145
146+
```cpp
147+
class Solution {
148+
public:
149+
vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {
150+
sort(nums.begin(), nums.end());
151+
int m = queries.size();
152+
vector<int> idx(m);
153+
iota(idx.begin(), idx.end(), 0);
154+
sort(idx.begin(), idx.end(), [&](int i, int j) {
155+
return queries[i] < queries[j];
156+
});
157+
vector<int> ans(m);
158+
int s = 0, j = 0;
159+
for (int i : idx) {
160+
while (j < nums.size() && s + nums[j] <= queries[i]) {
161+
s += nums[j++];
162+
}
163+
ans[i] = j;
164+
}
165+
return ans;
166+
}
167+
};
168+
```
169+
107170
### **Go**
108171

109172
```go
@@ -119,6 +182,28 @@ func answerQueries(nums []int, queries []int) (ans []int) {
119182
}
120183
```
121184

185+
```go
186+
func answerQueries(nums []int, queries []int) (ans []int) {
187+
sort.Ints(nums)
188+
m := len(queries)
189+
idx := make([]int, m)
190+
for i := range idx {
191+
idx[i] = i
192+
}
193+
sort.Slice(idx, func(i, j int) bool { return queries[idx[i]] < queries[idx[j]] })
194+
ans = make([]int, m)
195+
s, j := 0, 0
196+
for _, i := range idx {
197+
for j < len(nums) && s+nums[j] <= queries[i] {
198+
s += nums[j]
199+
j++
200+
}
201+
ans[i] = j
202+
}
203+
return
204+
}
205+
```
206+
122207
### **TypeScript**
123208

124209
```ts
@@ -148,6 +233,28 @@ function answerQueries(nums: number[], queries: number[]): number[] {
148233
}
149234
```
150235

236+
```ts
237+
function answerQueries(nums: number[], queries: number[]): number[] {
238+
nums.sort((a, b) => a - b);
239+
const m = queries.length;
240+
const idx: number[] = new Array(m);
241+
for (let i = 0; i < m; i++) {
242+
idx[i] = i;
243+
}
244+
idx.sort((i, j) => queries[i] - queries[j]);
245+
const ans: number[] = new Array(m);
246+
let s = 0;
247+
let j = 0;
248+
for (const i of idx) {
249+
while (j < nums.length && s + nums[j] <= queries[i]) {
250+
s += nums[j++];
251+
}
252+
ans[i] = j;
253+
}
254+
return ans;
255+
}
256+
```
257+
151258
### **Rust**
152259

153260
```rust

0 commit comments

Comments
 (0)