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/171-180/179. 最大数（中等）.md | 179. 最大数 | https://leetcode-cn.com/problems/largest-number/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-vn86e/ | 中等 | [
"贪心"
] | 给定一组非负整数 `nums`,重新排列每个数的顺序(每个数不可拆分)使之组成一个最大的整数。
注意:输出结果可能非常大,所以你需要返回一个字符串而不是整数。
示例 1:
```
输入:nums = [10,2]
输出:"210"
```
示例 2:
```
输入:nums = [3,30,34,5,9]
输出:"9534330"
```
示例 3:
```
输入:nums = [1]
输出:"1"
```
示例 4:
```
输入:nums = [10]
输出:"10"
```
提示:
* $1 <= nums.length <= 100$
* $0 <= nums[i] <= 10^9$ | ### 贪心
对于 $nums$ 中的任意两个值 $a$ 和 $b$,我们无法直接从常规角度上确定其大小/先后关系。
但我们可以根据「结果」来决定 $a$ 和 $b$ 的排序关系:
如果拼接结果 $ab$ 要比 $ba$ 好,那么我们会认为 $a$ 应该放在 $b$ 前面。
另外,注意我们需要处理前导零(最多保留一位)。
Java 代码:
```java
class Solution {
public String largestNumber(int[] nums) {
int n = nums.length;
String[] ss = new String[n];
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.179` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1711. 大餐计数（中等）.md | 1711. 大餐计数 | https://leetcode-cn.com/problems/count-good-meals/solution/gong-shui-san-xie-xiang-jie-san-chong-gu-nn4f/ | 中等 | [
"哈希表",
"位运算"
] | 大餐 是指 恰好包含两道不同餐品 的一餐,其美味程度之和等于 2 的幂。
你可以搭配 任意 两道餐品做一顿大餐。
给你一个整数数组 deliciousness ,其中 deliciousness[i] 是第 i 道餐品的美味程度,返回你可以用数组中的餐品做出的不同 大餐 的数量。结果需要对 $10^9$ + 7 取余。
注意,只要餐品下标不同,就可以认为是不同的餐品,即便它们的美味程度相同。
示例 1:
```
输入:deliciousness = [1,3,5,7,9]
输出:4
解释:大餐的美味程度组合为 (1,3) 、(1,7) 、(3,5) 和 (7,9) 。
它们各自的美味程度之和分别为 4 、8 、8 和... | ### 枚举前一个数(TLE)
一个朴素的想法是,从前往后遍历 $deliciousness$ 中的所有数,当遍历到下标 $i$ 的时候,回头检查下标小于 $i$ 的数是否能够与 $deliciousness[i]$ 相加形成 $2$ 的幂。
这样的做法是 $O(n^2)$ 的,防止同样的数值被重复计算,我们可以使用「哈希表」记录某个数出现了多少次,但这并不改变算法仍然是 $O(n^2)$ 的。
而且我们需要一个 `check` 方法来判断某个数是否为 $2$ 的幂:
* 朴素的做法是对 $x$ 应用试除法,当然因为精度问题,我们需要使用乘法实现试除;
* 另一个比较优秀的做法是利用位运算找到符合「大于等于 $x$」的最近的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1711` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1713. 得到子序列的最少操作次数（困难）.md | 1713. 得到子序列的最少操作次数 | https://leetcode-cn.com/problems/minimum-operations-to-make-a-subsequence/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-oj7yu/ | 困难 | [
"最长公共子序列",
"最长上升子序列",
"贪心",
"二分"
] | 给你一个数组 target ,包含若干 互不相同 的整数,以及另一个整数数组 arr ,arr 可能 包含重复元素。
每一次操作中,你可以在 arr 的任意位置插入任一整数。比方说,如果 arr = [1,4,1,2] ,那么你可以在中间添加 3 得到 [1,4,3,1,2] 。你可以在数组最开始或最后面添加整数。
请你返回 最少 操作次数,使得 target 成为 arr 的一个子序列。
一个数组的 子序列 指的是删除原数组的某些元素(可能一个元素都不删除),同时不改变其余元素的相对顺序得到的数组。比方说,[2,7,4] 是 [4,2,3,7,2,1,4] 的子序列(加粗元素),但 [2,4,2] 不是子序列。
示例 1:... | ### 基本分析
为了方便,我们令 $target$ 长度为 $n$,$arr$ 长度为 $m$,$target$ 和 $arr$ 的最长公共子序列长度为 $max$,不难发现最终答案为 $n - max$。
因此从题面来说,这是一道最长公共子序列问题(LCS)。
但朴素求解 LCS 问题复杂度为 $O(n * m)$,使用状态定义「**$f[i][j]$ 为考虑 `a` 数组的前 $i$ 个元素和 `b` 数组的前 $j$ 个元素的最长公共子序列长度为多少**」进行求解。
而本题的数据范围为 $10^5$,使用朴素求解 LCS 的做法必然超时。
一个很显眼的切入点是 $target$ 数组元素各不相同,当 LCS 问题增... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1713` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1716. 计算力扣银行的钱（简单）.md | 1716. 计算力扣银行的钱 | https://leetcode-cn.com/problems/calculate-money-in-leetcode-bank/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-ifit/ | 简单 | [
"数学",
"模拟"
] | Hercy 想要为购买第一辆车存钱。他 **每天** 都往力扣银行里存钱。
最开始,他在周一的时候存入 `1` 块钱。从周二到周日,他每天都比前一天多存入 `1` 块钱。在接下来每一个周一,他都会比 前一个周一 多存入 `1` 块钱。
给你 `n` ,请你返回在第 `n` 天结束的时候他在力扣银行总共存了多少块钱。
示例 1:
```
输入:n = 4
输出:10
解释:第 4 天后,总额为 1 + 2 + 3 + 4 = 10 。
```
示例 2:
```
输入:n = 10
输出:37
解释:第 10 天后,总额为 (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4) = 37 。注... | ### 模拟
根据题意进行模拟即可,分两步进行计算。
先计算完整周:共 $a = \left \lfloor \frac{n}{7} \right \rfloor$ 周,第一周起始日金额为 $1$,每周的起始日的金额递增 $1$,周内金额可使用「等差数列求和」公式直接求解。
然后再计算最后一周(若有)的金额:共 $b = n \pmod 7$ 天,使用紧接的起始日金额继续进行累加即可。
代码:
```Java
class Solution {
public int totalMoney(int n) {
int a = n / 7, b = n % 7;
int ans = 0, k ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1716` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1719. 重构一棵树的方案数（困难）.md | 1719. 重构一棵树的方案数 | https://leetcode-cn.com/problems/number-of-ways-to-reconstruct-a-tree/solution/gong-shui-san-xie-gou-zao-yan-zheng-he-f-q6fc/ | 困难 | [
"树"
] | 给你一个数组 `pairs`,其中 $pairs[i] = [x_i, y_i]$ ,并且满足:
* `pairs` 中没有重复元素
* $x_i < y_i$
令 ways 为满足下面条件的有根树的方案数:
* 树所包含的所有节点值都在 `pairs` 中。
* 一个数对 $[x_i, y_i]$ 出现在 `pairs` 中 当且仅当 $x_i$ 是 $y_i$ 的祖先或者 $y_i$ 是 $x_i$ 的祖先。
* 注意:构造出来的树不一定是二叉树。
两棵树被视为不同的方案当存在至少一个节点在两棵树中有不同的父节点。
请你返回:
* 如果 ways == 0 ,返回 0 。
* 如果 ways == 1 ,返回 1 。... | ### 构造 + 验证(合法性 + 非唯一性)
这道题是名副其实的困难题,我最早的提交时间是去年 $3$ 月,起初只能想到 $O(n * m)$ 的做法,对于一颗多叉树来说显然会 `TLE`,虽然到现在印象不深了,但如果不是之前做过,今天大概率会很晚才能发布题解。
该题突破口在于如何利用 `pairs` 构造出一种具体方案,然后辨别方案的合法性(是否返回 $0$)和方案中的某些点是否可相互替换(返回 $1$ 还是 $2$)。
给定 `pairs` 数组为父子关系,对于 $pairs[i] = (a,b)$ 而言,既可以是 $a$ 为 $b$ 祖宗节点,也可以是 $b$ 为 $a$ 祖宗节点。
题目的「当且仅当」含义为所有的 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1719` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1720. 解码异或后的数组（简单）.md | 1720. 解码异或后的数组 | https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/ | 简单 | [
"数学",
"模拟",
"位运算"
] | 未知 整数数组 arr 由 n 个非负整数组成。
经编码后变为长度为 n - 1 的另一个整数数组 encoded ,其中 encoded[i] = arr[i] XOR arr[i + 1] 。
例如,arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3] 。
给你编码后的数组 encoded 和原数组 arr 的第一个元素 first(arr[0])。
请解码返回原数组 arr 。
可以证明答案存在并且是唯一的。
示例 1:
```
输入:encoded = [1,2,3], first = 1
输出:[1,0,2,1]
解释:若 arr = [1,0,2,1] ,那么 first = ... | ### 模拟
这是道模拟(重拳出击)题。
根据题目给定的规则,利用如下异或性质从头做一遍即可:
1. 相同数值异或,结果为 $0$
2. 任意数值与 $0$ 进行异或,结果为数值本身
3. 异或本身满足交换律
已知 `encoded[i-1] = arr[i-1] XOR arr[i]`,将等式两边同时「异或」上 `arr[i-1]`。可得:
1. `encoded[i-1] XOR arr[i-1] = arr[i-1] XOR arr[i] XOR arr[i-1]`
2. 结合「性质三」和「性质一」,可化简「右式」得 `encoded[i-1] XOR arr[i-1] = arr[i] XOR 0`
3. 结合「性... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1720` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1721-1730/1723. 完成所有工作的最短时间（困难）.md | 1723. 完成所有工作的最短时间 | https://leetcode-cn.com/problems/find-minimum-time-to-finish-all-jobs/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-4epdd/ | 困难 | [
"DFS",
"模拟退火",
"启发式搜索",
"随机化"
] | 给你一个整数数组 `jobs` ,其中 $jobs[i]$ 是完成第 $i$ 项工作要花费的时间。
请你将这些工作分配给 $k$ 位工人。所有工作都应该分配给工人,且每项工作只能分配给一位工人。
工人的 工作时间 是完成分配给他们的所有工作花费时间的总和。
请你设计一套最佳的工作分配方案,使工人的 最大工作时间 得以 最小化 。
返回分配方案中尽可能「最小」的 最大工作时间 。
示例 1:
```
输入:jobs = [3,2,3], k = 3
输出:3
解释:给每位工人分配一项工作,最大工作时间是 3 。
```
示例 2:
```
输入:jobs = [1,2,4,7,8], k = 2
输出:11
解释:按... | ### DFS(TLE)
一看数据范围只有 $12$,我猜不少同学上来就想 `DFS`,但是注意 `n` 和 `k` 同等规模的,爆搜(`DFS`)的复杂度是 $O(k^n)$ 的。
那么极限数据下的计算量为 $12^{12}$,远超运算量 $10^7$。
抱着侥幸的心理一运行,很顺利的卡在了 $43/60$ 个数据:
```Java
[254,256,256,254,251,256,254,253,255,251,251,255] // n = 12
10 // k = 10
```
代码:
```Java
class Solution {
int[] jobs;
int n, k;
int an... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1723` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1721-1730/1725. 可以形成最大正方形的矩形数目（简单）.md | 1725. 可以形成最大正方形的矩形数目 | https://leetcode-cn.com/problems/number-of-rectangles-that-can-form-the-largest-square/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-7756/ | 简单 | [
"模拟"
] | 给你一个数组 `rectangles`,其中 $rectangles[i] = [l_i, w_i]$ 表示第 $i$ 个矩形的长度为 $l_i$ 、宽度为 $w_i$ 。
如果存在 `k` 同时满足 $k <= l_i$ 和 $k <= w_i$ ,就可以将第 `i` 个矩形切成边长为 `k` 的正方形。例如,矩形 $[4,6]$ 可以切成边长最大为 $4$ 的正方形。
设 `maxLen` 为可以从矩形数组 `rectangles` 切分得到的 最大正方形 的边长。
请你统计有多少个矩形能够切出边长为 `maxLen` 的正方形,并返回矩形 数目 。
示例 1:
```
输入:rectangles = [[5,8],[3... | ### 模拟
根据题意,对于任意一个矩形 $rectangles[i]$ 而言,其能分割出的最大方形边长为 $\min(rectangles[i][0], rectangles[i][1])$。
我们在遍历过程中使用变量 `max` 维护最大边长,同时使用 `ans` 记录能够分割出最大边长 `max` 的矩形数量。
代码:
```Java
class Solution {
public int countGoodRectangles(int[][] rectangles) {
int max = 0, ans = 0;
for (int[] r : rectangles) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1725` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1721-1730/1728. 猫和老鼠 II（困难）.md | 1728. 猫和老鼠 II | https://leetcode.cn/problems/cat-and-mouse-ii/solution/by-ac_oier-gse8/ | 困难 | [
"博弈论",
"动态规划",
"记忆化搜索"
] | 一只猫和一只老鼠在玩一个叫做猫和老鼠的游戏。
它们所处的环境设定是一个 `rows x cols` 的方格 `grid` ,其中每个格子可能是一堵墙、一块地板、一位玩家(猫或者老鼠)或者食物。
* 玩家由字符 `'C'` (代表猫)和 `'M'` (代表老鼠)表示。
* 地板由字符 `'.'` 表示,玩家可以通过这个格子。
* 墙用字符 `'#'` 表示,玩家不能通过这个格子。
* 食物用字符 `'F'` 表示,玩家可以通过这个格子。
* 字符 `'C'` , `'M'` 和 `'F'` 在 `grid` 中都只会出现一次。
猫和老鼠按照如下规则移动:
* 老鼠 先移动 ,然后两名玩家轮流移动。
* 每一次操作时,猫和老鼠可... | ### 博弈论 DP
当时在 [(题解) 913. 猫和老鼠](https://leetcode.cn/problems/cat-and-mouse/solution/gong-shui-san-xie-dong-tai-gui-hua-yun-y-0bx1/) 没能证出来更小 $K$ 值(回合数)的正确性,用的 $2n^2$ 做的 ,其余题解说 $2 n$ 合法,后来也被证实是错误的。
对于本题如果用相同的分析思路,状态数多达 $8 \times 8 \times 8 \times 8 \times 2 = 8192$ 种,题目很贴心调整了规则为 $1000$ 步以内为猫获胜,但证明 $K$ 的理论上界仍是困难(上次分析不出来... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1728` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1732. 找到最高海拔（简单）.md | 1732. 找到最高海拔 | https://leetcode.cn/problems/find-the-highest-altitude/solution/by-ac_oier-a0j8/ | 简单 | [
"模拟"
] | 有一个自行车手打算进行一场公路骑行,这条路线总共由 $n + 1$ 个不同海拔的点组成。自行车手从海拔为 `0` 的点 `0` 开始骑行。
给你一个长度为 `n` 的整数数组 `gain`,其中 `gain[i]` 是点 `i` 和点 `i + 1` 的 净海拔高度差($0 <= i < n$)。请你返回 最高点的海拔 。
示例 1:
```
输入:gain = [-5,1,5,0,-7]
输出:1
解释:海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
```
示例 2:
```
输入:gain = [-4,-3,-2,-1,4,3,2]
输出:0
解释:海拔高度依次为 [0,-4,-7,-9,-... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int largestAltitude(int[] g) {
int cur = 0, ans = 0;
for (int x : g) {
cur += x;
ans = Math.max(ans, cur);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function largestAltitude(g: number[]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1732` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1734. 解码异或后的排列（中等）.md | 1734. 解码异或后的排列 | https://leetcode-cn.com/problems/decode-xored-permutation/solution/gong-shui-san-xie-note-bie-pian-li-yong-zeh6o/ | 中等 | [
"数学",
"异或"
] | 给你一个整数数组 perm ,它是前 n 个正整数的排列,且 n 是个 奇数 。
它被加密成另一个长度为 n - 1 的整数数组 encoded ,满足 encoded[i] = perm[i] XOR perm[i + 1] 。比方说,如果 perm = [1,3,2] ,那么 encoded = [2,1] 。
给你 encoded 数组,请你返回原始数组 perm 。题目保证答案存在且唯一。
示例 1:
```
输入:encoded = [3,1]
输出:[1,2,3]
解释:如果 perm = [1,2,3] ,那么 encoded = [1 XOR 2,2 XOR 3] = [3,1]
```
示例 2:
```... | ### 基本分析
我们知道异或运算有如下性质:
1. 相同数值异或,结果为 $0$
2. 任意数值与 $0$ 进行异或,结果为数值本身
3. 异或本身满足交换律
本题与 [1720. 解码异或后的数组](https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/) 的主要区别是没有给出首位元素。
因此,求得答案数组的「首位元素」或者「结尾元素」可作为本题切入点。
---
### 数学 & 模拟
我们定义答案数组为 `ans[]`,`ans[]` 数组的长度为 `n`... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1734` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1736. 替换隐藏数字得到的最晚时间（简单）.md | 1736. 替换隐藏数字得到的最晚时间 | https://leetcode-cn.com/problems/latest-time-by-replacing-hidden-digits/solution/gong-shui-san-xie-ti-huan-yin-cang-shu-z-2l1h/ | 简单 | [
"贪心"
] | 给你一个字符串 `time`,格式为 `hh:mm`(小时:分钟),其中某几位数字被隐藏(用 `?` 表示)。
有效的时间为 `00:00` 到 `23:59` 之间的所有时间,包括 `00:00` 和 `23:59` 。
替换 `time` 中隐藏的数字,返回你可以得到的最晚有效时间。
示例 1:
```
输入:time = "2?:?0"
输出:"23:50"
解释:以数字 '2' 开头的最晚一小时是 23 ,以 '0' 结尾的最晚一分钟是 50 。
```
示例 2:
```
输入:time = "0?:3?"
输出:"09:39"
```
示例 3:
```
输入:time = "1?:22"
输出:"19:2... | ### 贪心 + 模拟
规则十分简单,对每一位进行分情况讨论即可:
* 第一位:如果需要被替换,优先替换为 `2`,当然前提是第二位不能超过 `4`。否则会出现 `24:xx`、`25:xx` 等;
* 第二位:如果需要被替换,根据第一位是什么,决定替换为 `9` 还是 `3`;
* 第三位:固定为 `:`;
* 第四位:如果需要被替换,替换为 `5`;
* 第五位:如果需要被替换,替换为 `9`。
代码:
```Java
class Solution {
public String maximumTime(String time) {
StringBuilder sb = new StringBuil... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1737. 满足三条件之一需改变的最少字符数（中等）.md | 1737. 满足三条件之一需改变的最少字符数 | https://leetcode.cn/problems/change-minimum-characters-to-satisfy-one-of-three-conditions/solution/by-ac_oier-vs5u/ | 中等 | [
"枚举",
"计数",
"模拟"
] | 给你两个字符串 `a` 和 `b` ,二者均由小写字母组成。
一步操作中,你可以将 `a` 或 `b` 中的 任一字符 改变为 任一小写字母 。
操作的最终目标是满足下列三个条件 之一 :
* `a` 中的 每个字母 在字母表中 **严格小于** `b` 中的 每个字母 。
* `b` 中的 每个字母 在字母表中 **严格小于** `a` 中的 每个字母 。
* `a` 和 `b` 都 由 同一个 字母组成。
返回达成目标所需的 最少 操作数。
示例 1:
```
输入:a = "aba", b = "caa"
输出:2
解释:满足每个条件的最佳方案分别是:
1) 将 b 变为 "ccc",2 次操作,满足 a 中... | ### 计数 + 枚举
使用 `c1` 和 `c2` 对字符串 `a` 和 `b` 分别进行词频统计,记字符串 `a` 和 `b` 的长度为 $n$ 和 $m$。
然后枚举字符 $i$,分别对三种情况的修改次数进行统计:
1. 对应条件 $1$:目的是要将字符串 `a` 中所有的字符变得「严格小于」字符 $i$,将字符串 `b` 中的所有字符变成「不小于/大于等于」字符 $i$。
这可以分别统计 `a` 中大小满足「大于等于」字符 $i$ 的字符数量,以及 `b` 中大小满足「小于」字符 $i$ 数量,两者之和即是满足该条件的最小修改次数。
注意,当 $i = 0$(含义为枚举到小写字母 $a$)时,需要跳过,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1737` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1738. 找出第 K 大的异或坐标值（中等）.md | 1738. 找出第 K 大的异或坐标值 | https://leetcode-cn.com/problems/find-kth-largest-xor-coordinate-value/solution/gong-shui-san-xie-xiang-jie-li-yong-er-w-ai0d/ | 中等 | [
"Top K",
"数学",
"前缀和"
] | 给你一个二维矩阵 matrix 和一个整数 k ,矩阵大小为 m x n 由非负整数组成。
矩阵中坐标 (a, b) 的 值 可由对所有满足 0 <= i <= a < m 且 0 <= j <= b < n 的元素 matrix[i][j](下标从 0 开始计数)执行异或运算得到。
请你找出 matrix 的所有坐标中第 k 大的值(k 的值从 1 开始计数)。
示例 1:
```
输入:matrix = [[5,2],[1,6]], k = 1
输出:7
解释:坐标 (0,1) 的值是 5 XOR 2 = 7 ,为最大的值。
```
示例 2:
```
输入:matrix = [[5,2],[1,6]], k = 2
... | ### 基本分析
根据题意,我们知道其实就是求「所有子矩阵中第 $k$ 大的异或和」,同时规定所有子矩阵的左上角端点为 $(0, 0)$。
数据范围为 $10^3$,因此「枚举所有右下角」并「每次计算子矩阵异或和」的朴素做法 $O(m^2 * n^2)$ 不用考虑。
要在全局中找最优,「枚举所有右下角」过程不可避免,我们可以优化「每次计算子矩阵异或和」的过程。
这个分析过程与 [1310. 子数组异或查询](https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-r... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1738` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1742. 盒子中小球的最大数量（简单）.md | 1742. 盒子中小球的最大数量 | https://leetcode.cn/problems/maximum-number-of-balls-in-a-box/solution/by-ac_oier-3mxf/ | 简单 | [
"哈希表",
"模拟"
] | 你在一家生产小球的玩具厂工作,有 `n` 个小球,编号从 `lowLimit` 开始,到 `highLimit` 结束(包括 `lowLimit` 和 `highLimit` ,即 `n == highLimit - lowLimit + 1`)。另有无限数量的盒子,编号从 `1` 到 `infinity` 。
你的工作是将每个小球放入盒子中,其中盒子的编号应当等于小球编号上每位数字的和。例如,编号 `321` 的小球应当放入编号 `3 + 2 + 1 = 6` 的盒子,而编号 `10` 的小球应当放入编号 `1 + 0 = 1` 的盒子。
给你两个整数 `lowLimit` 和 `highLimit` ,返回放有最多小球的盒子... | ### 模拟
数据范围 $n = 1e5$,因此最大盒子编号 `99999 = 5 * 9 = 45`,我们可以用一个大小为 $50$ 的数组 `cnts` 来统计每个编号盒子中小球的数量,$cnts[idx] = x$ 含义为编号为 $idx$ 的盒子有 $x$ 个小球。
Java 代码:
```Java
class Solution {
public int countBalls(int l, int r) {
int ans = 0;
int[] cnts = new int[50];
for (int i = l; i <= r; i++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1742` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1743. 从相邻元素对还原数组（中等）.md | 1743. 从相邻元素对还原数组 | https://leetcode-cn.com/problems/restore-the-array-from-adjacent-pairs/solution/gong-shui-san-xie-yi-ti-shuang-jie-dan-x-elpx/ | 中等 | [
"哈希表",
"双指针",
"模拟"
] | 存在一个由 `n` 个不同元素组成的整数数组 `nums` ,但你已经记不清具体内容,好在你还记得 `nums` 中的每一对相邻元素。
给你一个二维整数数组 `adjacentPairs` ,大小为 `n - 1` ,其中每个 $adjacentPairs[i] = [u_i, v_i]$ 表示元素 $u_i$ 和 $v_i$ 在 `nums` 中相邻。
题目数据保证所有由元素 `nums[i]` 和 `nums[i+1]` 组成的相邻元素对都存在于 `adjacentPairs` 中,存在形式可能是 `[nums[i], nums[i+1]]` ,也可能是 `[nums[i+1], nums[i]]` 。这些相邻元素对可以「按... | ### 单向构造(哈希表计数)
根据题意,由于所有的相邻关系都会出现在 $nums$ 中,假设其中一个合法数组为 $ans$,长度为 $n$。
那么显然 $ans[0]$ 和 $ans[n - 1]$ 在 $nums$ 中只存在一对相邻关系,而其他 $ans[i]$ 则存在两对相邻关系。
因此我们可以使用「哈希表」对 $nums$ 中出现的数值进行计数,找到“出现一次”的数值作为 $ans$ 数值的首位,然后根据给定的相邻关系进行「单向构造」,为了方便找到某个数其相邻的数是哪些,我们还需要再开一个「哈希表」记录相邻关系。
Java 代码:
```Java
class Solution {
public int[] r... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1743` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗？（中等）.md | 1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗? | https://leetcode-cn.com/problems/can-you-eat-your-favorite-candy-on-your-favorite-day/solution/gong-shui-san-xie-qian-zhui-he-qiu-jie-c-b38y/ | 中等 | [
"前缀和"
] | 给你一个下标从 `0` 开始的正整数数组 `candiesCount`,其中 `candiesCount[i]` 表示你拥有的第 `i` 类糖果的数目。
同时给你一个二维数组 `queries` ,其中 $queries[i] = [favoriteType_{i}, favoriteDay_{i}, dailyCap_{i}]$ 。
你按照如下规则进行一场游戏:
* 你从第 `0` 天开始吃糖果。
* 你在吃完 所有 第 `i - 1` 类糖果之前,不能 吃任何一颗第 `i` 类糖果。
* 在吃完所有糖果之前,你必须每天 至少 吃 一颗 糖果。
请你构建一个布尔型数组 `answer`,满足 `answer.length ... | ### 基本分析
根据题意,在处理某个询问时,每天的吃糖数量为 $[1, queries[i][2]]$,因此我们可以计算出「最早/最晚」吃到第 $queries[i][0]$ 类糖果的时间,然后判断 $queries[i][1]$ 是否落在范围内,若落在范围内返回则有 $ans[i]$ 为 `True`,否则为 `False`。
---
### 前缀和
问题转换为如何快速求得「最早/最晚」吃到第 $queries[i][0]$ 类糖果的时间。
我们需要先预处理出 $candiesCount$ 的前缀和数组 $sum$(下标从 $1$ 开始),方便快速求得第 $i$ 类糖果之前有多少糖果。
为了方便,在处理某个询问时,我... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1744` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1748. 唯一元素的和（简单）.md | 1748. 唯一元素的和 | https://leetcode-cn.com/problems/sum-of-unique-elements/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-atnd/ | 简单 | [
"模拟",
"哈希表",
"双指针",
"排序"
] | 给你一个整数数组 nums 。数组中唯一元素是那些只出现「恰好一次」的元素。
请你返回 nums 中唯一元素的和 。
示例 1:
```
输入:nums = [1,2,3,2]
输出:4
解释:唯一元素为 [1,3] ,和为 4 。
```
示例 2:
```
输入:nums = [1,1,1,1,1]
输出:0
解释:没有唯一元素,和为 0 。
```
示例 3 :
```
输入:nums = [1,2,3,4,5]
输出:15
解释:唯一元素为 [1,2,3,4,5] ,和为 15 。
```
提示:
* 1 <= nums.length <= 100
* 1 <= nums[i] <= 100 | ### 排序 + 双指针
根据题意,其中一个做法是先对 `nums` 进行排序,使用双指针找到值相同的连续段 $[i, j)$,若连续段长度为 $1$,则将该值累加到答案。
代码:
```Java
class Solution {
public int sumOfUnique(int[] nums) {
Arrays.sort(nums);
int n = nums.length, ans = 0;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && nums[j] ==... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1748` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1749. 任意子数组和的绝对值的最大值（中等）.md | 1749. 任意子数组和的绝对值的最大值 | https://leetcode-cn.com/problems/maximum-absolute-sum-of-any-subarray/solution/xiang-jie-qian-zhui-he-jie-fa-fen-xi-si-yibby/ | 中等 | [
"前缀和"
] | 给你一个整数数组 nums 。
一个子数组 `[numsl, numsl+1, ..., numsr-1, numsr]` 的「和的绝对值」为 `abs(numsl + numsl+1 + ... + numsr-1 + numsr) `。
请你找出 nums 中 和的绝对值 最大的任意子数组(可能为空),并返回该 最大值 。
abs(x) 定义如下:
* 如果 x 是负整数,那么 abs(x) = -x 。
* 如果 x 是非负整数,那么 abs(x) = x 。
示例 1:
```
输入:nums = [1,-3,2,3,-4]
输出:5
解释:子数组 [2,3] 和的绝对值最大,为 abs(2+3) =... | ### 前缀和
题目要我们求连续一段的子数组的和,很自然就能想到前缀和。
当我们有了前缀和数组 `sum` 之后,需要求任意一段子数组 `[i,j]` 的和可以直接通过 `sum[j] - sum[i - 1]` 得出。
要使得 `abs(sum[j] - sum[i - 1])` 最大,其实有这么几种情况:
* 找到前缀和数组中的最大值减去最小值,得到一个最大正数(前提是最大值出现在最小值的后面,并且最小值是个负数,否则应该直接取最大值作为答案)
* 找到前缀和的最小值减去最大值,得到一个最小负数(前提是最小值出现在最大值的后面,而且最大值是一个正数,否则直接取最小值作为答案)。
也就是说最终答案只与前缀和数组中的最大... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1749` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1751. 最多可以参加的会议数目 II（困难）.md | 1751. 最多可以参加的会议数目 II | https://leetcode-cn.com/problems/maximum-number-of-events-that-can-be-attended-ii/solution/po-su-dp-er-fen-dp-jie-fa-by-ac_oier-88du/ | 困难 | [
"二分",
"序列 DP"
] | 给你一个 `events` 数组,其中 $events[i] = [startDay_i, endDay_i, value_i]$ ,表示第 $i$ 个会议在 $startDay_i$ 天开始,第 $endDay_i$ 天结束,如果你参加这个会议,你能得到价值 $value_i$ 。
同时给你一个整数 $k$ 表示你能参加的最多会议数目。
你同一时间只能参加一个会议。如果你选择参加某个会议,那么你必须完整地参加完这个会议。
会议结束日期是包含在会议内的,也就是说你不能同时参加一个开始日期与另一个结束日期相同的两个会议。
请你返回能得到的会议价值最大和。
示例 1:
```
输入:events = [[1,2,4],[3,... | ### 基本思路
**定义 $f[i][j]$ 为考虑前 $i$ 个事件,选择不超过 $j$ 的最大价值**
对于每个事件,都有选择与不选两种选择:
* 不选: $f[i][j] = f[i - 1][j]$
* 选:找到第 $i$ 件事件之前,与第 $i$ 件事件不冲突的事件,记为 `last`,则有 $f[i][j] = f[last][j - 1] + value_i$
两者取 $max$,则是 $f[i][j]$ 的值。
分析到这里,因为我们要找 `last`,我们需要先对 `events` 的结束时间排序,然后找从右往左找,找到第一个满足 `结束时间 小于 当前事件的开始时间` 的事件,就是 `last`
而找... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1751` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1758. 生成交替二进制字符串的最少操作数（简单）.md | 1758. 生成交替二进制字符串的最少操作数 | https://leetcode.cn/problems/minimum-changes-to-make-alternating-binary-string/solution/by-ac_oier-gclh/ | 简单 | [
"模拟"
] | 给你一个仅由字符 `'0'` 和 `'1'` 组成的字符串 `s` 。一步操作中,你可以将任一 `'0'` 变成 `'1'` ,或者将 `'1'` 变成 `'0'` 。
交替字符串 定义为:如果字符串中不存在相邻两个字符相等的情况,那么该字符串就是交替字符串。例如,字符串 `"010"` 是交替字符串,而字符串 `"0100"` 不是。
返回使 `s` 变成 交替字符串 所需的 最少 操作数。
示例 1:
```
输入:s = "0100"
输出:1
解释:如果将最后一个字符变为 '1' ,s 就变成 "0101" ,即符合交替字符串定义。
```
示例 2:
```
输入:s = "10"
输出:0
解释:s 已经是... | ### 模拟
最终结果只有「从 `0` 开始的交替串」和「从 `1` 开始的交替串」两种。
对于一个长度为 `n` 的未知序列 `A` 而言,假设我们需要花费 `cnt` 次操作将其变为「从 `0` 开始的交替串」,那么我们想要将其变为「从 `1` 开始的交替串」则需要 `n - cnt` 次操作:原本操作的 `cnt` 个位置不能动,而原本没操作的位置则都需要翻转,从而确保两种交替串对应位均相反。
Java 代码:
```Java
class Solution {
public int minOperations(String s) {
int n = s.length(), cnt = 0;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1758` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1759. 统计同构子字符串的数目（中等）.md | 1759. 统计同构子字符串的数目 | https://acoier.com/2022/12/26/1759.%20%E7%BB%9F%E8%AE%A1%E5%90%8C%E6%9E%84%E5%AD%90%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E6%95%B0%E7%9B%AE%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"双指针",
"数学"
] | 给你一个字符串 `s`,返回 `s` 中 同构子字符串 的数目。
由于答案可能很大,只需返回对 $10^9 + 7$ 取余 后的结果。
同构字符串的定义为:如果一个字符串中的所有字符都相同,那么该字符串就是同构字符串。
子字符串是字符串中的一个连续字符序列。
示例 1:
```
输入:s = "abbcccaa"
输出:13
解释:同构子字符串如下所列:
"a" 出现 3 次。
"aa" 出现 1 次。
"b" 出现 2 次。
"bb" 出现 1 次。
"c" 出现 3 次。
"cc" 出现 2 次。
"ccc" 出现 1 次。
3 + 1 + 2 + 1 + 3 + 2 + 1 = 13
```
示例... | ### 双指针 + 数学
根据题意,我们需要找出 `s` 中所有字符相同的连续段。
假设 $s[i...(j - 1)]$ 为某个连续段,长度为 $m$,根据「等差数列求和」可知该连续段所能提供的同构字符串数量为 $\frac{(1 + m) \times m}{2}$。
具体的,我们可以从前往后扫描 `s`,假设当前处理到的位置为 `i`,将其看作连续段的左端点,然后从 `i` 出发找到当前最长连续段的右端点 `j - 1`,统计 $s[i...(j - 1)]$ 所能贡献同构字符串数量,并调整下个发起点为 $i = j$ 以扫描下一个连续段。
Java 代码:
```Java
class Solution {
p... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1759` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1760. 袋子里最少数目的球（中等）.md | 1760. 袋子里最少数目的球 | https://leetcode.cn/problems/minimum-limit-of-balls-in-a-bag/solutions/2519994/gong-shui-san-xie-jing-dian-er-fen-yun-y-pj6r/ | 中等 | [
"二分"
] | 给你一个整数数组 `nums`,其中 `nums[i]` 表示第 `i` 个袋子里球的数目。同时给你一个整数 `maxOperations`。
你可以进行如下操作至多 `maxOperations` 次:
* 选择任意一个袋子,并将袋子里的球分到 `2` 个新的袋子中,每个袋子里都有 正整数 个球。
* 比方说,一个袋子里有 `5` 个球,你可以把它们分到两个新袋子里,分别有 `1` 个和 `4` 个球,或者分别有 `2` 个和 `3` 个球。
你的开销是单个袋子里球数目的 最大值 ,你想要 最小化 开销。
请你返回进行上述操作后的最小开销。
示例 1:
```
输入:nums = [9], maxOperations ... | ### 二分
最小化不超过 `max` 次划分操作后的单个袋子最大值,我们将其称为「划分值」。
**答案具有二段性:若使用 $k \leq \max$ 次划分操作后可达到最小划分值,此时减少划分操作次数,会使得划分值非单调上升。**
因此我们可以二分答案,从而将问题进行等价转换:
**假设当前二分到的值为 $limit$,我们需要实现一个线性复杂度为 `check` 函数,判断能否使用不超过 $\max$ 次划分次数,来使得划分值不超过 $limit$**:
* 若能满足,说明 $[limit, +\infty]$ 范围的划分值,均能使用不超过 $\max$ 次的实现,此时让 $r = limit$
* 若不能满足,比 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1758` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1763. 最长的美好子字符串（简单）.md | 1763. 最长的美好子字符串 | https://leetcode-cn.com/problems/longest-nice-substring/solution/gong-shui-san-xie-yi-ti-san-jie-po-su-ji-oflj/ | 简单 | [
"模拟",
"前缀和",
"位运算"
] | 当一个字符串 `s` 包含的每一种字母的大写和小写形式 同时 出现在 `s` 中,就称这个字符串 `s` 是 美好 字符串。
比方说,`"abABB"` 是美好字符串,因为 `'A'` 和 `'a'` 同时出现了,且 `'B'` 和 `'b'` 也同时出现了。然而,`"abA"` 不是美好字符串因为 `'b'` 出现了,而 `'B'` 没有出现。
给你一个字符串 `s` ,请你返回 `s` 最长的 美好子字符串 。如果有多个答案,请你返回 最早 出现的一个。如果不存在美好子字符串,请你返回一个空字符串。
示例 1:
```
输入:s = "YazaAay"
输出:"aAa"
解释:"aAa" 是一个美好字符串,因为这个子串... | ### 朴素解法
数据范围只有 $100$,最为简单的做法是枚举所有的子串( 复杂度为 $O(n^2)$ ),然后对子串进行合法性检查( 复杂度为 $O(n)$ ),整体复杂度为 $O(n^3)$,可以过。
代码:
```Java
class Solution {
public String longestNiceSubstring(String s) {
int n = s.length();
String ans = "";
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1763` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1764. 通过连接另一个数组的子数组得到一个数组（中等）.md | 1764. 通过连接另一个数组的子数组得到一个数组 | https://leetcode-cn.com/problems/form-array-by-concatenating-subarrays-of-another-array/solution/clean-solutionni-jue-dui-neng-kan-dong-d-l4ts/ | 中等 | [
"双指针"
] | 给你一个长度为 `n` 的二维整数数组 `groups` ,同时给你一个整数数组 `nums` 。
你是否可以从 `nums` 中选出 `n` 个 不相交 的子数组,使得第 `i` 个子数组与 `groups[i]` (下标从 `0` 开始)完全相同,且如果 `i > 0` ,那么第 (`i-1`) 个子数组在 `nums` 中出现的位置在第 `i` 个子数组前面。(也就是说,这些子数组在 `nums` 中出现的顺序需要与 `groups` 顺序相同)
如果你可以找出这样的 `n` 个子数组,请你返回 `true` ,否则返回 `false`。
如果不存在下标为 `k` 的元素 `nums[k]` 属于不止一个子数组,就称这些... | ### 双指针
为了方便,将 `groups` 记为 `gs`。
从前往后处理每个 $gs[i]$,使用 `idx` 记录当前使用到 `nums` 中的哪一位(即 $[0, ... (idx - 1)]$ 的 $nums[i]$ 已经用于匹配 $gs[0, ... (i - 1)]$。
每次尝试从 `idx` 出发匹配 `gs[i]`,若能匹配成功,则整段更新 $idx = idx + gs[i].length$;否则将 `idx` 后移一位,继续尝试匹配 `gs[i]`。
代码:
```Java
class Solution {
public boolean canChoose(int[][] gs, int[] ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1764` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1765. 地图中的最高点（中等）.md | 1765. 地图中的最高点 | https://leetcode-cn.com/problems/map-of-highest-peak/solution/gong-shui-san-xie-duo-yuan-bfs-yun-yong-8sw0f/ | 中等 | [
"图论搜索",
"多源 BFS"
] | 给你一个大小为 `m x n` 的整数矩阵 `isWater` ,它代表了一个由 陆地 和 水域 单元格组成的地图。
* 如果 `isWater[i][j] == 0` ,格子 `(i, j)` 是一个 陆地 格子。
* 如果 `isWater[i][j] == 1` ,格子 `(i, j)` 是一个 水域 格子。
你需要按照如下规则给每个单元格安排高度:
* 每个格子的高度都必须是非负的。
* 如果一个格子是是 **水域** ,那么它的高度必须为 $0$ 。
* 任意相邻的格子高度差 至多 为 `1` 。当两个格子在正东、南、西、北方向上相互紧挨着,就称它们为相邻的格子。(也就是说它们有一条公共边)
找到一种安排高度的方案... | ### 多源 BFS
这是一道「多源 `BFS`」板子题,对「多源 `BFS`」不熟悉的同学,可以看看前置 🧀:[多源 BFS 入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&scene=178&cur_album_id=1917113998693449732#rd)。
里面详解了「多源 `B... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1765` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1766. 互质树（困难）.md | 1766. 互质树 | https://leetcode-cn.com/problems/tree-of-coprimes/solution/bu-tai-yi-yang-de-dfs-ji-lu-suo-you-zui-d3xeu/ | 困难 | [
"DFS"
] | 给你一个 `n` 个节点的树(也就是一个无环连通无向图),节点编号从 `0` 到 `n - 1`,且恰好有 `n - 1` 条边,每个节点有一个值,树的根节点为 `0` 号点。
给你一个整数数组 `nums` 和一个二维数组 `edges` 来表示这棵树。
`nums[i]` 表示第 `i` 个点的值,$edges[j] = [u_{j}, v_{j}]$ 表示节点 $u_{j}$ 和节点 $v_{j}$ 在树中有一条边。
当 `gcd(x, y) == 1`,我们称两个数 `x` 和 `y` 是 互质的 ,其中 `gcd(x, y)` 是 `x` 和 `y` 的最大公约数。
从节点 `i` 到根最短路径上的点都是节点 `i... | ### DFS
题目描述很长,但其实就是说每个节点从下往上找,找到最近的「与其互质」的节点。
数据范围是 $10^5$,如果每个节点都直接往上找最近「互质」祖宗节点的话,当树为线性时,复杂度是 $O(n^2)$ ,会超时。
因此我们要利用 $nums[i]$ 范围只有 $50$ 的特性。
我们可以先预处理除 $[1, 50]$ 范围内的每个数,求出他们互质的数有哪些,存到一个字典里。
那么对于某个节点而言,假设节点的值为 `x` ,所在层数为 `y`。
那么问题转化为求与 `x` 互质的数有哪些,最近的在哪一层。
用 `dep[x]` 表示距离值为 `x` 的节点最近的层是多少;`pos[x]` 代表具体的节点编号。... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1766` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1768. 交替合并字符串（简单）.md | 1768. 交替合并字符串 | https://leetcode.cn/problems/merge-strings-alternately/solution/by-ac_oier-rjve/ | 简单 | [
"模拟"
] | 给你两个字符串 `word1` 和 `word2`。请你从 `word1` 开始,通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长,就将多出来的字母追加到合并后字符串的末尾。
返回 合并后的字符串 。
示例 1:
```
输入:word1 = "abc", word2 = "pqr"
输出:"apbqcr"
解释:字符串合并情况如下所示:
word1: a b c
word2: p q r
合并后: a p b q c r
```
示例 2:
```
输入:word1 = "ab", word2 = "pqrs"
输出:"apbqrs"
解释:注意,word2 比 word1 长,"... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public String mergeAlternately(String s1, String s2) {
int n = s1.length(), m = s2.length(), i = 0, j = 0;
StringBuilder sb = new StringBuilder();
while (i < n || j < m) {
if (i < n) sb.append(s1.charAt(i++));
if ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1768` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1769. 移动所有球到每个盒子所需的最小操作数（中等）.md | 1769. 移动所有球到每个盒子所需的最小操作数 | null | 中等 | [
"模拟"
] | 有 `n` 个盒子。给你一个长度为 `n` 的二进制字符串 `boxes`,其中 `boxes[i]` 的值为 `'0'` 表示第 `i` 个盒子是 空 的,而 `boxes[i]` 的值为 `'1'` 表示盒子里有 一个 小球。
在一步操作中,你可以将 一个 小球从某个盒子移动到一个与之相邻的盒子中。第 `i` 个盒子和第 `j` 个盒子相邻需满足 `abs(i - j) == 1`。注意,操作执行后,某些盒子中可能会存在不止一个小球。
返回一个长度为 `n` 的数组 `answer`,其中 `answer[i]` 是将所有小球移动到第 `i` 个盒子所需的 最小 操作数。
每个 `answer[i]` 都需要根据盒子的 初... | ### 模拟
预处理两个与 `boxes` 等长的数组 `l` 和 `r`:$l[i]$ 和 $r[i]$ 分别代表「将 $[0, i]$ 的小球移动到位置 $i$」以及「将 $[i, n - 1]$ 的小球移动到位置 $i$」所需要的步数。
所求的答案数组 `ans` 与数组 `l` 和 `r` 的关系为:$ans[i] = l[i] + r[i]$。
预处理两数组是简单的:分别从两个方向遍历 `boxes`,使用变量 `cur` 代表当前处理到的前缀/后缀的小球总个数,变量 `step` 代表将当前所有前缀/后缀小球移动到位置 $i$ 所需要的步数。
Java 代码:
```Java
class Solution {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1769` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1771-1780/1773. 统计匹配检索规则的物品数量（简单）.md | 1773. 统计匹配检索规则的物品数量 | https://leetcode.cn/problems/count-items-matching-a-rule/solution/by-ac_oier-qyd6/ | 简单 | [
"模拟"
] | 给你一个数组 `items` ,其中 $items[i] = [type_{i}, color_{i}, name_{i}]$ ,描述第 `i` 件物品的类型、颜色以及名称。
另给你一条由两个字符串 `ruleKey` 和 `ruleValue` 表示的检索规则。
如果第 `i` 件物品能满足下述条件之一,则认为该物品与给定的检索规则 匹配 :
* `ruleKey = "type"` 且 $ruleValue = type_{i}$ 。
* `ruleKey = "color"` 且 $ruleValue = color_{i}$。
* `ruleKey = "name"` 且 $ruleValue = name{i}$。
... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int countMatches(List<List<String>> items, String k, String v) {
int ans = 0, idx = k.charAt(0) == 't' ? 0 : k.charAt(0) == 'c' ? 1 : 2;
for (List<String> item : items) {
if (item.get(idx).equals(v)) ans++;
}
r... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1773` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1771-1780/1775. 通过最少操作次数使数组的和相等（中等）.md | 1775. 通过最少操作次数使数组的和相等量 | https://leetcode.cn/problems/equal-sum-arrays-with-minimum-number-of-operations/solutions/2582561/gong-shui-san-xie-fen-qing-kuang-tao-lun-saa1/ | 中等 | [
"枚举",
"贪心",
"数学"
] | 给你两个长度可能不等的整数数组 `nums1` 和 `nums2` 。两个数组中的所有值都在 `1` 到 `6` 之间(包含 `1` 和 `6`)。
每次操作中,你可以选择 任意 数组中的任意一个整数,将它变成 `1` 到 `6` 之间 任意 的值(包含 `1` 和 `6`)。
请你返回使 `nums1` 中所有数的和与 `nums2` 中所有数的和相等的最少操作次数。如果无法使两个数组的和相等,请返回 `-1` 。
示例 1:
```
输入:nums1 = [1,2,3,4,5,6], nums2 = [1,1,2,2,2,2]
输出:3
解释:你可以通过 3 次操作使 nums1 中所有数的和与 nums2 中所有数的... | ### 枚举 + 贪心 + 数学
令 `nums1` 的长度为 `n`,`nums2` 的长度为 `m`,根据题意两数组的值域分别为 $[n, 6n]$ 和 $[m, 6m]$,可分别视为数轴上的两条线段。
为了方便,我们人为固定 $n\leq m$,若不满足则交换两数组,返回 `minOperations(nums2, nums1)` 即可。
先来考虑无解的情况:当 $6n < m$ 时,说明两线段不重合,必然无法通过变换使得总和相等,直接返回 `-1`。
由于 $\max(n, m)$ 的范围为 $1e5$,且 $nums[i]$ 的值域大小 $C = 6$,因此我们可以通过枚举最终目标和 `x`(两线段的重合部分)来... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1775` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1771-1780/1780. 判断一个数字是否可以表示成三的幂的和（中等）.md | 1780. 判断一个数字是否可以表示成三的幂的和 | https://acoier.com/2022/12/12/1780.%20%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E6%95%B0%E5%AD%97%E6%98%AF%E5%90%A6%E5%8F%AF%E4%BB%A5%E8%A1%A8%E7%A4%BA%E6%88%90%E4%B8%89%E7%9A%84%E5%B9%82%E7%9A%84%E5%92%8C%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"数学"
] | 给你一个整数 `n`,如果你可以将 `n` 表示成若干个不同的三的幂之和,请你返回 `true`,否则请返回 `false`。
对于一个整数 `y`,如果存在整数 `x` 满足 $y = 3^x$,我们称这个整数 `y` 是三的幂。
示例 1:
```
输入:n = 12
输出:true
解释:12 = 31 + 32
```
示例 2:
```
输入:n = 91
输出:true
解释:91 = 30 + 32 + 34
```
示例 3:
```
输入:n = 21
输出:false
```
提示:
* $1 <= n <= 10^7$ | ### 数学
这是一道考察「进制转换」基本认识的题目。
将 `n` 看作一个三进制数,例如对于 $(210)_{3}$ 而言,其代表的是 $2 \times 3^2 + 1 \times 3^1 + 0 \times 3^0$ 十进制数。
由于题目规定组成和的三的幂需要满足「不同」的条件,因此 `n` 所代表的三进制表示中的系数只能是 $1$ 或 $0$,而不是能是 $2$。
Java 代码:
```Java
class Solution {
public boolean checkPowersOfThree(int n) {
while (n != 0) {
if (n % ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1780` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1781. 所有子字符串美丽值之和（中等）.md | 1781. 所有子字符串美丽值之和 | null | 中等 | [
"模拟",
"哈希表"
] | 一个字符串的 美丽值 定义为:出现频率最高字符与出现频率最低字符的出现次数之差。
比方说,`"abaacc"` 的美丽值为 `3 - 1 = 2`。
给你一个字符串 `s` ,请你返回它所有子字符串的 美丽值 之和。
示例 1:
```
输入:s = "aabcb"
输出:5
解释:美丽值不为零的字符串包括 ["aab","aabc","aabcb","abcb","bcb"] ,每一个字符串的美丽值都为 1 。
```
示例 2:
```
输入:s = "aabcbaa"
输出:17
```
提示:
* $1 <= s.length <= 500$
* `s` 只包含小写英文字母。 | ### 模拟 + 哈希表
数据范围只有 $500$,我们可以通过两层循环的方式枚举所有子串,当枚举子串左端点 `i` 的时候,可以同步开一个大小为 $C = 26$ 的数组来记录每个字母的出现次数,随后通过遍历该数组来得知最大和最小频次,将当前子串对应的美丽值累加到答案。
该做法复杂度为 $O(n^2 \times C)$,计算量约为 $500 \times 500 \times 26 = 6.5 \times 10^6$,可以过。
在确定了子串的左端点 `i`,枚举右端点 `j` 的过程中,维护最大频次是简单的,关键在于如果知晓最小频次,我们可以额外起一个哈希表 `map` 来记录出现频次为 `x` 的字符有多少个,`map... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1781` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1784. 检查二进制字符串字段（简单）.md | 1784. 检查二进制字符串字段 | https://leetcode.cn/problems/check-if-binary-string-has-at-most-one-segment-of-ones/solution/by-ac_oier-kiu6/ | 简单 | [
"模拟"
] | 给你一个二进制字符串 `s` ,该字符串 不含前导零 。
如果 `s` 包含 零个或一个由连续的 `'1'` 组成的字段 ,返回 `true`。否则,返回 `false`。
如果 `s` 中 由连续若干个 `'1'` 组成的字段 数量不超过 `1`,返回 `true`。否则,返回 `false`。
示例 1:
```
输入:s = "1001"
输出:false
解释:由连续若干个 '1' 组成的字段数量为 2,返回 false
```
示例 2:
```
输入:s = "110"
输出:true
```
提示:
* $1 <= s.length <= 100$
* `s[i]` 为 `'0'` 或 `'1'`
* `... | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public boolean checkOnesSegment(String s) {
int n = s.length(), cnt = 0, idx = 0;
while (idx < n && cnt <= 1) {
while (idx < n && s.charAt(idx) == '0') idx++;
if (idx < n) {
while (idx < n && s.charAt(idx)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1784` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1785. 构成特定和需要添加的最少元素（中等）.md | 1785. 构成特定和需要添加的最少元素 | https://acoier.com/2022/12/16/1785.%20%E6%9E%84%E6%88%90%E7%89%B9%E5%AE%9A%E5%92%8C%E9%9C%80%E8%A6%81%E6%B7%BB%E5%8A%A0%E7%9A%84%E6%9C%80%E5%B0%91%E5%85%83%E7%B4%A0%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"贪心",
"模拟"
] | 给你一个整数数组 `nums`,和两个整数 `limit` 与 `goal`。
数组 `nums` 有一条重要属性:`abs(nums[i]) <= limit`。
返回使数组元素总和等于 `goal` 所需要向数组中添加的 最少元素数量 ,添加元素 不应改变 数组中 `abs(nums[i]) <= limit` 这一属性。
注意,如果 `x >= 0`,那么 `abs(x)` 等于 `x` ;否则,等于 `-x`。
示例 1:
```
输入:nums = [1,-1,1], limit = 3, goal = -4
输出:2
解释:可以将 -2 和 -3 添加到数组中,数组的元素总和变为 1 - 1 + 1 - 2 ... | ### 贪心
对于 `nums` 而言,我们可以先通过 $O(n)$ 的遍历求得其原总和 `sum` 为何值。
若 `sum` 与 `goal` 不等,我们可以按照「贪心」的方式里添加元素。
由于添加的元素需要满足 `abs(x) <= limit` 要求,因此我们添加数的范围在 $[-limit, limit]$ 之间。
为确保添加的元素最小,我们应当优先添加能够有效抵消两者差值的数值(添加 $limit$ 或 $-limit$),添加个数为 $\left \lceil \frac{\left | sum - goal \right |}{limit} \right \rceil$。
Java 代码:
```Java
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1785` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1786. 从第一个节点出发到最后一个节点的受限路径数（中等）.md | 1786. 从第一个节点出发到最后一个节点的受限路径数 | https://leetcode-cn.com/problems/number-of-restricted-paths-from-first-to-last-node/solution/xiang-jie-dui-you-hua-dijkstra-dong-tai-i6j0d/ | 中等 | [
"最短路",
"线性 DP"
] | 现有一个加权无向连通图。给你一个正整数 `n` ,表示图中有 `n` 个节点,并按从 `1` 到 `n` 给节点编号;另给你一个数组 `edges`,其中每个 $edges[i] = [u_{i}, v_{i}, weight_{i}]$ 表示存在一条位于节点 $u_{i}$ 和 $v_{i}$ 之间的边,这条边的权重为 $weight_{i}$ 。
从节点 start 出发到节点 `end` 的路径是一个形如 $[z_{0}, z_{1}, z_{2}, ..., z_{k}]$ 的节点序列,满足 $z_{0} = start$ 、$z_{k} = end$ 且在所有符合 $0 <= i <= k-1$ 的节点 $z_{i}$ ... | ### 堆优化 Dijkstra + 动态规划
`n` 为点的数量,`m` 为边的数量。
为了方便理解,我们将第 `n` 个点称为「起点」,第 `1` 个点称为「结尾」。
按照题意,我们需要先求每个点到结尾的「最短路」,求最短路的算法有很多,通常根据「有无负权边」& 「稠密图还是稀疏图」进行选择。
该题只有正权变,而且“边”和“点”的数量在一个数量级上,属于稀疏图。
因此我们可以采用「最短路」算法:堆优化的 Dijkstra,复杂度为 $O(m\log{n})$。
> PS. 通常会优先选择 SPFA,SPFA 通常情况下复杂度为 $O(m)$,但最坏情况下复杂度为 $O(n \times m)$。从数据上来说 SPFA... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1786` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1787. 使所有区间的异或结果为零（困难）.md | 1787. 使所有区间的异或结果为零 | https://leetcode-cn.com/problems/make-the-xor-of-all-segments-equal-to-zero/solution/gong-shui-san-xie-chou-xiang-cheng-er-we-ww79/ | 困难 | [
"线性 DP",
"异或",
"数学"
] | 给你一个整数数组 `nums` 和一个整数 `k` 。
区间 `[left, right]``(left <= right)`的 异或结果 是对下标位于 `left` 和 `right`(包括 `left` 和 `right` )之间所有元素进行 XOR 运算的结果:`nums[left] XOR nums[left+1] XOR ... XOR nums[right]` 。
返回数组中**要更改的最小元素数** ,以使所有长度为 `k` 的区间异或结果等于零。
示例 1:
```
输入:nums = [1,2,0,3,0], k = 1
输出:3
解释:将数组 [1,2,0,3,0] 修改为 [0,0,0,0,0]
... | ### 基本分析
题目示例所包含的提示过于明显了,估计很多同学光看三个样例就猜出来了:**答案数组必然是每 $k$ 个一组进行重复的。**
这样的性质是可由「答案数组中所有长度为 $k$ 的区间异或结果为 $0$」推导出来的:
* 假设区间 $[i, j]$ 长度为 $k$,其异或结果为 $0$。即 $nums[i] ⊕ nums[i + 1] ⊕ ... ⊕ nums[j] = 0$
* 长度不变,将区间整体往后移动一位 $[i + 1, j + 1]$,其异或结果为 $0$。即 $nums[i + 1] ⊕ ... ⊕ nums[j] ⊕ nums[j + 1] = 0$
* 两式结合,中间 $[i + 1, j]$ ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1787` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1790. 仅执行一次字符串交换能否使两个字符串相等（简单）.md | 1790. 仅执行一次字符串交换能否使两个字符串相等 | https://leetcode-cn.com/problems/make-the-xor-of-all-segments-equal-to-zero/solution/gong-shui-san-xie-chou-xiang-cheng-er-we-ww79/ | 简单 | [
"模拟"
] | 给你长度相等的两个字符串 `s1` 和 `s2` 。一次 字符串交换 操作的步骤如下:选出某个字符串中的两个下标(不必不同),并交换这两个下标所对应的字符。
如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:s1 = "bank", s2 = "kanb"
输出:true
解释:例如,交换 s2 中的第一个和最后一个字符可以得到 "bank"
```
示例 2:
```
输入:s1 = "attack", s2 = "defend"
输出:false
解释:一次字符串交换无法使两个字符串相等
```
示例 3:
```... | ### 模拟
根据题意进行模拟即可 : 使用 `a` 和 `b` 记录不同的位置下标,初始值为 `-1`,若「不同位置超过 $2$ 个」或「只有 $1$ 个」直接返回 `false`,若「不存在不同位置」或「不同位置字符相同」,则返回 `true`。
Java 代码:
```Java
class Solution {
public boolean areAlmostEqual(String s1, String s2) {
int n = s1.length(), a = -1, b = -1;
for (int i = 0; i < n; i++) {
if (s... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1790` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1791-1800/1791. 找出星型图的中心节点（简单）.md | 1791. 找出星型图的中心节点 | https://leetcode-cn.com/problems/find-center-of-star-graph/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-qoix/ | 简单 | [
"模拟"
] | 有一个无向的 星型 图,由 $n$ 个编号从 $1$ 到 $n$ 的节点组成。星型图有一个 中心 节点,并且恰有 $n - 1$ 条边将中心节点与其他每个节点连接起来。
给你一个二维整数数组 `edges` ,其中 $edges[i] = [u_i, v_i]$ 表示在节点 $u_i$ 和 $v_i$ 之间存在一条边。请你找出并返回 `edges` 所表示星型图的中心节点。
示例 1:
```
输入:edges = [[1,2],[2,3],[4,2]]
输出:2
解释:如上图所示,节点 2 与其他每个节点都相连,所以节点 2 是中心节点。
```
示例 2:
```
输入:edges = [[1,2],[5,1],[1,... | ### 模拟
根据题意,中心节点必然出现在所有的 $edges[i]$ 中,因此使用前两条边即可确定答案。
起始让 $edges[0][0]$ 和 $edges[0][1]$ 作为答案候选,然后在 $edges[1]$ 关系中检查哪个候选出现过。
代码:
```Java
class Solution {
public int findCenter(int[][] edges) {
int a = edges[0][0], b = edges[0][1];
if (a == edges[1][0] || a == edges[1][1]) return a;
else re... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1791` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1791-1800/1797. 设计一个验证系统（中等）.md | 1797. 设计一个验证系统 | null | 中等 | [
"链表",
"哈希表"
] | 你需要设计一个包含验证码的验证系统。
每一次验证中,用户会收到一个新的验证码,这个验证码在 `ct` 时刻之后 `timeToLive` 秒过期。
如果验证码被更新了,那么它会在 `ct` (可能与之前的 `ct` 不同)时刻延长 `timeToLive` 秒。
请你实现 `AuthenticationManager` 类:
* `AuthenticationManager(int timeToLive)` 构造 `AuthenticationManager` 并设置 `timeToLive` 参数。
* `generate(string id, int ct)` 给定 `id`,在当前时间 `ct` 生成一个新的验证码。... | ### 哈希表
数据范围只有 `20`,我们使用哈希表记录每个 `id` 的过期时间 `ct`,在每次查询时遍历整个哈希表来统计未过期的验证码数量。
Java 代码:
```Java
class AuthenticationManager {
int d;
Map<String, Integer> map = new HashMap<>();
public AuthenticationManager(int timeToLive) {
d = timeToLive;
}
public void generate(String id, int ct) {
ma... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1797` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1791-1800/1798. 你能构造出连续值的最大数目（中等）.md | 1798. 你能构造出连续值的最大数目 | https://leetcode.cn/problems/maximum-number-of-consecutive-values-you-can-make/solutions/2607482/gong-shui-san-xie-shu-xue-lei-gou-zao-ti-wf47/ | 中等 | [
"数学",
"脑筋急转弯",
"排序",
"构造"
] | 给你一个长度为 `n` 的整数数组 `coins`,它代表你拥有的 `n` 个硬币。第 `i` 个硬币的值为 `coins[i]`。如果你从这些硬币中选出一部分硬币,它们的和为 `x` ,那么称,你可以构造出 `x` 。
请返回从 `0` 开始(包括 `0` ),你最多能构造出多少个连续整数。
你可能有多个相同值的硬币。
示例 1:
```
输入:coins = [1,3]
输出:2
解释:你可以得到以下这些值:
- 0:什么都不取 []
- 1:取 [1]
从 0 开始,你可以构造出 2 个连续整数。
```
示例 2:
```
输入:coins = [1,1,1,4]
输出:8
解释:你可以得到以下这些值:
- 0... | ### 数学
`n` 的数据范围为 $4 \times 10^4$,必然不是考察我们使用 `coins` 来构造单个数值 `x` 的逻辑,因为「遍历 + 逐个构造验证」的做法会超时,**因此只能是考察我们能否推导出整段构造的相关性质**。
假设我们已经用前 `k` 个数值构造出连段 $[0, x]$ 中的任意数,当增加第 $k + 1$ 个数值时,还能否进行连续构造:
* 若不能,则连续构造中断,答案为 $[0, x]$,共 $x + 1$ 个
* 若能,则再考虑连续构造的右边界会到哪个地方
由于题目允许我们任意使用 `coins` 中的数,同时整段构造又是不断扩大 $[0, x]$ 中右边界的过程(从小到大),为了方便,我... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1798` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1801-1810/1801. 积压订单中的订单总数（中等）.md | 1801. 积压订单中的订单总数 | https://leetcode-cn.com/problems/number-of-orders-in-the-backlog/solution/gss-by-ac_oier-4pqk/ | 中等 | [
"数据结构",
"模拟",
"优先队列(堆)"
] | 给你一个二维整数数组 $orders$ ,其中每个 $orders[i] = [price_i, amount_i, orderType_i]$ 表示有 $amount_i$ 笔类型为 $orderType_i$、价格为 $price_i$ 的订单。
订单类型 $orderType_i$ 可以分为两种:
* $0$ 表示这是一批采购订单 `buy`
* $1$ 表示这是一批销售订单 `sell`
注意,$orders[i]$ 表示一批共计 $amount_i$ 笔的独立订单,这些订单的价格和类型相同。
对于所有有效的 $i$ ,由 $orders[i]$ 表示的所有订单提交时间均早于 $orders[i+1]$ 表示的所有订... | ### 模拟 + 数据结构
整理题意:从前往后处理所有的 $orders[i]$,对于 `buy` 类型的订单,从积压订单中找价格低于等于当前价格的 `sell` 订单进行抵消;同理,对于 `sell` 类型的订单,从积压订单中找价格高于等于当前价格的 `buy` 订单进行抵消。问最终有多少积压订单。
这个找「最低/最高」价格的操作可以利用优先队列(堆)来做,对于积压的 `buy` 类型订单,我们总是要找价格高的,使用大根堆维护;对于积压的 `sell` 类型订单,我们总是要找价格低的,使用小根堆维护。
两个优先队列(堆)均维护形如 $(price_i, amount_i)$ 的二元组信息,代表价格为 $price_i$ 的订... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1801` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1801-1810/1802. 有界数组中指定下标处的最大值（中等）.md | 1802. 有界数组中指定下标处的最大值 | https://leetcode.cn/problems/maximum-value-at-a-given-index-in-a-bounded-array/solutions/2363016/gong-shui-san-xie-chang-gui-zong-he-ti-b-ohvx/ | 中等 | [
"二分",
"数学",
"构造",
"贪心",
"模拟"
] | 给你三个正整数 `n`、`index` 和 `maxSum`。
你需要构造一个同时满足下述所有条件的数组 `nums`(下标 从 `0` 开始 计数):
* `nums.length == n`
* `nums[i]` 是 正整数 ,其中 `0 <= i < n`
* `abs(nums[i] - nums[i+1]) <= 1` ,其中 `0 <= i < n-1`
* `nums` 中所有元素之和不超过 `maxSum`
* `nums[index]` 的值被 最大化
* 返回你所构造的数组中的 `nums[index]`
注意:`abs(x)` 等于 `x` 的前提是 `x >= 0`;否则,`abs(x)` 等于 `-... | ### 二分 + 贪心 + 数学
根据题意,容易想到以 `ans` 为分割点的正整数数组具有二段性,其中 `ans` 为最大的 $nums[idx]$。
小于等于 `ans` 的值均能通过直接调整 $nums[idx]$ 来构造,不会违反总和不超过 `max` 的限制;大于 `ans` 的值则无法满足 `max` 限制。基于此我们可通过「二分」的方式来找分割点。
假设当前二分到的值为 `x`,考虑如何实现一个 `check` 函数,该函数用于判断 `x` 能否作为 $nums[idx]$:
为了令 $nums[idx] = x$ 时,数组总和 `sum` 不超过 `max` 限制,我们应当贪心构造 $nums$ 的剩余元素:... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1802` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/181-190/187. 重复的DNA序列（中等）.md | 187. 重复的DNA序列 | https://leetcode-cn.com/problems/repeated-dna-sequences/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-30pg/ | 中等 | [
"滑动窗口",
"哈希表",
"字符串哈希",
"前缀和"
] | 所有 DNA 都由一系列缩写为 `'A'`,`'C'`,`'G'` 和 `'T'` 的核苷酸组成,例如:`"ACGAATTCCG"`。在研究 DNA 时,识别 DNA 中的重复序列有时会对研究非常有帮助。
编写一个函数来找出所有目标子串,目标子串的长度为 $10$,且在 DNA 字符串 `s` 中出现次数超过一次。
示例 1:
```
输入:s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
输出:["AAAAACCCCC","CCCCCAAAAA"]
```
示例 2:
```
输入:s = "AAAAAAAAAAAAA"
输出:["AAAAAAAAAA"]
```
提示:
* 0 <= s.l... | ### 滑动窗口 + 哈希表
数据范围只有 $10^5$,一个朴素的想法是:从左到右处理字符串 $s$,使用滑动窗口得到每个以 $s[i]$ 为结尾且长度为 $10$ 的子串,同时使用哈希表记录每个子串的出现次数,如果该子串出现次数超过一次,则加入答案。
为了防止相同的子串被重复添加到答案,而又不使用常数较大的 `Set` 结构。我们可以规定:当且仅当该子串在之前出现过一次(加上本次,当前出现次数为两次)时,将子串加入答案。
代码:
```Java
class Solution {
public List<String> findRepeatedDnaSequences(String s) {
List... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.187` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。
```
``` |
LeetCode/181-190/190. 颠倒二进制位（简单）.md | 190. 颠倒二进制位 | https://leetcode-cn.com/problems/reverse-bits/solution/yi-ti-san-jie-dui-cheng-wei-zhu-wei-fen-ub1hi/ | 简单 | [
"位运算",
"模拟"
] | 颠倒给定的 32 位无符号整数的二进制位。
提示:
* 请注意,在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,输入和输出都将被指定为有符号整数类型,并且不应影响您的实现,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的。
* 在 Java 中,编译器使用二进制补码记法来表示有符号整数。因此,在上面的 示例 2 中,输入表示有符号整数 -3,输出表示有符号整数 -1073741825。
进阶:
* 如果多次调用这个函数,你将如何优化你的算法?
示例 1:
```
输入: 00000010100101000001111010011100
输出: 0011100101111000001010... | ### 「对称位」构造
一个简单的做法是对输入的 $n$ 做诸位检查。
**如果某一位是 1 的话,则将答案相应的对称位置修改为 1。**
代码:
```Java
public class Solution {
public int reverseBits(int n) {
int ans = 0;
for (int i = 0; i < 32; i++) {
int t = (n >> i) & 1;
if (t == 1) {
ans |= (1 << (31 - i));
}
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.190` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。
```
``` |
LeetCode/1811-1820/1816. 截断句子（简单）.md | 1816. 截断句子 | https://leetcode-cn.com/problems/truncate-sentence/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-l7gu/ | 简单 | [
"模拟"
] | 句子 是一个单词列表,列表中的单词之间用单个空格隔开,且不存在前导或尾随空格。
每个单词仅由大小写英文字母组成(不含标点符号)。
例如,`"Hello World"`、`"HELLO"` 和 `"hello world hello world"` 都是句子。
给你一个句子 `s` 和一个整数 `k` ,请你将 `s` 截断 ,使截断后的句子仅含 前 `k` 个单词。返回 截断 `s` 后得到的句子。
示例 1:
```
输入:s = "Hello how are you Contestant", k = 4
输出:"Hello how are you"
解释:
s 中的单词为 ["Hello", "how" "are", ... | ### 模拟
根据题意进行模拟,在拼接答案时对「空格」进行计数即可。
可通过 `StringBuilder` 实现拼接,也可以使用变量 `idx` 记录答案的结尾位置。
代码:
```Java
class Solution {
public String truncateSentence(String s, int k) {
StringBuilder sb = new StringBuilder();
int n = s.length();
for (int i = 0, cnt = 0; i < n && cnt < k; i++) {
cha... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1816` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1811-1820/1818. 绝对差值和（中等）.md | 1818. 绝对差值和 | https://leetcode-cn.com/problems/minimum-absolute-sum-difference/solution/gong-shui-san-xie-tong-guo-er-fen-zhao-z-vrmq/ | 中等 | [
"二分"
] | 给你两个正整数数组 `nums1` 和 `nums2` ,数组的长度都是 `n` 。
数组 `nums1` 和 `nums2` 的 **绝对差值和** 定义为所有 `|nums1[i] - nums2[i]|(0 <= i < n)`的 总和(下标从 $0$ 开始)。
你可以选用 `nums1` 中的 **任意一个** 元素来替换 `nums1` 中的 **至多** 一个元素,以 **最小化** 绝对差值和。
在替换数组 `nums1` 中最多一个元素 之后 ,返回最小绝对差值和。因为答案可能很大,所以需要对 $10^9 + 7$ 取余 后返回。
`|x|` 定义为:
* 如果 $x >= 0$,值为 `x` ,或者
* ... | ### 二分
这是一道二分陈题,具体做法如下:
我们在进行处理前,先对 $nums1$ 进行拷贝并排序,得到 $sorted$ 数组。
然后 **在遍历 $nums1$ 和 $nums2$ 计算总的差值 $sum$ 时,通过对 $sorted$ 进行二分查找,找到最合适替换 $nums[i]$ 的值**。
具体的,当我们处理到第 $i$ 位时,假设该位的原差值为 $x = abs(nums1[i] - nums2[i])$,然后从 $sorted$ 数组中通过二分找到最接近 $nums2[i]$ 的值,计算一个新的差值 $nd$(注意要检查分割点与分割点的下一位),如果满足 $nd < x$ 说明存在一个替换方案使得差值变小... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1818` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1821-1830/1822. 数组元素积的符号（简单）.md | 1822. 数组元素积的符号 | https://leetcode.cn/problems/sign-of-the-product-of-an-array/solution/by-ac_oier-qy0n/ | 简单 | [
"模拟"
] | 已知函数 `signFunc(x)` 将会根据 `x` 的正负返回特定值:
* 如果 `x` 是正数,返回 `1` 。
* 如果 `x` 是负数,返回 `-1` 。
* 如果 `x` 是等于 `0` ,返回 `0` 。
给你一个整数数组 `nums`。令 `product` 为数组 `nums` 中所有元素值的乘积。
返回 `signFunc(product)` 。
示例 1:
```
输入:nums = [-1,-2,-3,-4,3,2,1]
输出:1
解释:数组中所有值的乘积是 144 ,且 signFunc(144) = 1
```
示例 2:
```
输入:nums = [1,5,0,2,-3]
输出:0
解... | ### 模拟
根据题意进行模拟。
Java 代码:
```Java
class Solution {
public int arraySign(int[] nums) {
int ans = 1;
for (int x : nums) {
if (x == 0) return 0;
if (x < 0) ans *= -1;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function arraySign(nums: number[]): num... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1822s` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1821-1830/1823. 找出游戏的获胜者（中等）.md | 1823. 找出游戏的获胜者 | https://leetcode-cn.com/problems/find-the-winner-of-the-circular-game/solution/by-ac_oier-qsuq/ | 中等 | [
"模拟",
"约瑟夫环"
] | 共有 $n$ 名小伙伴一起做游戏。小伙伴们围成一圈,按 顺时针顺序 从 $1$ 到 $n$ 编号。确切地说,从第 $i$ 名小伙伴顺时针移动一位会到达第 ($i+1$) 名小伙伴的位置,其中 $1 <= i < n$ ,从第 $n$ 名小伙伴顺时针移动一位会回到第 $1$ 名小伙伴的位置。
游戏遵循如下规则:
1. 从第 $1$ 名小伙伴所在位置 开始 。
2. 沿着顺时针方向数 $k$ 名小伙伴,计数时需要 包含 起始时的那位小伙伴。逐个绕圈进行计数,一些小伙伴可能会被数过不止一次。
3. 你数到的最后一名小伙伴需要离开圈子,并视作输掉游戏。
4. 如果圈子中仍然有不止一名小伙伴,从刚刚输掉的小伙伴的 顺时针下一位 小伙伴 开... | ### 模拟
利用数据范围 $1 <= k <= n <= 500$,我们可以直接根据规则进行模拟。
创建一个标记数组 $vis$,若有 $vis[idx] = true$ 则代表点编号为 $idx$ 已被淘汰,每次我们都从当前位置 $cur$ 开始,找到第 $k$ 个尚未淘汰的点($vis[idx] = false$),并将其进行标记($vis[idx] = true$),共有 $n - 1$ 个点需要被淘汰。
一些细节,为了方便取模,我们调整点编号从 $1$ 开始,在返回答案时再重新调整为从 $1$ 开始。
代码:
```Java
class Solution {
public int findTheWinner... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1823` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1831-1840/1833. 雪糕的最大数量（中等）.md | 1833. 雪糕的最大数量 | https://leetcode-cn.com/problems/maximum-ice-cream-bars/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-yrhjx/ | 中等 | [
"贪心",
"排序"
] | 夏日炎炎,小男孩 Tony 想买一些雪糕消消暑。
商店中新到 `n` 支雪糕,用长度为 n 的数组 `costs` 表示雪糕的定价,其中 `costs[i]` 表示第 `i` 支雪糕的现金价格。
Tony 一共有 `coins` 现金可以用于消费,他想要买尽可能多的雪糕。
给你价格数组 `costs` 和现金量 `coins`,请你计算并返回 Tony 用 `coins` 现金能够买到的雪糕的 最大数量 。
注意:Tony 可以按任意顺序购买雪糕。
示例 1:
```
输入:costs = [1,3,2,4,1], coins = 7
输出:4
解释:Tony 可以买下标为 0、1、2、4 的雪糕,总价为 1 + 3 ... | ### 基本分析
从题面看,是一道「01 背包」问题,每个物品的成本为 $cost[i]$,价值为 $1$。
但「01 背包」的复杂度为 $O(N\times C)$,其中 $N$ 为物品数量(数量级为 $10^5$),$C$ 为背包容量(数量级为 $10^8$)。显然会 `TLE`。
换个思路发现,每个被选择的物品对答案的贡献都是 $1$,优先选择价格小的物品会使得我们剩余金额尽可能的多,将来能够做的决策方案也就相应变多。
因此一个直观的做法是,对物品数组进行「从小到大」排序,然后「从前往后」开始决策购买。
---
### 证明
直观上,这样的贪心思路可以使得最终选择的物品数量最多。
接下来证明一下该思路的正确性。... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1833` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1831-1840/1834. 单线程 CPU（中等）.md | 1834. 单线程 CPU | https://leetcode-cn.com/problems/single-threaded-cpu/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-1qk0/ | 中等 | [
"模拟",
"排序",
"优先队列(堆)"
] | 给你一个二维数组 $tasks$,用于表示 $n$ 项从 $0$ 到 $n - 1$ 编号的任务。
其中 $tasks[i] = [enqueueTime_i, processingTime_i]$ 意味着第 $i$ 项任务将会于 $enqueueTime_i$ 时进入任务队列,需要 $processingTime_i$ 的时长完成执行。
现有一个单线程 CPU ,同一时间只能执行**最多一项**任务,该 CPU 将会按照下述方式运行:
* 如果 CPU 空闲,且任务队列中没有需要执行的任务,则 CPU 保持空闲状态。
* 如果 CPU 空闲,但任务队列中有需要执行的任务,则 CPU 将会选择 执行时间最短 的任务开始执行。如果... | ### 模拟 + 数据结构
先将 $tasks$ 按照「入队时间」进行升序排序,同时为了防止任务编号丢失,排序前需要先将二元组的 $tasks$ 转存为三元组,新增记录的是原任务编号。
然后可以按照「时间线」进行模拟:
1. 起始令 $time$ 从 $1$ 开始进行递增,每次将到达「入队时间」的任务进行入队;
2. 判断当前队列是否有可以执行的任务:
1. 如果没有,说明还没到达下一个入队任务的入队时间,直接将 $times$ 快进到下一个入队任务的入队时间;
2. 如果有,从队列中取出任务执行,同时由于是单线程执行,在该任务结束前,不会有新任务被执行,将 $times$ 快进到该任务的结束时间。
代码:
`... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1834` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1831-1840/1838. 最高频元素的频数（中等）.md | 1838. 最高频元素的频数 | https://leetcode-cn.com/problems/frequency-of-the-most-frequent-element/solution/gong-shui-san-xie-cong-mei-ju-dao-pai-xu-kxnk/ | 中等 | [
"枚举",
"哈希表",
"排序",
"前缀和",
"二分",
"滑动窗口",
"双指针"
] | 元素的**频数**是该元素在一个数组中出现的次数。
给你一个整数数组 $nums$ 和一个整数 $k$ 。
在一步操作中,你可以选择 $nums$ 的一个下标,并将该下标对应元素的值增加 $1$ 。
执行最多 $k$ 次操作后,返回数组中最高频元素的**最大可能频数**。
示例 1:
```
输入:nums = [1,2,4], k = 5
输出:3
解释:对第一个元素执行 3 次递增操作,对第二个元素执 2 次递增操作,此时 nums = [4,4,4] 。
4 是数组中最高频元素,频数是 3 。
```
示例 2:
```
输入:nums = [1,4,8,13], k = 5
输出:2
解释:存在多种最优解决方... | ### 枚举
一个朴素的做法是,先对原数组 $nums$ 进行排序,然后枚举最终「频数对应值」是哪个。
利用每次操作只能对数进行加一,我们可以从「频数对应值」开始往回检查,从而得出在操作次数不超过 $k$ 的前提下,以某个值作为「频数对应值」最多能够凑成多少个。
算法整体复杂度为 $O(n^2)$,Java 2021/07/19 可过。
代码:
```Java
class Solution {
public int maxFrequency(int[] nums, int k) {
int n = nums.length;
Map<Integer, Integer> map = new... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1838` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1841-1850/1846. 减小和重新排列数组后的最大元素（中等）.md | 1846. 减小和重新排列数组后的最大元素 | https://leetcode-cn.com/problems/maximum-element-after-decreasing-and-rearranging/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-yh9qt/ | 中等 | [
"贪心"
] | 给你一个正整数数组 `arr`。请你对 `arr` 执行一些操作(也可以不进行任何操作),使得数组满足以下条件:
* `arr` 中 第一个 元素必须为 $1$ 。
* 任意相邻两个元素的差的绝对值 小于等于 $1$ ,也就是说,对于任意的 $1 <= i < arr.length$ (数组下标从 $0$ 开始),都满足 `abs(arr[i] - arr[i - 1]) <= 1`。`abs(x)` 为 `x` 的绝对值。
你可以执行以下 $2$ 种操作任意次:
* 减小 `arr` 中任意元素的值,使其变为一个 更小的正整数 。
* 重新排列 `arr` 中的元素,你可以以任意顺序重新排列。
请你返回执行以上操作后,在满足前... | ### 基本分析 & 证明
根据题意,数组的第一位必须是 $1$,且每个数只能 **减小** 或 **不变**,数值位置可以任意调整。
求解经过调整后,符合要求的数组中的最大值是多少。
首先符合条件的数组相邻位差值绝对值不超过 $1$,这限定了数组的必然是如下三种分布之一:
* (非严格)单调递减
* 存在波段
* (非严格)单调递增
**证明一:取得最优解对应的数组「必然是」或者「可调整为」(非严格)单调递增的形式。**
我们使用反证法来证明另外两种分布不能取得最优解:
* (非严格)单调递减:题目限定了数的范围为正整数,且第一位为 $1$,这种情况不用讨论了,跳过;
* 存在波段:我们始终可以将波峰的右侧出现的值,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1846` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1871-1880/1877. 数组中最大数对和的最小值（中等）.md | 1877. 数组中最大数对和的最小值 | https://leetcode-cn.com/problems/minimize-maximum-pair-sum-in-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ru29y/ | 中等 | [
"贪心"
] | 一个数对 (a,b) 的 数对和 等于 a + b 。最大数对和 是一个数对数组中最大的 数对和 。
比方说,如果我们有数对 (1,5) ,(2,3) 和 (4,4),最大数对和 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8 。
给你一个长度为 偶数 n 的数组 nums ,请你将 nums 中的元素分成 n / 2 个数对,使得:
* nums 中每个元素 恰好 在 一个 数对中,且
* 最大数对和 的值 最小 。
请你在最优数对划分的方案下,返回最小的 最大数对和 。
示例 1:
```
输入:nums = [3,5,2,3]
输出:7
解释:数组中的元素可以分为数对 (3,3) 和... | ### 基本分析 & 证明
直觉上,我们会认为「**尽量让“较小数”和“较大数”组成数对,可以有效避免出现“较大数成对”的现象**」。
我们来证明一下该猜想是否成立。
假定 $nums$ 本身有序,由于我们要将 $nums$ 拆分成 $n / 2$ 个数对,根据猜想,我们得到的数对序列为:
$$
(nums[0], nums[n - 1]), (nums[1], nums[n - 2]), ... , (nums[(n / 2) - 1], nums[n / 2])
$$
**换句话说,构成答案的数对必然是较小数取自有序序列的左边,较大数取自有序序列的右边,且与数组中心对称**。
假设最大数对是 $(nums[i], nu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1877` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1871-1880/1879. 两个数组最小的异或值之和（困难）.md | 1879. 两个数组最小的异或值之和 | https://leetcode.cn/problems/minimum-xor-sum-of-two-arrays/solutions/2402125/gong-shui-san-xie-yi-ti-shuang-jie-zhuan-iusv/ | 困难 | [
"状压 DP",
"动态规划",
"启发式搜索"
] | 给你两个整数数组 `nums1` 和 `nums2`,它们长度都为 `n`。
两个数组的 异或值之和 为 `(nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1])` (下标从 `0` 开始)。
比方说,`[1,2,3]` 和 `[3,2,1]` 的 异或值之和 等于 `(1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4`。
请你将 `nums2` 中的元素重新排列,使得异或值之和最小 。
请你返回重新排列之后的 异或值之和 。
示例 1:
```
输入:... | ### 状压 DP
这是一道「状压 DP」模板题。
为了方便,我们令下标从 $1$ 开始。
**定义 $f[i][s]$ 为考虑前 $i$ 个元素,且对 `nums2` 的使用情况为 $s$ 时的最小异或值**。其中 $s$ 是一个长度为 $n$ 的二进制数:若 $s$ 中的第 $k$ 位为 $1$,说明 `nums2[k]` 已被使用;若 $s$ 中的第 $k$ 位为 $0$,说明 `nums2[k]` 未被使用。
起始时,只有 $f[0][0] = 0$,其余均为无穷大 `INF`。$f[0][0]$ 含义为在不考虑任何数,对 `nums2` 没有任何占用情况时,最小异或值为 $0$。最终 $f[n][2^n - 1]$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1879` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1891-1900/1893. 检查是否区域内所有整数都被覆盖（简单）.md | 1893. 检查是否区域内所有整数都被覆盖 | https://leetcode-cn.com/problems/check-if-all-the-integers-in-a-range-are-covered/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-j83x/ | 简单 | [
"模拟",
"树状数组",
"线段树"
] | 给你一个二维整数数组 `ranges` 和两个整数 `left` 和 `right`。每个 $ranges[i] = [start_i, end_i]$ 表示一个从 $start_i$ 到 $end_i$ 的 闭区间 。
如果闭区间 $[left, right]$ 内每个整数都被 `ranges` 中 至少一个 区间覆盖,那么请你返回 `true`,否则返回 `false`。
已知区间 $ranges[i] = [start_i, end_i]$,如果整数 `x` 满足 $start_i <= x <= end_i$,那么我们称整数 `x` 被覆盖了。
示例 1:
```
输入:ranges = [[1,2],[3,4],[5... | ### 模拟
一个简单的想法是根据题意进行模拟,检查 $[left, right]$ 中的每个整数,如果检查过程中发现某个整数没被 $ranges$ 中的闭区间所覆盖,那么直接返回 `False`,所有数值通过检查则返回 `True`。
代码:
```Java
class Solution {
public boolean isCovered(int[][] rs, int l, int r) {
for (int i = l; i <= r; i++) {
boolean ok = false;
for (int[] cur : rs) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1893` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1891-1900/1894. 找到需要补充粉笔的学生编号（中等）.md | 1894. 找到需要补充粉笔的学生编号 | https://leetcode-cn.com/problems/find-the-student-that-will-replace-the-chalk/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-kpqsk/ | 中等 | [
"前缀和",
"二分",
"模拟"
] | 一个班级里有 n 个学生,编号为 0 到 n - 1 。每个学生会依次回答问题,编号为 0 的学生先回答,然后是编号为 1 的学生,以此类推,直到编号为 n - 1 的学生,然后老师会重复这个过程,重新从编号为 0 的学生开始回答问题。
给你一个长度为 n 且下标从 0 开始的整数数组 chalk 和一个整数 k 。一开始粉笔盒里总共有 k 支粉笔。当编号为 i 的学生回答问题时,他会消耗 chalk[i] 支粉笔。如果剩余粉笔数量 严格小于 chalk[i] ,那么学生 i 需要 补充 粉笔。
请你返回需要 **补充** 粉笔的学生 **编号** 。
示例 1:
```
输入:chalk = [5,1,5], k = 22
... | ### 前缀和 + 二分
根据题意,每个学生消耗的粉笔为定值,所有粉笔最终会像老师的教导一样孜孜不倦地循环投入在所有的学生身上。
因此我们可以预处理出前缀和数组 $sum$,将 $k$ 对所有学生一次循环所消耗总粉笔数($sum[n]$)进行取模,得到最后一轮开始前的粉笔数量。
然后对前缀和数组进行二分,找到最后一位满足粉笔要求的学生,其往后一位的同学编号即是答案。
代码:
```Java
class Solution {
public int chalkReplacer(int[] chalk, int k) {
int n = chalk.length;
long[] sum = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1894` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/191-200/191. 位1的个数（简单）.md | 191. 位1的个数 | https://leetcode-cn.com/problems/number-of-1-bits/solution/yi-ti-san-jie-wei-shu-jian-cha-you-yi-to-av1r/ | 简单 | [
"位运算"
] | 编写一个函数,输入是一个无符号整数(以二进制串的形式),返回其二进制表达式中数字位数为 '1' 的个数(也被称为汉明重量)。
提示:
* 请注意,在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,输入和输出都将被指定为有符号整数类型,并且不应影响您的实现,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的。
* 在 Java 中,编译器使用二进制补码记法来表示有符号整数。因此,在上面的 示例 3 中,输入表示有符号整数 -3。
示例 1:
```
输入:00000000000000000000000000001011
输出:3
解释:输入的二进制串 00000000000000000000000... | ### 「位数检查」解法
一个朴素的做法是,对 `int` 的每一位进行检查,并统计 $1$ 的个数。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
for (int i = 0; i < 32; i++) {
ans += ((n >> i) & 1);
}
return ans;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位
* 空间复杂度:$O(1)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.191` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/191-200/198. 打家劫舍（中等）.md | 198. 打家劫舍 | https://leetcode.cn/problems/house-robber/solution/by-ac_oier-7v1g/ | 中等 | [
"线性 DP",
"状态机 DP",
"动态规划"
] | 你是一个专业的小偷,计划偷窃沿街的房屋。每间房内都藏有一定的现金,影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组,计算你 不触动警报装置的情况下 ,一夜之内能够偷窃到的最高金额。
示例 1:
```
输入:[1,2,3,1]
输出:4
解释:偷窃 1 号房屋 (金额 = 1) ,然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
```
示例 2:
```
输入:[2,7,9,3,1]
输出:12
解释:偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (... | ### 状态机 DP
这是一道入门级的状态机线性 DP 题。
定义 $f[i][j]$ 为考虑前 $i$ 间房子,且第 $i$ 间房子的状态为 $j$ 时所能取得的最大价值(其中 $j = 0$ 代表不偷该房子,$j = 1$ 代表偷该房子)。
再结合题意,因为相邻房子不能同时被偷,可推导出状态转移方程为:
* 当前房子不偷,则对前一间房子的状态无要求,状态值为前一状态的较大值:$f[i][0] = \max(f[i - 1][0], f[i - 1][1])$
* 当前房子偷,此时限定了前一间只能不偷,状态值为前一间房子不偷时的最大价值,加上当前房子的价值: $f[i][1] = f[i - 1][0] + nums[i ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.198` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/191-200/199. 二叉树的右视图（中等）.md | 199. 二叉树的右视图 | null | 中等 | [
"二叉树",
"BFS",
"DFS",
"层序遍历"
] | 给定一个二叉树的 根节点 `root`,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。
示例 1:
```
输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
```
示例 2:
```
输入: [1,null,3]
输出: [1,3]
```
示例 3:
```
输入: []
输出: []
```
提示:
* 二叉树的节点个数的范围是 $[0,100]$
* $-100 <= Node.val <= 100$ | ### BFS
本质就是找层序遍历过程中,每层的最后一个节点。
Java 代码:
```Java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* thi... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.198` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1971-1980/1976. 到达目的地的方案数（中等）.md | 1976. 到达目的地的方案数 | https://leetcode.cn/problems/number-of-ways-to-arrive-at-destination/solution/by-ac_oier-4ule/ | 中等 | [
"最短路",
"拓扑排序",
"动态规划"
] | 你在一个城市里,城市由 $n$ 个路口组成,路口编号为 $0$ 到 $n - 1$ ,某些路口之间有 双向 道路。输入保证你可以从任意路口出发到达其他任意路口,且任意两个路口之间最多有一条路。
给你一个整数 `n` 和二维整数数组 `roads`,其中 $roads[i] = [u_i, v_i, time_i]$ 表示在路口 $u_i$ 和 $v_i$ 之间有一条需要花费 $time_i$ 时间才能通过的道路。你想知道花费 最少时间 从路口 $0$ 出发到达路口 $n - 1$ 的方案数。
请返回花费 最少时间 到达目的地的 路径数目 。由于答案可能很大,将结果对 $10^9 + 7$ 取余 后返回。
示例 1:
```
... | ### Dijkstra + 拓扑排序 + DP
为了方便,我们记 `roads` 为 `rs`,令点数为 `n`,边数为 `m`。
边数与点数不在一个数量级上($m \approx n^2$),属于「稠密图」,我们可以使用「邻接矩阵」进行存图,同时使用朴素 `Dijkstra` 求解从 $0$ 号点到其他点的最短路,记为 `dist` 数组,$dist[i] = x$ 代表以 $0$ 号点为起点到到 $i$ 点的最短路径为 $x$。
当我们预处理出 $0$ 点到其他点的最短距离后,考虑如何统计从 $0$ 点到 $n - 1$ 点,且路径和为 $dist[n - 1]$ 的方案数。
一个容易想到的性质:**在任意的合法方案中... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1976` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1981-1990/1984. 学生分数的最小差值（简单）.md | 1984. 学生分数的最小差值 | https://leetcode-cn.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/solution/gong-shui-san-xie-pai-xu-hua-dong-chuang-ru6e/ | 简单 | [
"二分",
"滑动窗口"
] | 给你一个 下标从 $0$ 开始 的整数数组 $nums$ ,其中 $nums[i]$ 表示第 $i$ 名学生的分数。另给你一个整数 $k$ 。
从数组中选出任意 $k$ 名学生的分数,使这 $k$ 个分数间 **最高分** 和 **最低分** 的 差值 达到 最小化 。
返回可能的 **最小差值** 。
示例 1:
```
输入:nums = [90], k = 1
输出:0
解释:选出 1 名学生的分数,仅有 1 种方法:
- [90] 最高分和最低分之间的差值是 90 - 90 = 0
可能的最小差值是 0
```
示例 2:
```
输入:nums = [9,4,1,7], k = 2
输出:2
解释:选出 2 ... | ### 排序 + 滑动窗口
从 $n$ 个元素里找 $k$ 个,使得 $k$ 个元素最大差值最小。
**最大值最小化问题容易想到「二分」,利用答案本身具有「二段性」,来将原本的求解问题转化为判断定问题。**
回到本题,容易证明,这 $k$ 个元素必然是有序数组中(排序后)的连续段。反证法,若最佳 $k$ 个选择不是连续段,能够调整为连续段,结果不会变差。
因此我们可以先对 $nums$ 进行排序,然后扫描所有大小为 $k$ 的窗口,直接找到答案,而无须使用「二分」。
代码(二分答案代码见 $P2$):
```Java
class Solution {
public int minimumDifference(int... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1894` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/1994. 好子集的数目（困难）.md | 1994. 好子集的数目 | https://leetcode-cn.com/problems/the-number-of-good-subsets/solution/gong-shui-san-xie-zhuang-ya-dp-yun-yong-gz4w5/ | 困难 | [
"状压 DP"
] | 给你一个整数数组 `nums`。如果 `nums` 的一个子集中,所有元素的乘积可以表示为一个或多个 互不相同的质数 的乘积,那么我们称它为 好子集 。
* 比方说,如果 `nums = [1, 2, 3, 4]` :
* `[2, 3]` ,`[1, 2, 3]` 和 `[1, 3]` 是 好 子集,乘积分别为 `6 = 2*3` ,`6 = 2*3` 和 `3 = 3` 。
* `[1, 4]` 和 `[4]` 不是 好 子集,因为乘积分别为 `4 = 2*2` 和 `4 = 2*2` 。
请你返回 `nums` 中不同的 好 子集的数目对 $10^9 + 7$ 取余 的结果。
`nums` 中的 子集 是通过删除 `... | ### 状压 DP
该问题属于 NP 完全问题,注定不存在多项式解决方案,只能通过「爆搜 + 剪枝」或「状压 DP」来求解。
对子集的乘积进行质数分解,等价于对子集每一位数进行质数分解。
一个显然的突破口是 $1 <= nums[i] <= 30$,再加上题目对于「好子集」的定义,我们可以进一步缩减可选数的数量,不超过 $30$ 的质数个数包括 $[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$(共 $10$ 个),将其记作 $p$,在一个好子集中,每个 $p[i]$ 最多出现一次。
同时,题目规定数值相同,下标不同均视为不同方案,因此我们可以先使用数组 $cnts$ 统计在 $nums$ 中每个数... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1994` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/1995. 统计特殊四元组（简单）.md | 1995. 统计特殊四元组 | https://leetcode-cn.com/problems/count-special-quadruplets/solution/gong-shui-san-xie-yi-ti-si-jie-mei-ju-ha-gmhv/ | 简单 | [
"枚举",
"哈希表",
"背包 DP"
] | 给你一个 下标从 `0` 开始 的整数数组 `nums`,返回满足下述条件的**不同**四元组 `(a, b, c, d)` 的 数目 :
`nums[a] + nums[b] + nums[c] == nums[d]`,且 `a < b < c < d`。
示例 1:
```
输入:nums = [1,2,3,6]
输出:1
解释:满足要求的唯一一个四元组是 (0, 1, 2, 3) 因为 1 + 2 + 3 == 6 。
```
示例 2:
```
输入:nums = [3,3,6,4,5]
输出:0
解释:[3,3,6,4,5] 中不存在满足要求的四元组。
```
示例 3:
```
输入:nums = [1,1,... | ### 朴素解法
利用数据范围只有 $50$,可直接根据题意进行模拟。
代码:
```Java
class Solution {
public int countQuadruplets(int[] nums) {
int n = nums.length, ans = 0;
for (int a = 0; a < n; a++) {
for (int b = a + 1; b < n; b++) {
for (int c = b + 1; c < n; c++) {
for (int d = c ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1995` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/1996. 游戏中弱角色的数量（中等）.md | 1996. 游戏中弱角色的数量 | https://leetcode-cn.com/problems/the-number-of-weak-characters-in-the-game/solution/gong-shui-san-xie-tan-xin-yun-yong-ti-by-5ok6/ | 中等 | [
"贪心"
] | 你正在参加一个多角色游戏,每个角色都有两个主要属性:攻击 和 防御 。
给你一个二维整数数组 `properties`,其中 $properties[i] = [attack_i, defense_i]$ 表示游戏中第 $i$ 个角色的属性。
如果存在一个其他角色的攻击和防御等级 都严格高于 该角色的攻击和防御等级,则认为该角色为 弱角色 。
更正式地,如果认为角色 `i` 弱于 存在的另一个角色 `j` ,那么 $attack_j > attack_i$ 且 $defense_j > defense_i$ 。
返回 **弱角色** 的数量。
示例 1:
```
输入:properties = [[5,5],[6,3],[... | ### 排序 + 贪心 + 计数
为了方便,我们使用 `ps` 来代指 `properties`。
决定角色「强弱」的维度有两个,同时由于我们只关心某个角色是否为弱角色,而不关心有多少比其(严格)强的角色有多少个。
因此我们先对 `ps` 进行排序:**优先根据第一维度(攻击力)排序,在第一维度(攻击力)相同时,根据第二维度(防御力)进行排序**。
由于我们统计的是「严格弱角色」,因此在从前往后处理 `ps` 过程中,要将第一维度(攻击力)相同的作为一组进行处理,假设 $[i, j)$ 为第一维度(攻击力)相同的连续段,假设当前处理到连续段 $[i, j)$ 中的第 $k$ 个角色 $ps[k]$,那么 $ps[k]$ 为弱... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1996` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/2000. 反转单词前缀（简单）.md | 2000. 反转单词前缀 | https://leetcode-cn.com/problems/reverse-prefix-of-word/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-dp9u/ | 简单 | [
"模拟",
"双指针"
] | 给你一个下标从 $0$ 开始的字符串 `word` 和一个字符 `ch` 。找出 `ch` 第一次出现的下标 `i` ,反转 `word` 中从下标 $0$ 开始、直到下标 `i` 结束(含下标 `i` )的那段字符。如果 `word` 中不存在字符 `ch` ,则无需进行任何操作。
* 例如,如果 `word = "abcdefd"` 且 `ch = "d"` ,那么你应该 反转 从下标 $0$ 开始、直到下标 `3` 结束(含下标 `3` )。结果字符串将会是 `"dcbaefd"` 。
返回 结果字符串 。
示例 1:
```
输入:word = "abcdefd", ch = "d"
输出:"dcbaefd"
解释... | ### 模拟
先从前往后遍历,找到第一个 `ch` 的下标 $idx$(初始值为 $-1$),然后对 $[0, idx]$ 应用双指针进行翻转(若没有 `ch` 字符,则 $idx = -1$,则 $[0, idx]$ 为不合法区间,翻转过程被跳过)。
代码:
```Java
class Solution {
public String reversePrefix(String word, char ch) {
char[] cs = word.toCharArray();
int n = cs.length, idx = -1;
for (int i = 0; i < n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2000` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2001-2010/2003. 每棵子树内缺失的最小基因值（困难）.md | 2003. 每棵子树内缺失的最小基因值 | https://leetcode.cn/problems/smallest-missing-genetic-value-in-each-subtree/solutions/2505877/gong-shui-san-xie-tu-jie-san-da-jie-lun-mxjrn/ | 困难 | [
"DFS",
"图",
"脑筋急转弯"
] | 有一棵根节点为 `0` 的 家族树 ,总共包含 `n` 个节点,节点编号为 `0` 到 `n - 1`。
给你一个下标从 `0` 开始的整数数组 `parents`,其中 $parents[i]$ 是节点 `i` 的父节点。由于节点 `0` 是根 ,所以 $parents[0] = -1$。
总共有 $10^5$ 个基因值,每个基因值都用 闭区间 $[1, 10^5]$ 中的一个整数表示。
给你一个下标从 `0` 开始的整数数组 `nums`,其中 $nums[i]$ 是节点 `i` 的基因值,且基因值 互不相同 。
请你返回一个数组 `ans`,长度为 `n`,其中 $ans[i]$ 是以节点 `i` 为根的子树内缺失的最... | ### DFS
#### 破题
先用几句话破题。
共由 $n$ 个节点组成一棵树(节点编号从 $0$ 到 $n - 1$),`parents` 描述了该树的形态,同时每个节点有一个基因值 $nums[i]$。
题目要我们求:**以每个节点为根的子树中,权重集合在 $[1, n + 1]$ 范围内缺失的最小数**。
> 需要重点注意:是权重集合在 $[1, n + 1]$ 范围内缺失的最小数,而不是在 `nums` 中缺失的最小数。
举个 🌰,假设由 $4$ 个节点组成树,基因值 `nums = [2,3,4,5]`,那么对应的 `ans = [1,1,1,1]`。
再次强调:我们求的是每个节点为根的子树中,权重集合在... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2003` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2001-2010/2006. 差的绝对值为 K 的数对数目（简单）.md | 2006. 差的绝对值为 K 的数对数目 | https://leetcode-cn.com/problems/count-number-of-pairs-with-absolute-difference-k/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-1jel/ | 简单 | [
"模拟",
"哈希表"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,请你返回数对 $(i, j)$ 的数目,满足 $i < j$ 且`|nums[i] - nums[j]| == k`。
`|x|` 的值定义为:
* 如果 $x >= 0$ ,那么值为 $x$ 。
* 如果 $x < 0$ ,那么值为 $-x$ 。
示例 1:
```
输入:nums = [1,2,2,1], k = 1
输出:4
解释:差的绝对值为 1 的数对为:
- [1,2,2,1]
- [1,2,2,1]
- [1,2,2,1]
- [1,2,2,1]
```
示例 2:
```
输入:nums = [1,3], k = 3
输出:0
解释:没有任何数对差的... | ### 朴素解法
数据范围很小,直接根据题意模拟即可。
代码:
```Java
class Solution {
public int countKDifference(int[] nums, int k) {
int n = nums.length, ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (Math.abs(nums[i] - nums[j]) == k) ans++;
}
}
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2006` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/203. 移除链表元素（简单）.md | 203. 移除链表元素 | https://leetcode-cn.com/problems/remove-linked-list-elements/solution/gong-shui-san-xie-yi-chu-lian-biao-yuan-ca6fu/ | 简单 | [
"链表"
] | 给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
示例 1:
```
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
```
示例 2:
```
输入:head = [], val = 1
输出:[]
```
示例 3:
```
输入:head = [7,7,7,7], val = 7
输出:[]
```
提示:
* 列表中的节点在范围 [0, $10^4$] 内
* 1 <= Node.val <= 50
* 0 <= k <= 50 | ### 递归
一个直观的做法是:写一个递归函数来将某个值为 `val` 的节点从链表中移除。
由于是单链表,无法通过某个节点直接找到「前一个节点」,因此为了方便,我们可以为递归函数多设置一个入参,代表「前一个节点」。
代码:
```Java
class Solution {
public ListNode removeElements(ListNode head, int val) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
dfs(dummy, dummy.next, val);
ret... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.203` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/207. 课程表（中等）.md | 207. 课程表 | https://leetcode.cn/problems/course-schedule/solution/by-ac_oier-byxo/ | 中等 | [
"图论",
"拓扑排序"
] | 你这个学期必须选修 `numCourses` 门课程,记为 $0$ 到 $numCourses - 1$ 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 `prerequisites` 给出,其中 $prerequisites[i] = [a_i, b_i]$ ,表示如果要学习课程 $a_i$ 则 必须 先学习课程 $b_i$ 。
* 例如,先修课程对 $[0, 1$] 表示:想要学习课程 $0$ ,你需要先完成课程 $1$ 。
请你判断是否可能完成所有课程的学习?如果可以,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:numCourses = 2, prerequisites = ... | ### 拓扑排序
为了方便,我们记 `numCourses` 为 `n`,`prerequisites` 为 `g`。
若课程 `a` 存在前置课程 `b` 的话,我们添加一条从 `b` 到 `a` 的有向边,同时统计所有点的入度。
当处理完所有的 $g[i]$ 后,将所有的入度为 $0$ 的课程(含义为没有前置课程要求的科目)进行入队操作,跑一遍「拓扑排序」,若所有课程都能顺利出队,说明所有课程都能使完成。
代码:
```Java
class Solution {
int N = 100010, M = 5010;
int[] in = new int[N], he = new int[N], e = ne... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.207` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/208. 实现 Trie (前缀树)（中等）.md | 208. 实现 Trie (前缀树) | https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/ | 中等 | [
"字典树"
] | Trie(发音类似 "try")或者说 前缀树 是一种树形数据结构,用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景,例如自动补完和拼写检查。
请你实现 Trie 类:
* Trie() 初始化前缀树对象。
* void insert(String word) 向前缀树中插入字符串 word 。
* boolean search(String word) 如果字符串 word 在前缀树中,返回 true(即,在检索之前已经插入);否则,返回 false 。
* boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ,返回 true... | ### Trie 树
$Trie$ 树(又叫「前缀树」或「字典树」)是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。
其核心是使用「边」来代表有无字符,使用「点」来记录是否为「单词结尾」以及「其后续字符串的字符是什么」。
---
### 二维数组
一个朴素的想法是直接使用「二维数组」来实现 $Trie$ 树。
* 使用二维数组 $trie[]$ 来存储我们所有的单词字符。
* 使用 $index$ 来自增记录我们到底用了多少个格子(相当于给被用到格子进行编号)。
* 使用 $count[]$ 数组记录某个格子被「被标记为结尾的次数」(当 $idx$ 编号的格子被标记了 $n$ 次,则有 $cnt[idx] ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.208` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/209. 长度最小的子数组（中等）.md | 209. 长度最小的子数组 | https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/ | 中等 | [
"前缀和",
"二分",
"滑动窗口"
] | 给定一个含有 `n` 个正整数的数组和一个正整数 `target`。
找出该数组中满足其和 `≥ target` 的长度最小的 连续子数组 $[nums_l, nums_{l+1}, ..., nums_{r-1}, nums_r]$ ,并返回其长度。如果不存在符合条件的子数组,返回 $0$ 。
示例 1:
```
输入:target = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
```
示例 2:
```
输入:target = 4, nums = [1,4,4]
输出:1
```
示例 3:
```
输入:target = 11, nums = ... | ### 前缀和 + 二分
利用 $nums[i]$ 的数据范围为 $[1, 10^5]$,可知前缀和数组满足「单调递增」。
我们先预处理出前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于每个 $nums[i]$ 而言,假设其对应的前缀和值为 $s = sum[i + 1]$,我们将 $nums[i]$ 视为子数组的右端点,问题转换为:在前缀和数组下标 $[0, i]$ 范围内找到满足「**值小于等于 $s - t$**」的最大下标,充当子数组左端点的前一个值。
利用前缀和数组的「单调递增」(即具有二段性),该操作可使用「二分」来做。
Java 代码:
```Java
class Solution {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.209` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2011-2020/2013. 检测正方形（中等）.md | 2013. 检测正方形 | https://leetcode-cn.com/problems/detect-squares/solution/gong-shui-san-xie-jian-dan-ha-xi-biao-yu-748e/ | 中等 | [
"哈希表"
] | 给你一个在 X-Y 平面上的点构成的数据流。设计一个满足下述要求的算法:
* 添加 一个在数据流中的新点到某个数据结构中。可以添加 重复 的点,并会视作不同的点进行处理。
* 给你一个查询点,请你从数据结构中选出三个点,使这三个点和查询点一同构成一个 面积为正 的 轴对齐正方形 ,统计 满足该要求的方案数目。
轴对齐正方形 是一个正方形,除四条边长度相同外,还满足每条边都与 x-轴 或 y-轴 平行或垂直。
实现 `DetectSquares` 类:
* `DetectSquares()` 使用空数据结构初始化对象
* `void add(int[] point)` 向数据结构添加一个新的点 `point = [x, y]`
... | ### 哈希表
对于 `add` 操作,我们可以使用「哈希表 套 哈希表」的方式,以 `{x, {y : 点 (x,y) 数量}}` 的形式对传入点进行存储。
对于 `count` 查询而言,假定传入的点为 $(x, y)$,我们可以先查询 $x$ 行都有哪些列,枚举这些列( 即枚举点 $(x, ny)$ ),由 $y$ 和 $ny$ 可得正方形边长 $len$,此时再检查唯一确定的两点 $(x \pm len, y)$ 和 $(x \pm len, ny)$ 的出现次数,应用乘法原理,即可知道该正方形的方案数,统计所有合法方案数即是该询问的答案。
利用题目范围给定的 `x` 和 `y` 具有明确的范围 `0 <= x, y ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2013` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2011-2020/2016. 增量元素之间的最大差值（简单）.md | 2016. 增量元素之间的最大差值 | https://leetcode-cn.com/problems/maximum-difference-between-increasing-elements/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-gisg/ | 简单 | [
"模拟"
] | 给你一个下标从 $0$ 开始的整数数组 $nums$ ,该数组的大小为 $n$ ,请你计算 $nums[j] - nums[i]$ 能求得的 最大差值 ,其中 $0 <= i < j < n$ 且 $nums[i] < nums[j]$ 。
返回 最大差值 。如果不存在满足要求的 $i$ 和 $j$ ,返回 $-1$ 。
示例 1:
```
输入:nums = [7,1,5,4]
输出:4
解释:
最大差值出现在 i = 1 且 j = 2 时,nums[j] - nums[i] = 5 - 1 = 4 。
注意,尽管 i = 1 且 j = 0 时 ,nums[j] - nums[i] = 7 - 1 = 6 > 4 ,但... | ### 模拟
一个显然的做法是两层循环找合适的 `i` 和 `j`,这样的做法是 $O(n^2)$ 的。
利用我们目的是找到能够取得最大差值的数对,对于每个数对中的 $nums[i]$ 而言,对应的 $nums[j]$ 必然第是坐标 $i$ 左侧的最小值,因此可以通过边遍历边维护最小值 $min$ 的做法,从而将复杂度降到 $O(n)$。
代码:
```Java
class Solution {
public int maximumDifference(int[] nums) {
int n = nums.length, ans = -1;
for (int i = 0, min = n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2016` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2022. 将一维数组转变成二维数组（简单）.md | 2022. 将一维数组转变成二维数组 | https://leetcode-cn.com/problems/convert-1d-array-into-2d-array/solution/gong-shui-san-xie-jiang-2021-de-1-gai-ch-qc1a/ | 简单 | [
"模拟"
] | 给你一个下标从 $0$ 开始的一维整数数组 `original` 和两个整数 `m` 和 `n` 。
你需要使用 `original` 中 所有 元素创建一个 `m` 行 `n` 列的二维数组。
`original` 中下标从 `0` 到 `n - 1` (都 包含 )的元素构成二维数组的第一行,下标从 `n` 到 `2 * n - 1` (都 包含 )的元素构成二维数组的第二行,依此类推。
请你根据上述过程返回一个 `m x n` 的二维数组。如果无法构成这样的二维数组,请你返回一个空的二维数组。
示例 1:
```
输入:original = [1,2,3,4], m = 2, n = 2
输出:[[1,2],[3... | ### 模拟
**新年快乐,祝大家身体健康,各种上岸 🎉 🎉(带着 $2021$ 年的一切美好品质继续前行**
构造 $m * n$ 的新二维矩阵 `year2022`,并使用 $idx$ 对旧矩阵 `year2021` 进行遍历即可。
代码:
```Java
class Solution {
public int[][] construct2DArray(int[] year2021, int m, int n) {
if (year2021.length != m * n) return new int[0][0];
int[][] year2022 = new int[m][n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2021` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2024. 考试的最大困扰度（中等）.md | 2024. 考试的最大困扰度 | https://leetcode-cn.com/problems/maximize-the-confusion-of-an-exam/solution/by-ac_oier-2rii/ | 中等 | [
"滑动窗口",
"双指针"
] | 一位老师正在出一场由 $n$ 道判断题构成的考试,每道题的答案为 `true` (用 `'T'` 表示)或者 `false` (用 `'F'` 表示)。老师想增加学生对自己做出答案的不确定性,方法是最大化有连续相同结果的题数。(也就是连续出现 `true` 或者连续出现 `false`)。
给你一个字符串 $answerKey$ ,其中 $answerKey[i]$ 是第 $i$ 个问题的正确结果。除此以外,还给你一个整数 $k$,表示你能进行以下操作的最多次数:
每次操作中,将问题的正确答案改为 `'T'` 或者 `'F'` (也就是将 $answerKey[i]$ 改为 `'T'` 或者 `'F'` )。
请你返回在不超过 ... | ### 滑动窗口
题目求修改次数不超过 $k$ 的前提下,连续段 `'T'` 或 `'F'` 的最大长度。
等价于求一个包含 `'F'` 或者 `'T'` 的个数不超过 $k$ 的最大长度窗口。
假定存在一个 `int getCnt(char c)` 函数,返回包含字符 `c` 数量不超过 $k$ 的最大窗口长度,那么最终 `max(getCnt('T'), getCnt('F'))` 即是答案。
其中 `getCnt` 函数的实现可以使用「滑动窗口」:使用 $j$ 和 $i$ 分别代表窗口的左右端点,$cnt$ 为区间 $[j, i]$ 中的字符 `c` 的数量,每次右端点 $i$ 移动时,若满足 $s[i] = c$,让... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2024` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2028. 找出缺失的观测数据（中等）.md | 2028. 找出缺失的观测数据 | https://leetcode-cn.com/problems/find-missing-observations/solution/by-ac_oier-x22k/ | 中等 | [
"模拟",
"构造"
] | 现有一份 $n + m$ 次投掷单个「六面」骰子的观测数据,骰子的每个面从 $1$ 到 $6$ 编号。观测数据中缺失了 $n$ 份,你手上只拿到剩余 $m$ 次投掷的数据。幸好你有之前计算过的这 $n + m$ 次投掷数据的平均值。
给你一个长度为 $m$ 的整数数组 `rolls` ,其中 $rolls[i]$ 是第 $i$ 次观测的值。同时给你两个整数 $mean$ 和 $n$ 。
返回一个长度为 $n$ 的数组,包含所有缺失的观测数据,且满足这 $n + m$ 次投掷的平均值是 $mean$。
如果存在多组符合要求的答案,只需要返回其中任意一组即可。如果不存在答案,返回一个空数组。
$k$ 个数字的 平均值 为这些数字... | ### 构造
根据题意,我们需要构造长度为 $n$ 的序列 $ans$,使得 $ans$ 和 $rolls$ 并集的平均值为 $mean$。
由于最终的平均值 $mean$ 已知,我们可以直接算得两序列之和为 $t = (m + n) \times mean$。
使用 $t$ 减去 $$\sum_{i = 0}^{m}rolls[i]$$ 可得 $$\sum_{i = 0}^{n}ans[i]$$。我们知道一个长度为 $n$ 的有效序列的元素和范围为 $[n, 6 \times n]$(骰子编号为 $[1, 6]$),根据 $\sum_{i = 0}^{m}rolls[i]$ 与 $[n, 6 \times n]$ 关系进行分... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2028` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2029. 石子游戏 IX（中等）.md | 2029. 石子游戏 IX | https://leetcode-cn.com/problems/stone-game-ix/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-h1oa/ | 中等 | [
"博弈论"
] | `Alice` 和 `Bob` 轮流进行自己的回合,`Alice` 先手。每一回合,玩家需要从 `stones` 中移除任一石子。
如果玩家移除石子后,导致 所有已移除石子 的价值 总和 可以被 $3$ 整除,那么该玩家就 输掉游戏 。
如果不满足上一条,且移除后没有任何剩余的石子,那么 `Bob` 将会直接获胜(即便是在 `Alice` 的回合)。
假设两位玩家均采用 最佳 决策。如果 `Alice` 获胜,返回 `true` ;如果 `Bob` 获胜,返回 `false` 。
示例 1:
```
输入:stones = [2,1]
输出:true
解释:游戏进行如下:
- 回合 1:Alice 可以移除任意一个石子。
-... | ### 分情况讨论博弈
为了方便,我们用 `A` 来代指 `Alice`,用 `B` 带代指 `Bob`。
`A` 只有一种获胜方式,是使得 `B` 在选石子时凑成 $3$ 的倍数;而 `B` 除了能够通过让 `A` 凑成 $3$ 的倍数以外,还能通过让游戏常规结束来获胜。
因此整个游戏过程,我们只需要关心「已被移除的石子总和」和「剩余石子个数/价值情况」即可。
更进一步的,我们只需关心已被移除的石子总和是否为 $3$ 的倍数,以及剩余石子的价值与已移除石子总和相加是否凑成 $3$ 的倍数即可。
所以我们可以按照石子价值除以 $3$ 的余数分成三类,并统计相应数量。
不失一般性考虑,某个回合开始前,已移除的石子总和状态... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2029` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2031. 1 比 0 多的子数组个数（中等）.md | 2031. 1 比 0 多的子数组个数 | null | 中等 | [
"树状数组",
"前缀和"
] | 给你一个只包含 $0$ 和 $1$ 的数组 $nums$,请返回 $1$ 的数量 大于 $04 的数量的子数组的个数。
由于答案可能很大,请返回答案对 $10^9 + 7$ 取余 的结果。
一个 子数组 指的是原数组中连续的一个子序列。
示例 1:
```
输入: nums = [0,1,1,0,1]
输出: 9
解释:
长度为 1 的、1 的数量大于 0 的数量的子数组有: [1], [1], [1]
长度为 2 的、1 的数量大于 0 的数量的子数组有: [1,1]
长度为 3 的、1 的数量大于 0 的数量的子数组有: [0,1,1], [1,1,0], [1,0,1]
长度为 4 的、1 的数量大于 0 的数量的子... | ### 树状数组
为了方便,我们调整数组 $nums$ 下标从 $1$ 开始。同时将 $nums[i] = 0$ 的值看作 $nums[i] = -1$,并预处理出前缀和数组 $sum$。对于任意 $sum[i]$ 而言,其值域范围为 $[-n, n]$,我们可以通过对 $sum[i]$ 做整体 $n + 1$ 的偏移,将值域映射到 $[1, 2 * n + 1]$。
对于任意一个子数组 $i...j$ 而言,如果满足 $1$ 的数量大于 $0$,则必然有 $sum[j] - sum[i - 1] > 0$。
因此在求解以 $nums[j]$ 为右端点的「满足 $1$ 数量大于 $0$ 数量」的子数组个数时,等价于在问 $[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2031` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2034. 股票价格波动（中等）.md | 2034. 股票价格波动 | https://leetcode-cn.com/problems/stock-price-fluctuation/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-u6f4/ | 中等 | [
"数据结构"
] | 给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。
不巧的是,由于股票市场内在的波动性,股票价格记录可能不是按时间顺序到来的。某些情况下,有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中,前一条记录视为错误记录,后出现的记录 更正 前一条错误的记录。
请你设计一个算法,实现:
* 更新 股票在某一时间戳的股票价格,如果有之前同一时间戳的价格,这一操作将 更正 之前的错误价格。
* 找到当前记录里 最新股票价格 。最新股票价格 定义为时间戳最晚的股票价格。
* 找到当前记录里股票的 最高价格 。
* 找到当前记录里股票的 最低价格 。
请你实现 `StockPrice` 类:... | ### 模拟 + 数据结构
容易想到我们需要使用「哈希表」来记录 `{时间:价格}` 的映射关系。
**关于 `current` 操作,我们可以维护一个最大的时间戳 `cur`,在调用 `current` 的时候直接 $O(1)$ 查得结果。**
然后考虑解决 `update` 操作中对相同时间点的更新问题,我们可以使用 `TreeMap`(红黑树)来解决该问题。以 `{价格:该价格对应的时间点数量}` 的 `KV` 形式进行存储,`key` 按照「升序」进行排序。
然后对传入的 `timestamp` 是否已经被记录(是否已经存在哈希表中)进行分情况讨论:
* 传入的 `timestamp` 未被记录,直接更新哈希表和 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2034` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2038. 如果相邻两个颜色均相同则删除当前颜色（中等）.md | 2038. 如果相邻两个颜色均相同则删除当前颜色 | https://leetcode-cn.com/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-y-a8xm/ | 中等 | [
"脑筋急转弯",
"模拟"
] | 总共有 $n$ 个颜色片段排成一列,每个颜色片段要么是 `'A'` 要么是 `'B'` 。
给你一个长度为 $n$ 的字符串 `colors` ,其中 $colors[i]$ 表示第 $i$ 个颜色片段的颜色。
Alice 和 Bob 在玩一个游戏,他们轮流从这个字符串中删除颜色。Alice 先手 。
* 如果一个颜色片段为 `'A'` 且相邻两个颜色都是颜色 `'A'` ,那么 Alice 可以删除该颜色片段。Alice 不可以删除任何颜色 `'B'` 片段。
* 如果一个颜色片段为 `'B'` 且相邻两个颜色都是颜色 `'B'` ,那么 Bob 可以删除该颜色片段。Bob 不可以删除任何颜色 `'A'` 片段。
* Ali... | ### 脑筋急转弯
根据删除规则,删除任意一个 `A` 不会影响可被删删除的 `B` 的数量,反之亦然。
因此直接统计「可删除的 `A` 的数量」和「可删除的 `B` 的数量」,分别记为 $a$ 和 $b$,比较 $a$ 和 $b$ 的大小即可得到答案(只有 $a > b$ 时,先手获胜)。
代码:
```Java
class Solution {
public boolean winnerOfGame(String colors) {
char[] cs = colors.toCharArray();
int n = cs.length;
int a = 0, b = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2038` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2039. 网络空闲的时刻（中等）.md | 2039. 网络空闲的时刻 | https://leetcode-cn.com/problems/the-time-when-the-network-becomes-idle/solution/by-ac_oier-5txs/ | 中等 | [
"BFS"
] | 给你一个有 $n$ 个服务器的计算机网络,服务器编号为 $0$ 到 $n - 1$ 。同时给你一个二维整数数组 `edges` ,其中 $edges[i] = [u_i, v_i]$ 表示服务器 $u_i$ 和 $v_i$ 之间有一条信息线路,在一秒内它们之间可以传输任意数目的信息。再给你一个长度为 $n$ 且下标从 $0$ 开始的整数数组 `patience` 。
题目保证所有服务器都是相通的,也就是说一个信息从任意服务器出发,都可以通过这些信息线路直接或间接地到达任何其他服务器。
编号为 $0$ 的服务器是主服务器,其他服务器为数据服务器。每个数据服务器都要向主服务器发送信息,并等待回复。信息在服务器之间按最优线路传输,也就... | ### 建图 + BFS
根据题目可知这是一个边权为 $1$ 的无向连通图,我们可以采用「邻接表建图 + BFS」的方式预处理出 $dist$ 数组,$dist[i]$ 含义为节点 $i$ 到 $0$ 号点的最短距离。
一个数据服务器 $i$ 往主服务器发送消息所消耗的时间为两节点之间的最短路径 $dist[i]$,而从发送消息到收到回复所需的时间为 $di = 2 * dist[i]$。
同时每个数据服务器还存在时间间隔为 $t = patience[i]$ 的重发动作,并且动作只有在第一次收到主服务的回复后才会停止。
因此如果 $di <= t$,那么数据服务器不会发生重发动作,该节点活动停止时间点为 $di$;当 $d... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2039` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2043. 简易银行系统（中等）.md | 2043. 简易银行系统 | https://leetcode-cn.com/problems/simple-bank-system/solution/by-ac_oier-9pqi/ | 中等 | [
"模拟"
] | 你的任务是为一个很受欢迎的银行设计一款程序,以自动化执行所有传入的交易(转账,存款和取款)。
银行共有 $n$ 个账户,编号从 $1$ 到 $n$ 。每个账号的初始余额存储在一个下标从 $0$ 开始的整数数组 `balance` 中,其中第 $(i + 1)$ 个账户的初始余额是 $balance[i]$ 。
请你执行所有 **有效的** 交易。如果满足下面全部条件,则交易有效 :
* 指定的账户数量在 $1$ 和 $n$ 之间,且
* 取款或者转账需要的钱的总数 小于或者等于 账户余额。
实现 `Bank` 类:
* `Bank(long[] balance)` 使用下标从 $0$ 开始的整数数组 `balance` 初始化... | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Bank {
long[] val;
public Bank(long[] balance) {
val = balance;
}
boolean check(int account) {
return 1 <= account && account <= val.length;
}
public boolean transfer(int a, int b, long c) {
if (!check(a) || !check(b)) return f... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2043` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2044. 统计按位或能得到最大值的子集数目（中等）.md | 2044. 统计按位或能得到最大值的子集数目 | https://leetcode-cn.com/problems/count-number-of-maximum-bitwise-or-subsets/solution/by-ac_oier-dos6/ | 中等 | [
"二进制枚举",
"位运算",
"DFS",
"状压 DP"
] | 给你一个整数数组 $nums$ ,请你找出 $nums$ 子集 **按位或** 可能得到的 **最大值** ,并返回按位或能得到最大值的 **不同非空子集的数目** 。
如果数组 $a$ 可以由数组 $b$ 删除一些元素(或不删除)得到,则认为数组 $a$ 是数组 $b$ 的一个 子集 。如果选中的元素下标位置不一样,则认为两个子集 不同 。
对数组 $a$ 执行 **按位或** ,结果等于 $a[0]$ `OR` $a[1]$ `OR` `...` `OR` $a[a.length - 1]$(下标从 $0$ 开始)。
示例 1:
```
输入:nums = [3,1]
输出:2
解释:子集按位或能得到的最大值是 3 。... | ### 二进制枚举
令 $n$ 为 $nums$ 的长度,利用 $n$ 不超过 $16$,我们可以使用一个 `int` 数值来代指 $nums$ 的使用情况(子集状态)。
假设当前子集状态为 $state$,$state$ 为一个仅考虑低 $n$ 位的二进制数,当第 $k$ 位为 $1$,代表 $nums[k]$ 参与到当前的按位或运算,当第 $k$ 位为 $0$,代表 $nums[i]$ 不参与到当前的按位或运算。
在枚举这 $2^n$ 个状态过程中,我们使用变量 `max` 记录最大的按位或得分,使用 `ans` 记录能够取得最大得分的状态数量。
代码:
```Java
class Solution {
pub... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2044` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2045. 到达目的地的第二短时间（困难）.md | 2045. 到达目的地的第二短时间 | https://leetcode-cn.com/problems/second-minimum-time-to-reach-destination/solution/gong-shui-san-xie-yi-ti-shuang-jie-dui-y-88np/ | 困难 | [
"最短路",
"BFS",
"堆优化 Dijkstra",
"AStar 算法",
"启发式搜索"
] | 城市用一个 双向连通 图表示,图中有 $n$ 个节点,从 $1$ 到 $n$ 编号(包含 $1$ 和 $n$)。图中的边用一个二维整数数组 $edges$ 表示,其中每个 $edges[i] = [u_i, v_i]$ 表示一条节点 $u_i$ 和节点 $v_i$ 之间的双向连通边。每组节点对由 最多一条 边连通,顶点不存在连接到自身的边。穿过任意一条边的时间是 $time$ 分钟。
每个节点都有一个交通信号灯,每 $change$ 分钟改变一次,从绿色变成红色,再由红色变成绿色,循环往复。所有信号灯都 同时 改变。你可以在 任何时候 进入某个节点,但是 只能 在节点 信号灯是绿色时 才能离开。如果信号灯是 绿色 ,你 不能 在... | ### 堆优化 Dijkstra
整体题意:在一张正权无向图上求严格次短路,该图无重边与自环。
同时根据提示 $edges.length <= \min(2 * 10^4, n * (n - 1) / 2)$ 可知,该图为「稀疏图」,容易想到「堆优化 Dijkstra」做法。
对「堆优化 Dijkstra」或者「其他最短路算法」不熟悉的同学,可以看前置 🧀 :[【最短路/必背模板】涵盖所有的「存图方式」与「最短路算法(详尽注释)」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2045` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2047. 句子中的有效单词数（简单）.md | 2047. 句子中的有效单词数 | https://leetcode-cn.com/problems/number-of-valid-words-in-a-sentence/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-5pcz/ | 简单 | [
"模拟",
"双指针"
] | 句子仅由小写字母(`'a'` 到 `'z'`)、数字('0' 到 '9')、连字符(`'-'`)、标点符号(`'!'`、`'.'` 和 `','`)以及空格(`' '`)组成。每个句子可以根据空格分解成 一个或者多个 `token` ,这些 `token` 之间由一个或者多个空格 `' '` 分隔。
如果一个 `token` 同时满足下述条件,则认为这个 `token` 是一个有效单词:
* 仅由小写字母、连字符和/或标点(不含数字)。
* 至多一个 连字符 `'-'` 。如果存在,连字符两侧应当都存在小写字母(`"a-b"` 是一个有效单词,但 `"-ab"` 和 `"ab-"` 不是有效单词)。
* 至多一个 标点符号。如果... | ### 模拟
根据题意进行模拟即可,先将 `sentence` 按照空格进行分割,得到多个 `item`,再对每个 `item` 进行合法性检查,最后统计合法的 `item` 个数即为答案。
在对 `item` 进行合法性检查时,分别使用 $c1$ 和 $c2$ 代表「连字符」和「标点符号」的出现次数。
> 特别说明:Java 的 `split` 操作基于正则,复杂度为线性,其他语言可能需要使用「双指针」手写 `split` 操作
代码( 双指针实现 `split` 的代码见 $P2$ ):
```Java
class Solution {
public int countValidWords(String sent... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2047` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2049. 统计最高分的节点数目（中等）.md | 2049. 统计最高分的节点数目 | https://leetcode-cn.com/problems/count-nodes-with-the-highest-score/solution/gong-shui-san-xie-jian-tu-dfs-by-ac_oier-ujfo/ | 中等 | [
"图论",
"线性 DP"
] | 给你一棵根节点为 $0$ 的 二叉树 ,它总共有 $n$ 个节点,节点编号为 $0$ 到 $n - 1$ 。
同时给你一个下标从 $0$ 开始的整数数组 $parents$ 表示这棵树,其中 $parents[i]$ 是节点 $i$ 的父节点。由于节点 $0$ 是根,所以 $parents[0] == -1$ 。
一个子树的 **大小** 为这个子树内节点的数目。每个节点都有一个与之关联的 **分数** 。求出某个节点分数的方法是,将这个节点和与它相连的边全部 **删除** ,剩余部分是若干个 **非空** 子树,这个节点的 **分数** 为所有这些子树 大小的乘积 。
请你返回有 **最高得分** 节点的 数目 。
示例 ... | ### 建图 + DFS + 统计答案
为了更具有一般性,我们假定该树为多叉树。
由于题目给定的 `parents` 数组仅支持我们快速查找某个节点的父节点,为了方便遍历整棵树,我们先使用「邻接表」将图(树)建起来。
还不熟悉「邻接表」存图方式的同学可以看看前置 🧀 : [涵盖所有的「存图方式」模板](https%3A//mp.weixin.qq.com/s?__biz%3DMzU4NDE3MTEyMA%3D%3D%26mid%3D2247488007%26idx%3D1%26sn%3D9d0dcfdf475168d26a5a4bd6fcd3505d%26chksm%3Dfd9cb918caeb300e1c8844583db... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2049` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2051-2060/2055. 蜡烛之间的盘子（中等）.md | 2055. 蜡烛之间的盘子 | https://leetcode-cn.com/problems/plates-between-candles/solution/gong-shui-san-xie-er-fen-qian-zhui-he-yu-0qt0/ | 中等 | [
"前缀和",
"二分"
] | 给你一个长桌子,桌子上盘子和蜡烛排成一列。给你一个下标从 $0$ 开始的字符串 `s` ,它只包含字符 `'*'` 和 `'|'` ,其中 `'*'` 表示一个 盘子 ,`'|'` 表示一支 蜡烛 。
同时给你一个下标从 $0$ 开始的二维整数数组 `queries` ,其中 $queries[i] = [lefti, righti]$ 表示 子字符串 $s[left_i...right_i]$ (包含左右端点的字符)。对于每个查询,你需要找到 子字符串中 在 两支蜡烛之间 的盘子的 数目 。如果一个盘子在 子字符串中 左边和右边 都 至少有一支蜡烛,那么这个盘子满足在 两支蜡烛之间 。
比方说,`s = "||**||**|*... | ### 二分 + 前缀和
对于任意一个查询 $[a, b]$ 而言,我们需要统计所有左边和右边能够找到蜡烛的盘子数量。
一个自然的想法是:**找到区间 $[a, b]$ 两边缘的蜡烛,分别记为 $c$ 和 $d$,显然区间 $[c, d]$ 内的盘子都是需要被统计的。**
因此,我们可以对字符串 `s` 进行从前往后的扫描,将所有的蜡烛下标添加到数组(数组严格递增),并预处理出盘子的「前缀和」数组。
然后处理询问时的「找区间 $[a, b]$ 边缘蜡烛」操作可通过对数组「二分」来做,而「查询区间 $[c, d]$ 内的盘子数量」操作可直接查询「前缀和」数组。
Java 代码:
```Java
class Solution ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2055` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2051-2060/2059. 转化数字的最小运算数（中等）.md | 2059. 转化数字的最小运算数 | https://leetcode-cn.com/problems/minimum-operations-to-convert-number/solution/gong-shui-san-xie-shuang-xiang-bfs-mo-ba-uckg/ | 中等 | [
"图论 BFS",
"双向 BFS"
] | 给你一个下标从 `0` 开始的整数数组 `nums`,该数组由 互不相同 的数字组成。
另给你两个整数 `start` 和 `goal` 。
整数 `x` 的值最开始设为 `start` ,你打算执行一些运算使 `x` 转化为 `goal` 。
你可以对数字 `x` 重复执行下述运算:
如果 `0 <= x <= 1000`,那么,对于数组中的任一下标 `i` `(0 <= i < nums.length)`,可以将 `x` 设为下述任一值:
* `x + nums[i]`
* `x - nums[i]`
* `x ^ nums[i](按位异或 XOR)`
注意,你可以按任意顺序使用每个 `nums[i]` 任意次。使 `... | ### 常规 BFS
题目给定了从当前值 $x$ 到 $x'$ 的转换规则,同时只有满足 $0 <= x <= 1000$ 的数值才能继续进行转换,因此配合去重,转换次数具有明确上界,使用常规的 `BFS` 即可求解。
需要注意的是,为了避免 TLE,我们应当将「满足 $0 <= x <= 1000$ 才能进行下一步转换」这一规则应用到「限制入队」,而不是简单的应用在「限制拓展」。
即如果由 $x$ 拓展出来的 $x'$,既不与 $goal$ 相等,也不满足 $0 <= x' <= 1000$ 条件,那么 $x'$ 并无入队必要。
代码:
```Java
class Solution {
public int mi... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2059` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2061-2070/2069. 模拟行走机器人 II（中等）.md | 2069. 模拟行走机器人 II | https://leetcode-cn.com/problems/walking-robot-simulation-ii/solution/by-ac_oier-6zib/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 给你一个在 `XY` 平面上的 `width x height` 的网格图,左下角 的格子为 $(0, 0)$,右上角的格子为 $(width - 1, height - 1)$ 。网格图中相邻格子为四个基本方向之一(`"North"`,`"East"`,`"South"` 和 `"West"`)。一个机器人初始在格子 $(0, 0)$ ,方向为 `"East"`。
机器人可以根据指令移动指定的步数。每一步,它可以执行以下操作。
1. 沿着当前方向尝试往前一步 。
2. 如果机器人下一步将到达的格子超出了边界,机器人会逆时针转 90 度,然后再尝试往前一步。
如果机器人完成了指令要求的移动步数,它将停止移动并等待下一个指令。
... | ### 模拟
根据题目给定的移动规则可知,机器人总是在外圈移动(共上下左右四条),而移动方向分为四类:
当行走步数为 $mod = 2 * (w - 1) + 2 * (h - 1)$ 的整数倍时,会回到起始位置,因此我们可以通过维护一个变量 `loc` 来记录行走的总步数,并且每次将 `loc` 对 `mod` 进行取模来得到有效步数。
在回答 `getPos` 和 `getDir` 询问时,根据当前 `loc` 进行分情况讨论(见注释)。
另外还有一个小细节:根据题意,如果当前处于 $(0, 0)$ 位置,并且没有移动过,方向为 `East`,若移动过,方向则为 `South`,这可以通过一个变量 `moved` 来进行... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2069` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2091-2100/2100. 适合打劫银行的日子（中等）.md | 2100. 适合打劫银行的日子 | https://leetcode-cn.com/problems/find-good-days-to-rob-the-bank/solution/gong-shui-san-xie-qian-zhui-he-yun-yong-gf604/ | 中等 | [
"前缀和"
] | 你和一群强盗准备打劫银行。给你一个下标从 $0$ 开始的整数数组 $security$ ,其中 $security[i]$ 是第 $i$ 天执勤警卫的数量。日子从 $0$ 开始编号。同时给你一个整数 $time$ 。
如果第 $i$ 天满足以下所有条件,我们称它为一个适合打劫银行的日子:
* 第 $i$ 天前和后都分别至少有 $time$ 天。
* 第 $i$ 天前连续 $time$ 天警卫数目都是非递增的。
* 第 $i$ 天后连续 $time$ 天警卫数目都是非递减的。
更正式的,第 $i$ 天是一个合适打劫银行的日子当且仅当:
$security[i - time] >= security[i - time + 1] ... | ### 前缀和
为了方便,我们令 $n$ 为 $security$ 长度。
根据题目对「适合打劫银行的日子」的定义,首先我们可以确定答案落在 $[time, n - time]$ 范围内,另外规定了「适合打劫银行的日子」左右侧需要满足「非递增」和「非递减」的性质。
首先我们可以预处理 `g` 数组,$g[i]$ 代表当前时间 $security[i]$ 与前一时间 $security[i - 1]$ 的大小关系,当 $security[i] > security[i - 1]$ 时有 $g[i] = 1$,当 $security[i] < security[i - 1]$ 时有 $g[i] = -1$,否则 $g[i] = 0... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2100` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/21. 合并两个有序链表（简单）.md | 21. 合并两个有序链表 | https://leetcode-cn.com/problems/merge-two-sorted-lists/solution/shua-chuan-lc-shuang-zhi-zhen-jie-fa-sha-b22z/ | 简单 | [
"多路归并",
"链表"
] | 将两个升序链表合并为一个新的 升序 链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
```
输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]
```
示例 2:
```
输入:l1 = [], l2 = []
输出:[]
```
示例 3:
```
输入:l1 = [], l2 = [0]
输出:[0]
```
提示:
* 两个链表的节点数目范围是 $[0, 50]$
* $-100 <= Node.val <= 100$
* `l1` 和 `l2` 均按 非递减顺序 排列 | ### 多路归并(哨兵技巧)
哨兵技巧我们之前在「2. 两数相加」讲过啦,让三叶来帮你回忆一下:
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
由于两条链表本身就是有序的,只需要在遍历过程中进行比较即可:
代码:
```Java
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
if (l2 == null) return l1;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.21` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/22. 括号生成（中等）.md | 22. 括号生成 | https://leetcode-cn.com/problems/generate-parentheses/solution/shua-chuan-lc-dfs-jie-fa-by-ac_oier-nknl/ | 中等 | [
"DFS",
"回溯算法"
] | 数字 $n$ 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。
示例 1:
```
输入:n = 3
输出:["((()))","(()())","(())()","()(())","()()()"]
```
示例 2:
```
输入:n = 1
输出:["()"]
```
提示:
* $1 <= n <= 8$ | ### DFS
既然题目是求所有的方案,那只能爆搜了,爆搜可以使用 `DFS` 来做。
从数据范围 `1 <= n <= 8` 来说,`DFS` 应该是稳稳的 AC。
这题的关键是我们要从题目中发掘一些性质:
1. 括号数为 `n`,那么一个合法的括号组合,应该包含 `n` 个左括号和 `n` 个右括号,组合总长度为 `2n`
2. 一对合法的括号,应该是先出现左括号,再出现右括号。那么意味着**任意一个右括号的左边,至少有一个左括号**
其中性质 2 是比较难想到的,我们可以用反证法来证明性质 2 总是成立:
假设某个右括号不满足「其左边至少有一个左括号」,即其左边没有左括号,那么这个右括号就找不到一个与之对应的左括... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.22` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/23. 合并K个升序链表（困难）.md | 23. 合并K个升序链表 | https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/shua-chuan-lc-you-xian-dui-lie-jie-fa-sh-3flb/ | 困难 | [
"优先队列(堆)",
"链表",
"多路归并"
] | 给你一个链表数组,每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中,返回合并后的链表。
示例 1:
```
输入:lists = [[1,4,5],[1,3,4],[2,6]]
输出:[1,1,2,3,4,4,5,6]
解释:链表数组如下:
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
```
示例 2:
```
输入:lists = []
输出:[]
```
示例 3:
```
输入:lists = [[]]
输出:[]
```
提示:
* $k == lists.length$
* $0 <= k <=... | ### 多路归并 + 优先队列
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
由于所有链表本身满足「升序」,一个直观的做法是,我们比较每条链表的头结点,选取值最小的节点,添加到结果中,然后更新该链表的的头结点为该节点的 next 指针。循环比较,直到所有的节点都被加入结果中。
对应到代码的话,相当于我们需要准备一个「集合」,将所有链表的头结点放入「集合」,然后每次都从「集合」中挑出最小值,并将最小值的下一个节点添加进「集合」(如果有的话),循环这个过程,直到「集合」为空(说明所有节点都处理完,进过集合又从集合中出来)。
优先队列(堆)则是满足这样要求的数据结构,而整个过程其实就... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.23` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/24. 两两交换链表中的节点（中等）.md | 24. 两两交换链表中的节点 | https://leetcode-cn.com/problems/swap-nodes-in-pairs/solution/shua-chuan-lc-di-gui-die-dai-jie-fa-shao-70t3/ | 中等 | [
"递归",
"链表"
] | 给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
示例 1:
```
输入:head = [1,2,3,4]
输出:[2,1,4,3]
```
示例 2:
```
输入:head = []
输出:[]
```
示例 3:
```
输入:head = [1]
输出:[1]
```
提示:
* 链表中节点的数目在范围 $[0, 100]$ 内
* $0 <= Node.val <= 100$
进阶:你能在不修改链表节点值的情况下解决这个问题吗?(也就是说,仅修改节点本身。) | ### 递归解法(哨兵技巧)
哨兵技巧我们之前在前面的多道链表题讲过,让三叶来帮你回忆一下:
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
链表和树的题目天然适合使用递归来做。
我们可以设计一个递归函数,接受一个 `ListNode` 节点 root 作为参数,函数的作用是将 root 后面的两个节点进行交换,交换完成后再将下一个节点传入 ...
交换的前提条件:节点 root 后面至少有两个节点。同时别忘了应用我们的「哨兵技巧」。
代码:
```Java
class Solution {
public ListNode swapPairs(ListNode he... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.22` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/25. K 个一组翻转链表（困难）.md | 25. K 个一组翻转链表 | https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/shua-chuan-lc-duo-tu-jiang-jie-di-gui-gu-6wr0/ | 困难 | [
"递归",
"迭代",
"链表"
] | 给你一个链表,每 `k` 个节点一组进行翻转,请你返回翻转后的链表。
`k` 是一个正整数,它的值小于或等于链表的长度。
如果节点总数不是 `k` 的整数倍,那么请将最后剩余的节点保持原有顺序。
进阶:
* 你可以设计一个只使用常数额外空间的算法来解决此问题吗?
* 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。
示例 1:
```
输入:head = [1,2,3,4,5], k = 2
输出:[2,1,4,3,5]
```
示例 2:
```
输入:head = [1,2,3,4,5], k = 3
输出:[3,2,1,4,5]
```
示例 3:
```
输入:head = [1,2,3,4,5... | ### 迭代(哨兵技巧)
哨兵技巧我们在前面的多道链表题讲过,让三叶来帮你回忆一下:
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
链表和树的题目天然适合使用递归来做。
但这次我们先将简单的「递归版本」放一放,先搞清楚迭代版本该如何实现。
我们可以设计一个翻转函数 `reverse` :
**传入节点 `root` 作为参数,函数的作用是将以 `root` 为起点的 $k$ 个节点进行翻转。**
**当以 `root` 为起点的长度为 $k$ 的一段翻转完成后,再将下一个起始节点传入,直到整条链表都被处理完成。**
**当然,在 `reverse` 函数真正执行翻转前,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/26. 删除有序数组中的重复项（简单）.md | 26. 删除有序数组中的重复项 | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/ | 简单 | [
"数组",
"双指针",
"数组移除元素问题"
] | 给你一个有序数组 `nums` ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。
不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 $O(1)$ 额外空间的条件下完成。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
```
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数... | ### 双指针
一个指针 `i` 进行数组遍历,另外一个指针 `j` 指向有效数组的最后一个位置。
只有当 `i` 所指向的值和 `j` 不一致(不重复),才将 `i` 的值添加到 `j` 的下一位置。
代码:
```Java
class Solution {
public int removeDuplicates(int[] nums) {
int n = nums.length;
int j = 0;
for (int i = 0; i < n; i++) {
if (nums[i] != nums[j]) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.26` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/27. 移除元素（简单）.md | 27. 移除元素 | https://leetcode-cn.com/problems/remove-element/solution/shua-chuan-lc-shuang-bai-shuang-zhi-zhen-mzt8/ | 简单 | [
"数组",
"双指针",
"数组移除元素问题"
] | 给你一个数组 `nums` 和一个值 `val`,你需要「原地」移除所有数值等于 `val` 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 $O(1)$ 额外空间并「原地」修改输入数组。
元素的顺序可以改变。
你不需要考虑数组中超出新长度后面的元素。
**说明**:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
```
// nums 是以“引用”方式传递的。也就是说,不对实参作任何拷贝
int len = removeElement(nums, val);
// 在... | ### 双指针
本解法的思路与 [【题解】26. 删除排序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/) 中的「双指针解法」类似。
根据题意,我们可以将数组分成「前后」两段:
* 前半段是有效部分,存储的是不等于 `val` 的元素。
* 后半段是无效部分,存储的是等于 `val` 的元素。
最终答案返回有效部分的结尾下标。
代码:
```Java
class Solution {
public ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.27` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/28. 实现 strStr()（简单）.md | 28. 实现 strStr() | https://leetcode-cn.com/problems/implement-strstr/solution/shua-chuan-lc-shuang-bai-po-su-jie-fa-km-tb86/ | 简单 | [
"子串匹配",
"KMP"
] | 实现 `strStr()` 函数。
给你两个字符串 `haystack` 和 `needle` ,请你在 `haystack` 字符串中找出 `needle` 字符串出现的第一个位置(下标从 $0$ 开始)。
如果不存在,则返回 $-1$ 。
说明:
* 当 `needle` 是空字符串时,我们应当返回什么值呢?这是一个在面试中很好的问题。
* 对于本题而言,当 `needle` 是空字符串时我们应当返回 $0$ 。这与 C 语言的 `strstr()` 以及 Java 的 `indexOf()` 定义相符。
示例 1:
```
输入:haystack = "hello", needle = "ll"
输出:2
``... | ### 朴素解法
直观的解法的是:枚举原串 `ss` 中的每个字符作为「发起点」,每次从原串的「发起点」和匹配串的「首位」开始尝试匹配:
* 匹配成功:返回本次匹配的原串「发起点」。
* 匹配失败:枚举原串的下一个「发起点」,重新尝试匹配。
代码:
```Java
class Solution {
public int strStr(String ss, String pp) {
int n = ss.length(), m = pp.length();
char[] s = ss.toCharArray(), p = pp.toCharArray();
// 枚举原串的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.28` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/29. 两数相除（中等）.md | 29. 两数相除 | https://leetcode-cn.com/problems/divide-two-integers/solution/gong-shui-san-xie-dui-xian-zhi-tiao-jian-utb9/ | 中等 | [
"数学",
"二分"
] | 给定两个整数,被除数 `dividend` 和除数 `divisor`。
将两数相除,要求不使用乘法、除法和 `mod` 运算符。
返回被除数 `dividend` 除以除数 `divisor` 得到的商。
整数除法的结果应当截去(`truncate`)其小数部分,例如:`truncate(8.345) = 8` 以及 `truncate(-2.7335) = -2`
示例 1:
```
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
```
示例 2:
```
输入: dividend = 7,... | ### 基本分析
主要的歧义在于第三点限制「假设我们的环境只能存储 $32$ 位有符号整数,其数值范围是 $[−2^{31}, 2^{31} − 1]$。本题中,如果除法结果溢出,则返回 $2^{31} − 1$」的理解。
该限制有两种理解方式:
1. 不限制算法使用 `long`,只是解释为什么在溢出时,返回 $2^{31} − 1$;
2. 限制算法使用 `long`。
原始题解在 [这里](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/) 。
---... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.29` 篇,系列开始于 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.