leetcode max ratings:2100
碎碎念念
22/4/16 LCP春季杯
LCP 54. 夺回据点
少了个特判。。。qwq
22/3/6 第73场双周赛:T4
- T4:太久没写证明类的题目bonus。
22/3/7 第 283 场周赛:ak
- T2:少了一个等于,看半天。。。qwq(简单等差数列)
- T3:漏加了ma【par】=fa,看了半天。。。qwq
- T4:一开始没写对链表,看了半天。。。qwq
22/3/13 第 284 场周赛:T4
- T3:因为一个细节没考虑好,1wa,应该想清楚再码的,
- T4:想到了那个模型,DAG的套路太久没写了,有点短路。。。
22/3/19 第74场双周赛:ak
罚时好高。。。。。。
- T1:由于范围很小可以存一个数组里,之后%2判断是否可行。(赛时暴力了)
- T2:前缀和,瞎搞一下。
- T4: 用大根堆, 2 32 > 1 e 9 2^{32} > 1e9 232>1e9所以,对于每个数的操作,最多不超过32次,总不超过 n ∗ 32 n*32 n∗32
- T4:vector t麻了。。。
22/3/20 第 285 场周赛:T4 老了,码不动了,
- T1:其实把相等的去掉,之后扫一遍就好了。
- T2: 其实没分析到这道问题的本质,碰撞次数,扫两遍就可以了。
- T3: 暴搜,一开始没想到有没用完的,所以wa了一发
- T4:12:13才写完线段树,菜了。。。(一开始写并查集,一个假做法。。。早知道不写并查集)
- T4的set做法的学习。。。
22/3/27 第 286场周赛:ak
罚时好高。。。。。。(wa了两发)
- T1:直接暴力两重循环,之后写个函数,可以少写一点。
- T2:贪心,
- T3:观察可以发现,第k大就是前半部分。(我的码量很大,浪费了大部分时间和两发罚时)
- T4:分组背包(每个栈看成一组)
22/4/2 第 75 场双周赛:ak
这场做的有点滑水
- T1:异或一下,之后统计二进制位数就好了
- T2:数字三角形的过程
- T3:dp
- T4:扩展kmp(z函数)。模板题
22/4/3 第 287场周赛:ak
罚时好高。。。。。。(TLE了15发)
- T1:贪心,类似于二进制分解
- T2:暴力,排序,模拟
- T3:二分。一开始没注意会爆ll,wa了一发
- T4:模拟,因为下面这个,TLE了14发,一开始直接map。以为map不行,改trie,之后又喜提TLE。最后改HASH,又喜提TLE,最后无奈,看到下面那个地方,改成
+=
a了
string ans; ans = ans + char(c); ans += char(c);
22/4/10 第 288场周赛:3 罚时好高.
审题审题!!!!!!!!
- T1:直接类似排序,
比赛时在想什么呢 - T2:模拟,直接枚举substr, stoi计算
比赛时在想什么呢 - T3:优先队列,贪心,比赛时看错了k的范围,
寄,难怪怎么觉得码量有点大。。。。吧k看成 1 e 9 1e9 1e9 - T4:假如没在T3花太多时间,
T3主要是写了3个写法,赛时是想到了双指针的。哎下次专心点读题吧。
22/4/16 第 76 场双周赛:ak
这场做T2,T3都wa了一发 赛后还能被hack掉翻车了,
- T1:扫一遍,统计答案就好
- T2:枚举答案
- T3:模拟
- T4:
tricks
最大,次大,次次大。dp状态由于没设置好。赛后还能被 x
22/4/17 第 289 场双周赛:ak
T4边界1wa,T3没考虑一种转移1wa
- T1:模拟
- T2:用hash表存任务,之后判断就可以了
- T3:dp
- T4:树型dp,直径简单变种
22/4/24 第 290 场周赛:ak
手速场:
动力小子的一句话: faster, faster
T2因为写法,TLE了两发,其实复杂度是对的。
- T1:求多个数组的交集
一个元素在最后的交集里, 当前仅当 这个元素出现了n次。
- T2:对于每个圆,暴力枚举 x ∈ [ x − r , x + r ] , y ∈ [ y − r , y + r ] x\in[x-r,x+r], y\in[y-r,y+r] x∈[x−r,x+r],y∈[y−r,y+r],这个长方形里内的点,然后判断是否在圆内就好了
- T3:二维偏序问题,由于第二维 y y y很小,所以我们可以不用一些数据结构。
- T4:一个经典的问题。模型是什么忘了。。。
22/10/16 第 315 场周赛:ak
时隔6个月,再次打leetcode,罚时上天。最后1min侥幸ak。(想起了几天前的codeforces div4也是最后1min ak)。。。。老了老了
performance :1637.27
- T1:数据不大,直接暴力循环
- T2:直接暴力添加 r e v e r s e ( k ) reverse(k) reverse(k),之后排序去重就好了
- T3:借用上题的reverse,发现我们只用枚举 k,且 k + r e v e r s e ( k ) < = n u m k + reverse(k) <= num k+reverse(k)<=num,那么我们只用枚举到 [ 1 , n u m ] [1,num] [1,num]即可,时间复杂度 O( n u m s ∗ l o g 10 ( n u m s ) nums*log_{10}(nums) nums∗log10(nums) )
- T4:一个经典的问题。我们每次只用考虑值在 [ m i n K , m a x K ] [minK,maxK] [minK,maxK]的区间即可。对于每个这样的区间,固定右端点,查看最左到哪,用二分解决。
22/10/23 第 316 场周赛:ak
没有IDEA我什么不是。想起了去年打蓝桥的时候,赛时才知道不给用codeblocks(本人还会vscode),只能用dev-c++,调环境都用了2h,结果可想而知。
赛后看了一些大佬的解法,在发现写法后,不妨先想下,是否可以更简洁,
- T1:本质就是转换下,之后判断区间交。
static int cal(String x){
int v1 = Integer.parseInt(x.substring(0,2));
int v2 = Integer.parseInt(x.substring(3,5));
return v1*60+v2;
}
// min(r1,r2) >= max(l1,l2);
- T2:直接暴力循环,之后求gcd就行,是就ans++
- T3:一开始的以为,值不大,暴力值,但是TLE,后面改了写法
- T4:一个经典的问题。我们分奇偶计算答案就行了。
22/10/30 第 90 场双周赛:ak
finish Time: 1:25:03
PenaltyTime: 1:25:03
dirty 0
rank 412
T1写的太丑了。。。赛时不知道java里两个数组怎么判断相同,之前暴力for循环了,其实List中封装的equals可以解决,比较两个数组相等的问题。
T2:一开始读错题目了 寄。。。。
最近突然发现 arignote 是写java的
T4:没有贯彻用java,用c++的set去暴力了。。。
faster,faster!!!!
- T1: 我们直接循环比较就好
int dif[][]
//比较两个数组是否相等。
if(IntStream.of(dif[i]).boxed().toList().equals(IntStream.of(dif[j]).boxed().toList())) cnt++;
- T2:直接暴力找
// arignote tql!!
return Stream.of(queries)
.filter(t -> Stream.of(dictionary).anyMatch(
u -> IntStream.range(0, u.length()).filter(v -> t.charAt(v) != u.charAt(v)).count() < 3))
.toList();
- T3:把每个数字分组,是否在同一组如下,由于C很大,所以我们分组后用hash
cNums[i] = nums[i] - nums[i]/c*c;
cNums[i] = nums[i] % c;
- T4:我用setC++瞎搞过去了,
-
- 其实发现可以用st表去做。
-
- arignote 用单调栈去做,其实和我c++的思路差不多。不过优化了set中的upper_bound,转换为了 对 于 j 找 到 最 右 的 i 满 足 a [ i ] < a [ j ] , i < j 对于j找到最右的i满足 a[i] < a[j], i<j 对于j找到最右的i满足a[i]<a[j],i<j,这不就可以用单调栈处理了
22/10/30 第 317 场周赛:ak
finish Time: 0:58:41
PenaltyTime: 1:03:41
dirty 1
rank 151
前面被T2的模拟(hash表)耽误了不少时间。主要还是对java的map相关的操作不是很熟悉。T4的树形dp写的也有点久。
感觉codeforces rank有提升除了后期的题目之外,就是罚时了吧。
faster,faster!!!!
- T1: 我们直接循环统计就好了
//arignote 的写法经验到了,比我熟练太多了
IntStream.of(nums)
.filter(k -> k%6 == 0).average().orElseGet(()->0);
- T2:hash
/* ---- nest -------*/
Map<String, PriorityQueue<Integer>> map = new HashMap<>();
//如果Map中缺少这个key,使用这个方法。
map.computeIfAbsent(name, key -> new PriorityQueue<Integer>(
(o1,o2)-> o1-o2
)).add(queueEntry);
- T3:每次从最低位的非0,开始操作
- T4:树型dp
22/11/6 第 318 场周赛:ak
finish Time: 0:51:56
PenaltyTime: 0:56:56
dirty 1
rank 122
拿到了内推机会??
这场的T1写的时候,不知道怎么把0移到后面,就写了两个for暴力移动,赛后看到大佬原来定义排序规则就可以了.自定义的比较函数只能对封装类有效。所以我们可以用流解决。
前几周都写出了dp,最近有点飘,最后还是用了trick,去跑了网络流
- T1: 按照题意操作后,之后自定义规则排序
int[] nums;
return IntStream.of(nums).boxed().sorted((o1,o2) ->{
if(o2 == 0) return -1;
else if(o1 == 0) return 1;
return 0;
}).mapToInt(v -> v).toArray();
- T2: 用map记录,之后扫一遍
- T3:用两个优先队列维护,顺便用双指针来保证 元素不会重复。
- T4:网络流跑了,没想dp
22/11/13 第 319 场周赛:ak
finish Time: 0:46:31
PenaltyTime: 0:46:31
dirty 0
rank 239
这场的T3,没想到正解。赛后看到好多大佬都是循环节的做法,学习了。T3的排序假如是相邻位置,是用归并解(顺便复习了下,归并排序)。T4比较简单,变成了手速场。速度感觉还是可以提升的。
- T1: 按照题意输出就行了
- T2: O ( n ∗ n ∗ l o g k ) O(n*n*logk) O(n∗n∗logk)
- T3: s o r t : O ( n l o g n ) sort:O(nlogn) sort:O(nlogn)
- T4:简单二维 d p [ i ] [ j ] dp[i][j] dp[i][j]
22/11/20 第 320 场周赛:
finish Time: 0:49:41
PenaltyTime: 0:54:41
dirty 1
rank 602
这场的T2码的二分有点久
T3的正解想得有点久。。。。中间还wa了一发
T4简单的优化,可能是没写式子,不好看出来。。。。
- T1:直接for循环 O ( n 3 ) O(n^3) O(n3)
- T2:中序遍历,之后二分。
这里花了10min去写二分
其实二分的边界可以总结一下:
如果向 l l l收缩,就 m i d = l + r + 1 > > 1 mid = l + r + 1>>1 mid=l+r+1>>1
如果向 r r r收缩, 就 m i d = l + r > > 1 mid = l + r >> 1 mid=l+r>>1
//from arignote
class Solution {
public List<List<Integer>> closestNodes(TreeNode root, List<Integer> queries) {
TreeSet<Integer> set = new TreeSet<>(Set.of(-1));
closestNodes(root, set);
return queries.stream().map(t -> List.of(set.floor(t), set.ceiling(t) == null ? -1 : set.ceiling(t))).toList();
}
private void closestNodes(TreeNode root, TreeSet<Integer> set) {
if (root != null) {
set.add(root.val);
closestNodes(root.left, set);
closestNodes(root.right, set);
}
}
}
- T3: dfs&&思维
- T4:二维 d p [ i ] [ j ] dp[i][j] dp[i][j] + 优化
∣ i = 1 n ∣ 1 k d p [ i ] [ j ] = ∑ 0 t = i − m i n L e n d p [ t ] [ j − 1 ] |_{i=1}^{n} |_{1}^{k}dp[i][j] = \sum_{0}^{t = i-minLen}dp[t][j-1] ∣i=1n∣1kdp[i][j]=∑0t=i−minLendp[t][j−1]
我们发现这个式子的时间复杂度是 O ( n ∗ n ∗ k ) O(n*n*k) O(n∗n∗k)
由于每次 d p [ i ] [ j ] dp[i][j] dp[i][j]的答案在前面已经计算出来了,所以我们记录下就可以了
22/11/27 第 321 场周赛:ak
finish Time: 0:30:30
PenaltyTime: 0:30:30
dirty 0
rank 168
refresh maxRaing 2183!!!
大佬说手速场,qwq
T1:赛后看到了数学解法,%%%%%
T4:赛时,没想好前缀和,用了两维
- T1: 等差数列 or for or 数学
- T2:贪心
- T3:单调栈
- T4:前缀和
22/12/4 第 322 场周赛:
finish Time: 0:34:58
PenaltyTime: 0:34:58
dirty 4
rank 1341
不找借口,没写出来就是没写出来!!!
T3因为初始化问题,wa了3发。static int ans = Integer.MAX_VALUE;//这个要在函数里初始化!!!!!!!!!
- T1: split一下
- T2:发现答案确定,循环一下
- T3:发现,只用找一个连通块内的最小变,dfs一下
- T4:发现对每个点bfs分层
wls的题单
- dp