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/811-820/811. 子域名访问计数（中等）.md | 811. 子域名访问计数 | https://leetcode.cn/problems/subdomain-visit-count/solution/by-ac_oier-aex6/ | 中等 | [
"模拟",
"哈希表"
] | 网站域名 `"discuss.leetcode.com"` 由多个子域名组成。顶级域名为 `"com"` ,二级域名为 `"leetcode.com"` ,最低一级为 `"discuss.leetcode.com"` 。
当访问域名 `"discuss.leetcode.com"` 时,同时也会隐式访问其父域名 `"leetcode.com"` 以及 `"com"` 。
计数配对域名 是遵循 `"rep d1.d2.d3"` 或 `"rep d1.d2"` 格式的一个域名表示,其中 `rep` 表示访问域名的次数,`d1.d2.d3` 为域名本身。
例如,`"9001 discuss.leetcode.com"` 就是一个 计... | ### 哈希表
为了方便,我们令 `cpdomains` 为 `ss`。
根据题意进行模拟:使用哈希表记录每个域名的总访问次数,从前往后处理所有的 $ss[i]$。在处理某个 $ss[i]$ 时(记长度为 $n$,使用指针 `idx` 代指扫描到的游标位置),先通过指针扫描找到访问数字部分 `cnt = ss[i][0:idx]`,然后「从后往前」处理 $ss[i]$ 的 $[idx + 1, n - 1]$ 部分,按照域名层级「从小到大」的顺序进行截取,并累加访问次数 `cnt` 到当前域名。
最后根据哈希表构造答案。
Java 代码:
```Java
class Solution {
public List<St... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.811` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/812. 最大三角形面积（简单）.md | 812. 最大三角形面积 | https://leetcode.cn/problems/largest-triangle-area/solution/by-ac_oier-htv8/ | 简单 | [
"模拟"
] | 给定包含多个点的集合,从其中取三个点组成三角形,返回能组成的最大三角形的面积。
示例:
```
输入: points = [[0,0],[0,1],[1,0],[0,2],[2,0]]
输出: 2
解释:
这五个点如下图所示。组成的橙色三角形是最大的,面积为2。
```
注意:
* $3 <= points.length <= 50.$
* 不存在重复的点。
* $-50 <= points[i][j] <= 50$
* 结果误差值在 $10^{-6}$ 以内都认为是正确答案。 | ### 模拟
根据题意模拟即可:枚举三角形三个顶点并计算面积。
代码:
```Java
class Solution {
public double largestTriangleArea(int[][] ps) {
int n = ps.length;
double ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.812` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/813. 最大平均值和的分组（中等）.md | 813. 最大平均值和的分组 | https://leetcode.cn/problems/largest-sum-of-averages/solution/by-ac_oier-yfnt/ | 中等 | [
"序列 DP",
"前缀和",
"动态规划",
"数学"
] | 给定数组 `nums` 和一个整数 `m` 。
我们将给定的数组 `nums` 分成最多 `m` 个相邻的非空子数组,分数由每个子数组内的平均值的总和构成。
注意我们必须使用 `nums` 数组中的每一个数进行分组,并且分数不一定需要是整数。
返回我们所能得到的最大分数是多少。
答案误差在 $10^{-6}$ 内被视为是正确的。
示例 1:
```
输入: nums = [9,1,2,3,9], m = 3
输出: 20.00000
解释:
nums 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) / 3 + 9 = 20.
我们也可以把 nums 分成[9, 1... | ### 前缀和 + 序列 DP
题意可整理为一句话:将 $n$ 个元素划分为「最多」$m$ 个连续段,最大化连续段的平均值之和。
为了方便,我们令所有数组下标从 $1$ 开始。
定义 $f[i][j]$ 为考虑将前 $i$ 个元素划分成 $j$ 份的最大平均和,答案为 $f[n][k]$,其中 $1 \leq k \leq m$。
不失一般性考虑 $f[i][j]$ 该如何计算,由于划分出来的子数组不能是空集,因此我们可以根据 $j$ 的大小分情况讨论:
* 当 $j = 1$,此时有 $f[i][j] = \frac{\sum_{idx = 1}^{i} nums[idx - 1]}{i}$
* 当 $j > 1$,此时... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.813` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/814. 二叉树剪枝（中等）.md | 814. 二叉树剪枝 | https://leetcode.cn/problems/binary-tree-pruning/solution/by-ac_oier-7me9/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给你二叉树的根结点 `root`,此外树的每个结点的值要么是 $0$ ,要么是 $1$ 。
返回移除了所有不包含 $1$ 的子树的原二叉树。
节点 `node` 的子树为 `node` 本身加上所有 `node` 的后代。
示例 1:
```
输入:root = [1,null,0,0,1]
输出:[1,null,0,null,1]
解释:
只有红色节点满足条件“所有不包含 1 的子树”。 右图为返回的答案。
```
示例 2:
```
输入:root = [1,0,1,0,0,0,1]
输出:[1,null,1,null,1]
```
示例 3:
```
输入:root = [1,1,0,1,1,0,1,0]
... | ### 递归
根据题意,我们将原函数 `pruneTree` 作为递归函数,递归函数的含义为「将入参 `root` 中的所有不包含 $1$ 的子树移除,并返回新树头结点」。
不失一般性的考虑任意节点作为入参该如何处理:我们可以递归处理左右子树,并将新左右子树重新赋值给 `root`。由于当前节点 `root` 的左右子树可能为空树,因此我们要增加递归函数入参为空的边界处理。
当递归操作完成后,若左右节点任一值不为空(说明当前节点 `root` 不为叶子节点),我们可以直接返回 `root`,否则根据 `root` 的值是否为 $0$ 来决定返回空树还是 `root` 本身。
Java 代码:
```Java
class So... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.814` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/815. 公交路线（困难）.md | 815. 公交路线 | https://leetcode-cn.com/problems/bus-routes/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-1roh/ | 困难 | [
"图论 BFS",
"双向 BFS",
"图论搜索"
] | 给你一个数组 `routes` ,表示一系列公交线路,其中每个 `routes[i]` 表示一条公交线路,第 `i` 辆公交车将会在上面循环行驶。
* 例如,路线 `routes[0] = [1, 5, 7]` 表示第 0 辆公交车会一直按序列 `1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ...` 这样的车站路线行驶。
现在从 `source` 车站出发(初始时不在公交车上),要前往 `target` 车站。 期间仅可乘坐公交车。
求出 最少乘坐的公交车数量 。如果不可能到达终点车站,返回 `-1` 。
示例 1:
```
输入:routes = [[1,2,7],[3,6,7]], source... | ### 基本分析
为了方便,我们令每个公交站为一个「车站」,由一个「车站」可以进入一条或多条「路线」。
问题为从「起点车站」到「终点车站」,所进入的最少路线为多少。
抽象每个「路线」为一个点,当不同「路线」之间存在「公共车站」则为其增加一条边权为 $1$ 的无向边。
---
### 单向 BFS
由于是在边权为 $1$ 的图上求最短路,我们直接使用 `BFS` 即可。
起始时将「起点车站」所能进入的「路线」进行入队,每次从队列中取出「路线」时,查看该路线是否包含「终点车站」:
* 包含「终点车站」:返回进入该线路所花费的距离
* 不包含「终点车站」:遍历该路线所包含的车站,将由这些车站所能进入的路线,进行入队
一些... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.815` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/816. 模糊坐标（中等）.md | 816. 模糊坐标 | https://leetcode.cn/problems/ambiguous-coordinates/solution/by-ac_oier-sbxl/ | 中等 | [
"枚举",
"模拟"
] | 我们有一些二维坐标,如 `"(1, 3)"` 或 `"(2, 0.5)"`,然后我们移除所有逗号,小数点和空格,得到一个字符串 `S`。返回所有可能的原始字符串到一个列表中。
原始的坐标表示法不会存在多余的零,所以不会出现类似于 `"00", "0.0", "0.00", "1.0", "001", "00.01"` 或一些其他更小的数来表示坐标。
此外,一个小数点前至少存在一个数,所以也不会出现 `“.1”` 形式的数字。
最后返回的列表可以是任意顺序的。而且注意返回的两个数字中间(逗号之后)都有一个空格。
示例 1:
```
输入: "(123)"
输出: ["(1, 23)", "(12, 3)", "(1.2, 3... | ### 枚举
我们先将原字符串 `s` 中的左右括号去掉,重新定义 `s` 为原字符串 $s[1...(n - 2)]$,重新定义后的 `s` 长度为 `n`。
随后枚举逗号的位置 `idx`,枚举范围为 $[0, n - 1)$,含义为在 $s[idx]$ 后面追加逗号。
此时左边部分字符串为 $s[0, idx]$,右边部分字符串为 $s[idx + 1, n - 1]$。
实现一个搜索函数 `List<String> search(int start, int end)`,该函数返回使用字符串 $s[start...end]$ 构造的具体数值集合。
假设左边字符串 $s[0, idx]$ 搜索结果为 `A`,右边字符... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.816` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/817. 链表组件（中等）.md | 817. 链表组件 | https://leetcode.cn/problems/linked-list-components/solution/by-ac_oier-3gl5/ | 中等 | [
"链表",
"模拟",
"哈希表"
] | 给定链表头结点 `head`,该链表上的每个结点都有一个 唯一的整型值 。同时给定列表 `nums`,该列表是上述链表中整型值的一个子集。
返回列表 `nums` 中组件的个数,这里对组件的定义为:链表中一段最长连续结点的值(该值必须在列表 `nums` 中)构成的集合。
示例 1:
```
输入: head = [0,1,2,3], nums = [0,1,3]
输出: 2
解释: 链表中,0 和 1 是相连接的,且 nums 中不包含 2,所以 [0, 1] 是 nums 的一个组件,同理 [3] 也是一个组件,故返回 2。
```
示例 2:
```
输入: head = [0,1,2,3,4], nums = ... | ### 模拟
根据题意进行模拟即可 : 为了方便判断某个 $node.val$ 是否存在于 `nums` 中,我们先使用 `Set` 结构对所有的 $nums[i]$ 进行转存,随后每次检查连续段(组件)的个数。
Java 代码:
```Java
class Solution {
public int numComponents(ListNode head, int[] nums) {
int ans = 0;
Set<Integer> set = new HashSet<>();
for (int x : nums) set.add(x);
while (... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.817` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/819. 最常见的单词（简单）.md | 819. 最常见的单词 | https://leetcode-cn.com/problems/most-common-word/solution/by-ac_oier-6aqd/ | 简单 | [
"模拟",
"哈希表"
] | 给定一个段落 (`paragraph`) 和一个禁用单词列表 (`banned`)。返回出现次数最多,同时不在禁用列表中的单词。
题目保证至少有一个词不在禁用列表中,而且答案唯一。
禁用列表中的单词用小写字母表示,不含标点符号。段落中的单词不区分大小写。答案都是小写字母。
示例:
```
输入:
paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
banned = ["hit"]
输出: "ball"
解释:
"hit" 出现了3次,但它是一个禁用的单词。
"ball" 出现了2次 (同时没有其他单词出现2次),所以它是段落里出现次... | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public String mostCommonWord(String s, String[] banned) {
Set<String> set = new HashSet<>();
for (String b : banned) set.add(b);
char[] cs = s.toCharArray();
int n = cs.length;
String ans = null;
Map<String, Integer> m... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.819` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/821. 字符的最短距离（简单）.md | 821. 字符的最短距离 | https://leetcode-cn.com/problems/shortest-distance-to-a-character/solution/by-ac_oier-5bjs/ | 简单 | [
"模拟",
"BFS"
] | 给你一个字符串 `s` 和一个字符 `c` ,且 `c` 是 `s` 中出现过的字符。
返回一个整数数组 `answer`,其中 $answer.length == s.length$ 且 $answer[i]$ 是 `s` 中从下标 $i$ 到离它 最近 的字符 `c` 的 距离 。
两个下标 $i$ 和 $j$ 之间的 距离 为 `abs(i - j)` ,其中 `abs` 是绝对值函数。
示例 1:
```
输入:s = "loveleetcode", c = "e"
输出:[3,2,1,0,1,0,0,1,2,2,1,0]
解释:字符 'e' 出现在下标 3、5、6 和 11 处(下标从 0 开始计数)。
距下标 ... | ### 遍历
根据题意进行模拟即可:两次遍历,第一次找到每个 $i$ 左边最近的 `c`,第二次找到每个 $i$ 右边最近的 `c`。
代码:
```Java
class Solution {
public int[] shortestToChar(String s, char c) {
int n = s.length();
int[] ans = new int[n];
Arrays.fill(ans, n + 1);
for (int i = 0, j = -1; i < n; i++) {
if (s.charAt(i) ==... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.821` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/824. 山羊拉丁文（简单）.md | 824. 山羊拉丁文 | https://leetcode-cn.com/problems/goat-latin/solution/by-ac_oier-t7hj/ | 简单 | [
"模拟"
] | 给你一个由若干单词组成的句子 `sentence`,单词间由空格分隔。每个单词仅由大写和小写英文字母组成。
请你将句子转换为 “山羊拉丁文(`Goat Latin`)”(一种类似于 猪拉丁文 - Pig Latin 的虚构语言)。山羊拉丁文的规则如下:
* 如果单词以元音开头(`'a'`, `'e'`, `'i'`, `'o'`, `'u'`),在单词后添加`"ma"`。
* 例如,单词 `"apple"` 变为 `"applema"` 。
* 如果单词以辅音字母开头(即,非元音字母),移除第一个字符并将它放到末尾,之后再添加`"ma"`。
* 例如,单词 `"goat"` 变为 `"oatgma"` 。
* 根据单词在句子... | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public String toGoatLatin(String s) {
int n = s.length();
String last = "a";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ) {
int j = i;
while (j < n && s.charAt(j) != ' ') j++;
i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.824` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/825. 适龄的朋友（中等）.md | 825. 适龄的朋友 | https://leetcode-cn.com/problems/friends-of-appropriate-ages/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-maa8/ | 中等 | [
"排序",
"双指针",
"桶排序",
"前缀和"
] | 在社交媒体网站上有 $n$ 个用户。给你一个整数数组 `ages` ,其中 $ages[i]$ 是第 $i$ 个用户的年龄。
如果下述任意一个条件为真,那么用户 $x$ 将不会向用户 $y$(`x != y`)发送好友请求:
* $age[y] <= 0.5 * age[x] + 7$
* $age[y] > age[x]$
* $age[y] > 100$ 且 $age[x] < 100$
否则,$x$ 将会向 $y$ 发送一条好友请求。
注意,如果 $x$ 向 $y$ 发送一条好友请求,$y$ 不必也向 $x$ 发送一条好友请求。另外,用户不会向自己发送好友请求。
返回在该社交媒体网站上产生的好友请求总数。
示例 1... | ### 排序 + 双指针
从三个不发送好友请求的条件来看,以 $y$ 的角度来说,可总结为:**年龄比我小的不考虑(同龄的可以),年龄比我大可以考虑,但是不能超过一定范围则不考虑。**
即对于一个确定的 $y$ 而言,会发送好友请求的 $x$ 范围为连续段:
**随着 $y$ 的逐渐增大,对应的 $x$ 连续段的左右边界均逐渐增大(数轴上均往右移动)。**
因此,我们可以先对 $ages$ 进行排序,枚举每个 $y = ages[k]$,同时使用 $i$ 和 $j$ 维护左右区间,$[i, j)$ 代表在 $ages$ 上会往 $y = ages[k]$ 发送请求的 $x$ 连续段,统计每个 $y = ages[k]$ 的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.825` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/827. 最大人工岛（困难）.md | 827. 最大人工岛 | https://leetcode.cn/problems/making-a-large-island/solution/by-ac_oier-1kmp/ | 困难 | [
"并查集",
"枚举"
] | 给你一个大小为 `n x n` 二进制矩阵 `grid` 。最多 只能将一格 `0` 变成 `1` 。
返回执行此操作后,`grid` 中最大的岛屿面积是多少?
岛屿 由一组上、下、左、右四个方向相连的 `1` 形成。
示例 1:
```
输入: grid = [[1, 0], [0, 1]]
输出: 3
解释: 将一格0变成1,最终连通两个小岛得到面积为 3 的岛屿。
```
示例 2:
```
输入: grid = [[1, 1], [1, 0]]
输出: 4
解释: 将一格0变成1,岛屿的面积扩大为 4。
```
示例 3:
```
输入: grid = [[1, 1], [1, 1]]
输出: 4
解释: ... | ### 并查集 + 枚举
为了方便,我们令 `grid` 为 `g`。
根据题意,容易想到通过「并查集」来维护所有连通块大小,再通过「枚举」来找最优翻转点。
具体的,我们可以先使用「并查集」维护所有 $g[i][j] = 1$ 的块连通性,并在维护连通性的过程中,使用 `sz[idx]` 记录下每个连通块的大小(注意:只有连通块根编号,`sz[idx]` 才有意义,即只有 `sz[find(x)]` 才有意义)。
随后我们再次遍历 `g`,根据原始的 $g[i][j]$ 的值进行分别处理:
* 若 $g[i][j] = 1$,该位置不会作为翻转点,但真实最大面积未必是由翻转后所导致的(可能取自原有的连通块),因此我们需要将... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.827` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/828. 统计子串中的唯一字符（困难）.md | 828. 统计子串中的唯一字符 | https://leetcode.cn/problems/count-unique-characters-of-all-substrings-of-a-given-string/solution/by-ac_oier-922k/ | 困难 | [
"模拟",
"数学",
"线性 DP"
] | 我们定义了一个函数 `countUniqueChars(s)` 来统计字符串 `s` 中的唯一字符,并返回唯一字符的个数。
例如:`s = "LEETCODE"` ,则其中 `"L"`, `"T"`,`"C"`,`"O"`,`"D"` 都是唯一字符,因为它们只出现一次,所以 `countUniqueChars(s) = 5`。
本题将会给你一个字符串 `s` ,我们需要返回 `countUniqueChars(t)` 的总和,其中 `t` 是 `s` 的子字符串。
输入用例保证返回值为 `32` 位整数。
注意,某些子字符串可能是重复的,但你统计时也必须算上这些重复的子字符串(也就是说,你必须统计 `s` 的所有子字符串中的... | ### 模拟 + 乘法原理
这道题和 [907. 子数组的最小值之和](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493485&idx=1&sn=c6d6ac25c171e2617c5a95173aa58825) 如出一辙,只不过无须考虑运用「单调栈」。
原问题为求所有子数组的唯一字符数量和,其可等价为求每个 $s[i]$ 对答案的贡献,即每个 $s[i]$ 可作为多少个子数组的唯一元素。
假定我们能预处理出两数组 `l` 和 `r` 分别代表 $s[i]$ 作为子数组唯一字符时,其所能到达的最远两端:
* `l[i] = a` 代表下标 $a$ 为 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.828` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/829. 连续整数求和（困难）.md | 829. 连续整数求和 | https://leetcode.cn/problems/consecutive-numbers-sum/solution/by-ac_oier-220q/ | 困难 | [
"数论",
"数学"
] | 给定一个正整数 $n$,返回连续正整数满足所有数字之和为 $n$ 的组数 。
示例 1:
```
输入: n = 5
输出: 2
解释: 5 = 2 + 3,共有两组连续整数([5],[2,3])求和后为 5。
```
示例 2:
```
输入: n = 9
输出: 3
解释: 9 = 4 + 5 = 2 + 3 + 4
```
示例 3:
```
输入: n = 15
输出: 4
解释: 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5
```
提示:
* $1 <= n <= 10^9$ | ### 数论
假设我们存在某个连续段之和为 $n$,假定该连续段首项为 $a$,长度为 $k$,根据「等差数列求和」可知:
$$
\frac{(a + a + k - 1) \times k}{2} = n
$$
简单变形可得:
$$
(2a + k - 1) \times k = 2n \Leftrightarrow 2a = \frac{2n}{k} - k + 1
$$
根据首项 $a$ 和 $k$ 均为正整数,可得:
$$
2a = \frac{2n}{k} - k + 1 \geq 2
$$
进一步可得:
$$
\frac{2n}{k} \geq k + 1 \Leftrightarrow \frac{2n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.829` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/831-840/832. 翻转图像（简单）.md | 832. 翻转图像 | https://leetcode-cn.com/problems/flipping-an-image/solution/shuang-zhi-zhen-yi-bian-chu-li-huan-you-ik0v1/ | 简单 | [
"双指针"
] | 给定一个二进制矩阵 A,我们想先水平翻转图像,然后反转图像并返回结果。
水平翻转图片就是将图片的每一行都进行翻转,即逆序。例如,水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。
反转图片的意思是图片中的 0 全部被 1 替换, 1 全部被 0 替换。例如,反转 [0, 1, 1] 的结果是 [1, 0, 0]。
示例 1:
```
输入:[[1,1,0],[1,0,1],[0,0,0]]
输出:[[1,0,0],[0,1,0],[1,1,1]]
解释:首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]];
然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]
```
示例 2... | ### 双指针代码
对于每行而言,我们都需要对其进行「翻转」和「反转」。
这两步可以到放到一遍循环里做:
* 翻转部分:使用双指针进行数字交换
* 反转部分:将数字存储进目标位置前,使用「异或」对 0 1 进行翻转
当前有一些「小细节」需要注意:
1. 题目要求我们对参数图像进行翻转,并返回新图像。因此我们不能对输入直接进行修改,而要先进行拷贝再处理
2. 由于我们将「翻转」和「反转」合成了一步,因此对于「奇数」图像,需要对中间一列进行特殊处理:仅「反转」
对于 Java 的基本类型拷贝,有三种方式进行拷贝:
1. System.arraycopy() : 底层的数组拷贝接口,具体实现与操作系统相关,调用的是系统本地方法。需... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.832` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/831-840/834. 树中距离之和（困难）.md | 834. 树中距离之和 | https://leetcode.cn/problems/sum-of-distances-in-tree/solutions/2449965/gong-shui-san-xie-shu-xing-dp-chang-gui-1v7ud/ | 困难 | [
"树形 DP",
"DFS",
"动态规划",
"树"
] | 给定一个无向、连通的树。
树中有 `n` 个标记为 `0...n-1` 的节点以及 `n-1` 条边 。
给定整数 `n` 和数组 `edges`, $edges[i] = [a_{i}, b_{i}]$表示树中的节点 $a_{i}$ 和 $b_{i}$ 之间有一条边。
返回长度为 `n` 的数组 `answer`,其中 `answer[i]` 是树中第 `i` 个节点与所有其他节点之间的距离之和。
示例 1:
```
输入: n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
输出: [8,12,6,10,10,10]
解释: 树如图所示。
我们可以计算出 dist(0,1)... | ### 树形 DP
**对于树形 DP,可以随便以某个节点为根,把整棵树“拎起来”进行分析,通常还会以“方向”作为切入点进行思考。**
不妨以编号为 `0` 的节点作为根节点进行分析:假设当前处理到的节点为 `u`,当前节点 `u` 的父节点为 `fa`,同时 `u` 有若干子节点 `j`。
对于任意节点 `u` 而言,其树中距离之和可根据「方向/位置」分为两大类(对应示例图的左右两部分):
* 所有从节点 `u` “往下”延伸所达的节点距离之和,即所有经过 `u -> j` 边所能访问到的节点距离之和
* 所有从节点 `u` “往上”延伸所达的节点距离之和,即经过 `u -> fa` 边所能访问到的节点距离之和
假设我们... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.834` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/831-840/838. 推多米诺（中等）.md | 838. 推多米诺 | https://leetcode-cn.com/problems/push-dominoes/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-y-z52w/ | 中等 | [
"BFS",
"双指针"
] | `n` 张多米诺骨牌排成一行,将每张多米诺骨牌垂直竖立。在开始时,同时把一些多米诺骨牌向左或向右推。
每过一秒,倒向左边的多米诺骨牌会推动其左侧相邻的多米诺骨牌。同样地,倒向右边的多米诺骨牌也会推动竖立在其右侧的相邻多米诺骨牌。
如果一张垂直竖立的多米诺骨牌的两侧同时有多米诺骨牌倒下时,由于受力平衡, 该骨牌仍然保持不变。
就这个问题而言,我们会认为一张正在倒下的多米诺骨牌不会对其它正在倒下或已经倒下的多米诺骨牌施加额外的力。
给你一个字符串 `dominoes` 表示这一行多米诺骨牌的初始状态,其中:
* `dominoes[i] = 'L'`,表示第 `i` 张多米诺骨牌被推向左侧,
* `dominoes[i] = ... | ### BFS
推倒骨牌是一个行为传递的过程,可以使用 `BFS` 来进行模拟。
起始将所有不为 `.` 的骨牌以 $(loc, time, dire)$ 三元组的形式进行入队,三元组所代表的含义为「**位置为 $loc$ 的骨牌在 $time$ 时刻受到一个方向为 $dire$ 的力**」,然后进行常规的 `BFS` 即可。
在受力(入队)时,我们尝试修改骨牌的状态,同时为了解决「一个骨牌同时受到左右推力时,维持站立状态不变」的问题,我们需要在尝试修改骨牌状态后,额外记录下该骨牌的状态修改时间,如果在同一时间内,一块骨牌受力两次(只能是来自左右两个方向的力),需要将该骨牌恢复成竖立状态。
代码:
```Java
class... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.838` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/841-850/846. 一手顺子（中等）.md | 846. 一手顺子 | https://leetcode-cn.com/problems/hand-of-straights/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-4hxw/ | 中等 | [
"模拟",
"优先队列(堆)",
"哈希表"
] | Alice 手中有一把牌,她想要重新排列这些牌,分成若干组,使每一组的牌数都是 groupSize ,并且由 groupSize 张连续的牌组成。
给你一个整数数组 `hand` 其中 `hand[i]` 是写在第 `i` 张牌,和一个整数 `groupSize`。
如果她可能重新排列这些牌,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
输出:true
解释:Alice 手中的牌可以被重新排列为 [1,2,3],[2,3,4],[6,7,8]。
```
示例 2:
```
输入:hand = [1,2,3,... | ### 模拟 + 哈希表 + 优先队列(堆)
为了方便,我们令 $m = groupSize$。
题目要求我们将 $hand$ 分为若干份大小为 $m$ 的顺子。
**在给定 $hand$ 的情况下,划分方式唯一确定,因此本质上这是一个「模拟」的过程。**
具体的,我们可以使用「哈希表」对 $hand$ 中的数值进行「出现次数」统计,并用于后续 **实时** 维护剩余元素的出现次数。
然后使用优先队列维护(小根堆)所有的 $hand[i]$。每次从优先队列(堆)中取出堆顶元素 $t$ 来 **尝试作为**「顺子」的发起点/首个元素(当然 $t$ 能够作为发起点的前提是 $t$ 仍是剩余元素,即实时维护的出现次数不为 $0$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.846` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/841-850/847. 访问所有节点的最短路径（困难）.md | 847. 访问所有节点的最短路径 | https://leetcode-cn.com/problems/shortest-path-visiting-all-nodes/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-z-6p2k/ | 困难 | [
"图",
"图论 BFS",
"动态规划",
"状态压缩",
"AStar 算法",
"启发式搜索"
] | 存在一个由 $n$ 个节点组成的无向连通图,图中的节点按从 $0$ 到 $n - 1$ 编号。
给你一个数组 `graph` 表示这个图。其中,$graph[i]$ 是一个列表,由所有与节点 $i$ 直接相连的节点组成。
返回能够访问所有节点的最短路径的长度。你可以在任一节点开始和停止,也可以多次重访节点,并且可以重用边。
示例 1:
```
输入:graph = [[1,2,3],[0],[0],[0]]
输出:4
解释:一种可能的路径为 [1,0,2,0,3]
```
示例 2:
```
输入:graph = [[1],[0,2,4],[1,3,4],[2],[1,2]]
输出:4
解释:一种可能的路径为 [0... | ### 基本分析
为了方便,令点的数量为 $n$,边的数量为 $m$。
这是一个等权无向图,题目要我们求从「**一个点都没访问过**」到「**所有点都被访问**」的最短路径。
同时 $n$ 只有 $12$,容易想到使用「状态压缩」来代表「当前点的访问状态」:**使用二进制表示长度为 $32$ 的 `int` 的低 $12$ 来代指点是否被访问过。**
我们可以通过一个具体的样例,来感受下「状态压缩」是什么意思:
例如 $(000...0101)_2$ 代表编号为 $0$ 和编号为 $2$ 的节点已经被访问过,而编号为 $1$ 的节点尚未被访问。
然后再来看看使用「状态压缩」的话,一些基本的操作该如何进行:
假设变量 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.847` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/841-850/850. 矩形面积 II（困难）.md | 850. 矩形面积 II | https://leetcode.cn/problems/rectangle-area-ii/solution/gong-shui-san-xie-by-ac_oier-9r36/ | 困难 | [
"扫描线"
] | 我们给出了一个(轴对齐的)二维矩形列表 `rectangles`。 对于 $rectangle[i] = [x_1, y_1, x_2, y_2]$,其中$(x_1, y_1)$ 是矩形 `i` 左下角的坐标,$ (x_{i1}, y_{i1})$ 是该矩形 左下角 的坐标,$ (x_{i2}, y_{i2})$ 是该矩形 右上角 的坐标。
计算平面中所有 `rectangles` 所覆盖的 总面积 。任何被两个或多个矩形覆盖的区域应只计算 一次 。
返回 总面积 。因为答案可能太大,返回 $10^9 + 7$ 的 模 。
示例 1:
```
输入:rectangles = [[0,0,2,2],[1,0,2,3],[1,0... | ### 扫描线
这是一道「扫描线」模板题。
将所有给定的矩形的左右边对应的 `x` 端点提取出来并排序,每个端点可看作是一条竖直的线段(红色),问题转换为求解「由多条竖直线段分割开」的多个矩形的面积总和(黄色):
相邻线段之间的宽度为单个矩形的「宽度」(通过 `x` 差值直接算得),问题转换为求该区间内高度的并集(即矩形的高度)。
由于数据范围只有 $200$,我们可以对给定的所有矩形进行遍历,统计所有对该矩形有贡献的 `y` 值线段(即有哪些 `rs[i]` 落在该矩形中),再对线段进行求交集(总长度),即可计算出该矩形的「高度」,从而计算出来该矩形的面积。
Java 代码:
```Java
class Solution... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.850` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/851. 喧闹和富有（中等）.md | 851. 喧闹和富有 | https://leetcode-cn.com/problems/loud-and-rich/solution/gong-shui-san-xie-tuo-bu-pai-xu-yun-yong-ylih/ | 中等 | [
"拓扑排序"
] | 有一组 `n` 个人作为实验对象,从 `0` 到 `n - 1` 编号,其中每个人都有不同数目的钱,以及不同程度的安静值(`quietness`)。为了方便起见,我们将编号为 `x` 的人简称为 `"person x"`。
给你一个数组 `richer` ,其中 `richer[i] = [ai, bi]` 表示 $person$ $a_i$ 比 $person$ $b_i$ 更有钱。另给你一个整数数组 `quiet`,其中 `quiet[i]` 是 $person_i$ 的安静值。
`richer` 中所给出的数据 逻辑自恰(也就是说,在 $person_x$ 比 $person_y$ 更有钱的同时,不会出现 $person_... | ### 拓扑排序
根据题意,我们可以使用 `richer` 进行建图(邻接矩阵/邻接表),对于每组 $richer[i] = (a_i, b_i)$ 而言,添加一条从 $a$ 到 $b$ 的有向边(有钱指向没钱)。
其中题目中的「`richer` 逻辑自恰」是指在该图中不存在环,即为 DAG。
因此我们可以在建图过程中,同时统计每个节点的入度数,然后在图中跑一遍拓扑排序来求得答案 $ans$。
**对「图论 拓扑排序」不了解的同学,可以先看前置 🧀:[拓扑排序入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489706&idx=1&sn=771cd... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.851` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/852. 山脉数组的峰顶索引（简单）.md | 852. 山脉数组的峰顶索引 | https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/solution/gong-shui-san-xie-er-fen-san-fen-cha-zhi-5gfv/ | 简单 | [
"二分",
"三分"
] | 符合下列属性的数组 `arr` 称为 山脉数组 :
* `arr.length >= 3`
* 存在 `i(0 < i < arr.length - 1)` 使得:
* `arr[0] < arr[1] < ... arr[i-1] < arr[i]`
* `arr[i] > arr[i+1] > ... > arr[arr.length - 1]`
给你由整数组成的山脉数组 `arr` ,返回任何满足 `arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1]` 的下标 `i` 。
示例 1:
```
输入:ar... | ### 二分
往常我们使用「二分」进行查值,需要确保序列本身满足「二段性」:当选定一个端点(基准值)后,结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。
但本题求的是峰顶索引值,如果我们选定数组头部或者尾部元素,其实无法根据大小关系“直接”将数组分成两段。
但可以利用题目发现如下性质:**由于 `arr` 数值各不相同,因此峰顶元素左侧必然满足严格单调递增,峰顶元素右侧必然不满足。**
因此 **以峰顶元素为分割点的 `arr` 数组,根据与 前一元素/后一元素 的大小关系,具有二段性:**
* 峰顶元素左侧满足 $arr[i-1] < arr[i]$ 性质,右侧不满足
* 峰顶元素右侧满足 $arr[i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.852` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/854. 相似度为 K 的字符串（困难）.md | 854. 相似度为 K 的字符串 | https://leetcode.cn/problems/k-similar-strings/solution/by-ac_oier-w8nf/ | 困难 | [
"启发式搜索",
"AStar 算法"
] | 对于某些非负整数 `k` ,如果交换 $s_1$ 中两个字母的位置恰好 `k` 次,能够使结果字符串等于 $s_2$ ,则认为字符串 $s_1$ 和 $s_2$ 的 相似度为 `k` 。
给你两个字母异位词 $s_1$ 和 $s_2$ ,返回 $s_1$ 和 $s_2$ 的相似度 `k` 的最小值。
示例 1:
```
输入:s1 = "ab", s2 = "ba"
输出:1
```
示例 2:
```
输入:s1 = "abc", s2 = "bca"
输出:2
```
提示:
* $1 <= s1.length <= 20$
* $s2.length = s1.length$
* `s1` 和 `s2` 只包含集合 ... | ### AStar 算法
由于题目确保了 `s1` 和 `s2` 互为字母异位词(必然有解),因此最好的求解方式是使用 AStar 算法。
可直接根据本题规则来设计 AStar 的启发式函数: 对于两个状态 `a` 和 `b` 直接计算出「理论最小转换次数」: **不同字符串的转换成本之和,由于每一次交换最多可减少两个不同的字符,我们可计算 `a` 与 `b` 的不同字符数量 $ans$,对应的理论最小转换次数为 $\left \lfloor \frac{ans + 1}{2} \right \rfloor$。**
需要注意的是:**由于我们衡量某个字符 `str` 的估值是以目标字符串 `target` 为基准,因此我们只能... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.854` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/856. 括号的分数（中等）.md | 856. 括号的分数 | https://leetcode.cn/problems/score-of-parentheses/solution/by-ac_oier-0mhz/ | 中等 | [
"栈"
] | 给定一个平衡括号字符串 `S`,按下述规则计算该字符串的分数:
* `()` 得 `1` 分。
* `AB` 得 `A + B` 分,其中 `A` 和 `B` 是平衡括号字符串。
* `(A)` 得 `2 * A` 分,其中 `A` 是平衡括号字符串。
示例 1:
```
输入: "()"
输出: 1
```
示例 2:
```
输入: "(())"
输出: 2
```
示例 3:
```
输入: "()()"
输出: 2
```
示例 4:
```
输入: "(()(()))"
输出: 6
```
提示:
* `S` 是平衡括号字符串,且只含有 `(` 和 `)` 。
* $2 <= S.length <= 50$ | ### 栈
初始化将答案 `0` 放入栈中,从前往后处理整个 `s`,当遇到 `(` 则存入一个占位数值 `0`,遇到 `)` 取出栈顶元素 `cur`,根据栈顶元素数值值分情况讨论:
* 栈顶元素 $cur = 0$,即当前的 `)` 的前一元素即是 `(` ,根据 `()` 得一分的规则可知,我们本次操作得到的分值为 $1$;
* 栈顶元素 $cur \neq 0$,即当前 `)` 与其匹配的 `(` 中间相隔了其他字符,根据 `(A)` 的得分规则,此时可知得分为 $cur \times 2$;
将两者结合可统一为 $\max(cur \times 2, 1)$。
由于我们每次遇到 `)` 时,都将最近一次操作计算出来... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.856` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/857. 雇佣 K 名工人的最低成本（困难）.md | 857. 雇佣 K 名工人的最低成本 | https://leetcode.cn/problems/minimum-cost-to-hire-k-workers/solution/by-ac_oier-u42f/ | 困难 | [
"枚举",
"优先队列(堆)"
] | 有 `n` 名工人。 给定两个数组 `quality` 和 `wage` ,其中,`quality[i]` 表示第 `i` 名工人的工作质量,其最低期望工资为 `wage[i]` 。
现在我们想雇佣 `k` 名工人组成一个工资组。在雇佣 一组 `k` 名工人时,我们必须按照下述规则向他们支付工资:
* 对工资组中的每名工人,应当按其工作质量与同组其他工人的工作质量的比例来支付工资。
* 工资组中的每名工人至少应当得到他们的最低期望工资。
给定整数 `k`,返回 组成满足上述条件的付费群体所需的最小金额 。在实际答案的 $10^{-5}$ 以内的答案将被接受。。
示例 1:
```
输入: quality = [10,20,5... | ### 枚举 + 优先队列(堆)
为了方便,我们令 `quality` 为 `qs`,`wage` 为 `ws`。
从 $n$ 个工人中选 $k$ 个,使这 $k$ 个工人实际工资与其 $qs[i]$ 成比例,且实际工资不低于 $ws[i]$。
根据条件一,假设实际工资与能力值比值为 $t$,则所选工人的实际工资为 $qs[i] \times t$,再结合条件二可知 $qs[i] \times t >= ws[i]$,变形可得 $t >= \frac{ws[i]}{qs[i]}$。
那么在选定若干工人的情况下,为使得总支出最小,我们可以取 $t$ 为所有被选工人中的最大 $\frac{ws[i]}{qs[i]}$ 即可。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.857` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/859. 亲密字符串（简单）.md | 859. 亲密字符串 | https://leetcode-cn.com/problems/buddy-strings/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-q056/ | 简单 | [
"模拟"
] | 给你两个字符串 `s` 和 `goal` ,只要我们可以通过交换 `s` 中的两个字母得到与 `goal` 相等的结果,就返回 `true` ;否则返回 `false` 。
交换字母的定义是:取两个下标 `i` 和 `j` (下标从 $0$ 开始)且满足 `i != j` ,接着交换 `s[i]` 和 `s[j]` 处的字符。
* 例如,在 `"abcd"` 中交换下标 `0` 和下标 `2` 的元素可以生成 `"cbad"` 。
示例 1:
```
输入:s = "ab", goal = "ba"
输出:true
解释:你可以交换 s[0] = 'a' 和 s[1] = 'b' 生成 "ba",此时 s 和 goal 相... | ### 模拟
根据题意进行模拟即可,搞清楚什么情况下两者为「亲密字符」:
1. 当 $s$ 与 $goal$ 长度 或 词频不同,必然不为亲密字符;
2. 当「$s$ 与 $goal$ 不同的字符数量为 $2$(能够相互交换)」或「$s$ 与 $goal$ 不同的字符数量为 $0$,但同时 $s$ 中有出现数量超过 $2$ 的字符(能够相互交换)」时,两者必然为亲密字符。
代码:
```Java
class Solution {
public boolean buddyStrings(String s, String goal) {
int n = s.length(), m = goal.length... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.859` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/862. 和至少为 K 的最短子数组（困难）.md | 862. 和至少为 K 的最短子数组 | https://leetcode.cn/problems/shortest-subarray-with-sum-at-least-k/solution/by-ac_oier-es0s/ | 困难 | [
"前缀和",
"离散化",
"二分",
"树状数组"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,找出 `nums` 中和至少为 `k` 的 最短非空子数组 ,并返回该子数组的长度。如果不存在这样的子数组,返回 `-1` 。
子数组是数组中连续 的一部分。
示例 1:
```
输入:nums = [1], k = 1
输出:1
```
示例 2:
```
输入:nums = [1,2], k = 4
输出:-1
```
示例 3:
```
输入:nums = [2,-1,2], k = 3
输出:3
```
提示:
* $1 <= nums.length <= 10^5$
* $-10^5 <= nums[i] <= 10^5$
* $1 <= k <= 10^9... | ### 前缀和 + 离散化 + 权值树状数组
由于求解的对象是子数组,容易联想到求连续段之和,容易联想到「前缀和」,假设我们预处理出的前缀和数组为 $sum$(为了方便,我们令前缀和数组坐标从 $1$ 开始)。
即每个 $nums[i]$ 而言,本质上是找满足「$sum[i] - sum[j] \geqslant k$」条件的最大下标 $j$,其中 $j$ 的取值范围为 $[0, i - 1]$,从而知道以 $i$ 作为右端点时,满足条件的最短子数组长度为 $i - j$。
先考虑存在负数域的问题,由于我们需要使用 $sum[X]$,以及对应的 $sum[X] + k$,同时 $k$ 的取值为 $1e9$(过大),我们可以通过... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.862` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/863. 二叉树中所有距离为 K 的结点（中等）.md | 863. 二叉树中所有距离为 K 的结点 | https://leetcode-cn.com/problems/all-nodes-distance-k-in-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-x6hak/ | 中等 | [
"图论 BFS",
"图论 DFS",
"二叉树"
] | 给定一个二叉树(具有根结点 root), 一个目标结点 target ,和一个整数值 K 。
返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。
示例 1:
```
输入:root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, K = 2
输出:[7,4,1]
解释:
所求结点为与目标结点(值为 5)距离为 2 的结点,
值分别为 7,4,以及 1
```
注意,输入的 "root" 和 "target" 实际上是树上的结点。
上面的输入仅仅是对这些对象进行了序列化描述。
提示:
* 给定的树是非空的。
* 树上的每个结点都具有唯一的值 ... | ### 基本分析
显然,如果题目是以图的形式给出的话,我们可以很容易通过「`BFS` / 迭代加深」找到距离为 $k$ 的节点集。
而树是一类特殊的图,我们可以通过将二叉树转换为图的形式,再进行「`BFS` / 迭代加深」。
由于二叉树每个点最多有 $2$ 个子节点,点和边的数量接近,属于稀疏图,因此我们可以使用「邻接表」的形式进行存储。
建图方式为:对于二叉树中相互连通的节点(`root` 与 `root.left`、`root` 和 `root.right`),建立一条无向边。
建图需要遍历整棵树,使用 `DFS` 或者 `BFS` 均可。
由于所有边的权重均为 $1$,我们可以使用 「`BFS` / 迭代加深」 找... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.863` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/864. 获取所有钥匙的最短路径（困难）.md | 864. 获取所有钥匙的最短路径 | https://leetcode.cn/problems/shortest-path-to-get-all-keys/solution/by-ac_oier-5gxc/ | 困难 | [
"BFS",
"状态压缩"
] | 给定一个二维网格 `g`,其中:
* `'.'` 代表一个空房间
* `'#'` 代表一堵墙
* `'@'` 是起点
* 小写字母代表钥匙
* 大写字母代表锁
我们从起点开始出发,一次移动是指向四个基本方向之一行走一个单位空间。
我们不能在网格外面行走,也无法穿过一堵墙。
如果途经一个钥匙,我们就把它捡起来,除非我们手里有对应的钥匙,否则无法通过锁。
假设 `k` 为 钥匙/锁 的个数,且满足 $1 <= k <= 6$,字母表中的前 `k` 个字母在网格中都有自己对应的一个小写和一个大写字母。
换言之,每个锁有唯一对应的钥匙,每个钥匙也有唯一对应的锁。另外,代表钥匙和锁的字母互为大小写并按字母顺序排列。
返回获取所有... | ### BFS + 状态压缩
**一道常规的 `BFS` 运用题,只不过需要在 `BFS` 过程中记录收集到的钥匙状态。**
利用「钥匙数量不超过 $6$,并按字母顺序排列」,我们可以使用一个 `int` 类型二进制数 `state` 来代指当前收集到钥匙情况:
* 若 `state` 的二进制中的第 $k$ 位为 `1`,代表当前种类编号为 $k$ 的钥匙 **已被收集**,后续移动若遇到对应的锁则 **能通过**
* 若 `state` 的二进制中的第 $k$ 位为 `0`,代表当前种类编号为 $k$ 的钥匙 **未被收集**,后续移动若遇到对应的锁则 **无法通过**
其中「钥匙种类编号」则按照小写字母先后顺序,从 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.864` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/867. 转置矩阵（简单）.md | 867. 转置矩阵 | https://leetcode-cn.com/problems/transpose-matrix/solution/yi-you-wei-jin-huo-xu-ni-neng-kan-kan-zh-m53m/ | 简单 | [
"模拟"
] | 给你一个二维整数数组 matrix, 返回 matrix 的 转置矩阵 。
矩阵的 转置 是指将矩阵的主对角线翻转,交换矩阵的行索引与列索引。
示例 1:
```
输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出:[[1,4,7],[2,5,8],[3,6,9]]
```
示例 2:
```
输入:matrix = [[1,2,3],[4,5,6]]
输出:[[1,4],[2,5],[3,6]]
```
提示:
* m == matrix.length
* n == matrix[i].length
* 1 <= m, n <= 1000
* 1 <= m * n <= $10^5$
* -$1... | ### 模拟
对角线翻转,只需要从头模拟一遍即可。
```java
class Solution {
public int[][] transpose(int[][] matrix) {
int n = matrix.length, m = matrix[0].length;
int[][] ans = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
ans[i][j] = matrix[j][i];
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.867` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/868. 二进制间距（简单）.md | 868. 二进制间距 | https://leetcode-cn.com/problems/binary-gap/solution/by-ac_oier-2sui/ | 简单 | [
"模拟"
] | 给定一个正整数 $n$,找到并返回 $n$ 的二进制表示中两个 相邻 $1$ 之间的 最长距离 。如果不存在两个相邻的 $1$,返回 $0$ 。
如果只有 $0$ 将两个 $1$ 分隔开(可能不存在 $0$ ),则认为这两个 $1$ 彼此 相邻 。两个 $1$ 之间的距离是它们的二进制表示中位置的绝对差。例如,`"1001"` 中的两个 $1$ 的距离为 $3$ 。
示例 1:
```
输入:n = 22
输出:2
解释:22 的二进制是 "10110" 。
在 22 的二进制表示中,有三个 1,组成两对相邻的 1 。
第一对相邻的 1 中,两个 1 之间的距离为 2 。
第二对相邻的 1 中,两个 1 之间的距离为 1 。... | ### 模拟
根据题意进行模拟即可,遍历 $n$ 的二进制中的每一位 $i$,同时记录上一位 $1$ 的位置 $j$,即可得到所有相邻 $1$ 的间距,所有间距取 $\max$ 即是答案。
代码:
```Java
class Solution {
public int binaryGap(int n) {
int ans = 0;
for (int i = 31, j = -1; i >= 0; i--) {
if (((n >> i) & 1) == 1) {
if (j != -1) ans = Math.max(ans, j -... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.868` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/869. 重新排序得到 2 的幂（中等）.md | 869. 重新排序得到 2 的幂 | https://leetcode-cn.com/problems/reordered-power-of-2/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-c-3s1e/ | 中等 | [
"DFS",
"哈希表"
] | 给定正整数 `N` ,我们按任何顺序(包括原始顺序)将数字重新排序,注意其前导数字不能为零。
如果我们可以通过上述方式得到 $2$ 的幂,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:1
输出:true
```
示例 2:
```
输入:10
输出:false
```
示例 3:
```
输入:16
输出:true
```
示例 4:
```
输入:24
输出:false
```
示例 5:
```
输入:46
输出:true
```
提示:
$1 <= N <= 10^9$ | ### 打表 + DFS
一个朴素的做法是对 $n$ 进行重排,然后检查重排后的数值是否属于 $2$ 的幂。
由于 $2$ 的幂数固定,我们可以先通过「打表」将范围落在 $[1, 1e9]$ 以内的 $2$ 的幂预处理出来,这样我们可以在 $O(1)$ 的复杂度内判断某个数是否为 $2$ 的幂。
重排的过程则是 `DFS` 实现。
代码:
```Java
class Solution {
static Set<Integer> set = new HashSet<>();
static {
for (int i = 1; i < (int)1e9+10; i *= 2) set.add(i);... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.869` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/870. 优势洗牌（中等）.md | 870. 优势洗牌 | https://leetcode.cn/problems/advantage-shuffle/solution/by-ac_oier-i01s/ | 中等 | [
"红黑树",
"哈希表",
"排序",
"双指针",
"贪心"
] | 给定两个大小相等的数组 `nums1` 和 `nums2`,`nums1` 相对于 `nums` 的优势可以用满足 `nums1[i] > nums2[i]` 的索引 `i` 的数目来描述。
返回 `nums1` 的任意排列,使其相对于 `nums2` 的优势最大化。
示例 1:
```
输入:nums1 = [2,7,11,15], nums2 = [1,10,4,11]
输出:[2,11,7,15]
```
示例 2:
```
输入:nums1 = [12,24,8,32], nums2 = [13,25,32,11]
输出:[24,32,8,12]
```
提示:
* $1 <= nums1.length <= 10... | ### 数据结构
显然,对于任意一个 $t = nums2[i]$ 而言,我们应当在候选集合中选择**比其大的最小数**,若不存在这样的数字,则选择候选集合中的**最小值**。
同时,由于 $nums1$ 相同数会存在多个,我们还要对某个具体数字的可用次数进行记录。
也就是我们总共涉及两类操作:
1. 实时维护一个候选集合,该集合支持高效查询比某个数大的数值操作;
2. 对候选集合中每个数值的可使用次数进行记录,当使用到了候选集合中的某个数后,要对其进行计数减一操作,若计数为 $0$,则将该数值从候选集合中移除。
计数操作容易想到哈希表,而实时维护候选集合并高效查询可以使用基于红黑树的 `TreeSet` 数据结构。
J... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.870` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/871. 最低加油次数（困难）.md | 871. 最低加油次数 | https://leetcode.cn/problems/minimum-number-of-refueling-stops/solution/by-ac_oier-q2mk/ | 困难 | [
"贪心",
"优先队列(堆)",
"模拟"
] | 汽车从起点出发驶向目的地,该目的地位于出发位置东面 `target` 英里处。
沿途有加油站,每个 `station[i]` 代表一个加油站,它位于出发位置东面 `station[i][0]` 英里处,并且有 `station[i][1]` 升汽油。
假设汽车油箱的容量是无限的,其中最初有 `startFuel` 升燃料。它每行驶 $1$ 英里就会用掉 $1$ 升汽油。
当汽车到达加油站时,它可能停下来加油,将所有汽油从加油站转移到汽车中。
为了到达目的地,汽车所必要的最低加油次数是多少?如果无法到达目的地,则返回 $-1$ 。
注意:如果汽车到达加油站时剩余燃料为 $0$,它仍然可以在那里加油。如果汽车到达目的地时剩余燃... | ### 贪心 + 优先队列(堆)
我们可以模拟行进过程,使用 `n` 代表加油站总个数,`idx` 代表经过的加油站下标,使用 `remain` 代表当前有多少油(起始有 `remain = startFuel`),`loc` 代表走了多远,`ans` 代表答案(至少需要的加油次数)。
只要 `loc < target`,代表还没到达(经过)目标位置,我们可以继续模拟行进过程。
每次将 `remain` 累加到 `loc` 中,含义为使用完剩余的油量,可以去到的最远距离,同时将所在位置 `stations[idx][0] <= loc` 的加油站数量加入优先队列(大根堆,根据油量排倒序)中。
再次检查是否满足 `loc < ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.871` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/872. 叶子相似的树（简单）.md | 872. 叶子相似的树 | https://leetcode-cn.com/problems/leaf-similar-trees/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-udfc/ | 简单 | [
"树的搜索",
"非递归",
"递归",
"DFS"
] | 请考虑一棵二叉树上所有的叶子,这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。
举个例子,如上图所示,给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。
如果有两棵二叉树的叶值序列是相同,那么我们就认为它们是 叶相似 的。
如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的,则返回 true;否则返回 false 。
示例 1:
```
输入:
root1 = [3,5,1,6,2,9,8,null,null,7,4],
root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
输出:true
```
示例 2:
```
... | ### 递归
递归写法十分简单,属于树的遍历中最简单的实现方式。
代码:
```Java
class Solution {
public boolean leafSimilar(TreeNode t1, TreeNode t2) {
List<Integer> l1 = new ArrayList<>(), l2 = new ArrayList<>();
dfs(t1, l1);
dfs(t2, l2);
if (l1.size() == l2.size()) {
for (int i = 0; i < l1.size(); i++... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.872` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/873. 最长的斐波那契子序列的长度（中等）.md | 873. 最长的斐波那契子序列的长度 | https://leetcode.cn/problems/length-of-longest-fibonacci-subsequence/solution/by-ac_oier-beo2/ | 中等 | [
"序列 DP",
"哈希表",
"动态规划"
] | 如果序列 $X_1, X_2, ..., X_n$ 满足下列条件,就说它是 斐波那契式 的:
* `n >= 3`
* 对于所有 `i + 2 <= n`,都有 $X_i + X_{i+1} = X_{i+2}$
给定一个严格递增的正整数数组形成序列 `arr`,找到 `arr` 中最长的斐波那契式的子序列的长度。如果一个不存在,返回 $0$ 。
(回想一下,子序列是从原序列 `arr` 中派生出来的,它从 `arr` 中删掉任意数量的元素(也可以不删),而不改变其余元素的顺序。例如, `[3, 5, 8]` 是 `[3, 4, 5, 6, 7, 8]` 的一个子序列)
示例 1:
```
输入: arr = [1,2,3... | ### 序列 DP
定义 $f[i][j]$ 为使用 $arr[i]$ 为斐波那契数列的最后一位,使用 $arr[j]$ 为倒数第二位(即 $arr[i]$ 的前一位)时的最长数列长度。
不失一般性考虑 $f[i][j]$ 该如何计算,首先根据斐波那契数列的定义,我们可以直接算得 $arr[j]$ 前一位的值为 $arr[i] - arr[j]$,而快速得知 $arr[i] - arr[j]$ 值的坐标 $t$,可以利用 `arr` 的严格单调递增性质,使用「哈希表」对坐标进行转存,若坐标 $t$ 存在,并且符合 $t < j$,说明此时至少凑成了长度为 $3$ 的斐波那契数列,同时结合状态定义,可以使用 $f[j][t]$ 来... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.873` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/875. 爱吃香蕉的珂珂（中等）.md | 875. 爱吃香蕉的珂珂 | https://leetcode.cn/problems/koko-eating-bananas/solution/by-ac_oier-4z7i/ | 中等 | [
"二分"
] | 珂珂喜欢吃香蕉。这里有 `n` 堆香蕉,第 `i` 堆中有 `piles[i]` 根香蕉。警卫已经离开了,将在 `h` 小时后回来。
珂珂可以决定她吃香蕉的速度 `k` (单位:根/小时)。每个小时,她将会选择一堆香蕉,从中吃掉 `k` 根。如果这堆香蕉少于 `k` 根,她将吃掉这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉。
珂珂喜欢慢慢吃,但仍然想在警卫回来前吃掉所有的香蕉。
返回她可以在 `h` 小时内吃掉所有香蕉的最小速度 `k`(`k` 为整数)。
示例 1:
```
输入:piles = [3,6,7,11], h = 8
输出:4
```
示例 2:
```
输入:piles = [30,11,23,4... | ### 二分
由于存在「吃完这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉」的条件,因此不会存在多堆香蕉共用一个小时的情况,即每堆香蕉都是相互独立,同时可以明确每堆香蕉的耗时为 $\left \lceil \frac{piles[i]}{k} \right \rceil$(其中 $k$ 为速度)。
因此我们可以二分 $k$ 值,在以 $k$ 为分割点的数组上具有「二段性」:
* 小于 $k$ 的值,总耗时 $ans$ 必然不满足 $ans \leq h$
* 大于等于 $k$ 的值,总耗时 $ans$ 必然满足 $ans \leq h$
然后我们需要确定二分的范围,每堆香蕉至少消耗一个小时,因此大于 $\max(piles... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.875` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/877. 石子游戏（中等）.md | 877. 石子游戏 | https://leetcode-cn.com/problems/stone-game/solution/gong-shui-san-xie-jing-dian-qu-jian-dp-j-wn31/ | 中等 | [
"区间 DP",
"博弈论"
] | 亚历克斯和李用几堆石子在做游戏。偶数堆石子排成一行,每堆都有正整数颗石子 piles[i] 。
游戏以谁手中的石子最多来决出胜负。石子的总数是奇数,所以没有平局。
亚历克斯和李轮流进行,亚历克斯先开始。 每回合,玩家从行的开始或结束处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止,此时手中石子最多的玩家获胜。
假设亚历克斯和李都发挥出最佳水平,当亚历克斯赢得比赛时返回 true ,当李赢得比赛时返回 false 。
示例:
```
输入:[5,3,4,5]
输出:true
解释:
亚历克斯先开始,只能拿前 5 颗或后 5 颗石子 。
假设他取了前 5 颗,这一行就变成了 [3,4,5] 。
如果李拿走前 3 颗,那么... | ### 动态规划
**定义 $f[l][r]$ 为考虑区间 $[l,r]$,在双方都做最好选择的情况下,先手与后手的最大得分差值为多少。**
那么 $f[1][n]$ 为考虑所有石子,先手与后手的得分差值:
* $f[1][n] > 0$,则先手必胜,返回 `True`
* $f[1][n] < 0$,则先手必败,返回 `False`
不失一般性的考虑 $f[l][r]$ 如何转移。根据题意,只能从两端取石子(令 $piles$ 下标从 $1$ 开始),共两种情况:
* 从左端取石子,价值为 $piles[l - 1]$;取完石子后,原来的后手变为先手,从 $[l + 1, r]$ 区间做最优决策,所得价值为 $f[l +... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.877` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/878. 第 N 个神奇数字（困难）.md | 878. 第 N 个神奇数字 | https://leetcode.cn/problems/nth-magical-number/solution/by-ac_oier-ln3b/ | 困难 | [
"数学",
"容斥原理",
"二分",
"gcd",
"lcm"
] | 一个正整数如果能被 `a` 或 `b` 整除,那么它是神奇的。
给定三个整数 `n` , `a` , `b` ,返回第 `n` 个神奇的数字。因为答案可能很大,所以返回答案 对 $10^9 + 7$ 取模 后的值。
示例 1:
```
输入:n = 1, a = 2, b = 3
输出:2
```
示例 2:
```
输入:n = 4, a = 2, b = 3
输出:6
```
提示:
* $1 <= n <= 10^9$
* $2 <= a, b <= 4 \times 10^4$ | ### 数学
#### 提示一 : 从题面分析常见做法,从常见做法复杂度出发考虑其他做法
若不看数据范围,只看题面,容易想到的做法是「多路归并」:起始使用两个指针指向 `[a, 2a, 3a, ... ]` 和 `[b, 2b, 3b, ...]` 的开头,不断比较两指针所指向的数值大小,从而决定将谁后移,并不断更新顺位计数。
该做法常见,但其复杂度为 $O(n)$,对于本题 $n = 1e9$ 来说并不可行。
确定线性复杂度的做法不可行后,我们考虑是否存在对数复杂度的做法。
#### 提示二 : 如何考虑常见的对数复杂度做法,如何定义二段性
题目要我们求第 $n$ 个符合要求的数,假设我们想要通过「二分」来找该数值,那... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.878` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/879. 盈利计划（困难）.md | 879. 盈利计划 | https://leetcode-cn.com/problems/profitable-schemes/solution/gong-shui-san-xie-te-shu-duo-wei-fei-yon-7su9/ | 困难 | [
"动态规划",
"容斥原理",
"数学",
"背包问题",
"多维背包"
] | 集团里有 `n` 名员工,他们可以完成各种各样的工作创造利润。
第 `i` 种工作会产生 `profit[i]` 的利润,它要求 `group[i]` 名成员共同参与。如果成员参与了其中一项工作,就不能参与另一项工作。
工作的任何至少产生 `minProfit` 利润的子集称为 盈利计划 。并且工作的成员总数最多为 `n` 。
有多少种计划可以选择?因为答案很大,所以 返回结果模 $10^9 + 7 $ 的值。
示例 1:
```
输入:n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出:2
解释:至少产生 3 的利润,该集团可以完成工作 0 和工作 1 ,或仅完成工... | ### 动态规划
这是一类特殊的多维费用背包问题。
将每个任务看作一个「物品」,完成任务所需要的人数看作「成本」,完成任务得到的利润看作「价值」。
其特殊在于存在一维容量维度需要满足「不低于」,而不是常规的「不超过」。这需要我们对于某些状态作等价变换。
**定义 $f[i][j][k]$ 为考虑前 $i$ 件物品,使用人数不超过 $j$,所得利润至少为 $k$ 的方案数。**
对于每件物品(令下标从 $1$ 开始),我们有「选」和「不选」两种决策:
* 不选:显然有:
$$
f[i - 1][j][k]
$$
* 选:首先需要满足人数达到要求( $j >= group[i - 1]$ ),还需要考虑「至少利润」负值问... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.879` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/881. 救生艇（中等）.md | 881. 救生艇 | https://leetcode-cn.com/problems/boats-to-save-people/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-hosg8/ | 中等 | [
"贪心",
"双指针"
] | 第 `i` 个人的体重为 `people[i]`,每艘船可以承载的最大重量为 `limit`。
每艘船最多可同时载两人,但条件是这些人的重量之和最多为 `limit`。
返回载到每一个人所需的最小船数。(保证每个人都能被船载)。
示例 1:
```
输入:people = [1,2], limit = 3
输出:1
解释:1 艘船载 (1, 2)
```
示例 2:
```
输入:people = [3,2,2,1], limit = 3
输出:3
解释:3 艘船分别载 (1, 2), (2) 和 (3)
```
示例 3:
```
输入:people = [3,5,3,4], limit = 5
输出:4
解释:... | ### 贪心
一个直观的想法是:由于一个船要么载两人要么载一人,在人数给定的情况下,为了让使用的总船数最小,要当尽可能让更多船载两人,即尽可能多的构造出数量之和不超过 $limit$ 的二元组。
先对 $people$ 进行排序,然后使用两个指针 `l` 和 `r` 分别从首尾开始进行匹配:
* 如果 $people[l] + people[r] <= limit$,说明两者可以同船,此时船的数量加一,两个指针分别往中间靠拢;
* 如果 $people[l] + people[r] > limit$,说明不能成组,由于题目确保人的重量不会超过 $limit$,此时让 $people[r]$ 独立成船,船的数量加一,`r` 指针... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.881` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/882. 细分图中的可到达节点（困难）.md | 882. 细分图中的可到达节点 | https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph/solution/by-ac_oier-yrhg/ | 困难 | [
"最短路",
"单源最短路",
"Dijkstra",
"SPFA"
] | 给你一个无向图(原始图),图中有 `n` 个节点,编号从 `0` 到 `n - 1` 。你决定将图中的每条边 细分 为一条节点链,每条边之间的新节点数各不相同。
图用由边组成的二维数组 `edges` 表示,其中 $edges[i] = [u_{i}, v_{i}, cnt_{i}]$ 表示原始图中节点 $u_{i}$ 和 $v_{i}$ 之间存在一条边,$cnt_{i}$ 是将边 细分 后的新节点总数。注意,$cnt_{i} = 0$ 表示边不可细分。
要 细分边 $[u_{i}, v_{i}]$ ,需要将其替换为 $(cnt_{i} + 1)$ 条新边,和 $cnt_{i}$ 个新节点。新节点为 $x_1, x_2, ...... | ### 朴素 Dijkstra
为了方便,我们将原始图边的数量记为 `m`,因此对于原始图而言,点的数量 $3000$,边的数量为 $10000$。
题目要我们求新图上,从 `0` 点出发可到达的点的数量,我们将原图上存在的点称为「原点」,细分边上增加的点称为「细分点」,两类点中可达点的数量即是答案。
在分别考虑如何统计两类点之前,我们需要重新定义一下边的权重:**若原点 `u` 和原点 `v` 的边上存在 `c` 个细分点,我们将原点 `u` 和原点 `v` 之间的边看作是一条权重为 `c + 1` 的无向边(结合题意,`c` 个点存在 `c + 1` 个分段/距离)**。
重新定义边的权重后,因为该图是「稠密图」,我们可... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.882` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/883. 三维形体投影面积（简单）.md | 883. 三维形体投影面积 | https://leetcode-cn.com/problems/projection-area-of-3d-shapes/solution/by-ac_oier-r6hj/ | 简单 | [
"模拟"
] | 在 $n * n$ 的网格 `grid` 中,我们放置了一些与 `x`,`y`,`z` 三轴对齐的 $1 * 1 * 1$ 立方体。
每个值 $v = grid[i][j]$ 表示 $v$ 个正方体叠放在单元格 $(i, j)$ 上。
现在,我们查看这些立方体在 `xy`、`yz` 和 `zx` 平面上的投影。
投影 就像影子,将 三维 形体映射到一个 二维 平面上。从顶部、前面和侧面看立方体时,我们会看到“影子”。
返回 所有三个投影的总面积 。
示例 1:
```
输入:[[1,2],[3,4]]
输出:17
解释:这里有该形体在三个轴对齐平面上的三个投影(“阴影部分”)。
```
示例 2:
```
输入:gr... | ### 模拟
根据题意进行模拟即可,使用三个变量分别统计三视图的阴影面积:
* `ans1`:统计俯视图的面积,共有 $n * n$ 个位置需要被统计,当任意格子 $g[i][j] > 0$,阴影面积加一;
* `ans2`:统计左视图的面积,共有 $n$ 行需要被统计,每一行对 `ans2` 的贡献为该行的最大高度;
* `ans3`:统计主视图的面积,共有 $n$ 列需要被统计,每一列对 `ans3` 的贡献为该列的最大高度。
代码:
```Java
class Solution {
public int projectionArea(int[][] g) {
int ans1 = 0, ans2 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.883` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/884. 两句话中的不常见单词（简单）.md | 884. 两句话中的不常见单词 | https://leetcode-cn.com/problems/uncommon-words-from-two-sentences/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-wwam/ | 简单 | [
"模拟",
"哈希表"
] | 句子 是一串由空格分隔的单词。每个 单词 仅由小写字母组成。
如果某个单词在其中一个句子中恰好出现一次,在另一个句子中却 没有出现 ,那么这个单词就是 不常见的 。
给你两个 句子 `s1` 和 `s2` ,返回所有 不常用单词 的列表。返回列表中单词可以按 任意顺序 组织。
示例 1:
```
输入:s1 = "this apple is sweet", s2 = "this apple is sour"
输出:["sweet","sour"]
```
示例 2:
```
输入:s1 = "apple apple", s2 = "banana"
输出:["banana"]
```
提示:
* $1 <= s1.leng... | ### 数据结构 + 模拟
根据题意进行模拟即可,先使用「哈希表」对两字符串进行「词频统计」,然后分别从两边的「哈希表」出发,统计符合题意的字符串数量。
或是利用某个单词在一边出现一次,另外一边不曾出现,等价于「某个单词总共只出现一次」。
代码:
```Java
class Solution {
public String[] uncommonFromSentences(String s1, String s2) {
Map<String, Integer> map = new HashMap<>();
String str = s1 + " " + s2;
String... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.884` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/886. 可能的二分法（中等）.md | 886. 可能的二分法 | https://leetcode.cn/problems/possible-bipartition/solution/by-ac_oier-6j0n/ | 中等 | [
"二分图",
"染色法",
"并查集",
"DFS"
] | 给定一组 `n` 人(编号为 `1, 2, ..., n`), 我们想把每个人分进任意大小的两组。
每个人都可能不喜欢其他人,那么他们不应该属于同一组。
给定整数 `n` 和数组 `dislikes` ,其中 $dislikes[i] = [a_i, b_i]$ ,表示不允许将编号为 $a_i$ 和 $b_i$ 的人归入同一组。
当可以用这种方法将所有人分进两组时,返回 `true`;否则返回 `false`。
示例 1:
```
输入:n = 4, dislikes = [[1,2],[1,3],[2,4]]
输出:true
解释:group1 [1,4], group2 [2,3]
```
示例 2:
```
输入... | ### 染色法
无论是从题目描述和对点边的描述,这都是一道「染色法判定二分图」的模板题。
为了方便,我们令 `dislikes` 为 `ds`,将其长度记为 $m$。
题目要求我们将 $n$ 个点划分到两个集合中,同时我们将每个 $ds[i]$ 看做无向边的话,可知集合内部无边,即所有的边必然横跨两个集合之间。
使用 $ds[i]$ 进行建图,并将两个将要划分出的两个集合分别记为 `A` 和 `B`,我们可以采用「染色」的方式,尝试将所有点进行划分。
构建一个与点数相等的数组 `color`,我们人为规定划分到集合 `A` 的点满足 $color[i] = 1$,划分到集合 `B` 的点满足 $color[i] = 2$,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.886` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/888. 公平的糖果棒交换（简单）.md | 888. 公平的糖果棒交换 | https://leetcode-cn.com/problems/fair-candy-swap/solution/xiang-jie-po-su-jie-fa-cha-zhao-you-hua-9nd9y/ | 简单 | [
"哈希表"
] | 爱丽丝和鲍勃有不同大小的糖果棒:A[i] 是爱丽丝拥有的第 i 根糖果棒的大小,B[j] 是鲍勃拥有的第 j 根糖果棒的大小。
因为他们是朋友,所以他们想交换一根糖果棒,这样交换后,他们都有相同的糖果总量。(一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。)
返回一个整数数组 ans,其中 ans[0] 是爱丽丝必须交换的糖果棒的大小,ans[1] 是 Bob 必须交换的糖果棒的大小。
如果有多个答案,你可以返回其中任何一个。
保证答案存在。
示例 1:
```
输入:A = [1,1], B = [2,2]
输出:[1,2]
```
示例 2:
```
输入:A = [1,2], B = [2,3]
输出:[1,2... | ### 朴素解法
最终目的是让两个数组总和相等。
我们可以先分别求得两个数组总和为 $aSum$ 和 $bSum$。
即有数组总和 $total = aSum + bSum$。
同时得数组目标总和 $target = total / 2$。
当前两个数组与目标总和的差值分别为 $target - aSum$ 和 $target - bSum$。
我们记 $diff = target - aSum$。
对于某个 $a[i]$ 而言,如果 $a[i]$ 能构成答案,那么 `b` 数组中必然存在大小为 $a[i] + diff$ 的值,使得两者交换后,数组总和均为 $target$。
因此我们只需要遍历数组 `a`,查找哪... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.888` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/890. 查找和替换模式（中等）.md | 890. 查找和替换模式 | https://leetcode.cn/problems/find-and-replace-pattern/solution/by-ac_oier-s4cw/ | 中等 | [
"哈希表",
"模拟"
] | 你有一个单词列表 `words` 和一个模式 `pattern`,你想知道 `words` 中的哪些单词与模式匹配。
如果存在字母的排列 `p` ,使得将模式中的每个字母 `x` 替换为 `p(x)` 之后,我们就得到了所需的单词,那么单词与模式是匹配的。
(回想一下,字母的排列是从字母到字母的双射:每个字母映射到另一个字母,没有两个字母映射到同一个字母。)
返回 `words` 中与给定模式匹配的单词列表。
你可以按任何顺序返回答案。
示例:
```
输入:words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
输出:["mee","aqq"]
... | ### 哈希表 模拟
根据题意进行模拟即可,使用 `map` 记录具体的映射关系,使用 `vis` 记录哪些字符已被映射,利用字符集大小只有 $26$,我们可以使用数组充当哈希表。
代码:
```Java
class Solution {
public List<String> findAndReplacePattern(String[] ws, String pe) {
List<String> ans = new ArrayList<>();
int[] map = new int[26], vis = new int[26];
for (String s : ws) ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.890` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/891. 子序列宽度之和（困难）.md | 891. 子序列宽度之和 | https://leetcode.cn/problems/sum-of-subsequence-widths/solution/by-ac_oier-6tyk/ | 困难 | [
"数学"
] | 一个序列的 宽度 定义为该序列中最大元素和最小元素的差值。
给你一个整数数组 `nums`,返回 `nums` 的所有非空 子序列 的 宽度之和 。由于答案可能非常大,请返回对 $10^9 + 7$ 取余 后的结果。
子序列 定义为从一个数组里删除一些(或者不删除)元素,但不改变剩下元素的顺序得到的数组。例如,`[3,6,2,7]` 就是数组 `[0,3,1,6,2,2,7]` 的一个子序列。
示例 1:
```
输入:nums = [2,1,3]
输出:6
解释:子序列为 [1], [2], [3], [2,1], [2,3], [1,3], [2,1,3] 。
相应的宽度是 0, 0, 0, 1, 1, 2, 2 。
... | ### 数学
#### 提示一:每个子序列对答案的贡献
对于某个子序列而言,若其最大值为 $a$,最小值为 $b$,则该子序列对答案的贡献为 $(a - b)$。
我们有若干个子序列,即有若干个 $(a - b)$,答案为所有 $(a - b)$ 之和,我们称一个 $(a - b)$ 为 `item`。
#### 提示二:每个 $nums[i]$ 参与了多少个 `item` 的组成,在最终展开式中又是如何
对于每个 $(a - b)$ 而言,`a` 和 `b` 均必然是具体的 $nums[i]$。
同时易知若 $nums[i]$ 作为了 $k$ 个子序列的最小值,那么在最终表达式展开中,必然有 $k$ 个 $-nums[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.891` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/895. 最大频率栈（困难）.md | 895. 最大频率栈 | https://leetcode.cn/problems/maximum-frequency-stack/solution/by-ac_oier-tquk/ | 困难 | [
"哈希表",
"模拟"
] | 设计一个类似堆栈的数据结构,将元素推入堆栈,并从堆栈中弹出出现频率最高的元素。
实现 `FreqStack` 类:
* `FreqStack()` 构造一个空的堆栈。
* `void push(int val)` 将一个整数 `val` 压入栈顶。
* `int pop()` 删除并返回堆栈中出现频率最高的元素。
如果出现频率最高的元素不只一个,则移除并返回最接近栈顶的元素。
示例 1:
```
输入:
["FreqStack","push","push","push","push","push","push","pop","pop","pop","pop"],
[[],[5],[7],[5],[7],[4],[5],[],[... | ### 哈希表
这是一道很纯的哈希表题儿。
首先,我们容易想到建立 **第一个哈希表 `cnts` 用于记录某个数值的出现次数,`cnts[val] = c` 含义为数值 `val` 当前在栈中的出现次数为 `c`。我们称该哈希表为「计数哈希表」**。
再结合每次 `pop` 需要返回「频率最大的元素,若有多个则返回最考虑栈顶的一个」的要求,我们还可以 **建立第二个哈希 `map`,该哈希表以「出现次数 `c`」为键,以「出现次数均为 `c` 的元素序列」为值,`map[c] = A = [...]` 含义为出现次数为 `c` 的序列为 `A`,并且序列 `A` 中的结尾元素为出现次数为 `c` 的所有元素中最靠近栈顶的元素... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.895` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/896. 单调数列（简单）.md | 896. 单调数列 | https://leetcode-cn.com/problems/monotonic-array/solution/wei-shi-yao-yi-ci-bian-li-yao-bi-liang-c-uglp/ | 简单 | [
"数组",
"模拟"
] | 如果数组是单调递增或单调递减的,那么它是单调的。
如果对于所有 i <= j,A[i] <= A[j],那么数组 A 是单调递增的。 如果对于所有 i <= j,A[i]> = A[j],那么数组 A 是单调递减的。
当给定的数组 A 是单调数组时返回 true,否则返回 false。
示例 1:
```
输入:[1,2,2,3]
输出:true
```
示例 2:
```
输入:[6,5,4,4]
输出:true
```
示例 3:
```
输入:[1,3,2]
输出:false
```
示例 4:
```
输入:[1,2,4,5]
输出:true
```
示例 5:
```
输入:[1,1,1]
输出:true
```
... | ### 朴素解法(所谓的两次遍历)
两次遍历,分别检查是否为单调递增和单调递减。
```java []
class Solution {
public boolean isMonotonic(int[] a) {
return check(a, true) || check(a, false);
}
boolean check(int[] a, boolean flag) {
for (int i = 0; i < a.length - 1; i++) {
if (flag) {
if (a[i] > a[i + 1]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.896` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/897. 递增顺序搜索树（简单）.md | 897. 递增顺序搜索树 | https://leetcode-cn.com/problems/increasing-order-search-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-yc8l/ | 简单 | [
"树的遍历",
"递归",
"非递归"
] | 给你一棵二叉搜索树,请你 按中序遍历 将其重新排列为一棵递增顺序搜索树,使树中最左边的节点成为树的根节点,并且每个节点没有左子节点,只有一个右子节点。
示例 1:
```
输入:root = [5,3,6,2,4,null,8,1,null,null,null,7,9]
输出:[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
```
示例 2:
```
输入:root = [5,1,7]
输出:[1,null,5,null,7]
```
提示:
* 树中节点数的取值范围是 [1, 100]
* 0 <= Node.val <= 1000 | ### 基本思路
由于给定的树是一棵「二叉搜索树」,因此只要对其进行「中序遍历」即可得到有序列表,再根据有序列表构建答案即可。
而二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。
---
### 递归
递归写法十分简单,属于树的遍历中最简单的实现方式。
代码:
```Java
class Solution {
List<TreeNode> list = new ArrayList<>();
public TreeNode increasingBST(TreeNode root) {
dfs(root);
TreeNode dummy = new TreeNode(-1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.897` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/899. 有序队列（困难）.md | 899. 有序队列 | https://leetcode.cn/problems/orderly-queue/solution/by-ac_oier-443m/ | 困难 | [
"构造",
"最小表示法"
] | 给定一个字符串 `s` 和一个整数 `k` 。你可以从 `s` 的前 `k` 个字母中选择一个,并把它加到字符串的末尾。
返回 在应用上述步骤的任意数量的移动后,字典上最小的字符串 。
示例 1:
```
输入:s = "cba", k = 1
输出:"acb"
解释:
在第一步中,我们将第一个字符(“c”)移动到最后,获得字符串 “bac”。
在第二步中,我们将第一个字符(“b”)移动到最后,获得最终结果 “acb”。
```
示例 2:
```
输入:s = "baaca", k = 3
输出:"aaabc"
解释:
在第一步中,我们将第一个字符(“b”)移动到最后,获得字符串 “aacab”。
在第二步中,我们将第... | ### 最小表示法
当 $k > 1$ 时,我们能够构造出任意的字符串方案,因此当 $k > 1$ 时,我们可以直接通过对字符串排序来得到答案,复杂度为 $O(n\log{n})$。
当 $k = 1$ 时,我们共有 $n$ 种候选方案(将字符串 `s` 看作一个首尾相接的循环字符串,共有 $n$ 个起点可枚举),枚举过程中需要与当前最优的方案进行比较,比较复杂度为 $O(n)$,因此整体复杂度为 $O(n^2)$。
上述的做法已经可以通过本题,可以看出瓶颈在于对 $k = 1$ 的处理。
而实际上,对于给定字符串 `s`,求其循环同构的所有方案中字典序最小的方案,可以使用「最小表示法」来做,复杂度为 $O(n)$。
最小... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.899` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/901. 股票价格跨度（中等）.md | 901. 股票价格跨度 | https://leetcode.cn/problems/online-stock-span/solution/by-ac_oier-m8g7/ | 中等 | [
"分块",
"单调栈"
] | 编写一个 `StockSpanner` 类,它收集某些股票的每日报价,并返回该股票当日价格的跨度。
今天股票价格的跨度被定义为股票价格小于或等于今天价格的最大连续日数(从今天开始往回数,包括今天)。
例如,如果未来 `7` 天股票的价格是 `[100, 80, 60, 70, 60, 75, 85]`,那么股票跨度将是 `[1, 1, 1, 2, 1, 4, 6]`。
示例:
```
输入:["StockSpanner","next","next","next","next","next","next","next"], [[],[100],[80],[60],[70],[60],[75],[85]]
输出:[null,1,... | ### 分块
又名优雅的暴力。
这是一道在线问题,在调用 `next` 往数据流存入元素的同时,返回连续段不大于当前元素的数的个数。
一个朴素的想法是:使用数组 `nums` 将所有 `price` 进行存储,每次返回时往前找到第一个不满足要求的位置,并返回连续段的长度。
但对于 $10^4$ 的调用次数来看,该做法的复杂度为 $O(n^2)$,计算量为 $10^8$,不满足 `OJ` 要求。
实际上我们可以利用「分块」思路对其进行优化,将与连续段的比较转换为与最值的比较。
具体的,我们仍然使用 `nums` 对所有的 `price` 进行存储,同时使用 `region` 数组来存储每个连续段的最大值,其中 $regio... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.901` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/902. 最大为 N 的数字组合（困难）.md | 902. 最大为 N 的数字组合 | https://leetcode-cn.com/problems/numbers-at-most-n-given-digit-set/solution/by-ac_oier-8k27/ | 困难 | [
"动态规划",
"二分",
"数位 DP"
] | 给定一个按 非递减顺序 排列的数字数组 `digits`。你可以用任意次数 $digits[i]$ 来写的数字。例如,如果 $digits = [1,3,5]$,我们可以写数字,如 `'13'`, `'551'`, 和 `'1351315'`。
返回 **可以生成的小于或等于给定整数** $n$ 的正整数的个数 。
示例 1:
```
输入:digits = ["1","3","5","7"], n = 100
输出:20
解释:
可写出的 20 个数字是:
1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.
```
示例 2... | ### 数位 DP + 二分
这是一道「数位 DP」的经典运用题。
由于题目给定的 `digits` 不包含 $0$,因此相当于只需要回答使用 `digits` 的数值能够覆盖 $[1, x]$ 范围内的多少个数字。
起始先将字符串数组 `digits` 转为数字数组 `nums`,假定 `nums` 的长度为 $m$,然后考虑如何求得 $[1, x]$ 范围内合法数字的个数。
假定我们存在函数 `int dp(int x)` 函数,能够返回区间 $[1, x]$ 内合法数的个数,那么配合「容斥原理」我们便能够回答任意区间合法数的查询:
$$
ans_{(l, r)} = dp(r) - dp(l - 1)
$$
对于本题,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.902` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/904. 水果成篮（中等）.md | 904. 水果成篮 | https://leetcode.cn/problems/fruit-into-baskets/solution/by-ac_oier-skgk/ | 中等 | [
"双指针",
"模拟",
"滑动窗口"
] | 你正在探访一家农场,农场从左到右种植了一排果树。
这些树用一个整数数组 `fruits` 表示,其中 `fruits[i]` 是第 `i` 棵树上的水果种类。
你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:
* 你只有两个篮子,并且每个篮子只能装单一类型 的水果。每个篮子能够装的水果总量没有限制。
* 你可以选择任意一棵树开始采摘,你必须从每棵树(包括开始采摘的树)上恰好摘一个水果。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。
* 一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。
给你一个整数数组 `fruits`,返回你... | ### 滑动窗口
本题至少一半的难度在于理解题意。
坏消息是,像此类描述不够清晰的算法题,并不在少数。
好消息是,此类题目,通常都有对应的解决方案。就是如果读一遍题面,不能理解题意的时候,切勿来回阅读题面,而是从示例数据进行入手进行理解。
通过对先看「示例」再阅读「题面」的理解方式,整理出基本题意:从任意位置开始,**同时使用**两个篮子采集,一旦选择后不能修改篮子所装的水果种类,当所有树处理完或遇到第一棵种类不同的树则停止。
核心求解思路为滑动窗口:使用 `j` 和 `i` 分别代表滑动窗口的两端,窗口种类不超过 $2$ 种为合法。
Java 代码:
```Java
class Solution {
publi... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.904` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/905. 按奇偶排序数组（简单）.md | 905. 按奇偶排序数组 | https://leetcode-cn.com/problems/sort-array-by-parity/solution/by-ac_oier-nuz7/ | 简单 | [
"模拟",
"双指针"
] | 给你一个整数数组 `nums`,将 `nums` 中的的所有偶数元素移动到数组的前面,后跟所有奇数元素。
返回满足此条件的 任一数组 作为答案。
示例 1:
```
输入:nums = [3,1,2,4]
输出:[2,4,3,1]
解释:[4,2,3,1]、[2,4,1,3] 和 [4,2,1,3] 也会被视作正确答案。
```
示例 2:
```
输入:nums = [0]
输出:[0]
```
提示:
* $1 <= nums.length <= 5000$
* $0 <= nums[i] <= 5000$ | ### 模拟
根据题意进行模拟即可:使用指针 $i$ 和 $j$ 分别代表未处理区间的左右端点,当 $nums[i]$ 不为偶数时,将 $i$ 和 $j$ 两个位置互换,原有位置 $j$ 必然是奇数(已处理好),让 $j$ 自减左移,但原有位置 $i$ 交换后不确保是偶数,需要再次检查。
代码:
```Java
class Solution {
public int[] sortArrayByParity(int[] nums) {
int n = nums.length;
for (int i = 0, j = n - 1; i < j; i++) {
if (n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.905` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/907. 子数组的最小值之和（中等）.md | 907. 子数组的最小值之和 | https://leetcode.cn/problems/sum-of-subarray-minimums/solution/by-ac_oier-w2ya/ | 中等 | [
"数学",
"单调栈"
] | 给定一个整数数组 `arr`,找到 `min(b)` 的总和,其中 `b` 的范围为 `arr` 的每个(连续)子数组。
由于答案可能很大,因此 返回答案模 $10^9 + 7$ 。
示例 1:
```
输入:arr = [3,1,2,4]
输出:17
解释:
子数组为 [3],[1],[2],[4],[3,1],[1,2],[2,4],[3,1,2],[1,2,4],[3,1,2,4]。
最小值为 3,1,2,4,1,1,2,1,1,1,和为 17。
```
示例 2:
```
输入:arr = [11,81,94,43,3]
输出:444
```
提示:
* $1 <= arr.length <= 3 \times... | ### 单调栈 + 数学
原问题为求所有子数组的最小值之和。
统计所有子数组需要枚举左右端点,复杂度为 $O(n^2)$,对于每个子数组,我们还需要通过线性扫描的方式找到其最小值,复杂度为 $O(n)$,因此朴素解法的整体复杂度为 $O(n^3)$,题目给定数据范围为 $3 \times 10^4$,会 `TLE`。
由于我们是从子数组中取最小值来进行累加,即参与答案构成的每个数必然某个具体的 $arr[i]$。
**因此我们可以将原问题转化为「考虑统计每个 $arr[i]$ 对答案的贡献」。**
对于某一个 $arr[i]$ 而言,我们考虑其能够作为哪些子数组的最小值。
我们可以想象以 $arr[i]$ 为中心,分别往... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.907` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/908. 最小差值 I（简单）.md | 908. 最小差值 I | https://leetcode.cn/problems/smallest-range-i/solution/by-ac_oier-7fh0/ | 简单 | [
"模拟",
"脑筋急转弯"
] | 给你一个整数数组 `nums`,和一个整数 `k` 。
在一个操作中,您可以选择 $0 <= i < nums.length$ 的任何索引 `i` 。将 $nums[i]$ 改为 $nums[i] + x$ ,其中 $x$ 是一个范围为 $[-k, k]$ 的整数。对于每个索引 `i` ,最多 只能 应用 一次 此操作。
`nums` 的 分数 是 `nums` 中最大和最小元素的差值。
在对 `nums` 中的每个索引最多应用一次上述操作后,返回 `nums` 的最低 分数 。
示例 1:
```
输入:nums = [1], k = 0
输出:0
解释:分数是 max(nums) - min(nums) = 1 ... | ### 脑筋急转弯
根据题意,对于任意一个数 $nums[i]$ 而言,其所能变化的范围为 $[nums[i] - k, nums[i] + k]$,我们需要最小化变化后的差值。而当 $k$ 足够大时,我们必然能够将所有数变为同一个值,此时答案为 $0$,而更一般的情况,我们能够缩减的数值距离为 $2 * k$,因此如果原来的最大差值为 $d = \max - \min$,若 $d <= 2 * k$ 时,答案为 $0$,否则答案为 $d - 2 * k$。
代码:
```Java
class Solution {
public int smallestRangeI(int[] nums, int k) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.908` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/909. 蛇梯棋（中等）.md | 909. 蛇梯棋 | https://leetcode-cn.com/problems/snakes-and-ladders/solution/gong-shui-san-xie-bfs-mo-ni-by-ac_oier-woh6/ | 中等 | [
"图论 BFS"
] | 给你一个大小为 `n x n` 的整数矩阵 `board` ,方格按从 $1$ 到 $n^2$ 编号,编号遵循 转行交替方式 ,从左下角开始 (即,从 `board[n - 1][0]` 开始)每一行交替方向。
玩家从棋盘上的方格 $1$ (总是在最后一行、第一列)开始出发。
每一回合,玩家需要从当前方格 $curr$ 开始出发,按下述要求前进:
* 选定目标方格 `next`,目标方格的编号符合范围 $[curr + 1, min(curr + 6, n^2)]$。
* 该选择模拟了掷 六面体骰子 的情景,无论棋盘大小如何,玩家最多只能有 $6$ 个目的地。
* 传送玩家:如果目标方格 `next` 处存在蛇或梯子,那么玩家... | ### BFS
最多有 $20 * 20$ 个格子,直接使用常规的单向 `BFS` 进行求解即可。
为了方便我们可以按照题目给定的意思,将二维的矩阵「扁平化」为一维的矩阵,然后再按照规则进行 `BFS`。
代码:
```Java
class Solution {
int n;
int[] nums;
public int snakesAndLadders(int[][] board) {
n = board.length;
if (board[0][0] != -1) return -1;
nums = new int[n * n + 1];
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.909` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/91. 解码方法（中等）.md | 91. 解码方法 | https://leetcode-cn.com/problems/decode-ways/solution/gong-shui-san-xie-gen-ju-shu-ju-fan-wei-ug3dd/ | 中等 | [
"线性 DP"
] | 一条包含字母 A-Z 的消息通过以下映射进行了 编码 :
```
'A' -> 1
'B' -> 2
...
'Z' -> 26
```
要 解码 已编码的消息,所有数字必须基于上述映射的方法,反向映射回字母(可能有多种方法)。例如,"11106" 可以映射为:
* "AAJF" ,将消息分组为 (1 1 10 6)
* "KJF" ,将消息分组为 (11 10 6)
注意,消息不能分组为 (1 11 06) ,因为 "06" 不能映射为 "F" ,这是由于 "6" 和 "06" 在映射中并不等价。
给你一个只含数字的 非空 字符串 s ,请计算并返回 解码 方法的 总数 。
题目数据保证答案肯定是一个 32 位 的整数。... | ### 基本分析
我们称一个解码内容为一个 `item`。
为根据题意,每个 `item` 可以由一个数字组成,也可以由两个数字组成。
数据范围为 100,很具有迷惑性,可能会有不少同学会想使用 DFS 进行爆搜。
我们可以大致分析一下这样的做法是否可行:不失一般性的考虑字符串 `s` 中的任意位置 `i`,位置 `i` 既可以作为一个独立 `item`,也可以与上一位置组成新 `item`,那么相当于每个位置都有两种分割选择(先不考虑分割结果的合法性问题),这样做法的复杂度是 $O(2^n)$ 的,当 `n` 范围是 100 时,远超我们计算机单秒运算量($10^7$)。即使我们将「判断分割结果是否合法」的操作放到爆搜过程... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.91` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/92. 反转链表 II（中等）.md | 92. 反转链表 II | https://leetcode-cn.com/problems/reverse-linked-list-ii/solution/yi-ge-neng-ying-yong-suo-you-lian-biao-t-vjx6/ | 中等 | [
"链表"
] | 给你单链表的头指针 head 和两个整数 left 和 right ,其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点,返回 反转后的链表 。
示例 1:
```
输入:head = [1,2,3,4,5], left = 2, right = 4
输出:[1,4,3,2,5]
```
示例 2:
```
输入:head = [5], left = 1, right = 1
输出:[5]
```
提示:
* 链表中节点数目为 n
* 1 <= n <= 500
* -500 <= Node.val <= 500
* 1 <= left <= right <= n | ### 朴素解法
为了减少边界判断,我们可以建立一个虚拟头结点 dummy,使其指向 head,最终返回 dummy.next。
这种「哨兵」技巧能应用在所有的「链表」题目。
黄色部分的节点代表需要「翻转」的部分:
之后就是常规的模拟,步骤我写在示意图里啦 ~
代码:
```java []
class Solution {
public ListNode reverseBetween(ListNode head, int l, int r) {
ListNode dummy = new ListNode(0);
dummy.next = head;
r -= l... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.92` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/93. 复原 IP 地址（中等）.md | 93. 复原 IP 地址 | https://leetcode.cn/problems/restore-ip-addresses/solutions/2519711/gong-shui-san-xie-hui-su-suan-fa-yun-yon-khnj/ | 中等 | [
"回溯算法",
"DFS"
] | 有效 `IP` 地址 正好由四个整数(每个整数位于 `0` 到 `255` 之间组成,且不能含有前导 `0`),整数之间用 `'.'` 分隔。
例如:`"0.1.2.201"` 和 `"192.168.1.1"` 是 有效 `IP` 地址,但是 `"0.011.255.245"`、`"192.168.1.312"` 和 `"192.168@1.1"` 是 无效 `IP` 地址。
给定一个只包含数字的字符串 `s` ,用以表示一个 `IP` 地址,返回所有可能的有效 `IP` 地址,这些地址可以通过在 `s` 中插入 `'.'` 来形成。你 不能 重新排序或删除 `s` 中的任何数字。你可以按 任何 顺序返回答案。
示例 1:
... | ### 回溯算法
和 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8) 一样,同样是一道求所有方案的题目,只能是没有太多优化的「爆搜」做法。
设计递归函数 `void dfs(int idx, int n, List<Integer> cur)`,其中 `idx` 代表当前处理字符串 `s` 的哪个位置,`n` 代表字符串 `s` 总长度,而 `cur` 的则是代表子串 $s[0 ... (idx - 1)]$ 部分的具体划分方案。
用题... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.93` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/95. 不同的二叉搜索树 II（中等）.md | 95. 不同的二叉搜索树 II | https://leetcode.cn/problems/unique-binary-search-trees-ii/solutions/2438263/gong-shui-san-xie-chang-gui-er-cha-shu-b-h4sw/ | 中等 | [
"树",
"二叉搜索树",
"BST",
"DFS",
"递归",
"爆搜"
] | 给你一个整数 `n`,请你生成并返回所有由 `n` 个节点组成且节点值从 `1` 到 `n` 互不相同的不同 二叉搜索树 。
可以按 任意顺序 返回答案。
示例 1:
```
输入:n = 3
输出:[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
```
示例 2:
```
输入:n = 1
输出:[[1]]
```
提示:
* $1 <= n <= 8$ | ### 回溯算法
题目要我们求所有所能构造的二叉搜索树的具体方案,而给定 $n$ 个节点所能构成的二叉搜索树的个数为 [卡特兰数](https://baike.baidu.com/item/%E5%8D%A1%E7%89%B9%E5%85%B0%E6%95%B0)。
其他方案数同为卡特兰数的还包括:凸多边形三角划分、`n` 对括号正确匹配数目 ...
回到本题,根据二叉搜索搜索的特性,若某个子树的根节点为 `root`,那么 `root` 的左子树任意节点值均比 `root.val` 要小,`root` 的右子树任意节点值均比 `root.val` 要大。
因此,假设我们使用 $[l, r]$ 连续段来构造二叉搜索树,并且... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.95` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/96. 不同的二叉搜索树（中等）.md | 96. 不同的二叉搜索树 | https://leetcode.cn/problems/unique-binary-search-trees/solutions/2438266/gong-shui-san-xie-cong-qu-jian-dp-dao-qi-fz5z/ | 中等 | [
"树",
"二叉搜索树",
"动态规划",
"区间 DP",
"数学",
"卡特兰数"
] | 给你一个整数 `n` ,求恰由 `n` 个节点组成且节点值从 `1` 到 `n` 互不相同的 二叉搜索树 有多少种?
返回满足题意的二叉搜索树的种数。
示例 1:
```
输入:n = 3
输出:5
```
示例 2:
```
输入:n = 1
输出:1
```
提示:
* $1 <= n <= 19$ | ### 区间 DP
沿用 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 的基本思路,只不过本题不是求具体方案,而是求个数。
除了能用 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.96` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/97. 交错字符串（中等）.md | 97. 交错字符串 | https://leetcode.cn/problems/interleaving-string/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-51da/ | 中等 | [
"线性 DP",
"记忆化搜索"
] | 给定三个字符串 `s1`、`s2`、`s3`,请你帮忙验证 `s3` 是否是由 `s1` 和 `s2` 交错 组成的。
两个字符串 `s` 和 `t` **交错** 的定义与过程如下,其中每个字符串都会被分割成若干 **非空** 子字符串:
* `s = s1 + s2 + ... + sn`
* `t = t1 + t2 + ... + tm`
* `|n - m| <= 1`
交错是 `s1 + t1 + s2 + t2 + s3 + t3 + ...` 或者 `t1 + s1 + t2 + s2 + t3 + s3 + ...`
注意:`a + b` 意味着字符串 `a` 和 `b` 连接。
示例 1:
```
输... | ### 记忆化搜索
数据范围相比于「暴搜」而言有点大,但将「暴搜」解法作为前置思考,总能为我们带来灵感。
将 `s1`、`s2` 和 `s3` 的长度分别记为 $n$、$m$ 和 $l$。
一个显然的情况是若 $n + m$ 不为 $l$,必然不能用 `s1` 和 `s2` 来凑成 `s3`,返回 `false`。
定义暴搜函数为 `boolean dfs(int i, int j)`,代表当前处理到 `s1` 的第 $i$ 个字符,`s2` 的第 $j$ 个字符,能否凑成 `s3` 的前 $i + j$ 个字符。
最终答案为 `dfs(0, 0)`。
根据 $s1[i]$、$s2[j]$ 和 $s3[i + j]$ 的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.97` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/99. 恢复二叉搜索树（中等）.md | 99. 恢复二叉搜索树 | https://leetcode.cn/problems/recover-binary-search-tree/solutions/2431878/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-4po4/ | 中等 | [
"二叉树",
"树的搜索",
"递归",
"迭代",
"中序遍历",
"Morris 遍历"
] | 给你二叉搜索树的根节点 `root`,该树中的 恰好 两个节点的值被错误地交换。
请在不改变其结构的情况下,恢复这棵树 。
示例 1:
```
输入:root = [1,3,null,null,2]
输出:[3,1,null,null,2]
解释:3 不能是 1 的左孩子,因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。
```
示例 2:
```
输入:root = [3,1,4,null,null,2]
输出:[2,1,4,null,null,3]
解释:2 不能在 3 的右子树中,因为 2 < 3 。交换 2 和 3 使二叉搜索树有效。
```
提示:
* 树上节点的数目在范围 $[2, 1000]$... | ### 基本分析
首先,别想复杂了。
所谓的恢复二叉树(两节点互换),只需要将两节点的 `val` 进行互换即可,而不需要对节点本身进行互换。
---
### 中序遍历 - 递归 & 迭代
二叉搜索树,其中序遍历是有序的。
要找到哪两个节点被互换,可通过比对中序遍历序列来实现。
但将整个中序遍历序列保存下来,再检测序列有序性的做法,复杂度是 $O(n)$ 的(不要说题目要求的 $O(1)$,连 $O(h)$ 都达不到)。
所以第一步,**这个「递归 & 迭代」的次优解,我们先考虑如何做到 $O(h)$ 的空间复杂度,即在中序遍历过程中找到互换节点**。
其实也很简单,除了使用 `a` 和 `b` 来记录互换节点,额... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.99` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/911. 在线选举（中等）.md | 911. 在线选举 | https://leetcode-cn.com/problems/online-election/solution/gong-shui-san-xie-er-fen-yun-yong-ti-by-5y3hi/ | 中等 | [
"二分"
] | 给你两个整数数组 $persons$ 和 $times$ 。
在选举中,第 $i$ 张票是在时刻为 $times[i]$ 时投给候选人 $persons[i]$ 的。
对于发生在时刻 $t$ 的每个查询,需要找出在 t 时刻在选举中领先的候选人的编号。
在 $t$ 时刻投出的选票也将被计入我们的查询之中。在平局的情况下,最近获得投票的候选人将会获胜。
实现 TopVotedCandidate 类:
* `TopVotedCandidate(int[] persons, int[] times)` 使用 $persons$ 和 $times$ 数组初始化对象。
* `int q(int t)` 根据前面描述的规则,返回在时刻 ... | ### 二分
根据题意,我们会在 $times[i]$ 时刻为 $persons[i]$ 候选人增加一票。
**利用 $times$ 数组严格递增,我们可以在处理 $times$ 时(模拟加票过程),使用一个变量 $val$ 来维护当前得票的最大数量,使用 $list$ 来记录不同时刻点的候选人交替情况。**
起始时 $val = 0$,当出现票数大于等于 $val$ 时,我们往 $list$ 追加二元组记录 $list[idx] = (times[i], persons[i])$,并更新 $val$。
**每个 $list[idx]$ 代表了当前候选人 $list[idx][1]$ 的首次当选时刻为 $list[idx][... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.911` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/913. 猫和老鼠（困难）.md | 913. 猫和老鼠 | https://leetcode-cn.com/problems/cat-and-mouse/solution/gong-shui-san-xie-dong-tai-gui-hua-yun-y-0bx1/ | 困难 | [
"动态规划",
"记忆化搜索"
] | 两位玩家分别扮演猫和老鼠,在一张**无向**图上进行游戏,两人轮流行动。
图的形式是:`graph[a]` 是一个列表,由满足 `ab` 是图中的一条边的所有节点 `b` 组成。
老鼠从节点 `1` 开始,第一个出发;猫从节点 `2` 开始,第二个出发。在节点 `0` 处有一个洞。
在每个玩家的行动中,他们 必须 沿着图中与所在当前位置连通的一条边移动。
例如,如果老鼠在节点 `1` ,那么它必须移动到 `graph[1]` 中的任一节点。
此外,猫无法移动到洞中(节点 `0`)。
然后,游戏在出现以下三种情形之一时结束:
如果猫和老鼠出现在同一个节点,猫获胜。
如果老鼠到达洞中,老鼠获胜。
如果某一位置重复出现(即,... | ### 动态规划
数据范围只有 $50$,使得本题的难度大大降低。
**定义 $f[k][i][j]$ 为当前进行了 $k$ 步,老鼠所在位置为 $i$,猫所在的位置为 $j$ 时,最终的获胜情况($0$ 为平局,$1$ 和 $2$ 分别代表老鼠和猫获胜),起始我们让所有的 $f[k][i][j] = -1$(为无效值),最终答案为 $f[0][1][2]$。**
不失一般性的考虑 $f[i][j][k]$ 该如何转移,根据题意,将当前所在位置 $i$ 和 $j$ 结合「游戏结束,判定游戏」的规则来分情况讨论:
* 若 $i = 0$,说明老鼠位于洞中,老鼠获胜,此时有 $f[k][i][j] = 1$;
* 若 $i = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.913` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/915. 分割数组（中等）.md | 915. 分割数组 | https://leetcode.cn/problems/partition-array-into-disjoint-intervals/solution/by-ac_oier-yyen/ | 中等 | [
"模拟"
] | 给定一个数组 `nums`,将其划分为两个连续子数组 `left` 和 `right`,使得:
* `left` 中的每个元素都小于或等于 `right` 中的每个元素。
* `left` 和 `right` 都是非空的。
* `left` 的长度要尽可能小。
在完成这样的分组后返回 `left` 的长度。
用例可以保证存在这样的划分方法。
示例 1:
```
输入:nums = [5,0,3,8,6]
输出:3
解释:left = [5,0,3],right = [8,6]
```
示例 2:
```
输入:nums = [1,1,1,0,6,12]
输出:4
解释:left = [1,1,1,0],right =... | ### 模拟
根据题意,我们知道本质是求分割点,使得分割点的「左边的子数组的最大值」小于等于「右边的子数组的最小值」。
我们可以先通过一次遍历(从后往前)统计出所有后缀的最小值 `min`,其中 `min[i] = x` 含义为下标范围在 $[i, n - 1]$ 的 $nums[i]$ 的最小值为 `x`,然后再通过第二次遍历(从前往后)统计每个前缀的最大值(使用单变量进行维护),找到第一个符合条件的分割点即是答案。
Java 代码:
```Java
class Solution {
public int partitionDisjoint(int[] nums) {
int n = nums.len... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.915` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/917. 仅仅反转字母（简单）.md | 917. 仅仅反转字母 | https://leetcode-cn.com/problems/reverse-only-letters/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-xrpt/ | 简单 | [
"双指针"
] | 给你一个字符串 `s` ,根据下述规则反转字符串:
* 所有非英文字母保留在原有位置。
* 所有英文字母(小写或大写)位置反转。
返回反转后的 `s` 。
示例 1:
```
输入:s = "ab-cd"
输出:"dc-ba"
```
示例 2:
```
输入:s = "a-bC-dEf-ghIj"
输出:"j-Ih-gfE-dCba"
```
示例 3:
```
输入:s = "Test1ng-Leet=code-Q!"
输出:"Qedo1ct-eeLg=ntse-T!"
```
提示
* $1 <= s.length <= 100$
* `s` 仅由 `ASCII` 值在范围 $[33, 122]$ 的字符组成
*... | ### 双指针
根据题意进行模拟即可,每次都使用 `i` 和 `j` 分别指向左端和右端可以被交换的字母,若当前指针指向的不是字母,则分别往中间移动,直到找到下一个可交换的字母位置,每次交换结束,两指针均往中间移动一位。
代码:
```Java
class Solution {
public String reverseOnlyLetters(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
for (int i = 0, j = n - 1; i < j; ) {
while (... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.917` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/919. 完全二叉树插入器（中等）.md | 919. 完全二叉树插入器 | https://leetcode.cn/problems/complete-binary-tree-inserter/solution/by-ac_oier-t9dh/ | 中等 | [
"模拟",
"BFS",
"树的遍历"
] | 完全二叉树 是每一层(除最后一层外)都是完全填充(即,节点数达到最大)的,并且所有的节点都尽可能地集中在左侧。
设计一种算法,将一个新节点插入到一个完整的二叉树中,并在插入后保持其完整。
实现 `CBTInserter` 类:
* `CBTInserter(TreeNode root)` 使用头节点为 `root` 的给定树初始化该数据结构;
* `CBTInserter.insert(int v)` 向树中插入一个值为 `Node.val == val` 的新节点 `TreeNode`。使树保持完全二叉树的状态,并返回插入节点 `TreeNode` 的父节点的值
* `CBTInserter.get_root()` 将返回... | ### BFS
起始使用数组对构造函数传入的 `root` 进行 `BFS` 层序遍历(由于仍要保留层序遍历顺序,因此使用下标指针 `cur` 来模拟出队位置)。
对于 `insert` 操作而言,我们要在数组(层序遍历顺序)中找到首个「存在左右空子节点」的父节点 `fa`,由于找到 `fa` 节点的过程数组下标单调递增,因此可以使用全局变量 `idx` 不断往后搜索,每次将新节点 `node` 添加到当前树后,需要将 `node` 添加到数组尾部。
`get_root` 操作则始终返回数组首位元素即可。
Java 代码:
```Java
class CBTInserter {
List<TreeNode> list... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.919` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/921. 使括号有效的最少添加（中等）.md | 921. 使括号有效的最少添加 | https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid/solution/by-ac_oier-9tn1/ | 中等 | [
"模拟"
] | 只有满足下面几点之一,括号字符串才是有效的:
* 它是一个空字符串,或者
* 它可以被写成 `AB` (`A` 与 `B` 连接), 其中 `A` 和 `B` 都是有效字符串,或者
* 它可以被写作 (`A`),其中 `A` 是有效字符串。
给定一个括号字符串 `s` ,移动 `N` 次,你就可以在字符串的任何位置插入一个括号。
* 例如,如果 `s = "()))"` ,你可以插入一个开始括号为 `"(()))"` 或结束括号为 `"())))"` 。
返回 为使结果字符串 `s` 有效而必须添加的最少括号数。
示例 1:
```
输入:s = "())"
输出:1
```
示例 2:
```
输入:s = "((("... | ### 模拟
一个介绍过很多次的做法 : 将「有效括号问题」转化为「分值有效性」的数学判定。
使用 `score` 代指处理过程中的得分,将 `(` 记为 `+1`,将 `)` 记为 `-1`。
一个有效的括号应当在整个过程中不出现负数,因此一旦 `score` 出现负数,我们需要马上增加 `(` 来确保合法性;当整个 `s` 处理完后,还需要添加 `socre` 等同的 `)` 来确保合法性。
Java 代码:
```Java
class Solution {
public int minAddToMakeValid(String s) {
int score = 0, ans = 0;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.921` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/926. 将字符串翻转到单调递增（中等）.md | 926. 将字符串翻转到单调递增 | https://leetcode.cn/problems/flip-string-to-monotone-increasing/solution/by-ac_oier-h0we/ | 中等 | [
"LIS",
"序列 DP",
"贪心",
"二分",
"动态规划",
"前缀和",
"枚举",
"容斥原理"
] | 如果一个二进制字符串,是以一些 $0$(可能没有 $0$)后面跟着一些 $1$(也可能没有 $1$)的形式组成的,那么该字符串是 单调递增 的。
给你一个二进制字符串 `s`,你可以将任何 $0$ 翻转为 $1$ 或者将 $1$ 翻转为 $0$ 。
返回使 `s` 单调递增的最小翻转次数。
示例 1:
```
输入:s = "00110"
输出:1
解释:翻转最后一位得到 00111.
```
示例 2:
```
输入:s = "010110"
输出:2
解释:翻转得到 011111,或者是 000111。
```
示例 3:
```
输入:s = "00011000"
输出:2
解释:翻转得到 00000000。... | ### LIS 问题贪心解
根据题意,不难想到将原题进行等价转换:**令 `s` 长度为 $n$,原问题等价于在 `s` 中找到最长不下降子序列,设其长度为 $ans$,那么对应的 $n - ans$ 即是答案。**
由于数据范围为 $1e5$,因此我们需要使用 `LIS` 问题的贪心求解方式:**使用 `g` 数组记录每个长度的最小结尾元素,即 `g[len] = x` 含义为长度为 $len$ 的最长不下降子序列的结尾元素为 $x$,然后在从前往后处理每个 $t = s[i]$ 时,由于是求解「最长不下降子序列」,等价于找「满足大于 $t$ 的最小下标」,这可以运用「二分」进行求解。**
> 不了解 `LIS` 问题或者不... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.926` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/927. 三等分（困难）.md | 927. 三等分 | https://leetcode.cn/problems/three-equal-parts/solution/by-ac_oier-9i2s/ | 困难 | [
"模拟"
] | 给定一个由 `0` 和 `1` 组成的数组 `arr`,将数组分成 `3` 个非空的部分 ,使得所有这些部分表示相同的二进制值。
如果可以做到,请返回任何 `[i, j]`,其中 `i+1 < j`,这样一来:
* `arr[0], arr[1], ..., arr[i]` 为第一部分;
* `arr[i + 1], arr[i + 2], ..., arr[j - 1]` 为第二部分;
* `arr[j], arr[j + 1], ..., arr[arr.length - 1]` 为第三部分。
* 这三个部分所表示的二进制值相等。
如果无法做到,就返回 `[-1, -1]`。
注意,在考虑每个部分所表示的二进制时,应当... | ### 模拟
心情不好,写的代码也不好。
就大概讲讲啥意思吧:
1. 先统计 `1` 的个数 `cnt`,若 `cnt = 0` 代表能够任意划分,直接返回 `[0, 2]`;
2. 若 `cnt` 不为 $3$ 的倍数,必然不能正常划分,返回无解 `[-1, -1]`,否则可知三段中必然每一段 `1` 的数量均为 $t = \frac{cnt}{3}$ 个;
3. 最后检查「三段中 `1` 的间隔位是否相同,后缀 `0` 个数是否相同」即可:
1. 创建二维数组 `ins` 记录三段中,相邻 `1` 之间的间隔情况,若存在间隔 `1` 不同,返回无解 `[-1, -1]`;
2. 预处理四个变量 `l1`、`... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.927` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/929. 独特的电子邮件地址（简单）.md | 929. 独特的电子邮件地址 | https://leetcode.cn/problems/unique-email-addresses/solution/by-ac_oier-d3zu/ | 简单 | [
"模拟"
] | 每个 有效电子邮件地址 都由一个 本地名 和一个 域名 组成,以 `'@'` 符号分隔。除小写字母之外,电子邮件地址还可以含有一个或多个 `'.'` 或 `'+'` 。
* 例如,在 `alice@leetcode.com` 中, `alice` 是 本地名 ,而 `leetcode.com` 是域名 。
如果在电子邮件地址的 本地名 部分中的某些字符之间添加句点('`.'`),则发往那里的邮件将会转发到本地名中没有点的同一地址。请注意,此规则 不适用于域名 。
* 例如,`"alice.z@leetcode.com”` 和 `“alicez@leetcode.com”` 会转发到同一电子邮件地址。
如果在 本地名 中添加加... | ### 模拟
根据题意进行模拟。
代码:
```Java
class Solution {
public int numUniqueEmails(String[] emails) {
Set<String> set = new HashSet<>();
for (String s : emails) {
StringBuilder sb = new StringBuilder();
int n = s.length(), i = 0;
boolean ok = true;
while (i < ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.929` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/930. 和相同的二元子数组（中等）.md | 930. 和相同的二元子数组 | https://leetcode-cn.com/problems/binary-subarrays-with-sum/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-hfoc0/ | 中等 | [
"前缀和",
"哈希表",
"双指针"
] | 给你一个二元数组 nums ,和一个整数 goal ,请你统计并返回有多少个和为 goal 的 非空 子数组。
子数组 是数组的一段连续部分。
示例 1:
```
输入:nums = [1,0,1,0,1], goal = 2
输出:4
解释:
如下面黑体所示,有 4 个满足题目要求的子数组:
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
```
示例 2:
```
输入:nums = [0,0,0,0,0], goal = 0
输出:15
```
提示:
* 1 <= nums.length <= 3 * $10^4$
* nums[i] 不是 0 就是 1
* 0 <... | ### 前缀和 + 哈希表
一个简单的想法是,先计算 $nums$ 的前缀和数组 $sum$,然后从前往后扫描 $nums$,对于右端点 $r$,通过前缀和数组可以在 $O(1)$ 复杂度内求得 $[0, r]$ 连续一段的和,根据容斥原理,我们还需要求得某个左端点 $l$,使得 $[0, r]$ 减去 $[0, l - 1]$ 和为 $t$,即满足 $sum[r] - sum[l - 1] = t$,这时候利用哈希表记录扫描过的 $sum[i]$ 的出现次数,可以实现 $O(1)$ 复杂度内求得满足要求的左端点个数。
该方法适用于 $nums[i]$ 值不固定为 $0$ 和 $1$ 的其他情况。
代码:
```Java
cl... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.930` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/933. 最近的请求次数（简单）.md | 933. 最近的请求次数 | https://leetcode-cn.com/problems/number-of-recent-calls/solution/by-ac_oier-evqe/ | 简单 | [
"分块",
"线段树(动态开点)"
] | 写一个 `RecentCounter` 类来计算特定时间范围内最近的请求。
请你实现 `RecentCounter` 类:
* `RecentCounter()` 初始化计数器,请求数为 $0$ 。
* `int ping(int t)` 在时间 $t$ 添加一个新请求,其中 $t$ 表示以毫秒为单位的某个时间,并返回过去 $3000$ 毫秒内发生的所有请求数(包括新请求)。确切地说,返回在 $[t-3000, t]$ 内发生的请求数。
保证 每次对 `ping` 的调用都使用比之前更大的 $t$ 值。
示例 1:
```
输入:
["RecentCounter", "ping", "ping", "ping", "ping"... | > 以下内容(支持任意的 $[l, r]$ 查询)基于我漏看了 $t$ 递增这一条件。由于 $t$ 递增,因此往前距离大于 $3000$ 的记录无须保留,从而简化了问题,可以使用队列直接做,今天打字很多了,不补充了。
### 基本分析
根据题意,题目涉及「单点修改」和「区间查询」,根据 [区间求和问题](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 的总结,可以使用「树状数组」和「线段树」进行求解。
但是留意到 $t$ 的数据范围为 $1e9$,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.933` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/934. 最短的桥（中等）.md | 934. 最短的桥 | https://leetcode.cn/problems/shortest-bridge/solution/by-ac_oier-56ly/ | 中等 | [
"并查集",
"双向 BFS"
] | 给你一个大小为 `n x n` 的二元矩阵 `g`,其中 `1` 表示陆地,`0` 表示水域。
岛是由四面相连的 `1` 形成的一个最大组,即不会与非组内的任何其他 `1` 相连,`g` 中恰好存在两座岛。
你可以将任意数量的 `0` 变为 `1` ,以使两座岛连接起来,变成一座岛。
返回必须翻转的 `0` 的最小数目。
示例 1:
```
输入:g = [[0,1],[1,0]]
输出:1
```
示例 2:
```
输入:g = [[0,1,0],[0,0,0],[0,0,1]]
输出:2
```
示例 3:
```
输入:g = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0... | ### 并查集 + 双向 BFS
**使用「并查集」将两个岛标记出来,然后将两个岛的点分别入队,再运用「双向 BFS」来找最短通路。**
对于所有满足 $g[i][j] = 1$ 的节点与其四联通的方向,值同为 $1$ 的节点进行并查集连通性维护。
随后建立两个队列 `d1` 和 `d2` 分别存储两个岛的节点(以二元组 $(x, y)$ 的方式出入队),并使用两个哈希表 `m1` 和 `m2` 来记录从两岛屿出发到达该节点所消耗的步数(以节点的一维编号为 `key`,以消耗步数为 `value`)。
最后是使用「双向 BFS」来求解使两岛屿联通的最小通路:每次从队列中较少的进行拓展,只有尚未被处理过的节点(没有被当前哈希表... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.934` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/937. 重新排列日志文件（简单）.md | 937. 重新排列日志文件 | https://leetcode-cn.com/problems/reorder-data-in-log-files/solution/by-ac_oier-ap28/ | 简单 | [
"排序"
] | 给你一个日志数组 logs。每条日志都是以空格分隔的字串,其第一个字为字母与数字混合的 标识符 。
有两种不同类型的日志:
* 字母日志:除标识符之外,所有字均由小写字母组成
* 数字日志:除标识符之外,所有字均由数字组成
请按下述规则将日志重新排序:
* 所有 字母日志 都排在 数字日志 之前。
* 字母日志 在内容不同时,忽略标识符后,按内容字母顺序排序;在内容相同时,按标识符排序。
* 数字日志 应该保留原来的相对顺序。
返回日志的最终顺序。
示例 1:
```
输入:logs = ["dig1 8 1 5 1","let1 art can","dig2 3 6","let2 own kit dig","let3 ... | ### 自定义类 + 排序
根据排序规则,我们需要对每个 $str[i]$ 进行裁剪处理,从而得知每个 $str[i]$ 是属于「字母日志」还是「数字日志」,以及得到 `sign` 部分和 `content` 部分。
在排序过程中,每个 $str[i]$ 会被访问多次,为了让每个 $str[i]$ 只进行一次这样的预处理工作,我们可以自定义类,将这部分工作放到类的实例化去做。
最后是简单将 $str[i]$ 转存成 `Log` 实例,自定义排序,用排序结果构造答案的基本逻辑。
代码:
```Java
class Solution {
class Log {
int type, idx;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.937` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/938. 二叉搜索树的范围和（简单）.md | 938. 二叉搜索树的范围和 | https://leetcode-cn.com/problems/range-sum-of-bst/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-q2fo/ | 简单 | [
"树的搜索",
"DFS",
"BFS"
] | 给定二叉搜索树的根结点 root,返回值位于范围 [low, high] 之间的所有结点的值的和。
示例 1:
```
输入:root = [10,5,15,3,7,null,18], low = 7, high = 15
输出:32
```
示例 2:
```
输入:root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
输出:23
```
提示:
* 树中节点数目在范围 [1, 2 * $10^4$] 内
* 1 <= Node.val <= $10^5$
* 1 <= low <= high <= $10^5$
* 所有 Node.val 互不相同 | ### 基本思路
这又是众多「二叉搜索树遍历」题目中的一道。
**二叉搜索树的中序遍历是有序的。**
只要对其进行「中序遍历」即可得到有序列表,在遍历过程中判断节点值是否符合要求,对于符合要求的节点值进行累加即可。
二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。**由于给定了值范围 $[low, high]$,因此可以在遍历过程中做一些剪枝操作,但并不影响时空复杂度。**
---
### 递归
递归写法十分简单,属于树的遍历中最简单的实现方式。
代码:
```Java
class Solution {
int low, high;
int ans;
public int rangeSu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.938` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/940. 不同的子序列 II（困难）.md | 940. 不同的子序列 II | https://leetcode.cn/problems/distinct-subsequences-ii/solution/by-ac_oier-ph94/ | 困难 | [
"序列 DP",
"动态规划"
] | 给定一个字符串 `s`,计算 `s` 的 不同非空子序列 的个数。
因为结果可能很大,所以返回答案需要对 $10^9 + 7$ 取余 。
字符串的 子序列 是经由原字符串删除一些(也可能不删除)字符但不改变剩余字符相对位置的一个新字符串。
例如,`"ace"` 是 `"abcde"` 的一个子序列,但 `"aec"` 不是。
示例 1:
```
输入:s = "abc"
输出:7
解释:7 个不同的子序列分别是 "a", "b", "c", "ab", "ac", "bc", 以及 "abc"。
```
示例 2:
```
输入:s = "aba"
输出:6
解释:6 个不同的子序列分别是 "a", "b", "ab... | ### 序列 DP
为了方便,我们令 `s` 下标从 $1$ 开始,定义 $f[i][j]$ 为考虑前 $i$ 个字符,且结尾字符为 $j$ 的不同子序列的个数,其中 $j$ 的范围为 $[0, 25]$ 代指小写字符 `a-z`。
我们有显而易见的初始化条件 $f[0][X] = 0$,最终答案为 $\sum_{i = 0}^{25}f[n][i]$。
不失一般性考虑 $f[i][j]$ 该如何转移,根据 $s[i]$ 是否为 $j$ 进行分情况讨论:
* $s[i] \neq j$ : 由于状态定义限定了结尾字符必须是 $j$,因而 $s[i]$ 必然不会用到,此时有:
$$
f[i][j] = f[i - 1][j]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.940` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/942. 增减字符串匹配（简单）.md | 942. 增减字符串匹配 | https://leetcode.cn/problems/di-string-match/solution/by-ac_oier-pvjk/ | 简单 | [
"贪心",
"构造",
"双指针"
] | 由范围 $[0,n]$ 内所有整数组成的 $n + 1$ 个整数的排列序列可以表示为长度为 $n$ 的字符串 `s` ,其中:
* 如果 `perm[i] < perm[i + 1]` ,那么 `s[i] == 'I'`
* 如果 `perm[i] > perm[i + 1]` ,那么 `s[i] == 'D'`
给定一个字符串 `s` ,重构排列 `perm` 并返回它。如果有多个有效排列 `perm`,则返回其中 任何一个 。
示例 1:
```
输入:s = "IDID"
输出:[0,4,1,3,2]
```
示例 2:
```
输入:s = "III"
输出:[0,1,2,3]
```
示例 3:
```
输入... | ### 构造
根据题意,我们需要设想一种「构造」方式,使得利用 `s` 创建序列的过程能够顺利进行。
直觉上容易猜想到当 $s[i] = I$ 时,使用当前最小值进行构造,当 $s[i] = D$ 时使用当前最大值进行构造。
使用「归纳法」来证明该做法的可行性(可用数的范围为 $[0, n]$,构造答案为 $ans$ 数组):
1. 对于边界情况:起始最小值为 $0$,最大值为 $n$:
* 若有 $s[0] = I$,使用 $0$ 进行构造(即有 $ans[0] = 0$),可用数范围变为 $[1, n]$,后续再利用 $s[1]$ 进行构造 $ans[1]$ 时,可以确保始终满足 $ans[1] > ans[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.942` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/943. 最短超级串（困难）.md | 943. 最短超级串 | https://leetcode.cn/problems/find-the-shortest-superstring/solution/gong-shui-san-xie-zhuang-ya-dp-yun-yong-p6hlz/ | 困难 | [
"状压 DP",
"位运算"
] | 给定一个字符串数组 `words`,找到以 `words` 中每个字符串作为子字符串的最短字符串。如果有多个有效最短字符串满足题目条件,返回其中 任意一个 即可。
我们可以假设 `words` 中没有字符串是 `words` 中另一个字符串的子字符串。
示例 1:
```
输入:words = ["alex","loves","leetcode"]
输出:"alexlovesleetcode"
解释:"alex","loves","leetcode" 的所有排列都会被接受。
```
示例 2:
```
输入:words = ["catg","ctaagt","gcta","ttca","atgcatc"]
输出:"gcta... | ### 状压 DP
为了方便,将 `words` 记为 `ws`。
预处理二维数组 `g` 来表示字符串 `ws[i]` 和 `ws[j]` 的重叠部分的长度:若 `g[i][j] = len` 代表字符串 `ws[i]` 长度为 `len` 的后缀与字符串 `ws[j]` 长度为 `len` 的前缀相同。
另外用一个二进制数 `status` 来代表当前超级串 `ans` 对 `ws` 的使用(覆盖)情况:**若 `status` 的第 `i` 位为 `1` 代表字符串 `ws[i]` 已被使用(即 `ws[i]` 已是 `ans` 的子串),若 `status` 的第 `i` 位为 `0` 代表 `ws[i]` 未被使用... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.943` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/944. 删列造序（简单）.md | 944. 删列造序 | https://leetcode.cn/problems/delete-columns-to-make-sorted/solution/by-ac_oier-smoz/ | 简单 | [
"模拟"
] | 给你由 $n$ 个小写字母字符串组成的数组 `strs`,其中每个字符串长度相等。
这些字符串可以每个一行,排成一个网格。例如,`strs = ["abc", "bce", "cae"]` 可以排列为:
```
abc
bce
cae
```
你需要找出并删除 不是按字典序升序排列的 列。在上面的例子(下标从 $0$ 开始)中,列 $0$(`'a', 'b', 'c'`)和列 $2$(`'c', 'e', 'e'`)都是按升序排列的,而列 $1$(`'b', 'c', 'a'`)不是,所以要删除列 $1$ 。
返回你需要删除的列数。
示例 1:
```
输入:strs = ["cba","daf","ghi"]
输出:1
... | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public int minDeletionSize(String[] strs) {
int n = strs.length, m = strs[0].length(), ans = 0;
out:for (int i = 0; i < m; i++) {
for (int j = 0, cur = -1; j < n; j++) {
int t = (int) strs[j].charAt(i);
if ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.942` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/946. 验证栈序列（中等）.md | 946. 验证栈序列 | https://leetcode.cn/problems/validate-stack-sequences/solution/by-ac_oier-84qd/ | 中等 | [
"模拟",
"栈",
"双指针"
] | 给定 `pushed` 和 `popped` 两个序列,每个序列中的 值都不重复,只有当它们可能是在最初空栈上进行的推入 `push` 和弹出 `pop` 操作序列的结果时,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出:true
解释:我们可以按以下顺序执行:
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
```
示例 2:
```
输入:push... | ### 栈运用模拟
根据题意,利用元素各不相同,我们使用一个栈来处理 `pushed` 数组,每次将 $pushed[i]$ 放入栈中,然后比较当前栈顶元素是否与待弹出元素相同(使用变量 `j` 来代指当前待弹出元素下标),若相等则弹栈并进行 `j` 自增,当所有的元素处理完后,栈为空说明栈序列合法。
Java 代码:
```Java
class Solution {
public boolean validateStackSequences(int[] pushed, int[] popped) {
Deque<Integer> d = new ArrayDeque<>();
for (... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.946` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/950. 按递增顺序显示卡牌（中等）.md | 950. 按递增顺序显示卡牌 | https://leetcode.cn/problems/reveal-cards-in-increasing-order/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-nu48/ | 中等 | [
"模拟",
"队列",
"排序",
"构造"
] | 牌组中的每张卡牌都对应有一个唯一的整数。你可以按你想要的顺序对这套卡片进行排序。
最初,这些卡牌在牌组里是正面朝下的(即,未显示状态)。
现在,重复执行以下步骤,直到显示所有卡牌为止:
1. 从牌组顶部抽一张牌,显示它,然后将其从牌组中移出。
2. 如果牌组中仍有牌,则将下一张处于牌组顶部的牌放在牌组的底部。
3. 如果仍有未显示的牌,那么返回步骤 1。否则,停止行动。
返回能以递增顺序显示卡牌的牌组顺序。
答案中的第一张牌被认为处于牌堆顶部。
示例:
```
输入:[17,13,11,2,3,5,7]
输出:[2,13,3,11,5,17,7]
解释:
我们得到的牌组顺序为 [17,13,11,2,3,5,7](这... | ### 模拟
根据题意,我们可以先使用双端队列对 `deck` 进行一次模拟,并用哈希表记下每个元素 $deck[i]$ 的显示顺序(利用 $deck[i]$ 元素各不相同,可直接用 $deck[i]$ 作为 `key`)。
随后考虑如何通过哈希表来构建答案数组 `ans`。
假设原数组中的 $deck[i]$ 为首次显示的卡牌,那么 $ans[i]$ 应该放置 `deck` 中最小的元素,同理若 $deck[j]$ 若最后显示的卡牌,则 $ans[j]$ 应放置 `deck` 中的最大元素。
为了方便找 `deck` 中第 $k$ 大元素,可对 `deck` 进行拷贝并排序。
Java 代码:
```Java
class... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.950` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/951-960/952. 按公因数计算最大组件大小（困难）.md | 952. 按公因数计算最大组件大小 | https://leetcode.cn/problems/largest-component-size-by-common-factor/solution/by-ac_oier-mw04/ | 困难 | [
"数学",
"并查集"
] | 给定一个由不同正整数的组成的非空数组 `nums`,考虑下面的图:
* 有 `nums.length` 个节点,按从 `nums[0]` 到 `nums[nums.length - 1]` 标记;
* 只有当 `nums[i]` 和 `nums[j]` 共用一个大于 $1$ 的公因数时,`nums[i]` 和 `nums[j]`之间才有一条边。
返回 图中最大连通组件的大小 。
示例 1:
```
输入:nums = [4,6,15,35]
输出:4
```
示例 2:
```
输入:nums = [20,50,9,63]
输出:2
```
示例 3:
```
输入:nums = [2,3,6,7,4,12,21,3... | ### 枚举质因数 + 并查集
先考虑如何使用 `nums` 进行建图,`nums` 大小为 $n = 2 \times 10^4$,枚举所有点对并通过判断两数之间是否存在边的做法复杂度为 $O(n^2\sqrt{M})$(其中 $M = 1e5$ 为 $nums[i]$ 的最大值),无须考虑。
而不通过「枚举点 + 求公约数」的建图方式,可以对 $nums[i]$ 进行质因数分解(复杂度为 $O(\sqrt{nums[i]})$),假设其分解出来的质因数集合为 $S$,我们可以建立从 $S_{k}$ 到 $nums[i]$ 的映射关系,若 $nums[i]$ 与 $nums[j]$ 存在边,则 $nums[i]$ 和 $num... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.952` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/951-960/953. 验证外星语词典（简单）.md | 953. 验证外星语词典 | https://leetcode.cn/problems/verifying-an-alien-dictionary/solution/by-ac_oier-sxf1/ | 简单 | [
"排序",
"模拟"
] | 某种外星语也使用英文小写字母,但可能顺序 `order` 不同。字母表的顺序(`order`)是一些小写字母的排列。
给定一组用外星语书写的单词 `words`,以及其字母表的顺序 `order`,只有当给定的单词在这种外星语中按字典序排列时,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出:true
解释:在该语言的字母表中,'h' 位于 'l' 之前,所以单词序列是按字典序排列的。
```
示例 2:
```
输入:words = ["word","worl... | ### 自定义排序
为了快速判断某两个字符在字典序的前后关系,先使用一个大小与字符集相等的数组对 `order` 进行转存。
然后对 `words` 进行拷贝复制得到 `clone`,并执行自定义排序,最后根据排序前后顺序是否相等来返回答案。
代码:
```Java
class Solution {
public boolean isAlienSorted(String[] words, String order) {
int[] ord = new int[26];
for (int i = 0; i < 26; i++) ord[order.charAt(i) - 'a'] = i;... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.953` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/951-960/954. 二倍数对数组（中等）.md | 954. 二倍数对数组 | https://leetcode-cn.com/problems/array-of-doubled-pairs/solution/by-ac_oier-d1z7/ | 中等 | [
"优先队列(堆)",
"构造",
"哈希表",
"拓扑排序"
] | 给定一个长度为偶数的整数数组 `arr`,只有对 `arr` 进行重组后可以满足 “对于每个$ 0 <= i < len(arr) / 2$,都有 $arr[2 \times i + 1] = 2 \times arr[2 \times i]$” 时,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:arr = [3,1,3,6]
输出:false
```
示例 2:
```
输入:arr = [2,1,2,6]
输出:false
```
示例 3:
```
输入:arr = [4,-2,2,-4]
输出:true
解释:可以用 [-2,-4] 和 [2,4] 这两组组成 [-2,-4,2,4] ... | ### 逐个构造 + 优先队列
整理一下题意:是否能对 `arr` 进行重组,使得每一个奇数位置的值均是前一个位置的值的两倍,即凑成 $\frac{n}{2}$ 组形如 $(x, 2 \times x)$ 的数对。
对于一个任意的有理数而言,对其乘 $2$ 仅会改变数值的大小,而不会改变其方向(正负性质)。
因此如果我们每次都拿最接近 $0$ 的值作为起点,整个构造过程就是唯一确定的。
具体的,我们可以借助优先队列(堆)来实现,构造一个以与 $0$ 值距离作为基准的小根堆。每次从堆中取出元素 $x$,根据当前元素 $x$ 是否被「预定」过进行分情况讨论:
* 当前值 $x$ 没有被预定过,说明 $x$ 必然是数对中的「绝对... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.954` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/961-970/961. 在长度 2N 的数组中找出重复 N 次的元素（简单）.md | 961. 在长度 2N 的数组中找出重复 N 次的元素 | https://leetcode.cn/problems/n-repeated-element-in-size-2n-array/solution/by-ac_oier-bslq/ | 简单 | [
"模拟",
"计数",
"构造",
"哈希表"
] | 给你一个整数数组 `nums` ,该数组具有以下属性:
* $nums.length == 2 \times n$
* `nums` 包含 $n + 1$ 个 不同的 元素
* `nums` 中恰有一个元素重复 $n$ 次
找出并返回重复了 $n$ 次的那个元素。
示例 1:
```
输入:nums = [1,2,3,3]
输出:3
```
示例 2:
```
输入:nums = [2,1,2,5,3,2]
输出:2
```
示例 3:
```
输入:nums = [5,1,5,2,5,3,5,4]
输出:5
```
提示:
* $2 <= n <= 50004
* $nums.length == 2 \times n... | ### 计数模拟
根据题目给定的三个条件可推断出:数组中仅有一个元素出现多次,其余元素均出现一次。
又利用数据范围为 $10^4$,我们可以使用数组充当哈希表进行计数,当出现一个 $nums[i]$ 重复出现即是答案。
代码:
```Java
class Solution {
int[] cnts = new int[10010];
public int repeatedNTimes(int[] nums) {
for (int x : nums) {
if (++cnts[x] > 1) return x;
}
return -1;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.961` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/961-970/965. 单值二叉树（简单）.md | 965. 单值二叉树 | https://leetcode.cn/problems/univalued-binary-tree/solution/by-ac_oier-zxjl/ | 简单 | [
"DFS",
"BFS",
"二叉树",
"树的遍历",
"层序遍历"
] | 如果二叉树每个节点都具有相同的值,那么该二叉树就是单值二叉树。
只有给定的树是单值二叉树时,才返回 `true`;否则返回 `false`。
示例 1:
```
输入:[1,1,1,1,1,null,1]
输出:true
```
示例 2:
```
输入:[2,2,2,5,2]
输出:false
```
提示:
* 给定树的节点数范围是 $[1, 100]¥。
* 每个节点的值都是整数,范围为 $[0, 99]$ 。 | ### 递归
根据题意进行模拟即可。
代码:
```Java
class Solution {
int val = -1;
public boolean isUnivalTree(TreeNode root) {
if (val == -1) val = root.val;
if (root == null) return true;
if (root.val != val) return false;
return isUnivalTree(root.left) && isUnivalTree(root.right);
}
}
```
* ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.965` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/961-970/969. 煎饼排序（中等）.md | 969. 煎饼排序 | https://leetcode-cn.com/problems/pancake-sorting/solution/gong-shui-san-xie-mou-pao-pai-xu-yun-yon-c0mn/ | 中等 | [
"排序"
] | 给你一个整数数组 `arr`,请使用 **煎饼翻转** 完成对数组的排序。
一次煎饼翻转的执行过程如下:
* 选择一个整数 `k` ,$1 <= k <= arr.length$
* 反转子数组 `arr[0...k-1]`(下标从 $0$ 开始)
例如,`arr = [3,2,1,4]`,选择 `k = 3` 进行一次煎饼翻转,反转子数组 `[3,2,1]` ,得到 `arr = [1,2,3,4]` 。
以数组形式返回能使 `arr` 有序的煎饼翻转操作所对应的 `k` 值序列。任何将数组排序且翻转次数在 `10 * arr.length` 范围内的有效答案都将被判断为正确。
示例 1:
```
输入:[3,2,4,1... | ### 冒泡排序
由于每次我们都对「某段前缀」进行整体翻转,并且规定了翻转次数在一定范围内的方案均为合法翻转方案,同时 $arr$ 又是 $1$ 到 $n$ 的排列。
我们可以很自然想到「冒泡排序」:**每次确定未排序部分最右端的元素(最大值)。**
具体的,假设下标 $[k + 1, n - 1]$ 部分已有序,如果我们希望当前值 $t$ 出现在某个位置 $k$ 上,可以进行的操作为:
* 如果当前值 $t$ 已在 $k$ 上,无须进行操作;
* 如果当前值不在 $k$ 上,根据当前值是否在数组头部(下标为 $0$)进行分情况讨论:
* 当前值在数组头部(下标为 $0$),直接将 $[0, k]$ 部分进行翻转(将... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.969` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/971-980/978. 最长湍流子数组（中等）.md | 978. 最长湍流子数组 | https://leetcode-cn.com/problems/longest-turbulent-subarray/solution/xiang-jie-dong-tai-gui-hua-ru-he-cai-dp-3spgj/ | 中等 | [
"线性 DP",
"序列 DP"
] | 当 `A` 的子数组 $A[i], A[i+1], ..., A[j]$ 满足下列条件时,我们称其为湍流子数组:
* 若 $i <= k < j$,当 $k$ 为奇数时,$A[k] > A[k+1]$,且当 $k$ 为偶数时,$A[k] < A[k+1]$;
* 若 $i <= k < j$,当 $k$ 为偶数时,$A[k] > A[k+1]$ ,且当 $k$ 为奇数时,$A[k] < A[k+1]$。
也就是说,如果比较符号在子数组中的每个相邻元素对之间翻转,则该子数组是湍流子数组。
返回 `A` 的最大湍流子数组的长度。
示例 1:
```
输入:[9,4,2,10,7,8,8,1,9]
输出:5
解释:(A[1] > ... | ### 基本思路
本题其实是要我们求最长一段呈 `↗ ↘ ↗ ↘` 或者 `↘ ↗ ↘ ↗` 形状的数组长度。
看一眼数据范围,有 $40000$,那么枚举起点和终点,然后对划分出来的子数组检查是否为「湍流子数组」的朴素解法就不能过了。
朴素解法的复杂度为 $O(n^3)$ ,直接放弃朴素解法。
复杂度往下优化,其实就 $O(n)$ 的 DP 解法了。
---
### 动态规划
至于 DP 如何分析,通过我们会先考虑一维 DP 能否求解,不行再考虑二维 DP。
对于本题,**由于每个位置而言,能否「接着」上一个位置**形成「湍流」,取决于上一位置是由什么形状而来。
举个例子,对于样例 `[3,4,2]`,从 4 -... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.978` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/981-990/981. 基于时间的键值存储（中等）.md | 981. 基于时间的键值存储 | https://leetcode-cn.com/problems/time-based-key-value-store/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-h5et/ | 中等 | [
"设计数据结构",
"哈希表",
"二分",
"数组",
"红黑树"
] | 创建一个基于时间的键值存储类 `TimeMap`,它支持下面两个操作:
1. set(string key, string value, int timestamp)
* 存储键 key、值 value,以及给定的时间戳 timestamp。
2. get(string key, int timestamp)
* 返回先前调用 set(key, value, timestamp_prev) 所存储的值,其中 timestamp_prev <= timestamp。
* 如果有多个这样的值,则返回对应最大的 timestamp_prev 的那个值。
* 如果没有值,则返回空字符串("")。
示例 1:
```
输入:in... | ### 哈希表套数组
由于 `timestamp` 是严格递增,且没有删除 KV 的操作。
**我们可以使用哈希表套数组的方式进行实现,从而达到均摊 $O(1)$ 的插入操作和 $O(\log{n})$ 的查询操作。**
具体的,为了方便理解,我们可以先建一个 `Node` 类,类中包含键值对和时间戳信息。
然后使用一个全局哈希表 `map` 记录某个 `key` 对应了哪些 `Node`。其中多个 `Node` 是以动态数组的形式进行「以 `timestamp` 升序」存储:
* `set` 操作:以 $O(1)$ 的复杂度找到某个 `key` 对应的数组,利用 `timestamp` 严格递增的特性,以 $O(1)$ ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.981` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/981-990/985. 查询后的偶数和（中等）.md | 985. 查询后的偶数和 | https://leetcode.cn/problems/sum-of-even-numbers-after-queries/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-lwfq/ | 中等 | [
"模拟"
] | 给出一个整数数组 `A` 和一个查询数组 `queries`。
对于第 `i` 次查询,有 `val = queries[i][0]`, `index = queries[i][1]`,我们会把 `val` 加到 `A[index]` 上。然后,第 `i` 次查询的答案是 `A` 中偶数值的和。
(此处给定的 `index = queries[i][1]` 是从 `0` 开始的索引,每次查询都会永久修改数组 `A`。)
返回所有查询的答案。你的答案应当以数组 `answer` 给出,`answer[i]` 为第 `i` 次查询的答案。
示例:
```
输入:A = [1,2,3,4], queries = [[1,0],[-... | ### 模拟
为了方便,将 `queries` 记为 `qs`。
由于每次修改都是对 `A` 的永久修改,因此我们使用一个变量 `t` 来记录当前所有偶数和即可。
具体的,我们先统计原数组所有偶数和为 `t`,从前往后处理每个 $qs[i]$,若修改前的原值 $nums[qs[i][1]]$ 为偶数,我们需要将其从 `t` 中减去,再进行实际修改 `nums[qs[i][1]] += qs[i][0]`,若修改后值为偶数,则将其累加到 `t` 上。
Java 代码:
```Java
class Solution {
public int[] sumEvenAfterQueries(int[] nums, int[][... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.985` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/981-990/987. 二叉树的垂序遍历（困难）.md | 987. 二叉树的垂序遍历 | https://leetcode-cn.com/problems/vertical-order-traversal-of-a-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-h-wfm3/ | 困难 | [
"数据结构运用",
"二叉树",
"哈希表",
"排序",
"优先队列(堆)",
"DFS"
] | 给你二叉树的根结点 `root` ,请你设计算法计算二叉树的 垂序遍历 序列。
对位于 $(row, col)$ 的每个结点而言,其左右子结点分别位于 $(row + 1, col - 1)$ 和 $(row + 1, col + 1)$ 。树的根结点位于 $(0, 0)$ 。
二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束,按列索引每一列上的所有结点,形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点,则按结点的值从小到大进行排序。
返回二叉树的 垂序遍历 序列。
示例 1:
```
输入:root = [3,9,20,null,null,15,7]
输出:[[9],[3,15],[20],[7... | ### DFS + 哈希表 + 排序
根据题意,我们需要按照优先级「**“列号从小到大”,对于同列节点,“行号从小到大”,对于同列同行元素,“节点值从小到大”**」进行答案构造。
因此我们可以对树进行遍历,遍历过程中记下这些信息 $(col, row, val)$,然后根据规则进行排序,并构造答案。
我们可以先使用「哈希表」进行存储,最后再进行一次性的排序。
代码:
```Java
class Solution {
Map<TreeNode, int[]> map = new HashMap<>(); // col, row, val
public List<List<Integer>> verticalTr... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.987` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/992. K 个不同整数的子数组（困难）.md | 992. K 个不同整数的子数组 | https://leetcode-cn.com/problems/subarrays-with-k-different-integers/solution/miao-dong-xi-lie-xiang-jie-shuang-zhi-zh-9k8w/ | 困难 | [
"双指针",
"滑动窗口"
] | 给定一个正整数数组 $A$,如果 $A$ 的某个子数组中不同整数的个数恰好为 $K$,则称 $A$ 的这个连续、不一定不同的子数组为好子数组。
例如,$[1,2,3,1,2]$ 中有 $3$ 个不同的整数:$1$,$2$,以及 $3$。
返回 $A$ 中好子数组的数目。
示例 1:
```
输入:A = [1,2,1,2,3], K = 2
输出:7
解释:恰好由 2 个不同整数组成的子数组:[1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]
```
示例 2:
```
输入:A = [1,2,1,3,4], K = 3
输出:3
解释:恰好由 3 个不同整数... | ### 滑动窗口
对原数组每个 $nums[i]$ 而言:
1. 找到其左边「最远」满足出现 $k$ 个不同字符的下标,记为 $p$ ,这时候形成的区间为 $[p, i]$
2. 找到其左边「最远」满足出现 $k - 1$ 个不同字符的下标,记为 $j$ ,这时候形成的区间为 $[j, i]$
3. **那么对于 $j - p$ 其实就是代表以 $nums[i]$ 为右边界(必须包含 $num[i]$),不同字符数量「恰好」为 $k$ 的子数组数量**
我们使用 $lower$ 数组存起每个位置的 $p$;使用 $upper$ 数组存起每个位置的 $j$。
累积每个位置的 $upper[i] - lower[i]$ 就是答案... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.992` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/993. 二叉树的堂兄弟节点（简单）.md | 993. 二叉树的堂兄弟节点 | https://leetcode-cn.com/problems/cousins-in-binary-tree/solution/gong-shui-san-xie-shu-de-sou-suo-dfs-bfs-b200/ | 简单 | [
"树的搜索",
"BFS",
"DFS"
] | 在二叉树中,根节点位于深度 $0$ 处,每个深度为 $k$ 的节点的子节点位于深度 $k+1$ 处。
如果二叉树的两个节点深度相同,但 父节点不同 ,则它们是一对堂兄弟节点。
我们给出了具有唯一值的二叉树的根节点 $root$ ,以及树中两个不同节点的值 $x$ 和 $y$ 。
只有与值 $x$ 和 $y$ 对应的节点是堂兄弟节点时,才返回 $true$ 。否则,返回 $false$。
示例 1:
```
输入:root = [1,2,3,4], x = 4, y = 3
输出:false
```
示例 2:
```
输入:root = [1,2,3,null,4,null,5], x = 5, y = 4
输出:t... | ### DFS
显然,我们希望得到某个节点的「父节点」&「所在深度」,不难设计出如下「DFS 函数签名」:
```Java
/**
* 查找 t 的「父节点值」&「所在深度」
* @param root 当前搜索到的节点
* @param fa root 的父节点
* @param depth 当前深度
* @param t 搜索目标值
* @return [fa.val, depth]
*/
int[] dfs(TreeNode root, TreeNode fa, int depth, int t);
```
之后按照遍历的逻辑处理即可。
需要注意的时,我们需要区分出「搜索不到」和「搜索对象为 $root$(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.993` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/995. K 连续位的最小翻转次数（困难）.md | 995. K 连续位的最小翻转次数 | https://leetcode-cn.com/problems/minimum-number-of-k-consecutive-bit-flips/solution/po-su-tan-xin-jie-fa-yu-tan-xin-chai-fen-4lyy/ | 困难 | [
"贪心",
"差分"
] | 在仅包含 0 和 1 的数组 A 中,一次 K 位翻转包括选择一个长度为 K 的(连续)子数组,同时将子数组中的每个 0 更改为 1,而每个 1 更改为 0。
返回所需的 K 位翻转的最小次数,以便数组没有值为 0 的元素。如果不可能,返回 -1。
示例 1:
```
输入:A = [0,1,0], K = 1
输出:2
解释:先翻转 A[0],然后翻转 A[2]。
```
示例 2:
```
输入:A = [1,1,0], K = 2
输出:-1
解释:无论我们怎样翻转大小为 2 的子数组,我们都不能使数组变为 [1,1,1]。
```
示例 3:
```
输入:A = [0,0,0,1,0,1,1,0], K = 3
输出:... | ### 贪心解法
目标是将数组的每一位都变为 1 ,因此对于每一位 0 都需要翻转。
我们可以从前往后处理,遇到 0 则对后面的 `k` 位进行翻转。
这样我们的算法复杂度是 $O(nk)$ 的,数据范围是 3w(数量级为 $10^4$),极限数据下单秒的运算量在 $10^8$ 以上,会有超时风险。
```java []
class Solution {
public int minKBitFlips(int[] nums, int k) {
int n = nums.length;
int ans = 0;
for (int i = 0; i < n; i++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.995` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/997. 找到小镇的法官（简单）.md | 997. 找到小镇的法官 | https://leetcode-cn.com/problems/find-the-town-judge/solution/gong-shui-san-xie-jian-dan-chu-du-ru-du-5ms57/ | 简单 | [
"模拟",
"图论"
] | 在一个小镇里,按从 $1$ 到 $n$ 为 $n$ 个人进行编号。传言称,这些人中有一个是小镇上的秘密法官。
如果小镇的法官真的存在,那么:
* 小镇的法官不相信任何人。
* 每个人(除了小镇法官外)都信任小镇的法官。
* 只有一个人同时满足条件 $1$ 和条件 $24 。
给定数组 $trust$,该数组由信任对 $trust[i] = [a, b]$ 组成,表示编号为 $a$ 的人信任编号为 $b$ 的人。
如果小镇存在秘密法官并且可以确定他的身份,请返回该法官的编号。否则,返回 $-1$。
示例 1:
```
输入:n = 2, trust = [[1,2]]
输出:2
```
示例 2:
```
输入:n = 3... | ### 模拟
今天起晚了 🤣
令 $m$ 为 `trust` 数组长度,对于每个 $trust[i] = (a, b)$ 而言,看作是从 $a$ 指向 $b$ 的有向边。
遍历 `trust`,统计每个节点的「入度」和「出度」:若存在 $a -> b$,则 $a$ 节点「出度」加一,$b$ 节点「入度」加一。
最后遍历所有点,若存在「入度」数量为 $n - 1$,且「出度」数量为 $0$ 的节点即是法官。
代码:
```Java
class Solution {
public int findJudge(int n, int[][] trust) {
int[] in = new int[n + ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.997` 篇,系列开始于 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.