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/681-690/687. 最长同值路径（中等）.md | 687. 最长同值路径 | https://leetcode.cn/problems/longest-univalue-path/solution/by-ac_oier-8ue8/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给定一个二叉树的 `root`,返回 最长的路径的长度 ,这个路径中的 每个节点具有相同值 。 这条路径可以经过也可以不经过根节点。
两个节点之间的路径长度 由它们之间的边数表示。
示例 1:
```
输入:root = [5,4,5,1,1,5]
输出:2
```
示例 2:
```
输入:root = [1,4,5,4,4,5]
输出:2
```
提示:
* 树的节点数的范围是 $[0, 10^4] $
* $-1000 <= Node.val <= 1000$
* 树的深度将不超过 `1000` | ### 递归
设计递归函数 `int dfs(TreeNode root)`,含义为传入根节点 `root`,返回以该节点为起点,往下走同值路径所能经过的最大路径长度(即不能同时往左右节点走),同时使用全局变量 `max` 记录答案路径所能经过最大路径长度。
在递归函数内部,先通过递归 `root` 的左右子节点,拿到以 `root.left` 和 `root.right` 为起点的最大路径长度 `l` 和 `r`,然后根据当前节点值和左右子节点值的相等关系来更新 `ans`,同时用 `cur` 维护「以当前节点 `root` 为目标路径中深度最小(位置最高)节点时」所经过的最大路径长度。
Java 代码:
```Java
c... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.687` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/688. 骑士在棋盘上的概率（中等）.md | 688. 骑士在棋盘上的概率 | https://leetcode-cn.com/problems/knight-probability-in-chessboard/solution/gong-shui-san-xie-jian-dan-qu-jian-dp-yu-st8l/ | 中等 | [
"线性 DP"
] | 在一个 $n \times n$ 的国际象棋棋盘上,一个骑士从单元格 $(row, column)$ 开始,并尝试进行 $k$ 次移动。行和列是 从 $0$ 开始 的,所以左上单元格是 $(0,0)$ ,右下单元格是 $(n - 1, n - 1)$ 。
象棋骑士有 $8$ 种可能的走法,如下图所示。每次移动在基本方向上是两个单元格,然后在正交方向上是一个单元格。
每次骑士要移动时,它都会随机从 $8$ 种可能的移动中选择一种(即使棋子会离开棋盘),然后移动到那里。
骑士继续移动,直到它走了 $k$ 步或离开了棋盘。
返回 骑士在棋盘停止移动后仍留在棋盘上的概率 。
示例 1:
```
输入: n = 3, k = 2, ... | ### 线性 DP
**定义 $f[i][j][p]$ 为从位置 $(i, j)$ 出发,使用步数不超过 $p$ 步,最后仍在棋盘内的概率。**
不失一般性考虑 $f[i][j][p]$ 该如何转移,根据题意,移动规则为「八连通」,对下一步的落点 $(nx, ny)$ 进行分情况讨论即可:
* 由于计算的是仍在棋盘内的概率,因此对于 $(nx, ny)$ 在棋盘外的情况,无须考虑;
* 若下一步的落点 $(nx, ny)$ 在棋盘内,其剩余可用步数为 $p - 1$,则最后仍在棋盘的概率为 $f[nx][ny][p - 1]$,则落点 $(nx, ny)$ 对 $f[i][j][p]$ 的贡献为 $f[nx][ny][p - ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.688` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/689. 三个无重叠子数组的最大和（困难）.md | 689. 三个无重叠子数组的最大和 | https://leetcode-cn.com/problems/maximum-sum-of-3-non-overlapping-subarrays/solution/gong-shui-san-xie-jie-he-qian-zhui-he-de-ancx/ | 困难 | [
"序列 DP",
"前缀和"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,找出三个长度为 `k` 、互不重叠、且 `3 * k` 项的和最大的子数组,并返回这三个子数组。
以下标的数组形式返回结果,数组中的每一项分别指示每个子数组的起始位置(下标从 $0$ 开始)。如果有多个结果,返回字典序最小的一个。
示例 1:
```
输入:nums = [1,2,1,2,6,7,5,1], k = 2
输出:[0,3,5]
解释:子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。
也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。
```
示例 2:
```
输入:nums = [1,2,1... | ### 前缀和 + 序列 DP
若不考虑输出方案,仅是求「三个无重叠子数组的最大和」的最大值。
只需要使用动态规划求解即可:**定义 $f[i][j]$ 为考虑前 $i$ 个数,凑成无重叠子数组数量为 $j$ 个时的最大值。**
最终答案为 $f[n - 1][3]$。
不失一般性的考虑 $f[i][j]$ 该如何计算(以最优方案是否包含 $nums[i]$ 进行讨论):
* 最优方案中包含 $num[i]$:由于这 $j$ 个无重叠,因此前面的 $j - 1$ 个子数组不能覆盖 $[i - k + 1, i]$。即只能在 $[0, i - k]$ 中选 $j - 1$ 个子数组。此时有:
$$
f[i][j] = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.689` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/690. 员工的重要性（简单）.md | 690. 员工的重要性 | https://leetcode-cn.com/problems/employee-importance/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-s79x/ | 简单 | [
"BFS",
"DFS",
"队列"
] | 给定一个保存员工信息的数据结构,它包含了员工 唯一的 id ,重要度 和 直系下属的 id 。
比如,员工 1 是员工 2 的领导,员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工 1 的数据结构是 [1, 15, [2]] ,员工 2的 数据结构是 [2, 10, [3]] ,员工 3 的数据结构是 [3, 5, []] 。注意虽然员工 3 也是员工 1 的一个下属,但是由于 并不是直系 下属,因此没有体现在员工 1 的数据结构中。
现在输入一个公司的所有员工信息,以及单个员工 id ,返回这个员工和他所有下属的重要度之和。
示例:
```
输入:[[1, 5, [2, 3]], [2, ... | ### 递归 / DFS
一个直观的做法是,写一个递归函数来统计某个员工的总和。
统计自身的 $importance$ 值和直系下属的 $importance$ 值。同时如果某个下属还有下属的话,则递归这个过程。
代码:
```Java
class Solution {
Map<Integer, Employee> map = new HashMap<>();
public int getImportance(List<Employee> es, int id) {
int n = es.size();
for (int i = 0; i < n; i++) map.put(es... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.690` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/691. 贴纸拼词（困难）.md | 691. 贴纸拼词 | https://leetcode.cn/problems/stickers-to-spell-word/solution/by-ac_oier-5vv3/ | 困难 | [
"记忆化搜索",
"DFS",
"状压 DP",
"爆搜",
"动态规划",
"二进制枚举",
"状态压缩"
] | 我们有 $n$ 种不同的贴纸。每个贴纸上都有一个小写的英文单词。
您想要拼写出给定的字符串 `target` ,方法是从收集的贴纸中切割单个字母并重新排列它们。如果你愿意,你可以多次使用每个贴纸,每个贴纸的数量是无限的。
返回你需要拼出 `target` 的最小贴纸数量。如果任务不可能,则返回 $-1$ 。
注意:在所有的测试用例中,所有的单词都是从 $1000$ 个最常见的美国英语单词中随机选择的,并且 `target` 被选择为两个随机单词的连接。
示例 1:
```
输入: stickers = ["with","example","science"], target = "thehat"
输出:3
解释:
我们可... | ### 动态规划(记忆化搜索)
为了方便,我们记 $ss = stickers$,$t = target$,其中 $t$ 的长度为 $n$。
我们使用一个 $state$(一个 `int` 类型变量)来代表当前 $t$ 的凑成情况:若 $t[i]$ 已被凑成,则在 $state$ 中低 $i$ 位为 $1$,否则为 $0$。
起始时有 `state = 0`,最终若能凑成 $t$,则有 `state = (1 << n) - 1`。
由于每个 $ss[i]$ 可以被使用多次,因此对于一个特定的 $state$ 而言,其转换为最终的 `(1 << n) - 1` 的最小步数固定,因此我们可以使用「记忆化搜索」来避免对相同的 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.691` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/692. 前K个高频单词（中等）.md | 692. 前K个高频单词 | https://leetcode-cn.com/problems/top-k-frequent-words/solution/gong-shui-san-xie-xiang-jie-shi-yong-ha-8dxt2/ | 中等 | [
"哈希表",
"优先队列(堆)"
] | 给一非空的单词列表,返回前 `k` 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。
如果不同的单词有相同出现频率,按字母顺序排序。
示例 1:
```
输入: ["i", "love", "leetcode", "i", "love", "coding"], k = 2
输出: ["i", "love"]
解析: "i" 和 "love" 为出现次数最多的两个单词,均为2次。
注意,按字母顺序 "i" 在 "love" 之前。
```
示例 2:
```
输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", ... | ### 哈希表 & 优先队列(堆)
这道题是在「优先队列(堆)」裸题的基础上增加了字典序大小的比较。
相应的,我们不能只根据「词频大小」构建小根堆来获取前 $k$ 个元素,还需要结合字典序大小来做。
具体的,我们可以使用「哈希表」&「优先队列」进行求解:
1. 使用「哈希表」来统计所有的词频
2. 构建大小为 $k$ 按照「词频升序 + (词频相同)字典序倒序」的优先队列:
* 如果词频不相等,根据词频进行升序构建,确保堆顶元素是堆中词频最小的元素
* 如果词频相等,根据字典序大小进行倒序构建,结合 $2.1$ 可以确保堆顶元素是堆中「词频最小 & 字典序最大」的元素
3. 对所有元素进行遍历,尝试入堆:
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.692` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/693. 交替位二进制数（简单）.md | 693. 交替位二进制数 | https://leetcode-cn.com/problems/binary-number-with-alternating-bits/solution/gong-si-shui-by-ac_oier-zuw7/ | 简单 | [
"模拟",
"位运算"
] | 给定一个正整数,检查它的二进制表示是否总是 $0$、$1$ 交替出现:换句话说,就是二进制表示中相邻两位的数字永不相同。
示例 1:
```
输入:n = 5
输出:true
解释:5 的二进制表示是:101
```
示例 2:
```
输入:n = 7
输出:false
解释:7 的二进制表示是:111.
```
示例 3:
```
输入:n = 11
输出:false
解释:11 的二进制表示是:1011.
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 遍历
根据题意,对 $n$ 的每一位进行遍历检查。
代码:
```Java
class Solution {
public boolean hasAlternatingBits(int n) {
int cur = -1;
while (n != 0) {
int u = n & 1;
if ((cur ^ u) == 0) return false;
cur = u; n >>= 1;
}
return true;
}
}
```
* 时间复杂度:$O(\log{n}... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.693` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/697. 数组的度（简单）.md | 697. 数组的度 | https://leetcode-cn.com/problems/degree-of-an-array/solution/shu-zu-ji-shu-ha-xi-biao-ji-shu-jie-fa-y-a0mg/ | 简单 | [
"哈希表"
] | 给定一个非空且只包含非负数的整数数组 nums,数组的度的定义是指数组里任一元素出现频数的最大值。
你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组,返回其长度。
示例 1:
```
输入:[1, 2, 2, 3, 1]
输出:2
解释:
输入数组的度是2,因为元素1和2的出现频数最大,均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2,所以返回2.
```
示例 2:
```
输入:[1,2,2,3,1,4,2]
输出... | ### 数组计数
由于已知值的范围是 `[0, 49999]`。
我们可以使用数组 `cnt` 来统计每个值出现的次数,数组 `first` 和 `last` 记录每个值「首次出现」和「最后出现」的下标。
同时统计出最大词频为 `max`。
然后再遍历一次数组,对于那些满足词频为 `max` 的数值进行长度计算。
```Java
class Solution {
int N = 50009;
public int findShortestSubArray(int[] nums) {
int n = nums.length;
int[] cnt = new int[N];
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.697` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/698. 划分为k个相等的子集（中等）.md | 698. 划分为k个相等的子集 | https://leetcode.cn/problems/partition-to-k-equal-sum-subsets/solution/by-ac_oier-mryw/ | 中等 | [
"搜索",
"爆搜",
"剪枝",
"模拟退火",
"启发式搜索",
"回溯算法",
"贪心"
] | 给定一个整数数组 `nums` 和一个正整数 `k`,找出是否有可能把这个数组分成 `k` 个非空子集,其总和都相等。
示例 1:
```
输入: nums = [4, 3, 2, 3, 5, 2, 1], k = 4
输出: True
说明: 有可能将其分成 4 个子集(5),(1,4),(2,3),(2,3)等于总和。
```
示例 2:
```
输入: nums = [1,2,3,4], k = 3
输出: false
```
提示:
* $1 <= k <= len(nums) <= 16$
* $0 < nums[i] < 10000$
* 每个元素的频率在 $[1,4]$ 范围内 | ### 搜索 + 剪枝(贪心策略)
将 $n$ 个数均分成 $k$ 份,且 $n$ 与 $k$ 数据范围为 $16$,容易想到搜索剪枝。
先对一些显然的无解情况进行分析:记 $tot = \sum_{i = 0}^{n - 1}nums[i]$,**若 $tot$ 不为 $k$ 的倍数,必然是无法实现均分,直接返回 `false`(可行性剪枝)**。同时可知单个集合的总和为 $t = \frac{tot}{k}$。
设计搜索函数为 `boolean dfs(int idx, int cur, int cnt, boolean[] vis)`,各项参数含义如下:
* `cur` 为当前集合的元素和(初始值为 $0$);
* `c... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.698` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/699. 掉落的方块（困难）.md | 699. 掉落的方块 | https://leetcode.cn/problems/falling-squares/solution/by-ac_oier-zpf0/ | 困难 | [
"线段树(动态开点)",
"线段树"
] | 在无限长的数轴(即 `x` 轴)上,我们根据给定的顺序放置对应的正方形方块。
第 i 个掉落的方块(`positions[i] = (left, side_length)`)是正方形,其中 `left` 表示该方块最左边的点位置(`positions[i][0]`),`side_length` 表示该方块的边长(`positions[i][1]`)。
每个方块的底部边缘平行于数轴(即 `x` 轴),并且从一个比目前所有的落地方块更高的高度掉落而下。在上一个方块结束掉落,并保持静止后,才开始掉落新方块。
方块的底边具有非常大的粘性,并将保持固定在它们所接触的任何长度表面上(无论是数轴还是其他方块)。邻接掉落的边不会过早地粘合在一... | ### 基本分析
为了方便,我们使用 `ps` 来代指 `positions`。
每次从插入操作都附带一次询问,因此询问次数为 $1e3$,左端点的最大值为 $10e8$,边长最大值为 $1e6$,由此可知值域范围大于 $1e8$,但不超过 $1e9$。
对于值域范围大,但查询次数有限的区间和问题,不久前曾经总结过 : [求解常见「值域爆炸,查询有限」区间问题的几种方式](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491187&idx=2&sn=bb2d8b7e89c535914da8107387e951a2),可作为前置 🧀 进行了解。
而我的个... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.699` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/700. 二叉搜索树中的搜索（简单）.md | 700. 二叉搜索树中的搜索 | https://leetcode-cn.com/problems/search-in-a-binary-search-tree/solution/gong-shui-san-xie-er-cha-shu-de-sou-suo-8z7hj/ | 简单 | [
"树的搜索",
"迭代",
"递归"
] | 给定二叉搜索树(BST)的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在,则返回 NULL。
例如,
```
给定二叉搜索树:
4
/ \
2 7
/ \
1 3
和值: 2
```
你应该返回如下子树:
```
2
/ \
1 3
```
在上述示例中,如果要找的值是 5,但因为没有节点值为 5,我们应该返回 NULL。 | ### 递归
根据题意,进行「递归」搜索即可。
代码:
```Java
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if (root == null || root.val == val) return root;
return root.val < val ? searchBST(root.right, val) : searchBST(root.left, val);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(n)$
-... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.700` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/703. 数据流中的第 K 大元素（简单）.md | 703. 数据流中的第 K 大元素 | https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/solution/jian-da-ti-de-duo-chong-jie-fa-mou-pao-p-d1qi/ | 简单 | [
"Top K",
"排序",
"优先队列(堆)"
] | 设计一个找到数据流中第 `k` 大元素的类(class)。注意是排序后的第 `k` 大元素,不是第 `k` 个不同的元素。
请实现 `KthLargest` 类:
* `KthLargest(int k, int[] nums)` 使用整数 `k` 和整数流 `nums` 初始化对象。
* `int add(int val)` 将 `val` 插入数据流 `nums` 后,返回当前数据流中第 `k` 大的元素。
示例:
```
输入:
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
输出... | ### 冒泡排序 (TLE)
每次调用 `add` 时先将数装入数组,然后遍历 `k` 次,通过找 `k` 次最大值来找到 Top K。
代码:
```Java
class KthLargest {
int k;
List<Integer> list = new ArrayList<>(10009);
public KthLargest(int _k, int[] _nums) {
k = _k;
for (int i : _nums) list.add(i);
}
public int add(int val) {
list.add(val... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.703` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/704. 二分查找（简单）.md | 704. 二分查找 | https://leetcode-cn.com/problems/binary-search/solution/gong-shui-san-xie-yun-yong-er-fen-zhao-f-5jyj/ | 简单 | [
"二分"
] | 给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
示例 1:
```
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
```
示例 2:
```
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
```
提示:
* 你可以假设 nums 中的所有元素是不重复的。
* n 将在 [1, 10000]之间。
* nums 的每... | ### 二分
一道二分裸题,写二分重点在于学会从「二段性」出发进行分析,想清楚二分的是哪个端点/边界。
而不是局限于用什么模板,大于还是小于,硬记这些对理解二分不会有任何帮助。
事实上,当搞清楚二分的是什么内容之后,何种形式写法都能写出。
代码:
```Java
class Solution {
public int search(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.704` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/705. 设计哈希集合（简单）.md | 705. 设计哈希集合 | https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/ | 简单 | [
"哈希表"
] | 不使用任何内建的哈希表库设计一个哈希集合(HashSet)。
实现 MyHashSet 类:
void add(key) 向哈希集合中插入值 key 。
bool contains(key) 返回哈希集合中是否存在这个值 key 。
void remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值,什么也不做。
示例:
```
输入:
["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"]
[[], [1], [2], [1], [3], [2], [2], [2], ... | ### 简单数组
由于题目给出了 `0 <= key <= 10^6` 数据范围,同时限定了 key 只能是 int。
我们可以直接使用一个 boolean 数组记录某个 key 是否存在,key 直接对应 boolean 的下标。
代码:
```Java
class MyHashSet {
boolean[] nodes = new boolean[1000009];
public void add(int key) {
nodes[key] = true;
}
public void remove(int key) {
nodes[key]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.705` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/706. 设计哈希映射（简单）.md | 706. 设计哈希映射 | https://leetcode-cn.com/problems/design-hashmap/solution/yi-ti-shuang-jie-jian-dan-shu-zu-lian-bi-yhiw/ | 简单 | [
"哈希表"
] | 不使用任何内建的哈希表库设计一个哈希映射(HashMap)。
实现 MyHashMap 类:
MyHashMap() 用空映射初始化对象
void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中,则更新其对应的值 value 。
int get(int key) 返回特定的 key 所映射的 value ;如果映射中不包含 key 的映射,返回 -1 。
void remove(key) 如果映射中存在 key 的映射,则移除 key 和它所对应的 value 。
示例:
```
输入:
["MyHashMap", "put", "... | ### 简单数组解法
与昨天的 [705. 设计哈希集合](https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/) 不同。
我们不仅仅需要记录一个元素存在与否,还需要记录该元素对应的值是什么。
由于题目限定了数据范围 $0 <= key, value <= 10^6$,和 kv 的数据类型。
我们可以使用 int 类型的数组实现哈希表功能。
```java
class MyHashMap {
int INF = Integer.MAX_VALUE;
in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.706` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/707. 设计链表（中等）.md | 707. 设计链表 | https://leetcode.cn/problems/design-linked-list/solution/by-ac_oier-vaib/ | 中等 | [
"链表"
] | 设计链表的实现。您可以选择使用单链表或双链表。
单链表中的节点应该具有两个属性:`val` 和 `next`。`val` 是当前节点的值,`next` 是指向下一个节点的指针/引用。
如果要使用双向链表,则还需要一个属性 `prev` 以指示链表中的上一个节点。假设链表中的所有节点都是 `0-index` 的。
在链表类中实现这些功能:
* `get(index)`:获取链表中第 `index` 个节点的值。如果索引无效,则返回`-1`。
* `addAtHead(val)`:在链表的第一个元素之前添加一个值为 `val` 的节点。插入后,新节点将成为链表的第一个节点。
* `addAtTail(val)`:将值为 `val... | ### 双向链表
一道手写链表裸题(啊嘿,$9$ 月活动的同学表示很棒 🤣
由于需要涉及部分 `index` 相关操作,因此我们可以实现一个「双向链表」,同时使用变量 `sz` 记录下当前链表的总长度,这样在涉及 `index` 操作时,可从较近的一边出发遍历,剩下的则是常规的链表节点操作。
> 一些细节:所有的链表题目我们都可以引入前后哨兵来简化边界处理;同时能写双链表自然能写单链表,因此如果你没有顺利写出双链表的话,在看了题解写完双链表后,再手写一遍单链表作为练习。
Java 代码:
```Java
class MyLinkedList {
class Node {
Node prev, nex... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.707` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/709. 转换成小写字母（简单）.md | 709. 转换成小写字母 | https://leetcode-cn.com/problems/to-lower-case/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-czpo/ | 简单 | [
"模拟"
] | 给你一个字符串 `s` ,将该字符串中的大写字母转换成相同的小写字母,返回新的字符串。
示例 1:
```
输入:s = "Hello"
输出:"hello"
```
示例 2:
```
输入:s = "here"
输出:"here"
```
示例 3:
```
输入:s = "LOVELY"
输出:"lovely"
```
提示:
* `1 <= s.length <= 100`
* `s` 由 `ASCII` 字符集中的可打印字符组成 | ### 模拟
根据题意进行模拟。
代码:
```Java
class Solution {
public String toLowerCase(String s) {
return s.toLowerCase();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.709` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/710. 黑名单中的随机数（困难）.md | 710. 黑名单中的随机数 | https://leetcode.cn/problems/random-pick-with-blacklist/solution/by-ac_oier-2rww/ | 困难 | [
"前缀和",
"二分",
"离散化",
"随机化",
"哈希表"
] | 给定一个整数 `n` 和一个 无重复 黑名单整数数组 `blacklist`。
设计一种算法,从 $[0, n - 1]$ 范围内的任意整数中选取一个 未加入 黑名单 `blacklist` 的整数。任何在上述范围内且不在黑名单 `blacklist` 中的整数都应该有 同等的可能性 被返回。
优化你的算法,使它最小化调用语言 内置 随机函数的次数。
实现 `Solution` 类:
* `Solution(int n, int[] blacklist)` 初始化整数 `n` 和被加入黑名单 `blacklist` 的整数
* `int pick()` 返回一个范围为 $[0, n - 1]$ 且不在黑名单 `blacklis... | ### 前缀和 + 二分
为了方便,我们记 `blacklist` 为 `bs`,将其长度记为 `m`。
问题本质是让我们从 $[0, n - 1]$ 范围内随机一个数,这数不能在 `bs` 里面。
由于 $n$ 的范围是 $1e9$,我们不能在对范围在 $[0, n - 1]$ 且不在 `bs` 中的点集进行离散化,因为离散化后的点集大小仍很大。
同时 $m$ 的范围是 $1e5$,我们也不能使用普通的拒绝采样做法,这样单次 `pick` 被拒绝的次数可能很大。
一个简单且绝对正确的做法是:**我们不对「点」做离散化,而利用 `bs` 数据范围为 $1e5$,来对「线段」做离散化**。
具体的,我们先对 `bs` 进行... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.710` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/71. 简化路径（中等）.md | 71. 简化路径 | https://leetcode-cn.com/problems/simplify-path/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-w7xi/ | 中等 | [
"模拟",
"栈"
] | 给你一个字符串 `path`,表示指向某一文件或目录的 `Unix` 风格 绝对路径 (以 `'/'` 开头),请你将其转化为更加简洁的规范路径。
在 `Unix` 风格的文件系统中,一个点(`.`)表示当前目录本身;此外,两个点 (`..`) 表示将目录切换到上一级(指向父目录);两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠(即,`'//'`)都被视为单个斜杠 `'/'` 。 对于此问题,任何其他格式的点(例如,`'...'`)均被视为文件`/`目录名称。
请注意,返回的 规范路径 必须遵循下述格式:
* 始终以斜杠 `'/'` 开头。
* 两个目录名之间必须只有一个斜杠 `'/'` 。
* 最后一个目录名(如果存... | ### 模拟
根据题意,使用栈进行模拟即可。
具体的,从前往后处理 `path`,每次以 `item` 为单位进行处理(有效的文件名),根据 `item` 为何值进行分情况讨论:
* `item` 为有效值 :存入栈中;
* `item` 为 `..` :弹出栈顶元素(若存在);
* `item` 为 `.` :不作处理。
代码:
```Java
class Solution {
public String simplifyPath(String path) {
Deque<String> d = new ArrayDeque<>();
int n = path.length();
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.71` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/73. 矩阵置零（中等）.md | 73. 矩阵置零 | https://leetcode-cn.com/problems/set-matrix-zeroes/solution/xiang-jie-fen-san-bu-de-o1-kong-jian-jie-dbxd/ | 中等 | [
"模拟"
] | 给定一个 $m \times n$ 的矩阵,如果一个元素为 $0$ ,则将其所在行和列的所有元素都设为 $0$ 。
请使用「原地」算法。
进阶:
* 一个直观的解决方案是使用 $O(m \times n)$ 的额外空间,但这并不是一个好的解决方案。
* 一个简单的改进方案是使用 $O(m + n)$ 的额外空间,但这仍然不是最好的解决方案。
* 你能想出一个仅使用常量空间的解决方案吗?
示例 1:
```
输入:matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出:[[1,0,1],[0,0,0],[1,0,1]]
```
示例 2:
```
输入:matrix = [[0,1,2,0],[3,4... | ### 前言
由于 $O(m \times n)$ 和 $O(m+n)$ 空间的解法都十分简单,无非是「同等大小的矩阵」或「与行列数量相等的标识」来记录置零信息。
这里着重讲解利用原矩阵的 $O(1)$ 空间解法。
---
### O(1) 空间
**1. 使用两个变量(r0 & c0),记录「首行 & 首列」是否该被置零**
**2.「非首行首列」的位置**
* 将置零信息存储到原矩阵
* 根据置零信息,置零「非首行首列」的位置
**3. 使用 r0 & c0 ,置零「首行 & 首列」**
代码:
```Java
class Solution {
public void setZeroes(int[][] ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.73` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/74. 搜索二维矩阵（中等）.md | 74. 搜索二维矩阵 | https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/ | 中等 | [
"二叉搜索树",
"二分"
] | 编写一个高效的算法来判断 m x n 矩阵中,是否存在一个目标值。该矩阵具有如下特性:
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
示例 1:
```
输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出:true
```
示例 2:
```
输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出:false
```
提示:
* m == matrix.length
* n == matrix[i].length
* 1 <= ... | ### 二分解法(一)
由于二维矩阵固定列的「从上到下」或者固定行的「从左到右」都是升序的。
因此我们可以使用两次二分来定位到目标位置:
1. 第一次二分:从第 0 列中的「所有行」开始找,找到合适的行 `row`
2. 第二次二分:从 `row` 中「所有列」开始找,找到合适的列 `col`
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] mat, int t) {
int m = mat.length, n = mat[0].length;
// 第一次二分:定位到所在行(从上往下,找到最后一个满... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.74` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/75. 颜色分类（中等）.md | 75. 颜色分类 | https://leetcode.cn/problems/sort-colors/solution/by-ac_oier-7lwk/ | 中等 | [
"排序",
"双指针"
] | 给定一个包含红色、白色和蓝色、共 `n` 个元素的数组 `nums`,原地对它们进行排序,使得相同颜色的元素相邻,并按照红色、白色、蓝色顺序排列。
我们使用整数 `0`、 `1` 和 `2` 分别表示红色、白色和蓝色。
必须在不使用库的 `sort` 函数的情况下解决这个问题。
示例 1:
```
输入:nums = [2,0,2,1,1,0]
输出:[0,0,1,1,2,2]
```
示例 2:
```
输入:nums = [2,0,1]
输出:[0,1,2]
```
提示:
* $n = nums.length$
* $1 <= n <= 300$
* `nums[i]` 为 `0`、`1` 或 `2`
进阶:
*... | ### 双指针
该题为经典的荷兰国旗问题,由于题目本质是要我们将数分成三段。
因此除了使用一个变量 `idx` 代指处理到哪一个 $nums[i]$ 以外,至少还需要两个变量来代指三段的边界:
* 变量 `l` 为下一个填入 `0` 的位置(因此范围 $[0, l - 1]$ 均为 `0`,初始化 $l = 0$,代表空集)
* 变量 `r` 为下一个填入 `2` 的位置(因此范围 $[r + 1, n - 1]$ 均为 `2`,初始化 $r = n - 1$,代表空集)
由于 $[0, idx - 1]$ 均为处理过的数值(即 `0` 和 `2` 必然都被分到了两端),同时 $l - 1$ 又是 `0` 的右边界,因此 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.75` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/76. 最小覆盖子串（困难）.md | 76. 最小覆盖子串 | https://leetcode.cn/problems/minimum-window-substring/solutions/2384313/gong-shui-san-xie-hua-dong-chuang-kou-ji-14q9/ | 困难 | [
"双指针",
"滑动窗口"
] | 给你一个字符串 `s`、一个字符串 `t`。返回 `s` 中涵盖 `t` 所有字符的最小子串。
如果 `s` 中不存在涵盖 `t` 所有字符的子串,则返回空字符串 `""`。
注意:
* 对于 `t` 中重复字符,我们寻找的子字符串中该字符数量必须不少于 `t` 中该字符数量。
* 如果 `s` 中存在这样的子串,我们保证它是唯一的答案。
示例 1:
```
输入:s = "ADOBECODEBANC", t = "ABC"
输出:"BANC"
解释:最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
```
示例 2:
```
输入:s = "a", t = "a"
输出:"a"
解释:... | ### 滑动窗口
定义两个长度为 $60$(足够存下所有字母种类)的数组 `c1` 和 `c2`,用于存储字符频率。其中 `c1` 用于记录字符串 `t` 中字符的频率,`c2` 用于记录当前滑动窗口内字符的频率。
设定好字母与频率数组下标的映射关系:小写字母 `a-z` 对应下标 `0-25`,大写字母 `A-Z` 对应下标 `26-51`。
使用变量 `tot` 来记录还需要匹配的字符种类数,当 `tot = 0` 代表当前滑动窗口对应的子串能够实现对 `t` 的覆盖,即任意字符满足 $c2[i] \geq c1[i]$。
使用双指针 `j` 和 `i` 表示滑动窗口的左右边界。从前往后遍历字符串 `s`,在每个位置上更... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.76` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/80. 删除有序数组中的重复项 II（中等）.md | 80. 删除有序数组中的重复项 II | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array-ii/solution/gong-shui-san-xie-guan-yu-shan-chu-you-x-glnq/ | 中等 | [
"双指针"
] | 给你一个有序数组 `nums` ,请你「原地」删除重复出现的元素,使每个元素 最多出现两次 ,返回删除后数组的新长度。
不要使用额外的数组空间,你必须「原地」修改输入数组 并在使用 $O(1)$ 额外空间的条件下完成。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
```
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出... | ### 通用解法
为了让解法更具有一般性,我们将原问题的「保留 2 位」修改为「保留 k 位」。
对于此类问题,我们应该进行如下考虑:
* 由于是保留 `k` 个相同数字,**对于前 `k` 个数字,我们可以直接保留**
* 对于后面的任意数字,能够保留的前提是:**与当前写入的位置前面的第 `k` 个元素进行比较,不相同则保留**
举个🌰,我们令 `k=2`,假设有如下样例 $[1,1,1,1,1,1,2,2,2,2,2,2,3]$
1. 首先我们先让前 2 位直接保留,得到 1,1
2. 对后面的每一位进行继续遍历,能够保留的前提是与当前位置的前面 `k` 个元素不同(答案中的第一个 1),因此我们会跳过剩余的 1,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.80` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/713. 乘积小于 K 的子数组（中等）.md | 713. 乘积小于 K 的子数组 | https://leetcode-cn.com/problems/subarray-product-less-than-k/solution/by-ac_oier-3w08/ | 中等 | [
"滑动窗口",
"双指针"
] | 给你一个整数数组 `nums` 和一个整数 $k$ ,请你返回子数组内所有元素的乘积严格小于 $k$ 的连续子数组的数目。
示例 1:
```
输入:nums = [10,5,2,6], k = 100
输出:8
解释:8 个乘积小于 100 的子数组分别为:[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
```
示例 2:
```
输入:nums = [1,2,3], k = 0
输出:0
```
提示:
* $1 <= nums.length <= 3 \times 10^4$
* $1 <= nums[i... | ### 滑动窗口
利用 $1 <= nums[i] <= 1000$,我们可以从前往后处理所有的 $nums[i]$,使用一个变量 $cur$ 记录当前窗口的乘积,使用两个变量 $j$ 和 $i$ 分别代表当前窗口的左右端点。
当 $cur >= k$ 时,我们考虑将左端点 $j$ 右移,同时消除原来左端点元素 $nums[j]$ 对 $cur$ 的贡献,直到 $cur >= k$ 不再满足,这样我们就可以得到每个右端点 $nums[i]$ 的最远左端点 $nums[j]$,从而得知以 $nums[i]$ 为结尾的合法子数组个数为 $i - j + 1$。
Java 代码:
```Java
class Solution {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.713` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/715. Range 模块（困难）.md | 715. Range 模块 | https://leetcode.cn/problems/range-module/solution/by-ac_oier-i4sw/ | 困难 | [
"线段树",
"线段树(动态开点)"
] | `Range` 模块是跟踪数字范围的模块。设计一个数据结构来跟踪表示为 半开区间 的范围并查询它们。
半开区间 $[left, right)$ 表示所有 $left <= x < right$ 的实数 `x` 。
实现 `RangeModule` 类:
* `RangeModule()` 初始化数据结构的对象。
* `void addRange(int left, int right)` 添加 半开区间 `[left, right)`,跟踪该区间中的每个实数。添加与当前跟踪的数字部分重叠的区间时,应当添加在区间 `[left, right)` 中尚未跟踪的任何数字到该区间中。
* `boolean queryRange(int... | ### 基本分析
线段树(动态开点)写过超多次了。
令 $m$ 为 `addRange`、`queryRange` 和 `removeRange` 的调用总数,$n = 1e9$ 为值域大小。
由于值域过大,我们无法直接使用空间大小固定为 $4 \times n$ 的常规线段树,而要采用「动态开点」的方式,其中动态开点的方式有两种 :「需要进行估点的数组实现」和「无须估点的动态指针」。
设计 `Node` 节点维护什么信息:
* `ls` 和 `rs` 分别指向左右区间子节点(当采用「估点数组」方式时,记录的是左右区间子节点在线段树数组中的下标;在「动态指针」方式时,记录的是左右区间子节点对象);
* `sum` 为记录当... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.715` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/717. 1比特与2比特字符（简单）.md | 717. 1比特与2比特字符 | https://leetcode-cn.com/problems/1-bit-and-2-bit-characters/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-igh7/ | 简单 | [
"模拟"
] | 有两种特殊字符:
* 第一种字符可以用一个比特 $0$ 来表示
* 第二种字符可以用两个比特($10$ 或 $11$)来表示、
给定一个以 $0$ 结尾的二进制数组 `bits` ,如果最后一个字符必须是一位字符,则返回 `true` 。
示例 1:
```
输入: bits = [1, 0, 0]
输出: true
解释: 唯一的编码方式是一个两比特字符和一个一比特字符。
所以最后一个字符是一比特字符。
```
示例 2:
```
输入: bits = [1, 1, 1, 0]
输出: false
解释: 唯一的编码方式是两比特字符和两比特字符。
所以最后一个字符不是一比特字符。
```
提示:
* $1 <= bit... | ### 模拟
根据题意进行模拟即可,使用 $n$ 代指 `bits` 的长度,$idx$ 为当前「比特字」的开头,从前往后扫描每个「比特字」,如果最后一个「比特字」的开头为 $n - 1$ 返回 `True`,否则返回 `False`。
代码:
```Java
class Solution {
public boolean isOneBitCharacter(int[] bits) {
int n = bits.length, idx = 0;
while (idx < n - 1) {
if (bits[idx] == 0) idx++;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.717` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/719. 找出第 K 小的数对距离（困难）.md | 719. 找出第 K 小的数对距离 | https://leetcode.cn/problems/find-k-th-smallest-pair-distance/solution/by-ac_oier-o4if/ | 困难 | [
"双指针",
"二分"
] | 数对 $(a,b)$ 由整数 `a` 和 `b` 组成,其数对距离定义为 `a` 和 `b` 的绝对差值。
给你一个整数数组 `nums` 和一个整数 $k$ ,数对由 $nums[i]$ 和 $nums[j]$ 组成且满足 $0 <= i < j < nums.length$ 。
返回 所有数对距离中 第 $k$ 小的数对距离。
示例 1:
```
输入:nums = [1,3,1], k = 1
输出:0
解释:数对和对应的距离如下:
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
距离第 1 小的数对是 (1,1) ,距离为 0 。
```
示例 2:
```
输入:nums = [1,1,1], ... | ### 二分 + 双指针
根据题意,由于对距离定义使用的是绝对值,因此从原数组中找数对 $(i, j)$,等价于在排序数组中找数对 $(i, j)$。
同时由于 $k$ 的范围为 $n^2$,因此我们不能使用复杂度为 $O(k\log{n})$ 的「多路归并」做法来做。
利用数据范围 $0 <= nums[i] <= 10^6$,我们知道距离值域范围为 $[0, 10^6]$,假设所能形成的距离序列为 $A = a_1, a_2, ... ,a_m$,此时在以第 $k$ 小的距离值为分割点的数轴上,具有「二段性」,记这第 $k$ 小的距离值为 $a_k$:
* 处于 $a_k$ 右侧的所有位置 $a_i$(包含 $a_k$)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.719` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/720. 词典中最长的单词（简单）.md | 720. 词典中最长的单词 | https://leetcode-cn.com/problems/longest-word-in-dictionary/solution/by-ac_oier-bmot/ | 简单 | [
"模拟",
"哈希表",
"字典树"
] | 给出一个字符串数组 `words` 组成的一本英语词典。返回 `words` 中最长的一个单词,该单词是由 `words` 词典中其他单词逐步添加一个字母组成。
若其中有多个可行的答案,则返回答案中字典序最小的单词。若无答案,则返回空字符串。
示例 1:
```
输入:words = ["w","wo","wor","worl", "world"]
输出:"world"
解释: 单词"world"可由"w", "wo", "wor", 和 "worl"逐步添加一个字母组成。
```
示例 2:
```
输入:words = ["a", "banana", "app", "appl", "ap", "apply", "appl... | ### 模拟
数据范围很小,我们可以直接模拟来做。
先将所有的 $words[i]$ 存入 `Set` 集合,方便后续可以近似 $O(1)$ 查询某个子串是否存在 $words$ 中。
遍历 $words$ 数组(题目没有说 $words$ 不重复,因此最好遍历刚刚预处理的 `Set` 集合),判断每个 $words[i]$ 是否为「合法单词」,同时利用当前的最长单词来做剪枝。
不算剪枝效果,该做法计算量不超过 $10^6$,可以过。
代码:
```Java
class Solution {
public String longestWord(String[] words) {
String an... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.720` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/724. 寻找数组的中心下标（简单）.md | 724. 寻找数组的中心下标 | https://leetcode-cn.com/problems/find-pivot-index/solution/shi-yong-shao-bing-ji-qiao-liang-bian-qi-vkju/ | 简单 | [
"前缀和"
] | 给你一个整数数组 nums,请编写一个能够返回数组 “中心下标” 的方法。
数组 中心下标 是数组的一个下标,其左侧所有元素相加的和等于右侧所有元素相加的和。
如果数组不存在中心下标,返回 -1 。
如果数组有多个中心下标,应该返回最靠近左边的那一个。
注意:中心下标可能出现在数组的两端。
示例 1:
```
输入:nums = [1, 7, 3, 6, 5, 6]
输出:3
解释:
中心下标是 3 。
左侧数之和 (1 + 7 + 3 = 11),
右侧数之和 (5 + 6 = 11) ,二者相等。
```
示例 2:
```
输入:nums = [1, 2, 3]
输出:-1
解释:
数组中不存在满足此条件的中... | ### 基本分析
这是一道前缀和的裸题。
只需要用两个数组,前后处理两遍前缀和,再对两个前缀和数组的相同下标进行判别即可。
为了简化数组越界的判断,我们通常会给前缀和数组多预留一位作为哨兵。
这里由于要求前后前缀和。所以我们直接多开两位。
代码:
```Java
class Solution {
public int pivotIndex(int[] nums) {
int n = nums.length;
int[] s1 = new int[n + 2], s2 = new int[n + 2];
for (int i = 1; i <= n; i++) s1[i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.724` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/725. 分隔链表（中等）.md | 725. 分隔链表 | https://leetcode-cn.com/problems/split-linked-list-in-parts/solution/gong-shui-san-xie-jing-dian-lian-biao-ju-9yj4/ | 中等 | [
"模拟",
"链表"
] | 给你一个头结点为 `head` 的单链表和一个整数 `k` ,请你设计一个算法将链表分隔为 `k` 个连续的部分。
每部分的长度应该尽可能的相等:任意两部分的长度差距不能超过 $1$ 。这可能会导致有些部分为 null 。
这 `k` 个部分应该按照在链表中出现的顺序排列,并且排在前面的部分的长度应该大于或等于排在后面的长度。
返回一个由上述 k 部分组成的数组。
示例 1:
```
输入:head = [1,2,3], k = 5
输出:[[1],[2],[3],[],[]]
解释:
第一个元素 output[0] 为 output[0].val = 1 ,output[0].next = null 。
最后一个元素... | ### 模拟
根据题意,我们应当近可能将链表平均分为 $k$ 份。
我们可以采取与 [(题解) 68. 文本左右对齐](https://leetcode-cn.com/problems/text-justification/solution/gong-shui-san-xie-zi-fu-chuan-mo-ni-by-a-s3v7/) 类似的思路(在 $68$ 中,填充空格的操作与本题一致:尽可能平均,无法均分时,应当使前面比后面多)。
回到本题,我们可以先对链表进行一次扫描,得到总长度 $cnt$,再结合需要将将链表划分为 $k$ 份,可知每一份的 **最小** 分配单位 $per = \left \lfloor \frac... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.725` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/726. 原子的数量（困难）.md | 726. 原子的数量 | https://leetcode-cn.com/problems/number-of-atoms/solution/gong-shui-san-xie-shi-yong-xiao-ji-qiao-l5ak4/ | 困难 | [
"模拟",
"数据结构运用",
"栈",
"哈希表",
"优先队列(堆)"
] | 给定一个化学式 `formula`(作为字符串),返回每种原子的数量。
原子总是以一个大写字母开始,接着跟随0个或任意个小写字母,表示原子的名字。
如果数量大于 1,原子后会跟着数字表示原子的数量。如果数量等于 1 则不会跟数字。例如,`H2O` 和 `H2O2` 是可行的,但 `H1O2` 这个表达是不可行的。
两个化学式连在一起是新的化学式。例如 `H2O2He3Mg4` 也是化学式。
一个括号中的化学式和数字(可选择性添加)也是化学式。例如 `(H2O2)` 和 `(H2O2)3` 是化学式。
给定一个化学式,输出所有原子的数量。格式为:第一个(按字典序)原子的名子,跟着它的数量(如果数量大于 1),然后是第二个原子... | ### 数据结构 + 模拟
一道综合模拟题。
相比于[(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 的表达式计算问题,本题设计模拟流程的难度要低很多,之所谓定位困难估计是使用到的数据结构较多一些。
为了方便,我们约定以下命名:
* 称一段完整的连续字母为「原子」
* 称一段完整的连续数字为「数值」
* 称 `(` 和`)` 为「符号」
基本实现思路如下:
1. 在处理入参 `s` 的过程中,始终维护着一个哈希表 `... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.726` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/728. 自除数（简单）.md | 728. 自除数 | https://leetcode-cn.com/problems/self-dividing-numbers/solution/by-ac_oier-pvb1/ | 简单 | [
"模拟",
"打表",
"哈希表",
"二分"
] | 自除数是指可以被它包含的每一位数整除的数。
* 例如,$128$ 是一个 自除数 ,因为 `128 % 1 == 0`,`128 % 2 == 0`,`128 % 8 == 0`。
自除数不允许包含 $0$ 。
给定两个整数 `left` 和 `right` ,返回一个列表,列表的元素是范围 $[left, right]$ 内所有的 自除数 。
示例 1:
```
输入:left = 1, right = 22
输出:[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
```
示例 2:
```
输入:left = 47, right = 85
输出:[48,55,66,77]
```... | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public List<Integer> selfDividingNumbers(int left, int right) {
List<Integer> ans = new ArrayList<>();
out:for (int i = left; i <= right; i++) {
int cur = i;
while (cur != 0) {
int t = cur % 10;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.726` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/729. 我的日程安排表 I（中等）.md | 729. 我的日程安排表 I | https://leetcode.cn/problems/my-calendar-i/solution/by-ac_oier-hnjl/ | 中等 | [
"模拟",
"红黑树",
"线段树(动态开点)",
"线段树",
"分块",
"位运算",
"哈希表"
] | 实现一个 `MyCalendar` 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ,则可以存储这个新的日程安排。
当两个日程安排有一些时间上的交叉时(例如两个日程安排都在同一时间内),就会产生 重复预订 。
日程可以用一对整数 `start` 和 `end` 表示,这里的时间是半开区间,即 $[start, end)$, 实数 $x$ 的范围为, $start <= x < end$ 。
实现 MyCalendar 类:
* `MyCalendar()` 初始化日历对象。
* `boolean book(int start, int end)` 如果可以将日程安排成功添加到日历中而不会导致重复预订,返回 `... | ### 模拟
利用 `book` 操作最多调用 $1000$ 次,我们可以使用一个数组存储所有已被预定的日期 $[start, end - 1]$,对于每次 `book` 操作,检查当前传入的 $[start, end)$ 是否会与已有的日期冲突,冲突返回 `False`,否则将 $[start, end- 1]$ 插入数组并返回 `True`。
代码:
```Java
class MyCalendar {
List<int[]> list = new ArrayList<>();
public boolean book(int start, int end) {
end--;
f... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.729` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/730. 统计不同回文子序列（困难）.md | 730. 统计不同回文子序列 | https://leetcode.cn/problems/count-different-palindromic-subsequences/solution/by-ac_oier-lbva/ | 困难 | [
"区间 DP",
"动态规划"
] | 给定一个字符串 `s`,返回 `s` 中不同的非空「回文子序列」个数 。
通过从 `s` 中删除 $0$ 个或多个字符来获得子序列。
如果一个字符序列与它反转后的字符序列一致,那么它是「回文字符序列」。
如果有某个 $i$ , 满足 $a_i$ != $b_i$ ,则两个序列 `a1, a2, ...` 和 `b1, b2, ...` 不同。
注意:
* 结果可能很大,你需要对 $10^9 + 7$ 取模 。
示例 1:
```
输入:s = 'bccb'
输出:6
解释:6 个不同的非空回文子字符序列分别为:'b', 'c', 'bb', 'cc', 'bcb', 'bccb'。
注意:'bcb' 虽然出现两次但仅计... | ### 区间 DP
往长度较少的回文串两端添加字符,可能组成新的长度大的回文串,容易想到「区间 DP」,同时 `s` 仅由 $4$ 类小写字母组成,也是一个切入点。
根据区间 DP 的一般思路,定义 $f[i][j]$ 为考虑字符串 `s` 中的 $[i,j]$ 范围内回文子序列的个数,最终答案为 $f[0][n - 1]$。
**不失一般性考虑 $f[i][j]$ 该如何转移,通过枚举 `abcd` 作为回文方案「边缘字符」来进行统计,即分别统计各类字符作为「边缘字符」时对 $f[i][j]$ 的贡献,此类统计方式天生不存在重复性问题。**
假设当前枚举到的字符为 $k$ :
* 若 $s[i...j]$ 中没有字符 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.730` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/731. 我的日程安排表 II（中等）.md | 731. 我的日程安排表 II | https://leetcode.cn/problems/my-calendar-ii/solution/by-ac_oier-a1b3/ | 中等 | [
"线段树(动态开点)",
"线段树"
] | 实现一个 `MyCalendar` 类来存放你的日程安排。如果要添加的时间内不会导致三重预订时,则可以存储这个新的日程安排。
`MyCalendar` 有一个 `book(int start, int end)` 方法。它意味着在 `start` 到 `end` 时间内增加一个日程安排,注意,这里的时间是半开区间,即 $[start, end)$, 实数 $x$ 的范围为,$ start <= x < end$。
当三个日程安排有一些时间上的交叉时(例如三个日程安排都在同一时间内),就会产生三重预订。
每次调用 `MyCalendar.book` 方法时,如果可以将日程安排成功添加到日历中而不会导致三重预订,返回 `true`... | ### 线段树(动态开点)- 估点
和 [729. 我的日程安排表 I](https://leetcode-cn.com/problems/my-calendar-i/solution/by-ac_oier-1znx/) 几乎完全一致,只需要将对「线段树」所维护的节点信息进行调整即可。
线段树维护的节点信息包括:
* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;
* `add`: 懒标记;
* `max`: 为当前区间的最大值。
对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 \times n$ 的空间,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.731` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/732. 我的日程安排表 III（困难）.md | 732. 我的日程安排表 III | https://leetcode-cn.com/problems/my-calendar-iii/solution/by-ac_oier-cv31/ | 困难 | [
"线段树(动态开点)",
"分块",
"线段树"
] | 当 $k$ 个日程安排有一些时间上的交叉时(例如 $k$ 个日程安排都在同一时间内),就会产生 $k$ 次预订。
给你一些日程安排 $[start, end)$ ,请你在每个日程安排添加后,返回一个整数 $k$ ,表示所有先前日程安排会产生的最大 $k$ 次预订。
实现一个 `MyCalendarThree` 类来存放你的日程安排,你可以一直添加新的日程安排。
* `MyCalendarThree()` 初始化对象。
* `int book(int start, int end)` 返回一个整数 $k$ ,表示日历中存在的 $k$ 次预订的最大值。
示例:
```
输入:
["MyCalendarThree", "book"... | ### 线段树(动态开点)
和 [731. 我的日程安排表 II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491636&idx=1&sn=48bfdd56cdcc33ededd6f154ffd41f0a) 几乎完全一致,只需要将对「线段树」所维护的节点信息进行调整即可。
线段树维护的节点信息包括:
* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;
* `add`: 懒标记;
* `max`: 为当前区间的最大值。
对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.732` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/735. 行星碰撞（中等）.md | 735. 行星碰撞 | https://leetcode.cn/problems/asteroid-collision/solution/by-ac_oier-p4qh/ | 中等 | [
"栈",
"模拟"
] | 给定一个整数数组 `asteroids`,表示在同一行的行星。
对于数组中的每一个元素,其绝对值表示行星的大小,正负表示行星的移动方向(正表示向右移动,负表示向左移动)。
每一颗行星以相同的速度移动,找出碰撞后剩下的所有行星。
碰撞规则:
1. 两个行星相互碰撞,较小的行星会爆炸。
2. 如果两颗行星大小相同,则两颗行星都会爆炸。
3. 两颗移动方向相同的行星,永远不会发生碰撞。
示例 1:
```
输入:asteroids = [5,10,-5]
输出:[5,10]
解释:10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。
```
示例 2:
```
输入:asteroids = [8,-8]
... | ### 模拟 + 栈
由于碰撞抵消总是从相邻行星之间发生,我们可以使用「栈」来模拟该过程。
从前往后处理所有的 $ats[i]$,使用栈存储当前未被抵消的行星,当栈顶元素方向往右,当前 $ats[i]$ 方向往左时,会发生抵消操作,抵消过程根据规则进行即可。
Java 代码:
```Java
class Solution {
public int[] asteroidCollision(int[] asteroids) {
Deque<Integer> d = new ArrayDeque<>();
for (int t : asteroids) {
boolea... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.735` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/736. Lisp 语法解析（困难）.md | 736. Lisp 语法解析 | https://leetcode.cn/problems/parse-lisp-expression/solution/by-ac_oier-i7w1/ | 困难 | [
"DFS",
"模拟",
"哈希表"
] | 给你一个类似 `Lisp` 语句的字符串表达式 `expression`,求出其计算结果。
表达式语法如下所示:
* 表达式可以为整数,`let` 表达式,`add` 表达式,`mult` 表达式,或赋值的变量。表达式的结果总是一个整数。
* 整数可以是正整数、负整数、$0$
* `let` 表达式采用 `"(let v1 e1 v2 e2 ... vn en expr)"` 的形式,其中 `let` 总是以字符串 `"let"`来表示,接下来会跟随一对或多对交替的变量和表达式,也就是说,第一个变量 `v1`被分配为表达式 `e1` 的值,第二个变量 `v2` 被分配为表达式 `e2` 的值,依次类推;最终 `let` 表达式的... | ### DFS 模拟
今天身体不舒服,不写太详细,题目不难,大家结合代码看吧。
设计函数 `int dfs(int l, int r, Map<String, Integer> map)`,代表计算 $s[l...r]$ 的结果,答案为 `dfs(0,n-1,map)`,其中 $n$ 为字符串的长度。
根据传入的 $[l, r]$ 是否为表达式分情况讨论:
* 若 $s[l] = ($,说明是表达式,此时从 $l$ 开始往后取,取到空格为止(假设位置为 `idx`),从而得到操作 `op`(其中 `op` 为 `let`、`add` 或 `mult` 三者之一),此时 `op` 对应参数为 $[idx + 1, r - 1]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/739. 每日温度（中等）.md | 739. 每日温度 | https://leetcode.cn/problems/daily-temperatures/solution/by-ac_oier-aj5k/ | 中等 | [
"单调栈"
] | 给定一个整数数组 `temperatures`,表示每天的温度,返回一个数组 `answer`,其中 `answer[i]` 是指对于第 `i` 天,下一个更高温度出现在几天后。如果气温在这之后都不会升高,请在该位置用 `0` 来代替。
示例 1:
```
输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]
```
示例 2:
```
输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]
```
示例 3:
```
输入: temperatures = [30,60,90]
输出: [1,1,0]
```... | ### 单调栈
抽象题意为 : 求解给定序列中每个位置(右边)最近一个比其大的位置,可使用「单调栈」来进行求解。
具体的,我们可以从前往后处理所有的 $temperatures[i]$,使用某类容器装载我们所有的「待更新」的位置(下标),假设当前处理到的是 $temperatures[i]$:
* 若其比容器内的任意位置(下标)对应温度要低,其必然不能更新任何位置(下标),将其也加入容器尾部(此时我们发现,若有一个新的位置(下标)加入容器,其必然是当前所有待更新位置(下标)中的温度最低的,即容器内的温度单调递减);
* 若其价格高于容器内的任一位置(下标)对应温度,其能够更新容器位置(下标)的答案,并且由于我们容器满足单调递... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.739` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/740. 删除并获得点数（中等）.md | 740. 删除并获得点数 | https://leetcode-cn.com/problems/delete-and-earn/solution/gong-shui-san-xie-zhuan-huan-wei-xu-lie-6c9t0/ | 中等 | [
"序列 DP"
] | 给你一个整数数组 nums ,你可以对它进行一些操作。
每次操作中,选择任意一个 nums[i] ,删除它并获得 nums[i] 的点数。之后,你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
示例 1:
```
输入:nums = [3,4,2]
输出:6
解释:
删除 4 获得 4 个点数,因此 3 也被删除。
之后,删除 2 获得 2 个点数。总共获得 6 个点数。
```
示例 2:
```
输入:nums = [2,2,3,3,3,4]
输出:9
解释:
删除 3 获得 3 个点数,接着要删除两个 2 和 4 。... | ### 动态规划
根据题意,当我们选择 $nums[i]$ 的时候,比 $nums[i]$ 大/小 一个单位的数都不能被选择。
如果我们将数组排好序,从前往后处理,其实只需要考虑“当前数”与“前一个数”的「大小 & 选择」关系即可,这样处理完,显然每个数的「前一位/后一位」都会被考虑到。
这样我们将问题转化为一个「序列 DP」问题(选择某个数,需要考虑前一个数的「大小/选择」状态)。
**定义 $f[i][0]$ 代表数值为 $i$ 的数字「不选择」的最大价值;$f[i][1]$ 代表数值为 $i$ 的数字「选择」的最大价值。**
为了方便,我们可以先对 $nums$ 中出现的所有数值进行计数,而且由于数据范围只有 $10... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.740` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/741. 摘樱桃（困难）.md | 741. 摘樱桃 | https://leetcode.cn/problems/cherry-pickup/solution/by-ac_oier-pz7i/ | 困难 | [
"线性 DP"
] | 一个$N \times N$ 的网格( `grid`) 代表了一块樱桃地,每个格子由以下三种数字的一种来表示:
* $0$ 表示这个格子是空的,所以你可以穿过它。
* $1$ 表示这个格子里装着一个樱桃,你可以摘到樱桃然后穿过它。
* $-1$ 表示这个格子里有荆棘,挡着你的路。
你的任务是在遵守下列规则的情况下,尽可能的摘到最多樱桃:
* 从位置 $(0, 0)$ 出发,最后到达 $(N-1, N-1)$ ,只能向下或向右走,并且只能穿越有效的格子(即只可以穿过值为 $0$ 或者 $1$ 的格子);
* 当到达 $(N-1, N-1)$ 后,你要继续走,直到返回到 $(0, 0)$ ,只能向上或向左走,并且只能穿越有效的格子... | ### 线性 DP
为了方便,我们令 `grid` 为 `g`,同时调整矩阵横纵坐标从 $1$ 开始。
原问题为先从左上角按照「只能往下 + 只能往右」的规则走到右下角,然后再按照「只能往上 + 只能往左」的规则走回左上角,途径的值为 $1$ 的格子得一分(只能得分一次,得分后置零),同时不能经过值为 $-1$ 的格子。
其中第二趟的规则等价于按照第一趟的规则从左上角到右下角再走一遍,再结合每个位置的只能得分一次,可以将原问题等价于:两个点从左上角开始同时走,最终都走到右下角的最大得分。
定义 $f[k][i1][i2]$ 为当前走了 $k$ 步(横纵坐标之和),且第一个点当前在第 $i1$ 行,第二点在第 $i2$ 行时的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.741` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/743. 网络延迟时间（中等）.md | 743. 网络延迟时间 | https://leetcode-cn.com/problems/network-delay-time/solution/gong-shui-san-xie-yi-ti-wu-jie-wu-chong-oghpz/ | 中等 | [
"最短路",
"图",
"优先队列(堆)"
] | 有 $n$ 个网络节点,标记为 $1$ 到 $n$。
给你一个列表 times,表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi),其中 ui 是源节点,vi 是目标节点, wi 是一个信号从源节点传递到目标节点的时间。
现在,从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号?如果不能使所有节点收到信号,返回 -1 。
示例 1:
```
输入:times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出:2
```
示例 2:
```
输入:times = [[1,2,1]], n = 2, k = 1
输出:1
```
示例 3:
... | ### 基本分析
**为了方便,我们约定 $n$ 为点数,$m$ 为边数。**
根据题意,首先 $n$ 的数据范围只有 $100$,$m$ 的数据范围为 $6000$,使用「邻接表」或「邻接矩阵」来存图都可以。
同时求的是「**从 $k$ 点出发,所有点都被访问到的最短时间**」,将问题转换一下其实就是求「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。
---
### 存图方式
在开始讲解最短路之前,我们先来学习三种「存图」方式。
#### 邻接矩阵
这是一种使用二维矩阵来进行存图的方式。
适用于边数较多的**稠密图**使用,当边数量接近点的数量的平方,即 $m \approx n^2$ 时,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.743` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/744. 寻找比目标字母大的最小字母（简单）.md | 744. 寻找比目标字母大的最小字母 | https://leetcode-cn.com/problems/find-smallest-letter-greater-than-target/solution/by-ac_oier-to07/ | 简单 | [
"二分"
] | 给你一个排序后的字符列表 `letters`,列表中只包含小写英文字母。另给出一个目标字母 `target`,请你寻找在这一有序列表里比目标字母大的最小字母。
在比较时,字母是依序循环出现的。举个例子:
如果目标字母 `target = 'z'` 并且字符列表为 `letters = ['a', 'b']`,则答案返回 `'a'`
示例 1:
```
输入: letters = ["c", "f", "j"],target = "a"
输出: "c"
```
示例 2:
```
输入: letters = ["c","f","j"], target = "c"
输出: "f"
```
示例 3:
```
输入: lette... | ### 二分
给定的数组「有序」,找到比 $target$ 大的最小字母,容易想到二分。
唯一需要注意的是,二分结束后需要再次 `check`,如果不满足,则取数组首位元素。
代码:
```Java
class Solution {
public char nextGreatestLetter(char[] letters, char target) {
int n = letters.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.744` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/745. 前缀和后缀搜索（困难）.md | 745. 前缀和后缀搜索 | https://leetcode.cn/problems/prefix-and-suffix-search/solution/by-ac_oier-ayej/ | 困难 | [
"字典树"
] | 设计一个包含一些单词的特殊词典,并能够通过前缀和后缀来检索单词。
实现 `WordFilter` 类:
* `WordFilter(string[] words)` 使用词典中的单词 `words` 初始化对象。
* `f(string pref, string suff)` 返回词典中具有前缀 `prefix` 和后缀 `suff` 的单词的下标。如果存在不止一个满足要求的下标,返回其中 最大的下标 。如果不存在这样的单词,返回 $-1$ 。
示例:
```
输入
["WordFilter", "f"]
[[["apple"]], ["a", "e"]]
输出
[null, 0]
解释
WordFilter wordFi... | ### 基本分析
为了方便,我们令 `words` 为 `ss`,令 `pref` 和 `suff` 分别为 `a` 和 `b`。
搜索某个前缀(后缀可看做是反方向的前缀)容易想到字典树,但单词长度数据范围只有 $7$,十分具有迷惑性,使用暴力做法最坏情况下会扫描所有的 $ss[i]$,不考虑任何的剪枝操作的话,计算量也才为 $2 \times \ 7 \times 1e4 = 1.4 \times 10^5$,按道理是完全可以过的。
但不要忘记 LC 是一个具有「设定每个样例时长,同时又有总时长」这样奇怪机制的 OJ。
---
### 暴力(TLE or 双百)
于是有了 `Java` 总时间超时,`TypeScrip... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.745` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/747. 至少是其他数字两倍的最大数（简单）.md | 747. 至少是其他数字两倍的最大数 | 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/ | 简单 | [
"模拟"
] | 给你一个整数数组 $nums$ ,其中总是存在 **唯一的** 一个最大整数 。
请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。
如果是,则返回 **最大元素的下标** ,否则返回 $-1$ 。
示例 1:
```
输入:nums = [3,6,1,0]
输出:1
解释:6 是最大的整数,对于数组中的其他整数,6 大于数组中其他元素的两倍。6 的下标是 1 ,所以返回 1 。
```
示例 2:
```
输入:nums = [1,2,3,4]
输出:-1
解释:4 没有超过 3 的两倍大,所以返回 -1 。
```
示例 3:
```
输入:nums = [1]
输出:0
解释:因为不存在其... | ### 模拟
根据题意进行模拟即可,遍历过程中维护最大值和次大值的下标,最后判断最大值是否至少为次大值两倍。
然后?今天属于圆梦了?(这真的只是他们的日常可爱 🤣
**代码(感谢 [@5cm/s 🌸](/u/megurine/)、[@Benhao](/u/himymben/) 和 [@Qian](/u/qian2/) 几位总提供的其他语言版本 🤣 🤣 ):**
```Java
class Solution {
public int dominantIndex(int[] nums) {
int n = nums.length;
if (n == 1) return 0;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.747` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/748. 最短补全词（简单）.md | 748. 最短补全词 | https://leetcode-cn.com/problems/shortest-completing-word/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-j-x4ao/ | 简单 | [
"模拟"
] | 给你一个字符串 $licensePlate$ 和一个字符串数组 $words$ ,请你找出并返回 $words$ 中的 最短补全词 。
补全词 是一个包含 $licensePlate$ 中所有的字母的单词。在所有补全词中,最短的那个就是 最短补全词 。
在匹配 $licensePlate$ 中的字母时:
* 忽略 $licensePlate$ 中的 数字和空格 。
* 不区分大小写。
* 如果某个字母在 $licensePlate$ 中出现不止一次,那么该字母在补全词中的出现次数应当一致或者更多。
例如:`licensePlate = "aBc 12c"`,那么它的补全词应当包含字母 `'a'`、`'b'` (忽略大写)和两个... | ### 模拟
根据题意,先对 $licensePlate$ 进行词频统计(忽略空格和数字),然后遍历 $words$ 进行词频统计,从所有符合要求的 $words[i]$ 找到最短的补全词。
代码:
```Java
class Solution {
public String shortestCompletingWord(String licensePlate, String[] words) {
int[] cnt = getCnt(licensePlate);
String ans = null;
for (String s : words) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.748` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/749. 隔离病毒（困难）.md | 749. 隔离病毒 | https://leetcode.cn/problems/contain-virus/solution/by-ac_oier-l9ya/ | 困难 | [
"模拟",
"图论搜索",
"BFS"
] | 病毒扩散得很快,现在你的任务是尽可能地通过安装防火墙来隔离病毒。
假设世界由 $m \times n$ 的二维矩阵 `isInfected` 组成,`isInfected[i][j] == 0` 表示该区域未感染病毒,而 `isInfected[i][j] == 1` 表示该区域已感染病毒。可以在任意 $2$ 个相邻单元之间的共享边界上安装一个防火墙(并且只有一个防火墙)。
每天晚上,病毒会从被感染区域向相邻未感染区域扩散,除非被防火墙隔离。现由于资源有限,每天你只能安装一系列防火墙来隔离其中一个被病毒感染的区域(一个区域或连续的一片区域),且该感染区域对未感染区域的威胁最大且 保证唯一 。
你需要努力使得最后有部分区域不被... | ### 搜索模拟
根据题意,我们可以按天进行模拟,设计函数 `getCnt` 用于返回当天会被安装的防火墙数量,在 `getCnt` 内部我们会进行如下操作:
* 找出当天「对未感染区域的威胁最大」的区域,并将该区域进行隔离(将 $1$ 设置为 $-1$);
* 对其他区域,进行步长为 $1$ 的感染操作。
考虑如何实现 `getCnt`:我们需要以「连通块」为单位进行处理,因此每次的 `getCnt` 操作,我们先重建一个与矩阵等大的判重数组 `vis`,对于每个 $g[i][j] = 1$ 且未被 $vis[i][j]$ 标记为 `True` 的位置进行搜索,搜索过程使用 `BFS` 实现。
**在 `BFS` 过程中,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.749` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/751-760/752. 打开转盘锁（中等）.md | 752. 打开转盘锁 | https://leetcode-cn.com/problems/open-the-lock/solution/gong-shui-san-xie-yi-ti-shuang-jie-shuan-wyr9/ | 中等 | [
"双向 BFS",
"启发式搜索",
"AStar 算法",
"IDAStar 算法"
] | 你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转:例如把 '9' 变为 '0','0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。
锁的初始数字为 '0000' ,一个代表四个拨轮的数字的字符串。
列表 deadends 包含了一组死亡数字,一旦拨轮的数字和列表里的任何一个元素相同,这个锁将会被永久锁定,无法再被旋转。
字符串 target 代表可以解锁的数字,你需要给出解锁需要的最小旋转次数,如果无论如何不能解锁,返回 -1 。
示例 1:
```
输入:deadends = ["... | ### 基本分析
首先,我建议你先做 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd),然后再回过头将本题作为「练习题」。
[127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.752` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/751-760/754. 到达终点数字（中等）.md | 754. 到达终点数字 | https://leetcode.cn/problems/reach-a-number/solution/by-ac_oier-o4ze/ | 中等 | [
"数学"
] | 在一根无限长的数轴上,你站在 `0` 的位置。终点在 `target` 的位置。
你可以做一些数量的移动 numMoves :
* 每次你可以选择向左或向右移动。
* 第 `i` 次移动(从 `i == 1` 开始,到 `i == numMoves`),在选择的方向上走 `i` 步。
给定整数 `target`,返回 到达目标所需的 最小 移动次数(即最小 `numMoves` ) 。
示例 1:
```
输入: target = 2
输出: 3
解释:
第一次移动,从 0 到 1 。
第二次移动,从 1 到 -1 。
第三次移动,从 -1 到 2 。
```
示例 2:
```
输入: target = 3
输出:... | ### 数学
#### 提示一:数轴上的任意点都以起点($0$ 点)对称,只需要考虑对称点的任意一边
由于题目没有限制我们「不能到达哪些点」以及「出发的起始方向」,因此以起点为中心的左右两边对称。
即:左边所能到达任意一个点,都能通过调整所达路径的方向来将终点调整到右边。
同时由于起点是一个特殊的位置 $0$ 点,因此相应的「正数点」和「负数点」对称,我们仅需考虑一边(例如正数域)即可。
#### 提示二:先往靠近 `target` 的方向移动,到达或越过 `target` 的时候则停止
只考虑 `target` 为正的情况,我们假定起始先往靠近 `target` 的方向移动(即所有步数均为正值),根据是「到达」还是「越... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.754` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/751-760/757. 设置交集大小至少为2（困难）.md | 757. 设置交集大小至少为2 | https://leetcode.cn/problems/set-intersection-size-at-least-two/solution/by-ac_oier-3xn6/ | 困难 | [
"贪心"
] | 一个整数区间 $[a, b]$ ($a < b$) 代表着从 `a` 到 `b` 的所有连续整数,包括 `a` 和 `b`。
给你一组整数区间 `intervals`,请找到一个最小的集合 `S`,使得 `S` 里的元素与区间 `intervals` 中的每一个整数区间都至少有 $2$ 个元素相交。
输出这个最小集合 `S` 的大小。
示例 1:
```
输入: intervals = [[1, 3], [1, 4], [2, 5], [3, 5]]
输出: 3
解释:
考虑集合 S = {2, 3, 4}. S与intervals中的四个区间都有至少2个相交的元素。
且这是S最小的情况,故我们输出3。
```
示例 2... | ### 贪心
不要被样例数据误导了,题目要我们求最小点集的数量,并不规定点集 `S` 是连续段。
为了方便,我们令 `intervals` 为 `ins`。
当只有一个线段时,我们可以在线段内取任意两点作为 `S` 成员,而当只有两个线段时,我们可以两个线段重合情况进行决策:
1. 当两个线段完全不重合时,为满足题意,我们需要从两个线段中各取两个点,此时这四个点都可以任意取;
2. 当两个线段仅有一个点重合,为满足 `S` 最小化的题意,我们可以先取重合点,然后再两个线段中各取一个;
3. 当两个线段有两个及以上的点重合,此时在重合点中任选两个即可。
不难发现,当出现重合的所有情况中,必然可以归纳某个线段的边缘点上。即不存... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.752` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/761. 特殊的二进制序列（困难）.md | 761. 特殊的二进制序列 | https://leetcode.cn/problems/special-binary-string/solution/by-ac_oier-cz6h/ | 困难 | [
"构造"
] | 特殊的二进制序列是具有以下两个性质的二进制序列:
* `0` 的数量与 `1` 的数量相等。
* 二进制序列的每一个前缀码中 `1` 的数量要大于等于 `0` 的数量。
给定一个特殊的二进制序列 `S`,以字符串形式表示。定义一个操作为首先选择 `S` 的两个连续且非空的特殊的子串,然后将它们交换。(两个子串为连续的当且仅当第一个子串的最后一个字符恰好为第二个子串的第一个字符的前一个字符。)
在任意次数的操作之后,交换后的字符串按照字典序排列的最大的结果是什么?
示例 1:
```
输入: S = "11011000"
输出: "11100100"
解释:
将子串 "10" (在S[1]出现) 和 "1100" (在S[... | ### 构造
我们可以定义每个字符的得分:字符 `1` 得分为 $1$ 分,字符 `0` 得分为 $-1$ 分。
根据题目对「特殊字符串」的定义可知,给定字符串 `s` 的总得分为 $0$,且任意前缀串不会出现得分为负数的情况。
考虑将 `s` 进行划分为多个足够小特殊字符串 `item`(足够小的含义为每个 `item` 无法再进行划分),每个 `item` 的总得分为 $0$。根据 `s` 定义,必然可恰好划分为多个 `item`。
每次操作可以将相邻特殊字符串进行交换,于是问题转换为将 `s` 进行重排,求其重排后字典序最大的方案。
首先可以证明一个合法 `item` 必然满足 `1...0` 的形式,可通过「反证法... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.761` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/762. 二进制表示中质数个计算置位（简单）.md | 762. 二进制表示中质数个计算置位 | https://leetcode-cn.com/problems/prime-number-of-set-bits-in-binary-representation/solution/by-ac_oier-w50x/ | 简单 | [
"模拟",
"位运算"
] | 给你两个整数 `left` 和 `right`,在闭区间 $[left, right]$ 范围内,统计并返回计算置位位数为质数的整数个数。
计算置位位数就是二进制表示中 $1$ 的个数。
例如, $21$ 的二进制表示 `10101` 有 $3$ 个计算置位。
示例 1:
```
输入:left = 6, right = 10
输出:4
解释:
6 -> 110 (2 个计算置位,2 是质数)
7 -> 111 (3 个计算置位,3 是质数)
9 -> 1001 (2 个计算置位,2 是质数)
10-> 1010 (2 个计算置位,2 是质数)
共计 4 个计算置位为质数的数字。
```
示例 2:
```
输入:left... | ### 模拟 + lowbit
利用一个 `int` 的二进制表示不超过 $32$,我们可以先将 $32$ 以内的质数进行打表。
从前往后处理 $[left, right]$ 中的每个数 $x$,利用 `lowbit` 操作统计 $x$ 共有多少位 $1$,记为 $cnt$,若 $cnt$ 为质数,则对答案进行加一操作。
代码:
```Java
class Solution {
static boolean[] hash = new boolean[40];
static {
int[] nums = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 3... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.762` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/764. 最大加号标志（中等）.md | 764. 最大加号标志 | https://leetcode.cn/problems/largest-plus-sign/solution/by-ac_oier-q932/ | 中等 | [
"模拟",
"预处理"
] | 在一个 $n \times n$ 的矩阵 `grid` 中,除了在数组 `mines` 中给出的元素为 `0`,其他每个元素都为 `1`。$mines[i] = [x_i, y_i]$ 表示 $grid[x_i][y_i] = 0$。
返回 `grid` 中包含 `1` 的最大的轴对齐加号标志的阶数 。
如果未找到加号标志,则返回 `0` 。
一个 `k` 阶由 `1` 组成的 “轴对称”加号标志 具有中心网格 $grid[r][c] = 1$ ,以及 `4` 个从中心向上、向下、向左、向右延伸,长度为 `k-1`,由 `1` 组成的臂。
注意,只有加号标志的所有网格要求为 `1` ,别的网格可能为 `0` 也可能为 `1... | ### 预处理 + 模拟
假设点 $(x, y)$ 能够取得最大长度 $k$,我们知道 $k$ 取决于以点 $(x, y)$ 为起点,四联通方向中「最短的连续 $1$ 的长度」。
基于此,我们可以建立四个大小为 $n \times n$ 的矩阵(二维数组)`a`、`b`、`c` 和 `d` 分别代表四个方向连续 $1$ 的前缀数:
数据范围为 $500$,预处理前缀数组复杂度为 $O(n^2)$,统计答案复杂度为 $O(n^2)$,时间复杂度没有问题。
再考虑空间,建立四个方向的前缀数组所需空间为 $500 \times 500 \times 4 = 10^6$,即使加上原矩阵 `g` 也不会有 `MLE` 风险,空间复杂度... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.764` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/765. 情侣牵手（困难）.md | 765. 情侣牵手 | https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/ | 困难 | [
"并查集",
"贪心"
] | N 对情侣坐在连续排列的 2N 个座位上,想要牵到对方的手。 计算最少交换座位的次数,以便每对情侣可以并肩坐在一起。 一次交换可选择任意两人,让他们站起来交换座位。
人和座位用 0 到 2N-1 的整数表示,情侣们按顺序编号,第一对是 (0, 1),第二对是 (2, 3),以此类推,最后一对是 (2N-2, 2N-1)。
这些情侣的初始座位 row[i] 是由最初始坐在第 i 个座位上的人决定的。
示例 1:
```
输入: row = [0, 2, 1, 3]
输出: 1
解释: 我们只需要交换row[1]和row[2]的位置即可。
```
示例 2:
```
输入: row = [3, 2, 0, 1]
输出: 0
解释... | ### 并查集
首先,我们总是以「情侣对」为单位进行设想:
1. 当有两对情侣相互坐错了位置,ta们两对之间形成了一个环。需要进行一次交换,使得每队情侣独立(相互牵手)
2. 如果三对情侣相互坐错了位置,ta们三对之间形成了一个环,需要进行两次交换,使得每队情侣独立(相互牵手)
3. 如果四对情侣相互坐错了位置,ta们四对之间形成了一个环,需要进行三次交换,使得每队情侣独立(相互牵手)
也就是说,如果我们有 `k` 对情侣形成了错误环,需要交换 `k - 1` 次才能让情侣牵手。
**于是问题转化成 `n / 2` 对情侣中,有多少个这样的环。**
可以直接使用「并查集」来做。
由于 0和1配对、2和3配对 ... ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.765` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/766. 托普利茨矩阵（简单）.md | 766. 托普利茨矩阵 | https://leetcode-cn.com/problems/toeplitz-matrix/solution/cong-ci-pan-du-qu-cheng-ben-fen-xi-liang-f20w/ | 简单 | [
"模拟"
] | 给你一个 m x n 的矩阵 matrix 。如果这个矩阵是托普利茨矩阵,返回 true ;否则,返回 false 。
如果矩阵上每一条由左上到右下的对角线上的元素都相同,那么这个矩阵是 托普利茨矩阵 。
示例 1:
```
输入:matrix = [[1,2,3,4],[5,1,2,3],[9,5,1,2]]
输出:true
解释:
在上述矩阵中, 其对角线为:
"[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]"。
各条对角线上的所有元素均相同, 因此答案是 True 。
```
示例 2:
```
输入:matrix = [[1,2],[2,2]]
输... | ### 按「格子」遍历
对于一个合格的「托普利茨矩阵」而言,每个格子总是与其左上角格子相等(如果有的话)。
我们以「格子」为单位进行遍历,每次与左上角的格子进行检查即可。
这样我们每对一个格子进行判断,都要读 `matrix` 上的两个格子的值(即**非边缘格子其实会被读取两次**)。
```Java
class Solution {
public boolean isToeplitzMatrix(int[][] matrix) {
int m = matrix.length, n = matrix[0].length;
for (int i = 1; i < m; i++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.761` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/768. 最多能完成排序的块 II（困难）.md | 768. 最多能完成排序的块 II | https://leetcode.cn/problems/max-chunks-to-make-sorted-ii/solution/by-ac_oier-z4wt/ | 困难 | [
"贪心"
] | 这个问题和“最多能完成排序的块”相似,但给定数组中的元素可以重复,输入数组最大长度为$2000$,其中的元素最大为 $10^8$。
`arr` 是一个可能包含重复元素的整数数组,我们将这个数组分割成几个“块”,并将这些块分别进行排序。之后再连接起来,使得连接的结果和按升序排序后的原数组相同。
我们最多能将数组分成多少块?
示例 1:
```
输入: arr = [5,4,3,2,1]
输出: 1
解释:
将数组分成2块或者更多块,都无法得到所需的结果。
例如,分成 [5, 4], [3, 2, 1] 的结果是 [4, 5, 1, 2, 3],这不是有序的数组。
```
示例 2:
```
输入: arr = [2,1,3... | ### 贪心 + 构造
一种容易想到的构造方法,是与目标序列(已排升序的数组 `clone`)做区间比较。
由于题目要求尽可能划分出多的区间,我们可以从前往后处理 `arr` 和 `clone` 时统计区间内数的情况,若有 `arr[i...j]` 和 `clone[i...j]` 词频完全相同,可知 `arr[i...j]` 可通过内部排序调整为 `clone[i...j]`,此时我们将范围 $[i...j]$ 划分为一个区间,然后继续往后处理直到整个数组处理完。
容易证明该做法的正确性:可从边界开始进行归纳分析,起始两者均从下标为 $0$ 的位置进行扫描。假设最优解和贪心解的第一个区间的结束位置相同,问题就会归结到子问题上... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.768` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/769. 最多能完成排序的块（中等）.md | 769. 最多能完成排序的块 | https://leetcode.cn/problems/max-chunks-to-make-sorted/solution/by-ac_oier-4uny/ | 中等 | [
"模拟"
] | 给定一个长度为 `n` 的整数数组 `arr` ,它表示在 $[0, n - 1]$ 范围内的整数的排列。
我们将 `arr` 分割成若干块 (即分区),并对每个块单独排序。
将它们连接起来后,使得连接的结果和按升序排序后的原数组相同。
返回数组能分成的最多块数量。
示例 1:
```
输入: arr = [4,3,2,1,0]
输出: 1
解释:
将数组分成2块或者更多块,都无法得到所需的结果。
例如,分成 [4, 3], [2, 1, 0] 的结果是 [3, 4, 0, 1, 2],这不是有序的数组。
```
示例 2:
```
输入: arr = [1,0,2,3,4]
输出: 4
解释:
我们可以把它分成两块... | ### 模拟
本题考察的是简单模拟能力,或者说是简单的对「循环不变量」的设计。
我们从前往后处理所有的 $arr[i]$(即 `i` 定义为当前划分块的右边界下标),处理过程中定义变量 `j` 为当前划分块的左边界下标(初始值为 $0$),定义 `min` 为当前划分块中元素最小值(初始值为 $arr[0]$ 或 $n$),定义 `max` 为当前划分块中元素最大值(初始值为 $arr[0]$ 或 $-1$)。
当且仅当 $j = min$ 且 $i = max$ 时,下标范围 $[j, i]$ 排序结果为 $[min, max]$,此时块的个数加一,并重新初始化几个变量,继续循环统计下个块的信息。
Java 代码:
```... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.769` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/773. 滑动谜题（困难）.md | 773. 滑动谜题 | https://leetcode-cn.com/problems/sliding-puzzle/solution/gong-shui-san-xie-fa-hui-a-suan-fa-zui-d-3go8/ | 困难 | [
"BFS",
"最小步数",
"AStar 算法",
"启发式搜索"
] | 在一个 `2 x 3` 的板上(`board`)有 $5$ 块砖瓦,用数字 `1~5` 来表示, 以及一块空缺用 $0$ 来表示.
一次移动定义为选择 $0$ 与一个相邻的数字(上下左右)进行交换.
最终当板 `board` 的结果是 $[[1,2,3],[4,5,0]]$ 谜板被解开。
给出一个谜板的初始状态,返回最少可以通过多少次移动解开谜板,如果不能解开谜板,则返回 $-1$ 。
示例 1:
```
输入:board = [[1,2,3],[4,0,5]]
输出:1
解释:交换 0 和 5 ,1 步完成
```
示例 2:
```
输入:board = [[1,2,3],[5,4,0]]
输出:-1
解释:没有... | ### 基本分析
这是八数码问题的简化版:将 $3 * 3$ 变为 $2 * 3$,同时将「输出路径」变为「求最小步数」。
通常此类问题可以使用「BFS」、「AStar 算法」、「康拓展开」进行求解。
由于问题简化到了 $2 * 3$,我们使用前两种解法即可。
---
### BFS
为了方便,将原来的二维矩阵转成字符串(一维矩阵)进行处理。
这样带来的好处直接可以作为哈希 `Key` 使用,也可以很方便进行「二维坐标」与「一维下标」的转换。
由于固定是 $2 * 3$ 的格子,因此任意的合法二维坐标 $(x, y)$ 和对应一维下标 $idx$ 可通过以下转换:
* $idx = x * 3 + y$
* $x ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.773` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/775. 全局倒置与局部倒置（中等）.md | 775. 全局倒置与局部倒置 | https://leetcode.cn/problems/global-and-local-inversions/solution/by-ac_oier-jc7a/ | 中等 | [
"树状数组",
"数学"
] | 给你一个长度为 `n` 的整数数组 `nums`,表示由范围 $[0, n - 1]$ 内所有整数组成的一个排列。
全局倒置 的数目等于满足下述条件不同下标对 $(i, j)$ 的数目:
* $0 <= i < j < n$
* $nums[i] > nums[j]$
局部倒置 的数目等于满足下述条件的下标 i 的数目:
* $0 <= i < n - 1$
* $nums[i] > nums[i + 1]$
当数组 `nums` 中 全局倒置 的数量等于 局部倒置 的数量时,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:nums = [1,0,2]
输出:true
解释:有 1 个... | ### 树状数组
根据题意,对于每个 $nums[i]$ 而言:
* 其左边比它大的 $nums[j]$ 的个数,是以 $nums[i]$ 为右端点的“全局倒置”数量,统计所有以 $nums[i]$ 为右端点的“全局倒置”数量即是总的“全局倒置”数量 `a`
* 同时我们可以将每个 $nums[i]$ 与前一个值进行比较,从而统计总的“局部倒置”数量 `b`,其中 $i$ 的取值范围为 $[1, n - 1)$
一个容易想到的做法是利用「树状数组」,虽然该做法没有利用到核心条件「$nums$ 是一个 $[0, n - 1]$ 的排列」,但根据数据范围 $n$ 可知该复杂度为 $O(n\log{n})$ 的做法可过,且依赖的条... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.775` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/777. 在LR字符串中交换相邻字符（中等）.md | 777. 在LR字符串中交换相邻字符 | https://leetcode.cn/problems/swap-adjacent-in-lr-string/solutions/1863778/by-ac_oier-ye71/ | 中等 | [
"双指针"
] | 在一个由 `'L'` ,`'R'` 和 `'X'` 三个字符组成的字符串(例如 `"RXXLRXRXL"`)中进行移动操作。
一次移动操作指用一个 `"LX"` 替换一个 `"XL"`,或者用一个 `"XR"` 替换一个 `"RX"`。
现给定起始字符串 `start` 和结束字符串 `end`,请编写代码,当且仅当存在一系列移动操作使得 `start` 可以转换成 `end` 时, 返回 `True`。
示例 :
```
输入: start = "RXXLRXRXL", end = "XRLXXRRLX"
输出: True
解释:
我们可以通过以下几步将start转换成end:
RXXLRXRXL ->
XRXLRXRX... | ### 双指针
根据题意,我们每次移动要么是将 `XL` 变为 `LX`,要么是将 `RX` 变为 `XR`,而该两者操作可分别看做将 `L` 越过多个 `X` 向左移动,将 `R` 越过多个 `X` 向右移动。
因此在 `start` 和 `end` 中序号相同的 `L` 和 `R` 必然满足坐标性质:
1. 序号相同的 `L` : `start` 的下标不小于 `end` 的下标(即 `L` 不能往右移动)
2. 序号相同的 `R` : `start` 的下标不大于 `end` 的下标(即 `R` 不能往左移动)
其中「序号」是指在 `LR` 字符串中出现的相对顺序。
Java 代码:
```Java
class So... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.777` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/778. 水位上升的泳池中游泳（困难）.md | 778. 水位上升的泳池中游泳 | https://leetcode-cn.com/problems/swim-in-rising-water/solution/gong-shui-san-xie-yi-ti-shuang-jie-krusk-7c6o/ | 困难 | [
"最小生成树",
"并查集",
"Kruskal",
"二分",
"BFS"
] | 在一个 `N x N` 的坐标方格 `grid` 中,每一个方格的值 $grid[i][j]$ 表示在位置 $(i,j)$ 的平台高度。
现在开始下雨了。当时间为 $t$ 时,此时雨水导致水池中任意位置的水位为 $t$ 。
你可以从一个平台游向四周相邻的任意一个平台,但是前提是此时水位必须同时淹没这两个平台。
假定你可以瞬间移动无限距离,也就是默认在方格内部游动是不耗时的。
当然,在你游泳的时候你必须待在坐标方格里面。
你从坐标方格的左上平台 $(0, 0)$ 出发,最少耗时多久你才能到达坐标方格的右下平台 $(N-1,N-1)$?
示例 1:
```
输入: [[0,2],[1,3]]
输出: 3
解释:
时间为0... | ### Kruskal
由于在任意点可以往任意方向移动,所以相邻的点(四个方向)之间存在一条无向边。
边的权重 $w$ 是指两点节点中的最大高度。
按照题意,我们需要找的是从左上角点到右下角点的最优路径,其中最优路径是指**途径的边的最大权重值最小**,然后输入最优路径中的最大权重值。
我们可以先遍历所有的点,将所有的边加入集合,存储的格式为数组 $[a, b, w]$ ,代表编号为 $a$ 的点和编号为 $b$ 的点之间的权重为 $w$(按照题意,$w$ 为两者的最大高度)。
对集合进行排序,按照 $w$ 进行从小到达排序。
当我们有了所有排好序的候选边集合之后,我们可以对边从前往后处理,每次加入一条边之后,使用并查集... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.778` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/779. 第K个语法符号（中等）.md | 779. 第K个语法符号 | https://leetcode.cn/problems/k-th-symbol-in-grammar/solution/by-ac_oier-fp2f/ | 中等 | [
"DFS",
"递归"
] | 我们构建了一个包含 `n` 行( 索引从 `1` 开始 )的表。首先在第一行我们写上一个 `0`。接下来的每一行,将前一行中的 `0` 替换为 `01`,`1` 替换为 `10`。
* 例如,对于 `n = 3`,第 `1` 行是 `0` ,第 `2` 行是 `01`,第 `3` 行是 `0110` 。
给定行数 `n` 和序数 `k`,返回第 `n` 行中第 `k` 个字符。( `k` 从索引 `1` 开始)
示例 1:
```
输入: n = 1, k = 1
输出: 0
解释: 第一行:0
```
示例 2:
```
输入: n = 2, k = 1
输出: 0
解释:
第一行: 0
第二行: 01
```... | ### 递归(倒推验证)
整理一下条件:首行为 `0`,每次用当前行拓展出下一行时,字符数量翻倍(将 `0` 拓展为 `01`,将 `1` 拓展为 `10`),且字符种类仍为 `01`。
要求我们输出第 $n$ 行第 $k$ 列的字符,我们可以通过「倒推验证」的方式来求解:假设第 $n$ 行第 $k$ 为 `1`,若能倒推出首行为 $0$,说明假设成立,返回 `1`,否则返回 `0`。
倒推验证可通过实现递归函数 `int dfs(int r, int c, int cur)` 来做,含义为当第 $r$ 行第 $c$ 列的字符为 $cur$ 时,首行首列字符为何值。同时实现该函数是容易的:
* 若「当前列 $c$ 为偶数且 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.779` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/780. 到达终点（困难）.md | 780. 到达终点 | https://leetcode-cn.com/problems/reaching-points/solution/by-ac_oier-hw11/ | 困难 | [
"数学"
] | 给定四个整数 `sx`,`sy`,`tx` 和 `ty`,如果通过一系列的转换可以从起点 $(sx, sy)$ 到达终点 $(tx, ty)$,则返回 `true`,否则返回 `false`。
从点 $(x, y)$ 可以转换到 $(x, x+y)$ 或者 $(x+y, y)$。
示例 1:
```
输入: sx = 1, sy = 1, tx = 3, ty = 5
输出: true
解释:
可以通过以下一系列转换从起点转换到终点:
(1, 1) -> (1, 2)
(1, 2) -> (3, 2)
(3, 2) -> (3, 5)
```
示例 2:
```
输入: sx = 1, sy = 1, tx = 2, ty... | ### 数学
给定的 $(sx, sy)$ 的数据范围为 $[1, 10^9]$(即均为正整数),且每次转换,只能将另外一维的数值累加到当前维,因此对于每一维的数值而言,随着转换次数的进行,呈(非严格)递增趋势,再结合起始值为正整数,可知在转换过程中均不会出现负数。
**由此得知从 $(tx, ty)$ 到 $(sx, sy)$ 的转换过程唯一确定:总是取较大数减去较小数来进行反推(否则会出现负数)。**
但即使反向转换唯一确定,数据范围为 $10^9$,线性模拟仍会超时。
我们考虑将「相同操作的连续段转换动作」进行合并,在某次反向转换中,如果有 $tx < ty$,我们会将 $(tx, ty)$ 转换为 $(tx, ty ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.780` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/781. 森林中的兔子（中等）.md | 781. 森林中的兔子 | https://leetcode-cn.com/problems/rabbits-in-forest/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-v17p5/ | 中等 | [
"贪心"
] | 森林中,每个兔子都有颜色。其中一些兔子(可能是全部)告诉你还有多少其他的兔子和自己有相同的颜色。我们将这些回答放在 `answers` 数组里。
返回森林中兔子的最少数量。
示例:
```
输入: answers = [1, 1, 2]
输出: 5
解释:
两只回答了 "1" 的兔子可能有相同的颜色,设为红色。
之后回答了 "2" 的兔子不会是红色,否则他们的回答会相互矛盾。
设回答了 "2" 的兔子为蓝色。
此外,森林中还应有另外 2 只蓝色兔子的回答没有包含在数组中。
因此森林中兔子的最少数量是 5: 3 只回答的和 2 只没有回答的。
输入: answers = [10, 10, 10]
输出: 11
输入: an... | ### 基本分析
首先,兔子它不会说谎 (`・ω・ ́),因此我们可以得出以下结论:
* **同一颜色的兔子回答的数值必然是一样的**
* **但回答同样数值的,不一定就是同颜色兔子**
举个🌰,假如有 3 只白兔,每只白兔的回答必然都是 2(对应结论 1);但假如有兔子回答了数值 2,可能只是三只白兔,也可能是三只白兔和三只灰兔同时进行了回答(对应结论 2)。
**答案要我们求最少的兔子数量。**
不妨设有某种颜色的兔子 $m$ 只,它们回答的答案数值为 $cnt$,那么 $m$ 和 $cnt$ 满足什么关系?
显然两者关系为 $m = cnt + 1$。
但如果是在 $answers$ 数组里,回答 $cnt$ ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.781` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/782. 变为棋盘（困难）.md | 782. 变为棋盘 | https://leetcode.cn/problems/transform-to-chessboard/solution/by-ac_oier-vf1m/ | 困难 | [
"构造"
] | 一个 `n x n` 的二维网络 `board` 仅由 `0` 和 `1` 组成 。每次移动,你能任意交换两列或是两行的位置。
返回 将这个矩阵变为 “棋盘” 所需的最小移动次数 。如果不存在可行的变换,输出 `-1`。
“棋盘” 是指任意一格的上下左右四个方向的值均与本身不同的矩阵。
示例 1:
```
输入: board = [[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]
输出: 2
解释:一种可行的变换方式如下,从左到右:
第一次移动交换了第一列和第二列。
第二次移动交换了第二行和第三行。
```
示例 2:
```
输入: board = [[0, 1], [1, 0]]... | ### 构造分析
数据范围具有一定的迷惑性,但其并不是一个棋盘搜索问题。
我们需要考虑何种情况下无解,以及有解情况的最小步数。
在给定棋盘大小 $n$ 的前提下,所能构造的合法棋盘只有两种情况:首个格子为 $0$ 或首个格子为 $1$,即问题转化为能否构造出合法棋盘,以及构造哪种合法棋盘所用步数更小。
同时,**交换行和交换列均不会影响行的种类数量和列的种类数量**,因此我们可以得到第一个判断无解的条件:若起始棋盘的行/列种类数不为 $2$,必然无法构造出合法棋盘。
假设起始的行分别为 `r1` 和 `r2`,起始的列分别为 `c1` 和 `c2`。不难发现第二性质:**若能构成合法棋盘,`r1` 和 `r2` 中 $0$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.782` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/783. 二叉搜索树节点最小距离（简单）.md | 783. 二叉搜索树节点最小距离 | https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/solution/gong-shui-san-xie-yi-ti-san-jie-shu-de-s-7r17/ | 简单 | [
"树的搜索",
"迭代",
"非迭代",
"中序遍历",
"BFS",
"DFS"
] | 给你一个二叉搜索树的根节点 root ,返回 树中任意两不同节点值之间的最小差值 。
注意:本题与 530:https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同
示例 1:
```
输入:root = [4,2,6,1,3]
输出:1
```
示例 2:
```
输入:root = [1,0,48,null,null,12,49]
输出:1
```
提示:
* 树中节点数目在范围 [2, 100] 内
* 0 <= Node.val <= $10^5$
* 差值是一个正数,其数值等于两值之差的绝对值 | ### 朴素解法(BFS & DFS)
如果不考虑利用二叉搜索树特性的话,一个朴素的做法是将所有节点的 $val$ 存到一个数组中。
对数组进行排序,并获取答案。
将所有节点的 $val$ 存入数组,可以使用 BFS 或者 DFS。
代码:
```java []
class Solution {
public int minDiffInBST(TreeNode root) {
List<Integer> list = new ArrayList<>();
// BFS
Deque<TreeNode> d = new ArrayDeque<>();
d.... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.783` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/784. 字母大小写全排列（中等）.md | 784. 字母大小写全排列 | https://leetcode.cn/problems/letter-case-permutation/solution/by-ac_oier-x7f0/ | 中等 | [
"DFS",
"爆搜",
"二进制枚举"
] | 给定一个字符串 `s` ,通过将字符串 `s` 中的每个字母转变大小写,我们可以获得一个新的字符串。
返回 所有可能得到的字符串集合 。以 任意顺序 返回输出。
示例 1:
```
输入:s = "a1b2"
输出:["a1b2", "a1B2", "A1b2", "A1B2"]
```
示例 2:
```
输入: s = "3z4"
输出: ["3z4","3Z4"]
```
提示:
* $1 <= s.length <= 12$
* `s` 由小写英文字母、大写英文字母和数字组成 | ### DFS
数据范围为 $12$,同时要我们求所有具体方案,容易想到使用 `DFS` 进行「爆搜」。
我们可以从前往后考虑每个 $s[i]$,根据 $s[i]$ 是否为字母进行分情况讨论:
* 若 $s[i]$ 不是字母,直接保留
* 若 $s[i]$ 是字母,则有「保留原字母」或「进行大小写转换」两种决策
设计 `DFS` 函数为 `void dfs(int idx, int n, String cur)`:其中 $n$ 固定为具体方案的长度(即原字符串长度),而 `idx` 和 `cur` 分别为当前处理到哪一个 $s[idx]$,而 `cur` 则是当前具体方案。
根据上述分析可知,当 $s[idx]$ 不为字母... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.784` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/786. 第 K 个最小的素数分数（中等）.md | 786. 第 K 个最小的素数分数 | https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-8ymk/ | 中等 | [
"优先队列(堆)",
"多路归并",
"二分",
"双指针"
] | 给你一个按递增顺序排序的数组 `arr` 和一个整数 `k` 。
数组 `arr` 由 $1$ 和若干 **素数** 组成,且其中所有整数互不相同。
对于每对满足 $0 < i < j < arr.length$ 的 $i$ 和 $j$ ,可以得到分数 $arr[i] / arr[j]$ 。
那么第 $k$ 个最小的分数是多少呢? 以长度为 $2$ 的整数数组返回你的答案, 这里 $answer[0] == arr[i]$ 且 $answer[1] == arr[j]$ 。
示例 1:
```
输入:arr = [1,2,3,5], k = 3
输出:[2,5]
解释:已构造好的分数,排序后如下所示:
1/5, 1... | ### 优先队列(堆)
数据范围只有 $10^3$,直接扫描所有点对的计算量不超过 $10^6$。
因此我们可以使用「扫描点对」+「优先队列(堆)」的做法,使用二元组 $(arr[i], arr[j])$ 进行存储,构建大小为 $k$ 的大根堆。
根据「堆内元素多少」和「当前计算值与堆顶元素的大小关系」决定入堆行为:
* 若堆内元素不足 $k$ 个,直接将当前二元组进行入堆;
* 若堆内元素已达 $k$ 个,根据「当前计算值 $\frac{arr[i]}{arr[j]}$ 与堆顶元素 $\frac{peek[0]}{peek[1]}$ 的大小关系」进行分情况讨论:
* 如果当前计算值比堆顶元素大,那么当前元素不可能是... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.786` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/787. K 站中转内最便宜的航班（中等）.md | 787. K 站中转内最便宜的航班 | https://leetcode-cn.com/problems/cheapest-flights-within-k-stops/solution/gong-shui-san-xie-xiang-jie-bellman-ford-dc94/ | 中等 | [
"最短路",
"Bellman Ford"
] | 有 `n` 个城市通过一些航班连接。给你一个数组 `flights`,其中 $flights[i] = [from_i, to_i, price_i]$ ,表示该航班都从城市 $from_i$ 开始,以价格 $price_i$ 抵达 $to_i$。
现在给定所有的城市和航班,以及出发城市 `src` 和目的地 `dst`,你的任务是找到出一条最多经过 `k` 站中转的路线,使得从 `src` 到 `dst` 的 价格最便宜 ,并返回该价格。 如果不存在这样的路线,则输出 `-1`。
示例 1:
```
输入:
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst... | ### 基本分析
从题面看就能知道,这是一类「有限制」的最短路问题。
「限制最多经过不超过 $k$ 个点」等价于「限制最多不超过 $k + 1$ 条边」,而解决「有边数限制的最短路问题」是 SPFA 所不能取代 Bellman Ford 算法的经典应用之一(SPFA 能做,但不能直接做)。
**Bellman Ford/SPFA 都是基于动态规划,其原始的状态定义为 $f[i][k]$ 代表从起点到 $i$ 点,且经过最多 $k$ 条边的最短路径。这样的状态定义引导我们能够使用 Bellman Ford 来解决有边数限制的最短路问题。**
**同样多源汇最短路算法 Floyd 也是基于动态规划,其原始的三维状态定义为 $f[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.787` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/788. 旋转数字（中等）.md | 788. 旋转数字 | https://leetcode.cn/problems/rotated-digits/solution/by-ac_oier-9qpw/ | 中等 | [
"模拟"
] | 我们称一个数 `X` 为好数, 如果它的每位数字逐个地被旋转 `180` 度后,我们仍可以得到一个有效的,且和 `X` 不同的数。要求每位数字都要被旋转。
如果一个数的每位数字被旋转以后仍然还是一个数字, 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己;2 和 5 可以互相旋转成对方(在这种情况下,它们以不同的方向旋转,换句话说,2 和 5 互为镜像);6 和 9 同理,除了这些以外其他的数字旋转以后都不再是有效的数字。
现在我们有一个正整数 `N`, 计算从 `1` 到 `N` 中有多少个数 X 是好数?
示例:
```
输入: 10
输出: 4
解释:
在[1, 10]中有四个好数: 2, 5, 6, ... | ### 模拟
利用 $n$ 的范围为 $1e4$,我们可以直接检查 $[1, n]$ 的每个数。
由于每一个位数都需要翻转,因此如果当前枚举到的数值 `x` 中包含非有效翻转数字(非 `0125689`)则必然不是好数;而在每一位均为有效数字的前提下,若当前枚举到的数值 `x` 中包含翻转后能够发生数值上变化的数值(`2569`),则为好数。
Java 代码:
```Java
class Solution {
public int rotatedDigits(int n) {
int ans = 0;
out:for (int i = 1; i <= n; i++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.788` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/789. 逃脱阻碍者（中等）.md | 789. 逃脱阻碍者 | https://leetcode-cn.com/problems/escape-the-ghosts/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-w69gr/ | 中等 | [
"数学"
] | 你在进行一个简化版的吃豆人游戏。你从 [0, 0] 点开始出发,你的目的地是 target = [xtarget, ytarget] 。地图上有一些阻碍者,以数组 ghosts 给出,第 i 个阻碍者从 ghosts[i] = [xi, yi] 出发。所有输入均为 整数坐标 。
每一回合,你和阻碍者们可以同时向东,西,南,北四个方向移动,每次可以移动到距离原位置 1 个单位 的新位置。当然,也可以选择 不动 。所有动作 同时 发生。
如果你可以在任何阻碍者抓住你 之前 到达目的地(阻碍者可以采取任意行动方式),则被视为逃脱成功。如果你和阻碍者同时到达了一个位置(包括目的地)都不算是逃脱成功。
只有在你有可能成功逃脱时,输出 t... | ### 数学
从数据范围 $-10^4 <= x_{target}, y_{target} <= 10^4$ 且每次只能移动一个单位(或不移动)就注定了不能使用朴素的 `BFS` 进行求解。
朴素的 `BFS` 是指每次在玩家移动一步前,先将阻碍者可以一步到达的位置“置灰”(即设为永不可达),然后判断玩家是否能够到达 $target$。
朴素 `BFS` 本质是模拟,由于棋盘足够大,步长只有 $1$,因此该做法显然会 TLE。
是否有比模拟更快的做法呢?
**根据「树的直径」类似的证明,我们可以证明出「如果一个阻碍者能够抓到玩家,必然不会比玩家更晚到达终点」。**
为了方便,我们设玩家起点、阻碍者起点、终点分别为 $s$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.789` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/790. 多米诺和托米诺平铺（中等）.md | 790. 多米诺和托米诺平铺 | https://leetcode.cn/problems/domino-and-tromino-tiling/solution/gong-shui-san-xie-by-ac_oier-kuv4/ | 中等 | [
"状态机 DP",
"动态规划"
] | 有两种形状的瓷砖:一种是 `2 x 1` 的多米诺形,另一种是形如 `"L"` 的托米诺形,两种形状都可以旋转。
给定整数 `n` ,返回可以平铺 `2 x n` 的面板的方法的数量,返回对 $10^9 + 7$ 取模 的值。
平铺指的是每个正方形都必须有瓷砖覆盖。
两个平铺不同,当且仅当面板上有四个方向上的相邻单元中的两个,使得恰好有一个平铺有一个瓷砖占据两个正方形。
示例 1:
```
输入: n = 3
输出: 5
解释: 五种不同的方法如上所示。
```
示例 2:
```
输入: n = 1
输出: 1
```
提示:
* $1 <= n <= 1000$ | ### 状态机 DP
定义 $f[i][j]$ 为无须考虑前 $i - 1$ 列(含义为前 $i - 1$ 列已铺满),当前第 $i$ 列状态为 $j$ 时的方案数。
其中 $j$ 取值范围为 $[0, 4)$ 分别对应了当前列的填充情况:
为了方便,我们人为规定列数从 $1$ 开始。
由于骨牌只能在 $2 \times n$ 的棋盘内填充(不能延伸出棋盘两端),因此我们有显而易见的初始化状态:
$$
f[1][0] = f[1][1] = 1
$$
分别对应「第一列不放置任何骨牌」和「第一列竖着放一块 $1 \times 2$ 骨牌」合法方案。
而 $f[1][2]$ 和 $f[1][3]$ 由于没法在棋盘左侧以外的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.790` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/791. 自定义字符串排序（中等）.md | 791. 自定义字符串排序 | https://leetcode.cn/problems/custom-sort-string/solution/by-ac_oier-ali0/ | 中等 | [
"构造",
"模拟"
] | 给定两个字符串 `order` 和 `s` 。
`order` 的所有单词都是唯一的,并且以前按照一些自定义的顺序排序。
对 `s` 的字符进行置换,使其与排序的 `order` 相匹配。
更具体地说,如果在 `order` 中的字符 `x` 出现字符 `y` 之前,那么在排列后的字符串中, `x` 也应该出现在 `y` 之前。
返回满足这个性质的 `s` 的任意排列 。
示例 1:
```
输入: order = "cba", s = "abcd"
输出: "cbad"
解释:
“a”、“b”、“c”是按顺序出现的,所以“a”、“b”、“c”的顺序应该是“c”、“b”、“a”。
因为“d”不是按顺序出现的,所以它可... | ### 构造
根据题意进行模拟即可:起始先使用大小为 $C = 26$ 的数组 `cnts` 对 `s` 的所有字符进行词频统计,随后根据 `order` 的优先级进行构造。
若字符 `x` 在 `order` 中排于 `y` 前面,则先往答案追加 `cnts[x]` 个字符 `x`,再往答案追加 `cnts[y]` 个字符 `y`,并更新对应词频,最后将仅出现在 `s` 中的字符追加到答案尾部。
Java 代码:
```Java
class Solution {
public String customSortString(String order, String s) {
int[] cnts = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.791` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/792. 匹配子序列的单词数（中等）.md | 792. 匹配子序列的单词数 | https://leetcode.cn/problems/number-of-matching-subsequences/solution/by-ac_oier-u1ox/ | 中等 | [
"二分",
"哈希表"
] | 给定字符串 `s` 和字符串数组 `words`, 返回 `words[i]` 中是 `s` 的子序列的单词个数 。
字符串的子序列是从原始字符串中生成的新字符串,可以从中删去一些字符(可以是`""`),而不改变其余字符的相对顺序。
例如, `“ace”` 是 `“abcde”` 的子序列。
示例 1:
```
输入: s = "abcde", words = ["a","bb","acd","ace"]
输出: 3
解释: 有三个是 s 的子序列的单词: "a", "acd", "ace"。
```
示例 2:
```
输入: s = "dsahjpjauf", words = ["ahjpjau","ja","ahb... | ### 预处理 + 哈希表 + 二分
朴素判定某个字符串是为另一字符串的子序列的复杂度为 $O(n + m)$,对于本题共有 $5000$ 个字符串需要判定,每个字符串最多长为 $50$,因此整体计算量为 $(5 \times 10^4 + 50) \times 5000 \approx 2.5 \times 10^8$,会超时。
不可避免的是,我们要对每个 $words[i]$ 进行检查,因此优化的思路可放在如何优化单个 $words[i]$ 的判定操作。
朴素的判定过程需要使用双指针扫描两个字符串,其中对于原串的扫描,会有大量的字符会被跳过(无效匹配),即只有两指针对应的字符相同时,匹配串指针才会后移。
我们考虑如何优化... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.792` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/793. 阶乘函数后 K 个零（困难）.md | 793. 阶乘函数后 K 个零 | https://leetcode.cn/problems/preimage-size-of-factorial-zeroes-function/solution/by-ac_oier-pk9g/ | 困难 | [
"数学",
"二分",
"容斥原理"
] | `f(x)` 是 `x!` 末尾是 `0` 的数量。回想一下 `x! = 1 * 2 * 3 * ... * x`,且 `0! = 1`。
例如, `f(3) = 0`,因为 `3! = 6` 的末尾没有 `0` ;而 `f(11) = 2`,因为 `11!= 39916800` 末端有 `2` 个 `0` 。
给定 `k`,找出返回能满足 `f(x) = k` 的非负整数 `x` 的数量。
示例 1:
```
输入:k = 0
输出:5
解释:0!, 1!, 2!, 3!, 和 4! 均符合 k = 0 的条件。
```
示例 2:
```
输入:k = 5
输出:0
解释:没有匹配到这样的 x!,符合 k = 5 ... | ### 数学 + 二分
对于一个 $n! = 1 \times 2 \times ... \times (n - 1) \times n$ 而言,其最终结果尾部包含 $0$ 的数量取决于其被累乘 $10$ 的次数,而 $10$ 可通过质因数 $2$ 和 $5$ 相乘而来,因此假设对 $n!$ 进行阶乘分解,最终分解出 $2^p$ 和 $5^q$ 的话,那么最终结果尾部包含 $0$ 的个数为 $q$ 个(可证明 $p >= q$ 始终满足)。
因此原问题转化为:在非负整数中,有多少个数进行阶乘分解后,所含质因数 $5$ 的个数恰好为 $k$ 个。
同时我们可知:随着 $n$ 的增大,其所能分解出来的 $5$ 的个数必然是递增的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.793` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/794. 有效的井字游戏（中等）.md | 794. 有效的井字游戏 | https://leetcode-cn.com/problems/valid-tic-tac-toe-state/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-pikn/ | 中等 | [
"模拟"
] | 给你一个字符串数组 `board` 表示井字游戏的棋盘。当且仅当在井字游戏过程中,棋盘有可能达到 `board` 所显示的状态时,才返回 `true` 。
井字游戏的棋盘是一个 `3 x 3` 数组,由字符 `' '`,`'X'` 和 `'O'` 组成。字符 `' '` 代表一个空位。
以下是井字游戏的规则:
* 玩家轮流将字符放入空位(`' '`)中。
* 玩家 $1$ 总是放字符 `'X'` ,而玩家 $2$ 总是放字符 `'O'` 。
* 'X' 和 'O' 只允许放置在空位中,不允许对已放有字符的位置进行填充。
* 当有 $3$ 个相同(且非空)的字符填充任何行、列或对角线时,游戏结束。
* 当所有位置非空时,也算为游戏... | ### 分情况讨论
给定的棋盘大小固定,对于无效情况进行分情况讨论即可:
1. 由于 `X` 先手,`O` 后手,两者轮流下子。因此 `O` 的数量不会超过 `X`,且两者数量差不会超过 $1$,否则为无效局面;
2. 若局面是 `X` 获胜,导致该局面的最后一个子必然是 `X`,此时必然有 `X` 数量大于 `O`(`X` 为先手),否则为无效局面;
3. 若局面是 `O` 获胜,导致该局面的最后一个子必然是 `O`,此时必然有 `X` 数量等于 `O`(`X` 为先手),否则为无效局面;
4. 局面中不可能出现两者同时赢(其中一方赢后,游戏结束)。
代码:
```Java
class Solution {
publ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.794` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/795. 区间子数组个数（中等）.md | 795. 区间子数组个数 | https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum/solution/by-ac_oier-gmpt/ | 中等 | [
"模拟",
"单调栈"
] | 给你一个整数数组 `nums` 和两个整数:`left` 及 `right` 。
找出 `nums` 中连续、非空且其中最大元素在范围 $[left, right]$ 内的子数组,并返回满足条件的子数组的个数。
生成的测试用例保证结果符合 `32-bit` 整数范围。
示例 1:
```
输入:nums = [2,1,4,3], left = 2, right = 3
输出:3
解释:满足条件的三个子数组:[2], [2, 1], [3]
```
示例 2:
```
输入:nums = [2,9,2,5,6], left = 2, right = 8
输出:7
```
提示:
* $1 <= nums.length... | ### 单调栈
为了方便,我们令 $[left, right]$ 为 $[a, b]$。
一个容易想到的思路是使用「单调栈」。
**统计所有最大值范围在 $[a, b]$ 之间的子数组个数,可等价为统计每一个范围落在 $[a, b]$ 之间的 $nums[i]$ 作为最大值时子数组的个数。**
由此可以进一步将问题转换为:求解每个 $nums[i]$ 作为子数组最大值时,最远的合法左右端点的位置。也就是求解每一个 $nums[i]$ 左右最近一个比其“大”的位置,这可以使用「单调栈」来进行求解。
> 对于单调栈不了解的同学,可以看前置 🧀 : [【RMQ 专题】关于 RMQ 的若干解法](https://mp.weixi... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.795` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/796. 旋转字符串（简单）.md | 796. 旋转字符串 | https://leetcode-cn.com/problems/rotate-string/solution/by-ac_oier-bnkx/ | 简单 | [
"模拟"
] | 给定两个字符串,`s` 和 `goal`。如果在若干次旋转操作之后,`s` 能变成 `goal`,那么返回 `true`。
`s` 的旋转操作就是将 `s` 最左边的字符移动到最右边。
* 例如, 若 `s = 'abcde'`,在旋转一次之后结果就是`'bcdea'` 。
示例 1:
```
输入: s = "abcde", goal = "cdeab"
输出: true
```
示例 2:
```
输入: s = "abcde", goal = "abced"
输出: false
```
提示:
* $1 <= s.length, goal.length <= 100$
* `s` 和 `goal` 由小写英文字母... | ### 模拟
由于每次旋转操作都是将最左侧字符移动到最右侧,因此如果 `goal` 可由 `s` 经过多步旋转而来,那么 `goal` 必然会出现在 `s + s` 中,即满足 `(s + s).contains(goal)`,同时为了 `s` 本身过长导致的结果成立,我们需要先确保两字符串长度相等。
代码:
```Java
class Solution {
public boolean rotateString(String s, String goal) {
return s.length() == goal.length() && (s + s).contains(goal);
}
}
``... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.796` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/797. 所有可能的路径（中等）.md | 797. 所有可能的路径 | https://leetcode-cn.com/problems/all-paths-from-source-to-target/solution/gong-shui-san-xie-yun-yong-dfs-bao-sou-s-xlz9/ | 中等 | [
"回溯算法",
"DFS"
] | 给你一个有 n 个节点的 有向无环图(DAG),请你找出所有从节点 0 到节点 n-1 的路径并输出(不要求按特定顺序)
二维数组的第 i 个数组中的单元都表示有向图中 i 号节点所能到达的下一些节点,空就是没有下一个结点了。
译者注:有向图是有方向的,即规定了 a→b 你就不能从 b→a 。
示例 1:
```
输入:graph = [[1,2],[3],[3],[]]
输出:[[0,1,3],[0,2,3]]
解释:有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3
```
示例 2:
```
输入:graph = [[4,3,1],[3,2,4],[3],[4],[]]
输出:[[0,4],[0,3... | ### DFS
$n$ 只有 $15$,且要求输出所有方案,因此最直观的解决方案是使用 `DFS` 进行爆搜。
起始将 $0$ 进行加入当前答案,当 $n - 1$ 被添加到当前答案时,说明找到了一条从 $0$ 到 $n - 1$ 的路径,将当前答案加入结果集。
当我们决策到第 $x$ 位(非零)时,该位置所能放入的数值由第 $x - 1$ 位已经填入的数所决定,同时由于给定的 $graph$ 为有向无环图(拓扑图),因此按照第 $x - 1$ 位置的值去决策第 $x$ 位的内容,必然不会决策到已经在当前答案的数值,否则会与 $graph$ 为有向无环图(拓扑图)的先决条件冲突。
换句话说,与一般的爆搜不同的是,我们不再需... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.797` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/798. 得分最高的最小轮调（困难）.md | 798. 得分最高的最小轮调 | https://leetcode-cn.com/problems/smallest-rotation-with-highest-score/solution/gong-shui-san-xie-shang-xia-jie-fen-xi-c-p6kh/ | 困难 | [
"区间求和问题",
"差分"
] | 给你一个数组 $nums$,我们可以将它按一个非负整数 $k$ 进行轮调,这样可以使数组变为 $[nums[k], nums[k + 1], ... nums[nums.length - 1], nums[0], nums[1], ..., nums[k-1]]$ 的形式。此后,任何值小于或等于其索引的项都可以记作一分。
例如,数组为 $nums = [2,4,1,3,0]$,我们按 $k = 2$ 进行轮调后,它将变成 $[1,3,0,2,4]$。这将记为 $3$ 分,因为 $1 > 0$ [不计分]、$3 > 1$ [不计分]、$0 <= 2$ [计 $1$ 分]、$2 <= 3$ [计 $1$ 分],$4 <= 4$ [计... | ### 上下界分析 + 差分应用
为了方便,令 $n$ 为 $nums$ 长度(中文的数据范围是错的,数组长度应该是 $10^5$,不是 $20000$)。
对于给定的 $nums$ 而言,有效的轮调范围为 $[0, n - 1]$,即对于任意 $nums[i]$ 而言,可取的下标共有 $n$ 种。
假定当前下标为 $i$,轮调次数为 $k$,那么轮调后下标为 $i - k$,当新下标为负数时,相当于 $nums[i]$ 出现在比原数组更“靠后”的位置,此时下标等价于 $(i - k + n) \mod n$。
考虑什么情况下 $nums[i]$ 能够得分?
首先新下标的取值范围为 $[0, n - 1]$,即有 $0 \... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.798` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/799. 香槟塔（中等）.md | 799. 香槟塔 | https://leetcode.cn/problems/champagne-tower/solution/by-ac_oier-c8jn/ | 中等 | [
"动态规划",
"线性 DP"
] | 我们把玻璃杯摆成金字塔的形状,其中 第一层 有 `1` 个玻璃杯, 第二层 有 `2` 个,依次类推到第 `100` 层,每个玻璃杯 (`250ml`) 将盛有香槟。
从顶层的第一个玻璃杯开始倾倒一些香槟,当顶层的杯子满了,任何溢出的香槟都会立刻等流量的流向左右两侧的玻璃杯。当左右两边的杯子也满了,就会等流量的流向它们左右两边的杯子,依次类推。(当最底层的玻璃杯满了,香槟会流到地板上)
例如,在倾倒一杯香槟后,最顶层的玻璃杯满了。倾倒了两杯香槟后,第二层的两个玻璃杯各自盛放一半的香槟。在倒三杯香槟后,第二层的香槟满了 - 此时总共有三个满的玻璃杯。在倒第四杯后,第三层中间的玻璃杯盛放了一半的香槟,他两边的玻璃杯各自盛放了四分之一... | ### 线性 DP
为了方便,我们令 `poured` 为 `k`,`query_row` 和 `query_glass` 分别为 $n$ 和 $m$。
定义 $f[i][j]$ 为第 $i$ 行第 $j$ 列杯子所经过的水的流量(而不是最终剩余的水量)。
起始我们有 $f[0][0] = k$,最终答案为 $\min(f[n][m], 1)$。
不失一般性考虑 $f[i][j]$ 能够更新哪些状态:显然当 $f[i][j]$ 不足 $1$ 的时候,不会有水从杯子里溢出,即 $f[i][j]$ 将不能更新其他状态;当 $f[i][j]$ 大于 $1$ 时,将会有 $f[i][j] - 1$ 的水会等量留到下一行的杯子里,所流... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.799` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/801. 使序列递增的最小交换次数（困难）.md | 801. 使序列递增的最小交换次数 | https://leetcode.cn/problems/minimum-swaps-to-make-sequences-increasing/solution/by-ac_oier-fjhp/ | 困难 | [
"状态机 DP",
"动态规划"
] | 我们有两个长度相等且不为空的整型数组 `nums1` 和 `nums2`。
在一次操作中,我们可以交换 $nums1[i]$ 和 $nums2[i]$ 的元素。
例如,如果 $nums1 = [1,2,3,8]$ ,$nums2 =[5,6,7,4]$ ,你可以交换 $i = 3$ 处的元素,得到 $nums1 =[1,2,3,4]$ 和 $nums2 =[5,6,7,8]$ 。
返回 使 `nums1` 和 `nums2` 严格递增 所需操作的最小次数 。
数组 `arr` 严格递增 且 $arr[0] < arr[1] < arr[2] < ... < arr[arr.length - 1]$ 。
注意:
用例保证... | ### 基本分析
这是一道很裸的状态机 DP 运用题。
由于每次交换只会发生在两数组的相同位置上,使得问题变得简单:**仅需考虑交换当前位置后,当前元素与前后元素大小关系变化即可**。
又因为我们会从前往后处理每个位置,因此只需要考虑当前位置与前一位置的大小关系即可。
---
### 状态机 DP
定义 $f[i][j]$ 为考虑下标范围为 $[0, i]$ 的元素,且位置 $i$ 的交换状态为 $j$ 时(其中 $j = 0$ 为不交换,$j = 1$ 为交换)两数组满足严格递增的最小交换次数。
最终答案为 $\min(f[n - 1][0], f[n - 1][1])$,同时我们有显而易见的初始化条件 $f[0][... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.801` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/802. 找到最终的安全状态（中等）.md | 802. 找到最终的安全状态 | https://leetcode-cn.com/problems/find-eventual-safe-states/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-isy6u/ | 中等 | [
"图",
"拓扑排序"
] | 在有向图中,以某个节点为起始节点,从该点出发,每一步沿着图中的一条有向边行走。如果到达的节点是终点(即它没有连出的有向边),则停止。
对于一个起始节点,如果从该节点出发,无论每一步选择沿哪条有向边行走,最后必然在有限步内到达终点,则将该起始节点称作是 安全 的。
返回一个由图中所有安全的起始节点组成的数组作为答案。答案数组中的元素应当按 升序 排列。
该有向图有 n 个节点,按 0 到 n - 1 编号,其中 n 是 graph 的节点数。图以下述形式给出:graph[i] 是编号 j 节点的一个列表,满足 (i, j) 是图的一条有向边。
示例 1:
```
输入:graph = [[1,2],[2,3],[5],[0... | ### 基本分析 & 拓扑排序
为了方便,我们令点数为 $n$,边数为 $m$。
**在图论中,一个有向无环图必然存在至少一个拓扑序与之对应,反之亦然。**
如果对拓扑排序不熟悉的小伙伴,可以看看 [拓扑排序](https://baike.baidu.com/item/%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F)。
**简单来说,就是将图中的所有节点展开成一维序列,对于序列中任意的节点 $(u, v)$,如果在序列中 $u$ 在 $v$ 的前面,则说明在图中存在从 $u$ 出发达到 $v$ 的通路,即 $u$ 排在 $v$ 的前面。反之亦然。**
同时,我们需要知晓「入度」和「出度」的概念:
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.802` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/804. 唯一摩尔斯密码词（简单）.md | 804. 唯一摩尔斯密码词 | https://leetcode-cn.com/problems/unique-morse-code-words/solution/by-ac_oier-a9hv/ | 简单 | [
"模拟"
] | 国际摩尔斯密码定义一种标准编码方式,将每个字母对应于一个由一系列点和短线组成的字符串, 比如:
* `'a'` 对应 `".-"` ,
* `'b'` 对应 `"-..."` ,
* `'c'` 对应 `"-.-."`,以此类推。
为了方便,所有 $26$ 个英文字母的摩尔斯密码表如下:
```
[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
```
给你一... | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
String[] ss = new String[]{".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
public int uniqueMorseRepresentations(String[] words) {
Set<Strin... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.804` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/805. 数组的均值分割（困难）.md | 805. 数组的均值分割 | https://leetcode.cn/problems/split-array-with-same-average/solution/gong-shui-san-xie-by-ac_oier-flsd/ | 困难 | [
"折半搜索",
"二进制枚举",
"哈希表"
] | 给定你一个整数数组 `nums`。
我们要将 `nums` 数组中的每个元素移动到 `A` 数组 或者 `B` 数组中,使得 `A` 数组和 `B` 数组不为空,并且 `average(A) == average(B)` 。
如果可以完成则返回 `true`, 否则返回 `false`。
注意:对于数组 `arr`, `average(arr)` 是 `arr` 的所有元素除以 `arr` 长度的和。
示例 1:
```
输入: nums = [1,2,3,4,5,6,7,8]
输出: true
解释: 我们可以将数组分割为 [1,4,5,8] 和 [2,3,6,7], 他们的平均值都是4.5。
```
示例 2:
`... | ### 折半搜索 + 二进制枚举 + 哈希表 + 数学
##### 提示一:将长度为 $n$,总和为 $sum$ 的原数组划分为两组,使得两数组平均数相同,可推导出该平均数 $avg = \frac{sum}{n}$
若两数组平均数相同,则由两数组组成的新数组(对应原数组 `nums`)平均数不变,而原数组的平均数可直接算得。
##### 提示二:原数组长度为 $30$,直接通过「二进制枚举」的方式来做,计算量为 $2^{30}$,该做法无须额外空间,但会 `TLE`。
所谓的直接使用「二进制枚举」来做,是指用二进制表示中的 `0` 和 `1` 分别代表在划分数组两边。
如果直接对原数组进行「二进制枚举」,由于每个 $nu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.805` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/806. 写字符串需要的行数（简单）.md | 806. 写字符串需要的行数 | https://leetcode-cn.com/problems/number-of-lines-to-write-string/solution/by-ac_oier-5hg2/ | 简单 | [
"模拟"
] | 我们要把给定的字符串 `S` 从左到右写到每一行上,每一行的最大宽度为 $100$ 个单位,如果我们在写某个字母的时候会使这行超过了 $100$ 个单位,那么我们应该把这个字母写到下一行。
我们给定了一个数组 `widths`,这个数组 $widths[0]$ 代表 `'a'` 需要的单位, $widths[1]$ 代表 `'b'` 需要的单位,..., $widths[25]$ 代表 `'z'` 需要的单位。
现在回答两个问题:至少多少行能放下 `S`,以及最后一行使用的宽度是多少个单位?
将你的答案作为长度为 $2$ 的整数列表返回。
示例 1:
```
输入:
widths = [10,10,10,10,10,10,... | ### 模拟
根据题意进行模拟即可。
使用变量 `a` 代指当前有多少行是满的,使用变量 `b` 代指当前填充光标所在的位置。
代码:
```Java
class Solution {
public int[] numberOfLines(int[] widths, String s) {
int a = 0, b = 0;
for (char c : s.toCharArray()) {
int t = widths[c - 'a'];
if (b + t > 100 && ++a >= 0) b = t;
els... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.804` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/807. 保持城市天际线（中等）.md | 807. 保持城市天际线 | https://leetcode-cn.com/problems/max-increase-to-keep-city-skyline/solution/gong-shui-san-xie-jian-dan-tan-xin-yun-y-2f47/ | 中等 | [
"贪心"
] | 在二维数组 $grid$ 中,$grid[i][j]$ 代表位于某处的建筑物的高度。 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度。 高度 $0$ 也被认为是建筑物。
最后,从新数组的所有四个方向(即顶部,底部,左侧和右侧)观看的“天际线”必须与原始数组的天际线相同。 城市的天际线是从远处观看时,由所有建筑物形成的矩形的外部轮廓。 请看下面的例子。
建筑物高度可以增加的最大总和是多少?
例子:
```
输入: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
输出: 35
解释:
The grid is:
[ [3, 0, 8, 4],
[2, 4... | ### 贪心
根据题意,我们需要确保在调整建筑物高度后,从「水平」和「竖直」两个方向所看到的「行」和「列」的最大高度不变。
因此我们可以先通过 $O(n * m)$ 的复杂度预处理出 `grid` 中每行的最大值(使用 $r$ 数组存储),以及每列的最大值(使用 $c$ 数组存储)。
然后在统计答案时,通过判断当前位置 $g[i][j]$ 与 $\min(r[i], c[j])$ 的大小关系来决定当前位置能够增高多少。
可以证明,当每个位置都取得最大的增大高度(局部最优)时,可使得总的增加高度最大(全局最优)。
代码:
```Java
class Solution {
public int maxIncreaseK... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.807` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/808. 分汤（中等）.md | 808. 分汤 | https://leetcode.cn/problems/soup-servings/solution/by-ac_oier-3n1h/ | 中等 | [
"数学",
"动态规划",
"线性 DP"
] | 有 `A` 和 `B` 两种类型 的汤,一开始每种类型的汤有 `n` 毫升。
有四种分配操作:
1. 提供 `100ml` 的 汤A 和 `0ml` 的 汤B 。
2. 提供 `75ml` 的 汤A 和 `25ml` 的 汤B 。
3. 提供 `50ml` 的 汤A 和 `50ml` 的 汤B 。
4. 提供 `25ml` 的 汤A 和 `75ml` 的 汤B 。
当我们把汤分配给某人之后,汤就没有了。
每个回合,我们将从四种概率同为 `0.25` 的操作中进行分配选择。
如果汤的剩余量不足以完成某次操作,我们将尽可能分配。
当两种类型的汤都分配完时,停止操作。
注意 不存在先分配 `100 ml` 汤B 的操作。
... | ### 数学 + 动态规划
四种分配方式都是 $25$ 的倍数,因此我们可以将 $n$ 进行除以 $25$ 上取整的缩放操作,并将四类操作等价成:
1. 提供 `4ml` 的 汤A 和 `0ml` 的 汤B 。
2. 提供 `3ml` 的 汤A 和 `1ml` 的 汤B 。
3. 提供 `2ml` 的 汤A 和 `2ml` 的 汤B 。
4. 提供 `1ml` 的 汤A 和 `3ml` 的 汤B 。
定义 $f[i][j]$ 为 汤A 剩余 $i$ 毫升,汤B 剩余 $j$ 毫升时的最终概率($概率 = 汤A先分配完的概率 + 汤A和汤B同时分配完的概率 \times 0.5$)。
最终答案为 $f[n][n]$ 为最终答案... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.808` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/809. 情感丰富的文字（中等）.md | 809. 情感丰富的文字 | https://leetcode.cn/problems/expressive-words/solution/by-ac_oier-tb57/ | 中等 | [
"双指针",
"模拟"
] | 有时候人们会用重复写一些字母来表示额外的感受,比如 `"hello" -> "heeellooo", "hi" -> "hiii"`。我们将相邻字母都相同的一串字符定义为相同字母组,例如:`"h", "eee", "ll", "ooo"`。
对于一个给定的字符串 `S` ,如果另一个单词能够通过将一些字母组扩张从而使其和 `S` 相同,我们将这个单词定义为可扩张的(`stretchy`)。
扩张操作定义如下:选择一个字母组(包含字母 `c` ),然后往其中添加相同的字母 `c` 使其长度达到 `3` 或以上。
例如,以 `"hello"` 为例:
我们可以对字母组 `"o"` 扩张得到 `"hellooo"`,但是无法以同样... | ### 双指针
该题最难的部分就是理解 “扩张” 操作:假设有两个字符相同的连续段 `a` 和 `b`,如何判断 `a` 是否能由 `b` 扩张而来。
忘记掉题目所说的规则,我们重新定义 “扩张” 操作:
* 当 `a` 和 `b` 长度相同,定义为可扩张;
* 当 `a` 和 `b` 长度不同,根据「`a` 和 `b` 长度对比」以及「`a` 的长度大小」分情况讨论:
* 当 `b` 长度大于 `a`,不可扩张;
* 当 `a` 长度大于 `b`,**我们不一定要拿整一段的 `b` 进行扩张,可以拿 `b` 中的一个字符进行扩张。** 因此只需要满足扩张后的长度(`a` 的长度)大于等于 $3$ 即可定义为可... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.809` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/810. 黑板异或游戏（困难）.md | 810. 黑板异或游戏 | https://leetcode-cn.com/problems/chalkboard-xor-game/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ges7k/ | 困难 | [
"博弈论",
"数学",
"异或"
] | 黑板上写着一个非负整数数组 `nums[i]` 。
`Alice` 和 `Bob` 轮流从黑板上擦掉一个数字,`Alice` 先手。如果擦除一个数字后,剩余的所有数字按位异或运算得出的结果等于 `0` 的话,当前玩家游戏失败。 (另外,如果只剩一个数字,按位异或运算得到它本身;如果无数字剩余,按位异或运算结果为 `0`。)
换种说法就是,轮到某个玩家时,如果当前黑板上所有数字按位异或运算结果等于 `0`,这个玩家获胜。
假设两个玩家每步都使用最优解,当且仅当 `Alice` 获胜时返回 `true`。
示例:
```
输入: nums = [1, 1, 2]
输出: false
解释:
Alice 有两个选择: 擦掉数... | ### 基本分析
这是一道「博弈论」题。
如果没接触过博弈论,其实很难想到,特别是数据范围为 $10^3$,很具有迷惑性。
如果接触过博弈论,对于这种「判断先手后手的必胜必败」的题目,博弈论方向是一个优先考虑的方向。
根据题意,如果某位玩家在操作前所有数值异或和为 $0$,那么该玩家胜利。要我们判断给定序列时,先手是处于「必胜态」还是「必败态」,如果处于「必胜态」返回 `True`,否则返回 `False`。
对于博弈论的题目,通常有两类的思考方式:
1. 经验分析:见过类似的题目,猜一个性质,然后去证明该性质是否可推广。
2. 状态分析:根据题目给定的规则是判断「胜利」还是「失败」来决定优先分析「必胜态」还是「必败态」... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.810` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/81. 搜索旋转排序数组 II（中等）.md | 81. 搜索旋转排序数组 II | https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/ | 中等 | [
"二分"
] | 已知存在一个按非降序排列的整数数组 nums ,数组中的值不必互不相同。
在传递给函数之前,nums 在预先未知的某个下标 k(0 <= k < nums.length)上进行了 旋转 ,使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]](下标 从 0 开始 计数)。例如, [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。
给你 旋转后 的数组 nums 和一个整数 target ,请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在... | ### 二分
根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。
但和 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode-solut/) 不同的是,本题元素并不唯一。
**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**
**因为「二分」的本质是二段性,并非单调性。只要一段满足某个... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.81` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/82. 删除排序链表中的重复元素 II（中等）.md | 82. 删除排序链表中的重复元素 II | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/solution/tong-yong-shan-chu-zhong-fu-jie-dian-lia-od9g/ | 中等 | [
"链表"
] | 存在一个按升序排列的链表,给你这个链表的头节点 `head`,请你删除链表中所有存在数字重复情况的节点,只保留原始链表中没有重复出现的数字。
返回同样按升序排列的结果链表。
示例 1:
```
输入:head = [1,2,3,3,4,4,5]
输出:[1,2,5]
```
示例 2:
```
输入:head = [1,1,1,2,3]
输出:[2,3]
```
提示:
* 链表中节点数目在范围 $[0, 300]$ 内
* $-100 <= Node.val <= 100$
* 题目数据保证链表已经按升序排列 | ### 基本思路
几乎所有的链表题目,都具有相似的解题思路。
1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面
2. 使用 `tail` 代表当前有效链表的结尾
3. 通过原输入的 `head` 指针进行链表扫描
我们会确保「进入外层循环时 `head` 不会与上一节点相同」,因此插入时机:
1. `head` 已经没有下一个节点,`head` 可以被插入
2. `head` 有一下个节点,但是值与 `head` 不相同,`head` 可以被插入
Java 代码:
```Java
class Solution {
public ListNode deleteDupl... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.82` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/83. 删除排序链表中的重复元素（简单）.md | 83. 删除排序链表中的重复元素 | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/solution/tong-yong-shan-chu-zhong-fu-jie-dian-lia-101c/ | 简单 | [
"链表"
] | 存在一个按升序排列的链表,给你这个链表的头节点 `head`,请你删除所有重复的元素,使每个元素只出现一次 。
返回同样按升序排列的结果链表。
示例 1:
```
输入:head = [1,1,2]
输出:[1,2]
```
示例 2:
```
输入:head = [1,1,2,3,3]
输出:[1,2,3]
```
提示:
* 链表中节点数目在范围 $[0, 300]$ 内
* $-100 <= Node.val <= 100$
* 题目数据保证链表已经按升序排列 | ### 基本思路
几乎所有的链表题目,都具有相似的解题思路。
1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面
2. 使用 `tail` 代表当前有效链表的结尾
3. 通过原输入的 `head` 指针进行链表扫描
Java 代码:
```Java
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if (head == null) return head;
ListNode dummy = new ListNode(-109);
ListN... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.83` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/84. 柱状图中最大的矩形（困难）.md | 84. 柱状图中最大的矩形 | https://leetcode.cn/problems/largest-rectangle-in-histogram/solution/by-ac_oier-i470/ | 困难 | [
"单调栈"
] | 给定 `n` 个非负整数,用来表示柱状图中各个柱子的高度。每个柱子彼此相邻,且宽度为 `1` 。
求在该柱状图中,能够勾勒出来的矩形的最大面积。
示例 1:
```
输入:heights = [2,1,5,6,2,3]
输出:10
解释:最大的矩形为图中红色区域,面积为 10
```
示例 2:
```
输入: heights = [2,4]
输出: 4
```
提示:
* $1 <= heights.length <=10^5$
* $0 <= heights[i] <= 10^4$ | ### 单调栈 + 枚举高度
为了方便,我们令 `heights` 为 `hs`。
最终矩形的高度必然取自某个 $hs[i]$,因此我们可以枚举最终矩形的高度来做。
问题转换为当使用某个 $hs[i]$ 作为矩形高度时,该矩形所能取得的最大宽度为多少。
假设我们能够预处理出 `l` 和 `r` 数组,其中 $l[i]$ 代表位置 $i$ 左边最近一个比其小的位置(初始值为 $-1$),$r[i]$ 代表位置 $i$ 右边最近一个比其小的位置(初始值为 $n$),那么 $r[i] - l[i] - 1$ 则是以 $hs[i]$ 作为矩形高度时所能取得的最大宽度。
预处理 `l` 和 `r` 则是经典的「求最近一个比当前值大的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.84` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/85. 最大矩形（困难）.md | 85. 最大矩形 | https://leetcode.cn/problems/maximal-rectangle/solution/by-ac_oier-k02i/ | 困难 | [
"单调栈",
"前缀和"
] | 给定一个仅包含 `0` 和 `1` 、大小为 `rows x cols` 的二维二进制矩阵,找出只包含 `1` 的最大矩形,并返回其面积。
示例 1:
```
输入:matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
输出:6
解释:最大矩形如上图所示。
```
示例 2:
```
输入:matrix = []
输出:0
```
示例 3:
```
输入:matrix = [["0"]]
输出:0
```
示例 4:
```
输入:matrix = [["1"]]
输出:1
... | ### 前缀和 + 单调栈
为了方便,我们令 `matrix` 为 `mat`,记矩阵的行高为 $n$,矩阵的列宽为 $m$。
定义坐标系 : 左上角坐标为 $(1, 1)$,右下角坐标为 $(n, m)$。
我们将 `mat` 的每一行作为基准,以基准线为起点,往上连续 $1$ 的个数为高度。
以题目样例进行说明:
1. 红框部分代表「以第一行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时只有第一行,可得:$[1, 0, 1, 0, 0]$
2. 黄框部分代表「以第二行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时有第一行和第二行,可得:$[2, 0, 2, 1, 1]$
3. 蓝框部... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.85` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/87. 扰乱字符串（困难）.md | 87. 扰乱字符串 | https://leetcode-cn.com/problems/scramble-string/solution/gong-shui-san-xie-yi-ti-san-jie-di-gui-j-hybk/ | 困难 | [
"DFS",
"记忆化搜索",
"区间 DP"
] | 使用下面描述的算法可以扰乱字符串 s 得到字符串 t :
1. 如果字符串的长度为 1 ,算法停止
2. 如果字符串的长度 > 1 ,执行下述步骤:
* 在一个随机下标处将字符串分割成两个非空的子字符串。即,如果已知字符串 s ,则可以将其分成两个子字符串 x 和 y ,且满足 s = x + y 。
* 随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即,在执行这一步骤之后,s 可能是 s = x + y 或者 s = y + x 。
* 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。
给你两个 长度相等 的字符串 s1 和 s2,判断 s2 是否是 s1 的扰乱字符串。如果是... | ### 朴素解法(TLE)
一个朴素的做法根据「扰乱字符串」的生成规则进行判断。
由于题目说了整个生成「扰乱字符串」的过程是通过「递归」来进行。
我们要实现 $isScramble$ 函数的作用是判断 $s1$ 是否可以生成出 $s2$。
这样判断的过程,同样我们可以使用「递归」来做:
假设 $s1$ 的长度为 $n$, 的第一次分割的分割点为 $i$,那么 $s1$ 会被分成 $[0, i)$ 和 $[i, n)$ 两部分。
同时由于生成「扰乱字符串」时,可以选交换也可以选不交换。因此我们的 $s2$ 会有两种可能性:
**因为对于某个确定的分割点,$s1$ 固定分为两部分,分别为 $[0,i)$ & $[i, n)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.87` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/88. 合并两个有序数组（简单）.md | 88. 合并两个有序数组 | https://leetcode-cn.com/problems/merge-sorted-array/solution/gong-shui-san-xie-yi-ti-san-jie-shuang-z-47gj/ | 简单 | [
"双指针",
"排序"
] | 给你两个有序整数数组 `nums1` 和 `nums2`,请你将 `nums2` 合并到 `nums1` 中,使 `nums1` 成为一个有序数组。
初始化 `nums1` 和 `nums2` 的元素数量分别为 `m` 和 `n` 。
你可以假设 `nums1` 的空间大小等于 `m + n`,这样它就有足够的空间保存来自 `nums2` 的元素。
示例 1:
```
输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出:[1,2,2,3,5,6]
```
示例 2:
```
输入:nums1 = [1], m = 1, nums2 = [], n = 0
输... | ### 模拟
最简单的做法,我们可以将 $nums2$ 的内容先搬到 $nums1$ 去,再对 $nums1$ 进行排序。
Java 代码:
```Java
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
System.arraycopy(nums2, 0, nums1, m, n);
Arrays.sort(nums1);
}
}
```
C++ 代码:
```C++
class Solution {
public:
void merge(vector<int>& n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.88` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/89. 格雷编码（中等）.md | 89. 格雷编码 | https://leetcode-cn.com/problems/gray-code/solution/gong-shui-san-xie-dui-cheng-xing-gou-zao-9ap1/ | 中等 | [
"模拟"
] | $n$ 位格雷码序列 是一个由 $2^n$ 个整数组成的序列,其中:
* 每个整数都在范围 $[0, 2^n - 1]$ 内(含 $0$ 和 $2^n - 1$)
* 第一个整数是 0
* 一个整数在序列中出现 不超过一次
* 每对 相邻 整数的二进制表示 恰好一位不同 ,且
* 第一个 和 最后一个 整数的二进制表示 恰好一位不同
给你一个整数 `n` ,返回任一有效的 `n` 位格雷码序列 。
示例 1:
```
输入:n = 2
输出:[0,1,3,2]
解释:
[0,1,3,2] 的二进制表示是 [00,01,11,10] 。
- 00 和 01 有一位不同
- 01 和 11 有一位不同
- 11 和 10 有一位... | ### 对称性构造
根据格雷码的定义,我们需要构造一个合法序列,序列之间每两个数的二进制表示中只有一位不同,同时序列第一位和最后一位对应的二进制也只有一位不同。
我们知道 $k + 1$ 位的格雷码序列是 $k$ 位格雷码序列长度的两倍,利用合法 $k$ 位格雷码序列,我们可以「对称性」地构造出 $k + 1$ 位格雷码。
具体的,假定 $k$ 位格雷码序列长度为 $n$,我们将这 $k$ 位的格雷序列进行翻转,并追加到原有序列的尾部,得到长度为 $2 * n$ 的序列,此时新序列的前后两部分均为合法的格雷码。
考虑如何进行解决衔接点的合法性:我们可以对于序列的后半(翻转而来)的部分中的每个数进行「尾部」追加 $1$ 的操作... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.89` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/90. 子集 II（中等）.md | 90. 子集 II | https://leetcode-cn.com/problems/subsets-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hui-s-g77q/ | 中等 | [
"位运算",
"回溯算法",
"状态压缩",
"DFS"
] | 给你一个整数数组 `nums`,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。
解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
示例 1:
```
输入:nums = [1,2,2]
输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]
```
示例 2:
```
输入:nums = [0]
输出:[[],[0]]
```
提示:
* $1 <= nums.length <= 10$
* $-10 <= nums[i] <= 10$ | ### 回溯解法(Set)
由于是求所有的方案,而且数据范围只有 $10$,可以直接用爆搜来做。
同时由于答案中不能包含相同的方案,因此我们可以先对原数组进行排序,从而确保所有爆搜出来的方案,都具有单调性,然后配合 `Set` 进行去重。
代码:
```Java
class Solution {
public List<List<Integer>> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
Set<List<Integer>> ans = new HashSet<>();
List<Integer> cur = new... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.90` 篇,系列开始于 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.