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/351-360/357. 统计各位数字都不同的数字个数（中等）.md | 357. 统计各位数字都不同的数字个数 | https://leetcode-cn.com/problems/count-numbers-with-unique-digits/solution/by-ac_oier-6tfl/ | 中等 | [
"数学",
"容斥原理",
"数位 DP"
] | 给你一个整数 $n$ ,统计并返回各位数字都不同的数字 $x$ 的个数,其中 $0 <= x < 10^n$ 。
示例 1:
```
输入:n = 2
输出:91
解释:答案应为除去 11、22、33、44、55、66、77、88、99 外,在 0 ≤ x < 100 范围内的所有数字。
```
示例 2:
```
输入:n = 0
输出:1
```
提示:
* $0 <= n <= 8$ | ### 乘法原理
对于 $n = 0$ 的情况较为特殊,特判一下,返回 $1$。
对于其他情况,由于不能含有前导 $0$,最高位可选择的数值个数为 $9$,而从次高位开始到最低位,可选的个数从 $9$ 开始逐一递减。
利用乘法原理,每位数可选的数值个数相乘即是长度为 $n$ 的数的可能方案数 $cur$,而所有长度 $[1, n]$ 的方案数累加即是答案。
代码:
```Java
class Solution {
public int countNumbersWithUniqueDigits(int n) {
if (n == 0) return 1;
int ans = 10;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.357` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/361-370/363. 矩形区域不超过 K 的最大数值和（困难）.md | 363. 矩形区域不超过 K 的最大数值和 | https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-dh8s/ | 困难 | [
"二分",
"前缀和"
] | 给你一个 `m x n` 的矩阵 `matrix` 和一个整数 $k$ ,找出并返回矩阵内部矩形区域的不超过 $k$ 的最大数值和。
题目数据保证总会存在一个数值和不超过 $k$ 的矩形区域。
示例 1:
```
输入:matrix = [[1,0,1],[0,-2,3]], k = 2
输出:2
解释:蓝色边框圈出来的矩形区域 [[0, 1], [-2, 3]] 的数值和是 2,且 2 是不超过 k 的最大数字(k = 2)。
```
示例 2:
```
输入:matrix = [[2,2,-1]], k = 3
输出:3
```
提示:
* $m == matrix.length$
* $n == matrix[i... | ### 朴素二维前缀和
从题面来看显然是一道「二维前缀和」的题目,如果你还不了解「二维前缀和」,可以看看 [(题解)304. 二维区域和检索 - 矩阵不可变](https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/)。本题预处理前缀和的复杂度为 $O(m * n)$。
搜索所有子矩阵需要枚举「矩形左上角」和「矩形右下角」,复杂度是 $O(m^2 * n^2)$。
因此,如果把本题当做二维前缀和模板题来做的话,整体复杂度是 $O(m^2 * n^2)$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.363` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/361-370/367. 有效的完全平方数（简单）.md | 367. 有效的完全平方数 | https://leetcode-cn.com/problems/valid-perfect-square/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-g5el/ | 简单 | [
"二分",
"数学"
] | 给定一个 正整数 $num$ ,编写一个函数,如果 $num$ 是一个完全平方数,则返回 $true$ ,否则返回 $false$ 。
进阶:不要使用任何内置的库函数,如 `sqrt`。
示例 1:
```
输入:num = 16
输出:true
```
示例 2:
```
输入:num = 14
输出:false
```
提示:
* $1 <= num <= 2^{31} - 1$ | ### 二分
假如答案为 $ans$,那么以 $ans$ 为分割点的数轴上具有二段性:
* 小于 $ans$ 的一段 $x$ 必然不满足 $x * x \geq num$;
* 大于等于 $ans$ 的一段 $x$ 必然满足 $x * x \geq num$。
因此可以通过「二分」来找到分割点 $ans$。
代码:
```Java
class Solution {
public boolean isPerfectSquare(int num) {
long l = 0, r = num;
while (l < r) {
long mid = l + r + 1 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.367` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/361-370/368. 最大整除子集（中等）.md | 368. 最大整除子集 | https://leetcode-cn.com/problems/largest-divisible-subset/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-0a3jc/ | 中等 | [
"序列 DP"
] | 给你一个由 无重复 正整数组成的集合 nums ,请你找出并返回其中最大的整除子集 answer ,子集中每一元素对 (answer[i], answer[j]) 都应当满足:
* answer[i] % answer[j] == 0 ,或
* answer[j] % answer[i] == 0
如果存在多个有效解子集,返回其中任何一个均可。
示例 1:
```
输入:nums = [1,2,3]
输出:[1,2]
解释:[1,3] 也会被视为正确答案。
```
示例 2:
```
输入:nums = [1,2,4,8]
输出:[1,2,4,8]
```
提示:
* 1 <= nums.length <= 1000
*... | ### 基本分析
根据题意:**对于符合要求的「整除子集」中的任意两个值,必然满足「较大数」是「较小数」的倍数。**
数据范围是 $10^3$,我们不可能采取获取所有子集,再检查子集是否合法的爆搜解法。
通常「递归」做不了,我们就往「递推」方向去考虑。
**由于存在「整除子集」中任意两个值必然存在倍数/约数关系的性质,我们自然会想到对 `nums` 进行排序,然后从集合 `nums` 中从大到小进行取数,每次取数只考虑当前决策的数是否与「整除子集」中的最后一个数成倍数关系即可。**
这时候你可能会想枚举每个数作为「整除子集」的起点,然后从前往后遍历一遍,每次都将符合「与当前子集最后一个元素成倍数」关系的数加入答案。
举个... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.368` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/371. 两整数之和（中等）.md | 371. 两整数之和 | https://leetcode-cn.com/problems/sum-of-two-integers/solution/gong-shui-san-xie-shi-yong-wei-yun-suan-4hpb7/ | 中等 | [
"位运算"
] | 给你两个整数 `a` 和 `b` ,不使用 运算符 `+` 和 `-`,计算并返回两整数之和。
示例 1:
```
输入:a = 1, b = 2
输出:3
```
示例 2:
```
输入:a = 2, b = 3
输出:5
```
提示:
* -1000 <= a, b <= 1000 | ### 位运算
一个朴素的做法是使用「位运算」,利用二进制的「逢二进一」和「`int` 二进制表示长度为 $32$」,我们可以从低位往高位进行处理,处理过程中使用变量 $t$ 记录进位信息。
然后对两数当前位进行分情况讨论:
* 两个当前位均为 $1$:此时当前位是什么取决于前一位的进位情况,即有 `ans |= (t << i)`,同时进位 $t = 1$;
* 两个当前位只有一位是 $1$:此时当前位是什么取决于前一位的进位情况(整理后可统一为 `ans |= ((1 ^ t) << i)`:
* 前一进位若为 $1$,结合该位为 $1$,则有当前位为 $0$,进位不变 $t = 1$;
* 前一进位若为 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.371` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/372. 超级次方（中等）.md | 372. 超级次方 | https://leetcode-cn.com/problems/super-pow/solution/gong-shui-san-xie-di-gui-kuai-su-mi-ying-yx1j/ | 中等 | [
"数学",
"快速幂"
] | 你的任务是计算 `ab` 对 $1337$ 取模,`a` 是一个正整数,`b` 是一个非常大的正整数且会以数组形式给出。
示例 1:
```
输入:a = 2, b = [3]
输出:8
```
示例 2:
```
输入:a = 2, b = [1,0]
输出:1024
```
示例 3:
```
输入:a = 1, b = [4,3,3,8,5,2]
输出:1
```
示例 4:
```
输入:a = 2147483647, b = [2,0,0]
输出:1198
```
提示:
* $1 <= a <= 2^{31} - 1$
* $1 <= b.length <= 2000$
* $0 <= b[i] <= 9$
... | ### 递归 + 快速幂(可选)
根据题意,要我们求得的是 $a^b \bmod {1337}$ 的值,其中 $b$ 是以数组形式给出。
刚一看是一道快速幂的题目(事实上也确实可以使用快速幂,但不是必须),由于 $b$ 是数组形式,因此我们还需要对其进行分解。
假设 $b$ 所代表的数值为 $K$,则有:
$$
a^{K} = a^{(\left \lfloor \frac{K}{10} \right \rfloor * 10) + (K \bmod 10)} = a^{(\left \lfloor \frac{K}{10} \right \rfloor * 10)} * a^{(K \bmod 10)} = ({a^{\l... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.372` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/373. 查找和最小的K对数字（中等）.md | 373. 查找和最小的K对数字 | https://leetcode-cn.com/problems/find-k-pairs-with-smallest-sums/solution/gong-shui-san-xie-duo-lu-gui-bing-yun-yo-pgw5/ | 中等 | [
"优先队列(堆)",
"二分",
"多路归并"
] | 给定两个以升序排列的整数数组 `nums1` 和 `nums2` , 以及一个整数 `k` 。
定义一对值 $(u,v)$,其中第一个元素来自 `nums1`,第二个元素来自 `nums2`。
请找到和最小的 `k` 个数对 $(u_1,v_1), (u_2,v_2) ... (u_k,v_k)$ 。
示例 1:
```
输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
输出: [1,2],[1,4],[1,6]
解释: 返回序列中的前 3 对数:
[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
``... | ### 基本分析
这道题和 [(题解) 786. 第 K 个最小的素数分数](https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-8ymk/) 几乎是一模一样,先做哪一道都是一样的,难度上没有区别 🤣
最常规的做法是使用「多路归并」,还不熟悉「多路归并」的同学,建议先学习前置🧀:[多路归并入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490029&idx=1&sn=bba9d... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.373` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/374. 猜数字大小（简单）.md | 374. 猜数字大小 | https://leetcode-cn.com/problems/guess-number-higher-or-lower/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-tocm/ | 简单 | [
"二分"
] | 猜数字游戏的规则如下:
* 每轮游戏,我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
* 如果你猜错了,我会告诉你,你猜测的数字比我选出的数字是大了还是小了。
你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果,返回值一共有 3 种可能的情况(-1,1 或 0):
* -1:我选出的数字比你猜的数字小 pick < num
* 1:我选出的数字比你猜的数字大 pick > num
* 0:我选出的数字和你猜的数字一样。恭喜!你猜对了!pick == num
返回我选出的数字。
示例 1:
```
输入:n = 10, pick = 6
输出:6
```
示例 2:
`... | ### 二分
端午安康呀 🍭🍭🍭
今天的题目表达不太好 🤣,还是逐字阅读才明白是啥意思 🤣
就当做是因为题目本身要比 [278. 第一个错误的版本](https://leetcode-cn.com/problems/first-bad-version/) 简单(不需要考虑完全相同,没有二段性的情况),所以在阅读上增加了难度吧 🤣
一道交互题,根据题意可知,是尽可能少调用 `guess` 方法来找到分割点。
直接使用 `guess` 当做 `check` 函数进行二分即可。
另外根据数据范围需要注意计算 `mid` 时的爆 `int` 问题,可以通过使用类似 `l + (r - l) / 2` 的做法解决,也可... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.374` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/375. 猜数字大小 II（中等）.md | 375. 猜数字大小 II | https://leetcode-cn.com/problems/guess-number-higher-or-lower-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-92e5/ | 中等 | [
"博弈论",
"区间 DP",
"记忆化搜索"
] | 我们正在玩一个猜数游戏,游戏规则如下:
1. 我从 `1` 到 `n` 之间选择一个数字。
2. 你来猜我选了哪个数字。
3. 如果你猜到正确的数字,就会 赢得游戏 。
4. 如果你猜错了,那么我会告诉你,我选的数字比你的 更大或者更小 ,并且你需要继续猜数。
5. 每当你猜了数字 `x` 并且猜错了的时候,你需要支付金额为 `x` 的现金。如果你花光了钱,就会 输掉游戏 。
给你一个特定的数字 `n` ,返回能够 确保你获胜 的最小现金数,不管我选择那个数字 。
示例 1:
```
输入:n = 10
输出:16
解释:制胜策略如下:
- 数字范围是 [1,10] 。你先猜测数字为 7 。
- 如果这是我选中的数... | ### 基本分析
这不是一道可通过「二分」求解的题目,主要原因为每次惩罚的金额不固定,最小惩罚次数不等同于猜中数字的最小成本。
---
### 记忆化搜索
比较容易想到的做法为使用「递归」进行求解。
设计递归函数为 `int dfs(int l, int r)` 传入参数 `l` 和 `r` 代表在范围 $[l, r]$ 内进行猜数,返回值为在 $[l, r]$ 内猜中数字至少需要多少钱。
**我们可决策的部分为「选择猜哪个数 $x$」,而不可决策的是「选择某个数 $x$ 之后(假设没有猜中),真实值会落在哪边」。**
因此为求得「最坏情况下最好」的结果,我们应当取所有的 $x$ 中的最小值。
最后,为减少重复计算,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.375` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/380. O(1) 时间插入、删除和获取随机元素（中等）.md | 380. O(1) 时间插入、删除和获取随机元素 | https://leetcode-cn.com/problems/insert-delete-getrandom-o1/solution/by-ac_oier-tpex/ | 中等 | [
"数据结构",
"哈希表"
] | 实现 `RandomizedSet` 类:
* `RandomizedSet()` 初始化 `RandomizedSet` 对象
* `bool insert(int val)` 当元素 `val` 不存在时,向集合中插入该项,并返回 `true`;否则,返回 `false`。
* `bool remove(int val)` 当元素 `val` 存在时,从集合中移除该项,并返回 `true`;否则,返回 `false`。
* `int getRandom()` 随机返回现有集合中的一项(测试用例保证调用此方法时集合中至少存在一个元素)。每个元素应该有 相同的概率 被返回。
你必须实现类的所有函数,并满足每个函数的 平均 时间复... | ### 哈希表 + 删除交换
对于 `insert` 和 `remove` 操作容易想到使用「哈希表」来实现 $O(1)$ 复杂度,但对于 `getRandom` 操作,比较理想的情况是能够在一个数组内随机下标进行返回。
将两者结合,我们可以将哈希表设计为:以入参 `val` 为键,数组下标 `loc` 为值。
**为了确保严格 $O(1)$,我们不能「使用拒绝采样」和「在数组非结尾位置添加/删除元素」。**
因此我们需要申请一个足够大的数组 `nums`(利用数据范围为 $2* 10^5$),并使用变量 `idx` 记录当前使用到哪一位(即下标在 $[0, idx]$ 范围内均是存活值)。
对于几类操作逻辑:
* `i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.380` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/382. 链表随机节点（中等）.md | 382. 链表随机节点 | https://leetcode-cn.com/problems/linked-list-random-node/solution/gong-shui-san-xie-xu-shui-chi-chou-yang-1lp9d/ | 中等 | [
"链表",
"模拟",
"蓄水池抽样"
] | 给你一个单链表,随机选择链表的一个节点,并返回相应的节点值。每个节点 **被选中的概率一样** 。
实现 `Solution` 类:
* `Solution(ListNode head)` 使用整数数组初始化对象。
* `int getRandom()` 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。
示例:
```
输入
["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"]
[[[1, 2, 3]], [], [], [], [], []]
输出
[null, 1, 3, 2, 2, 3]
解... | ### 模拟
由于链表长度只有 $10^4$,因此可以在初始化时遍历整条链表,将所有的链表值预处理到一个数组内。
在查询时随机一个下标,并将数组中对应下标内容返回出去。
**代码(感谢 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**
```Java
class Solution {
List<Integer> list = new ArrayList<>();
Random random = new Random(20220116);
public Solution(ListNode head) {
while (head != null) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.382` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/383. 赎金信（简单）.md | 383. 赎金信 | https://leetcode-cn.com/problems/ransom-note/solution/gong-shui-san-xie-jian-dan-ji-shu-mo-ni-udpzn/ | 简单 | [
"模拟"
] | 为了不在赎金信中暴露字迹,从杂志上搜索各个需要的字母,组成单词来表达意思。
给你一个赎金信 (`ransomNote`) 字符串和一个杂志(`magazine`)字符串,判断` ransomNote` 能不能由 `magazines` 里面的字符构成。
如果可以构成,返回 `true` ;否则返回 `false` 。
`magazine` 中的每个字符只能在 `ransomNote` 中使用一次。
示例 1:
```
输入:ransomNote = "a", magazine = "b"
输出:false
```
示例 2:
```
输入:ransomNote = "aa", magazine = "ab"
输出:fal... | ### 计数模拟
根据题意并利用两字符串只包含小写字母,先使用大小为字符集大小的数组(充当哈希表)对 $magazine$ 进行词频统计,然后在遍历 $ransomNote$ 时对计数数组进行抵消操作。
若处理过程中出现词频数量为负数,则说明 $magazine$ 不能凑出 $ransomNote$。
代码:
```Java
class Solution {
public boolean canConstruct(String a, String b) {
int[] cnt = new int[26];
for (char c : b.toCharArray()) cnt[c - 'a... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.383` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/384. 打乱数组（中等）.md | 384. 打乱数组 | https://leetcode-cn.com/problems/shuffle-an-array/solution/gong-shui-san-xie-xi-pai-suan-fa-yun-yon-0qmy/ | 中等 | [
"洗牌算法"
] | 给你一个整数数组 `nums`,设计算法来打乱一个没有重复元素的数组。
实现 `Solution class`:
* `Solution(int[] nums)` 使用整数数组 `nums` 初始化对象
* `int[] reset()` 重设数组到它的初始状态并返回
* `int[] shuffle()` 返回数组随机打乱后的结果
示例:
```
输入
["Solution", "shuffle", "reset", "shuffle"]
[[[1, 2, 3]], [], [], []]
输出
[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
解释
Solution solution = ne... | ### 洗牌算法
共有 $n$ 个不同的数,根据每个位置能够选择什么数,共有 $n!$ 种组合。
题目要求每次调用 `shuffle` 时等概率返回某个方案,或者说每个元素都够等概率出现在每个位置中。
我们可以使用 $Knuth$ 洗牌算法,在 $O(n)$ 复杂度内等概率返回某个方案。
具体的,我们从前往后尝试填充 $[0, n - 1]$ 该填入什么数时,通过随机当前下标与(剩余的)哪个下标进行值交换来实现。
对于下标 $x$ 而言,我们从 $[x, n - 1]$ 中随机出一个位置与 $x$ 进行值交换,当所有位置都进行这样的处理后,我们便得到了一个公平的洗牌方案。
> 对于下标为 $0$ 位置,从 $[0, n ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.384` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/385. 迷你语法分析器（中等）.md | 385. 迷你语法分析器 | https://leetcode-cn.com/problems/mini-parser/solution/by-ac_oier-zuy6/ | 中等 | [
"栈",
"模拟"
] | 给定一个字符串 `s` 表示一个整数嵌套列表,实现一个解析它的语法分析器并返回解析的结果 `NestedInteger` 。
列表中的每个元素只可能是整数或整数嵌套列表
示例 1:
```
输入:s = "324",
输出:324
解释:你应该返回一个 NestedInteger 对象,其中只包含整数值 324。
```
示例 2:
```
输入:s = "[123,[456,[789]]]",
输出:[123,[456,[789]]]
解释:返回一个 NestedInteger 对象包含一个有两个元素的嵌套列表:
1. 一个 integer 包含值 123
2. 一个包含两个元素的嵌套列表:
i. 一个 in... | ### 栈
每个 `[` 的出现意味着存在一个嵌套类型的 `NestedInteger` 实例,同时每个 `NestedInteger` 实例(无论是嵌套类型还是数值类型)都归属于其最近一个左边的嵌套类型的 `NestedInteger` 实例(即其左边最近一个 `[`),因此我们可以使用栈来处理。
对出现的几类字符进行简单分情况讨论:
* `,`:跳过即可;
* `-` 或 `数字`:将连续段代表数值的字符串取出,创建数值型的 `NestedInteger` 实例并压入栈中;
* `[`:创建一个嵌套类型的 `NestedInteger` 实例并压入栈中,同时为了方便,同时压入一个起「标识」作用的 `NestedIntege... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.385` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/386. 字典序排数（中等）.md | 386. 字典序排数 | https://leetcode-cn.com/problems/lexicographical-numbers/solution/by-ac_oier-ktn7/ | 中等 | [
"DFS",
"递归",
"迭代"
] | 给你一个整数 `n` ,按字典序返回范围 $[1, n]$ 内所有整数。
你必须设计一个时间复杂度为 $O(n)$ 且使用 $O(1)$ 额外空间的算法。
示例 1:
```
输入:n = 13
输出:[1,10,11,12,13,2,3,4,5,6,7,8,9]
```
示例 2:
```
输入:n = 2
输出:[1,2]
```
提示:
* $1 <= n <= 5 * 10^4$ | ### 递归
首先容易想到使用「递归」来实现 `DFS`。
将 $[1, n]$ 的数按照字典序添加到答案,本质上是对一颗节点数量为 $n$,形态类似字典树的多阶树进行遍历,根节点为 $0$,需要被跳过,因此我们可以从树的第二层开始搜索。
树中每个节点的值为其搜索路径所代表的数字,且每个节点有 $[0, 9]$ 共 $10$ 个子节点。
代码:
```Java
class Solution {
List<Integer> ans = new ArrayList<>();
public List<Integer> lexicalOrder(int n) {
for (int i = 1; i <... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.386` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/388. 文件的最长绝对路径（中等）.md | 388. 文件的最长绝对路径 | https://leetcode-cn.com/problems/longest-absolute-file-path/solution/by-ac_oier-c55t/ | 中等 | [
"模拟",
"哈希表"
] | 假设有一个同时存储文件和目录的文件系统。下图展示了文件系统的一个示例:
这里将 `dir` 作为根目录中的唯一目录。`dir` 包含两个子目录 `subdir1` 和 `subdir2` 。
`subdir1` 包含文件 `file1.ext` 和子目录 `subsubdir1`;`subdir2` 包含子目录 `subsubdir2`,该子目录下包含文件 `file2.ext`。
在文本格式中,如下所示(⟶表示制表符):
```
dir
⟶ subdir1
⟶ ⟶ file1.ext
⟶ ⟶ subsubdir1
⟶ subdir2
⟶ ⟶ subsubdir2
⟶ ⟶ ⟶ file2.ext
```
如果是代码表示,上面... | ### 模拟 + 哈希表
为了方便,我们将 `input` 替换为 `s`。
对于每一个文件或文件夹而言,我们可以通过访问到结尾(`\n`)的方式取得,记为 `cur`,然后根据 `cur` 前面有多少个 `\t` 得知其所在的层级,假设当前其所在层级为 `level`,那么它自然归属到最新一个层级为 `level - 1` 的文件夹中,因此我们可以使用哈希表记录每个层级最新的文件夹路径,通过字符串拼接的方式得到 `cur` 所在的完整路径 `path`,并在处理整个 `s` 过程中,统计长度最大的文件路径。
代码:
```Java
class Solution {
public int lengthLongestPa... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.388` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/390. 消除游戏（中等）.md | 390. 消除游戏 | https://leetcode-cn.com/problems/elimination-game/solution/gong-shui-san-xie-yue-se-fu-huan-yun-yon-x60m/ | 中等 | [
"动态规划",
"数学",
"约瑟夫环"
] | 列表 `arr` 由在范围 `[1, n]` 中的所有整数组成,并按严格递增排序。
请你对 `arr` 应用下述算法:
* 从左到右,删除第一个数字,然后每隔一个数字删除一个,直到到达列表末尾。
* 重复上面的步骤,但这次是从右到左。也就是,删除最右侧的数字,然后剩下的数字每隔一个删除一个。
* 不断重复这两步,从左到右和从右到左交替进行,直到只剩下一个数字。
给你整数 `n`,返回 `arr` 最后剩下的数字。
示例 1:
```
输入:n = 9
输出:6
解释:
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
arr = [2, 4, 6, 8]
arr = [2, 6]
arr = [6]
`... | ### 约瑟夫环
与求解约瑟夫环类似,本题也可以通常找规律,分析出公式之后进行递推求解。
对于本题,定义 $f[i]$ 为在 **连续序列** $[1, i]$ 中进行「起始先从左到右,再从右往左」的轮流换向间隔删除,最终左边剩余的编号;定义 $f'[i]$ 为在 **连续序列** $[1, i]$ 中进行「起始先从右到左,再从左往右」的轮流换向间隔删除,最终右边剩余的编号。
**由于「从左往右」和「从右往左」分别为「从左端点发起,间隔删除」和「从右端点发起,间隔删除」,因此整个删除过程在连续序列中 $[1, i]$ 中具有对称性,两者最终剩余的编号在连续序列中也具有对称性。**
即可得出第一个公式:
$$
f[i] + ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.390` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/391. 完美矩形（困难）.md | 391. 完美矩形 | https://leetcode-cn.com/problems/perfect-rectangle/solution/gong-shui-san-xie-chang-gui-sao-miao-xia-p4q4/ | 困难 | [
"扫描线"
] | 给你一个数组 `rectangles`,其中 $rectangles[i] = [x_i, y_i, a_i, b_i]$ 表示一个坐标轴平行的矩形。这个矩形的左下顶点是 $(x_i, y_i)$ ,右上顶点是 $(a_i, b_i)$ 。
如果所有矩形一起精确覆盖了某个矩形区域,则返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]
输出:true
解释:5 个矩形一起可以精确地覆盖一个矩形区域。
```
示例 2:
```
输入:rectangles = [[1... | ### 扫描线
将每个矩形 $rectangles[i]$ 看做两条竖直方向的边,使用 $(x, y1, y2)$ 的形式进行存储(其中 $y1$ 代表该竖边的下端点,$y2$ 代表竖边的上端点),同时为了区分是矩形的左边还是右边,再引入一个标识位,即以四元组 $(x, y1, y2, flag)$ 的形式进行存储。
一个完美矩形的充要条件为:**对于完美矩形的每一条非边缘的竖边,都「成对」出现(存在两条完全相同的左边和右边重叠在一起);对于完美矩形的两条边缘竖边,均独立为一条连续的(不重叠)的竖边。**
如图(红色框的为「完美矩形的边缘竖边」,绿框的为「完美矩形的非边缘竖边」):
* 绿色:非边缘竖边必然有成对的左右两条完... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.391` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/393. UTF-8 编码验证（中等）.md | 393. UTF-8 编码验证 | https://leetcode-cn.com/problems/utf-8-validation/solution/by-ac_oier-zvoy/ | 中等 | [
"模拟"
] | 给定一个表示数据的整数数组 `data` ,返回它是否为有效的 $UTF-8$ 编码。
`UTF-8` 中的一个字符可能的长度为 $1$ 到 $4$ 字节,遵循以下的规则:
1. 对于 $1$ 字节 的字符,字节的第一位设为 $0$ ,后面 $7$ 位为这个符号的 `unicode` 码。
2. 对于 $n$ 字节 的字符 ($n > 1$),第一个字节的前 $n$ 位都设为 $1$,第 $n+1$ 位设为 $0$ ,后面字节的前两位一律设为 $10$ 。剩下的没有提及的二进制位,全部为这个符号的 `unicode` 码。
这是 UTF-8 编码的工作方式:
```
Char. number range | ... | ### 模拟
根据题意进行模拟即可。
从前往后处理每个 $data[i]$,先统计 $data[i]$ 从第 $7$ 位开始往后有多少位连续的 $1$,代表这是一个几字节的字符,记为 $cnt$ :
* 如果 $cnt$ 为 $1$ 或者大于 $4$ 均违反编码规则(与字符长度为 $1$ 时的编码规则 和 字符长度只能是 $1$ 到 $4$ 冲突),返回 `False`;
* 如果位置 $i$ 后面不足 $cnt - 1$ 也返回 `False`;
* 否则检查下标范围为 $[i + 1, i + cnt - 1]$ 的数是否满足前两位为 $10$ 的要求,若不满足返回 `False`。
如果上述过程满足要求,跳到下一个检查... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.393` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/395. 至少有 K 个重复字符的最长子串（中等）.md | 395. 至少有 K 个重复字符的最长子串 | https://leetcode-cn.com/problems/longest-substring-with-at-least-k-repeating-characters/solution/xiang-jie-mei-ju-shuang-zhi-zhen-jie-fa-50ri1/ | 中等 | [
"双指针",
"枚举"
] | 给你一个字符串 s 和一个整数 k ,请你找出 s 中的最长子串, 要求该子串中的每一字符出现次数都不少于 k 。返回这一子串的长度。
示例 1:
```
输入:s = "aaabb", k = 3
输出:3
解释:最长子串为 "aaa" ,其中 'a' 重复了 3 次。
```
示例 2:
```
输入:s = "ababbc", k = 2
输出:5
解释:最长子串为 "ababb" ,其中 'a' 重复了 2 次, 'b' 重复了 3 次。
```
提示:
* 1 <= s.length <= $10^4$
* s 仅由小写英文字母组成
* 1 <= k <= $10^5$ | ### 枚举 + 双指针
其实看到这道题,我第一反应是「二分」,直接「二分」答案。
但是往下分析就能发现「二分」不可行,因为不具有二段性质。
也就是假设有长度 `t` 的一段区间满足要求的话,`t + 1` 长度的区间是否「一定满足」或者「一定不满足」呢?
显然并不一定,是否满足取决于 `t + 1` 个位置出现的字符在不在原有区间内。
举个🌰吧,假设我们已经画出来一段长度为 `t` 的区间满足要求(且此时 k > 1),那么当我们将长度扩成 `t + 1` 的时候(无论是往左扩还是往右扩):
* 如果新位置的字符在原有区间**出现过**,那必然还是满足出现次数大于 k,这时候 **`t + 1` 的长度满足要求**
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.395` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/396. 旋转函数（中等）.md | 396. 旋转函数 | https://leetcode-cn.com/problems/rotate-function/solution/by-ac_oier-sxbi/ | 中等 | [
"前缀和",
"滑动窗口"
] | 给定一个长度为 $n$ 的整数数组 $nums$ 。
假设 $arr_k$ 是数组 $nums$ 顺时针旋转 $k$ 个位置后的数组,我们定义 $nums$ 的 旋转函数 `F` 为:
* `F(k) = 0 * arrk[0] + 1 * arrk[1] + ... + (n - 1) * arrk[n - 1]`
返回 `F(0), F(1), ..., F(n-1)` 中的最大值 。
生成的测试用例让答案符合 $32$ 位 整数。
示例 1:
```
输入: nums = [4,3,2,6]
输出: 26
解释:
F(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 ... | ### 前缀和 + 滑动窗口
为了方便,我们将 $nums$ 的长度记为 $n$。
题目要对「旋转数组」做逻辑,容易想到将 $nums$ 进行复制拼接,得到长度为 $2 \times n$ 的新数组,在新数组上任意一个长度为 $n$ 的滑动窗口都对应了一个旋转数组。
然后考虑在窗口的滑动过程中,计算结果会如何变化,假设当前我们处理到下标为 $[i, i + n - 1]$ 的滑动窗口,根据题意,当前结果为:
$$
cur = nums[i] \times 0 + nums[i + 1] \times 1 + ... + nums[i + n - 1] \times (n - 1)
$$
当窗口往后移动一位,也就是窗口的右... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.396` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/397. 整数替换（中等）.md | 397. 整数替换 | https://leetcode-cn.com/problems/integer-replacement/solution/gong-shui-san-xie-yi-ti-san-jie-dfsbfs-t-373h/ | 中等 | [
"DFS",
"BFS",
"贪心"
] | 给定一个正整数 `n` ,你可以做如下操作:
1. 如果 `n` 是偶数,则用 `n / 2` 替换 `n` 。
2. 如果 `n` 是奇数,则可以用 `n + 1` 或 `n - 1` 替换 `n` 。
`n` 变为 $1$ 所需的最小替换次数是多少?
示例 1:
```
输入:n = 8
输出:3
解释:8 -> 4 -> 2 -> 1
```
示例 2:
```
输入:n = 7
输出:4
解释:7 -> 8 -> 4 -> 2 -> 1
或 7 -> 6 -> 3 -> 2 -> 1
```
示例 3:
```
输入:n = 4
输出:2
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### DFS
运用 `DFS` 进行求解。为防止重复处理某些数值,可以使用「哈希表」进行记忆化。
代码:
```Java
class Solution {
Map<Long, Integer> map = new HashMap<>();
public int integerReplacement(int n) {
return dfs(n * 1L);
}
int dfs(long n) {
if (n == 1) return 0;
if (map.containsKey(n)) return map.get(n);
int a... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.397` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/398. 随机数索引（中等）.md | 398. 随机数索引 | https://leetcode-cn.com/problems/random-pick-index/solution/by-ac_oier-zhml/ | 中等 | [
"哈希表",
"模拟",
"随机化",
"蓄水池抽样"
] | 给定一个可能含有重复元素的整数数组,要求随机输出给定的数字的索引。 您可以假设给定的数字一定存在于数组中。
注意:
数组大小可能非常大。 使用太多额外空间的解决方案将不会通过测试。
示例:
```
int[] nums = new int[] {1,2,3,3,3};
Solution solution = new Solution(nums);
// pick(3) 应该返回索引 2,3 或者 4。每个索引的返回概率应该相等。
solution.pick(3);
// pick(1) 应该返回 0。因为只有nums[0]等于1。
solution.pick(1);
```
提示:
* $1 <= nums.length... | ### 哈希表 预处理(定长数据流)
切换英文补全一下数据范围:
* $1 <= nums.length <= 2 * 10^4$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* `target` 确保存在于 `nums` 中
* 最多调用 $10^4$ 次的 `pick`
为了方便,我们令 `nums` 的长度为 $n$,利用 $n$ 的数据范围为 $2 * 10^4$,且完整的数组为初始化时已给出,我们可以通过使用「哈希表 + 预处理」的方式进行求解。
具体的,在构造函数传入 `nums` 时,遍历 `nums` 并存储每个 $nums[i]$ 对应的下标集合,即使用哈希表以 $nums[i]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.398` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/400. 第 N 位数字（中等）.md | 400. 第 N 位数字 | https://leetcode-cn.com/problems/nth-digit/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-w5wl/ | 中等 | [
"数学",
"模拟"
] | 给你一个整数 $n$ ,请你在无限的整数序列 `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]` 中找出并返回第 $n$ 位数字。
示例 1:
```
输入:n = 3
输出:3
```
示例 2:
```
输入:n = 11
输出:0
解释:第 11 位数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是 0 ,它是 10 的一部分。
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 模拟
我们知道,对于长度为 $len$ 的数字的范围为 $[10^{len - 1}, 10^{len} - 1]$(共 $9 * 10^{len - 1}$ 个),总长度为:
$$
L = len * 9 * 10^{len - 1}
$$
因此我们可以先对 $n$ 进行不断试减(更新 $n$),确定下来目标数字 $x$ 的长度为多少,假设为 $len$。
然后直接计算出长度 $len$ 的最小值为 $s = 10^{len - 1}$,由于范围内的数长度都是 $len$,因此我们可以直接定位到目标数字 $x$ 为何值。
根据目标值 $x$ 必然满足关系式:
$$
(x - s + 1) * len \geq ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.400` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/401. 二进制手表（简单）.md | 401. 二进制手表 | https://leetcode-cn.com/problems/binary-watch/solution/gong-shui-san-xie-jian-dan-ti-xue-da-bia-gwn2/ | 简单 | [
"打表",
"二进制"
] | 二进制手表顶部有 4 个 LED 代表 小时(0-11),底部的 6 个 LED 代表 分钟(0-59)。每个 LED 代表一个 0 或 1,最低位在右侧。
例如,下面的二进制手表读取 "3:25" 。
(图源:WikiMedia - Binary clock samui moon.jpg ,许可协议:Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) )
给你一个整数 turnedOn ,表示当前亮着的 LED 的数量,返回二进制手表可以表示的所有可能时间。你可以 按任意顺序 返回答案。
小时不会以零开头:
例如,"01:00" 是无效的时间,正确的写法应该是 "1:00... | ### 打表
具体的,我们可以创建一个 `静态数据结构` 来存储打表信息(需确保全局唯一,即使存在多组测试数据只生成一次打表数据)。
然后在返回数据的时候直接 $O(1)$ 查表返回。
PS. 如果打表逻辑计算量接近 $10^7$ 上限,可以考虑放到本地去做,这里数据量较少,直接放到 `static` 代码块去做即可。
代码:
```Java
class Solution {
// 打表逻辑,也可以放到本地做
// 注意使用 static 修饰,确保打表数据只会被生成一次
static Map<Integer, List<String>> map = new HashMap<>();
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.401` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/403. 青蛙过河（困难）.md | 403. 青蛙过河 | https://leetcode-cn.com/problems/frog-jump/solution/gong-shui-san-xie-yi-ti-duo-jie-jiang-di-74fw/ | 困难 | [
"DFS",
"BFS",
"记忆化搜索",
"线性 DP"
] | 一只青蛙想要过河。 假定河流被等分为若干个单元格,并且在每一个单元格内都有可能放有一块石子(也有可能没有)。 青蛙可以跳上石子,但是不可以跳入水中。
给你石子的位置列表 stones(用单元格序号 升序 表示), 请判定青蛙能否成功过河(即能否在最后一步跳至最后一块石子上)。
开始时, 青蛙默认已站在第一块石子上,并可以假定它第一步只能跳跃一个单位(即只能从单元格 1 跳至单元格 2 )。
如果青蛙上一步跳跃了 k 个单位,那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1 个单位。 另请注意,青蛙只能向前方(终点的方向)跳跃。
示例 1:
```
输入:stones = [0,1,3,5,6,8,12,17]... | ### DFS(TLE)
根据题意,我们可以使用 `DFS` 来模拟/爆搜一遍,检查所有的可能性中是否有能到达最后一块石子的。
通常设计 `DFS` 函数时,我们只需要不失一般性的考虑完成第 $i$ 块石子的跳跃需要些什么信息即可:
* 需要知道当前所在位置在哪,也就是需要知道当前石子所在列表中的下标 $u$。
* 需要知道当前所在位置是经过多少步而来的,也就是需要知道上一步的跳跃步长 $k$。
代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
public boolean canCross(int[] ss) ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.403` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/405. 数字转换为十六进制数（简单）.md | 405. 数字转换为十六进制数 | https://leetcode-cn.com/problems/convert-a-number-to-hexadecimal/solution/gong-shui-san-xie-yi-ti-shuang-jie-jin-z-d93o/ | 简单 | [
"位运算",
"模拟"
] | 给定一个整数,编写一个算法将这个数转换为十六进制数。对于负整数,我们通常使用 补码运算 方法。
注意:
1. 十六进制中所有字母(a-f)都必须是小写。
2. 十六进制字符串中不能包含多余的前导零。如果要转化的数为0,那么以单个字符'0'来表示;对于其他情况,十六进制字符串中的第一个字符将不会是0字符。
3. 给定的数确保在32位有符号整数范围内。
4. 不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。
示例 1:
```
输入:26
输出:"1a"
```
示例 2:
```
输入:-1
输出:"ffffffff"
``` | ### 模拟 + 进制转换
首先,我们可以利用通用的进制转换思路来做,不断循环 `num % k` 和 `num / k` 的操作来构造出 $k$ 进制每一位。
但需要处理「补码」问题:对于负数的 $num$,我们需要先在 $num$ 基础上加上 $2^{32}$ 的偏移量,再进行进制转换。
代码:
```Java
class Solution {
public String toHex(int _num) {
if (_num == 0) return "0";
long num = _num;
StringBuilder sb = new StringBuilder(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.405` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/406. 根据身高重建队列（中等）.md | 406. 根据身高重建队列 | https://leetcode.cn/problems/queue-reconstruction-by-height/solution/by-ac_oier-fda2/ | 中等 | [
"排序",
"构造",
"二分",
"树状数组"
] | 假设有打乱顺序的一群人站成一个队列,数组 `people` 表示队列中一些人的属性(不一定按顺序)。每个 $people[i] = [h_i, k_i]$ 表示第 $i$ 个人的身高为 $h_i$ ,前面 正好 有 $k_i$ 个身高大于或等于 $h_i$ 的人。
请你重新构造并返回输入数组 `people` 所表示的队列。返回的队列应该格式化为数组 `queue` ,其中 $queue[j] = [h_j, k_j]$ 是队列中第 $j$ 个人的属性($queue[0]$ 是排在队列前面的人)。
示例 1:
```
输入:people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出:[[... | ### 构造 + 二分 + 树状数组
这是一道非常综合的题目。
首先根据双关键字排序:当「高度(第一维)」不同,根据高度排升序,对于高度相同的情况,则根据「编号(第二维)」排降序。
采取这样的排序规则的好处在于:**在从前往后处理某个 $people[i]$ 时,我们可以直接将其放置在「当前空位序列(从左往后统计的,不算已被放置的位置)」中的 $people[i][1] + 1$ 位(预留了前面的 $people[i][1]$ 个位置给后面的数)。**
关于「空位序列」如图所示(黄色代表已被占用,白色代表尚未占用):
具体的,我们按照构造的合理性来解释双关键字排序的合理性,假设当前处理的是 $people[i]$:
根据... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.406` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/407. 接雨水 II（困难）.md | 407. 接雨水 II | https://leetcode-cn.com/problems/trapping-rain-water-ii/solution/gong-shui-san-xie-jing-dian-dijkstra-yun-13ik/ | 困难 | [
"最短路",
"优先队列(堆)"
] | 给你一个 $m x n$ 的矩阵,其中的值均为非负整数,代表二维高度图每个单元的高度,请计算图中形状最多能接多少体积的雨水。
示例 1:
```
输入: heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]
输出: 4
解释: 下雨后,雨水将会被上图蓝色的方块中。总的接雨水量为1+2+1=4。
```
示例 2:
```
输入: heightMap = [[3,3,3,3,3],[3,2,2,2,3],[3,2,1,2,3],[3,2,2,2,3],[3,3,3,3,3]]
输出: 10
```
提示:
* m == heightMap.length
* n =... | ### Dijkstra 变形 + 优先队列(堆)
首先,最外层的一圈(边界)是不会接到任何雨水的(会从边界流出)。
我们定义从点 $(x, y)$ 到边界的路径中出现的最大高度为「路径高度」,路径高度 $h$ 必然满足 $h >= heightMap[x][y]$。
**问题的本质是求「从点 $(x, y)$ 到边界的所有路径高度的最小值为多少」,这个路径高度的最小值与 $(x, y)$ 本身的高度 $heightMap[x][y]$ 之间的差值,即是该点能接到的雨水数量。**
> PS. 对此觉得不好理解的同学,可以尝试从现实角度出发进行考虑:假如该位置是出水口(能够源源不断的出水并往各个方向蔓延),那么该位置最终承载多... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.407` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/41. 缺失的第一个正数（困难）.md | 41. 缺失的第一个正数 | https://leetcode-cn.com/problems/first-missing-positive/solution/yan-ge-on-de-tong-pai-xu-si-lu-yi-ji-wei-wm8d/ | 困难 | [
"桶排序",
"原地哈希"
] | 给你一个未排序的整数数组 `nums` ,请你找出其中没有出现的最小的正整数。
**进阶**:你可以实现时间复杂度为 $O(n)$ 并且只使用常数级别额外空间的解决方案吗?
示例 1:
```
输入:nums = [1,2,0]
输出:3
```
示例 2:
```
输入:nums = [3,4,-1,1]
输出:2
```
示例 3:
```
输入:nums = [7,8,9,11,12]
输出:1
```
提示:
* $0 <= nums.length <= 300$
* $-2^{31} <= nums[i] <= 2^{31} - 1$ | ### 桶排序(原地哈希)
令数组长度为 `n`,那么答案必然在 `[1, n + 1]` 范围内。
**因此我们可以使用「桶排序」的思路,将每个数放在其应该出现的位置上。**
基本思路为:
1. 按照桶排序思路进行预处理:保证 1 出现在 `nums[0]` 的位置上,2 出现在 `nums[1]` 的位置上,...,`n` 出现在 `nums[n - 1]` 的位置上。不在 `[1, n]` 范围内的数不用动。
例如样例中 `[3,4,-1,1]` 将会被预处理成 `[1,-1,3,4]`。
2. 遍历 `nums`,找到第一个不在应在位置上的 `[1, n]` 的数。如果没有找到,说明数据连续,答案为 `n + 1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.41` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/42. 接雨水（困难）.md | 42. 接雨水 | https://leetcode-cn.com/problems/trapping-rain-water/solution/po-su-jie-fa-on2-cha-zhao-you-hua-on-dan-iu44/ | 困难 | [
"模拟",
"单调栈",
"数学"
] | 给定 `n` 个非负整数表示每个宽度为 `1` 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。
示例 1:
```
输入:height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出:6
解释:上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图,在这种情况下,可以接 6 个单位的雨水(蓝色部分表示雨水)。
```
示例 2:
```
输入:height = [4,2,0,3,2,5]
输出:9
```
提示:
* $n = height.length$
* $0 <= n <= 2 \times 10^4$
* $0 <= height[i] <= 10^5$ | ### 模拟
对每根柱子而言,我们先找出其「左边最高的柱子」和「右边最高的柱子」。
对左右最高柱子取较小值,再和当前柱子高度做比较,即可得出当前位置可以接下的雨水。
同时,边缘的柱子不可能接到雨水(某一侧没有柱子)。
最后注意:该解法计算量会去到 $n^2 = 4 \times 10^8$,一旦计算量上界接近 $10^7$,我们就需要考虑 `TLE`(超时)问题,在 LeetCode 上该解法 `C++` 无法通过,其他语言目前还能通过。
Java 代码:
```Java
class Solution {
public int trap(int[] height) {
int n = height.... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.42` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/43. 字符串相乘（中等）.md | 43. 字符串相乘 | https://leetcode-cn.com/problems/multiply-strings/solution/zhi-yao-ni-hui-shou-suan-cheng-fa-zhe-ti-ainl/ | 中等 | [
"数学",
"模拟"
] | 给定两个以字符串形式表示的非负整数 `num1` 和 `num2`,返回 `num1` 和 `num2` 的乘积,它们的乘积也表示为字符串形式。
示例 1:
```
输入: num1 = "2", num2 = "3"
输出: "6"
```
示例 2:
```
输入: num1 = "123", num2 = "456"
输出: "56088"
```
说明:
* `num1` 和 `num2` 的长度小于 $110$。
* `num1` 和 `num2` 只包含数字 `0-9`。
* `num1` 和 `num2` 均不以零开头,除非是数字 `0` 本身。
* **不能使用任何标准库的大数类型(比如 BigInteger)... | ### 模拟
本质上是道模拟题,模拟手算乘法的过程。
想要做出这道题,需要知道一个数学定理:
**两个长度分别为 `n` 和 `m` 的数相乘,长度不会超过 `n + m`。**
因此我们可以创建一个长度为 `n + m` 的数组 `res` 存储结果。
另外,最后拼接结果时需要注意忽略前导零。
Java 代码:
```Java
class Solution {
public String multiply(String n1, String n2) {
int n = n1.length(), m = n2.length();
int[] res = new int[n + m]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.43` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/44. 通配符匹配（困难）.md | 44. 通配符匹配 | https://leetcode-cn.com/problems/wildcard-matching/solution/gong-shui-san-xie-xiang-jie-dong-tai-gui-ifyx/ | 困难 | [
"动态规划",
"序列 DP"
] | 给定一个字符串 (`s`) 和一个字符模式 (`p`) ,实现一个支持 `'?'` 和 `'*'` 的通配符匹配。
* `'?'` 可以匹配任何单个字符。
* `'*'` 可以匹配任意字符串(包括空字符串)。
两个字符串完全匹配才算匹配成功。
说明:
* `s` 可能为空,且只包含从 `a-z` 的小写字母。
* `p` 可能为空,且只包含从 `a-z` 的小写字母,以及字符 `?` 和 `*`。
示例 1:
```
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
```
示例 2:
```
输入:
s = "aa"
p = "*"
输出: true
... | ### 动态规划
这道题与 [10. 正则表达式匹配](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247484130&idx=1&sn=af3517194634dde1652ec72eb5ea9ff2&chksm=fd9ca9fdcaeb20eb1fd7509e3adf8fee6f75d77b8afbd30067ac11a56bd77b5066b0f164eb49&token=840813710&lang=zh_CN#rd) 的分析思路是类似的。
但和第 10 题相比,本题要简单一些。
整理一下题意,对于字符串 `p` 而言,有三种字符:
* 普通字符:需要... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.44` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/45. 跳跃游戏 II（中等）.md | 45. 跳跃游戏 II | https://leetcode-cn.com/problems/jump-game-ii/solution/xiang-jie-dp-tan-xin-shuang-zhi-zhen-jie-roh4/ | 中等 | [
"贪心",
"线性 DP",
"双指针"
] | 给定一个非负整数数组,你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
假设你总是可以到达数组的最后一个位置。
示例 1:
```
输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。
```
示例 2:
```
输入: [2,3,0,1,4]
输出: 2
```
提示:
* 1 <= nums.length <= 1000
* 0 <= nums[i] <= $10^5$ | ### BFS
对于这一类问题,我们一般都是使用 BFS 进行求解。
本题的 BFS 解法的复杂度是 $O(n^2)$,数据范围为 $10^3$,可以过。
代码:
```Java
class Solution {
public int jump(int[] nums) {
int n = nums.length;
int ans = 0;
boolean[] st = new boolean[n];
Deque<Integer> d = new ArrayDeque<>();
st[0] = true;
d.addLast(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.45` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/412. Fizz Buzz（简单）.md | 412. Fizz Buzz | https://leetcode-cn.com/problems/fizz-buzz/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-jll0/ | 简单 | [
"模拟"
] | 写一个程序,输出从 `1` 到 `n` 数字的字符串表示。
1. 如果 `n` 是 `3` 的倍数,输出 `“Fizz”`;
2. 如果 `n` 是 `5` 的倍数,输出 `“Buzz”`;
3. 如果 `n` 同时是 `3` 和 `5` 的倍数,输出 `“FizzBuzz”`。
示例:
```
n = 15,
返回:
[
"1",
"2",
"Fizz",
"4",
"Buzz",
"Fizz",
"7",
"8",
"Fizz",
"Buzz",
"11",
"Fizz",
"13",
"14",
"... | ### 模拟
根据题意进行模拟。
代码:
```Java
class Solution {
public List<String> fizzBuzz(int n) {
List<String> ans = new ArrayList<>();
for (int i = 1; i <= n; i++) {
String cur = "";
if (i % 3 == 0) cur += "Fizz";
if (i % 5 == 0) cur += "Buzz";
if (cur.length() =... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.412` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/413. 等差数列划分（中等）.md | 413. 等差数列划分 | https://leetcode-cn.com/problems/arithmetic-slices/solution/gong-shui-san-xie-shuang-zhi-zhen-qiu-ji-ef1q/ | 中等 | [
"双指针",
"模拟",
"数学"
] | 如果一个数列 至少有三个元素 ,并且任意两个相邻元素之差相同,则称该数列为等差数列。
例如,[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
给你一个整数数组 nums ,返回数组 nums 中所有为等差数组的 子数组 个数。
子数组 是数组中的一个连续序列。
示例 1:
```
输入:nums = [1,2,3,4]
输出:3
解释:nums 中有三个子等差数组:[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。
```
示例 2:
```
输入:nums = [1]
输出:0
```
提示:
* $1 <= nums.length <= 5000$
* ... | ### 双指针
具体的,我们可以枚举 $i$ 作为差值为 $d$ 的子数组的左端点,然后通过「双指针」的方式找到当前等差并最长的子数组的右端点 $j$,令区间 $[i, j]$ 长度为 $len$。
那么显然,符合条件的子数组的数量为:
$$
cnt = \sum_{k = 3}^{len}countWithArrayLength(k)
$$
函数 `int countWithArrayLength(int k)` 求的是长度为 $k$ 的子数组的数量。
不难发现,随着入参 $k$ 的逐步减小,函数返回值逐步增大。
因此上述结果 $cnt$ 其实是一个 **首项为 $1$,末项为 $len - 3 + 1$,公差为 $1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.413` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/414. 第三大的数（简单）.md | 414. 第三大的数 | https://leetcode-cn.com/problems/third-maximum-number/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-pmln/ | 简单 | [
"排序",
"数组",
"模拟"
] | 给你一个非空数组,返回此数组中 第三大的数 。如果不存在,则返回数组中最大的数。
示例 1:
```
输入:[3, 2, 1]
输出:1
解释:第三大的数是 1 。
```
示例 2:
```
输入:[1, 2]
输出:2
解释:第三大的数不存在, 所以返回最大的数 2 。
```
示例 3:
```
输入:[2, 2, 3, 1]
输出:1
解释:注意,要求返回第三大的数,是指在所有不同数字中排第三大的数。
此例中存在两个值为 2 的数,它们都排第二。在所有不同数字中排第三大的数为 1 。
```
提示:
* 1 <= nums.length <= $10^4$
* $-2^{31}$ <= nums[i] <= ... | ### Set 去重 + 排序
题目要求返回含重复元素的数组 $nums$ 中的第三大数。
一个朴素的做法是,先使用 `Set` 对重复元素进行去重,然后对去重后的元素进行排序,并返回第三大的元素。
代码:
```Java
class Solution {
public int thirdMax(int[] nums) {
Set<Integer> set = new HashSet<>();
for (int x : nums) set.add(x);
List<Integer> list = new ArrayList<>(set);
Collecti... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.414` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/416. 分割等和子集(上)（中等）.md | 416. 分割等和子集(上) | https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/gong-shui-san-xie-bei-bao-wen-ti-shang-r-ln14/ | 中等 | [
"背包 DP"
] | 给你一个 只包含正整数 的 非空 数组 nums 。
请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。
示例 1:
```
输入:nums = [1,5,11,5]
输出:true
解释:数组可以分割成 [1, 5, 5] 和 [11] 。
```
示例 2:
```
输入:nums = [1,2,3,5]
输出:false
解释:数组不能分割成两个元素和相等的子集。
```
提示:
* 1 <= nums.length <= 200
* 1 <= nums[i] <= 100 | ### 前言
今天是我们讲解**动态规划专题**中的 *「背包问题」的第二天*。
在众多背包问题中「01 背包问题」是最为核心的,因此我建议你先精读过 [背包问题 第一讲](https://mp.weixin.qq.com/s/xmgK7SrTnFIM3Owpk-emmg) 之后再阅读本文。
**另外,我在文章结尾处列举了我所整理的关于背包问题的相关题目。**
背包问题我会按照编排好的顺序进行讲解(*每 2~3 天更新一篇,确保大家消化*)。
你也先可以尝试做做,也欢迎你向我留言补充,你觉得与背包相关的 DP 类型题目 ~
***
## 基本分析
**通常「背包问题」相关的题,都是在考察我们的「建模」能力,也就是将... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.416` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/416. 分割等和子集(下)（中等）.md | 416. 分割等和子集(下) | https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/gong-shui-san-xie-bei-bao-wen-ti-xia-con-mr8a/ | 中等 | [
"背包 DP"
] | 给你一个 只包含正整数 的 非空 数组 nums 。
请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。
示例 1:
```
输入:nums = [1,5,11,5]
输出:true
解释:数组可以分割成 [1, 5, 5] 和 [11] 。
```
示例 2:
```
输入:nums = [1,2,3,5]
输出:false
解释:数组不能分割成两个元素和相等的子集。
```
提示:
* 1 <= nums.length <= 200
* 1 <= nums[i] <= 100 | ### 基本分析
基本的「将原问题抽象为 01 背包问题」的分析在 [上一讲](https://mp.weixin.qq.com/s/NnVbGs5Chm9BwAQeMOnJfg) 讲过啦 ~
本节要解决的问题是:**如何将「间接求解」的方式转为「直接求解」,并学习为什么能这么做,此类做法是否有共性 ...**
---
### 直接求解
我们先来回顾一下 [上一节](https://mp.weixin.qq.com/s/NnVbGs5Chm9BwAQeMOnJfg) 使用的「状态定义」和「转移方程」。
状态定义:
$f[i][j]$ 代表考虑前 $i$ 个数值,其选择数字总和不超过 $j$ 的最大价值。
转移方程:... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.416` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/417. 太平洋大西洋水流问题（中等）.md | 417. 太平洋大西洋水流问题 | https://leetcode-cn.com/problems/pacific-atlantic-water-flow/solution/by-ac_oier-do7d/ | 中等 | [
"DFS",
"BFS",
"多源 BFS",
"并查集"
] | 有一个 `m × n` 的矩形岛屿,与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界,而 “大西洋” 处于大陆的右边界和下边界。
这个岛被分割成一个由若干方形单元格组成的网格。给定一个 `m x n` 的整数矩阵 `heights` , $heights[r][c]$ 表示坐标 $(r, c)$ 上单元格 高于海平面的高度 。
岛上雨水较多,如果相邻单元格的高度 小于或等于 当前单元格的高度,雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。
返回 网格坐标 `result` 的 2D 列表 ,其中 $result[i] = [r_i, c_i]$ 表示雨水可以从单元格 $(... | ### 基本分析
整理题意,需要我们统计能够同时流向两片海域的格子。
从源点(格子)流向汇点(海域)是按照高度从高到低(非严格)的规则,那么反过来从海域到格子则是按照从低到高(非严格)规则进行,同时本身处于边缘的格子与海域联通。
因此我们可以使用两遍 `DFS/BFS` 进行求解:分别从与当前海域直接相连的边缘格子出发,统计能够流向当前海域的格子集合,两片海域求得的集合交集即是答案。
---
### BFS(多源 BFS)
使用 `BFS` 进行求解:目的是构造出两个答案矩阵 $res_1$ 和 $res_2$,$res_k[i][j] = true$ 代表格子 $(i, j)$ 能够流向海域,起始将所有与海域相连... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.417` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/419. 甲板上的战舰（中等）.md | 419. 甲板上的战舰 | https://leetcode-cn.com/problems/battleships-in-a-board/solution/gong-shui-san-xie-ji-chong-sao-miao-xian-trmc/ | 中等 | [
"脑筋急转弯"
] | 给你一个大小为 $m x n$ 的矩阵 $board$ 表示甲板,其中,每个单元格可以是一艘战舰 `'X'` 或者是一个空位 `'.'` ,返回在甲板 $board$ 上放置的 战舰 的数量。
战舰 只能水平或者垂直放置在 $board$ 上。换句话说,战舰只能按 $1 * k$($1$ 行,$k$ 列)或 $k * 1$($k$ 行,$1$ 列)的形状建造,其中 $k$ 可以是任意大小。
两艘战舰之间至少有一个水平或垂直的空位分隔 (即没有相邻的战舰)。
示例 1:
```
输入:board = [["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
输出:2
``... | ### 脑筋急转弯
如果「允许扫描多次」或者「使用与输入同规模的空间」的话,做法都十分简单:
* 允许扫描多次,但空间只能 $O(1)$:每次遇到 `X` 的格子,则将 `X` 所在的战舰修改为 `-`,统计完答案后,再扫描一次,将 `-` 恢复为 `X` 即可;
* 扫描一次,但空间允许 $O(m * n)$:使用一个与矩阵同等大小的辅助数组 $vis$ 记录访问过的位置即可。
但题目要求「扫描一次」并且「空间 $O(1)$」,这就需要有点「脑筋急转弯」了。
> 注意这里的「扫描一次」是指使用一次遍历,而非要求每个单元格仅能访问一次,注意两者区别。
思考上述两种做法,我们本质 **都是在战舰的首个格子进行计数,并将该战舰... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.419` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/420. 强密码检验器（困难）.md | 420. 强密码检验器 | https://leetcode-cn.com/problems/strong-password-checker/solution/by-ac_oier-unp5/ | 困难 | [
"模拟"
] | 如果一个密码满足下述所有条件,则认为这个密码是强密码:
* 由至少 $6$ 个,至多 $20$ 个字符组成。
* 至少包含一个小写字母,一个大写字母,和一个数字。
* 同一字符不能连续出现三次 (比如 `"...aaa..."` 是不允许的, 但是 `"...aa...a..."` 如果满足其他条件也可以算是强密码)。
给你一个字符串 `password`,返回将 `password` 修改到满足强密码条件需要的最少修改步数。如果 `password` 已经是强密码,则返回 $0$ 。
在一步修改操作中,你可以:
* 插入一个字符到 `password`,
* 从 `password` 中删除一个字符,或
* 用另一个字符来... | ### 模拟(分情况讨论)
这是一道麻烦而又没啥意义的题。
需要满足的条件有三个,根据 `password` 的长度 $n$,字符种类数量 $m$,以及相同字符连续长度不低于 $3$ 的情况 $g$(数组 $g$ 的长度为相同字符长度不低于 $3$ 的连续段个数,$g[i]$ 代表第 $i$ 个连续段的长度),进行分情况讨论:
* $n < 6$:长度过短,不满足要求,任何一次「删除」操作都需要额外搭配一个「增加」操作,而这两步操作可以使用「替换」来代替,结果不会变差;同时为了满足长度要求,我们必然要使用到「增加」操作。因此**需要用到「增加」和「替换」操作**,枚举所有的情况发现,最少操作次数最终可以归纳到 $\max(6 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.420` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/421. 数组中两个数的最大异或值（中等）.md | 421. 数组中两个数的最大异或值 | https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/ | 中等 | [
"字典树",
"贪心"
] | 给你一个整数数组 $nums$ ,返回 `nums[i] XOR nums[j]` 的最大运算结果,其中 $0 ≤ i ≤ j < n$ 。
**进阶**:你可以在 $O(n)$ 的时间解决这个问题吗?
示例 1:
```
输入:nums = [3,10,5,25,2,8]
输出:28
解释:最大运算结果是 5 XOR 25 = 28.
```
示例 2:
```
输入:nums = [0]
输出:0
```
示例 3:
```
输入:nums = [2,4]
输出:6
```
示例 4:
```
输入:nums = [8,10,2]
输出:10
```
示例 5:
```
输入:nums = [14,70,53,83... | ### 基本分析
要求得数组 `nums` 中的「最大异或结果」,假定 $nums[i]$ 与 $nums[j]$ 异或可以取得最终结果。
**由于异或计算「每位相互独立」(又称为不进位加法),同时具有「相同值异或结果为 $0$,不同值异或结果为 $1$」的特性。**
因此对于 $nums[j]$ 而言,可以从其二进制表示中的最高位开始往低位找,尽量让每一位的异或结果为 $1$,这样找到的 $nums[i]$ 与 $nums[j]$ 的异或结果才是最大的。
具体的,我们需要先将 `nums` 中下标范围为 $[0, j]$ 的数(二进制表示)加入 $Trie$ 中,然后每次贪心的匹配每一位(优先匹配与之不同的二进制位)。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.421` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/423. 从英文中重建数字（中等）.md | 423. 从英文中重建数字 | https://leetcode-cn.com/problems/reconstruct-original-digits-from-english/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-m-vg7a/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 给你一个字符串 `s` ,其中包含字母顺序打乱的用英文单词表示的若干数字`(0-9)`。按 升序 返回原始的数字。
示例 1:
```
输入:s = "owoztneoer"
输出:"012"
```
示例 2:
```
输入:s = "fviefuro"
输出:"45"
```
提示:
* $1 <= s.length <= 10^5$
* `s[i]` 为 `["e","g","f","i","h","o","n","s","r","u","t","w","v","x","z"]` 这些字符之一
* `s` 保证是一个符合题目要求的字符串 | ### 模拟
题目要求我们将打乱的英文单词重建为数字。
我们可以先对 `s` 进行词频统计,然后根据「英文单词中的字符唯一性」确定构建的顺序,最后再对答案进行排序即可。
具体的,`zero` 中的 `z` 在其余所有单词中都没出现过,我们可以先统计 `zero` 的出现次数,并构建 $0$;然后观察剩余数字,其中 `eight` 中的 `g` 具有唯一性,构建 $8$;再发现 `six` 中的 `x` 具有唯一性,构建 $6$;发现 `three` 中的 `h` 具有唯一性(利用在此之前 `eight` 已经被删除干净,词频中仅存在 `three` 对应的 `h`),构建 $3$ ...
最终可以确定一个可行的构建序列为 `... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.423` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/424. 替换后的最长重复字符（中等）.md | 424. 替换后的最长重复字符 | https://leetcode-cn.com/problems/longest-repeating-character-replacement/solution/ping-ping-wu-qi-shuang-zhi-zhen-da-bai-h-fgif/ | 中等 | [
"双指针",
"滑动窗口"
] | 给你一个仅由大写英文字母组成的字符串,你可以将任意位置上的字符替换成另外的字符,总共可最多替换 $k$ 次。
在执行上述操作后,找到包含重复字母的最长子串的长度。
注意:字符串长度 和 $k$ 不会超过 $10^4$。
示例 1:
```
输入:s = "ABAB", k = 2
输出:4
解释:用两个'A'替换为两个'B',反之亦然。
```
示例 2:
```
输入:s = "AABABBA", k = 1
输出:4
解释:
将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。
子串 "BBBB" 有最长重复字母, 答案为 4。
``` | ### 滑动窗口
令 `l` 为符合条件的子串的左端点,`r` 为符合条件的子串的右端点。
使用 `cnt` 统计 `[l,r]` 范围的子串中每个字符串出现的次数。
对于合法的子串而言,必然有 `sum(所有字符的出现次数) - max(出现次数最多的字符的出现次数)= other(其他字符的出现次数) <= k`。
当找到这样的性质之后,我们可以对 `s` 进行遍历,每次让 `r` 右移并计数,如果符合条件,更新最大值;如果不符合条件,让 `l` 右移,更新计数,直到符合条件。
代码:
```Java
class Solution {
public int characterReplacement(String... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.424` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/427. 建立四叉树（中等）.md | 427. 建立四叉树 | https://leetcode.cn/problems/construct-quad-tree/solution/by-ac_oier-maul/ | 中等 | [
"递归",
"前缀和"
] | 给你一个 $n \times n$ 矩阵 `grid` ,矩阵由若干 $0$ 和 $1$ 组成。请你用四叉树表示该矩阵 `grid` 。
你需要返回能表示矩阵的 四叉树 的根结点。
注意,当 `isLeaf` 为 `False` 时,你可以把 `True` 或者 `False` 赋值给节点,两种值都会被判题机制 接受 。
四叉树数据结构中,每个内部节点只有四个子节点。此外,每个节点都有两个属性:
* `val`:储存叶子结点所代表的区域的值。$1$ 对应 `True`,$0$ 对应 `False`;
* `isLeaf`: 当这个节点是一个叶子结点时为 `True`,如果它有 $4$ 个子节点则为 `False` 。
```... | ### 递归
假定我们存在函数 `Node dfs(int a, int b, int c, int d)`,其能够返回「以 $(a, b)$ 为左上角,$(c, d)$ 为右下角」所代表的矩阵的根节点。
那么最终答案为 `dfs(0, 0, n-1, n-1)`,不失一般性考虑「以 $(a, b)$ 为左上角,$(c, d)$ 为右下角」时如何计算:
* 判断该矩阵是否为全 $0$ 或全 $1$:
* 如果是则直接创建根节点(该节点四个子节点属性均为空)并进行返回;
* 如果不是则创建根节点,递归创建四个子节点并进行赋值,利用左上角 $(a,b)$ 和右下角 $(c, d)$ 可算的横纵坐标的长度为 $c -... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.427` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/429. N 叉树的层序遍历（中等）.md | 429. N 叉树的层序遍历 | https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/solution/by-ac_oier-yeye/ | 中等 | [
"BFS",
"树"
] | 给定一个 `N` 叉树,返回其节点值的层序遍历。(即从左到右,逐层遍历)。
树的序列化输入是用层序遍历,每组子节点都由 `null` 值分隔(参见示例)。
示例 1:
```
输入:root = [1,null,3,2,4,null,5,6]
输出:[[1],[3,2,4],[5,6]]
```
示例 2:
```
输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
```
提示... | ### BFS
根据题意进行 `BFS` 即可。
由于我们需要以「层」为单位构建答案,因此在单次 `BFS` 过程中也按层进行。
代码:
```Java
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> ans = new ArrayList<>();
Deque<Node> d = new ArrayDeque<>();
if (root != null) d.addLast(root);
while (!d.isEmpty())... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.429` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/430. 扁平化多级双向链表（中等）.md | 430. 扁平化多级双向链表 | https://leetcode-cn.com/problems/flatten-a-multilevel-doubly-linked-list/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-9wfz/ | 中等 | [
"链表",
"迭代",
"递归"
] | 多级双向链表中,除了指向下一个节点和前一个节点指针之外,它还有一个子链表指针,可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项,依此类推,生成多级数据结构,如下面的示例所示。
给你位于列表第一级的头节点,请你扁平化列表,使所有结点出现在单级双链表中。
示例 1:
```
输入:head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
输出:[1,2,3,7,8,11,12,9,10,4,5,6]
解释:
```
输入的多级列表如下图所示:
扁平化后的链表如下图:
示例 2:
```
输入:head = [1,2,null,3]
输出:[1,... | ### 递归
一道常规链表模拟题。
利用 `flatten` 函数本身的含义(将链表头为 $head$ 的链表进行扁平化,并将扁平化后的头结点进行返回),我们可以很容易写出递归版本。
为防止空节点等边界问题,起始时建立一个哨兵节点 $dummy$ 指向 $head$,然后利用 $head$ 指针从前往后处理链表:
* 当前节点 $head$ 没有 $child$ 节点:直接让指针后即可,即 $head = head.next$;
* 当前节点 $head$ 有 $child$ 节点:将 $head.child$ 传入 `flatten` 函数递归处理,拿到普遍化后的头结点 $chead$,然后将 $head$ 和 $chea... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.430` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/432. 全 O(1) 的数据结构（困难）.md | 432. 全 O(1) 的数据结构 | https://leetcode-cn.com/problems/all-oone-data-structure/solution/by-ac_oier-t26d/ | 困难 | [
"双向链表",
"哈希表"
] | 请你设计一个用于存储字符串计数的数据结构,并能够返回计数最小和最大的字符串。
实现 `AllOne` 类:
* `AllOne()` 初始化数据结构的对象。
* `inc(String key)` 字符串 `key` 的计数增加 $1$ 。如果数据结构中尚不存在 `key` ,那么插入计数为 $1$ 的 `key` 。
* `dec(String key)` 字符串 `key` 的计数减少 $1$ 。如果 `key` 的计数在减少后为 $0$ ,那么需要将这个 `key` 从数据结构中删除。测试用例保证:在减少计数前,`key` 存在于数据结构中。
* `getMaxKey()` 返回任意一个计数最大的字符串。如果没有元素存在,... | ### 双向链表 + 哈希表
题目要求我们支持 $O(1)$ 的查询和修改,其中查询只需返回任意一个计数次数「最多」和「最少」的元素即可(如果有)。
虽然插入的字符串长度不超过 $10$(该数据范围的含义为字符串的哈希计算消耗可看作常数),但单纯的使用「哈希表」仅能做到 $O(1)$ 的计数,无法做到 $O(1)$ 查询。
**我们可以采取和 [实现一个 LRUCache](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486820&idx=1&sn=2055864e10848bce55afc4e2feda79a7&chksm=fd9ca67bcaeb2f6... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.432` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/433. 最小基因变化（中等）.md | 433. 最小基因变化 | https://leetcode-cn.com/problems/minimum-genetic-mutation/solution/by-ac_oier-74b4/ | 中等 | [
"BFS",
"双向 BFS",
"图论 DFS",
"AStar 算法",
"启发式搜索"
] | 基因序列可以表示为一条由 $8$ 个字符组成的字符串,其中每个字符都是 `'A'`、`'C'`、`'G'` 和 `'T'` 之一。
假设我们需要调查从基因序列 `start` 变为 `end` 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。
* 例如,`"AACCGGTT" --> "AACCGGTA"` 就是一次基因变化。
另有一个基因库 `bank` 记录了所有有效的基因变化,只有基因库中的基因才是有效的基因序列。
给你两个基因序列 `start` 和 `end` ,以及一个基因库 `bank` ,请你找出并返回能够使 `start` 变化为 `end` 所需的最少变化次数。如果无法完成此基因... | ### BFS
为了方便,我们令 $S = start$、 $T = end$,将每个基因序列视为「状态」。
容易想到使用 `BFS` 进行求解,并使用「哈希表」记录到达某个状态所消耗的步数(同时为了快速判断某个状态是否合法,我们使用 `Set` 结构对 $bank[i]$ 进行转存)。
起始将 `S` 加入队列,并更新到达 `S` 所使用的步数为 $0$,然后进行常规的 `BFS` 过程:每次取出队头元素,尝试替换当前状态的某一位,来得到新的状态(限定新状态必须合法,即必须出现在 `Set` 中),如果新状态合法并且没有在记录步数的哈希表中出现过,则将新状态入队并更新得到新状态所用步数,否则丢弃新状态。
重复上述过程直到... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.433` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/434. 字符串中的单词数（简单）.md | 434. 字符串中的单词数 | https://leetcode-cn.com/problems/number-of-segments-in-a-string/solution/gong-shui-san-xie-jian-dan-zi-fu-mo-ni-t-0gx6/ | 简单 | [
"模拟"
] | 统计字符串中的单词个数,这里的单词指的是连续的不是空格的字符。
请注意,你可以假定字符串里不包括任何不可打印的字符。
示例:
```
输入: "Hello, my name is John"
输出: 5
解释: 这里的单词是指连续的不是空格的字符,所以 "Hello," 算作 1 个单词。
``` | ### 模拟
题目对于「单词」的定义为「连续的不是空格的字符」。
因此,我们可以从前往后处理字符串 `s` 并进行计数,对于是空格的字符进行跳过(不计数),而对于非空格字符,则在遍历完一个完整单词(连续一段)后进行一次计数。
代码:
```Java
class Solution {
public int countSegments(String s) {
int n = s.length();
int ans = 0;
for (int i = 0; i < n; ) {
if (s.charAt(i) == ' ' && i++ >= 0) co... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.434` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/436. 寻找右区间（中等）.md | 436. 寻找右区间 | https://leetcode.cn/problems/find-right-interval/solution/by-ac_oier-sijp/ | 中等 | [
"排序",
"二分",
"双指针",
"莫队算法"
] | 给你一个区间数组 `intervals` ,其中 $intervals[i] = [start_i, end_i]$,且每个 $start_i$ 都 不同 。
区间 $i$ 的 右侧区间 可以记作区间 $j$ ,并满足 $start_j >= end_i$ ,且 $start_j$ 最小化 。
返回一个由每个区间 $i$ 的 右侧区间 的最小起始位置组成的数组。如果某个区间 $i$ 不存在对应的 右侧区间 ,则下标 $i$ 处的值设为 $-1$ 。
示例 1:
```
输入:intervals = [[1,2]]
输出:[-1]
解释:集合中只有一个区间,所以输出-1。
```
示例 2:
```
输入:intervals... | ### 排序 + 二分
为了方便,我们称 $intervals$ 为 $its$。
对于每个 $its[i]$ 而言,我们需要在所有满足「$its[j][0] \geqslant its[i][1]$」中找到 $its[j][0]$ 值最小的下标 $j$,并将其记为 $ans[i]$。
对于一个特定的 $its[i]$ 而言,其右端点固定,并且我们只关心目标位置的左端点。
因此我们可以构造一个记录区间左端点的数组 $clone$,并将其进行排序,同时为了记录每个左端点来自于原序列中的那个下标,还需要额外记录原序列下标,即以 $(start, idx)$ 二元组的形式进行转存,并根据 $start$ 排序。
然后从前往后处... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.436` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/437. 路径总和 III（中等）.md | 437. 路径总和 III | https://leetcode-cn.com/problems/path-sum-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-q-usa7/ | 中等 | [
"DFS",
"树的遍历",
"前缀和"
] | 给定一个二叉树的根节点 `root` ,和一个整数 `targetSum`,求该二叉树里节点值之和等于 `targetSum` 的 路径 的数目。
路径 不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。
示例 1:
```
输入:root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
输出:3
解释:和等于 8 的路径有 3 条,如图所示。
```
示例 2:
```
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:3
```
提示... | ### 树的遍历 + DFS
一个朴素的做法是搜索以每个节点为根的(往下的)所有路径,并对路径总和为 $targetSum$ 的路径进行累加统计。
使用 `dfs1` 来搜索所有节点,复杂度为 $O(n)$;在 `dfs1` 中对于每个当前节点,使用 `dfs2` 搜索以其为根的所有(往下的)路径,同时累加路径总和为 $targetSum$ 的所有路径,复杂度为 $O(n)$。
整体复杂度为 $O(n^2)$,数据范围为 $10^3$,可以过。
代码:
```Java
class Solution {
int ans, t;
public int pathSum(TreeNode root, int _t) ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.437` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/438. 找到字符串中所有字母异位词（中等）.md | 438. 找到字符串中所有字母异位词 | https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/solution/gong-shui-san-xie-shuang-zhi-zhen-shi-xi-t5hc/ | 中等 | [
"双指针",
"滑动窗口"
] | 给定两个字符串 `s` 和 `p`,找到 `s` 中所有 `p` 的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。
**异位词** 指由相同字母重排列形成的字符串(包括相同的字符串)。
示例 1:
```
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
```
示例 2:
```
输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" ... | ### 双指针(滑动窗口)
这是一道使用双指针实现滑动窗口的裸题。
具体的,我们可以先创建一个大小为 $26$ 的数组 $c2$ 来统计字符串 `p` 的词频,另外一个同等大小的数组 $c1$ 用来统计「滑动窗口」内的 `s` 的子串词频。
当两个数组所统计词频相等,说明找到了一个异位组,将窗口的左端点加入答案。
代码:
```Java
class Solution {
public List<Integer> findAnagrams(String s, String p) {
List<Integer> ans = new ArrayList<>();
int n = s.leng... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.438` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/440. 字典序的第K小数字（困难）.md | 440. 字典序的第K小数字 | https://leetcode-cn.com/problems/k-th-smallest-in-lexicographical-order/solution/by-ac_oier-m3zl/ | 困难 | [
"数学",
"模拟",
"找规律",
"计数"
] | 给定整数 $n$ 和 $k$,返回 $[1, n]$ 中字典序第 $k$ 小的数字。
示例 1:
```
输入: n = 13, k = 2
输出: 10
解释: 字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9],所以第二小的数字是 10。
```
示例 2:
```
输入: n = 1, k = 1
输出: 1
```
提示:
* $1 <= k <= n <= 10^9$ | ### 计数模拟
寻找字典序第 $k$ 小的数。
我们可以将该过程分两步操作 :「确定前缀」和「从以某个前缀开始找目标值」。
假定我们存在某个函数 `int getCnt(int x, int limit)`,该函数实现了统计范围 $[1, limit]$ 内以 $x$ 为前缀的数的个数。
有了该函数之后,我们可以从最小的前缀 $1$ 开始枚举,假设当前枚举到前缀 $x$,根据 $cnt = getCnt(x, n)$ 与 $k$ 的大小关系进行分情况讨论:
* $cnt < k$:说明所有以 $x$ 为前缀的数组均可跳过,此时让 $x$ 自增,$k$ 减去 $cnt$。含义为从下一个「数值比 $x$ 大」的前缀中找目标值... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.440` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/441. 排列硬币（简单）.md | 441. 排列硬币 | https://leetcode-cn.com/problems/arranging-coins/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-x-sv9o/ | 简单 | [
"数学",
"二分"
] | 你总共有 `n` 枚硬币,并计划将它们按阶梯状排列。
对于一个由 `k` 行组成的阶梯,其第 `i` 行必须正好有 i 枚硬币。阶梯的最后一行**可能**是不完整的。
给你一个数字 `n` ,计算并返回可形成**完整阶梯行**的总行数。
示例 1:
```
输入:n = 5
输出:2
解释:因为第三行不完整,所以返回 2 。
```
示例 2:
```
输入:n = 8
输出:3
解释:因为第四行不完整,所以返回 3 。
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 数学
假设 $n$ 个硬币最多凑出 $x$ 行,根据等差数列求和公式 $S_n = n * a_1 + \frac{n * (n - 1)}{2} * d$(首项和公差均为 $1$),可得 $n$ 和 $x$ 的关系:
$$
\frac{x * (x + 1)}{2} <= n
$$
问题为求满足上式前提下,$x$ 的最大值为多少。
根据 [求解一元二次方程](https://baike.baidu.com/item/%E4%B8%80%E5%85%83%E4%BA%8C%E6%AC%A1%E6%96%B9%E7%A8%8B) 求根公式,可得:
$$
x <= \left \lfloor \frac{- 1 + \... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.441` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/442. 数组中重复的数据（中等）.md | 442. 数组中重复的数据 | https://leetcode-cn.com/problems/find-all-duplicates-in-an-array/solution/by-ac_oier-0m3c/ | 中等 | [
"原地哈希",
"数组"
] | 给你一个长度为 $n$ 的整数数组 `nums`,其中 `nums` 的所有整数都在范围 $[1, n]$ 内,且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数,并以数组形式返回。
你必须设计并实现一个时间复杂度为 $O(n)$ 且仅使用常量额外空间的算法解决此问题。
示例 1:
```
输入:nums = [4,3,2,7,8,2,3,1]
输出:[2,3]
```
示例 2:
```
输入:nums = [1,1,2]
输出:[1]
```
示例 3:
```
输入:nums = [1]
输出:[]
```
提示:
* $n == nums.length$
* $1 <= n <= 10^5$
* $... | ### 原地哈希
给定数组长度为 $n$,且所有数范围在 $[1, n]$,找出出现次数超过一次的所有数字。
利用值域与数字下标空间大小的等同关系,我们可以构造一种对应“关系”,使得每个数出现在它应该出现的位置:对于值为 $k$ 的数字,我们将其应该出现在的位置定为 $k - 1$。
基于此,我们从前往后遍历 $nums$,并尝试将当前处理到的 $nums[i]$ 放到目标位置 $nums[i] - 1$ 处。如果一个数在尝试移动到它应该出现的位置时,发现 $nums[nums[i] - 1] = nums[i] (nums[i] - 1 \neq i)$,则说明该数字出现了超过一次。此时我们将 $nums[i]$ 加入答案,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.442` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/443. 压缩字符串（中等）.md | 443. 压缩字符串 | https://leetcode-cn.com/problems/string-compression/solution/gong-shui-san-xie-shuang-zhi-zhen-yuan-d-bppu/ | 中等 | [
"模拟",
"双指针",
"字符串"
] | 给你一个字符数组 chars ,请使用下述算法压缩:
从一个空字符串 s 开始。对于 chars 中的每组 连续重复字符 :
* 如果这一组长度为 1 ,则将字符追加到 s 中。
* 否则,需要向 s 追加字符,后跟这一组的长度。
压缩后得到的字符串 s 不应该直接返回 ,需要转储到字符数组 chars 中。需要注意的是,如果组长度为 10 或 10 以上,则在 chars 数组中会被拆分为多个字符。
请在** 修改完输入数组后**,返回该数组的新长度。
你必须设计并实现一个只使用常量额外空间的算法来解决此问题。
示例 1:
```
输入:chars = ["a","a","b","b","c","c","c"]
输出... | ### 双指针
令输入数组 `cs` 长度为 $n$。
使用两个指针 `i` 和 `j` 分别指向「当前处理到的位置」和「答案待插入的位置」:
1. `i` 指针一直往后处理,每次找到字符相同的连续一段 $[i, idx)$,令长度为 $cnt$;
2. 将当前字符插入到答案,并让 `j` 指针后移:`cs[j++] = cs[i]`;
3. 检查长度 $cnt$ 是否大于 $1$,如果大于 $1$,需要将数字拆分存储。由于简单的实现中,我们只能从个位开始处理 $cnt$,因此需要使用 `start` 和 `end` 记录下存储数字的部分,再处理完 $cnt$ 后,将 $[start, end)$ 部分进行翻转,并更新 `j`... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/446. 等差数列划分 II - 子序列（困难）.md | 446. 等差数列划分 II - 子序列 | https://leetcode-cn.com/problems/arithmetic-slices-ii-subsequence/solution/gong-shui-san-xie-xiang-jie-ru-he-fen-xi-ykvk/ | 困难 | [
"动态规划",
"序列 DP",
"容斥原理",
"数学"
] | 给你一个整数数组 nums ,返回 nums 中所有 等差子序列 的数目。
如果一个序列中 至少有三个元素 ,并且任意两个相邻元素之差相同,则称该序列为等差序列。
* 例如,[1, 3, 5, 7, 9]、[7, 7, 7, 7] 和 [3, -1, -5, -9] 都是等差序列。
* 再例如,[1, 1, 2, 5, 7] 不是等差序列。
数组中的子序列是从数组中删除一些元素(也可能不删除)得到的一个序列。
* 例如,[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。
题目数据保证答案是一个 32-bit 整数。
示例 1:
```
输入:nums = [2,4,6,8,10]
输出:7
解... | ### 基本分析
从题目描述来看,我们可以确定这是一个「序列 DP」问题,通常「序列 DP」需要 $O(n^2)$ 的时间复杂度,而某些具有特殊性质的「序列 DP」问题,例如 LIS 问题,能够配合贪心思路 + 二分做到 $O(n\log{n})$ 复杂度。再看一眼数据范围为 $10^3$,基本可以确定这是一道复杂度为 $O(n^2)$ 的「序列 DP」问题。
---
### 动态规划 + 容斥原理
**既然分析出是序列 DP 问题,我们可以先猜想一个基本的状态定义,看是否能够「不重不漏」的将状态通过转移计算出来。如果不行,我们再考虑引入更多的维度来进行求解。**
先从最朴素的猜想出发,定义 $f[i]$ 为考虑下标不超过... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/447. 回旋镖的数量（中等）.md | 447. 回旋镖的数量 | https://leetcode-cn.com/problems/number-of-boomerangs/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-evu2/ | 中等 | [
"哈希表",
"模拟"
] | 给定平面上 `n` 对 互不相同 的点 `points`,其中 `points[i] = [xi, yi]` 。回旋镖 是由点 `(i, j, k)` 表示的元组 ,其中 `i` 和 `j` 之间的距离和 `i` 和 `k` 之间的距离相等(需要考虑元组的顺序)。
返回平面上所有回旋镖的数量。
示例 1:
```
输入:points = [[0,0],[1,0],[2,0]]
输出:2
解释:两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
```
示例 2:
```
输入:points = [[1,1],[2,2],[3,3]]
输出:2
```
示例 3:
```
输入:... | ### 哈希表
数据范围为 $500$,三层循环的朴素做法显然会 TLE。
对于每个回旋镖三元组而言,本质上我们在统计给定 $i$ 的情况下,与 $i$ 距离相等的 $(j, k)$ 组合个数为多少。
我们可以使用哈希表进行预处理,在统计以 $i$ 为三元组第一位的回旋镖个数前,先计算出 $i$ 和其余点的距离,并以 `{ 距离 : 个数 }` 的形式进行存储,然后分别对所有的距离进行累加计数。
在计算距离时为了避免使用 `sqrt`,我们直接使用 $x^2 + y^2$ 来代指两点间的距离。
代码:
```Java
class Solution {
public int numberOfBoomerangs(in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.447` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/448. 找到所有数组中消失的数字（简单）.md | 448. 找到所有数组中消失的数字 | https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array/solution/li-yong-tong-pai-xu-de-si-lu-ni-huan-ke-e3t4w/ | 简单 | [
"排序",
"原地哈希"
] | 给定一个范围在 $1 ≤ a[i] ≤ n$ ( $n$ = 数组大小 ) 的 整型数组,数组中的元素一些出现了两次,另一些只出现一次。
找到所有在 $[1, n]$ 范围之间没有出现在数组中的数字。
您能在不使用额外空间且时间复杂度为 $O(n)$ 的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。
示例:
```
输入:
[4,3,2,7,8,2,3,1]
输出:
[5,6]
``` | ### 桶排序(原地哈希)
题目规定了 $1 ≤ a[i] ≤ n$,因此我们可以使用「桶排序」的思路,将每个数放在其应该出现的位置上。
基本思路为:
按照桶排序思路进行预处理:保证 $1$ 出现在 $nums[0]$ 的位置上,$2$ 出现在 $nums[1]$ 的位置上,...,$n$ 出现在 $nums[n - 1]$ 的位置上。不在 $[1, n]$ 范围内的数不用动。
例如样例中 $[4,3,2,7,8,2,3,1]$ 将会被预处理成 $[1,2,3,4,3,2,7,8]$。
遍历 $nums$,将不符合 `nums[i] != i + 1` 的数字加入结果集 ~
代码:
```Java
class Sol... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.448` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/449. 序列化和反序列化二叉搜索树（中等）.md | 449. 序列化和反序列化二叉搜索树 | https://leetcode.cn/problems/serialize-and-deserialize-bst/solution/by-ac_oier-ncwn/ | 中等 | [
"前序遍历",
"BST",
"二分"
] | 序列化是将数据结构或对象转换为一系列位的过程,以便它可以存储在文件或内存缓冲区中,或通过网络连接链路传输,以便稍后在同一个或另一个计算机环境中重建。
设计一个算法来序列化和反序列化 二叉搜索树 。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串,并且可以将该字符串反序列化为最初的二叉搜索树。
编码的字符串应尽可能紧凑。
示例 1:
```
输入:root = [2,1,3]
输出:[2,1,3]
```
示例 2:
```
输入:root = []
输出:[]
```
提示:
* 树中节点数范围是 $[0, 10^4]$
* $0 <= Node.val <= 10^4$
* 题目数据... | ### BST 特性(前序遍历)
实现上,我们可以忽略「BST」这一条件,使用「BFS」或者「直接充当满二叉树」来序列化和反序列化。
但由于点的数量是 $1e4$,最坏情况下是当 BST 成链时,会有较大的空间浪费。
因此,一种较为紧凑的序列化/反序列化的方式是利用「前序遍历 + BST 特性」:
* 序列化:对 BST 进行「前序遍历」,并跳过空节点,节点值通过 `,` 进行分割,假设最终序列化出来的字符串是 `s`。
之所以使用「前序遍历」是为了方便反序列化:首先对于某个子树而言,其必然是连续存储,也就是必然能够使用 $s[l,r]$ 所表示处理,同时首位元素必然是该子树的头结点;
* 反序列化:将 `s` 根... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.449` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/450. 删除二叉搜索树中的节点（中等）.md | 450. 删除二叉搜索树中的节点 | https://leetcode.cn/problems/delete-node-in-a-bst/solution/by-ac_oier-s60a/ | 中等 | [
"递归",
"BST",
"二叉树"
] | 给定一个二叉搜索树的根节点 `root` 和一个值 `key`,删除二叉搜索树中的 `key` 对应的节点,并保证二叉搜索树的性质不变。返回二叉搜索树(有可能被更新)的根节点的引用。
一般来说,删除节点可分为两个步骤:
* 首先找到需要删除的节点;
* 如果找到了,删除它。
示例 1:
```
输入:root = [5,3,6,2,4,null,7], key = 3
输出:[5,4,6,2,null,null,7]
解释:给定需要删除的节点值是 3,所以我们首先找到 3 这个节点,然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
```
```
另一个正确答案是 [5,2,6... | ### 递归
利用题目本身的函数签名的含义,也就是「**在以 `root` 为根的子树中,删除值为 `key` 的节点,并返回删除节点后的树的根节点**」,我们可以用「递归」来做。
起始先对边界情况进行处理,当 `root` 为空(可能起始传入的 `root` 为空,也可能是递归过程中没有找到值为 `key` 的节点时,导致的 `root` 为空),我们无须进行任何删除,直接返回 `null` 即可。
根据当前 `root.val` 与 `key` 的大小关系,进行分情况讨论:
1. 若有 $root.val < key$,说明待删除的节点必然不是当前节点,以及不在当前节点的左子树中,我们将删除动作「递归」到当前节点的右子树... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.450` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/451. 根据字符出现频率排序（中等）.md | 451. 根据字符出现频率排序 | https://leetcode-cn.com/problems/sort-characters-by-frequency/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-gst9/ | 中等 | [
"模拟",
"桶排序",
"哈希表",
"数组",
"优先队列(堆)"
] | 给定一个字符串,请将字符串里的字符按照出现的频率降序排列。
示例 1:
```
输入:
"tree"
输出:
"eert"
解释:
'e'出现两次,'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外,"eetr"也是一个有效的答案。
```
示例 2:
```
输入:
"cccaaa"
输出:
"cccaaa"
解释:
'c'和'a'都出现三次。此外,"aaaccc"也是有效的答案。
注意"cacaca"是不正确的,因为相同的字母必须放在一起。
```
示例 3:
```
输入:
"Aabb"
输出:
"bbAa"
解释:
此外,"bbaA"也是一个有效的答案,但"Aabb"是不正确的。
注意... | ### 数据结构 + 模拟
这是一道考察数据结构运用的模拟题。
具体做法如下:
1. 先使用「哈希表」对词频进行统计;
2. 遍历统计好词频的哈希表,将每个键值对以 `{字符,词频}` 的形式存储到「优先队列(堆)」中。并规定「优先队列(堆)」排序逻辑为:
* 如果 `词频` 不同,则按照 `词频` 倒序;
* 如果 `词频` 相同,则根据 `字符字典序` 升序(由于本题采用 Special Judge 机制,这个排序策略随意调整也可以。但通常为了确保排序逻辑满足「全序关系」,这个地方可以写正写反,但理论上不能不写,否则不能确保每次排序结果相同);
3. 从「优先队列(堆)」依次弹出,构造答案。
代码:
```... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.451` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/453. 最小操作次数使数组元素相等（简单）.md | 453. 最小操作次数使数组元素相等 | https://leetcode-cn.com/problems/minimum-moves-to-equal-array-elements/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-tt3zu/ | 简单 | [
"数学"
] | 给你一个长度为 `n` 的整数数组,每次操作将会使 `n - 1` 个元素增加 `1` 。
返回让数组所有元素相等的最小操作次数。
示例 1:
```
输入:nums = [1,2,3]
输出:3
解释:
只需要3次操作(注意每次操作会增加两个元素的值):
[1,2,3] => [2,3,3] => [3,4,3] => [4,4,4]
```
示例 2:
```
输入:nums = [1,1,1]
输出:0
```
提示:
* n == nums.length
* $1 <= nums.length <= 10^5$
* $-10^9 <= nums[i] <= 10^9$
* 答案保证符合 32-bit ... | ### 数学
为了方便,令原数组 $num$ 的总和为 $sum$,最小值为 $min$,最大值为 $max$,长度为 $n$,真实最小操作次数为 $ans$。
由于每次只能将 $n - 1$ 个元素整体加一,因此在最终的相等状态,整体元素的大小值 $t$ 满足关系 $t \geqslant max$。
我们考虑是否必然可以取到关系式中的等号?
答案是不一定,当且仅当 $num$ 本身有 $n - 1$ 个元素与 $max$ 差值相等,才能取得关系式中的等号。
同时我们知道,$ans$ 与 $t$ 存在一一对应关系:
$$
ans = \frac{t * n - sum}{n - 1}
$$
要取得最小的 $ans$,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.453` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/456. 132 模式（中等）.md | 456. 132 模式 | https://leetcode-cn.com/problems/132-pattern/solution/xiang-xin-ke-xue-xi-lie-xiang-jie-wei-he-95gt/ | 中等 | [
"单调栈"
] | 给你一个整数数组 `nums`,数组中共有 `n` 个整数。`132` 模式的子序列 由三个整数 `nums[i]`、`nums[j]` 和 `nums[k]` 组成,并同时满足:$i < j < k$ 和 $nums[i] < nums[k] < nums[j]$ 。
如果 `nums` 中存在 `132` 模式的子序列 ,返回 `true`;否则,返回 `false`。
进阶:很容易想到时间复杂度为 $O(n^2)$ 的解决方案,你可以设计一个时间复杂度为 $O(n \log{n})$ 或$ O(n)$ 的解决方案吗?
示例 1:
```
输入:nums = [1,2,3,4]
输出:false
解释:序列中不存在 1... | ### 基本思路
朴素的做法是分别对三个数进行枚举,这样的做法是 $O(n^3)$ 的,数据范围是 $10^4$,稳稳超时。
事实上,这样的数据范围甚至不足以我们枚举其中两个数,然后优化找第三个数的 $O(n^2)$ 做法。
**这时候根据数据范围会联想到树状数组,使用树状数组的复杂度是 $O(n\log{n})$ 的,可以过。但是代码量会较多一点,还需要理解离散化等前置知识**。题解也不太好写。
因此,我们可以从 132 的大小特性去分析,如果在确定一个数之后,如何快速找到另外两个数(我们使用 `ijk` 来代指 132 结构):
1. 枚举 `i`:由于 `i` 是 132 结构中最小的数,那么相当于我们要从 i 后面... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.456` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/457. 环形数组是否存在循环（中等）.md | 457. 环形数组是否存在循环 | https://leetcode-cn.com/problems/circular-array-loop/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-ag05/ | 中等 | [
"图",
"模拟"
] | 存在一个不含 $0$ 的 环形 数组 $nums$ ,每个 $nums[i]$ 都表示位于下标 $i$ 的角色应该向前或向后移动的下标个数:
* 如果 $nums[i]$ 是正数,向前 移动 $nums[i]$ 步
* 如果 $nums[i]$ 是负数,向后 移动 $nums[i]$ 步
因为数组是**环形**的,所以可以假设从最后一个元素向前移动一步会到达第一个元素,而第一个元素向后移动一步会到达最后一个元素。
数组中的 循环 由长度为 $k$ 的下标序列 $seq$ :
* 遵循上述移动规则将导致重复下标序列 `seq[0] -> seq[1] -> ... -> seq[k - 1] -> seq[0] -> ...`
... | ### 模拟
根据题意,我们可以从每个下标 $i$ 进行出发检查,如果以某个下标 $i$ 为出发点发现了「循环」,返回 `True`,否则返回 `False`。
唯一需要注意的细节是,当我们处理到的下标为 $cur$,计算下一个跳转点 $next = cur + nums[cur]$ 时,对于越过数组的情况进行处理:
1. 如果 $next$ 为负数:在 $next$ 的基础上增加 $n * \left \lceil next / n \right \rceil$,将其映射回正值;
2. 如果 $next$ 为正数:将 $next$ 模数组长度 $n$,确保不会越界。
整理一下,我们可以统一写成 `next = ((cur... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.457` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/458. 可怜的小猪（困难）.md | 458. 可怜的小猪 | https://leetcode-cn.com/problems/poor-pigs/solution/gong-shui-san-xie-jin-zhi-cai-xiang-xian-69fl/ | 困难 | [
"数学"
] | 有 `buckets` 桶液体,其中 正好 有一桶含有毒药,其余装的都是水。它们从外观看起来都一样。
为了弄清楚哪只水桶含有毒药,你可以喂一些猪喝,通过观察猪是否会死进行判断。不幸的是,你只有 `minutesToTest` 分钟时间来确定哪桶液体是有毒的。
喂猪的规则如下:
1. 选择若干活猪进行喂养
2. 可以允许小猪同时饮用任意数量的桶中的水,并且该过程不需要时间。
3. 小猪喝完水后,必须有 `minutesToDie` 分钟的冷却时间。在这段时间里,你只能观察,而不允许继续喂猪。
4. 过了 `minutesToDie` 分钟后,所有喝到毒药的猪都会死去,其他所有猪都会活下来。
5. 重复这一过程,直到时间用完。
... | ### 数学
我们用实验对象来代指题干的小动物。同时为了方便,我们使用 $n$ 代指有多少桶水,$d$ 为实验对象的反应时间,$t$ 为测试总时间。
根据题意,最大测试次数为 $k = \left \lfloor \frac{t}{d} \right \rfloor$。
我们可以先考虑 $k = 1$ 的情况,最简单的情况是,我们使用与水同等数量的实验对象数量来进行测试。
此时哪个实验对象有反应,则可以推断出哪一桶水有问题。
但这样的测试方式,每个实验动物承载的信息量是很低的,每个实验对象仅承载了某一桶水是否有问题。
**为减少实验对象数量,我们需要增大每个实验对象承载的信息量(让每个实验对象同时测试多桶水),然后从最终... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.458` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/460. LFU 缓存（困难）.md | 460. LFU 缓存 | https://leetcode-cn.com/problems/lfu-cache/solution/gong-shui-san-xie-yun-yong-tong-pai-xu-s-53m3/ | 困难 | [
"链表",
"双向链表",
"设计"
] | 请你为 **最不经常使用(LFU)** 缓存算法设计并实现数据结构。
实现 `LFUCache` 类:
* `LFUCache(int capacity)` - 用数据结构的容量 `capacity` 初始化对象
* `int get(int key)` - 如果键存在于缓存中,则获取键的值,否则返回 -1。
* `void put(int key, int value)` - 如果键已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量时,则应该在插入新项之前,使最不经常使用的项无效。在此问题中,当存在平局(即两个或更多个键具有相同使用频率)时,应该去除 **最近最久未使用** 的键。
注意「项的使用次数」就是自插... | ### 基本分析
前两天我们刚讲过 [146. LRU 缓存机制](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486820&idx=1&sn=2055864e10848bce55afc4e2feda79a7&chksm=fd9ca67bcaeb2f6d2038706e32cafffd701d3d6b71b60c52a568ed6dc0e268d93f8a78498105&token=672687058&lang=zh_CN#rd) ,简单理解 LRU 就是「移除最久不被使用的元素」。
因此对于 LRU 我们只需要在使用「哈希表」的同时,维护一个「双向链表」... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.460` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/461. 汉明距离（简单）.md | 461. 汉明距离 | https://leetcode-cn.com/problems/hamming-distance/solution/gong-shui-san-xie-tong-ji-liang-shu-er-j-987a/ | 简单 | [
"位运算"
] | 两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
给出两个整数 x 和 y,计算它们之间的汉明距离。
注意:
0 ≤ x, y < 231.
示例:
```
输入: x = 1, y = 4
输出: 2
解释:
1 (0 0 0 1)
4 (0 1 0 0)
↑ ↑
上面的箭头指出了对应二进制位不同的位置。
``` | ### 逐位比较
本身不改变 $x$ 和 $y$,每次取不同的偏移位进行比较,不同则加一。
循环固定取满 $32$ 。
代码:
```Java
class Solution {
public int hammingDistance(int x, int y) {
int ans = 0;
for (int i = 0; i < 32; i++) {
int a = (x >> i) & 1 , b = (y >> i) & 1;
ans += a != b ? 1 : 0;
}
return ans;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.461` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/462. 最少移动次数使数组元素相等 II（中等）.md | 462. 最少移动次数使数组元素相等 II | https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii/solution/by-ac_oier-db44/ | 中等 | [
"数学"
] | 给你一个长度为 $n$ 的整数数组 $nums$,返回使所有数组元素相等需要的最少移动数。
在一步操作中,你可以使数组中的一个元素加 $1$ 或者减 $1$ 。
示例 1:
```
输入:nums = [1,2,3]
输出:2
解释:
只需要两步操作(每步操作指南使一个元素加 1 或减 1):
[1,2,3] => [2,2,3] => [2,2,2]
```
示例 2:
```
输入:nums = [1,10,2,9]
输出:16
```
提示:
* $n == nums.length$
* $1 <= nums.length <= 10^5$
* $-10^9 <= nums[i] <= 10^9$ | ### 数学
假定所有的 $nums[i]$ 均位于数轴上的 $nums[i]$ 的位置,题目要求我们在数轴上找出一个点 $t$,使得所有 $nums[i]$ 到 $t$ 的距离之和最小。
**首先,容易证明 $t$ 不可能位于最小的 $nums[i]$ 的左侧,也不可能位于最大的 $nums[i]$ 的右侧,否则我们「至少」能够将目标点调整为 最小的 $nums[i]$ 或 最大的 $nums[i]$ 来得到更小的距离总和。**
> 其实由上述这一点进行推广,已经可以证明最优点必然是在中间点($nums$ 数量为奇数时)或者中间两点形成的闭区间中的任意点($nums$ 数量为偶数时)。
但为了证明更加直观,我们仍从「反证法」... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.462` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/464. 我能赢吗（中等）.md | 464. 我能赢吗 | https://leetcode.cn/problems/can-i-win/solution/by-ac_oier-0ed9/ | 中等 | [
"博弈论 DP",
"记忆化搜索",
"状态压缩"
] | 在 "100 game" 这个游戏中,两名玩家轮流选择从 $1$ 到 $10$ 的任意整数,累计整数和,先使得累计整数和 达到或超过 $100$ 的玩家,即为胜者。
如果我们将游戏规则改为 “玩家 不能 重复使用整数” 呢?
例如,两个玩家可以轮流从公共整数池中抽取从 $1$ 到 $15$ 的整数(不放回),直到累计整数和 >= $100$。
给定两个整数 `maxChoosableInteger` (整数池中可选择的最大数)和 `desiredTotal`(累计和),若先出手的玩家是否能稳赢则返回 `true` ,否则返回 `false` 。假设两位玩家游戏时都表现 最佳 。
示例 1:
```
输入:maxChoosa... | ### 二维博弈论 DP(TLE)
这是一道博弈论 DP 的题,为了方便,我们使用 $n$ 来表示 $maxChoosableInteger$,使用 $t$ 来表示 $desiredTotal$。
由于 $n$ 数据范围为 $20$,且每个数只能选一次,我们可以使用一个二进制数 $state$ 来表示 $[1, n]$ 范围内的被选择的数的情况:二进制表示中 $1$ 的位置代表数已被选择,否则代表尚未选择。
首先朴素二维状态表示相对容易想到:**定义 $f[statue][k]$ 为当前已被选择的数为 $state$,轮数为 $k$ 时,「原始回合的先手」能否获胜($1$ 代表能,$-1$ 代表不能),其中 $k$ 从 $0$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.464` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/467. 环绕字符串中唯一的子字符串（中等）.md | 467. 环绕字符串中唯一的子字符串 | https://leetcode.cn/problems/unique-substrings-in-wraparound-string/solution/by-ac_oier-qteu/ | 中等 | [
"线性 DP",
"树状数组"
] | 把字符串 `s` 看作是 `“abcdefghijklmnopqrstuvwxyz”` 的无限环绕字符串,所以 `s` 看起来是这样的:
`"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd...."` .
现在给定另一个字符串 `p` 。返回 `s` 中 唯一 的 `p` 的 非空子串 的数量 。
示例 1:
```
输入: p = "a"
输出: 1
解释: 字符串 s 中只有一个"a"子字符。
```
示例 2:
```
输入: p = "cac"
输出: 2
解释: 字符串 s 中的字符串“cac”只有两个子串“a”、“c”。.
```... | ### 线性 DP + 树状数组 + 同字符最大长度计数
> ~~早上起来没睡醒~~ 老了,脑袋不行了,第一反应是用「线性 DP + 树状数组」来做,估了一下时间复杂度没问题就写了。
该做法有一点点思维难度,因此可能不是这道中等题的标准解法。
**定义 $f[i]$ 为以 $s[i]$ 为结尾的最大有效子串的长度。**
从该状态定义容易得到如下的状态转移方程:
* 存在 $s[i - 1]$ 并且 $s[i]$ 能够接在 $s[i - 1]$ 后面(除了 $s[i]$ 为 $s[i - 1]$ 的下一字母以外,还特别包括 $s[i - 1] = z$ 同时 $s[i] = a$ 的情况),则我们有 $f[i] = f[i ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.467` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/468. 验证IP地址（中等）.md | 468. 验证IP地址 | https://leetcode.cn/problems/validate-ip-address/solution/by-ac_oier-s217/ | 中等 | [
"模拟",
"双指针"
] | 给定一个字符串 `queryIP`。如果是有效的 `IPv4` 地址,返回 `"IPv4"` ;如果是有效的 `IPv6` 地址,返回 `"IPv6"` ;如果不是上述类型的 `IP` 地址,返回 `"Neither"` 。
有效的 `IPv4` 地址 是 `“x1.x2.x3.x4”` 形式的 `IP` 地址。 其中$ 0 <= x_i <= 255$ 且 $x_i$ 不能包含 前导零。
例如: `“192.168.1.1”` 、 `“192.168.1.0”` 为有效 `IPv4` 地址, `“192.168.01.1”` 为无效 `IPv4` 地址; `“192.168.1.00”` 、 `“192.168@1.1”` 为... | ### 模拟
为了方便,我们称合法 `IPv4`/`IPv6` 中由 `.`/`:` 分割的部分称为 `item`。
无论是 `IPv4` 还是 `IPv6`,我们都只需将连续段的 `item` 取出,并结合题意判断即可,一个较为简单的方式使用 `split` 操作来得到所有的 `item`,考虑到某些语言并不内置 `split`,这里采取双指针的方式来做。
为方便大家理解,今天将题解文字说明写到注释中。
代码:
```Java
class Solution {
public String validIPAddress(String ip) {
if (ip.indexOf(".") >= 0 && ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.468` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/470. 用 Rand7() 实现 Rand10()（中等）.md | 470. 用 Rand7() 实现 Rand10() | https://leetcode-cn.com/problems/implement-rand10-using-rand7/solution/gong-shui-san-xie-k-jin-zhi-zhu-wei-shen-zmd4/ | 中等 | [
"位运算",
"数学"
] | 已有方法 rand7 可生成 1 到 7 范围内的均匀随机整数,试写一个方法 rand10 生成 1 到 10 范围内的均匀随机整数。
不要使用系统的 Math.random() 方法。
示例 1:
```
输入: 1
输出: [7]
```
示例 2:
```
输入: 2
输出: [8,4]
```
示例 3:
```
输入: 3
输出: [8,1,10]
```
提示:
1. rand7 已定义。
2. 传入参数: n 表示 rand10 的调用次数。
进阶:
* rand7()调用次数的 期望值 是多少 ?
* 你能否尽量少调用 rand7() ? | ### 基本分析
给定一个随机生成 $1$ ~ $7$ 的函数,要求实现等概率返回 $1$ ~ $10$ 的函数。
首先需要知道,在输出域上进行定量整体偏移,仍然满足等概率,即要实现 $0$ ~ $6$ 随机器,只需要在 `rand7` 的返回值上进行 $-1$ 操作即可。
但输出域的 拼接/叠加 并不满足等概率。例如 `rand7() + rand7()` 会产生 $[2, 14]$ 范围内的数,但每个数并非等概率:
* 产生 $2$ 的概率为:$\frac{1}{7} * \frac{1}{7} = \frac{1}{49}$
* 产生 $4$ 的概率为:$\frac{1}{7} * \frac{1}{7} + \fra... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.470` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/472. 连接词（困难）.md | 472. 连接词 | https://leetcode-cn.com/problems/concatenated-words/solution/gong-shui-san-xie-xu-lie-dpzi-fu-chuan-h-p7no/ | 困难 | [
"字符串哈希",
"序列 DP"
] | 给你一个 不含重复 单词的字符串数组 `words` ,请你找出并返回 `words` 中的所有 连接词 。
连接词 定义为:一个完全由给定数组中的至少两个较短单词组成的字符串。
示例 1:
```
输入:words = ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]
输出:["catsdogcats","dogcatsdog","ratcatdogcat"]
解释:"catsdogcats" 由 "cats", "dog" 和 "cats" 组成;
"dogcatsdog" 由 "dog"... | ### 序列 DP + 字符串哈希
给定数组 $words$,先考虑如何判断某个 $s = words[i]$ 是否为「连接词」。
为了方便,我们称组成 `s` 的每个连接部分为 `item`。
举个 🌰,例如 `s = abc`,其可能的 `item` 组合为 `a` 和 `bc`。
判断单个字符串是否为连接词可使用动态规划求解:**定义 $f[i]$ 为考虑 `s` 的前 $i$ 个字符(令下标从 $1$ 开始),能够切分出的最大 `item` 数的个数。**
这里之所以采用「记录 $f[i]$ 为最大分割 `item` 数(`int` 类型动规数组)」,而不是「记录 $f[i]$ 为是否可由多个 `item` 组成... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.472` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/473. 火柴拼正方形（中等）.md | 473. 火柴拼正方形 | https://leetcode.cn/problems/matchsticks-to-square/solution/by-ac_oier-k8i7/ | 中等 | [
"剪枝",
"DFS",
"爆搜",
"模拟退火",
"启发式搜索",
"随机化"
] | 你将得到一个整数数组 `matchsticks`,其中 $matchsticks[i]$ 是第 `i` 个火柴棒的长度。你要用 所有的火柴棍 拼成一个正方形。
你 不能折断 任何一根火柴棒,但你可以把它们连在一起,而且每根火柴棒必须 使用一次 。
如果你能使这个正方形,则返回 `true`,否则返回 `false`。
示例 1:
```
输入: matchsticks = [1,1,2,2,2]
输出: true
解释: 能拼成一个边长为2的正方形,每边两根火柴。
```
示例 2:
```
输入: matchsticks = [3,3,3,3,4]
输出: false
解释: 不能用所有火柴拼成一个正方形。
```... | > 祝大家儿童节快乐,永葆童心,一直善良 😊 ~
### DFS 剪枝
为了方便,我们称 `matchsticks` 为 `ms`。
数据范围为 $n = 15$,朴素的 `DFS` 爆搜(搜索过程中维护一个大小为 $4$ 的数组 `cur`,数组中的每一位代表正方形一条边长所使用到的火柴总长度,若最终数组中每一位均等于 $t = \frac{\sum_{i = 0}^{n - 1}ms[i]}{4}$,代表存在合法方案)复杂度为 $4^n$,会 `TLE`。
我们考虑如何进行「剪枝」。
首先一个较为明显的剪枝操作是进行「可行性剪枝」:我们在决策 $ms[idx]$ 时,如果将其累加到某个 $cur[i]$ 之后,会导... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.472` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/474. 一和零（中等）.md | 474. 一和零 | https://leetcode-cn.com/problems/ones-and-zeroes/solution/gong-shui-san-xie-xiang-jie-ru-he-zhuan-174wv/ | 中等 | [
"01 背包",
"背包问题",
"多维背包",
"动态规划"
] | 给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的大小,该子集中 最多 有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素,集合 x 是集合 y 的 子集 。
示例 1:
```
输入:strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出:4
解释:最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ,因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意,因为... | ### (多维)01 背包
通常与「背包问题」相关的题考察的是 **将原问题转换为「背包问题」的能力**。
要将原问题转换为「背包问题」,往往需要从题目中抽象出「价值」与「成本」的概念。
这道题如果抽象成「背包问题」的话,应该是:
**每个字符串的价值都是 1(对答案的贡献都是 1),选择的成本是该字符串中 1 的数量和 0 的数量。**
问我们在 1 的数量不超过 $m$,0 的数量不超过 $n$ 的条件下,最大价值是多少。
由于每个字符串只能被选一次,且每个字符串的选与否对应了「价值」和「成本」,求解的问题也是「最大价值」是多少。
因此可以直接套用 01 背包的「状态定义」来做:
**$f[k][i][j]$ 代... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.474` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/475. 供暖器（中等）.md | 475. 供暖器 | https://leetcode-cn.com/problems/heaters/solution/gong-shui-san-xie-er-fen-shuang-zhi-zhen-mys4/ | 中等 | [
"排序",
"二分",
"双指针"
] | 冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
在加热器的加热半径范围内的每个房屋都可以获得供暖。
现在,给出位于一条水平线上的房屋 `houses` 和供暖器 `heaters` 的位置,请你找出并返回可以覆盖所有房屋的最小加热半径。
说明:所有供暖器都遵循你的半径标准,加热的半径也一样。
示例 1:
```
输入: houses = [1,2,3], heaters = [2]
输出: 1
解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1,那么所有房屋就都能得到供暖。
```
示例 2:
```
输入: houses = [1,2,3,4], heaters = [1,4]
输出... | ### 二分 + 双指针
需要求得最小加热半径 $ans$,使得所有的 $houses[i]$ 均被覆盖。
在以 $ans$ 为分割点的数轴上具有「二段性」:
* 数值小于 $ans$ 的半径无法覆盖所有的房子;
* 数值大于等于 $ans$ 的半径可以覆盖所有房子。
因此可直接「二分答案」,考虑应该在什么范围内进行「二分」。
可以从数据范围入手,使用 $1e9$ 为二分上界,该做法能确保答案在二分范围内。
考虑如何实现 `check` 函数。
先对 $houses$ 和 $heaters$ 进行排序,使用 $i$ 指向当前处理到的 $houses[i]$;$j$ 指向 **可能** 覆盖到 $houses[i]$ 的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.475` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/476. 数字的补数（简单）.md | 476. 数字的补数 | https://leetcode-cn.com/problems/number-complement/solution/gong-shui-san-xie-yi-ti-shuang-jie-bian-wjl0y/ | 简单 | [
"模拟",
"位运算"
] | 对整数的二进制表示取反(`0` 变 `1` ,`1` 变 `0`)后,再转换为十进制表示,可以得到这个整数的补数。
* 例如,整数 `5` 的二进制表示是 `"101"` ,取反后得到 `"010"` ,再转回十进制表示得到补数 2 。
给你一个整数 `num`,输出它的补数。
示例 1:
```
输入:num = 5
输出:2
解释:5 的二进制表示为 101(没有前导零位),其补数为 010。所以你需要输出 2 。
```
示例 2:
```
输入:num = 1
输出:0
解释:1 的二进制表示为 1(没有前导零位),其补数为 0。所以你需要输出 0 。
```
提示:
* $1 <= num < 2^{31}$ | ### 模拟(遍历)
返回对 $num$ 的二进制表示取反的数,注意 $num$ 的二进制表示是不包含前导零的。
因此主要问题求得 $num$ 最高位 $1$ 的位置。
一个简单的做法是:先对 $num$ 进行「从高到低」的检查,找到最高位 $1$ 的位置 $s$,然后再对 $num$ 进行遍历,将低位到 $s$ 位的位置执行逐位取反操作。
代码:
```Java
class Solution {
public int findComplement(int num) {
int s = -1;
for (int i = 31; i >= 0; i--) {
if... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.476` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/477. 汉明距离总和（中等）.md | 477. 汉明距离总和 | https://leetcode-cn.com/problems/total-hamming-distance/solution/gong-shui-san-xie-ying-yong-cheng-fa-yua-g21t/ | 中等 | [
"位运算",
"数学"
] | 两个整数的 汉明距离 指的是这两个数字的二进制数对应位不同的数量。
给你一个整数数组 nums,请你计算并返回 nums 中任意两个数之间汉明距离的总和。
示例 1:
```
输入:nums = [4,14,2]
输出:6
解释:在二进制表示中,4 表示为 0100 ,14 表示为 1110 ,2表示为 0010 。(这样表示是为了体现后四位之间关系)
所以答案为:
HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6
```
示例 2:
```
输入:nums = [4,14,4]
输出:4
```
... | ### 按位统计
我们知道,汉明距离为两数二进制表示中不同位的个数,同时每位的统计是相互独立的。
即最终的答案为 $\sum_{x = 0}^{31} calc(x)$,其中 $calc$ 函数为求得所有数二进制表示中的某一位 $x$ 所产生的不同位的个数。
我们考虑某个 $cacl(x)$ 如何求得:
事实上,对于某个 `nums[i]` 我们只关心在 `nums` 中有多少数的第 $x$ 位的与其不同,而不关心具体是哪些数与其不同,同时二进制表示中非 $0$ 即 $1$。
**这指导我们可以建立两个集合 $s0$ 和 $s1$,分别统计出 `nums` 中所有数的第 $x$ 位中 $0$ 的个数和 $1$ 的个数,集合... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.477` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/478. 在圆内随机生成点（中等）.md | 478. 在圆内随机生成点 | https://leetcode.cn/problems/generate-random-point-in-a-circle/solution/by-ac_oier-btkm/ | 中等 | [
"数学",
"随机化"
] | 给定圆的半径和圆心的位置,实现函数 `randPoint`,在圆中产生均匀随机点。
实现 `Solution` 类:
* `Solution(double radius, double x_center, double y_center)` 用圆的半径 `radius` 和圆心的位置 $(x_center, y_center)$ 初始化对象
* `randPoint()` 返回圆内的一个随机点。圆周上的一点被认为在圆内。答案作为数组返回 $[x, y]$ 。
示例 1:
```
输入:
["Solution","randPoint","randPoint","randPoint"]
[[1.0, 0.0, 0.0], [], ... | ### 等概率随机采样
为了方便,我们称圆心为 $(x, y)$,半径为 $r$。
对给定圆内的点进行等概率随机采样,容易想到随机化两个信息:一个是距离圆心的距离 `len`(在范围 $[0, r]$ 中进行随机),另外一个是夹角 `ang`(在范围 $[0, 2\pi]$ 中随机,随便找个参考线即可,例如以往 $x$ 轴正方向的射线为参考)。
然后根据 `len` 和 `ang` 直接计算对应的点的坐标,这样 **可以确保随机出来的点一定在圆内,但并非「等概率」。**
在不考虑夹角的情况下,我们本质是在 $[0, r]$ 范围内随机,这在「一维」上「等概率」是成立的,因为满足「任意连续段中点被抽到的次数与总次数的比例」与「... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.478` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/479. 最大回文数乘积（困难）.md | 479. 最大回文数乘积 | https://leetcode-cn.com/problems/largest-palindrome-product/solution/by-ac_oier-t8j7/ | 困难 | [
"枚举",
"数学"
] | 给定一个整数 $n$ ,返回 可表示为两个 $n$ 位整数乘积的 最大回文整数 。
因为答案可能非常大,所以返回它对 $1337$ 取余 。
示例 1:
```
输入:n = 2
输出:987
解释:99 x 91 = 9009, 9009 % 1337 = 987
```
示例 2:
```
输入: n = 1
输出: 9
```
提示:
* $1 <= n <= 8$ | ### 枚举 + 数学
对于数位为 $n$ 的两个数而言,其乘积的位数要么是 $2 * n$,要么是 $2 * n - 1$。
当数位 $n > 1$ 时,我们总能在数位为 $2 * n$ 中找到答案。
利用回文串的特性,我们只需枚举回文串的前半部分即可(后半部分唯一确定),我们只要在枚举前半部分时按照「从大到小」进行,即可确保找到的第一个合法值为最大数,对于一个数位为 $n$ 的最大数为 $10^n - 1$。
具体的,当枚举到回文串的前半部分 $i$ 时,我们利用回文串特性构造出具实际的回文数值 $nums$,随后检查 $nums$ 能否分解成数位为 $n$ 的数对 $(a, b)$,利用乘法具有交换律,我们只需要枚举数... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.479` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/480. 滑动窗口中位数（困难）.md | 480. 滑动窗口中位数 | https://leetcode-cn.com/problems/sliding-window-median/solution/xiang-jie-po-su-jie-fa-you-xian-dui-lie-mo397/ | 困难 | [
"滑动窗口",
"优先队列(堆)"
] | 中位数是有序序列最中间的那个数。如果序列的长度是偶数,则没有最中间的数;此时中位数是最中间的两个数的平均数。
例如:
* $[2,3,4]$,中位数是 $3$
* $[2,3]$,中位数是 $(2 + 3) / 2 = 2.5$
给你一个数组 $nums$,有一个长度为 $k$ 的窗口从最左端滑动到最右端。
窗口中有 $k$ 个数,每次窗口向右移动 $1$ 位。
你的任务是找出每次窗口移动后得到的新窗口中元素的中位数,并输出由它们组成的数组。
示例:
```
给出 nums = [1,3,-1,-3,5,3,6,7],以及 k = 3。
窗口位置 中位数
-----------... | ### 朴素解法
一个直观的做法是:对每个滑动窗口的数进行排序,获取排序好的数组中的第 $\frac{k}{2}$ 和 $\frac{k - 1}{2}$ 个数(避免奇偶数讨论),计算中位数。
我们大概分析就知道这个做法至少 $O(n * k)$ 的,算上排序的话应该是 $O(n * (k + k\log{k}))$。
比较无奈的是,这道题的中文说明中没有给出数据范围。我们无法根据判断这样的做法会不会超时。
朴素做法通常是优化的开始,所以还是提供一下朴素做法的代码。
代码:
```Java
class Solution {
public double[] medianSlidingWindow(int[] nums... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.480` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/481. 神奇字符串（中等）.md | 481. 神奇字符串 | https://leetcode.cn/problems/magical-string/solution/by-ac_oier-7wjo/ | 中等 | [
"模拟",
"构造",
"双指针",
"打表"
] | 神奇字符串 `s` 仅由 `'1'` 和 `'2'` 组成,并需要遵守下面的规则:
* 神奇字符串 `s` 的神奇之处在于,串联字符串中 `'1'` 和 `'2'` 的连续出现次数可以生成该字符串。
`s` 的前几个元素是 `s = "1221121221221121122......"` 。如果将 `s` 中连续的若干 `1` 和 `2` 进行分组,可以得到 `"1 22 11 2 1 22 1 22 11 2 11 22 ......"` 。
每组中 `1` 或者 `2` 的出现次数分别是 `"1 2 2 1 1 2 1 2 2 1 2 2 ......"` 。上面的出现次数正是 `s` 自身。
给你一个整数 `n` ,... | ### 双指针 + 构造 + 打表
我们将相关的字符串分为三类:**题目描述的神奇字符串 `s` 称为“原串”,对 `s` 进行连续段划分所得的串叫“划分串”,对划分串进行计数的串叫“计数串”**。
解题的核心思路:**由于划分串是对原串的划分,同时计数串又与原串相同,因此可得三类串均只有 `1` 和 `2` 两种数值。即可知划分串的每段长度只能是「长度为 `1`」或「长度为 `2`」,利用划分串的每段构造长度有限,我们可以通过「简单分情况讨论」的方式进行构造**。
具体的,我们需要利用「原串和计数串的相同的性质」对 `s` 进行构造:不难发现计数串总是不长于原串,因此我们可以使用变量 `i` 来记录当前构造到原串位置,使用变... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.481` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/482. 密钥格式化（简单）.md | 482. 密钥格式化 | https://leetcode-cn.com/problems/license-key-formatting/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-piya/ | 简单 | [
"模拟"
] | 有一个密钥字符串 `S`,只包含字母,数字以及 `'-'`(破折号)。其中,`N` 个 `'-'` 将字符串分成了 `N+1` 组。
给你一个数字 `K`,请你重新格式化字符串,使每个分组恰好包含 `K` 个字符。特别地,第一个分组包含的字符个数必须小于等于 `K`,但至少要包含 `1` 个字符。两个分组之间需要用 `'-'`(破折号)隔开,并且将所有的小写字母转换为大写字母。
给定非空字符串 `S` 和数字 `K`,按照上面描述的规则进行格式化。
示例 1:
```
输入:S = "5F3Z-2e-9-w", K = 4
输出:"5F3Z-2E9W"
解释:字符串 S 被分成了两个部分,每部分 4 个字符;
注... | ### 模拟
简单字符串模拟,从后往前处理,避免对首个分区的分情况讨论和取余操作。
代码:
```Java
class Solution {
public String licenseKeyFormatting(String s, int k) {
StringBuilder sb = new StringBuilder();
for (int i = s.length() - 1, cnt = 0; i >= 0; i--) {
if (s.charAt(i) == '-') continue;
if (cnt == k && (cnt =... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.482` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/483. 最小好进制（困难）.md | 483. 最小好进制 | https://leetcode-cn.com/problems/smallest-good-base/solution/gong-shui-san-xie-xiang-jie-ru-he-fen-xi-r94g/ | 困难 | [
"数学",
"推公式"
] | 对于给定的整数 n, 如果n的k(k>=2)进制数的所有数位全为1,则称 k(k>=2)是 n 的一个好进制。
以字符串的形式给出 n, 以字符串的形式返回 n 的最小好进制。
示例 1:
```
输入:"13"
输出:"3"
解释:13 的 3 进制是 111。
```
示例 2:
```
输入:"4681"
输出:"8"
解释:4681 的 8 进制是 11111。
```
示例 3:
```
输入:"1000000000000000000"
输出:"999999999999999999"
解释:1000000000000000000 的 999999999999999999 进制是 11。
```
提示:
* n的取值范... | ### 基本分析
设 $(n)_{10}$ 的 $k$ 进制表示共有 $Len$ 位,那么根据「进制转换」相关知识,必然有如下等式:
$$
(n)_{10} = (11...11)_{k} = k^0 + k^1 + k^2 + ... + k^{Len - 1}
$$
当 $n$ 给定的情况下,$k$ 随着 $Len$ 减小而增大,由此我们可以分析出 $k$ 的上界:
* 当 $Len$ 取 $1$ 的时候:$k^0 = n$,即 $n = 1$,与题目给定的数据范围冲突,不可取;
* 当 $Len$ 取 $2$ 的时候:$k^0 + k^1 = n$,即 $k = n - 1$,为合法值。
**因此 $k$ 的上界为... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.483` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/485. 最大连续 1 的个数（简单）.md | 485. 最大连续 1 的个数 | https://leetcode-cn.com/problems/max-consecutive-ones/solution/you-shi-yi-tian-gao-pin-jian-dan-ti-ni-d-avj1/ | 简单 | [
"双指针"
] | 给定一个二进制数组, 计算其中最大连续 1 的个数。
示例:
```
输入:[1,1,0,1,1,1]
输出:3
解释:开头的两位和最后的三位都是连续 1 ,所以最大连续 1 的个数是 3.
```
提示:
* 输入的数组只包含 0 和 1 。
* 输入数组的长度是正整数,且不超过 10,000。 | ### 双指针解法
使用 `i` 和 `j` 分别代表连续 1 的左右边界。
起始状态 `i == j`,当 `i` 到达第一个 1 的位置时,让 `j` 不断右移直到右边界。
更新 `ans`
```java
class Solution {
public int findMaxConsecutiveOnes(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0, j = 0; i < n; j = i) {
if (nums[i] == 1) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.485` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/488. 祖玛游戏（困难）.md | 488. 祖玛游戏 | https://leetcode-cn.com/problems/zuma-game/solution/gong-shui-san-xie-yi-ti-shuang-jie-sou-s-3ftb/ | 困难 | [
"DFS",
"搜索",
"启发式搜索",
"AStar 算法"
] | 你正在参与祖玛游戏的一个变种。
在这个祖玛游戏变体中,桌面上有 一排 彩球,每个球的颜色可能是:红色 `'R'`、黄色 `'Y'`、蓝色 `'B'`、绿色 `'G'` 或白色 `'W'` 。你的手中也有一些彩球。
你的目标是 清空 桌面上所有的球。每一回合:
* 从你手上的彩球中选出 任意一颗 ,然后将其插入桌面上那一排球中:两球之间或这一排球的任一端。
* 接着,如果有出现 三个或者三个以上 且 颜色相同 的球相连的话,就把它们移除掉。
* 如果这种移除操作同样导致出现三个或者三个以上且颜色相同的球相连,则可以继续移除这些球,直到不再满足移除条件。
* 如果桌面上所有球都被移除,则认为你赢得本场游戏。
* 重复这个过程,直... | ### 搜索 + 剪枝
数据范围 $1 <= board.length <= 16$ 和 $1 <= hand.length <= 5$。
为了方便,我们使用 $a$ 和 $b$ 来代指 $board$ 和 $hand$。
但在爆搜过程中同时维持两个字符串构造会超时,考虑使用一个 `int` 来记录 $hand$ 的使用情况。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
String b;
int m;
Map<String, Integer> map = new HashMap<>();
public int findMinS... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.488` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/492. 构造矩形（简单）.md | 492. 构造矩形 | https://leetcode-cn.com/problems/construct-the-rectangle/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-7ser/ | 简单 | [
"模拟"
] | 作为一位web开发者, 懂得怎样去规划一个页面的尺寸是很重要的。 现给定一个具体的矩形页面面积,你的任务是设计一个长度为 L 和宽度为 W 且满足以下要求的矩形的页面。要求:
1. 你设计的矩形页面必须等于给定的目标面积。
2. 宽度 W 不应大于长度 L,换言之,要求 L >= W 。
3. 长度 L 和宽度 W 之间的差距应当尽可能小。
你需要按顺序输出你设计的页面的长度 L 和宽度 W。
示例:
```
输入: 4
输出: [2, 2]
解释: 目标面积是 4, 所有可能的构造方案有 [1,4], [2,2], [4,1]。
但是根据要求2,[1,4] 不符合要求; 根据要求3,[2,2] 比 [4,1] 更能符... | ### 模拟
根据题意,从 $\sqrt{area}$ 开始往后模拟,遇到第一个能够被整除的数值,则返回该答案。
代码:
```Java
class Solution {
public int[] constructRectangle(int area) {
for (int i = (int)(Math.sqrt(area)); ;i--) {
if (area % i == 0) return new int[]{area / i, i};
}
}
}
```
* 时间复杂度:$O(\sqrt{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.492` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/494. 目标和（中等）.md | 494. 目标和 | https://leetcode-cn.com/problems/target-sum/solution/gong-shui-san-xie-yi-ti-si-jie-dfs-ji-yi-et5b/ | 中等 | [
"DFS",
"记忆化搜索",
"背包 DP",
"01 背包"
] | 给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 '+' 或 '-' ,然后串联起所有整数,可以构造一个 表达式 :
* 例如,nums = [2, 1] ,可以在 2 之前添加 '+' ,在 1 之前添加 '-' ,然后串联起来得到表达式 "+2-1" 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
示例 1:
```
输入:nums = [1,1,1,1,1], target = 3
输出:5
解释:一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1... | ### DFS
数据范围只有 $20$,而且每个数据只有 $+/-$ 两种选择,因此可以直接使用 DFS 进行「爆搜」。
而 DFS 有「使用全局变量维护」和「接收返回值处理」两种形式。
代码:
```Java
class Solution {
public int findTargetSumWays(int[] nums, int t) {
return dfs(nums, t, 0, 0);
}
int dfs(int[] nums, int t, int u, int cur) {
if (u == nums.length) {
return... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.494` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/495. 提莫攻击（简单）.md | 495. 提莫攻击 | https://leetcode-cn.com/problems/teemo-attacking/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-gteh/ | 简单 | [
"模拟"
] | 在《英雄联盟》的世界中,有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希(编者注:寒冰射手)进入中毒状态。
当提莫攻击艾希,艾希的中毒状态正好持续 `duration` 秒。
正式地讲,提莫在 `t` 发起发起攻击意味着艾希在时间区间 `[t, t + duration - 1]`(含 `t` 和 `t + duration - 1`)处于中毒状态。如果提莫在中毒影响结束 前 再次攻击,中毒状态计时器将会 重置 ,在新的攻击之后,中毒影响将会在 `duration` 秒后结束。
给你一个 非递减 的整数数组 `timeSeries`,其中 `timeSeries[i]` 表示提莫在 `timeSeries[i]` 秒时对... | ### 模拟
题目已确保 $timeSeries$ 为非递减排序,按照顺序进行遍历处理即可。
我们使用 $ans$ 统计答案,使用 $last$ 记录上一次攻击的结束点,对于任意的 $timeSeries[i]$ 而言,假设其发起点为 $s = timeSeries[i]$,结束点为 $e = s + duration - 1$,针对 $last$ 和 $s$ 进行分情况讨论即可:
* $last < s$ :两次攻击不重合,则有 $ans += duration; last = e;$
* $last >= s$ :两次攻击重合,则有 $ans += e - last; last = e$
>注意:$last$ 作为上次的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.495` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/496. 下一个更大元素 I（简单）.md | 496. 下一个更大元素 I | https://leetcode-cn.com/problems/next-greater-element-i/solution/gong-shui-san-xie-yi-ti-shuang-jie-bian-n6nwz/ | 简单 | [
"模拟",
"单调栈",
"哈希表"
] | 给你两个 没有重复元素 的数组 `nums1` 和 `nums2`,其中 `nums1` 是 `nums2` 的子集。
请你找出 `nums1` 中每个元素在 `nums2` 中的下一个比其大的值。
`nums1` 中数字 `x` 的下一个更大元素是指 `x` 在 `nums2` 中对应位置的右边的第一个比 `x` 大的元素。如果不存在,对应位置输出 $-1$ 。
示例 1:
```
输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
对于 num1 中的数字 4 ,你无法在第二个数组中找到下一个更大的数字,因此输出 -1 。
对于 num1 中的数字 1 ,... | ### 模拟
一个朴素的做法是直接根据题意进行模拟,对于每个 $ans[i]$ 而言,先找到 $nums1[i]$ 在 $nums2$ 的位置 $j$,然后接着往后找到最近一个比其大的数,如果 $j$ 走到结尾尚未出现合法的 $ans[i]$,则是 $-1$。
代码:
```Java
class Solution {
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
int[] ans = new int[n];
for (i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.496` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/497. 非重叠矩形中的随机点（中等）.md | 497. 非重叠矩形中的随机点 | https://leetcode.cn/problems/random-point-in-non-overlapping-rectangles/solution/by-ac_oier-mhi6/ | 中等 | [
"前缀和",
"二分",
"随机化"
] | 给定一个由非重叠的轴对齐矩形的数组 `rects`,其中 $rects[i] = [a_i, b_i, x_i, y_i]$ 表示 $(a_i, b_i)$ 是第 $i$ 个矩形的左下角点,$(x_i, y_i)$ 是第 $i$ 个矩形的右上角点。
设计一个算法来随机挑选一个被某一矩形覆盖的整数点。矩形周长上的点也算做是被矩形覆盖。所有满足要求的点必须等概率被返回。
在给定的矩形覆盖的空间内的任何整数点都有可能被返回。
请注意 ,整数点是具有整数坐标的点。
实现 `Solution` 类:
* `Solution(int[][] rects)` 用给定的矩形数组 `rects` 初始化对象。
* `int[] pick()`... | ### 前缀和 + 二分
为了方便,我们使用 `rs` 来代指 `rects`,定义某个矩阵内整数点的数量为「面积」。
一个朴素的想法是「先随机使用哪个矩形,再随机该矩形内的点」,其中后者是极其容易的,根据矩形特质,只需在该矩形的 `XY` 坐标范围内随机即可确保等概率,而前者(随机使用哪个矩形)为了确保是等概率,我们不能简单随机坐标,而需要结合面积来做。
具体的,我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),其中 $sum[i]$ 代表前 $i$ 个矩形的面积之和(即下标范围 $[0, i - 1]$ 的面积总和),最终 $sum[n]$ 为所有矩形的总面积,我们可以在 $[1, sum[n]]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.497` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/498. 对角线遍历（中等）.md | 498. 对角线遍历 | https://leetcode.cn/problems/diagonal-traverse/solution/by-ac_oier-yw5x/ | 中等 | [
"模拟"
] | 给你一个大小为 `m x n` 的矩阵 `mat`,请以对角线遍历的顺序,用一个数组返回这个矩阵中的所有元素。
示例 1:
```
输入:mat = [[1,2,3],[4,5,6],[7,8,9]]
输出:[1,2,4,7,5,3,6,8,9]
```
示例 2:
```
输入:mat = [[1,2],[3,4]]
输出:[1,2,3,4]
```
提示:
* $m == mat.length$
* $n == mat[i].length$
* $1 <= m, n <= 10^4$
* $1 <= m \times n <= 10^4$
* $-10^5 <= mat[i][j] <= 10^5$ | ### 模拟
根据题意进行模拟即可。
为了方便,令 `mat` 为 `g`,记 `g` 的行和宽分别为 $n$ 和 $m$。当前所在位置为 $(x, y)$,遍历方向使用 $dir$ 代指(当 $dir = 1$ 代表往右上方进行遍历,当 $dir = -1$ 代表往左下方进行遍历),使用 $idx$ 记录当前处理到的答案下标。
每次除了将当前格子放入答案(`ans[idx++]=g[x][y]`)以外,还需要结合 $dir$ 找到当前位置的右上方格子 $(x - 1, y + 1)$ 或是左下方格子 $(x + 1, y - 1)$,若下一目标位置「越界」并且还没搜索完整个矩阵,我们需要根据优先级来找「下一个发起点」的位置,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.498` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/500. 键盘行（简单）.md | 500. 键盘行 | https://leetcode-cn.com/problems/keyboard-row/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-zx6b/ | 简单 | [
"模拟",
"哈希表"
] | 给你一个字符串数组 `words`,只返回可以使用在 美式键盘 同一行的字母打印出来的单词。键盘如下图所示。
美式键盘 中:
* 第一行由字符 `"qwertyuiop"` 组成。
* 第二行由字符 `"asdfghjkl"` 组成。
* 第三行由字符 `"zxcvbnm"` 组成。
示例 1:
```
输入:words = ["Hello","Alaska","Dad","Peace"]
输出:["Alaska","Dad"]
```
示例 2:
```
输入:words = ["omk"]
输出:[]
```
示例 3:
```
输入:words = ["adsdf","sfd"]
输出:["adsdf","sfd"... | ### 模拟
根据题意,进行模拟即可。
先将键盘上的三行字母进行打表分类,依次检查 $words$ 中的单词中的每个字符是否都属于同一编号,若属于同一编号,则将其单词加入答案。
代码:
```Java
class Solution {
static String[] ss = new String[]{"qwertyuiop", "asdfghjkl", "zxcvbnm"};
static int[] hash = new int[26];
static {
for (int i = 0; i < ss.length; i++) {
for (char c : ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.500` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/502. IPO（困难）.md | 502. IPO | https://leetcode-cn.com/problems/next-greater-element-ii/solution/cong-po-su-jie-fa-de-jiao-du-qu-li-jie-d-trht/ | 困难 | [
"贪心",
"优先队列(堆)"
] | 假设 力扣(LeetCode)即将开始 IPO 。
为了以更高的价格将股票卖给风险投资公司,力扣 希望在 IPO 之前开展一些项目以增加其资本。
由于资源有限,它只能在 IPO 之前完成最多 k 个不同的项目。
帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。
给你 n 个项目。对于每个项目 i ,它都有一个纯利润 profits[i] ,和启动该项目需要的最小资本 capital[i] 。
最初,你的资本为 w 。当你完成一个项目时,你将获得纯利润,且利润将被添加到你的总资本中。
总而言之,从给定项目中选择 最多 k 个不同项目的列表,以 最大化最终资本 ,并输出最终可获得的最多资本。
答案保证在 ... | ### 贪心 + 优先队列(堆)
由于每完成一个任务都会使得总资金 `w` 增加或不变。因此对于所选的第 $i$ 个任务而言,应该在所有「未被选择」且启动资金不超过 `w` 的所有任务里面选利润最大的。
**可通过「归纳法」证明每次都在所有候选中选择利润最大的任务,可使得总资金最大。**
对于第 $i$ 次选择而言(当前所有的资金为 $w$),如果选择的任务利润为 $cur$,而实际可选的最大任务利润为 $max$( $cur <= max$ )。
将「选择 $cur$」调整为「选择 $max$」,结果不会变差:
1. 根据传递性,由 $cur <= max$ 可得 $w + cur <= w + max$,可推导出调整后... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.502` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/503. 下一个更大元素 II（中等）.md | 503. 下一个更大元素 II | https://leetcode-cn.com/problems/next-greater-element-ii/solution/cong-po-su-jie-fa-de-jiao-du-qu-li-jie-d-trht/ | 中等 | [
"单调栈"
] | 给定一个循环数组(最后一个元素的下一个元素是数组的第一个元素),输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序,这个数字之后的第一个比它更大的数,这意味着你应该循环地搜索它的下一个更大的数。如果不存在,则输出 -1。
示例 1:
```
输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2;
数字 2 找不到下一个更大的数;
第二个 1 的下一个最大的数需要循环搜索,结果也是 2。
``` | ### 单调栈解法
对于「找最近一个比当前值大/小」的问题,都可以使用单调栈来解决。
单调栈就是在栈的基础上维护一个栈内元素单调。
在理解单调栈之前,我们先回想一下「朴素解法」是如何解决这个问题的。
对于每个数而言,我们需要遍历其右边的数,直到找到比自身大的数,这是一个 $O(n^2)$ 的做法。
**之所以是 $O(n^2)$,是因为每次找下一个最大值,我们是通过「主动」遍历来实现的。**
而如果使用的是单调栈的话,可以做到 $O(n)$ 的复杂度,我们**将当前还没得到答案的下标暂存于栈内,从而实现「被动」更新答案。**
也就是说,栈内存放的永远是还没更新答案的下标。
具体的做法是:
每次将当前遍历到的下标存入... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.501` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/504. 七进制数（简单）.md | 504. 七进制数 | https://leetcode-cn.com/problems/base-7/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-2759/ | 简单 | [
"模拟"
] | 给定一个整数 `num`,将其转化为 $7$ 进制,并以字符串形式输出。
示例 1:
```
输入: num = 100
输出: "202"
```
示例 2:
```
输入: num = -7
输出: "-10"
```
提示:
* $-10^7 <= num <= 10^7$ | ### 模拟
今天是个特别的日子,可惜是个简单题 QWQ
按照通用的进制转换方式进行模拟即可。
代码:
```Java
class Solution {
public String convertToBase7(int n) {
boolean flag = n < 0;
if (flag) n = -n;
StringBuilder sb = new StringBuilder();
do {
sb.append(n % 7);
n /= 7;
} while (n != 0);
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.504` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/506. 相对名次（简单）.md | 506. 相对名次 | https://leetcode-cn.com/problems/relative-ranks/solution/gong-shui-san-xie-jian-dan-pai-xu-mo-ni-cmuzj/ | 简单 | [
"排序",
"模拟"
] | 给你一个长度为 `n` 的整数数组 `score`,其中 `score[i]` 是第 $i$ 位运动员在比赛中的得分。所有得分都**互不相同**。
运动员将根据得分**决定名次**,其中名次第 `1` 的运动员得分最高,名次第 `2` 的运动员得分第 `2` 高,依此类推。运动员的名次决定了他们的获奖情况:
* 名次第 `1` 的运动员获金牌 `"Gold Medal"` 。
* 名次第 `2` 的运动员获银牌 `"Silver Medal"`。
* 名次第 `3` 的运动员获铜牌 `"Bronze Medal"`。
* 从名次第 `4` 到第 `n` 的运动员,只能获得他们的名次编号(即,名次第 x 的运动员获得编号 `"x"`... | ### 模拟
根据题意,我们可以先对 `score` 数组进行拷贝并排序,利用分数各不相同,对排序数组中分值进行名次编号(存入哈希表),再利用名次编号构造答案。
代码:
```Java
class Solution {
String[] ss = new String[]{"Gold Medal", "Silver Medal", "Bronze Medal"};
public String[] findRelativeRanks(int[] score) {
int n = score.length;
String[] ans = new String[n];
i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.506` 篇,系列开始于 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.