Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 906f6a5

Browse files
committed
第162场双周赛T1~T4 & 第461场周赛T1~T4 (8)
1 parent 3e9c1dc commit 906f6a5

16 files changed

+737
-0
lines changed
Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
public class Solution3633 {
2+
}
3+
/*
4+
3633. 最早完成陆地和水上游乐设施的时间 I
5+
https://leetcode.cn/problems/earliest-finish-time-for-land-and-water-rides-i/description/
6+
7+
第 162 场双周赛 T1。
8+
9+
给你两种类别的游乐园项目:陆地游乐设施 和 水上游乐设施。
10+
- 陆地游乐设施
11+
- landStartTime[i] – 第 i 个陆地游乐设施最早可以开始的时间。
12+
- landDuration[i] – 第 i 个陆地游乐设施持续的时间。
13+
- 水上游乐设施
14+
- waterStartTime[j] – 第 j 个水上游乐设施最早可以开始的时间。
15+
- waterDuration[j] – 第 j 个水上游乐设施持续的时间。
16+
一位游客必须从 每个 类别中体验 恰好一个 游乐设施,顺序 不限 。
17+
- 游乐设施可以在其开放时间开始,或 之后任意时间 开始。
18+
- 如果一个游乐设施在时间 t 开始,它将在时间 t + duration 结束。
19+
- 完成一个游乐设施后,游客可以立即乘坐另一个(如果它已经开放),或者等待它开放。
20+
返回游客完成这两个游乐设施的 最早可能时间 。
21+
提示:
22+
1 <= n, m <= 100
23+
landStartTime.length == landDuration.length == n
24+
waterStartTime.length == waterDuration.length == m
25+
1 <= landStartTime[i], landDuration[i], waterStartTime[j], waterDuration[j] <= 1000
26+
27+
同: 3635. 最早完成陆地和水上游乐设施的时间 II
28+
https://leetcode.cn/problems/earliest-finish-time-for-land-and-water-rides-ii/description/
29+
*/
Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
import java.util.Arrays;
2+
3+
public class Solution3634 {
4+
public int minRemoval(int[] nums, int k) {
5+
int n = nums.length;
6+
Arrays.sort(nums);
7+
int ans = n - 1;
8+
for (int i = 0; i < n; i++) {
9+
int j = upperBound(nums, (long) k * nums[i]);
10+
ans = Math.min(ans, i + n - j);
11+
}
12+
return ans;
13+
}
14+
15+
private int upperBound(int[] a, long key) {
16+
int l = 0, r = a.length;
17+
while (l < r) {
18+
int m = l + (r - l) / 2;
19+
if (a[m] > key) r = m;
20+
else l = m + 1;
21+
}
22+
return l;
23+
}
24+
}
25+
/*
26+
3634. 使数组平衡的最少移除数目
27+
https://leetcode.cn/problems/minimum-removals-to-balance-array/description/
28+
29+
第 162 场双周赛 T2。
30+
31+
给你一个整数数组 nums 和一个整数 k。
32+
如果一个数组的 最大 元素的值 至多 是其 最小 元素的 k 倍,则该数组被称为是 平衡 的。
33+
你可以从 nums 中移除 任意 数量的元素,但不能使其变为 空 数组。
34+
返回为了使剩余数组平衡,需要移除的元素的 最小 数量。
35+
注意:大小为 1 的数组被认为是平衡的,因为其最大值和最小值相等,且条件总是成立。
36+
提示:
37+
1 <= nums.length <= 10^5
38+
1 <= nums[i] <= 10^9
39+
1 <= k <= 10^5
40+
41+
排序 + 二分。
42+
时间复杂度 O(nlogn)。
43+
*/
Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
public class Solution3635 {
2+
public int earliestFinishTime(int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) {
3+
int landWater = getAns(landStartTime, landDuration, waterStartTime, waterDuration);
4+
int waterLand = getAns(waterStartTime, waterDuration, landStartTime, landDuration);
5+
return Math.min(landWater, waterLand);
6+
}
7+
8+
private int getAns(int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) {
9+
int n = landStartTime.length;
10+
int m = waterStartTime.length;
11+
12+
int landEnd = Integer.MAX_VALUE;
13+
for (int i = 0; i < n; i++) {
14+
landEnd = Math.min(landEnd, landStartTime[i] + landDuration[i]);
15+
}
16+
17+
int res = Integer.MAX_VALUE;
18+
for (int i = 0; i < m; i++) {
19+
res = Math.min(res, Math.max(landEnd, waterStartTime[i]) + waterDuration[i]);
20+
}
21+
return res;
22+
}
23+
}
24+
/*
25+
3635. 最早完成陆地和水上游乐设施的时间 II
26+
https://leetcode.cn/problems/earliest-finish-time-for-land-and-water-rides-ii/description/
27+
28+
第 162 场双周赛 T3。
29+
30+
给你两种类别的游乐园项目:陆地游乐设施 和 水上游乐设施。
31+
- 陆地游乐设施
32+
- landStartTime[i] – 第 i 个陆地游乐设施最早可以开始的时间。
33+
- landDuration[i] – 第 i 个陆地游乐设施持续的时间。
34+
- 水上游乐设施
35+
- waterStartTime[j] – 第 j 个水上游乐设施最早可以开始的时间。
36+
- waterDuration[j] – 第 j 个水上游乐设施持续的时间。
37+
一位游客必须从 每个 类别中体验 恰好一个 游乐设施,顺序 不限 。
38+
- 游乐设施可以在其开放时间开始,或 之后任意时间 开始。
39+
- 如果一个游乐设施在时间 t 开始,它将在时间 t + duration 结束。
40+
- 完成一个游乐设施后,游客可以立即乘坐另一个(如果它已经开放),或者等待它开放。
41+
返回游客完成这两个游乐设施的 最早可能时间 。
42+
提示:
43+
1 <= n, m <= 5 * 10^4
44+
landStartTime.length == landDuration.length == n
45+
waterStartTime.length == waterDuration.length == m
46+
1 <= landStartTime[i], landDuration[i], waterStartTime[j], waterDuration[j] <= 10^5
47+
48+
贪心 + 分类讨论。
49+
情况一:陆地 + 水上。
50+
情况二:水上 + 陆地。
51+
时间复杂度 O(n + m)。
52+
*/
Lines changed: 155 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,155 @@
1+
import java.util.ArrayList;
2+
import java.util.Arrays;
3+
import java.util.Collections;
4+
import java.util.HashMap;
5+
import java.util.HashSet;
6+
import java.util.List;
7+
import java.util.Map;
8+
import java.util.Set;
9+
import java.util.TreeMap;
10+
import java.util.TreeSet;
11+
12+
public class Solution3636 {
13+
public int[] subarrayMajority(int[] nums, int[][] queries) {
14+
int n = nums.length;
15+
int numQueries = queries.length;
16+
17+
Set<Integer> set = new HashSet<>();
18+
for (int num : nums) {
19+
set.add(num);
20+
}
21+
List<Integer> list = new ArrayList<>(set);
22+
Collections.sort(list);
23+
Map<Integer, Integer> numToIdx = new HashMap<>();
24+
for (int i = 0; i < list.size(); i++) {
25+
numToIdx.put(list.get(i), i);
26+
}
27+
28+
int m = list.size();
29+
int[] arr = new int[n];
30+
for (int i = 0; i < n; i++) {
31+
arr[i] = numToIdx.get(nums[i]);
32+
}
33+
34+
int blockSize = (int) Math.sqrt(n);
35+
Query[] qs = new Query[numQueries];
36+
for (int i = 0; i < numQueries; i++) {
37+
int l = queries[i][0];
38+
int r = queries[i][1];
39+
int threshold = queries[i][2];
40+
qs[i] = new Query(l, r, threshold, i);
41+
}
42+
43+
Arrays.sort(qs, (a, b) -> {
44+
int blockA = a.l / blockSize;
45+
int blockB = b.l / blockSize;
46+
if (blockA != blockB) {
47+
return blockA - blockB;
48+
}
49+
if (blockA % 2 == 0) {
50+
return a.r - b.r;
51+
} else {
52+
return b.r - a.r;
53+
}
54+
});
55+
56+
int[] cnt = new int[m];
57+
TreeMap<Integer, TreeSet<Integer>> freqToNums = new TreeMap<>();
58+
int left = 0, right = -1;
59+
int[] ans = new int[numQueries];
60+
61+
for (Query query : qs) {
62+
int l = query.l, r = query.r, threshold = query.threshold, idx = query.idx;
63+
while (right < r) {
64+
add(arr[++right], cnt, freqToNums);
65+
}
66+
while (right > r) {
67+
remove(arr[right--], cnt, freqToNums);
68+
}
69+
while (left < l) {
70+
remove(arr[left++], cnt, freqToNums);
71+
}
72+
while (left > l) {
73+
add(arr[--left], cnt, freqToNums);
74+
}
75+
76+
int maxFreq = freqToNums.isEmpty() ? 0 : freqToNums.lastKey();
77+
if (maxFreq < threshold) {
78+
ans[idx] = -1;
79+
} else {
80+
int numIdx = freqToNums.get(maxFreq).first();
81+
ans[idx] = list.get(numIdx);
82+
}
83+
}
84+
85+
return ans;
86+
}
87+
88+
private void add(int x, int[] cnt, TreeMap<Integer, TreeSet<Integer>> freqToNums) {
89+
int oldFreq = cnt[x];
90+
int newFreq = oldFreq + 1;
91+
cnt[x] = newFreq;
92+
93+
if (oldFreq > 0) {
94+
TreeSet<Integer> setOld = freqToNums.get(oldFreq);
95+
setOld.remove(x);
96+
if (setOld.isEmpty()) {
97+
freqToNums.remove(oldFreq);
98+
}
99+
}
100+
101+
TreeSet<Integer> setNew = freqToNums.computeIfAbsent(newFreq, k -> new TreeSet<>());
102+
setNew.add(x);
103+
}
104+
105+
private void remove(int x, int[] cnt, TreeMap<Integer, TreeSet<Integer>> freqToNums) {
106+
int oldFreq = cnt[x];
107+
int newFreq = oldFreq - 1;
108+
cnt[x] = newFreq;
109+
110+
TreeSet<Integer> setOld = freqToNums.getOrDefault(oldFreq, new TreeSet<>());
111+
setOld.remove(x);
112+
if (setOld.isEmpty()) {
113+
freqToNums.remove(oldFreq);
114+
}
115+
116+
if (newFreq > 0) {
117+
TreeSet<Integer> setNew = freqToNums.computeIfAbsent(newFreq, k -> new TreeSet<>());
118+
setNew.add(x);
119+
}
120+
}
121+
122+
static class Query {
123+
int l, r, threshold, idx;
124+
125+
Query(int l, int r, int threshold, int idx) {
126+
this.l = l;
127+
this.r = r;
128+
this.threshold = threshold;
129+
this.idx = idx;
130+
}
131+
}
132+
}
133+
/*
134+
3636. 查询超过阈值频率最高元素
135+
https://leetcode.cn/problems/threshold-majority-queries/description/
136+
137+
第 162 场双周赛 T4。
138+
139+
给你一个长度为 n 的整数数组 nums 和一个查询数组 queries,其中 queries[i] = [li, ri, thresholdi]。
140+
返回一个整数数组 ans,其中 ans[i] 等于子数组 nums[li...ri] 中出现 至少 thresholdi 次的元素,选择频率 最高 的元素(如果频率相同则选择 最小 的元素),如果不存在这样的元素则返回 -1。
141+
提示:
142+
1 <= nums.length == n <= 10^4
143+
1 <= nums[i] <= 10^9
144+
1 <= queries.length <= 5 * 10^4
145+
queries[i] = [li, ri, thresholdi]
146+
0 <= li <= ri < n
147+
1 <= thresholdi <= ri - li + 1
148+
149+
离散化 + 莫队算法。
150+
莫队是轮椅算法(轮椅是指在稍有挑战性的游戏中,玩家可以使用的,攻略易复制的,上手难度低,强度超标的武器装备,或者某种套路,这些装备和套路可以大幅度地提高技术水平较低的玩家的游玩体验)。
151+
时间复杂度 O((n + q) sqrt(n) logm)。其中n为数组长度,q为查询数量,m为不同数字个数。
152+
莫队算法(回滚莫队)https://leetcode.cn/problems/threshold-majority-queries/solutions/3740919/mo-dui-suan-fa-hui-gun-mo-dui-pythonjava-x7yw/
153+
https://chat.deepseek.com/a/chat/s/83972666-2ebb-4b37-bb65-646f15179fec
154+
rating 2325 (clist.by)
155+
*/
Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
public class Solution3637 {
2+
public boolean isTrionic(int[] nums) {
3+
int n = nums.length - 1;
4+
int[] a = new int[n];
5+
for (int i = 0; i < n; i++) {
6+
if (nums[i + 1] - nums[i] > 0) a[i] = 1;
7+
else if (nums[i + 1] - nums[i] < 0) a[i] = -1;
8+
else return false;
9+
}
10+
11+
int i = 0;
12+
int st = i;
13+
for (; i < n && a[i] == 1; i++) {
14+
}
15+
if (i - st < 1) return false;
16+
17+
st = i;
18+
for (; i < n && a[i] == -1; i++) {
19+
}
20+
if (i - st < 1) return false;
21+
22+
st = i;
23+
for (; i < n && a[i] == 1; i++) {
24+
}
25+
if (i - st < 1) return false;
26+
27+
return i == n;
28+
}
29+
}
30+
/*
31+
3637. 三段式数组 I
32+
https://leetcode.cn/problems/trionic-array-i/description/
33+
34+
第 461 场周赛 T1。
35+
36+
给你一个长度为 n 的整数数组 nums。
37+
如果存在索引 0 < p < q < n − 1,使得数组满足以下条件,则称其为 三段式数组(trionic):
38+
nums[0...p] 严格 递增,
39+
nums[p...q] 严格 递减,
40+
nums[q...n − 1] 严格 递增。
41+
如果 nums 是三段式数组,返回 true;否则,返回 false。
42+
提示:
43+
3 <= n <= 100
44+
-1000 <= nums[i] <= 1000
45+
46+
分组循环。
47+
时间复杂度 O(n)。
48+
*/
Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
public class Solution3638 {
2+
public int maxBalancedShipments(int[] weight) {
3+
int n = weight.length;
4+
int ans = 0;
5+
int mn = Integer.MAX_VALUE;
6+
for (int i = n - 1; i >= 0; i--) {
7+
if (mn > weight[i]) {
8+
mn = weight[i];
9+
} else if (mn < weight[i]) {
10+
ans++;
11+
mn = Integer.MAX_VALUE;
12+
}
13+
}
14+
return ans;
15+
}
16+
}
17+
/*
18+
3638. 平衡装运的最大数量
19+
https://leetcode.cn/problems/maximum-balanced-shipments/description/
20+
21+
第 461 场周赛 T2。
22+
23+
给你一个长度为 n 的整数数组 weight,表示按直线排列的 n 个包裹的重量。装运 定义为包裹的一个连续子数组。如果一个装运满足以下条件,则称其为 平衡装运:最后一个包裹的重量 严格小于 该装运中所有包裹中 最大重量 。
24+
选择若干个 不重叠 的连续平衡装运,并满足 每个包裹最多出现在一次装运中(部分包裹可以不被装运)。
25+
返回 可以形成的平衡装运的最大数量 。
26+
提示:
27+
2 <= n <= 10^5
28+
1 <= weight[i] <= 10^9
29+
30+
贪心。
31+
后往前遍历。维护最小值,遇到比最小值大的数 答案就加一。
32+
时间复杂度 O(n)。
33+
*/

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /