file_path stringlengths 27 66 | url_title stringlengths 6 38 | url stringlengths 60 237 ⌀ | difficulty stringclasses 3
values | tags listlengths 1 8 | question stringlengths 107 2.73k | solution stringlengths 163 28.6k | final stringlengths 308 330 |
|---|---|---|---|---|---|---|---|
LeetCode/1331-1340/1332. 删除回文子序列（简单）.md | 1332. 删除回文子序列 | https://leetcode-cn.com/problems/the-k-weakest-rows-in-a-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-7okx/ | 简单 | [
"双指针",
"模拟"
] | 给你一个字符串 `s`,它仅由字母 `'a'` 和 `'b'` 组成。每一次删除操作都可以从 `s` 中删除一个回文 **子序列**。
返回删除给定字符串中所有字符(字符串为空)的最小删除次数。
「子序列」定义:如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到,那么这个字符串就是原字符串的一个子序列。
「回文」定义:如果一个字符串向后和向前读是一致的,那么这个字符串就是一个回文。
示例 1:
```
输入:s = "ababa"
输出:1
解释:字符串本身就是回文序列,只需要删除一次。
```
示例 2:
```
输入:s = "abb"
输出:2
解释:"abb" -> "bb" -> "".
先... | ### 双指针
由于 `s` 只有字母 `a` 和 `b`,并且删除的是「子序列」,因此最大的删除次数为 $2$(先删除所有的 `a`,再删除所有的 `b`)。
同时 `s` 本身不为空串(不存在删除次数为 $0$ 的情况),因此如果我们不能一次删除的话(`s` 本身为回文),只能通过 $2$ 次进行删除。
代码:
```Java
class Solution {
public int removePalindromeSub(String s) {
int n = s.length();
int i = 0, j = n - 1;
while (i < j) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1332` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1331-1340/1334. 阈值距离内邻居最少的城市（中等）.md | 1334. 阈值距离内邻居最少的城市 | https://leetcode.cn/problems/find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance/solutions/2526052/gong-shui-san-xie-han-gai-suo-you-cun-tu-svq7/ | 中等 | [
"最短路",
"图"
] | 有 $n$ 个城市,按从 $0$ 到 $n-1$ 编号。
给你一个边数组 `edges`,其中 $edges[i] = [from_{i}, to_{i}, weight_{i}]$ 代表 $from_{i}$ 和 $to_{i}$ 两个城市之间的双向加权边,距离阈值是一个整数 `distanceThreshold`。
返回能通过某些路径到达其他城市数目最少、且路径距离最大为 `distanceThreshold` 的城市。如果有多个这样的城市,则返回编号最大的城市。
注意,连接城市 $i$ 和 $j$ 的路径的距离等于沿该路径的所有边的权重之和。
示例 1:
```
输入:n = 4, edges = [[0,1,3],... | ### 基本分析
若能预处理图中任意两点 $i$ 和 $j$ 的最短距离 `dist`,那么统计每个点 $i$ 在图中有多少满足 $dist[j] \leq distanceThreshold$ 的点 $j$ 即为答案。
于是问题转换为:**如何求解给定图中,任意两点的最短距离**。
---
### 存图
在学习最短路之前,我们先搞懂众多图论问题的前置 🧀 :存图。
为了方便,我们约定 $n$ 为点数,$m$ 为边数。
根据点和边的数量级关系,可以将图分成如下两类:
* 稠密图:边数较多,边数接近于点数的平方,即 $m \approx n^2$
* 稀疏图:边数较少,边数接近于点数,即 $m \approx n$
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1334` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1331-1340/1337. 矩阵中战斗力最弱的 K 行（简单）.md | 1337. 矩阵中战斗力最弱的 K 行 | https://leetcode-cn.com/problems/the-k-weakest-rows-in-a-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-7okx/ | 简单 | [
"优先队列(堆)",
"二分"
] | 给你一个大小为 $m * n$ 的矩阵 $mat$,矩阵由若干军人和平民组成,分别用 $1$ 和 $0$ 表示。
请你返回矩阵中战斗力最弱的 $k$ 行的索引,按从最弱到最强排序。
如果第 $i$ 行的军人数量少于第 $j$ 行,或者两行军人数量相同但 $i$ 小于 $j$,那么我们认为第 $i$ 行的战斗力比第 $j$ 行弱。
军人 总是 排在一行中的靠前位置,也就是说 $1$ 总是出现在 $0$ 之前。
示例 1:
```
输入:mat =
[[1,1,0,0,0],
[1,1,1,1,0],
[1,0,0,0,0],
[1,1,0,0,0],
[1,1,1,1,1]],
k = 3
输出:[2,0,3]
... | ### 朴素解法
一个朴素的做法是对矩阵进行遍历,统计每一行的军人数量,并以二元组 $(cnt_i, idx_i)$ 的形式进行存储。
然后对所有行的战力进行排序,选出战力最小的 $k$ 个下标即是答案。
代码:
```Java
class Solution {
public int[] kWeakestRows(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
int[][] all = new int[m][1];
for (int i = 0; i < m; i++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1337` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1341-1350/1342. 将数字变成 0 的操作次数（简单）.md | 1342. 将数字变成 0 的操作次数 | https://leetcode-cn.com/problems/number-of-steps-to-reduce-a-number-to-zero/solution/gong-shui-san-xie-note-bie-pian-yi-ti-sh-85fb/ | 简单 | [
"模拟",
"数学"
] | 给你一个非负整数 `num` ,请你返回将它变成 $0$ 所需要的步数。 如果当前数字是偶数,你需要把它除以 $2$ ;否则,减去 $1$ 。
示例 1:
```
输入:num = 14
输出:6
解释:
步骤 1) 14 是偶数,除以 2 得到 7 。
步骤 2) 7 是奇数,减 1 得到 6 。
步骤 3) 6 是偶数,除以 2 得到 3 。
步骤 4) 3 是奇数,减 1 得到 2 。
步骤 5) 2 是偶数,除以 2 得到 1 。
步骤 6) 1 是奇数,减 1 得到 0 。
```
示例 2:
```
输入:num = 8
输出:4
解释:
步骤 1) 8 是偶数,除以 2 得到 4 。
步骤 2) 4 是偶数,... | ### 模拟
根据题意进行模拟:**根据当前 $num$ 的奇偶性进行对应操作,直到 $num$ 为 $0$,返回操作次数。**
代码:
```Java
class Solution {
public int numberOfSteps(int num) {
int ans = 0;
while (num != 0 && ++ans >= 0) num = num % 2 == 0 ? num / 2 : num - 1;
return ans;
}
}
```
* 时间复杂度:$O(\log{num})$
* 空间复杂度:$O(1)$
---
### 数学(二... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1341-1350/1345. 跳跃游戏 IV（困难）.md | 1345. 跳跃游戏 IV | https://leetcode-cn.com/problems/jump-game-iv/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-q9tb1/ | 困难 | [
"图论 BFS",
"双向 BFS"
] | 给你一个整数数组 `arr` ,你一开始在数组的第一个元素处(下标为 `0`)。
每一步,你可以从下标 i 跳到下标:
* `i + 1` 满足:`i + 1 < arr.length`
* `i - 1` 满足:`i - 1 >= 0`
* `j` 满足:`arr[i] == arr[j]` 且 `i != j`
请你返回到达数组最后一个元素的下标处所需的 **最少操作次数** 。
注意:任何时候你都不能跳到数组外面。
示例 1:
```
输入:arr = [100,-23,-23,404,100,23,23,23,3,404]
输出:3
解释:那你需要跳跃 3 次,下标依次为 0 --> 4 --> 3 --> 9 ... | ### 单向 BFS
根据跳跃规则,我们能够进行「前后跳」和「等值跳」,问题为到达结尾位置的最少步数,容易想到 `BFS`。
为了方便进行「等值跳」,我们可以先使用「哈希表」记录某个值有哪些下标。
在进行 `BFS` 时,假如当前走到的位置为 $t$,我们尝试将 $t - 1$、$t + 1$ 和与 $arr[t]$ 等值的位置进行入队,为了防止重复同队,我们可以使用 $dist$ 数组记录到达某个位置的最小步数(初始化为 `INF`),只有 $dist[ne]$ 为 `INF` 时,该点没有被遍历过,可以入队并更新最小步数。
但光使用 $dist$ 还不能确保复杂度为 $O(n)$,因为每次都需要遍历与 $arr[t]$ ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1345` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1371-1380/1374. 生成每种字符都是奇数个的字符串（简单）.md | 1374. 生成每种字符都是奇数个的字符串 | https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts/solution/by-ac_oier-i74n/ | 简单 | [
"模拟"
] | 给你一个整数 `n`,请你返回一个含 `n` 个字符的字符串,其中每种字符在该字符串中都恰好出现 奇数次 。
返回的字符串必须只含小写英文字母。如果存在多个满足题目要求的字符串,则返回其中任意一个即可。
示例 1:
```
输入:n = 4
输出:"pppz"
解释:"pppz" 是一个满足题目要求的字符串,因为 'p' 出现 3 次,且 'z' 出现 1 次。当然,还有很多其他字符串也满足题目要求,比如:"ohhh" 和 "love"。
```
示例 2:
```
输入:n = 2
输出:"xy"
解释:"xy" 是一个满足题目要求的字符串,因为 'x' 和 'y' 各出现 1 次。当然,还有很多其他字符串也满足题目要... | ### 模拟
题目仅规定所用到的字符出现次数均为奇数,并无规定单个字符的最大使用次数。
因此直接根据 $n$ 的奇偶性来做即可,若 $n$ 为奇数,则构造出由 $n$ 个 `b` 拼接的字符串;若 $n$ 为偶数,则构造出由 $1$ 个 `a` 和 $n - 1$ 个 `b` 的拼接字符串。
Java 代码:
```Java
class Solution {
public String generateTheString(int n) {
StringBuilder sb = new StringBuilder();
if (n % 2 == 0 && --n >= 0) sb.app... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1374` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1371-1380/1380. 矩阵中的幸运数（简单）.md | 1380. 矩阵中的幸运数 | https://leetcode-cn.com/problems/lucky-numbers-in-a-matrix/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-9xwg/ | 简单 | [
"模拟"
] | 给你一个 $m * n$ 的矩阵,矩阵中的数字 **各不相同** 。请你按 **任意** 顺序返回矩阵中的所有幸运数。
幸运数是指矩阵中满足同时下列两个条件的元素:
* 在同一行的所有元素中最小
* 在同一列的所有元素中最大
示例 1:
```
输入:matrix = [[3,7,8],[9,11,13],[15,16,17]]
输出:[15]
解释:15 是唯一的幸运数,因为它是其所在行中的最小值,也是所在列中的最大值。
```
示例 2:
```
输入:matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]
输出:[12]
解释:12 是唯一的幸运数,因为它是其所在行中的最小值,... | ### 模拟
根据题意进行模拟即可。
具体的,创建两个数组 `row` 和 `col` 用于进行预处理,$row[x]$ 含义为第 $x$ 行的最小值,$col[y]$ 为第 $y$ 列的最大值。
然后扫描棋盘取得符合条件的幸运值即可。
代码:
```Java
class Solution {
int N = 55;
int[] row = new int[N], col = new int[N];
public List<Integer> luckyNumbers (int[][] mat) {
int n = mat.length, m = mat[0].length;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1380` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1391-1400/1395. 统计作战单位数（中等）.md | 1395. 统计作战单位数 | https://leetcode.cn/problems/count-number-of-teams/solution/by-ac_oier-qm3a/ | 中等 | [
"树状数组",
"容斥原理"
] | `n` 名士兵站成一排。每个士兵都有一个 独一无二 的评分 `rating` 。
每 $3$ 个士兵可以组成一个作战单位,分组规则如下:
* 从队伍中选出下标分别为 `i`、`j`、`k` 的 $3$ 名士兵,他们的评分分别为 $rating[i]$、$rating[j]$、$rating[k]$
* 作战单位需满足: $rating[i] < rating[j] < rating[k]$ 或者 $rating[i] > rating[j] > rating[k]$ ,其中 $0 <= i < j < k < n$
请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。
示例 1:
```
输入... | ### 基本分析
为了方便,我们记 `rating` 为 `rs`。
题目本质是要我们统计所有满足「递增」或「递减」的三元组。换句话说,对于每个 $t = rs[i]$ 而言,我们需要统计比其 $t$ 大或比 $t$ 小的数的个数。
问题涉及「单点修改(更新数值 $t$ 的出现次数)」以及「区间查询(查询某段范围内数的个数)」,使用「树状数组」求解较为合适。
---
### 树状数组 - 枚举两端
一个朴素的想法是,对于三元组 $(i, j, k)$,我们枚举其两端 $i$ 和 $k$,根据 $rs[i]$ 和 $rs[k]$ 的大小关系,查询范围 $[i + 1, k - 1]$ 之间合法的数的个数。
在确定左端点 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1395` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1403. 非递增顺序的最小子序列（简单）.md | 1403. 非递增顺序的最小子序列 | https://leetcode.cn/problems/minimum-subsequence-in-non-increasing-order/solution/by-ac_oier-766t/ | 简单 | [
"贪心"
] | 给你一个数组 `nums`,请你从中抽取一个子序列,满足该子序列的元素之和严格大于未包含在该子序列中的各元素之和。
如果存在多个解决方案,只需返回长度最小的子序列。如果仍然有多个解决方案,则返回元素之和最大的子序列。
与子数组不同的地方在于,「数组的子序列」不强调元素在原数组中的连续性,也就是说,它可以通过从数组中分离一些(也可能不分离)元素得到。
注意,题目数据保证满足所有约束条件的解决方案是唯一的。同时,返回的答案应当按非递增顺序排列。
示例 1:
```
输入:nums = [4,3,10,9,8]
输出:[10,9]
解释:子序列 [10,9] 和 [10,8] 是最小的、满足元素之和大于其他各元素之和的子序列... | ### 贪心
根据题意,我们可以先对 `nums` 进行排序(升序),然后从后往前开始选择,当首次满足「选择元素之和 严格大于 未选择元素之和」时,必然满足所选元素个数最少,若存在其他同样个数的合法方案,也满足所选方案为元素和最大方案,同时满足答案输出按照非升序要求。
Java 代码:
```Java
class Solution {
public List<Integer> minSubsequence(int[] nums) {
Arrays.sort(nums);
int sum = 0, cur = 0, idx = nums.length - 1;
for (in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1403` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1405. 最长快乐字符串（中等）.md | 1405. 最长快乐字符串 | https://leetcode-cn.com/problems/longest-happy-string/solution/gong-shui-san-xie-jie-he-you-xian-dui-li-q6fd/ | 中等 | [
"优先队列(堆)",
"贪心"
] | 如果字符串中不含有任何 `'aaa'`,`'bbb'` 或 `'ccc'` 这样的字符串作为子串,那么该字符串就是一个「快乐字符串」。
给你三个整数 `a`,`b` ,`c`,请你返回 任意一个 满足下列全部条件的字符串 `s`:
* `s` 是一个尽可能长的快乐字符串。
* `s` 中 最多 有 `a` 个字母 `'a'`、`b` 个字母 `'b'`、`c` 个字母 `'c'` 。
* `s` 中只含有 `'a'`、`'b'` 、`'c'` 三种字母。
如果不存在这样的字符串 `s` ,请返回一个空字符串 `""`。
示例 1:
```
输入:a = 1, b = 1, c = 7
输出:"ccaccbcc"
解释:"... | ### 贪心
容易想到:**每次都取当前剩余次数最多的字符来进行构造(前提是满足「不出现形如 `aaa` 字符串」的要求)**。
具体的,可以使用「优先队列(堆)」来实现上述过程,以 `(字符编号, 字符剩余数量)` 的二元组形式进行存储,构建以 `字符剩余数量` 排倒序的「大根堆」:
1. 起始先将 $(0, a)$、$(1, b)$ 和 $(2, c)$ 进行入堆(其中 $123$ 为字符编号,代指 `abc`,同时规定只有剩余数量大于 $0$ 才能入堆);
2. 每次取出堆顶元素(剩余数量最多的字符),尝试参与答案的构造:
1. 不违反连续三个字符相同:则说明当前字符能够追加到当前答案尾部,若追加后还有字符剩余,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1405` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1408. 数组中的字符串匹配（简单）.md | 1408. 数组中的字符串匹配 | https://leetcode.cn/problems/string-matching-in-an-array/solution/by-ac_oier-k03v/ | 简单 | [
"模拟"
] | 给你一个字符串数组 `words`,数组中的每个字符串都可以看作是一个单词。
请你按任意顺序返回 `words` 中是其他单词的子字符串的所有单词。
如果你可以删除 `words[j]` 最左侧和/或最右侧的若干字符得到 `word[i]`,那么字符串 `words[i]` 就是 `words[j]` 的一个子字符串。
示例 1:
```
输入:words = ["mass","as","hero","superhero"]
输出:["as","hero"]
解释:"as" 是 "mass" 的子字符串,"hero" 是 "superhero" 的子字符串。
["hero","as"] 也是有效的答案。
```
示例 2:... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public List<String> stringMatching(String[] ss) {
List<String> ans = new ArrayList<>();
int n = ss.length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1408` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1410. HTML 实体解析器（中等）.md | 1410. HTML 实体解析器 | https://leetcode.cn/problems/html-entity-parser/solutions/2538217/gong-shui-san-xie-jing-dian-zi-fu-chuan-rvdh3/ | 中等 | [
"模拟",
"哈希表"
] | 「HTML 实体解析器」 是一种特殊的解析器,它将 HTML 代码作为输入,并用字符本身替换掉所有这些特殊的字符实体。
HTML 里这些特殊字符和它们对应的字符实体包括:
* 双引号:字符实体为 `"`,对应的字符是 `"`。
* 单引号:字符实体为 `'`,对应的字符是 `'` 。
* 与符号:字符实体为 `&`,对应对的字符是 `&` 。
* 大于号:字符实体为 `>`,对应的字符是 `>`。
* 小于号:字符实体为 `<`,对应的字符是 `<`。
* 斜线号:字符实体为 `⁄`,对应的字符是 `/`。
给你输入字符串 `text`,请你实现一个 HTML 实体解析器,返... | ### 模拟
每个特殊字符均以 `&` 开头,最长一个特殊字符为 `⁄`。
从前往后处理 `text`,若遇到 `&` 则往后读取最多 $6$ 个字符(中途遇到结束字符 `;` 则终止),若读取子串为特殊字符,将使用替换字符进行拼接,否则使用原字符进行拼接。
Java 代码:
```Java
class Solution {
public String entityParser(String text) {
Map<String, String> map = new HashMap<>(){{
put(""", "\"");
put(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1410` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/141. 环形链表（简单）.md | 141. 环形链表 | https://leetcode.cn/problems/linked-list-cycle/solution/by-ac_oier-lfgr/ | 简单 | [
"链表",
"快慢指针",
"双指针"
] | 给你一个链表的头节点 `head`,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪 `next` 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置(索引从 $0$ 开始)。注意:`pos` 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ,则返回 true 。 否则,返回 false 。
示例 1:
```
输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。
```
示例 2:
```
输入:head = [1,2], pos = 0
输... | ### 快慢指针
这是一道「快慢指针」的模板题。
使用两变量 `slow` 和 `fast` 分别代表快慢指针,`slow` 每次往后走一步,而 `fast` 每次往后两步,两者初始化均为 `head`。
若链表无环,则 `fast` 必然会先走到结尾,算法正常结束;若链表有环,当 `slow` 来到环入口时,`fast` 必然已经在环中的某个位置,此时再继续进行,由于存在速度差,发生相遇必不可能是 `slow` 追上 `fast`,而只能是 `fast` 从后方追上 `slow`,由于速度差为 $1$,因此最多会消耗不超过环节点个数的回合,两者即会相遇。
代码:
```Java
public class Solution ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.141` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/142. 环形链表 II（中等）.md | 142. 环形链表 II | https://leetcode.cn/problems/linked-list-cycle-ii/solution/by-ac_oier-xw16/ | 中等 | [
"链表",
"快慢指针",
"双指针"
] | 给定一个链表的头节点 `head`,返回链表开始入环的第一个节点。 如果链表无环,则返回 `null`。
如果链表中有某个节点,可以通过连续跟踪 `next` 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置(索引从 `0` 开始)。如果 `pos` 是 `-1`,则在该链表中没有环。
注意:`pos` 不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1:
```
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。
```
示例... | ### 快慢指针
起始使用 `slow` 和 `fast` 作为慢快指针(`slow` 每次走一步,`fast` 每次走两步),起始均为 `head`。
若 `fast` 顺利走到结尾,说明链表无环,直接返回 `null`;
若两者成功相遇,说明链表有环。我们定义链表起点到环入口距离为 `x`,环内节点数量为 `y`。那么从链表起点到环入口的任意路径都能归纳成 $x + k \times y$(其中 $k$ 为大于等于 $0$ 的任意值)。
当两者首次相遇时,假设 `slow` 走的距离为 `d1`,而 `fast` 走的距离为 `d2`,根据速度差定义可知 $d2 = d1 \times 2$。同时根据 [141. 环形链... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.142` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/146. LRU 缓存机制（中等）.md | 146. LRU 缓存机制 | https://leetcode-cn.com/problems/lru-cache/solution/gong-shui-san-xie-she-ji-shu-ju-jie-gou-68hv2/ | 中等 | [
"设计",
"链表",
"哈希表"
] | 运用你所掌握的数据结构,设计和实现一个 `LRU` (最近最少使用) 缓存机制 。
实现 `LRUCache` 类:
* `LRUCache(int capacity)` 以正整数作为容量 `capacity` 初始化 `LRU` 缓存
* `int get(int key)` 如果关键字 `key` 存在于缓存中,则返回关键字的值,否则返回 $-1$
* `void put(int key, int value)` 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。
进阶:你是否可以在 $O(1)$ ... | ### 基本分析
LRU 是一种十分常见的页面置换算法。
将 LRU 翻译成大白话就是:**当不得不淘汰某些数据时(通常是容量已满),选择最久未被使用的数据进行淘汰。**
**题目让我们实现一个容量固定的 `LRUCache` 。如果插入数据时,发现容器已满时,则先按照 LRU 规则淘汰一个数据,再将新数据插入,其中「插入」和「查询」都算作一次“使用”。**
可以通过 🌰 来理解,假设我们有容量为 $2$ 的 `LRUCache` 和 测试键值对 `[1-1,2-2,3-3]` ,将其按照顺序进行插入 & 查询:
* 插入 `1-1`,此时最新的使用数据为 `1-1`
* 插入 `2-2`,此时最新使用数据变为 `2-2`... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.146` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/149. 直线上最多的点数（困难）.md | 149. 直线上最多的点数 | https://leetcode-cn.com/problems/max-points-on-a-line/solution/gong-shui-san-xie-liang-chong-mei-ju-zhi-u44s/ | 困难 | [
"数学",
"枚举",
"哈希表"
] | 给你一个数组 `points`,其中 $points[i] = [x_i, y_i]$ 表示 `X-Y` 平面上的一个点。求最多有多少个点在同一条直线上。
示例 1:
```
输入:points = [[1,1],[2,2],[3,3]]
输出:3
```
示例 2:
```
输入:points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出:4
```
提示:
* $1 <= points.length <= 300$
* $points[i].length == 2$
* $-10^4 <= x_i, y_i <= 10^4$
* `points` 中的所有点 互不相同 | ### 枚举直线 + 枚举统计
我们知道,两点可以确定一条线。
一个朴素的做法是先枚举两点(确定一条线),然后检查其余点是否落在该线中。
为避免除法精度问题,当我们枚举两个点 $x$ 和 $y$ 时,不直接计算其对应直线的 `斜率`和 `截距`。
而是通过判断 $x$ 和 $y$ 与第三个点 $p$ 形成的两条直线斜率是否相等,来得知点 $p$ 是否落在该直线上。
斜率相等的两条直线要么平行,要么重合。
平行需要 $4$ 个点来唯一确定,我们只有 $3$ 个点,因此直接判定两条直线是否重合即可。
详细说,当给定两个点 $(x_1, y_1)$ 和 $(x_2, y_2)$ 时,对应斜率 $\frac{y_2 - y_1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.149` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/150. 逆波兰表达式求值（中等）.md | 150. 逆波兰表达式求值 | https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/solution/yi-ti-shuang-jie-xi-tong-zhan-shu-zu-mo-i1eq3/ | 中等 | [
"表达式计算"
] | 根据 逆波兰表示法,求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。
说明:
* 整数除法只保留整数部分。
* 给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1:
```
输入:tokens = ["2","1","+","3","*"]
输出:9
解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9
```
示例 2:
```
输入:tokens = ["4","13","5","/","+"]
输出:6
解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6
```
示例 ... | ### 基本思路
这是一道关于「表达式计算」的题目。
所有的「表达式计算」问题都离不开「栈」。
对于本题,我们可以建立一个「数字栈」,存放所有的数字,当遇到运算符时,从栈中取出两个数进行运算,并将结果放回栈内,整个过程结束后,栈顶元素就是最终结果。
而栈的实现通常有两种:使用数组继续模拟 & 使用系统自带的栈结构
***
### 数组模拟栈解法
代码:
```java []
class Solution {
public int evalRPN(String[] ts) {
int[] d = new int[ts.length];
int hh = 0, tt = -1;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.150` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1413. 逐步求和得到正数的最小值（简单）.md | 1413. 逐步求和得到正数的最小值 | https://leetcode.cn/problems/minimum-value-to-get-positive-step-by-step-sum/solution/by-ac_oier-qo4e/ | 简单 | [
"模拟"
] | 给你一个整数数组 `nums`。你可以选定任意的正数 `startValue` 作为初始值。
你需要从左到右遍历 `nums` 数组,并将 `startValue` 依次累加上 `nums` 数组中的值。
请你在确保累加和始终大于等于 $1$ 的前提下,选出一个最小的 正数 作为 `startValue`。
示例 1:
```
输入:nums = [-3,2,-3,4,2]
输出:5
解释:如果你选择 startValue = 4,在第三次累加时,和小于 1 。
累加求和
startValue = 4 | startValue = 5 | nums
... | ### 模拟
由于 `startValue` 可设定的最小值为 $1$,我们可以先统计当 `startValue = 1` 时,累加过程中的最小值 `min`。
根据 `min` 是否符合规定(大于等于 $1$)来决定如何调整:
* 若 `min` 满足大于等于 $1$,则 `startValue` 可取最小值 $1$;
* 若 `min` 不满足大于等于 $1$,计算将 `min` 调整到 $1$ 所需要的值(即 `1 - min`),将其累加到起始值上,即得答案 `2 - min`。
Java 代码:
```Java
class Solution {
public int minStartValue(int[] ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1413` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1414. 和为 K 的最少斐波那契数字数目（中等）.md | 1414. 和为 K 的最少斐波那契数字数目 | https://leetcode-cn.com/problems/find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-rgty8/ | 中等 | [
"数学",
"二分",
"贪心"
] | 给你数字 `k` ,请你返回和为 `k` 的斐波那契数字的最少数目,其中,每个斐波那契数字都可以被使用多次。
斐波那契数字定义为:
* F1 = 1
* F2 = 1
* Fn = Fn-1 + Fn-2 , 其中 n > 2 。
数据保证对于给定的 `k` ,一定能找到可行解。
示例 1:
```
输入:k = 7
输出:2
解释:斐波那契数字为:1,1,2,3,5,8,13,......
对于 k = 7 ,我们可以得到 2 + 5 = 7 。
```
示例 2:
```
输入:k = 10
输出:2
解释:对于 k = 10 ,我们可以得到 2 + 8 = 10 。
```
示例 3:
```
输入:k =... | ### 打表 + 贪心 + 二分
利用 `k` 的数据范围为 $1 <= k <= 10^9$,可以先使用 `static` 进行打表,预处理出值不超过 $10^9$ 的斐波那契数,存入数组 `list` 中。
然后考虑如何使用 `list` 中的数字(可重复)凑成 `k`。
一个直观的想法是:**每次从 `list` 中找到不超过 `k` 的最大数,用于进行对 `k` 的消减,直到 `k` 被消减到 $0$ 为止,消减的次数即是答案。**
而「从 `list` 中找到不超过 `k` 的最大数」这一操作,可使用「二分」。
下面证明该做法的正确性:
假定该做法所得到的可行解序列为 `A`(序列长度为 $ans$),真实最优... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1414` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1417. 重新格式化字符串（简单）.md | 1417. 重新格式化字符串 | https://leetcode.cn/problems/reformat-the-string/solution/by-ac_oier-uk8z/ | 简单 | [
"模拟",
"双指针"
] | 给你一个混合了数字和字母的字符串 `s`,其中的字母均为小写英文字母。
请你将该字符串重新格式化,使得任意两个相邻字符的类型都不同。也就是说,字母后面应该跟着数字,而数字后面应该跟着字母。
请你返回重新格式化后的字符串;如果无法按要求重新格式化,则返回一个空字符串。
示例 1:
```
输入:s = "a0b1c2"
输出:"0a1b2c"
解释:"0a1b2c" 中任意两个相邻字符的类型都不同。 "a0b1c2", "0a1b2c", "0c2a1b" 也是满足题目要求的答案。
```
示例 2:
```
输入:s = "leetcode"
输出:""
解释:"leetcode" 中只有字母,所以无法满足重新格式化的... | ### 模拟
起始先对字符串 `s` 进行遍历,将其分成字母串和数字串,若两者长度差值超过 $1$,说明无法构造成间隔字符串(返回空串),否则对两字符串使用双指针算法进行构造。
Java 代码:
```Java
class Solution {
public String reformat(String s) {
StringBuilder a = new StringBuilder(), b = new StringBuilder();
for (char c : s.toCharArray()) {
if (c >= 'a') a.append(c);
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1417` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1418. 点菜展示表（中等）.md | 1418. 点菜展示表 | https://leetcode-cn.com/problems/display-table-of-food-orders-in-a-restaurant/solution/gong-shui-san-xie-ha-xi-biao-yu-hong-hei-jmli/ | 中等 | [
"数据结构",
"哈希表",
"红黑树"
] | 给你一个数组 orders,表示客户在餐厅中完成的订单,确切地说, `orders[i]=[customerNamei,tableNumberi,foodItemi] `,其中 `customerNamei `是客户的姓名,`tableNumberi `是客户所在餐桌的桌号,而 `foodItemi `是客户点的餐品名称。
请你返回该餐厅的 点菜展示表 。在这张表中,表中第一行为标题,其第一列为餐桌桌号 “Table” ,后面每一列都是按字母顺序排列的餐品名称。接下来每一行中的项则表示每张餐桌订购的相应餐品数量,第一列应当填对应的桌号,后面依次填写下单的餐品数量。
注意:客户姓名不是点菜展示表的一部分。此外,表中的数据行应该按餐... | ### 基本分析
这是一道考虑「数据结构运用」与「简单设计」的模拟题。
我们可以根据最终的 “结果” 反推数据结构存储格式。
最终 “结果” 包含两部分:
1. `title` : 由 **"Table" + 排序去重的餐品** 组成
2. 内容 : 由 **桌号 + 每件餐品对应的数量** 组成
基于此,不难设计出使用 `Set` 存储 `title` 相关内容,使用 `Map` 存储内容相关部分。
去重 `Map` 的部分 `Key` 为桌号,同时为了快速索引当前桌号「某个餐品的数量」,需要再套一层 `Map`。即最终存储格式为 `桌号 : {餐品 : 个数}`。
---
### HashSet & HashMa... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1418` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1421-1430/1422. 分割字符串的最大得分（简单）.md | 1422. 分割字符串的最大得分 | https://leetcode.cn/problems/maximum-score-after-splitting-a-string/solution/by-ac_oier-3wua/ | 简单 | [
"前缀和",
"模拟"
] | 给你一个由若干 `0` 和 `1` 组成的字符串 `s` ,请你计算并返回将该字符串分割成两个非空子字符串(即左子字符串和右子字符串)所能获得的最大得分。
「分割字符串的得分」为左子字符串中 `0` 的数量加上右子字符串中 `1` 的数量。
示例 1:
```
输入:s = "011101"
输出:5
解释:
将字符串 s 划分为两个非空子字符串的可行方案有:
左子字符串 = "0" 且 右子字符串 = "11101",得分 = 1 + 4 = 5
左子字符串 = "01" 且 右子字符串 = "1101",得分 = 1 + 3 = 4
左子字符串 = "011" 且 右子字符串 = "101",得分 = 1 + 2 ... | ### 前缀和
构建前缀和数组来记录每个前缀中 $1$ 个个数,复杂度为 $O(n)$,枚举每个分割点,搭配前缀和数组计算左串中 $0$ 的数量和右串中 $1$ 的数量,取所有得分的最大值即是答案。
Java 代码:
```Java
class Solution {
public int maxScore(String s) {
int n = s.length(), ans = 0;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (s.charAt(i - 1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1422` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1421-1430/1423. 可获得的最大点数（中等）.md | 1423. 可获得的最大点数 | https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards/solutions/2551466/gong-shui-san-xie-zhuan-huan-wei-gu-ding-pbvd/ | 中等 | [
"滑动窗口"
] | 几张卡牌排成一行,每张卡牌都有一个对应的点数,点数由整数数组 `cardPoints` 给出。
每次行动,你可以从行的开头或者末尾拿一张卡牌,最终你必须正好拿 `k` 张卡牌。
你的点数就是你拿到手中的所有卡牌的点数之和。
给你一个整数数组 `cardPoints` 和整数 `k`,请你返回可以获得的最大点数。
示例 1:
```
输入:cardPoints = [1,2,3,4,5,6,1], k = 3
输出:12
解释:第一次行动,不管拿哪张牌,你的点数总是 1 。但是,先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌,最终点数为 1 + 6 + 5 = 12 。
```
示例 2:
```
输入... | ### 滑动窗口
从两边选卡片,选 `k` 张,卡片总数量为 `n` 张,即有 `n - k` 张不被选择。
所有卡片总和 `sum` 固定,要使选择的 `k` 张的总和最大,反过来就是要让不被选择的 `n - k` 张总和最小。
原问题等价为:**从 `cardPoints` 中找长度为 `n - k` 的连续段,使其总和最小。**
具体的,用变量 `sum` 代指 `cardPoints` 总和,`cur` 代表长度固定为 `n - k` 的当前窗口总和,`minv` 代表所有长度为 `n - k` 的窗口中总和最小的值。
起始先将滑动窗口压满,取得第一个滑动窗口的目标值 `cur`(同时更新为 `minv`),随后往... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1423` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1431-1440/1436. 旅行终点站（简单）.md | 1436. 旅行终点站 | https://leetcode-cn.com/problems/destination-city/solution/gong-shui-san-xie-jian-dan-fang-jia-mo-n-y47c/ | 简单 | [
"哈希表",
"模拟"
] | 给你一份旅游线路图,该线路图中的旅行线路用数组 paths 表示,其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站,即没有任何可以通往其他城市的线路的城市。
题目数据保证线路图会形成一条不存在循环的线路,因此恰有一个旅行终点站。
示例 1:
```
输入:paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
输出:"Sao Paulo"
解释:从 "London" 出发,最后抵达终点站 "Sao Paulo" 。本次旅行的路线是 "Lon... | ### 模拟 + 哈希表
根据题意,我们可以取一个任意城市作为起点,然后使用 $paths$ 中的路线信息开始搜索,直到当前城市无法到达下一个城市,即是答案。
实现上,为了可以快速找到某个城市所能到达的城市,可以先使用哈希表对 $paths$ 中的路线信息进行预处理。
代码:
```Java
class Solution {
public String destCity(List<List<String>> ps) {
Map<String, String> map = new HashMap<>();
for (List<String> p : ps) map.put(p.get(0)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1436` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1431-1440/1438. 绝对差不超过限制的最长连续子数组（中等）.md | 1438. 绝对差不超过限制的最长连续子数组 | https://leetcode-cn.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/solution/xiang-jie-er-fen-hua-dong-chuang-kou-dan-41g1/ | 中等 | [
"滑动窗口",
"单调队列",
"二分"
] | 给你一个整数数组 nums ,和一个表示限制的整数 limit,请你返回最长连续子数组的长度,该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。
如果不存在满足条件的子数组,则返回 0 。
示例 1:
```
输入:nums = [8,2,4,7], limit = 4
输出:2
解释:所有子数组如下:
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4.
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 ... | ### 二分 + 滑动窗口
数据范围是 $10^5$,因此只能考虑「对数解法」和「线性解法」。
对数解法很容易想到「二分」。
在给定 `limit` 的情况下,倘若有「恰好」满足条件的区间长度为 `len`,必然存在满足条件且长度小于等于 `len` 的区间,同时必然不存在长度大于 `len` 且满足条件的区间。
因此长度 `len` 在数轴中具有「二段性」。
**问题转化为「如何判断 `nums` 中是否有长度 `len` 的区间满足绝对值不超过 `limit`」**
我们可以枚举区间的右端点 `r`,那么对应的左端点为 `r - len + 1`,然后使用「单调队列」来保存区间的最大值和最小值。
```java
c... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1438` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1441. 用栈操作构建数组（中等）.md | 1441. 用栈操作构建数组 | https://leetcode.cn/problems/build-an-array-with-stack-operations/solution/by-ac_oier-q37s/ | 中等 | [
"模拟",
"构造"
] | 给你一个数组 `target` 和一个整数 `n`。
每次迭代,需要从 `list = { 1 , 2 , 3 ..., n }` 中依次读取一个数字。
请使用下述操作来构建目标数组 `target` :
* `"Push"`:从 `list` 中读取一个新元素, 并将其推入数组中。
* `"Pop"`:删除数组中的最后一个元素。
如果目标数组构建完成,就停止读取更多元素。
题目数据保证目标数组严格递增,并且只包含 `1` 到 `n` 之间的数字。
请返回构建目标数组所用的操作序列。如果存在多个可行方案,返回任一即可。
示例 1:
```
输入:target = [1,3], n = 3
输出:["Push","P... | ### 模拟
根据题意进行模拟即可。
每次我们将当前处理到 `i` 压入栈中(往答案添加一个 `Push`),然后判断当前处理到的 `i` 是否最新的栈顶元素 $target[j]$ 是否相同。
若不相同则丢弃元素(往答案添加一个 `Pop`),若存在则将指针 `j` 后移,直到构建出目标答案。
Java 代码:
```Java
class Solution {
public List<String> buildArray(int[] target, int n) {
List<String> ans = new ArrayList<>();
int m = target.length... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1441` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1442. 形成两个异或相等数组的三元组数目（中等）.md | 1442. 形成两个异或相等数组的三元组数目 | https://leetcode-cn.com/problems/count-triplets-that-can-form-two-arrays-of-equal-xor/solution/gong-shui-san-xie-xiang-jie-shi-yong-qia-7gzm/ | 中等 | [
"数学",
"前缀和"
] | 给你一个整数数组 arr 。
现需要从数组中取三个下标 i、j 和 k ,其中 (0 <= i < j <= k < arr.length) 。
a 和 b 定义如下:
* a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]
* b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k]
注意:^ 表示 按位异或 操作。
请返回能够令 a == b 成立的三元组 (i, j , k) 的数目。
示例 1:
```
输入:arr = [2,3,1,6,7]
输出:4
解释:满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)
`... | ### 基本分析
数据范围是 $10^2$,三元组包含 $i$、$j$ 和 $k$ 三个下标,因此通过「枚举下标」并「每次循环计算异或结果」的 $O(n^4)$ 朴素做法不用考虑了。
相信做过 [1310. 子数组异或查询](https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/) 的同学不难想到可以使用「树状数组」或者「前缀异或」来优化我们「每次循环计算异或结果」的过程。
由于不涉及修改操作,我们优先使用「前缀异或」。经过这样优化之后的复杂度是 $O(n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1442` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1446. 连续字符（简单）.md | 1446. 连续字符 | https://leetcode-cn.com/problems/consecutive-characters/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-xtv6/ | 简单 | [
"双指针",
"模拟"
] | 给你一个字符串 `s` ,字符串的「能量」定义为:只包含一种字符的最长非空子字符串的长度。
请你返回字符串的能量。
示例 1:
```
输入:s = "leetcode"
输出:2
解释:子字符串 "ee" 长度为 2 ,只包含字符 'e' 。
```
示例 2:
```
输入:s = "abbcccddddeeeeedcba"
输出:5
解释:子字符串 "eeeee" 长度为 5 ,只包含字符 'e' 。
```
示例 3:
```
输入:s = "triplepillooooow"
输出:5
```
示例 4:
```
输入:s = "hooraaaaaaaaaaay"
输出:11
```
示例 5:
```
输... | ### 双指针
根据题意,使用「双指针」进行扫描计数即可。
代码:
```Java
class Solution {
public int maxPower(String s) {
int n = s.length(), ans = 1;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && s.charAt(j) == s.charAt(i)) j++;
ans = Math.max(ans, j - i);
i = j;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1447. 最简分数（中等）.md | 1447. 最简分数 | https://leetcode-cn.com/problems/simplified-fractions/solution/gong-shui-san-xie-jian-dan-shu-lun-yun-y-wma5/ | 中等 | [
"数学",
"最大公约数"
] | 给你一个整数 `n` ,请你返回所有 $0$ 到 $1$ 之间(不包括 $0$ 和 $1$)满足分母小于等于 `n` 的 最简 分数 。分数可以以 **任意** 顺序返回。
示例 1:
```
输入:n = 2
输出:["1/2"]
解释:"1/2" 是唯一一个分母小于等于 2 的最简分数。
```
示例 2:
```
输入:n = 3
输出:["1/2","1/3","2/3"]
```
示例 3:
```
输入:n = 4
输出:["1/2","1/3","1/4","2/3","3/4"]
解释:"2/4" 不是最简分数,因为它可以化简为 "1/2" 。
```
示例 4:
```
输入:n = 1
输出:[]... | ### 数论
数据范围为 $100$ 且数值大小在 $(0, 1)$ 之间,因此枚举「分子 + 分母」的 $O(n^2)$ 做法是可接受的。
于是问题转化为:**如何快速判断两个数组成的分数是否为最简(即判断两个数的最大公约数是否为 $1$)。**
快速求得 $a$ 和 $b$ 的最大公约数的主要方式有两种 :「更相减损法」和「欧几里得算法」,其中「欧几里得算法」的递归实现最为好写,复杂度为 $O(\log{(a + b)})$,在绝大多数的情况下适用,只有在需要实现高精度时,才会考虑使用「更相减损法」。
而 stein 算法则是没有必要掌握的。
代码:
```Java
class Solution {
int g... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1447` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1449. 数位成本和为目标值的最大数字（困难）.md | 1449. 数位成本和为目标值的最大数字 | https://leetcode-cn.com/problems/form-largest-integer-with-digits-that-add-up-to-target/solution/gong-shui-san-xie-fen-liang-bu-kao-lu-we-uy4y/ | 困难 | [
"完全背包",
"背包问题",
"动态规划"
] | 给你一个整数数组 cost 和一个整数 target 。请你返回满足如下规则可以得到的 最大 整数:
给当前结果添加一个数位(i + 1)的成本为 cost[i] (cost 数组下标从 0 开始)。
总成本必须恰好等于 target 。
添加的数位中没有数字 0 。
由于答案可能会很大,请你以字符串形式返回。
如果按照上述要求无法得到任何整数,请你返回 "0" 。
示例 1:
```
输入:cost = [4,3,2,5,6,7,2,5,5], target = 9
输出:"7772"
解释:添加数位 '7' 的成本为 2 ,添加数位 '2' 的成本为 3 。所以 "7772" 的代价为 2*3+ 3*1 = 9 。 "97... | ### 基本分析
根据题意:给定 $1$~$9$ 几个数字,每个数字都有选择成本,求给定费用情况下,凑成的最大数字是多少。
通常我们会如何比较两数大小关系?
首先我们 **根据长度进行比较,长度较长数字较大**;再者,对于长度相等的数值,**从高度往低位进行比较,找到第一位不同,不同位值大的数值较大。**
其中规则一的比较优先级要高于规则二。
基于此,我们可以将构造分两步进行。
---
### 动态规划 + 贪心
具体的,先考虑「数值长度」问题,每个数字有相应选择成本,所能提供的长度均为 $1$。
问题转换为:**有若干物品,求给定费用的前提下,花光所有费用所能选择的最大价值(物品个数)为多少。**
每个数字可以... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1449` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1450. 在既定时间做作业的学生人数（简单）.md | 1450. 在既定时间做作业的学生人数 | https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time/solution/by-ac_oier-4ftz/ | 简单 | [
"区间求和问题",
"差分"
] | 给你两个整数数组 `startTime`(开始时间)和 `endTime`(结束时间),并指定一个整数 `queryTime` 作为查询时间。
已知,第 `i` 名学生在 `startTime[i]` 时开始写作业并于 `endTime[i]` 时完成作业。
请返回在查询时间 `queryTime` 时正在做作业的学生人数。形式上,返回能够使 `queryTime` 处于区间 `[startTime[i], endTime[i]]`(含)的学生人数。
示例 1:
```
输入:startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
输出:1
解释:一共有 3 名学生。
第... | ### 差分
为了方便,我们令 `startTime` 为 `st`,令 `endTime` 为 `et`,令 `queryTime` 为 `t`。
问题涉及「区间修改」+「单点查询」,是一道关于「差分」的模板题。
> **对差分不熟悉的同学,可以查看前置 🧀 : [差分入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490329&idx=1&sn=6d448a53cd722bbd990fda82bd262857)**
利用时间点数据范围为 $1e3$,我们建立一个 $1e3$ 大小的差分数组 `c`,对于时间段 $[st[i], et[i]]$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1450` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1451-1460/1455. 检查单词是否为句中其他单词的前缀（简单）.md | 1455. 检查单词是否为句中其他单词的前缀 | https://leetcode.cn/problems/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/solution/by-ac_oier-cfsi/ | 简单 | [
"模拟",
"双指针"
] | 给你一个字符串 `sentence` 作为句子并指定检索词为 `searchWord`,其中句子由若干用 单个空格 分隔的单词组成。请你检查检索词 `searchWord` 是否为句子 `sentence` 中任意单词的前缀。
如果 `searchWord` 是某一个单词的前缀,则返回句子 `sentence` 中该单词所对应的下标(下标从 $1$ 开始)。如果 `searchWord` 是多个单词的前缀,则返回匹配的第一个单词的下标(最小下标)。如果 `searchWord` 不是任何单词的前缀,则返回 $-1$ 。
字符串 `s` 的前缀是 `s` 的任何前导连续子字符串。
示例 1:
```
输入:sentence = ... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int isPrefixOfWord(String s, String t) {
String[] ss = s.split(" ");
int n = ss.length, m = t.length();
for (int i = 0; i < n; i++) {
if (ss[i].length() < m) continue;
boolean ok = true;
for (in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1455` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1451-1460/1457. 二叉树中的伪回文路径（中等）.md | 1457. 二叉树中的伪回文路径 | https://leetcode.cn/problems/pseudo-palindromic-paths-in-a-binary-tree/solutions/2540912/gong-shui-san-xie-gao-xiao-ji-jian-de-we-f2gb/ | 中等 | [
"DFS",
"位运算"
] | 给你一棵二叉树,每个节点的值为 `1` 到 `9` 。
我们称二叉树中的一条路径是 「伪回文」的,当它满足:路径经过的所有节点值的排列中,存在一个回文序列。
请你返回从根到叶子节点的所有路径中伪回文路径的数目。
示例 1:
```
输入:root = [2,3,1,3,1,null,1]
输出:2
解释:上图为给定的二叉树。总共有 3 条从根到叶子的路径:红色路径 [2,3,3] ,绿色路径 [2,1,1] 和路径 [2,3,1] 。
在这些路径中,只有红色和绿色的路径是伪回文路径,因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ,绿色路径 [2,1,1] 存在回文排列 [1,2,1] 。
```... | ### DFS + 位运算
“伪回文”是指能够通过重新排列变成“真回文”,真正的回文串只有两种情况:
* 长度为偶数,即出现次数为奇数的字符个数为 $0$ 个
* 长度为奇数,即出现次数为奇数的字符个数为 $1$ 个(位于中间)
因此,**我们只关心路径中各个字符(数字 `0-9`)出现次数的奇偶性,若路径中所有字符出现次数均为偶数,或仅有一个字符出现次数为奇数,那么该路径满足要求**。
节点值范围为 $[1, 9]$,除了使用固定大小的数组进行词频统计以外,还可以使用一个 `int` 类型的变量 `cnt` 来统计各数值的出现次数奇偶性:若 $cnt$ 的第 $k$ 位为 $1$,说明数值 $k$ 的出现次数为奇数,否则说... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1457` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1451-1460/1460. 通过翻转子数组使两个数组相等（简单）.md | 1460. 通过翻转子数组使两个数组相等 | https://leetcode.cn/problems/make-two-arrays-equal-by-reversing-sub-arrays/solution/by-ac_oier-pv38/ | 简单 | [
"模拟",
"计数"
] | 给你两个长度相同的整数数组 `target` 和 `arr` 。每一步中,你可以选择 `arr` 的任意 非空子数组 并将它翻转。你可以执行此过程任意次。
如果你能让 `arr` 变得与 `target` 相同,返回 `True`;否则,返回 `False` 。
示例 1:
```
输入:target = [1,2,3,4], arr = [2,4,1,3]
输出:true
解释:你可以按照如下步骤使 arr 变成 target:
1- 翻转子数组 [2,4,1] ,arr 变成 [1,4,2,3]
2- 翻转子数组 [4,2] ,arr 变成 [1,2,4,3]
3- 翻转子数组 [4,3] ,arr 变成 [1,2,3,... | ### 模拟
当两数组词频相同,且翻转次数不受限制时,我们至少能通过「逐个调整」将一数组变为另一数组(以当前需要调整的位置作为待翻转子数组的左端点,目标数值所在位置作为右端点)。
Java 代码:
```Java
class Solution {
public boolean canBeEqual(int[] target, int[] arr) {
int n = arr.length, tot = 0;
int[] cnt = new int[1010];
for (int i = 0; i < n; i++) {
if (++cnt[targ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1460` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1464. 数组中两元素的最大乘积（简单）.md | 1464. 数组中两元素的最大乘积 | https://leetcode.cn/problems/maximum-product-of-two-elements-in-an-array/solution/by-ac_oier-t5p3/ | 简单 | [
"模拟"
] | 给你一个整数数组 `nums`,请你选择数组的两个不同下标 `i` 和 `j`,使 `(nums[i]-1)*(nums[j]-1)` 取得最大值。
请你计算并返回该式的最大值。
示例 1:
```
输入:nums = [3,4,5,2]
输出:12
解释:如果选择下标 i=1 和 j=2(下标从 0 开始),则可以获得最大值,(nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12 。
```
示例 2:
```
输入:nums = [1,5,4,5]
输出:16
解释:选择下标 i=1 和 j=3(下标从 0 开始),则可以获得最大值 (5-1)*(5-1) = 16 。
... | ### 模拟
根据题意,使用两个变量 `a` 和 `b` 记录最大值和次大值。
Java 代码:
```Java
class Solution {
public int maxProduct(int[] nums) {
int a = -1, b = -1;
for (int x : nums) {
if (x > a) {
b = a; a = x;
} else if (x > b) {
b = x;
}
}
retur... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1464` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1465. 切割后面积最大的蛋糕（中等）.md | 1465. 切割后面积最大的蛋糕 | https://leetcode.cn/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/solutions/2500353/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ecnvl/ | 中等 | [
"贪心",
"模拟"
] | 矩形蛋糕的高度为 `h` 且宽度为 `w`,给你两个整数数组 `hs` 和 `vs`,其中:
* `hs[i]` 是从矩形蛋糕顶部到第 `i` 个水平切口的距离
* `vs[j]` 是从矩形蛋糕的左侧到第 `j` 个竖直切口的距离
请你按数组 `hs` 和 `vs` 中提供的水平和竖直位置切割后,请你找出**面积最大**的那份蛋糕,并返回其**面积**。
由于答案可能是一个很大的数字,因此需要将结果 对 $10^9 + 7$ 取余 后返回。
示例 1:
```
输入:h = 5, w = 4, hs = [1,2,4], vs = [1,3]
输出:4
解释:上图所示的矩阵蛋糕中,红色线表示水平和竖直方向上的切口。... | ### 贪心
由于求是“最大”蛋糕面积,**水平/垂直方向的连续段必然由「同方向且相邻」的切割位置(或是蛋糕边界)所构成**。
这点可通过反证法证明:如果最终蛋糕的(左右或上下)边缘不是由「相邻」的切割位置(或是蛋糕边界)决定,而是由跨越某些切割点的位置所决定的话,那么这个蛋糕必不是“完整”一块。
用题面的示例 $1$ 来举个 🌰,我们仅分析水平方向(`hs = [1, 2, 4]`):
最终蛋糕的在该方向的连续段大小,只能是 `[上边缘, 切割点 1]`、`[切割点 1, 切割点 2]`、`[切割点 2, 切割点 4]` 和 `[切割点 4, 下边缘]` 四个之一,而不可能由非相邻切割点所组成,例如 `[切割点 1, ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1465` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1466. 重新规划路线（中等）.md | 1466. 重新规划路线 | null | 中等 | [
"图",
"DFS"
] | `n` 座城市,从 `0` 到 `n-1` 编号,其间共有 `n-1` 条路线。
因此,要想在两座不同城市之间旅行只有唯一一条路线可供选择(路线网形成一颗树)。
去年,交通运输部决定重新规划路线,以改变交通拥堵的状况。
路线用 `connections` 表示,其中 $connections[i] = [a, b]$ 表示从城市 `a` 到 `b` 的一条有向路线。
今年,城市 `0` 将会举办一场大型比赛,很多游客都想前往城市 `0` 。
请你帮助重新规划路线方向,使每个城市都可以访问城市 `0`。返回需要变更方向的最小路线数。
题目数据保证每个城市在重新规划路线方向后都能到达城市 `0` 。
示例 1:
```
... | ### DFS
核心等价:原图上从所有点能够访问到 `0`,等价于反图中从 `0` 出发能到任何点。
因此,可用 `connections` 创建双向图(原边权重为 $1$,反向边权重为 $0$),然后从 `0` 出发访问整张图,统计访问过程中的权重之和,即是原图中需要反向的边的数量。
Java 代码:
```Java
class Solution {
int N = 50010, M = N * 2, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
void add(int a, int ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1466` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1470. 重新排列数组（简单）.md | 1470. 重新排列数组 | https://leetcode.cn/problems/shuffle-the-array/solution/by-ac_oier-3lck/ | 简单 | [
"模拟"
] | 给你一个数组 `nums`,数组中有 `2n` 个元素,按 $[x_1,x_2,...,x_n,y_1,y_2,...,y_n]$ 的格式排列。
请你将数组按 $[x_1,y_1,x_2,y_2,...,x_n,y_n]$ 格式重新排列,返回重排后的数组。
示例 1:
```
输入:nums = [2,5,1,3,4,7], n = 3
输出:[2,3,5,4,1,7]
解释:由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ,所以答案为 [2,3,5,4,1,7]
```
示例 2:
```
输入:nums = [1,2,3,4,4,3,2,1], n = 4
输出:[1,4,2,3,3,2,... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int[] shuffle(int[] nums, int n) {
int[] ans = new int[2 * n];
for (int i = 0, j = n, k = 0; k < 2 * n; k++) {
ans[k] = k % 2 == 0 ? nums[i++] : nums[j++];
}
return ans;
}
}
```
Typescript 代码:
```Typescript... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1470` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1471-1480/1473. 粉刷房子 III（困难）.md | 1473. 粉刷房子 III | https://leetcode-cn.com/problems/paint-house-iii/solution/gong-shui-san-xie-san-wei-dong-tai-gui-h-ud7m/ | 困难 | [
"动态规划",
"序列 DP"
] | 在一个小城市里,有 `m` 个房子排成一排,你需要给每个房子涂上 `n` 种颜色之一(颜色编号为 `1` 到 `n` )。
有的房子去年夏天已经涂过颜色了,所以这些房子不可以被重新涂色。
我们将连续相同颜色尽可能多的房子称为一个街区。
(比方说 `houses = [1,2,2,3,3,2,1,1]`,它包含 5 个街区 `[{1}, {2,2}, {3,3}, {2}, {1,1}]` 。)
给你一个数组 `houses`,一个 `m * n` 的矩阵 `cost` 和一个整数 `target`,其中:
* `houses[i]`:是第 `i` 个房子的颜色,`0` 表示这个房子还没有被涂色。
* `cost[i][j... | ### 动态规划
**定义 $f[i][j][k]$ 为考虑前 $i$ 间房子,且第 $i$ 间房子的颜色编号为 $j$,前 $i$ 间房子形成的分区数量为 $k$ 的所有方案中的「最小上色成本」。**
我们不失一般性的考虑 $f[i][j][k]$ 该如何转移,由于某些房子本身就已经上色,上色的房子是不允许被粉刷的。
我们可以根据第 $i$ 间房子是否已经被上色,进行分情况讨论:
* 第 $i$ 间房子已经被上色,即 $houses[i] != 0$,此时只有满足 $j == houses[i]$ 的状态才是有意义的,其余状态均为 `INF`。
同时根据「第 $i$ 间房子的颜色 $j$」与「第 $i - 1$ 间... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1473` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1471-1480/1475. 商品折扣后的最终价格（简单）.md | 1475. 商品折扣后的最终价格 | https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop/solution/by-ac_oier-hw5b/ | 简单 | [
"模拟",
"单调栈"
] | 给你一个数组 `prices`,其中 `prices[i]` 是商店里第 `i` 件商品的价格。
商店里正在进行促销活动,如果你要买第 `i` 件商品,那么你可以得到与 `prices[j]` 相等的折扣,其中 `j` 是满足 `j > i` 且 `prices[j] <= prices[i]` 的 最小下标 ,如果没有满足条件的 `j` ,你将没有任何折扣。
请你返回一个数组,数组中第 `i` 个元素是折扣后你购买商品 `i` 最终需要支付的价格。
示例 1:
```
输入:prices = [8,4,6,2,3]
输出:[4,2,4,2,3]
解释:
商品 0 的价格为 price[0]=8 ,你将得到 prices[... | ### 模拟
数据范围为 $10^3$,可直接模拟。
Java 代码:
```Java
class Solution {
public int[] finalPrices(int[] ps) {
int n = ps.length;
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
int k = 0;
for (int j = i + 1; j < n && k == 0; j++) {
if (ps[j] <= ps[i]) k = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1475` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1471-1480/1480. 一维数组的动态和（简单）.md | 1480. 一维数组的动态和 | https://leetcode-cn.com/problems/running-sum-of-1d-array/solution/gong-shui-san-xie-yi-wei-qian-zhui-he-mo-g8hn/ | 简单 | [
"模拟",
"前缀和"
] | 给你一个数组 nums 。数组「动态和」的计算公式为:runningSum[i] = sum(nums[0]...nums[i]) 。
请返回 nums 的动态和。
示例 1:
```
输入:nums = [1,2,3,4]
输出:[1,3,6,10]
解释:动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
```
示例 2:
```
输入:nums = [1,1,1,1,1]
输出:[1,2,3,4,5]
解释:动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
```
示例 3:
```
输入:nums = [3,1,2,10,1]
输出:[3,4,6... | ### 一维前缀和
根据题意,创建答案数组,从头到尾模拟一遍,每次都将当前的前缀之和赋值给 $ans[i]$ 即可。
代码:
```Java
class Solution {
public int[] runningSum(int[] nums) {
int n = nums.length;
int[] ans = new int[n];
for (int i = 0, s = 0; i < n; i++) {
ans[i] = s = s + nums[i];
}
return ans;
}
}
```
* ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1480` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1481-1490/1482. 制作 m 束花所需的最少天数（中等）.md | 1482. 制作 m 束花所需的最少天数 | https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/ | 中等 | [
"二分"
] | 给你一个整数数组 bloomDay,以及两个整数 m 和 k 。
现需要制作 m 束花。制作花束时,需要使用花园中 相邻的 k 朵花 。
花园中有 n 朵花,第 i 朵花会在 bloomDay[i] 时盛开,恰好 可以用于 一束 花中。
请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。
示例 1:
```
输入:bloomDay = [1,10,3,10,2], m = 3, k = 1
输出:3
解释:让我们一起观察这三天的花开过程,x 表示花开,而 _ 表示花还未开。
现在需要制作 3 束花,每束只需要 1 朵。
1 天后:[x, _, _, _, _] // 只能制... | ### 二分查找
题目需要求得「所需的最少天数」。
假设「所需的最少天数」为 `ans` ,那么以 `ans` 为分割点的数轴具有「二段性」:
* 天数范围落在 $[0, ans)$ 无法制作完成
* 天数范围在 $[ans, +∞)$ 可以制作完成
因此可以通过「二分」来找到分割点 `ans`。
接下来我们需要确定「二分范围」,一个及格的「二分范围」只需要确保答案落在范围即可。
显然范围的左边界为 $0$(代表尚未有花绽放),范围的右边界为 $max(bloomDay[i])$(最后一朵花的开放时间,代表所有花都开完)。
我们既可以通过遍历 $bloomDay[]$ 数组来取得「精确右边界」,也可以直接根据数据范围 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1482` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1481-1490/1486. 数组异或操作（简单）.md | 1486. 数组异或操作 | https://leetcode-cn.com/problems/xor-operation-in-an-array/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-dggg/ | 简单 | [
"数学",
"模拟"
] | 给你两个整数,n 和 start 。
数组 nums 定义为:nums[i] = start + 2*i(下标从 0 开始)且 n == nums.length 。
请返回 nums 中所有元素按位异或(XOR)后得到的结果。
示例 1:
```
输入:n = 5, start = 0
输出:8
解释:数组 nums 为 [0, 2, 4, 6, 8],其中 (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8 。
"^" 为按位异或 XOR 运算符。
```
示例 2:
```
输入:n = 4, start = 3
输出:8
解释:数组 nums 为 [3, 5, 7, 9],其中 (3 ^ 5 ^ 7 ^ 9... | ### 模拟
数据范围只有 $10^3$,按照题目要求从头模拟一遍即可。
代码:
```Java
class Solution {
public int xorOperation(int n, int start) {
int ans = start;
for (int i = 1; i < n; i++) {
int x = start + 2 * i;
ans ^= x;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 数学... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1486` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1501-1510/1503. 所有蚂蚁掉下来前的最后一刻（中等）.md | 1503. 所有蚂蚁掉下来前的最后一刻 | https://leetcode.cn/problems/last-moment-before-all-ants-fall-out-of-a-plank/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-u77hy/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 有一块木板,长度为 `n` 个 单位 。一些蚂蚁在木板上移动,每只蚂蚁都以每秒一个单位的速度移动。其中,一部分蚂蚁向左移动,其他蚂蚁向右移动。
当两只向 不同 方向移动的蚂蚁在某个点相遇时,它们会同时改变移动方向并继续移动。假设更改方向不会花费任何额外时间。
而当蚂蚁在某一时刻 `t` 到达木板的一端时,它立即从木板上掉下来。
给你一个整数 `n` 和两个整数数组 `left` 以及 `right`。两个数组分别标识向左或者向右移动的蚂蚁在 `t = 0` 时的位置。请你返回最后一只蚂蚁从木板上掉下来的时刻。
示例 1:
```
输入:n = 4, left = [4,3], right = [0,1]
输出:4
解释... | ### 模拟
当一只蚂蚁起始位置为 `x`,方向往左,且往左移动过程不受其他影响时,其到达左边界所需时间为 `x`;若方向往右,且往右移动过程不受其他影响时,其到达右边界所需时间为 `n - x`。
蚂蚁之间的相互影响实际上并不会影响它们到达木板边缘的时间。
两只相遇的蚂蚁只是简单地交换了彼此的移动方向,并没有影响到它们的移动步数,即两只蚂蚁相遇可视为身份互换。
因此,我们只需要分别计算每只蚂蚁单独掉落到木板边缘所需的时间,然后取最大值即可得到所有蚂蚁掉落的最后时刻。
Java 代码:
```Java
class Solution {
public int getLastMoment(int n, int[] le... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1503` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/153. 寻找旋转排序数组中的最小值（中等）.md | 153. 寻找旋转排序数组中的最小值 | https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/ | 中等 | [
"二分"
] | 已知一个长度为 n 的数组,预先按照升序排列,经由 1 到 n 次 旋转 后,得到输入数组。
例如,原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到:
* 若旋转 4 次,则可以得到 [4,5,6,7,0,1,2]
* 若旋转 7 次,则可以得到 [0,1,2,4,5,6,7]
注意,数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
给你一个元素值 互不相同 的数组 nums ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
示例... | ### 二分查找
今天这道题和昨天的 [81. 搜索旋转排序数组 II](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) 相比,有了限制条件「所有整数互不相同」。
因此我们不需要进行「恢复二段性」的预处理,是可以做到严格 $O(log{n})$ 的复杂度。
我们仍然从「二分」的本质「二段性」进行出发分析:
经过旋转的数组,显然前半段满足 `>= nums[0]`,而后半段不满足 `>= nums[0]`。我们可以以此作为依据,通过「二分」找到旋转点。然后通过旋转点找到全局最小值即可。
代码:
```java []
class Solu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.153` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/154. 寻找旋转排序数组中的最小值 II（困难）.md | 154. 寻找旋转排序数组中的最小值 II | https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/ | 困难 | [
"二分"
] | 已知一个长度为 `n` 的数组,预先按照升序排列,经由 $1$ 到 $n$ 次 旋转 后,得到输入数组。
例如,原数组 `nums = [0,1,4,4,5,6,7]` 在变化后可能得到:
* 若旋转 $4$ 次,则可以得到 `[4,5,6,7,0,1,4]`
* 若旋转 $74 次,则可以得到 `[0,1,4,4,5,6,7]`
注意,数组 `[a[0], a[1], a[2], ..., a[n-1]]` 旋转一次 的结果为数组 `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]` 。
给你一个可能存在「重复」元素值的数组 `nums` ,它原来是一个升序排列的数组,并按上述情形进行了多次旋... | ### 二分
根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。
但和 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/) 不同的是,本题元素并不唯一。
**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**
**因为「二分」的本质是二段性,并非单调性。只... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.154` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/155. 最小栈（简单）.md | 155. 最小栈 | https://leetcode-cn.com/problems/min-stack/solution/tu-li-zhan-shi-shuang-zhan-shi-xian-zui-fcwj5/ | 简单 | [
"栈"
] | 设计一个支持 push ,pop ,top 操作,并能在常数时间内检索到最小元素的栈。
* push(x) —— 将元素 x 推入栈中。
* pop() —— 删除栈顶的元素。
* top() —— 获取栈顶元素。
* getMin() —— 检索栈中的最小元素。
示例:
```
输入:
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]
```
输出:
```
[null,null,null,null,-3,null,0,-2]
解释:
MinStack minStack = new Min... | ### 双栈解法
为了快速找到栈中最小的元素,我们可以使用一个辅助栈 help。
通过控制 help 的压栈逻辑来实现:*help 栈顶中始终存放着栈内元素的最小值。*
代码:
```java
class MinStack {
Deque<Integer> data = new ArrayDeque<>();
Deque<Integer> help = new ArrayDeque<>();
public void push(int val) {
data.addLast(val);
if (help.isEmpty() || help.peekLast() >= va... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.155` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/160. 相交链表（简单）.md | 160. 相交链表 | https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/gong-shui-san-xie-zhao-liang-tiao-lian-b-h3bd/ | 简单 | [
"链表",
"栈"
] | 给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
图示两个链表在节点 c1 开始相交:
<img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png" style="zoom:50%;" />
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
示例 1:
<img src="https://assets.leetcode-cn.com/aliyun-lc-upload/... | ### 朴素解法
一个朴素的做法是两层循环:当遇到第一个相同的节点时说明找到了;全都走完了还没遇到相同,说明不存在交点。
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
for (ListNode h1 = a; h1 != null ; h1 = h1.next) {
for (ListNode h2 = b; h2 != null ; h2 = h2.next) {
if (h1.equals(h2)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.160` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1511-1520/1518. 换酒问题（简单）.md | 1518. 换酒问题 | https://leetcode-cn.com/problems/water-bottles/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-sh-7yyo/ | 简单 | [
"模拟",
"数学"
] | 小区便利店正在促销,用 `numExchange` 个空酒瓶可以兑换一瓶新酒。你购入了 `numBottles` 瓶酒。
如果喝掉了酒瓶中的酒,那么酒瓶就会变成空的。
请你计算**最多**能喝到多少瓶酒。
示例 1:
```
输入:numBottles = 9, numExchange = 3
输出:13
解释:你可以用 3 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 9 + 3 + 1 = 13 瓶酒。
```
示例 2:
```
输入:numBottles = 15, numExchange = 4
输出:19
解释:你可以用 4 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 15 + 3 + 1 = 19 瓶酒。
... | ### 模拟
根据题意进行模拟即可,使用 $ans$ 统计答案,$n$ 为空瓶子个数。
起始有 $n$ 瓶酒,因此 $ans = n$,此时空瓶子个数为 $n$,当且仅当空瓶子个数 $n$ 大于等于兑换个数 $m$ 时,可以继续喝到酒(能够更新 $ans$),兑换后得到酒的个数为 $a = \left \lfloor \frac{n}{m} \right \rfloor$,剩余空瓶子个数等于「兑换酒的个数 $a$」和「兑换后剩余的酒瓶子个数 $b = n \pmod m$」之和。
代码:
```Java
class Solution {
public int numWaterBottles(int n, int m) ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1518` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1531-1540/1537. 最大得分（困难）.md | 1537. 最大得分 | https://leetcode.cn/problems/get-the-maximum-score/solution/by-ac_oier-ht78/ | 困难 | [
"前缀和",
"构造",
"双指针",
"序列 DP",
"动态规划"
] | 你有两个 有序 且数组内元素互不相同的数组 `nums1` 和 `nums2` 。
一条 合法路径 定义如下:
* 选择数组 `nums1` 或者 `nums2` 开始遍历(从下标 $0$ 处开始)。
* 从左到右遍历当前数组。
* 如果你遇到了 `nums1` 和 `nums2` 中都存在的值,那么你可以切换路径到另一个数组对应数字处继续遍历(但在合法路径中重复数字只会被统计一次)。
得分定义为合法路径中不同数字的和。
请你返回所有可能合法路径中的最大得分。
由于答案可能很大,请你将它对 $10^9 + 7$ 取余后返回。
示例 1:
```
输入:nums1 = [2,4,5,8,10], nums2 = [4,6... | ### 前缀和 + 构造(分段计算)
一个简单且正确的做法,是我们构造一种决策方案,使得能够直接计算出最大得分。
首先,在最佳路径中所有的公共点都必然会经过,因此我们可以将值相等的点进行合并,即看作同一个点。
利用两个数组均满足「单调递增」,我们可以通过 $O(n + m)$ 的复杂度统计出那些公共点,以二元组 $(i, j)$ 的形式存储到 `list` 数组(二元组含义为 $nums1[i] = nums2[j]$)。
对于 `list` 中的每对相邻元素(相邻公共点),假设为 $(a_i, b_i)$ 和 $(c_i, d_i)$,我们可以通过「前缀和」计算出 $nums1[a_i ... c_i]$ 以及 $nums... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1537` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1571-1580/1576. 替换所有的问号（简单）.md | 1576. 替换所有的问号 | https://leetcode-cn.com/problems/replace-all-s-to-avoid-consecutive-repeating-characters/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-fa1u/ | 简单 | [
"模拟"
] | 给你一个仅包含小写英文字母和 `'?'` 字符的字符串 `s`,请你将所有的 `'?'` 转换为若干小写字母,使最终的字符串不包含任何 **连续重复** 的字符。
注意:你 不能 修改非 `'?'` 字符。
题目测试用例保证 除 `'?'` 字符 之外,不存在连续重复的字符。
在完成所有转换(可能无需转换)后返回最终的字符串。如果有多个解决方案,请返回其中任何一个。可以证明,在给定的约束条件下,答案总是存在的。
示例 1:
```
输入:s = "?zs"
输出:"azs"
解释:该示例共有 25 种解决方案,从 "azs" 到 "yzs" 都是符合题目要求的。只有 "z" 是无效的修改,因为字符串 "zzs" 中有连续... | ### 模拟
根据题意进行模拟,尝试对每个 $s[i]$ 进行替换,能够替换的前提是 $s[i]$ 为 `?`,且替换字符与前后字符(若存在)不同,由于只需要确保与前后字符不同,因此必然最多在 $3$ 个字符内找到可替换的值。
代码:
```Java
class Solution {
public String modifyString(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
for (int i = 0; i < n; i++) {
for (int c = 0; c ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1576` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1581-1590/1582. 二进制矩阵中的特殊位置（简单）.md | 1582. 二进制矩阵中的特殊位置 | https://leetcode.cn/problems/special-positions-in-a-binary-matrix/solution/by-ac_oier-61w0/ | 简单 | [
"模拟"
] | 给你一个大小为 `rows x cols` 的矩阵 `mat`,其中 `mat[i][j]` 是 `0` 或 `1`,请返回 矩阵 `mat` 中特殊位置的数目 。
特殊位置 定义:如果 `mat[i][j] = 1` 并且第 `i` 行和第 `j` 列中的所有其他元素均为 `0`(行和列的下标均 从 `0` 开始 ),则位置 `(i, j)` 被称为特殊位置。
示例 1:
```
输入:mat = [[1,0,0],
[0,0,1],
[1,0,0]]
输出:1
解释:(1,2) 是一个特殊位置,因为 mat[1][2] == 1 且所处的行和列上所有其他元素都是 0
```... | ### 模拟
根据题意,使用数组 `r` 和 `c` 分别预处理除每行和每列所含 $1$ 的个数,复杂度为 $O(m \times n)$。
随后分别统计特殊位置的个数:满足 $mat[i][j] = 1$ 且 $r[i] = c[j] = 1$ 的位置。
Java 代码:
```Java
class Solution {
public int numSpecial(int[][] mat) {
int n = mat.length, m = mat[0].length, ans = 0;
int[] r = new int[n], c = new int[m];
for... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1582` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1581-1590/1583. 统计不开心的朋友（中等）.md | 1583. 统计不开心的朋友 | https://leetcode-cn.com/problems/count-unhappy-friends/solution/gong-shui-san-xie-ha-xi-biao-mo-ni-ti-by-2qy0/ | 中等 | [
"哈希表",
"模拟"
] | 给你一份 `n` 位朋友的亲近程度列表,其中 `n` 总是**偶数** 。
对每位朋友 `i`,`preferences[i]` 包含一份 按亲近程度从高到低排列 的朋友列表。
换句话说,排在列表前面的朋友与 `i` 的亲近程度比排在列表后面的朋友更高。每个列表中的朋友均以 `0` 到 `n-1` 之间的整数表示。
所有的朋友被分成几对,配对情况以列表 `pairs` 给出,其中 `pairs[i] = [xi, yi]` 表示 `xi` 与 `yi` 配对,且 `yi` 与 `xi` 配对。
但是,这样的配对情况可能会是其中部分朋友感到不开心。在 `x` 与 `y` 配对且 `u` 与 `v` 配对的情况下,如果同时满足下... | ### 模拟
模拟题,先将所有的 $preferences$ 使用「哈希表套哈希表」的形式进行存储,存储格式为 `{x : {y : score1}, {z : score12}, ... }`。
如果 $x$ 和 $y$ 的亲密度要比 $x$ 和 $z$ 的亲密度要高,则有 $score1 > score2$。利用原本 $preferences[i]$ 就是按照亲密度进行排序,我们可以对下标进行转换作为亲密数得分即可。
然后对所有的 $pairs$ 进行遍历,统计所有的答案,注意一个小朋友只能被统计一次。
> 当然利用 $n$ 的数据范围,直接使用二维数组充当哈希表也是可以的(见 $P2$)
代码:
```Java
cl... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1583` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1581-1590/1588. 所有奇数长度子数组的和（简单）.md | 1588. 所有奇数长度子数组的和 | https://leetcode-cn.com/problems/sum-of-all-odd-length-subarrays/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-18jq3/ | 简单 | [
"前缀和",
"数学"
] | 给你一个正整数数组 `arr` ,请你计算所有可能的奇数长度子数组的和。
子数组 定义为原数组中的一个连续子序列。
请你返回 `arr` 中 所有奇数长度子数组的和 。
示例 1:
```
输入:arr = [1,4,2,5,3]
输出:58
解释:所有奇数长度子数组和它们的和为:
[1] = 1
[4] = 4
[2] = 2
[5] = 5
[3] = 3
[1,4,2] = 7
[4,2,5] = 11
[2,5,3] = 10
[1,4,2,5,3] = 15
我们将所有值求和得到 1 + 4 + 2 + 5 + 3 + 7 + 11 + 10 + 15 = 58
```
示例 2:
```
输入:arr = [1... | ### 前缀和
枚举所有长度为奇数的子数组,我们可以通过「枚举长度 - 枚举左端点,并计算右端点」的两层循环来做。
而对于区间 $[l, r]$ 的和问题,可以直接再加一层循环来做,这样复杂度来到了 $O(n^3)$,但本题数据范围只有 $100$,也是可以过的。
对于此类区间求和问题,我们应当想到使用「前缀和」进行优化:使用 $O(n)$ 的复杂度预处理出前缀和数组,每次查询 $[l, r]$ 区间和可以在 $O(1)$ 返回。
代码:
```Java
class Solution {
public int sumOddLengthSubarrays(int[] arr) {
int n = ar... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1588` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1591-1600/1592. 重新排列单词间的空格（简单）.md | 1592. 重新排列单词间的空格 | https://leetcode.cn/problems/rearrange-spaces-between-words/solution/by-ac_oier-0f5h/ | 简单 | [
"模拟",
"双指针"
] | 给你一个字符串 `text`,该字符串由若干被空格包围的单词组成。每个单词由一个或者多个小写英文字母组成,并且两个单词之间至少存在一个空格。题目测试用例保证 `text` 至少包含一个单词 。
请你重新排列空格,使每对相邻单词之间的空格数目都 相等 ,并尽可能 最大化 该数目。如果不能重新平均分配所有空格,请 将多余的空格放置在字符串末尾 ,这也意味着返回的字符串应当与原 `text` 字符串的长度相等。
返回 重新排列空格后的字符串 。
示例 1:
```
输入:text = " this is a sentence "
输出:"this is a sentence"
解释:总共有 9 个空格和 4 ... | ### 模拟
根据题意模拟即可:使用「双指针」统计空格数量和分割出所有单词。
Java 代码:
```Java
class Solution {
public String reorderSpaces(String s) {
int n = s.length(), cnt = 0;
List<String> list = new ArrayList<>();
for (int i = 0; i < n; ) {
if (s.charAt(i) == ' ' && ++i >= 0 && ++cnt >= 0) continue;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1592` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1591-1600/1598. 文件夹操作日志搜集器（简单）.md | 1598. 文件夹操作日志搜集器 | https://leetcode.cn/problems/crawler-log-folder/solution/by-ac_oier-24xb/ | 简单 | [
"模拟",
"计数",
"栈"
] | 每当用户执行变更文件夹操作时,LeetCode 文件系统都会保存一条日志记录。
下面给出对变更操作的说明:
* `"../"` :移动到当前文件夹的父文件夹。如果已经在主文件夹下,则 继续停留在当前文件夹 。
* `"./"` :继续停留在当前文件夹。
* `"x/"` :移动到名为 `x` 的子文件夹中。题目数据 保证总是存在文件夹 x 。
给你一个字符串列表 `logs` ,其中 `logs[i]` 是用户在 `ith` 步执行的操作。
文件系统启动时位于主文件夹,然后执行 `logs` 中的操作。
执行完所有变更文件夹操作后,请你找出 返回主文件夹所需的最小步数 。
示例 1:
```
输入:logs = ["d... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int minOperations(String[] logs) {
int depth = 0;
for (String s : logs) {
if (s.equals("../")) depth = Math.max(0, depth - 1);
else if (!s.equals("./")) depth++;
}
return depth;
}
}
```
TypeScri... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1598` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1591-1600/1600. 皇位继承顺序（中等）.md | 1600. 皇位继承顺序 | https://leetcode-cn.com/problems/throne-inheritance/solution/gong-shui-san-xie-shi-yong-dan-xiang-lia-7t65/ | 中等 | [
"单链表",
"哈希表"
] | 一个王国里住着国王、他的孩子们、他的孙子们等等。每一个时间点,这个家庭里有人出生也有人死亡。
这个王国有一个明确规定的皇位继承顺序,第一继承人总是国王自己。我们定义递归函数 Successor(x, curOrder) ,给定一个人 x 和当前的继承顺序,该函数返回 x 的下一继承人。
```
Successor(x, curOrder):
如果 x 没有孩子或者所有 x 的孩子都在 curOrder 中:
如果 x 是国王,那么返回 null
否则,返回 Successor(x 的父亲, curOrder)
否则,返回 x 不在 curOrder 中最年长的孩子
```
比方说,假... | ### 单向链表 & 标记删除
根据题意,我们需要将「新儿子」插入到「父亲」的「最后一个儿子」的「儿子们」的后面(**注意这是个递归过程**);如果该「父亲」还没有任何儿子,则直接插到「父亲」后面。
因此,我们需要在节点 `Node` 中使用一个 `last` 记录该节点的「最后一个儿子」,同时因为删除的时候,我们无法在 $O(1)$ 的复杂度内更新 `last` 信息,所以只能使用「标记删除」的方式。
代码:
```Java
class ThroneInheritance {
class Node {
String name;
Node next;
Node last;... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1600` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1601. 最多可达成的换楼请求数目（困难）.md | 1601. 最多可达成的换楼请求数目 | https://leetcode-cn.com/problems/maximum-number-of-achievable-transfer-requests/solution/gong-shui-san-xie-er-jin-zhi-mei-ju-by-a-enef/ | 困难 | [
"二进制枚举"
] | 我们有 `n` 栋楼,编号从 `0` 到 `n - 1` 。每栋楼有若干员工。由于现在是换楼的季节,部分员工想要换一栋楼居住。
给你一个数组 $requests$ ,其中 $requests[i] = [from_i, to_i]$ ,表示一个员工请求从编号为 $from_i$ 的楼搬到编号为 $to_i$ 的楼。
一开始 所有楼都是满的,所以从请求列表中选出的若干个请求是可行的需要满足 每栋楼员工净变化为 $0$ 。意思是每栋楼 离开 的员工数目 等于 该楼 搬入 的员工数数目。比方说 $n = 3$ 且两个员工要离开楼 $0$ ,一个员工要离开楼 $1$ ,一个员工要离开楼 $2$ ,如果该请求列表可行,应该要有两个员工搬入... | ### 二进制枚举
为了方便,我们令 $requests$ 的长度为 $m$。
数据范围很小,$n$ 的范围为 $20$,而 $m$ 的范围为 $16$。
根据每个 $requests[i]$ 是否选择与否,共有 $2^m$ 种状态(不超过 $70000$ 种状态)。我们可以采用「二进制枚举」的思路来求解,使用二进制数 $state$ 来表示对 $requests[i]$ 的选择情况,当 $state$ 的第 $k$ 位为 $1$,代表 $requests[k]$ 被选择。
我们枚举所有的 $state$ 并进行合法性检查,从中选择出包含请求数的最多(二进制表示中包含 $1$ 个数最多)的合法 $state$,其包含的请求数... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1601` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1603. 设计停车系统（简单）.md | 1603. 设计停车系统 | https://leetcode-cn.com/problems/design-parking-system/solution/yi-ti-san-jie-jian-dan-bian-liang-ha-xi-0gs72/ | 简单 | [
"位运算",
"哈希表"
] | 请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位:大,中和小,每种尺寸分别有固定数目的车位。
请你实现 ParkingSystem 类:
* ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 类,三个参数分别对应每种停车位的数目。
* bool addCar(int carType) 检查是否有 carType 对应的停车位。 carType 有三种类型:大,中,小,分别用数字 1, 2 和 3 表示。一辆车只能停在 carType 对应尺寸的停车位中。如果没有空车位,请返回 false ,否则将该车停入车位并返回 true 。
示... | ### 简单变量
一个简单的做法是,直接使用几个成员变量来记录。
```Java
class ParkingSystem {
int big, medium, small;
public ParkingSystem(int _big, int _medium, int _small) {
big = _big;
medium = _medium;
small = _small;
}
public boolean addCar(int ct) {
if (ct == 1 && big > 0) return big-- >... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1603` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1606. 找到处理最多请求的服务器（困难）.md | 1606. 找到处理最多请求的服务器 | https://leetcode-cn.com/problems/find-servers-that-handled-most-number-of-requests/solution/by-ac_oier-zgm6/ | 困难 | [
"数据结构",
"优先队列(堆)",
"红黑树",
"二分"
] | 你有 $k$ 个服务器,编号为 $0$ 到 $k-1$ ,它们可以同时处理多个请求组。
每个服务器有无穷的计算能力但是不能同时处理超过一个请求。
请求分配到服务器的规则如下:
* 第 $i$(序号从 $0$ 开始)个请求到达。
* 如果所有服务器都已被占据,那么该请求被舍弃(完全不处理)。
* 如果第 ( `i % k` ) 个服务器空闲,那么对应服务器会处理该请求。
* 否则,将请求安排给下一个空闲的服务器(服务器构成一个环,必要的话可能从第 $0$ 个服务器开始继续找下一个空闲的服务器)。比方说,如果第 $i$ 个服务器在忙,那么会查看第 ( $i+1$ ) 个服务器,第 ( $i+2$ ) 个服务器等等。
* 给你一个严格... | ### 数据结构
题目要统计处理任务数最多的机器,首先容易想到使用「哈希表」统计每个机台处理的任务数,利用机台数量 $k$ 最多不超过 $10^5$,我们可以开一个静态数组 `cnts` 来充当哈希表,同时维护一个当前处理的最大任务数量 `max`,最终所有满足 $cnst[i] = \max$ 的机台集合即是答案。
再根据「每个任务有对应的开始时间和持续时间」以及「任务分配规则」,容易想到使用优先队列(堆)和有序集合(红黑树)来进行维护。
具体的,利用「每个任务有对应的开始时间和持续时间」,我们使用优先队列(堆)维护二元组 $(idx, endTime)$,其中 $idx$ 为机器编号,$endTime$ 为当前机台所处理任... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1606` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1608. 特殊数组的特征值（简单）.md | 1608. 特殊数组的特征值 | https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x/solution/by-ac_oier-z525/ | 简单 | [
"排序",
"二分",
"枚举",
"模拟",
"计数"
] | 给你一个非负整数数组 `nums`。如果存在一个数 `x` ,使得 `nums` 中恰好有 `x` 个元素 大于或者等于 `x` ,那么就称 `nums` 是一个 特殊数组 ,而 `x` 是该数组的 特征值 。
注意: `x` 不必 是 `nums` 的中的元素。
如果数组 `nums` 是一个 特殊数组 ,请返回它的特征值 `x` 。否则,返回 `-1` 。可以证明的是,如果 `nums` 是特殊数组,那么其特征值 `x` 是 唯一的 。
示例 1:
```
输入:nums = [3,5]
输出:2
解释:有 2 个元素(3 和 5)大于或等于 2 。
```
示例 2:
```
输入:nums = [0,0]
输出:... | ### 排序 + 枚举 + 二分
根据题意并结合 $nums[i]$ 的数据范围为 $1e3$,我们可以通过「枚举」的方式找到 `x`,而对于每个 `x` 的合法性检查,我们需要快速知道 `nums` 中比 `x` 大的数的个数,这可以通过「排序 + 二分」来做。
Java 代码:
```Java
class Solution {
public int specialArray(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
for (int x = 0; x < 1010; x++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1608` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1609. 奇偶树（中等）.md | 1609. 奇偶树 | https://leetcode-cn.com/problems/even-odd-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-d-kuyi/ | 中等 | [
"层序遍历",
"BFS",
"DFS"
] | 如果一棵二叉树满足下述几个条件,则可以称为 **奇偶树** :
二叉树根节点所在层下标为 $0$ ,根的子节点所在层下标为 $1$ ,根的孙节点所在层下标为 $2$ ,依此类推。
* **偶数下标** 层上的所有节点的值都是 **奇** 整数,从左到右按顺序 **严格递增**
* **奇数下标** 层上的所有节点的值都是 **偶** 整数,从左到右按顺序 **严格递减**
给你二叉树的根节点,如果二叉树为 奇偶树 ,则返回 `true` ,否则返回 `false` 。
示例 1:
```
输入:root = [1,10,4,3,null,7,9,12,8,6,null,null,2]
输出:true
解释:每一层的节点... | ### BFS
考察「层序遍历」,在遍历过程中需要记录层下标,并根据层下标检查进行「节点值的奇偶性」和「是否满足递增/递减」。
额外使用一个布尔变量 `flag` 记录层序是否为偶数(判断节点值的奇偶性),使用 `prev` 记录当前层的上一节点的值(判断是否满足递增/递减)即可,`prev` 起始值可根据数据范围设置为哨兵值。
代码:
```Java
class Solution {
public boolean isEvenOddTree(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
boolean flag = t... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1609` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1610. 可见点的最大数目（困难）.md | 1610. 可见点的最大数目 | https://leetcode-cn.com/problems/maximum-number-of-visible-points/solution/gong-shui-san-xie-qiu-ji-jiao-ji-he-ti-b-0bid/ | 困难 | [
"数学",
"几何",
"排序",
"双指针",
"滑动窗口"
] | 给你一个点数组 `points` 和一个表示角度的整数 `angle` ,你的位置是 `location`,其中 $location = [pos_x, pos_y]$ 且 $points[i] = [x_i, y_i]$ 都表示 `X-Y` 平面上的整数坐标。
最开始,你面向东方进行观测。你 不能 进行移动改变位置,但可以通过 自转 调整观测角度。换句话说,$pos_x$ 和 $pos_y$ 不能改变。你的视野范围的角度用 `angle` 表示, 这决定了你观测任意方向时可以多宽。设 d 为你逆时针自转旋转的度数,那么你的视野就是角度范围 $[d - angle/2, d + angle/2]$ 所指示的那片区域。
对于每个点... | ### 数学
这是一道思维难度不大,但细节繁多的题目。
题目要我们旋转出一个角度为 $angle$ 的、可无限延伸的覆盖面,使得该覆盖面所能覆盖 $points$ 中的点最多。
我们所在的位置为 $location = (x,y)$,我们可以将 $(x,y)$ 作为「极点」,求所有 $points[i]$ 的「极角」。
令 $points[i] =(a,b)$,与极点关系 $dx = a - x;dy = b - y$。
求极角的方式有两种:
1. 使用 $atan(\frac{dy}{dx})$:值域范围为 [-90°,90°],需要对 $dx$ 与 $dy$ 进行象限讨论,从而将值域范围转化为我们希望... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1610` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/162. 寻找峰值（中等）.md | 162. 寻找峰值 | https://leetcode-cn.com/problems/find-peak-element/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-qva7v/ | 中等 | [
"二分"
] | 峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 `nums`,找到峰值元素并返回其索引。数组可能包含多个峰值,在这种情况下,返回 任何一个峰值 所在位置即可。
你可以假设 `nums[-1] = nums[n] = -∞` 。
你必须实现时间复杂度为 $O(\log{n})$ 的算法来解决此问题。
示例 1:
```
输入:nums = [1,2,3,1]
输出:2
解释:3 是峰值元素,你的函数应该返回其索引 2。
```
示例 2:
```
输入:nums = [1,2,1,3,5,6,4]
输出:1 或 5
解释:你的函数可以返回索引 1,其峰值元素为 2;
或者返回索引 5, 其峰值... | ### 模拟
由于数据范围只有 $1000$,使用线性扫描找峰值的模拟做法也是没有问题。
代码:
```Java
class Solution {
public int findPeakElement(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
boolean ok = true;
if (i - 1 >= 0) {
if (nums[i - 1] >= nums[i]) ok = false;
}
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.162` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/165. 比较版本号（中等）.md | 165. 比较版本号 | https://leetcode-cn.com/problems/compare-version-numbers/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-xsod/ | 中等 | [
"模拟"
] | 给你两个版本号 version1 和 version2 ,请你比较它们。
版本号由一个或多个修订号组成,各修订号由一个 '.' 连接。每个修订号由 多位数字 组成,可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号,下标从 0 开始,最左边的修订号下标为 0 ,下一个修订号下标为 1 ,以此类推。例如,2.5.33 和 0.1 都是有效的版本号。
比较版本号时,请按从左到右的顺序依次比较它们的修订号。比较修订号时,只需比较 忽略任何前导零后的整数值 。也就是说,修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号,则该修订号视为 0 。例如,版本 1.0 小于版本 1.1 ,因为它们下标为 ... | ### 模拟
根据题意,对字符串进行分割,诸位比较「修订号」大小即可。
对于缺省的修订号位置,使用 $0$ 进行代指。
代码:
```Java
class Solution {
public int compareVersion(String v1, String v2) {
String[] ss1 = v1.split("\\."), ss2 = v2.split("\\.");
int n = ss1.length, m = ss2.length;
int i = 0, j = 0;
while (i < n || j < m) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.165` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/166. 分数到小数（中等）.md | 166. 分数到小数 | https://leetcode-cn.com/problems/fraction-to-recurring-decimal/solution/gong-shui-san-xie-mo-ni-shu-shi-ji-suan-kq8c4/ | 中等 | [
"数学",
"模拟",
"哈希表"
] | 给定两个整数,分别表示分数的分子 `numerator` 和分母 `denominator`,以**字符串形式返回小数**。
如果小数部分为循环小数,则将循环的部分括在括号内。
如果存在多个答案,只需返回 **任意一个**。
对于所有给定的输入,保证答案字符串的长度小于 $10^4$ 。
示例 1:
```
输入:numerator = 1, denominator = 2
输出:"0.5"
```
示例 2:
```
输入:numerator = 2, denominator = 1
输出:"2"
```
示例 3:
```
输入:numerator = 2, denominator = 3
输出:"0.(6)"
`... | ### 模拟
这是一道模拟 [竖式计算(除法)](https://baike.baidu.com/item/%E7%AB%96%E5%BC%8F%E8%AE%A1%E7%AE%97)的题目。
首先可以明确,两个数相除要么是「有限位小数」,要么是「无限循环小数」,而不可能是「无限不循环小数」。
然后考虑人工计算两数相除是如何进行:
这引导我们可以在模拟竖式计算(除法)过程中,使用「哈希表」记录某个余数最早在什么位置出现过,一旦出现相同余数,则将「出现位置」到「当前结尾」之间的字符串抠出来,即是「循环小数」部分。
> PS. 到这里,从人工模拟除法运算的过程,我们就可以知道「为什么不会出现“无限不循环小数”」,因为始终是对余数... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.166` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/168. Excel表列名称（简单）.md | 168. Excel表列名称 | https://leetcode-cn.com/problems/excel-sheet-column-title/solution/gong-shui-san-xie-cong-1-kai-shi-de-26-j-g2ur/ | 简单 | [
"模拟"
] | 给定一个正整数,返回它在 Excel 表中相对应的列名称。
例如,
```
1 -> A
2 -> B
3 -> C
...
26 -> Z
27 -> AA
28 -> AB
...
```
示例 1:
```
输入: 1
输出: "A"
```
示例 2:
```
输入: 28
输出: "AB"
```
示例 3:
```
输入: 701
输出: "ZY"
``` | ### 模拟
这是一道从 $1$ 开始的的 $26$ 进制转换题。
对于一般性的进制转换题目,只需要不断地对 $columnNumber$ 进行 `%` 运算取得最后一位,然后对 $columnNumber$ 进行 `/` 运算,将已经取得的位数去掉,直到 $columnNumber$ 为 $0$ 即可。
一般性的进制转换题目无须进行额外操作,是因为我们是在「每一位数值范围在 $[0,x)$」的前提下进行「逢 $x$ 进一」。
但本题需要我们将从 $1$ 开始,因此在执行「进制转换」操作前,我们需要先对 $columnNumber$ 执行减一操作,从而实现整体偏移。
Java 代码:
```Java
class Solut... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.168` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1611-1620/1614. 括号的最大嵌套深度（简单）.md | 1614. 括号的最大嵌套深度 | https://leetcode-cn.com/problems/maximum-nesting-depth-of-the-parentheses/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-pf5d/ | 简单 | [
"模拟"
] | 如果字符串满足以下条件之一,则可以称之为 有效括号字符串(valid parentheses string,可以简写为 VPS):
* 字符串是一个空字符串 `""`,或者是一个不为 `"("` 或 `")"` 的单字符。
* 字符串可以写为 `AB`(`A` 与 `B` 字符串连接),其中 `A` 和 `B` 都是 有效括号字符串 。
* 字符串可以写为 `(A)`,其中 `A` 是一个 有效括号字符串 。
类似地,可以定义任何有效括号字符串 `S` 的 嵌套深度 `depth(S)`:
* `depth("") = 0`
* `depth(C) = 0`,其中 `C` 是单个字符的字符串,且该字符不是 `"("` 或者 `... | ### 模拟
根据题意,其实就是求最大的连续左括号的数量(跳过普通字符,且与 `)` 抵消后),只需要边遍历边统计即可。
代码:
```Java
class Solution {
public int maxDepth(String s) {
int n = s.length(), ans = 0;
for (int i = 0, cnt = 0; i < n; i++) {
if (s.charAt(i) == '(') cnt++;
else if (s.charAt(i) == ')') cnt--;
ans =... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1614` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1611-1620/1619. 删除某些元素后的数组均值（简单）.md | 1619. 删除某些元素后的数组均值 | https://leetcode.cn/problems/mean-of-array-after-removing-some-elements/solution/by-ac_oier-73w7/ | 简单 | [
"模拟",
"排序"
] | 给你一个整数数组 `arr`,请你删除最小 `5%` 的数字和最大 `5%` 的数字后,剩余数字的平均值。
与 标准答案 误差在 $10^{-5}$ 的结果都被视为正确结果。
示例 1:
```
输入:arr = [1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3]
输出:2.00000
解释:删除数组中最大和最小的元素后,所有元素都等于 2,所以平均值为 2 。
```
示例 2:
```
输入:arr = [6,2,7,5,1,2,0,3,10,2,5,0,5,5,0,8,7,6,8,0]
输出:4.00000
```
示例 3:
```
输入:arr = [6,0,7,0,7,5,7,8... | ### 模拟
根据题意进行模拟即可:先对 `arr` 进行排序,再计算出待统计的左右端点(端点以外的数值为 `5%` 最值),最后计算出相应均值。
Java 代码:
```Java
class Solution {
public double trimMean(int[] arr) {
Arrays.sort(arr);
int n = arr.length, tot = 0;
for (int i = n / 20; i < n - n / 20; i++) tot += arr[i];
return tot * 1.0 / (n * 0.9);
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1619` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1611-1620/1620. 网络信号最好的坐标（中等）.md | 1620. 网络信号最好的坐标 | https://leetcode.cn/problems/coordinate-with-maximum-network-quality/solution/by-ac_oier-xtx3/ | 中等 | [
"模拟",
"枚举"
] | 给你一个数组 `towers` 和一个整数 `radius` 。
数组 `towers` 中包含一些网络信号塔,其中 $towers[i] = [x_{i}, y_{i}, q_{i}]$ 表示第 `i` 个网络信号塔的坐标是 $(x_{i}, y_{i})$ 且信号强度参数为 $q_{i}$ 。所有坐标都是在 `X-Y` 坐标系内的 **整数** 坐标。两个坐标之间的距离用 **欧几里得距离** 计算。
整数 `radius` 表示一个塔 能到达 的 最远距离 。如果一个坐标跟塔的距离在 `radius` 以内,那么该塔的信号可以到达该坐标。在这个范围以外信号会很微弱,所以 `radius` 以外的距离该塔是 不能到达的... | ### 模拟
观察数据范围:无论是 `towers` 数组大小、坐标 $(x, y)$ 的值域大小,还是最远距离 `k = radius`,取值均不超过 $50$。
因此我们可以直接采用「模拟」的方式进行求解,而不会面临 `TLE` 或 `MLE` 的风险。
具体的,我们建立一个大小为 $110 \times 110$ 的棋盘 `g`,用于记录每个坐标点的信号值,即 $g[i][j] = x$ 代表坐标 $(i, j)$ 的信号值为 $x$。
> 其中 $110$ 的大小是利用了「任意坐标 $(x, y)$ 的取值范围不超过 $50$」,同时「最远距离 $k$ 不超过 $50$」并且「最终答案为非负坐标」而定。
随后,我们... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1620` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1621-1630/1622. 奇妙序列（困难）.md | 1622. 奇妙序列 | null | 困难 | [
"线段树"
] | 请你实现三个 API `append`,`addAll` 和 `multAll` 来实现奇妙序列。
请实现 `Fancy` 类 :
* `Fancy()` 初始化一个空序列对象。
* `void append(val)` 将整数 `val` 添加在序列末尾。
* `void addAll(inc)` 将所有序列中的现有数值都增加 `inc` 。
* `void multAll(m)` 将序列中的所有现有数值都乘以整数 `m` 。
* `int getIndex(idx)` 得到下标为 `idx` 处的数值(下标从 $0$ 开始),并将结果对 $10^9 + 7$ 取余。如果下标大于等于序列的长度,请返回 $-1$ 。
示例:
... | ### 线段树(多个懒标记)
使用多个懒标记来解决 `add` 和 `mul` 问题。
代码:
```Java
class Fancy {
class Node {
int ls, rs;
long val, add, mul = 1;
}
int N = (int) 1e8 + 10, M = 1000010, loc = 1, cnt = 0, mod = (int)1e9+7;
Node[] tr = new Node[M];
void add(int u, int lc, int rc, int l, int r, int v) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1622` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1621-1630/1624. 两个相同字符之间的最长子字符串（简单）.md | 1624. 两个相同字符之间的最长子字符串 | https://leetcode.cn/problems/largest-substring-between-two-equal-characters/solution/by-ac_oier-ki3t/ | 简单 | [
"模拟"
] | 给你一个字符串 `s`,请你返回 两个相同字符之间的最长子字符串的长度 ,计算长度时不含这两个字符。如果不存在这样的子字符串,返回 `-1` 。
子字符串 是字符串中的一个连续字符序列。
示例 1:
```
输入:s = "aa"
输出:0
解释:最优的子字符串是两个 'a' 之间的空子字符串。
```
示例 2:
```
输入:s = "abca"
输出:2
解释:最优的子字符串是 "bc" 。
```
示例 3:
```
输入:s = "cbzxy"
输出:-1
解释:s 中不存在出现出现两次的字符,所以返回 -1 。
```
示例 4:
```
输入:s = "cabbac"
输出:4
解释:最优的子字符串... | ### 模拟
根据题意继续模拟即可:使用数组 `idxs` 记录下每个字符最开始出现的下标即可。
Java 代码:
```Java
class Solution {
public int maxLengthBetweenEqualCharacters(String s) {
int[] idxs = new int[26];
Arrays.fill(idxs, 310);
int n = s.length(), ans = -1;
for (int i = 0; i < n; i++) {
int u = s.charAt(i) - ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1624` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1621-1630/1629. 按键持续时间最长的键（简单）.md | 1629. 按键持续时间最长的键 | https://leetcode-cn.com/problems/slowest-key/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-zjwb/ | 简单 | [
"模拟"
] | LeetCode 设计了一款新式键盘,正在测试其可用性。测试人员将会点击一系列键(总计 `n` 个),每次一个。
给你一个长度为 `n` 的字符串 `keysPressed` ,其中 `keysPressed[i]` 表示测试序列中第 i 个被按下的键。`releaseTimes` 是一个升序排列的列表,其中 `releaseTimes[i]` 表示松开第 `i` 个键的时间。字符串和数组的 下标都从 `0` 开始 。第 `0` 个键在时间为 `0` 时被按下,接下来每个键都 恰好 在前一个键松开时被按下。
测试人员想要找出按键 持续时间最长 的键。第 `i` 次按键的持续时间为 `releaseTimes[i] - relea... | ### 模拟
为了方便,我们用 $rt$ 来代指 $releaseTimes$,用 $kp$ 来代指 $keysPressed$。
根据题意,从先往后处理每个 $kp[i]$,计算每次的持续时间(当前结束时间与上次时间的差值)$rt[i] - rt[i - 1]$,遍历过程中维护最大持续时间和对应的字符下标。
代码:
```Java
class Solution {
public char slowestKey(int[] rt, String kp) {
int n = rt.length, idx = 0, max = rt[0];
for (int i = 1; i < n; i+... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1629` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1631-1640/1631. 最小体力消耗路径（中等）.md | 1631. 最小体力消耗路径 | https://leetcode-cn.com/problems/path-with-minimum-effort/solution/fan-zheng-fa-zheng-ming-si-lu-de-he-fa-x-ohby/ | 中等 | [
"最小生成树",
"并查集",
"Kruskal"
] | 你准备参加一场远足活动。
给你一个二维 `rows x columns` 的地图 heights ,其中 `heights[row][col]` 表示格子 `(row, col)` 的高度。
一开始你在最左上角的格子 `(0, 0`) ,且你希望去最右下角的格子 `(rows-1, columns-1)` (注意下标从 0 开始编号)。
你每次可以往 上,下,左,右 四个方向之一移动,你想要找到耗费 体力 最小的一条路径。
一条路径耗费的「体力值」是路径上相邻格子之间「高度差绝对值」的「最大值」决定的。
请你返回从左上角走到右下角的最小 体力消耗值 。
示例 1:
```
输入:heights = [[1,2,2... | ### 基本分析
对于这道题,可能会有同学想这是不是应该用 DP 呀?
特别是接触过[「路径问题」](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzU4NDE3MTEyMA==&action=getalbum&album_id=1773144264147812354&scene=173&from_msgid=2247485319&from_itemidx=1&count=3#wechat_redirect)但又还没系统学完的同学。
**事实上,当题目允许往任意方向移动时,考察的往往就不是 DP 了,而是图论。**
**从本质上说,DP 问题是一类特殊的图论问题。**
**那... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1631` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1631-1640/1636. 按照频率将数组升序排序（简单）.md | 1636. 按照频率将数组升序排序 | https://leetcode.cn/problems/sort-array-by-increasing-frequency/solution/by-ac_oier-c3xc/ | 简单 | [
"哈希表",
"排序",
"模拟"
] | 给你一个整数数组 `nums`,请你将数组按照每个值的频率 升序 排序。如果有多个值的频率相同,请你按照数值本身将它们 降序 排序。
请你返回排序后的数组。
示例 1:
```
输入:nums = [1,1,2,2,2,3]
输出:[3,1,1,2,2,2]
解释:'3' 频率为 1,'1' 频率为 2,'2' 频率为 3 。
```
示例 2:
```
输入:nums = [2,3,1,3,2]
输出:[1,3,3,2,2]
解释:'2' 和 '3' 频率都为 2 ,所以它们之间按照数值本身降序排序。
```
示例 3:
```
输入:nums = [-1,1,-6,4,5,-6,1,4,1]
输出:[5,-1,4... | ### 哈希表 + 排序 + 模拟
根据题意,先使用哈希表进行词频统计,再以二元组 $(x, cnt)$ 的形式转存到数组 `list` 中(其中 $x$ 为对应的 $nums$ 中的数值,$cnt$ 为数值 $x$ 在 `nums` 中的出现次数),再根据题目给定对 `list` 进行排序,最后再构造出答案。
Java 代码:
```Java
class Solution {
public int[] frequencySort(int[] nums) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1636` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1631-1640/1640. 能否连接形成数组（简单）.md | 1640. 能否连接形成数组 | https://leetcode.cn/problems/check-array-formation-through-concatenation/solution/by-ac_oier-3jqf/ | 简单 | [
"排序",
"二分",
"哈希表",
"模拟"
] | 给你一个整数数组 `arr` ,数组中的每个整数 互不相同 。
另有一个由整数数组构成的数组 `pieces`,其中的整数也互不相同。
请你以任意顺序连接 `pieces` 中的数组以形成 `arr` 。
但是,不允许对每个数组 `pieces[i]` 中的整数重新排序。
如果可以连接 `pieces` 中的数组形成 `arr` ,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:arr = [15,88], pieces = [[88],[15]]
输出:true
解释:依次连接 [15] 和 [88]
```
示例 2:
```
输入:arr = [49,18,16], pieces ... | ### 排序 + 二分
偷懒直接看示例做了,于是漏掉「两数组元素各不相同」且「两数组总元素个数相等」等条件,写了一个「排序 + 二分 + 贪心」的解法。
**但实际上该做法也仅能解决「两数组元素各不相同」的问题,若允许元素重复,并不存在多项式解法。**
回归到元素互不相同的条件,可以退化出「排序 + 二分」解法。
记 `arr` 数组长度为 $n$,`pieces` 数组长度为 $m$。
起始对 `pieces` 进行排序(根据 $pieces[i]$ 的首位元素排升序),从前往后处理每个 `arr[i]` 尝试匹配,先通过二分找到合适的 $pieces[j]$(即满足首位元素与 `arr[i]` 相同的 $pieces[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1640` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1641-1650/1646. 获取生成数组中的最大值（简单）.md | 1646. 获取生成数组中的最大值 | https://leetcode-cn.com/problems/get-maximum-in-generated-array/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-sj53/ | 简单 | [
"模拟",
"打表"
] | 给你一个整数 n 。按下述规则生成一个长度为 n + 1 的数组 nums :
* nums[0] = 0
* nums[1] = 1
* 当 2 <= 2 * i <= n 时,nums[2 * i] = nums[i]
* 当 2 <= 2 * i + 1 <= n 时,nums[2 * i + 1] = nums[i] + nums[i + 1]
返回生成数组 nums 中的 最大 值。
示例 1:
```
输入:n = 7
输出:3
解释:根据规则:
nums[0] = 0
nums[1] = 1
nums[(1 * 2) = 2] = nums[1] = 1
nums[(1 * 2) + 1 = ... | ### 模拟
按照题意模拟一遍,得到数列 $nums$,再从 $nums$ 中找出最大值即可。
代码:
```Java
class Solution {
public int getMaximumGenerated(int n) {
if (n == 0) return 0;
int[] nums = new int[n + 1];
nums[0] = 0;
nums[1] = 1;
for (int i = 0; i < n; i++) {
if (2 * i <= n) nums[2 * i] = nums[i];... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1651-1660/1652. 拆炸弹（简单）.md | 1652. 拆炸弹 | https://leetcode.cn/problems/defuse-the-bomb/solution/by-ac_oier-osbg/ | 简单 | [
"模拟",
"前缀和"
] | 你有一个炸弹需要拆除,时间紧迫!
你的情报员会给你一个长度为 `n` 的 循环 数组 `code` 以及一个密钥 `k` 。
为了获得正确的密码,你需要替换掉每一个数字。所有数字会 同时 被替换。
* 如果 $k > 0$,将第 `i` 个数字用 接下来 `k` 个数字之和替换。
* 如果 $k < 0$,将第 `i` 个数字用 之前 `k` 个数字之和替换。
* 如果 $k = 0$,将第 `i` 个数字用 `0` 替换。
由于 `code` 是循环的, `code[n-1]` 下一个元素是 `code[0]` ,且 `code[0]` 前一个元素是 `code[n-1]` 。
给你 循环 数组 `code` 和整数密钥... | ### 前缀和
根据题意 `code` 为循环数组,我们可以建立一个长度为 $2 \times n$ 的前缀和数组(为了方便,我们令前缀和数组下标从 $1$ 开始),利用前缀和数组来构建答案。
对于每一位 $ans[i - 1]$ 而言(其中 $i$ 的取值范围为 $[1, n]$),我们根据 `k` 值的正负情况来决定取自前缀和数组中的哪一段:
* 若有 $k < 0$:需要取位置 $i$ 前的 $-k$ 个数,为防止下越界标,先将位置 $i$ 往后进行 $n$ 个偏移(即位置 $i + n$),随后可知对应区间 $[i + n + k, i + n - 1]$,对应区间和为 $sum[i + n - 1] - sum[i ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1652` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1651-1660/1656. 设计有序流（简单）.md | 1656. 设计有序流 | https://leetcode.cn/problems/design-an-ordered-stream/solution/by-ac_oier-5pe8/ | 简单 | [
"模拟"
] | 有 `n` 个 `(id, value)` 对,其中 `id` 是 `1` 到 `n` 之间的一个整数,`value` 是一个字符串。不存在 `id` 相同的两个 `(id, value)` 对。
设计一个流,以任意顺序获取 `n` 个 `(id, value)` 对,并在多次调用时按 `id` 递增的顺序返回一些值。
实现 `OrderedStream` 类:
* `OrderedStream(int n)` 构造一个能接收 `n` 个值的流,并将当前指针 `ptr` 设为 `1` 。
* `String[] insert(int id, String value)` 向流中存储新的 `(id, value)` 对。存储后:... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class OrderedStream {
String[] ss = new String[1010];
int idx, n;
public OrderedStream(int _n) {
Arrays.fill(ss, "");
idx = 1; n = _n;
}
public List<String> insert(int key, String value) {
ss[key] = value;
List<String> ans = new A... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1656` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1651-1660/1657. 确定两个字符串是否接近（中等）.md | 1657. 确定两个字符串是否接近 | https://leetcode.cn/problems/determine-if-two-strings-are-close/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-feae/ | 中等 | [
"模拟"
] | 如果可以使用以下操作从一个字符串得到另一个字符串,则认为两个字符串 接近 :
* 操作 1:交换任意两个 现有 字符。
* 例如,`abcde -> aecdb`
* 操作 2:将一个 现有 字符的每次出现转换为另一个 现有 字符,并对另一个字符执行相同的操作。
* 例如,`aacabb -> bbcbaa`(所有 `a` 转化为 `b` ,而所有的 `b` 转换为 `a`)
你可以根据需要对任意一个字符串多次使用这两种操作。
给你两个字符串,`word1` 和 `word2`。如果 `word1` 和 `word2` 接近 ,就返回 `true`;否则,返回 `false`。
示例 1:
```
输入:word1 =... | ### 模拟
两类操作都不会凭空产生或删除字符,而仅仅是对字符进行互换。
由于操作 `1` 和 `2` 都不限次数,因此我们只需检查「字符种类是否相同」和「字符频次是否相等」,即可得出两字符串是否接近的结论。
具体的,由于 `s1` 和 `s2` 都仅包含小写字母,因此可以创建两个大小为 `26` 的数组 `c1` 和 `c2` 分别对两字符串进行词频统计。
随后进行合法性检查:
1. 字符种类是否相同:若存在某个字符仅在 `s1` 或 `s2` 中出现过,两字符串必不接近,返回 `False`
2. 字符频次是否相等:对 `c1` 和 `c2` 进行排序,并逐项检查,若存在 `c1[i] != c2[i]`,说明存在词频... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1657` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1662. 检查两个字符串数组是否相等（简单）.md | 1662. 检查两个字符串数组是否相等 | https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent/solution/by-ac_oier-h0l6/ | 简单 | [
"模拟",
"双指针"
] | 给你两个字符串数组 `word1` 和 `word2`。如果两个数组表示的字符串相同,返回 `true` ;否则,返回 `false` 。
数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。
示例 1:
```
输入:word1 = ["ab", "c"], word2 = ["a", "bc"]
输出:true
解释:
word1 表示的字符串为 "ab" + "c" -> "abc"
word2 表示的字符串为 "a" + "bc" -> "abc"
两个字符串相同,返回 true
```
示例 2:
```
输入:word1 = ["a", "cb"], word2 = ["ab", "c"]
输出:... | ### 双指针
将 `word1` 和 `word2` 的长度记为 $n$ 和 $m$。
题目本质是要我们比较两个数组扁平化后的字符串是否相同。
使用变量 `i` 和 `j` 代表当前处理到哪个 $word1[i]$ 和 $word2[j]$,使用变量 `p` 和 `q` 代表当前比较到 $word1[i]$ 和 $word2[j]$ 的哪一位。
最后根据是否能顺利比较完返回相应答案。
Java 代码:
```Java
class Solution {
public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
int ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1662` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1668. 最大重复子字符串（简单）.md | 1668. 最大重复子字符串 | https://leetcode.cn/problems/maximum-repeating-substring/solution/by-ac_oier-xjhn/ | 简单 | [
"动态规划",
"序列 DP",
"字符串哈希"
] | 给你一个字符串 `sequence`,如果字符串 `word` 连续重复 `k` 次形成的字符串是 `sequence` 的一个子字符串,那么单词 `word` 的 重复值为 `k` 。
单词 `word` 的 最大重复值 是单词 `word` 在 `sequence` 中最大的重复值。如果 `word` 不是 `sequence` 的子串,那么重复值 `k` 为 `0` 。
给你一个字符串 `sequence` 和 `word` ,请你返回 最大重复值 `k` 。
示例 1:
```
输入:sequence = "ababc", word = "ab"
输出:2
解释:"abab" 是 "ababc" 的子字符串。
``... | ### 序列 DP
为了方便,我们记 `sequence` 为 `ss`,记 `word` 为 `pp`,将两者长度分别记为 `n` 和 `m`。
同时我们调整「字符串」以及「将要用到的动规数组」的下标从 $1$ 开始。
这是一道入门级的「序列 DP」运用题,容易想到 **定义 $f[i]$ 为了考虑以 `ss[i]` 结尾时的最大重复值**。
不失一般性考虑 $f[i]$ 该如何转移:由于 `pp` 的长度已知,每次转移 $f[i]$ 时我们可以从 `ss` 中截取 **以 $ss[i]$ 为结尾,长度为 $m$ 的后缀字符串** `sub` 并与 `pp` 匹配,若两者相等,说明 `sub` 贡献了大小为 $1$ 的重复... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1668` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1669. 合并两个链表（中等）.md | 1669. 合并两个链表 | https://leetcode.cn/problems/merge-in-between-linked-lists/solutions/2538688/gong-shui-san-xie-jian-dan-lian-biao-ti-4k20i/ | 中等 | [
"链表"
] | 给你两个链表 `list1` 和 `list2`,它们包含的元素分别为 `n` 个和 `m` 个。
请你将 `list1` 中下标从 `a` 到 `b` 的全部节点都删除,并将 `list2` 接在被删除节点的位置。
下图中蓝色边和节点展示了操作后的结果:
请你返回结果链表的头指针。
示例 1:
```
输入:list1 = [0,1,2,3,4,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]
输出:[0,1,2,1000000,1000001,1000002,5]
解释:我们删除 list1 中下标为 3 和 4 的两个节点,并将 list2 接在该位置。上图中... | ### 模拟
根据题意进行模拟即可。
使用两个变量 `A` 和 `B` 分别指向 `list1` 中两个断联的位置,分别将 `A` 指向 `list2` 的开头,将 `list2` 的 `next` 指针指向 `B`。
Java 代码:
```Java
class Solution {
public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
ListNode ans = list1;
ListNode A = null, B = null;
while (--a > ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1699` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1670. 设计前中后队列（中等）.md | 1670. 设计前中后队列 | https://leetcode.cn/problems/design-front-middle-back-queue/solutions/2544779/gong-shui-san-xie-qing-xi-gao-xiao-de-qu-o0eq/ | 中等 | [
"数据结构",
"双端队列",
"队列",
"链表"
] | 请你设计一个队列,支持在前,中,后三个位置的 `push` 和 `pop` 操作。
请你完成 `FrontMiddleBack` 类:
* `FrontMiddleBack()` 初始化队列。
* `void pushFront(int val)` 将 `val` 添加到队列的 最前面 。
* `void pushMiddle(int val)` 将 `val` 添加到队列的 正中间 。
* `void pushBack(int val)` 将 `val` 添加到队里的 最后面 。
* `int popFront()` 将最前面的元素从队列中删除并返回值,如果删除之前队列为空,那么返回 `-1`。
* `int popMiddl... | ### 双端队列
只要求在头部或尾部高效插入/弹出元素的话,容易联想到双端队列。
还需要考虑往中间插入/弹出元素的话,会想到使用两个双端队列。
将两个双端队列分别称为 `l` 和 `r`,把 `l` 和 `r` 拼接起来就是完整元素列表:
由于双端队列本身支持 $O(1)$ 首尾操作,问题的关键在于如何确保涉及 `Middle` 操作的高效性。
我们可以设计一个 `update` 方法,用于确保两队列的相对平衡:
* 当元素总个数为偶数时,确保两队列元素相等
* 当元素总个数为奇数时,确保 `r` 队列比 `l` 队列元素多一个
如此一来,当我们需要往 `Middle` 插入元素时,始终往 `l` 的尾部插入即可;而当... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1670` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1671-1680/1672. 最富有客户的资产总量（简单）.md | 1672. 最富有客户的资产总量 | https://leetcode-cn.com/problems/richest-customer-wealth/solution/by-ac_oier-ai19/ | 简单 | [
"模拟"
] | 给你一个 $m * n$ 的整数网格 `accounts`,其中 $accounts[i][j]$ 是第 $i$ 位客户在第 $j$ 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
示例 1:
```
输入:accounts = [[1,2,3],[3,2,1]]
输出:6
解释:
第 1 位客户的资产总量 = 1 + 2 + 3 = 6
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
两位客户都是最富有的,资产总量都是 6 ,所以返回 6 。
```
示例 2:
```
输入:accounts = [[1,... | ### 模拟
根据题意进行模拟即可。
```Java
class Solution {
public int maximumWealth(int[][] accounts) {
int m = accounts.length, n = accounts[0].length, ans = 0;
for (int i = 0; i < m; i++) {
int cur = 0;
for (int j = 0; j < n; j++) cur += accounts[i][j];
ans = Math.max(ans, c... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1672` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1671-1680/1678. 设计 Goal 解析器（简单）.md | 1678. 设计 Goal 解析器 | https://leetcode.cn/problems/goal-parser-interpretation/solution/by-ac_oier-a00y/ | 简单 | [
"模拟"
] | 请你设计一个可以解释字符串 `command` 的 `Goal` 解析器 。
`command` 由 `"G"`、`"()"` 或 `"(al)"` 按某种顺序组成。`Goal` 解析器会将 `"G"` 解释为字符串 `"G"`、`"()"` 解释为字符串 `"o"` ,`"(al)"` 解释为字符串 `"al"` 。
然后,按原顺序将经解释得到的字符串连接成一个字符串。
给你字符串 `command`,返回 `Goal` 解析器 对 `command` 的解释结果。
示例 1:
```
输入:command = "G()(al)"
输出:"Goal"
解释:Goal 解析器解释命令的步骤如下所示:
G -> G
() ... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public String interpret(String s) {
StringBuilder sb = new StringBuilder();
int n = s.length();
for (int i = 0; i < n; ) {
if (s.charAt(i) == 'G') {
sb.append('G'); i++;
} else if (i + 1 < n && s.c... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1678` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1681-1690/1684. 统计一致字符串的数目（简单）.md | 1684. 统计一致字符串的数目 | https://leetcode.cn/problems/count-the-number-of-consistent-strings/solution/by-ac_oier-j2kj/ | 简单 | [
"模拟",
"位运算"
] | 给你一个由不同字符组成的字符串 `allowed` 和一个字符串数组 `words`。如果一个字符串的每一个字符都在 `allowed` 中,就称这个字符串是 一致字符串 。
请你返回 `words` 数组中 一致字符串 的数目。
示例 1:
```
输入:allowed = "ab", words = ["ad","bd","aaab","baa","badab"]
输出:2
解释:字符串 "aaab" 和 "baa" 都是一致字符串,因为它们只包含字符 'a' 和 'b' 。
```
示例 2:
```
输入:allowed = "abc", words = ["a","b","c","ab","ac","bc","ab... | ### 模拟
根据题意模拟即可:为了快速判断某个字符是否在 `allowed` 出现过,我们可以使用 `Set` 结构、定长数组或是一个 `int` 变量(搭配位运算)来对 `allowed` 中出现的字符进行转存。
随后遍历所有的 $words[i]$,统计符合要求的字符串个数。
Java 代码:
```Java
class Solution {
public int countConsistentStrings(String allowed, String[] words) {
boolean[] hash = new boolean[26];
for (char c : allow... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1684` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1681-1690/1688. 比赛中的配对次数（简单）.md | 1688. 比赛中的配对次数 | https://leetcode-cn.com/problems/count-of-matches-in-tournament/solution/gong-shui-san-xie-jian-dan-nao-jin-ji-zh-cx7a/ | 简单 | [
"模拟"
] | 给你一个整数 `n` ,表示比赛中的队伍数。比赛遵循一种独特的赛制:
* 如果当前队伍数是 偶数 ,那么每支队伍都会与另一支队伍配对。总共进行 `n / 2` 场比赛,且产生 `n / 2` 支队伍进入下一轮。
* 如果当前队伍数为 奇数 ,那么将会随机轮空并晋级一支队伍,其余的队伍配对。总共进行 `(n - 1) / 2` 场比赛,且产生 `(n - 1) / 2 + 1` 支队伍进入下一轮。
返回在比赛中进行的配对次数,直到决出获胜队伍为止。
示例 1:
```
输入:n = 7
输出:6
解释:比赛详情:
- 第 1 轮:队伍数 = 7 ,配对次数 = 3 ,4 支队伍晋级。
- 第 2 轮:队伍数 = 4 ,配对次... | ### 脑筋急转弯
这个题不能浪费了,吃个鱼啥的吧 🤣
* [全鱼宴 I](https://leetcode-cn.com/problems/largest-number-at-least-twice-of-others/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-8179/)
* [全鱼宴 II](https://leetcode-cn.com/problems/calculate-money-in-leetcode-bank/solution/quan-yu-yan-di-er-can-jian-dan-de-shu-xu-zux4/)
共有 $n$ 支队伍,每场... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1688` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1691. 堆叠长方体的最大高度（困难）.md | 1691. 堆叠长方体的最大高度 | https://acoier.com/2022/12/10/1691.%20%E5%A0%86%E5%8F%A0%E9%95%BF%E6%96%B9%E4%BD%93%E7%9A%84%E6%9C%80%E5%A4%A7%E9%AB%98%E5%BA%A6%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/ | 困难 | [
"排序",
"序列 DP",
"动态规划"
] | 给你 `n` 个长方体 `cuboids`,其中第 `i` 个长方体的长宽高表示为 $cuboids[i] = [width_i, length_i, height_i]$(下标从 `0` 开始)。
请你从 `cuboids` 选出一个「子集」,并将它们堆叠起来。
如果 $width_{i} <= width_{j}$ 且 $length_{i} <= length_{j}$ 且 $height_{i} <= height_{j}$ ,你就可以将长方体 `i` 堆叠在长方体 `j` 上。你可以通过旋转把长方体的长宽高重新排列,以将它放在另一个长方体上。
返回 堆叠长方体 `cuboids` 可以得到的 最大高度 。
示例 1... | ### 排序 + 序列 DP
定义 $f[i]$ 为考虑前 $i$ 个箱子,且必须使用到第 $i$ 个箱子的最大高度。
不难发现,$f[i]$ 至少为当前箱子中的最大边长,而所有 $f[i]$ 的最大值即是答案。
由于题目规定了只有三边都不超过盒子 `j` 的盒子 `i` 才能放置在上面,因此我们可以先对三边总和进行「降序」排序。
这样当我们处理到盒子 `i` 时,所有能够位于盒子 `i` 底部的盒子 `j` 均位于 `i` 左侧,我们可以通过枚举 $j \in [0, i - 1]$ 的盒子,用满足条件的盒子 `j` 来更新 $f[i]$,即有 $f[i] = \max(f[j] + height_i)$。
实现上,当我... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1691` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1694. 重新格式化电话号码（简单）.md | 1694. 重新格式化电话号码 | https://leetcode.cn/problems/reformat-phone-number/solution/by-ac_oier-82xq/ | 简单 | [
"模拟"
] | 给你一个字符串形式的电话号码 `number`。`number` 由数字、空格 `' '`、和破折号 `'-'` 组成。
请你按下述方式重新格式化电话号码。
首先,删除 所有的空格和破折号。
其次,将数组从左到右 每 `3` 个一组 分块,直到 剩下 `4` 个或更少数字。剩下的数字将按下述规定再分块:
* `2` 个数字:单个含 `2` 个数字的块。
* `3` 个数字:单个含 `3` 个数字的块。
* `4` 个数字:两个分别含 `2` 个数字的块。
最后用破折号将这些块连接起来。注意,重新格式化过程中 不应该 生成仅含 `1` 个数字的块,并且 最多 生成两个含 `2` 个数字的块。
返回格式化后的电话号码。
示例... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public String reformatNumber(String number) {
String s = number.replace(" ", "").replace("-", "");
int n = s.length();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i += 3) {
if (sb.length() != 0) sb.... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1694` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1697. 检查边长度限制的路径是否存在（困难）.md | 1697. 检查边长度限制的路径是否存在 | https://acoier.com/2022/12/14/1697.%20%E6%A3%80%E6%9F%A5%E8%BE%B9%E9%95%BF%E5%BA%A6%E9%99%90%E5%88%B6%E7%9A%84%E8%B7%AF%E5%BE%84%E6%98%AF%E5%90%A6%E5%AD%98%E5%9C%A8%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/ | 困难 | [
"并查集",
"排序",
"双指针"
] | 给你一个 `n` 个点组成的无向图边集 `edgeList`,其中 $edgeList[i] = [u_i, v_i, dis_i]$ 表示点 $u_i$ 和点 $v_i$ 之间有一条长度为 $dis_i$ 的边。请注意,两个点之间可能有 超过一条边 。
给你一个查询数组 `queries`,其中 $queries[j] = [p_j, q_j, limit_j]$ ,你的任务是对于每个查询 $queries[j]$ ,判断是否存在从 $p_j$ 到 $q_j$ 的路径,且这条路径上的每一条边都 严格小于 $limit_j$ 。
请你返回一个 布尔数组 `answer`,其中 `answer.length == queries.... | ### 排序 + 并查集 + 双指针
为了方便,我们将点数记为 `n`,边数记为 `m`,询问数量记为 `k`,将 `edgeList` 简化为 `es`,将 `queries` 简化为 `qs`。
对于点边数量都在 $10^5$,同时询问次数也在 $10^5$ 的问题,不可能对于每个询问执行最短路算法,尤其还需考虑边权限制。
**对于一个询问 $(a, b, limit)$ 而言,等价于问我们使用所有边权小于 `limit` 的边,能否使得 `a` 和 `b` 两点联通。**
关于回答连通性问题,容易想到并查集。同时我们可以通过「调整回答询问的顺序」来降低复杂度(避免重复重置并查集和添加某些边),即转换为离线问题来处理。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1697` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1700. 无法吃午餐的学生数量（简单）.md | 1700. 无法吃午餐的学生数量 | https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch/solution/by-ac_oier-rvc3/ | 简单 | [
"模拟",
"计数",
"哈希表"
] | 学校的自助午餐提供圆形和方形的三明治,分别用数字 $0$ 和 $1$ 表示。所有学生站在一个队列里,每个学生要么喜欢圆形的要么喜欢方形的。
餐厅里三明治的数量与学生的数量相同。所有三明治都放在一个 栈 里,每一轮:
* 如果队列最前面的学生 喜欢 栈顶的三明治,那么会 拿走它 并离开队列。
* 否则,这名学生会 放弃这个三明治 并回到队列的尾部。
这个过程会一直持续到队列里所有学生都不喜欢栈顶的三明治为止。
给你两个整数数组 `students` 和 `sandwiches`,其中 `sandwiches[i]` 是栈里面第 `i` 个三明治的类型(`i = 0` 是栈的顶部), `students[j]` 是初始队列里第 ... | ### 模拟
根据题意进行模拟即可 : 当学生遇到喜欢的种类会进行匹配,否则会轮到队列尾部,而面包则是一直停在栈顶位置等待匹配。
因此当且仅当栈顶的面包种类没有待匹配的学生种类与之相对应时,整个匹配过程结束。
Java 代码:
```Java
class Solution {
public int countStudents(int[] a, int[] b) {
int[] cnts = new int[2];
for (int x : a) cnts[x]++;
for (int i = 0; i < b.length; i++) {
if (... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1700` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1704. 判断字符串的两半是否相似（简单）.md | 1704. 判断字符串的两半是否相似 | https://leetcode.cn/problems/determine-if-string-halves-are-alike/solution/by-ac_oier-u26p/ | 简单 | [
"模拟"
] | 给你一个偶数长度的字符串 `s` 。将其拆分成长度相同的两半,前一半为 `a` ,后一半为 `b` 。
两个字符串 相似 的前提是它们都含有相同数目的元音`('a','e','i','o','u','A','E','I','O','U')`。注意,`s` 可能同时含有大写和小写字母。
如果 `a` 和 `b` 相似,返回 `true`;否则,返回 `false` 。
示例 1:
```
输入:s = "book"
输出:true
解释:a = "bo" 且 b = "ok" 。a 中有 1 个元音,b 也有 1 个元音。所以,a 和 b 相似。
```
示例 2:
```
输入:s = "textbook"
输出:fal... | ### 模拟
根据题意进行模拟即可。
为了快速判断某个字符是否为元音字母,起始先对所有元音字母进行转存。
随后对 `s` 进行遍历,使用单个变量 `cnt` 记录元音字母数量。若当前遍历到的 `c` 所在下标属于前半部分,对 `cnt` 进行自增操作,若属于后半部分,对 `cnt` 进行自减操作。
当处理完整个 `s` 后满足 `cnt = 0` 说明前半部分元音字母和后半部分元音字母数量相同。
Java 代码:
```Java
class Solution {
public boolean halvesAreAlike(String s) {
Set<Character> set = new Ha... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1704` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1705. 吃苹果的最大数目（中等）.md | 1705. 吃苹果的最大数目 | https://leetcode-cn.com/problems/maximum-number-of-eaten-apples/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-hfdy0/ | 中等 | [
"贪心",
"优先队列(堆)"
] | 有一棵特殊的苹果树,一连 `n` 天,每天都可以长出若干个苹果。
在第 `i` 天,树上会长出 `apples[i]` 个苹果,这些苹果将会在 `days[i]` 天后(也就是说,第 `i + days[i]` 天时)腐烂,变得无法食用。
也可能有那么几天,树上不会长出新的苹果,此时用 `apples[i] == 0` 且 `days[i] == 0` 表示。
你打算每天 最多 吃一个苹果来保证营养均衡。注意,你可以在这 n 天之后继续吃苹果。
给你两个长度为 `n` 的整数数组 `days` 和 `apples` ,返回你可以吃掉的苹果的最大数目。
示例 1:
```
输入:apples = [1,2,3,5,2], d... | ### 贪心 + 优先队列(堆)
这题是一道经典的结合优先队列(堆)的贪心题,与结合排序的贪心题一样,属于最为常见的贪心题型。
**直觉上,我们会觉得「优先吃掉最快过期的苹果」会是最优,而这个维护苹果过期的过程,可以使用「小根堆」来实现。**
苹果数量很大,但产生苹果的天数最多为 $2 * 10^4$,因此我们以二元组 `(最后食用日期, 当日产生苹果数量)` 的形式存入「小根堆」进行维护。
具体的,我们可以按照如下逻辑进行模拟(令 $n$ 为数组长度,$time$ 为当前时间,$ans$ 为吃到的苹果数量):
* 首先,如果「$time < n$」或者「堆不为空」,说明「还有苹果未被生成」或者「未必吃掉」,继续模拟;
*... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1705` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1706. 球会落何处（中等）.md | 1706. 球会落何处 | https://leetcode-cn.com/problems/where-will-the-ball-fall/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-jz6f/ | 中等 | [
"模拟"
] | 用一个大小为 `m x n` 的二维网格 $grid$ 表示一个箱子。你有 $n$ 颗球。箱子的顶部和底部都是开着的。
箱子中的每个单元格都有一个对角线挡板,跨过单元格的两个角,可以将球导向左侧或者右侧。
* 将球导向右侧的挡板跨过左上角和右下角,在网格中用 $1$ 表示。
* 将球导向左侧的挡板跨过右上角和左下角,在网格中用 $-1$ 表示。
在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。如果球恰好卡在两块挡板之间的 `"V"` 形图案,或者被一块挡导向到箱子的任意一侧边上,就会卡住。
返回一个大小为 $n$ 的数组 $answer$ ,其中 $answer[i]$ 是球放在顶部的第 $i$ 列后从底... | ### 模拟
数据范围只有 $100$,直接模拟每个球从顶部的某列出发,最终到底底部哪列即可(如果可以到达的话)。
我们使用 `r` 和 `c` 表示小球当前所处的位置,受重力影响,在不被卡住的情况下,`r` 会持续自增,直到到达底部,而 `c` 的变化,则是取决于当前挡板 `grid[r][c]` 的方向,若 `grid[r][c]` 为 $1$,则小球的下一个位置为 $(r + 1, c + 1)$;若 `grid[r][c]` 为 $-1$,则下一位置为 $(r + 1, c - 1)$,即可以统一表示为 $(r + 1, c + grid[r][c])$。当且仅当小球在本次移动过程中没被卡住,才能继续移动。即只有 $c ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1706` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1707. 与数组中元素的最大异或值（困难）.md | 1707. 与数组中元素的最大异或值 | https://leetcode-cn.com/problems/maximum-xor-with-an-element-from-array/solution/gong-shui-san-xie-jie-zhe-ge-wen-ti-lai-lypqr/ | 困难 | [
"字典树",
"二分"
] | 给你一个由非负整数组成的数组 $nums$ 。另有一个查询数组 $queries$,其中 $queries[i] = [xi, mi]$ 。
第 $i$ 个查询的答案是 $x_i$ 和任何 $nums$ 数组中不超过 $m_i$ 的元素按位异或(XOR)得到的最大值。
换句话说,答案是 `max(nums[j] \{XOR} x_i)` ,其中所有 $j$ 均满足 $nums[j] <= m_i$ 。如果 $nums$ 中的所有元素都大于 $m_i$,最终答案就是 $-1$ 。
返回一个整数数组 $answer$ 作为查询的答案,其中 $answer.length == queries.length$ 且 $answer[i]... | ### 基本分析
**在做本题之前,请先确保已经完成 [421. 数组中两个数的最大异或值](https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/)。**
这种提前给定了所有询问的题目,我们可以运用离线思想(调整询问的回答顺序)进行求解。
对于本题有两种离线方式可以进行求解。
---
### 普通 Trie
第一种方法基本思路是:**不一次性地放入所有数,而是每次将需要参与筛选的数字放入 $Trie$,再进行与 [421.... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1707` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1710. 卡车上的最大单元数（简单）.md | 1710. 卡车上的最大单元数 | https://leetcode.cn/problems/maximum-units-on-a-truck/solution/by-ac_oier-5wlo/ | 简单 | [
"贪心",
"排序",
"模拟"
] | 请你将一些箱子装在 一辆卡车 上。给你一个二维数组 `boxTypes`,其中 $boxTypes[i] = [numberOfBoxes_i, numberOfUnitsPerBox_i]$ :
* $numberOfBoxes_i$ 是类型 `i` 的箱子的数量。
* $numberOfUnitsPerBox_i$ 是类型 `i` 每个箱子可以装载的单元数量。
整数 `truckSize` 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 `truckSize`,你就可以选择任意箱子装到卡车上。
返回卡车可以装载 单元 的 最大 总数。
示例 1:
```
输入:boxTypes = [[1,3],[2,2]... | ### 贪心
为了方便,我们令 `boxTypes` 为 `bs`,令 `truckSize` 为 `k`。
由于每个箱子成本相同(均占用一个箱子位置),因此在 `k` 给定的情况下,我们应当尽可能选择装载单元数量大的箱子。
这引导我们可以将 `bs` 根据「装载单元数量」排倒序,然后从前往后 `pick` 箱子,直到没有空闲位置。
Java 代码:
```Java
class Solution {
public int maximumUnits(int[][] bs, int k) {
int n = bs.length, ans = 0;
Arrays.sort(bs, (a,b)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1710` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/171-180/171. Excel表列序号（简单）.md | 171. Excel表列序号 | https://leetcode-cn.com/problems/excel-sheet-column-number/solution/gong-shui-san-xie-tong-yong-jin-zhi-zhua-y5fm/ | 简单 | [
"模拟",
"进制转换"
] | 给你一个字符串 columnTitle ,表示 Excel 表格中的列名称。返回该列名称对应的列序号。
例如,
```
A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...
```
示例 1:
```
输入: columnTitle = "A"
输出: 1
```
示例 2:
```
输入: columnTitle = "AB"
输出: 28
```
示例 3:
```
输入: columnTitle = "ZY"
输出: 701
```
示例 4:
```
输入: columnTitle = "FXSHRXW"
输出: 2147483647
```
提示:
*... | ### 进制转换
也许你没专门做过「进制转换」类的题目,但相信你确实在 $10$ 进制中使用过如下的「进制转换」手段。
如果题目是 $10$ 进制转换,那么你会很容易想到如下转换过程:**从高位向低位处理,起始让 $ans$ 为 $0$,每次使用当前位数值更新 $ans$,更新规则为 $ans = ans * 10 + val_i$。**
举个🌰,假设存在某个十进制数字,编码为 $ABCD$(字母与数字的映射关系与本题相同),转换过程如下:
> $ans$ = 0
$ans = ans * 10 + 1$ => A
$ans = ans * 10 + 2$ => B
$ans = ans * 10 + 3$ => C
$a... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.171` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/171-180/172. 阶乘后的零（中等）.md | 172. 阶乘后的零 | https://leetcode-cn.com/problems/factorial-trailing-zeroes/solution/by-ac_oier-1y6w/ | 中等 | [
"数学"
] | 给定一个整数 $n$ ,返回 $n!$ 结果中尾随零的数量。
提示 `n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1`
示例 1:
```
输入:n = 3
输出:0
解释:3! = 6 ,不含尾随 0
```
示例 2:
```
输入:n = 5
输出:1
解释:5! = 120 ,有一个尾随 0
```
示例 3:
```
输入:n = 0
输出:0
```
提示:
* $0 <= n <= 10^4$
进阶:你可以设计并实现对数时间复杂度的算法来解决此问题吗? | ### 数学
对于任意一个 $n!$ 而言,其尾随零的个数取决于展开式中 $10$ 的个数,而 $10$ 可由质因数 $2 * 5$ 而来,因此 $n!$ 的尾随零个数为展开式中各项分解质因数后 $2$ 的数量和 $5$ 的数量中的较小值。
即问题转换为对 $[1, n]$ 中的各项进行分解质因数,能够分解出来的 $2$ 的个数和 $5$ 的个数分别为多少。
为了更具一般性,我们分析对 $[1, n]$ 中各数进行分解质因数,能够分解出质因数 $p$ 的个数为多少。根据每个数能够分解出 $p$ 的个数进行分情况讨论:
* 能够分解出至少一个 $p$ 的个数为 $p$ 的倍数,在 $[1, n]$ 范围内此类数的个数为 $c_... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.172` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/171-180/173. 二叉搜索树迭代器（中等）.md | 173. 二叉搜索树迭代器 | https://leetcode-cn.com/problems/binary-search-tree-iterator/solution/xiang-jie-ru-he-dui-die-dai-ban-de-zhong-4rxj/ | 中等 | [
"树的搜索",
"中序遍历"
] | 实现一个二叉搜索树迭代器类 `BSTIterator`,表示一个按中序遍历二叉搜索树(`BST`)的迭代器:
* `BSTIterator(TreeNode root)` 初始化 `BSTIterator` 类的一个对象。`BST` 的根节点 `root` 会作为构造函数的一部分给出。指针应初始化为一个不存在于 `BST` 中的数字,且该数字小于 `BST` 中的任何元素。
* `boolean hasNext()` 如果向指针右侧遍历存在数字,则返回 `true`;否则返回 `false`。
* `int next()` 将指针向右移动,然后返回指针处的数字。
注意,指针初始化为一个不存在于 `BST` 中的数字,所以对 `ne... | ### 基本思路
**这道题本质上考的是「将迭代版的中序遍历代码」做等价拆分。**
我们知道,中序遍历的基本逻辑是:处理左子树 -> 处理当前节点 -> 处理右子树。
其中迭代做法是利用「栈」进行处理:
1. 先将当前节点的所有左子树压入栈,压到没有为止
2. 将最后一个压入的节点弹出(栈顶元素),加入答案
3. 将当前弹出的节点作为当前节点,重复步骤一
相应的裸题在这里:[94. 二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
中序遍历的迭代代码:
```java
class Solution {
List<I... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.173` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.