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/21-30/30. 串联所有单词的子串（困难）.md | 30. 串联所有单词的子串 | https://leetcode.cn/problems/substring-with-concatenation-of-all-words/solution/by-ac_oier-enjd/ | 困难 | [
"哈希表",
"滑动窗口",
"枚举"
] | 给定一个字符串 `s` 和一些长度相同的单词 `words`。
找出 `s` 中恰好可以由 `words` 中所有单词串联形成的子串的起始位置。
注意子串要与 `words` 中的单词完全匹配,中间不能有其他字符,但不需要考虑 `words` 中单词串联的顺序。
示例 1:
```
输入:
s = "barfoothefoobarman",
words = ["foo","bar"]
输出:[0,9]
解释:
从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。
输出的顺序不重要, [9,0] 也是有效答案。
```
示例 2:
```
输入:
s = "wordgoodgoodgoodbe... | ### 朴素哈希表
令 `n` 为字符串 `s` 的长度,`m` 为数组 `words` 的长度(单词的个数),`w` 为单个单词的长度。
由于 `words` 里面每个单词长度固定,而我们要找的字符串只能恰好包含所有的单词,因此我们要找的目标子串的长度为 $m \times w$。
那么一个直观的思路是:
1. 使用哈希表 `map` 记录 `words` 中每个单词的出现次数
2. 枚举 `s` 中的每个字符作为起点,往后取得长度为 $m \times w$ 的子串 `sub`
3. 使用哈希表 `cur ` 统计 `sub` 每个单词的出现次数(每隔 `w` 长度作为一个单词)
4. 比较 `cur` 和 `map` ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.30` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2101-2110/2103. 环和杆（简单）.md | 2103. 环和杆 | https://leetcode.cn/problems/rings-and-rods/solutions/2509056/gong-shui-san-xie-liang-ge-jiao-du-jin-x-r1v1/ | 简单 | [
"模拟",
"位运算"
] | 总计有 `n` 个环,环的颜色可以是红、绿、蓝中的一种。
这些环分别穿在 $10$ 根编号为 $0$ 到 $9$ 的杆上。
给你一个长度为 `2n` 的字符串 `rings`,表示这 `n` 个环在杆上的分布。
`rings` 中每两个字符形成一个 颜色位置对 ,用于描述每个环:
* 第 `i` 对中的 第一个 字符表示第 `i` 个环的 颜色(`'R'`、`'G'`、`'B'`)。
* 第 `i` 对中的 第二个 字符表示第 `i` 个环的 位置,也就是位于哪根杆上(`'0'` 到 `'9'`)。
例如,`"R3G2B1"` 表示:共有 $n = 3$ 个环,红色的环在编号为 $3$ 的杆上,绿色的环在编号为 $2$ 的... | ### 位运算 - 统计环
环的数量不定,但杆的数量就 $10$ 根。
我们可以从「环」的角度出发,进行统计。
用一个 `int` 来代表环的统计情况,根据题意,共有 `RGB` 三种颜色的环,共需要 $3$ 个 `int` 数(为了方便,代码直接开了大小为 $128$ 的数组)。
对于一个代表环的数值 $x$ 而言,从低位往高位数,若第 $k$ 位为 $1$,代表编号为 $k$ 的杆包含该颜色的环。
用示例 $1$ 来举个 🌰,`rings = "B0B6G0R6R0R6G9"`
* 红色:在 `0` 和 `6` 中出现过,对应数值 $x = (0001000001)_2$
* 蓝色:在 `0` 和 `6` 中出现... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2103` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2101-2110/2104. 子数组范围和（中等）.md | 2104. 子数组范围和 | https://leetcode-cn.com/problems/sum-of-subarray-ranges/solution/gong-shui-san-xie-yi-ti-san-jie-qu-jian-wn84z/ | 中等 | [
"区间 DP",
"单调栈"
] | 给你一个整数数组 `nums` 。`nums` 中,子数组的 **范围** 是子数组中最大元素和最小元素的差值。
返回 `nums` 中 **所有** 子数组范围的 **和** 。
子数组是数组中一个连续 **非空** 的元素序列。
示例 1:
```
输入:nums = [1,2,3]
输出:4
解释:nums 的 6 个子数组如下所示:
[1],范围 = 最大 - 最小 = 1 - 1 = 0
[2],范围 = 2 - 2 = 0
[3],范围 = 3 - 3 = 0
[1,2],范围 = 2 - 1 = 1
[2,3],范围 = 3 - 2 = 1
[1,2,3],范围 = 3 - 1 = 2
所有范围的和是 0 ... | ### 区间 DP(预处理)
数据范围为 $10^3$,最为朴素的三层循环为:枚举区间(左右端点)+ 扫描区间统计最值,并累加到答案中。该做法复杂度为 $O(n^3)$,会 `TLE`。
考虑在此基础上优化,枚举所有区间的操作不好避免,考虑通过「预处理」手段来优化「扫描区间统计最值」操作,通常会将其优化为 $O(1)$ 查表。
定义 $f[l][r][k]$ 为区间 $[l, r]$ 范围内的最值情况,其中 $k$ 非 $0$ 即 $1$:$f[l][r][0]$ 代表区间 $[l, r]$ 内的最小值,$f[l][r][1]$ 代表区间 $[l, r]$ 内的最大值。
不失一般性考虑 $f[l][r][0]$ 和 $f[l... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2104` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/211. 添加与搜索单词 - 数据结构设计（中等）.md | 211. 添加与搜索单词 - 数据结构设计 | https://leetcode-cn.com/problems/design-add-and-search-words-data-structure/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-un94/ | 中等 | [
"DFS",
"字典树"
] | 请你设计一个数据结构,支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。
实现词典类 `WordDictionary` :
* `WordDictionary()` 初始化词典对象
* `void addWord(word)` 将 `word` 添加到数据结构中,之后可以对它进行匹配
* `bool search(word)` 如果数据结构中存在字符串与 `word` 匹配,则返回 `true` ;否则,返回 `false`
* `word` 中可能包含一些 `'.'` ,每个 `.` 都可以表示任何一个字母。
示例:
```
输入:
["WordDictionary","addWord","addWord"... | ### 基本分析
一道 $Trie$ 的轻度变形模板题,还不熟悉 $Trie$ 的同学可以看 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=1006889101&lang=zh_CN#rd),里面详细介绍了实现 $Trie$ 的两种方式、注意事项以及 $Trie$ 应用面等等,是解... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.211` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/212. 单词搜索 II（困难）.md | 212. 单词搜索 II | https://leetcode-cn.com/problems/word-search-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hui-s-am8f/ | 困难 | [
"回溯算法",
"DFS",
"字典树"
] | 给定一个 $m x n$ 二维字符网格 $board$ 和一个单词(字符串)列表 $words$,找出所有同时在二维网格和字典中出现的单词。
单词必须按照字母顺序,通过 相邻的单元格 内的字母构成,其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。
示例 1:
```
输入:board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], words = ["oath","pea","eat","rain"]
输出:["eat","oath"]
```
示例 2:
```
... | ### 回溯算法
**数据范围只有 $12$,且 `words` 中出现的单词长度不会超过 $10$,可以考虑使用「回溯算法」。**
起始先将所有 `words` 出现的单词放到 `Set` 结构中,然后以 `board` 中的每个点作为起点进行爆搜(由于题目规定在一个单词中每个格子只能被使用一次,因此还需要一个 `vis` 数组来记录访问过的位置):
1. 如果当前爆搜到的字符串长度超过 $10$,直接剪枝;
2. 如果当前搜索到的字符串在 `Set` 中,则添加到答案(同时了防止下一次再搜索到该字符串,需要将该字符串从 `Set` 中移除)。
代码:
```Java
class Solution {
Set<St... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.212` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/213. 打家劫舍 II（中等）.md | 213. 打家劫舍 II | https://leetcode-cn.com/problems/house-robber-ii/solution/gong-shui-san-xie-ru-he-jiang-xin-xian-z-zf0w/ | 中等 | [
"线性 DP"
] | 你是一个专业的小偷,计划偷窃沿街的房屋,每间房内都藏有一定的现金。
这个地方所有的房屋都 围成一圈 ,这意味着第一个房屋和最后一个房屋是紧挨着的。
同时,相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组,计算你 在不触动警报装置的情况下 ,今晚能够偷窃到的最高金额。
示例 1:
```
输入:nums = [2,3,2]
输出:3
解释:你不能先偷窃 1 号房屋(金额 = 2),然后偷窃 3 号房屋(金额 = 2), 因为他们是相邻的。
```
示例 2:
```
输入:nums = [1,2,3,1]
输出:4
解释:你可以先偷... | ### 动态规划
在 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 中,并没有「第一间」和「最后一间」不能同时选择的限制,因此我们从头到尾做一遍 DP 即可。
在 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 中,我们可以将状态定义为两维:
**$f[i][j]$ 代表考虑前 $i$ 个房间,当前 $i$ 房间的现在状态为 $j$ 的最大价值。**
* $f[i][0]$ 代表考虑前 $i$ 个房间,并且「不选」第 $i$ 个房间的最大价值。由于已经明确了第 $i$ 个房间不选,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.213` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/215. 数组中的第K个最大元素（中等）.md | 215. 数组中的第K个最大元素 | https://leetcode.cn/problems/kth-largest-element-in-an-array/solution/by-ac_oier-x9h4/ | 中等 | [
"树状数组",
"二分",
"优先队列(堆)",
"快速选择"
] | 给定整数数组 `nums` 和整数 `k`,请返回数组中第 `k` 个最大的元素。
请注意,你需要找的是数组排序后的第 `k` 个最大的元素,而不是第 `k` 个不同的元素。
你必须设计并实现时间复杂度为 $O(n)$ 的算法解决此问题。
示例 1:
```
输入: [3,2,1,5,6,4], k = 2
输出: 5
```
示例 2:
```
输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4
```
提示:
* $1 <= k <= nums.length <= 10^5$
* $-10^4 <= nums[i] <= 10^4$ | ### 值域映射 + 树状数组 + 二分
除了直接对数组进行排序,取第 $k$ 位的 $O(n\log{n})$ 做法以外。
对于值域大小 小于 数组长度本身时,我们还能使用「树状数组 + 二分」的 $O(n\log{m})$ 做法,其中 $m$ 为值域大小。
首先值域大小为 $[-10^4, 10^4]$,为了方便,我们为每个 $nums[i]$ 增加大小为 $1e4 + 10$ 的偏移量,将值域映射到 $[10, 2 \times 10^4 + 10]$ 的空间。
将每个增加偏移量后的 $nums[i]$ 存入树状数组,考虑在 $[0, m)$ 范围内进行二分,假设我们真实第 $k$ 大的值为 $t$,那么在以 $t$ ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.215` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/218. 天际线问题（困难）.md | 218. 天际线问题 | https://leetcode-cn.com/problems/the-skyline-problem/solution/gong-shui-san-xie-sao-miao-xian-suan-fa-0z6xc/ | 困难 | [
"扫描线问题",
"优先队列(堆)"
] | 城市的天际线是从远处观看该城市中所有建筑物形成的轮廓的外部轮廓。
给你所有建筑物的位置和高度,请返回由这些建筑物形成的 天际线 。
每个建筑物的几何信息由数组 `buildings` 表示,其中三元组 `buildings[i] = [lefti, righti, heighti]` 表示:
* `left[i]` 是第 `i` 座建筑物左边缘的 `x` 坐标。
* `right[i]` 是第 `i` 座建筑物右边缘的 `x` 坐标。
* `height[i]` 是第 `i` 座建筑物的高度。
天际线 应该表示为由 “关键点” 组成的列表,格式 `[[x1,y1],[x2,y2],...]`,并按 `x` 坐标 进行 排序 ... | ### 基本分析
这是一题特别的扫描线问题 🤣🤣🤣
既不是求周长,也不是求面积,是求轮廓中的所有的水平线的左端点 🤣🤣🤣
所以这不是一道必须用「线段树」来解决的扫描线问题(因为不需要考虑区间查询问题)。
扫描线的核心在于 **将不规则的形状按照水平或者垂直的方式,划分成若干个规则的矩形。**
---
### 扫描线
对于本题,对应的扫描线分割形状如图:
不难发现,由相邻两个横坐标以及最大高度,可以确定一个矩形。
题目要我们 **输出每个矩形的“上边”的左端点,同时跳过可由前一矩形“上边”延展而来的那些边。**
因此我们需要实时维护一个最大高度,可以使用优先队列(堆)。
实现时,我们可以先记录下 $b... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.218` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/219. 存在重复元素 II（简单）.md | 219. 存在重复元素 II | https://leetcode-cn.com/problems/contains-duplicate-ii/solution/gong-shui-san-xie-hua-dong-chuang-kou-yu-q02i/ | 简单 | [
"滑动窗口",
"哈希表"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,判断数组中是否存在两个 不同的索引 `i` 和 `j` ,满足 `nums[i] == nums[j]` 且 `abs(i - j) <= k` 。如果存在,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:nums = [1,2,3,1], k = 3
输出:true
```
示例 2:
```
输入:nums = [1,0,1,1], k = 1
输出:true
```
示例 3:
```
输入:nums = [1,2,3,1,2,3], k = 2
输出:false
```
提示:
* $1 <= nums.length <= 10^... | ### 滑动窗口 + 哈希表
整理题意:是否存在长度不超过的 $k + 1$ 窗口,窗口内有相同元素。
我们可以从前往后遍历 $nums$,同时使用 `Set` 记录遍历当前滑窗内出现过的元素。
假设当前遍历的元素为 $nums[i]$:
* 下标小于等于 $k$(起始滑窗长度还不足 $k + 1$):直接往滑窗加数,即将当前元素加入 `Set` 中;
* 下标大于 $k$:将上一滑窗的左端点元素 $nums[i - k - 1]$ 移除,判断当前滑窗的右端点元素 $nums[i]$ 是否存在 `Set` 中,若存在,返回 `True`,否则将当前元素 $nums[i]$ 加入 `Set` 中。
重复上述过程,若整个 $n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.219` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/220. 存在重复元素 III（中等）.md | 220. 存在重复元素 III | https://leetcode-cn.com/problems/contains-duplicate-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-dlnv/ | 中等 | [
"滑动窗口",
"二分",
"桶排序"
] | 给你一个整数数组 nums 和两个整数 k 和 t 。
请你判断是否存在 两个不同下标 i 和 j,使得 abs(nums[i] - nums[j]) <= t ,同时又满足 abs(i - j) <= k 。
如果存在则返回 true,不存在返回 false。
示例 1:
```
输入:nums = [1,2,3,1], k = 3, t = 0
输出:true
```
示例 2:
```
输入:nums = [1,0,1,1], k = 1, t = 2
输出:true
```
示例 3:
```
输入:nums = [1,5,9,1,5,9], k = 2, t = 3
输出:false
```
提示:
* 0 ... | ### 滑动窗口 & 二分
**根据题意,对于任意一个位置 `i`(假设其值为 `u`),我们其实是希望在下标范围为 $[max(0, i - k), i)$ 内找到值范围在 $[u - t, u + t]$ 的数。**
一个朴素的想法是每次遍历到任意位置 `i` 的时候,往后检查 `k` 个元素,但这样做的复杂度是 $O(nk)$ 的,会超时。
显然我们需要优化「检查后面 `k` 个元素」这一过程。
**我们希望使用一个「有序集合」去维护长度为 `k` 的滑动窗口内的数,该数据结构最好支持高效「查询」与「插入/删除」操作:**
* **查询:能够在「有序集合」中应用「二分查找」,快速找到「小于等于 $u$ 的最大值」和「... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.220` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2121-2130/2127. 参加会议的最多员工数（困难）.md | 2127. 参加会议的最多员工数 | https://leetcode.cn/problems/maximum-employees-to-be-invited-to-a-meeting/solutions/2507559/gong-shui-san-xie-sha-shi-nei-xiang-wai-4ig79/ | 困难 | [
"基环森林",
"内向基环树",
"拓扑排序",
"图"
] | 一个公司准备组织一场会议,邀请名单上有 `n` 位员工。
公司准备了一张圆形的桌子,可以坐下任意数目的员工。
员工编号为 $0$ 到 $n - 1$。每位员工都有一位喜欢的员工,每位员工当且仅当他被安排在喜欢员工的旁边,他才会参加会议,每位员工喜欢的员工不会是他自己。
给你一个下标从 $0$ 开始的整数数组 `favorite`,其中 $favorite[i]$ 表示第 $i$ 位员工喜欢的员工。请你返回参加会议的最多员工数目。
示例 1:
```
输入:favorite = [2,2,1,2]
输出:3
解释:
上图展示了公司邀请员工 0,1 和 2 参加会议以及他们在圆桌上的座位。
没办法邀请所有员工参与会议,因为... | ### 内向基环森林 + 拓扑排序
根据题意,圆形桌上 $x$ 左右两边只要有一位是 $x$ 所喜欢即可。
我们可从 $i$ 向 $favorite[i]$ 添加有向边,从而得到一张包含多个「内向基环树」的图。
内向基环树,是指其满足基环树定义,且内向 ~~bushi~~。
基环树是指其具有 $n$ 个点 $n$ 条边的联通块,而「内向」是指树中任意节点有且只有一条出边,对应的「外向」是指树中任意节点有且只有一条入边。
例如,左图内向,右图外向:
根据题意,**圆桌最多放置一个长度大于 $2$ 的环(内向环,只有一条出边,即只有一个喜欢的人,安插其他非环成员,会破坏留下参加会议的必要条件),但可放置多个长度为 $2$ 的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2217` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2161-2170/2170. 使数组变成交替数组的最少操作数（中等）.md | 2170. 使数组变成交替数组的最少操作数 | https://leetcode-cn.com/problems/minimum-operations-to-make-the-array-alternating/solution/gong-shui-san-xie-jian-dan-ji-shu-lei-ta-0eo4/ | 中等 | [
"贪心"
] | 给你一个下标从 $0$ 开始的数组 $nums$ ,该数组由 $n$ 个正整数组成。
如果满足下述条件,则数组 $nums$ 是一个 交替数组 :
* $nums[i - 2] == nums[i]$ ,其中 $2 <= i <= n - 1$ 。
* $nums[i - 1] != nums[i]$ ,其中 $1 <= i <= n - 1$ 。
在一步 操作 中,你可以选择下标 $i$ 并将 $nums[i]$ 更改 为 任一 正整数。
返回使数组变成交替数组的 最少操作数 。
示例 1:
```
输入:nums = [3,1,3,2,4,3]
输出:3
解释:
使数组变成交替数组的方法之一是将该数组转换为 [3,... | ### 贪心
根据「交替数组」的定义,我们可以将数组根据下标奇偶性分成两个序列,最终目的是:**使用最少的修改次数,使得「两个序列均成为公差为 $0$ 等差数列」,同时「两序列的首项不相等」。**
要用最少次数将一个序列修改为公差为 $0$ 等差数列,等价于修改最少的数字,等价于保留最多的数字,容易想到将序列中的其他「非众数」修改为「众数」(若有多个众数,取任一)。
而单纯对两个序列执行上述逻辑,并不能确保最终得到的是「交替数组」,即未必满足「两序列的首项不相等」的要求。
因此我们可以对 $nums$ 进行扫描,分别统计「偶数下标序列」和「奇数下标序列」的最大值(众数)和次大值(**注意是非严格的次大值,即为「其他众数」或者... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2170` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/223. 矩形面积（中等）.md | 223. 矩形面积 | https://leetcode-cn.com/problems/rectangle-area/solution/gong-shui-san-xie-yun-yong-rong-chi-yuan-hzit/ | 中等 | [
"容斥原理"
] | 给你 **二维** 平面上两个 **由直线构成的** 矩形,请你计算并返回两个矩形覆盖的总面积。
每个矩形由其 左下 顶点和 右上 顶点坐标表示:
* 第一个矩形由其左下顶点 (ax1, ay1) 和右上顶点 (ax2, ay2) 定义。
* 第二个矩形由其左下顶点 (bx1, by1) 和右上顶点 (bx2, by2) 定义。
示例 1:
```
输入:ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2
输出:45
```
示例 2:
```
输入:ax1 = -2, ay1 = -2, ax2 = 2, ay2 = 2, bx... | ### 容斥原理
首先在给定左下顶点和右上顶点的情况下,计算矩形面积为 $(x2 - x1) * (y2 - y1)$。
因此,起始时我们可以先直接算得给定的两个矩形的面积 $A$ 和 $B$,并进行累加。
剩下的,我们需要求得两矩形的交集面积,利用「容斥原理」,减去交集面积,即是答案。
**求交集矩形面积,可以转换为求两矩形在坐标轴上的重合长度,若两矩形在 $X$ 轴上的重合长度为 $x$,在 $Y$ 轴上的重合长度为 $y$,则有重合面积为 $C = x * y$。同时考虑两矩形在任一坐标轴上没有重合长度,则不存在重合面积,因此需要将重合长度与 $0$ 取 $\max$。**
最终答案为 $A + B - C$ 。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.223` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/224. 基本计算器（困难）.md | 224. 基本计算器 | https://leetcode-cn.com/problems/basic-calculator/solution/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/ | 困难 | [
"表达式计算",
"栈"
] | 给你一个字符串表达式 `s` ,请你实现一个基本计算器来计算并返回它的值。
示例 1:
```
输入:s = "1 + 1"
输出:2
```
示例 2:
```
输入:s = " 2-1 + 2 "
输出:3
```
示例 3:
```
输入:s = "(1+(4+5+2)-3)+(6+8)"
输出:23
```
提示:
* $1 <= s.length <= 3 \times 10^5$
* `s` 由`数字`、`'+'`、`'-'`、`'('`、`')'`、和 `' '` 组成
* `s` 表示一个有效的表达式 | ### 双栈解法
我们可以使用两个栈 `nums` 和 `ops` 。
* `nums` : 存放所有的数字
* `ops` :存放所有的数字以外的操作,`+/-` 也看做是一种操作
然后从前往后做,对遍历到的字符做分情况讨论:
* 空格 : 跳过
* `(` : 直接加入 `ops` 中,等待与之匹配的 `)`
* `)` : 使用现有的 `nums` 和 `ops` 进行计算,直到遇到左边最近的一个左括号为止,计算结果放到 `nums`
* 数字 : 从当前位置开始继续往后取,将整一个连续数字整体取出,加入 `nums`
* `+/-` : 需要将操作放入 `ops` 中。**在放入之前先把栈内可以算的都算掉**,使用现有的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.224` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/227. 基本计算器 II（中等）.md | 227. 基本计算器 II | https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/ | 中等 | [
"表达式计算"
] | 给你一个字符串表达式 `s` ,请你实现一个基本计算器来计算并返回它的值。
整数除法仅保留整数部分。
示例 1:
```
输入:s = "3+2*2"
输出:7
```
示例 2:
```
输入:s = " 3/2 "
输出:1
```
示例 3:
```
输入:s = " 3+5 / 2 "
输出:5
```
提示:
* $1 <= s.length <= 3 \times 10^5$
* `s` 由整数和算符 (`'+'`, `'-'`, `'*'`, `'/'`) 组成,中间由一些空格隔开
* `s` 表示一个 有效表达式
* 表达式中的所有整数都是非负整数,且在范围 $[0, 2^{31} - 1]$ 内
* 题... | ### 双栈
如果你有看这篇 [224. 基本计算器](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 的话,今天这道题就是道练习题。
帮你巩固 **双栈解决「通用表达式」问题的通用解法** 。
**事实上,我提供这套解决方案不仅仅能解决只有 `+ - ( )`的 [[224. 基本计算器]](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b5301... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.227` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/229. 求众数 II（中等）.md | 229. 求众数 II | https://leetcode-cn.com/problems/majority-element-ii/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ws0rj/ | 中等 | [
"摩尔投票",
"哈希表"
] | 给定一个大小为 `n` 的整数数组,找出其中所有出现超过 `⌊ n/3 ⌋` 次的元素。
示例 1:
```
输入:[3,2,3]
输出:[3]
```
示例 2:
```
输入:nums = [1]
输出:[1]
```
示例 3:
```
输入:[1,1,1,3,3,2,2,2]
输出:[1,2]
```
提示:
* $1 <= nums.length <= 5 * 10^4$
* $-10^9 <= nums[i] <= 10^9$
进阶:尝试设计时间复杂度为 $O(n)$、空间复杂度为 $O(1)$ 的算法解决此问题。 | ### 哈希表计数
一个朴素的做法是使用「哈希表」进行计数,在计数完成后将所有出现次数超过 $n / 3$ 的元素加入答案。
代码:
```Java
class Solution {
public List<Integer> majorityElement(int[] nums) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
List<Integ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.229` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/230. 二叉搜索树中第K小的元素（中等）.md | 230. 二叉搜索树中第K小的元素 | https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/solution/gong-shui-san-xie-yi-ti-san-jie-pai-xu-y-8uah/ | 中等 | [
"二叉树",
"中序遍历",
"树的搜索"
] | 给定一个二叉搜索树的根节点 `root`,和一个整数 `k` ,请你设计一个算法查找其中第 `k` 个最小元素(从 $1$ 开始计数)。
示例 1:
```
输入:root = [3,1,4,null,2], k = 1
输出:1
```
示例 2:
```
输入:root = [5,3,6,2,4,null,null,1], k = 3
输出:3
```
提示:
* 树中的节点数为 n 。
* $1 <= k <= n <= 10^4$
* $0 <= Node.val <= 10^4$ | ### 树的遍历 + 排序
朴素的做法是先对二叉树进行一次完整遍历,将所有节点存入列表中,最后对列表排序后返回目标值。
树的遍历可以使用 `DFS` 或 `BFS`。
代码:
```Java
class Solution {
List<Integer> list = new ArrayList<>();
public int kthSmallest(TreeNode root, int k) {
dfs(root);
Collections.sort(list);
return list.get(k - 1);
}
void dfs(TreeNod... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.230` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2211-2220/2213. 由单个字符重复的最长子字符串（困难）.md | 2213. 由单个字符重复的最长子字符串 | https://leetcode-cn.com/problems/longest-substring-of-one-repeating-character/solution/by-ac_oier-0lso/ | 困难 | [
"区间求和",
"线段树"
] | 给你一个下标从 $0$ 开始的字符串 `s` 。另给你一个下标从 $0$ 开始、长度为 $k$ 的字符串 `queryCharacters`,一个下标从 $0$ 开始、长度也是 $k$ 的整数 下标 数组 `queryIndices`,这两个都用来描述 $k$ 个查询。
第 $i$ 个查询会将 `s` 中位于下标 $queryIndices[i]$ 的字符更新为 $queryCharacters[i]$。
返回一个长度为 $k$ 的数组 `lengths`,其中 $lengths[i]$ 是在执行第 $i$ 个查询之后 `s` 中仅由单个字符重复组成的 最长子字符串的长度 。
示例 1:
```
输入:s = "babacc"... | ### 线段树
这是一道经典的线段树应用题。
根据题意,涉及的操作 “似乎” 是「单点修改」和「区间查询」,那么根据 [(题解) 307. 区域和检索 - 数组可修改](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 的总结,我们应该使用的是「树状数组」吗?
其实并不是(或者说不能直接是),原因在于我们查询的是「修改过后 `s` 中相同字符连续段的最大长度」,而当我们进行所谓的「单点修改」时,会导致原本的连续段被破坏,或者形成新的连续段。也就是此处的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2213` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2211-2220/2216. 美化数组的最少删除数（中等）.md | 2216. 美化数组的最少删除数 | https://leetcode.cn/problems/minimum-deletions-to-make-array-beautiful/solutions/2535327/gong-shui-san-xie-zhi-ji-ben-zhi-de-ji-j-dk05/ | 中等 | [
"模拟"
] | 给你一个下标从 `0` 开始的整数数组 `nums`,如果满足下述条件,则认为数组 `nums` 是一个 美丽数组 :
* `nums.length` 为偶数
* 对所有满足 `i % 2 == 0` 的下标 `i`,`nums[i] != nums[i + 1]` 均成立
注意,空数组同样认为是美丽数组。
你可以从 `nums` 中删除任意数量的元素。当你删除一个元素时,被删除元素右侧的所有元素将会向左移动一个单位以填补空缺,而左侧的元素将会保持 不变 。
返回使 `nums` 变为美丽数组所需删除的最少元素数目。
示例 1:
```
输入:nums = [1,1,2,3,5]
输出:1
解释:可以删除 nums[0... | ### 模拟
使用变量 `cnt` 代表已删除的元素个数,由于每次删除元素,剩余元素都会往前移动,因此遍历过程中,当前下标为 $i - cnt$。
若当前下标为偶数,且与下一位置元素相同,那么当前元素需被删除,令 `cnt` 自增。
最终数组长度为 $n - cnt$,若长度为奇数,需要再额外删除结尾元素(`cnt` 再加一),否则 `cnt` 即为答案。
Java 代码:
```Java
class Solution {
public int minDeletion(int[] nums) {
int n = nums.length, cnt = 0;
for (int i = 0... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2216` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2241-2250/2246. 相邻字符不同的最长路径（困难）.md | 2246. 相邻字符不同的最长路径 | https://leetcode.cn/problems/longest-path-with-different-adjacent-characters/solutions/2453857/gong-shui-san-xie-shu-xing-dp-ding-gen-d-eh5i/ | 困难 | [
"树",
"DFS",
"树形 DP",
"动态规划"
] | 给你一棵 树(即一个连通、无向、无环图),根节点是节点 `0`,这棵树由编号从 `0` 到 `n - 1` 的 `n` 个节点组成。
用下标从 `0` 开始、长度为 `n` 的数组 `parent` 来表示这棵树,其中 `parent[i]` 是节点 `i` 的父节点,由于节点 `0` 是根节点,所以 `parent[0] = -1`。
另给你一个字符串 `s`,长度也是 `n`,其中 `s[i]` 表示分配给节点 `i` 的字符。
请你找出路径上任意一对相邻节点都没有分配到相同字符的 最长路径 ,并返回该路径的长度。
示例 1:
```
输入:parent = [-1,0,0,1,1,2], s = "abacbe"
... | ### DFS
起始先用 `parent` 进行建图,随后设计 `DFS` 函数来求解每个节点“往下”的最长路径:将当前节点 `cur` 作为传入参数,返回以节点“往下”的最长路径。
这是一个由子节点最长路径推导父节点最长路径的「自下而上」的推导过程。
> 先来关注该 `DFS` 的功能本身:
假设当前处理到的节点为 `u`,将要访问到的节点为 `j`。递归调用 `DFS` 函数拿到以节点 `j` 为根节点时的“往下”最大路径 `t`,并执行如下处理流程:
* 若节点 `j` 和节点 `u` 对应字符相同,说明将节点 `j` 拼接在节点 `u` 后面并非合法路径,跳过处理
* 否则使用 `t` 来更新以当前节点 `u` ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2346` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2251-2260/2258. 逃离火灾（困难）.md | 2258. 逃离火灾 | https://leetcode.cn/problems/escape-the-spreading-fire/solutions/2518985/gong-shui-san-xie-xiang-jie-ru-he-cong-e-458x/ | 困难 | [
"多源 BFS",
"二分",
"预处理"
] | 给你一个下标从 `0` 开始大小为 `m x n` 的二维整数数组 `grid`,它表示一个网格图。
每个格子为下面 $3$ 个值之一:
* `0` 表示草地。
* `1` 表示着火的格子。
* `2` 表示一座墙,你跟火都不能通过这个格子。
一开始你在最左上角的格子 $(0, 0)$ ,你想要到达最右下角的安全屋格子 $(m - 1, n - 1)$ 。
每一分钟,你可以移动到相邻的草地格子。
每次你移动之后 ,着火的格子会扩散到所有不是墙的相邻格子。
请你返回你在初始位置可以停留的最多分钟数,且停留完这段时间后你还能安全到达安全屋。
如果无法实现,请你返回 $-1$。如果不管你在初始位置停留多久,你总是能到达安全屋... | ### 二分 + BFS
火势蔓延是一个固定的过程,只有人员移动需要决策。
假设人员最晚在 $t$ 秒后出发,仍能到达安全屋,说明人员对逃走路线的访问,要比火势更快。那么人员在更早的时间点($[0, t - 1]$ 秒后)出发,必然仍能按照原定路线到达安全屋(火势对路径的影响不变)。
因此,在以 $t$ 为分割点的(正整数)数轴上,具有二段性,可运用「二分」求分割点。
假设存在某个判定函数 `check`,用于检查人员在 $x$ 秒后出发能否到达安全屋,那么可知:
* 当实际延迟出发的秒数,小于等于 $t$ 秒,必然能安全到达
* 当实际延迟出发的描述,超过 $t$ 秒,必然不能安全到达
在人员移动路线中,“回头路”是没... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2258` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2291-2300/2300. 咒语和药水的成功对数（中等）.md | 2300. 咒语和药水的成功对数 | https://leetcode.cn/problems/successful-pairs-of-spells-and-potions/solutions/2520333/gong-shui-san-xie-jing-dian-er-fen-yun-y-86y0/ | 中等 | [
"排序",
"二分"
] | 给你两个正整数数组 `spells` 和 `potions`,长度分别为 `n` 和 `m`,其中 `spells[i]` 表示第 `i` 个咒语的能量强度,`potions[j]` 表示第 `j` 瓶药水的能量强度。
同时给你一个整数 `success`。一个咒语和药水的能量强度相乘如果大于等于 `success`,那么它们视为一对成功的组合。
请你返回一个长度为 `n` 的整数数组 `pairs`,其中 `pairs[i]` 是能跟第 `i` 个咒语成功组合的 药水 数目。
示例 1:
```
输入:spells = [5,1,3], potions = [1,2,3,4,5], success = 7
输出:[4,0,... | ### 排序 + 二分
为了方便,我们将 `spells` 记为 `a`,将 `potions` 记为 `b`,将 `success` 记为 `t`。
对于每个 $a[i]$,有多少个 $b[j]$ 满足 $a[i] \times b[j] \geqslant t$,等价于问数组 `b` 中值大于等于 $\frac{t}{a[i]}$ 的个数,这容易让我们想到先对数组 `b` 排升序,再通过二分找到满足该条件的最小下标,从该下标到数组结尾,均为满足条件的 $b[j]$。
Java 代码:
```Java
class Solution {
public int[] successfulPairs(int[] a, int... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2300` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2301-2310/2304. 网格中的最小路径代价（中等）.md | 2304. 网格中的最小路径代价 | https://leetcode.cn/problems/minimum-path-cost-in-a-grid/solutions/2536854/gong-shui-san-xie-cong-tu-lun-zui-duan-l-emxv/ | 中等 | [
"最短路",
"图",
"模拟",
"序列 DP",
"动态规划"
] | 给你一个下标从 `0` 开始的整数矩阵 `grid`,矩阵大小为 `m x n`,由从 `0` 到 $m \times n - 1$ 的不同整数组成。
你可以在此矩阵中,从一个单元格移动到下一行的任何其他单元格。
如果你位于单元格 $(x, y)$ ,且满足 $x < m - 1$,你可以移动到 $(x + 1, 0)$, $(x + 1, 1)$, ..., $(x + 1, n - 1)$ 中的任何一个单元格。注意: 在最后一行中的单元格不能触发移动。
每次可能的移动都需要付出对应的代价,代价用一个下标从 `0` 开始的二维数组 `moveCost` 表示,该数组大小为 $(m \times n) \times n$ ,其... | ### 建新图 + 建虚拟点 + 堆优化 Dijkstra
> 注意:可以直接使用解法二的方法,但先认真看完本做法,再去看解法二,会有相当丝滑的体验。
每次移动,**实际路径权值 = 经过边的权值 + 目的地的权值**。
利用原图,构建新图:**每个单元格视为一个点,除最后一行外,每个点对下一行的所有点连一条有向边,边权 = 原图中该边的权值 + 原图中该目的地的权值**。
分析新图中的点边数量:
* 点:共 $m \times n$ 个点,数量为 $2.5 \times 10^3$
* 边:不算最后一行,共 $(m - 1) \times n$ 个点,这些点与下一行的每个点均有一条有向边,合计 $(m - 1) \tim... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2304` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2301-2310/2305. 公平分发饼干（中等）.md | 2305. 公平分发饼干 | https://leetcode.cn/problems/fair-distribution-of-cookies/solution/gong-shui-san-xie-jian-dan-zhuang-ya-dp-trg25/ | 中等 | [
"状压 DP",
"位运算"
] | 给你一个整数数组 `cookies`,其中 `cookies[i]` 表示在第 `i` 个零食包中的饼干数量。另给你一个整数 `k` 表示等待分发零食包的孩子数量,所有零食包都需要分发。
在同一个零食包中的所有饼干都必须分发给同一个孩子,不能分开。
分发的不公平程度定义为单个孩子在分发过程中能够获得饼干的最大总数。
返回所有分发的最小不公平程度。
示例 1:
```
输入:cookies = [8,15,10,20,8], k = 2
输出:31
解释:一种最优方案是 [8,15,8] 和 [10,20] 。
- 第 1 个孩子分到 [8,15,8] ,总计 8 + 15 + 8 = 31 块饼干。
- 第 2 个孩子分... | ### 状压 DP
为了方便,将 `cookies` 记为 `cs`。
**定义 $f[i][s]$ 为考虑前 $i$ 个人,对 `cs` 的分配情况为 `s` 时的最小不公平程度**。
其中 `s` 为一个二进制数,若 `s` 的第 `i` 位为 `1` 代表 `cs[i]` 已被分配,反之代表未分配。同时我们可以预处理 `g` 数组,`g[s] = t` 含义为选择 `cs` 状态为 `s` 时得到的饼干总和为 `t`。
初始化只有 $f[0][0] = 0$,其余均为正无穷 `0x3f3f3f3f`。
不失一般性考虑 $f[i][s]$ 该如何计算,**通过枚举第 $i$ 个小朋友所分配到的饼干情况 `p`(`s` ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2305` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/231. 2 的幂（简单）.md | 231. 2 的幂 | https://leetcode-cn.com/problems/power-of-two/solution/gong-shui-san-xie-2-de-mi-by-ac_oier-qm6e/ | 简单 | [
"数学",
"位运算"
] | 给你一个整数 n,请你判断该整数是否是 2 的幂次方。如果是,返回 true ;否则,返回 false 。
如果存在一个整数 x 使得 n == $2^x$ ,则认为 n 是 2 的幂次方。
示例 1:
```
输入:n = 1
输出:true
解释:20 = 1
```
示例 2:
```
输入:n = 16
输出:true
解释:24 = 16
```
示例 3:
```
输入:n = 3
输出:false
```
示例 4:
```
输入:n = 4
输出:true
```
示例 5:
```
输入:n = 5
输出:false
```
提示:
* -$2^{31}$ <= n <= $2^{31}$ - 1
进阶:你... | ### 朴素做法
首先小于等于 $0$ 的数必然不是,$1$ 必然是。
在处理完这些边界之后,尝试将 $n$ 除干净,如果最后剩余数值为 $1$ 则说明开始是 $2$ 的幂。
代码:
```Java
class Solution {
public boolean isPowerOfTwo(int n) {
if (n <= 0) return false;
while (n % 2 == 0) n /= 2;
return n == 1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### lowbit
熟... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.231` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/232. 用栈实现队列（简单）.md | 232. 用栈实现队列 | https://leetcode-cn.com/problems/implement-queue-using-stacks/solution/sha-shi-jun-tan-fu-za-du-ya-wo-de-suan-f-gb6d/ | 简单 | [
"栈",
"队列"
] | 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):
实现 MyQueue 类:
* void push(int x) 将元素 x 推到队列的末尾
* int pop() 从队列的开头移除并返回元素
* int peek() 返回队列开头的元素
* boolean empty() 如果队列为空,返回 true ;否则,返回 false
说明:
* 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
* 你所使用的语言也许不支持栈。你可以使用 list 或者 dequ... | ### 基本思路
无论「用栈实现队列」还是「用队列实现栈」,思路都是类似的。
都可以通过使用两个栈/队列来解决。
我们创建两个栈,分别为 `out` 和 `in`,用作处理「输出」和「输入」操作。
其实就是两个栈来回「倒腾」。
而对于「何时倒腾」决定了是 **O(n) 解法** 还是 **均摊 O(1) 解法**。
***
### O(n) 解法
我们创建两个栈,分别为 `out` 和 `in`:
* **`in` 用作处理输入操作 `push()`,使用 `in` 时需确保 `out` 为空**
* **`out` 用作处理输出操作 `pop()` 和 `peek()`,使用 `out` 时需确保 `in` 为空... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.232` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/233. 数字 1 的个数（困难）.md | 233. 数字 1 的个数 | https://leetcode-cn.com/problems/number-of-digit-one/solution/gong-shui-san-xie-jiang-shu-wei-dp-wen-t-c9oi/ | 困难 | [
"动态规划",
"数位 DP",
"模拟"
] | 给定一个整数 $n$,计算所有小于等于 $n$ 的非负整数中数字 $1$ 出现的个数。
示例 1:
```
输入:n = 13
输出:6
```
示例 2:
```
输入:n = 0
输出:0
```
提示:
* 0 <= n <= $2 * 10^9$ | ### 基本分析
这是一道经典的「数位 DP」模板题的简化版,原题在 [这里](https://www.luogu.com.cn/problem/P1980) 。
这几天每日一题出得挺好,「序列 DP」、「区间 DP」、「数位 DP」轮着来 🤣
但由于本题只需求 $1$ 出现的次数,而不需要求解 $0$ 到 $9$ 的出现次数,同时意味着不需要考虑统计 $0$ 次数时的前导零边界问题。
因此,也可以不当作数位 DP 题来做,只当作一道计数类模拟题来求解。
---
### 计数类模拟
回到本题,我们需要计算 $[1, n]$ 范围内所有数中 $1$ 出现的次数。
我们可以统计 $1$ 在每一位出现的次数,将其累加起来... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.233` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/235. 二叉搜索树的最近公共祖先（中等）.md | 235. 二叉搜索树的最近公共祖先 | https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/solution/gong-shui-san-xie-yun-yong-dfs-qiu-jie-l-n3jh/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 `T` 的两个结点 `p`、`q`,最近公共祖先表示为一个结点 `x`,满足 `x` 是 `p`、`q` 的祖先且 `x` 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉搜索树: `root = [6,2,8,0,4,7,9,null,null,3,5]`
示例 1:
```
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。
```
示例 2:
```
输入: r... | ### DFS
也是常见的 `LCA` 问题,但相比 [236. 二叉树的最近公共祖先](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247500218&idx=1&sn=a6d790dcecfee353be5f3b53c312c3d4&chksm=fd9f6aa5cae8e3b36d85448674b189ed2d35fdce18381ac7676ec90a33d62da05718f85e3103#rd),本题搜索对象为二叉搜索树,利用此特性,我们可以将搜索复杂度从 $O(n)$ 优化至 $O(h)$。
利用原函数作为递归函数,复用 `root` 作为搜索过程中... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.235` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/236. 二叉树的最近公共祖先（中等）.md | 236. 二叉树的最近公共祖先 | https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/solutions/2402113/gong-shui-san-xie-yun-yong-dfs-qiu-jie-l-htd9/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个节点 `p`、`q`,最近公共祖先表示为一个节点 `x`,满足 `x` 是 `p`、`q` 的祖先且 `x` 的深度尽可能大(一个节点也可以是它自己的祖先)。”
示例 1:
```
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出:3
解释:节点 5 和节点 1 的最近公共祖先是节点 3 。
```
示例 2:
```
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出:5
解释:... | ### DFS
常见的 `LCA` 问题。
设计 `DFS` 函数 `boolean dfs(TreeNode cur, TreeNode t, List<TreeNode> path)`:其中 **`cur` 为当前处理到的节点,`t` 为需要找到的目的节点,`path` 为从根节点到当前节点 `cur` 所经过的路径**。若能够以当前节点 `cur` 为根的子树包含目标节点 `t`,函数返回 `true`,否则返回 `false`。z
调用函数分别传入 `p` 和 `q` 作为目标节点,从而得到从根节点到 `p` 和 `q` 的路径列表,遍历路径找到最后一个相同的节点即是答案。
Java 代码:
```Java
clas... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.236` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/237. 删除链表中的节点（简单）.md | 237. 删除链表中的节点 | https://leetcode-cn.com/problems/delete-node-in-a-linked-list/solution/gong-shui-san-xie-jian-dan-lian-biao-mo-rovcb/ | 简单 | [
"模拟",
"链表",
"脑筋急转弯"
] | 请编写一个函数,用于**删除单链表中某个特定节点 **。
在设计函数时需要注意,你无法访问链表的头节点 head ,只能直接访问**要被删除的节点**。
题目数据保证需要删除的节点 不是末尾节点 。
示例 1:
```
输入:head = [4,5,1,9], node = 5
输出:[4,1,9]
解释:指定链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9
```
示例 2:
```
输入:head = [4,5,1,9], node = 1
输出:[4,5,9]
解释:指定链表中值为 1 的第三个节点,那么在调用了你的函数之后,该链表应变为 4 -> 5 -> 9
`... | ### 模拟
对于一般性的链表删除操作而言,我们需要知道待删除节点的前一节点与后一节点,并对两者建立联系。
对于本题,由于我们只知道待删除节点本身,同时该链表为单链表(无法访问前一节点),因此我们只能先将后一节点的值复制到当前节点,然后将后一节点当作「待删除节点」来进行常规删除。
代码:
```Java
class Solution {
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.237` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/238. 除自身以外数组的乘积（中等）.md | 238. 除自身以外数组的乘积 | https://leetcode.cn/problems/product-of-array-except-self/solution/by-ac_oier-fqp3/ | 中等 | [
"前缀和",
"容斥原理"
] | 给你一个整数数组 `nums`,返回 数组 `answer`,其中 $answer[i]$ 等于 `nums` 中除 $nums[i]$ 之外其余各元素的乘积 。
题目数据 保证 数组 `nums` 之中任意元素的全部前缀元素和后缀的乘积都在 $32$ 位 整数范围内。
请不要使用除法,且在 $O(n)$ 时间复杂度内完成此题。
示例 1:
```
输入: nums = [1,2,3,4]
输出: [24,12,8,6]
```
示例 2:
```
输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]
```
提示:
* $2 <= nums.length <= 10^5$
* $-30 <... | ### 前缀和
根据题意,对于每个 $ans[i]$ 均由两部分组成:
$$
(nums[0] \times nums[1] \times ... \times nums[i - 1]) \times (nums[i + 1] \times nums[i + 2] \times ... \times nums[n - 1])
$$
因此我们可以运用「前缀和」思想,使用数组 `s1` 和 `s2` 分别计算范围 $[1, x]$ 的前缀乘 和 范围 $[x, n]$ 的后缀乘法(前缀和数组下标默认从 $1$ 开始),即 $s1[i]$ 代表范围 $[1,i]$ 的前缀乘值,$s2[i]$ 代表范围 $[i, n]$ 的后缀乘值。... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.238` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/239. 滑动窗口最大值（困难）.md | 239. 滑动窗口最大值 | https://leetcode.cn/problems/sliding-window-maximum/solution/by-ac_oier-o89l/ | 困难 | [
"优先队列(堆)",
"线段树",
"分块",
"单调队列",
"RMQ"
] | 给你一个整数数组 `nums`,有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值 。
示例 1:
```
输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
输出:[3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5]... | ### 优先队列(堆)
根据题意,容易想到优先队列(大根堆),同时为了确保滑动窗口的大小合法性,我们以二元组 $(idx, nums[idx])$ 的形式进行入队。
当下标达到首个滑动窗口的右端点后,每次尝试从优先队列(大根堆)中取出最大值(若堆顶元素的下标小于当前滑动窗口左端点时,则丢弃该元素)。
代码:
```Java
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->b[1]-a[1]);
i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.239` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/240. 搜索二维矩阵 II（中等）.md | 240. 搜索二维矩阵 II | https://leetcode-cn.com/problems/search-a-2d-matrix-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-y1ns/ | 中等 | [
"二分",
"二叉搜索树",
"模拟"
] | 编写一个高效的算法来搜索 `m x n` 矩阵 `matrix` 中的一个目标值 `target` 。
该矩阵具有以下特性:
* 每行的元素从左到右升序排列。
* 每列的元素从上到下升序排列。
示例 1:
```
输入:matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
输出:true
```
示例 2:
```
输入:matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,2... | ### 前言
这道题和之前的[(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 类似,建议你将两题放到一起去做。
---
### 二分
与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 不同,本题没有确保「每行的第一个整数大于... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.240` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2331-2340/2335. 装满杯子需要的最短总时长（简单）.md | 2335. 装满杯子需要的最短总时长 | https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247495870&idx=1&sn=a15b87852faaa33fc9d976b575ef1099 | 简单 | [
"排序",
"递归",
"模拟",
"贪心",
"数学"
] | 现有一台饮水机,可以制备冷水、温水和热水。每秒钟,可以装满 `2` 杯 不同 类型的水或者 `1` 杯任意类型的水。
给你一个下标从 `0` 开始、长度为 `3` 的整数数组 `amount`,其中 `amount[0]`、`amount[1]` 和 `amount[2]` 分别表示需要装满冷水、温水和热水的杯子数量。
返回装满所有杯子所需的 **最少** 秒数。
示例 1:
```
输入:amount = [1,4,2]
输出:4
解释:下面给出一种方案:
第 1 秒:装满一杯冷水和一杯温水。
第 2 秒:装满一杯温水和一杯热水。
第 3 秒:装满一杯温水和一杯热水。
第 4 秒:装满一杯温水。
可以证明最少需要 4 秒... | ### 排序 + 递归
水的种类固定为 `3`,且每种水的数据范围只有 $100$,可直接使用递归进行求解。
为了尽可能的凑成多的对数,我们可以每次取剩余数量最多且不为 `0` 的两类水进行成组(因此每次处理前需要先对当前 `amount` 进行排序),直到没有水剩余,或只有一类水的剩余数据量不为 `0`(剩下的水只能独自生成)。
Java 代码:
```Java
class Solution {
public int fillCups(int[] amount) {
Arrays.sort(amount);
if (amount[1] == 0) return amount[2];
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2335` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2331-2340/2336. 无限集中的最小数字（中等）.md | 2336. 无限集中的最小数字 | https://leetcode.cn/problems/smallest-number-in-infinite-set/solutions/2546157/gong-shui-san-xie-rong-yi-you-gao-xiao-d-431o/ | 中等 | [
"优先队列(堆)",
"哈希表"
] | 现有一个包含所有正整数的集合 $[1, 2, 3, 4, 5, ...]$ 。
实现 `SmallestInfiniteSet` 类:
* `SmallestInfiniteSet()` 初始化 `SmallestInfiniteSet` 对象以包含所有正整数。
* `int popSmallest()` 移除并返回该无限集中的最小整数。
* `void addBack(int num)` 如果正整数 `num` 不存在于无限集中,则将一个 `num` 添加到该无限集中。
示例:
```
输入
["SmallestInfiniteSet", "addBack", "popSmallest", "popSmallest", "p... | ### 优先队列(小根堆)+ 哈希表
使用 `idx` 代表顺序弹出的集合左边界,$[idx, +\infty]$ 范围内的数均为待弹出,起始有 $idx = 1$。
考虑当调用 `addBack` 往集合添加数值 `x` 时,该如何处理:
* $x \geq idx$:数值本身就存在于集合中,忽略该添加操作;
* $x = idx - 1$:数值刚好位于边界左侧,更新 $idx = idx - 1$;
* $x < idx - 1$:考虑将数值添加到某个容器中,该容器支持返回最小值,容易联想到“小根堆”;但小根堆并没有“去重”功能,为防止重复弹出,还需额外使用“哈希表”来记录哪些元素在堆中。
该做法本质上将集合分成两类:一... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2336` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2341-2350/2342. 数位和相等数对的最大和（中等）.md | 2342. 数位和相等数对的最大和 | https://leetcode.cn/problems/max-sum-of-a-pair-with-equal-sum-of-digits/solutions/2531511/gong-shui-san-xie-yong-bian-li-guo-cheng-kt3f/ | 中等 | [
"模拟",
"哈希表"
] | 给你一个下标从 `0` 开始的数组 `nums`,数组中的元素都是正整数。
请你选出两个下标 `i` 和 `j`(`i != j`),且 `nums[i]` 的数位和与 `nums[j]` 的数位和相等。
请你找出所有满足条件的下标 `i` 和 `j`,找出并返回 `nums[i] + nums[j]` 可以得到的最大值。
示例 1:
```
输入:nums = [18,43,36,13,7]
输出:54
解释:满足条件的数对 (i, j) 为:
- (0, 2) ,两个数字的数位和都是 9 ,相加得到 18 + 36 = 54 。
- (1, 4) ,两个数字的数位和都是 7 ,相加得到 43 + 7 = 50 。
所... | ### 模拟
既然每个 $nums[i]$ 都对应一个具体的数位和,统计每个数位和的最大值和次大值,然后在所有数位和的最大值和次大值求和中取 `max` 即是答案。
利用 $1 <= nums[i] <= 10^9$,我们知道数位和不会超过 $9 \times 9 = 81$,可直接起一个大小为 $100 \times 2$ 的二维数组进行统计,$val[x][0]$ 代表数位和为 $x$ 的次大值,$val[x][1]$ 代表数位和为 $x$ 的最大值。
Java 代码:
```Java
class Solution {
public int maximumSum(int[] nums) {
int[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/241-250/241. 为运算表达式设计优先级（中等）.md | 241. 为运算表达式设计优先级 | https://leetcode.cn/problems/different-ways-to-add-parentheses/solution/by-ac_oier-z07i/ | 中等 | [
"DFS",
"爆搜"
] | 给你一个由数字和运算符组成的字符串 `expression`,按不同优先级组合数字和运算符,计算并返回所有可能组合的结果。你可以 按任意顺序 返回答案。
生成的测试用例满足其对应输出值符合 $32$ 位整数范围,不同结果的数量不超过 $10^4$ 。
示例 1:
```
输入:expression = "2-1-1"
输出:[0,2]
解释:
((2-1)-1) = 0
(2-(1-1)) = 2
```
示例 2:
```
输入:expression = "2*3-4*5"
输出:[-34,-14,-10,-10,10]
解释:
(2*(3-(4*5))) = -34
((2*3)-(4*5)) = -14
((... | ### DFS
为了方便,我们令 `expression` 为 `s`。
数据范围为 $20$,且要统计所有的计算结果,我们可以运用 `DFS` 爆搜所有方案。
给定的 `s` 只有数字和运算符,我们可以根据运算符将式子分为左右两部分,设计递归函数 `List<Integer> dfs(int l, int r)`,含义为搜索子串 $s[l...r]$ 的所有运算结果。
最终答案为 `dfs(0,n-1)`,其中 $n$ 为入参字符串的长度,同时我们有显而易见的递归出口:当给定的 $s[l...r]$ 不包含任何运算符时,搜索结果为 $s[l...r]$ 所代表的数字本身。
考虑如何对任意 $s[l...r]$ 进行计算:... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.241` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2471-2480/2477. 到达首都的最少油耗（中等）.md | 2477. 到达首都的最少油耗 | https://leetcode.cn/problems/minimum-fuel-cost-to-report-to-the-capital/solutions/2554316/gong-shui-san-xie-zhu-bu-jiang-jie-zui-d-25qs/ | 中等 | [
"DFS"
] | 给你一棵 `n` 个节点的树(一个无向、连通、无环图),每个节点表示一个城市,编号从 `0` 到 `n - 1`,且恰好有 `n - 1` 条路。
`0` 是首都。给你一个二维整数数组 `roads`,其中 $roads[i] = [a_{i}, b_{i}]$ ,表示城市 $a_{i}$ 和 $b_{i}$ 之间有一条 双向路 。
每个城市里有一个代表,他们都要去首都参加一个会议。
每座城市里有一辆车。给你一个整数 `seats` 表示每辆车里面座位的数目。
城市里的代表可以选择乘坐所在城市的车,或者乘坐其他城市的车。相邻城市之间一辆车的油耗是一升汽油。
请你返回到达首都最少需要多少升汽油。
示例 1:
```
输入... | ### DFS
将双向图看作是以节点 `0` 为根的有向树,从每个节点出发往 `0` 前行,可看作是自底向上的移动过程。
当 `seats = 1` 时,每个节点前往 `0` 的过程相互独立,总油耗为每节点到 `0` 的最短距离之和。
当 `seats` 不为 `1` 时,考虑组成顺风车,此时总的油耗不该超过 `seats = 1` 的情况。
不难发现,**只有「深度大的节点,在前往 `0` 过程中,搭乘深度小顺风车」可减少油耗**(例如在上图节点 `3` 在经过节点 `1` 时搭乘顺风车,可与节点 `1` 合计使用一份油耗前往到 `0`),否则如果是深度小的节点先往深度大的节点走,再一同前往 `0`,会额外多经过某些边,产... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2477` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/251-260/258. 各位相加（简单）.md | 258. 各位相加 | https://leetcode-cn.com/problems/add-digits/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-zdml/ | 简单 | [
"模拟",
"数学"
] | 给定一个非负整数 `num`,反复将各个位上的数字相加,直到结果为一位数。返回这个结果。
示例 1:
```
输入: num = 38
输出: 2
解释: 各位相加的过程为:
38 --> 3 + 8 --> 11
11 --> 1 + 1 --> 2
由于 2 是一位数,所以返回 2。
```
示例 1:
```
输入: num = 0
输出: 0
```
提示:
* $0 <= num <= 2^{31} - 1$
进阶:你可以不使用循环或者递归,在 $O(1)$ 时间复杂度内解决这个问题吗? | ### 模拟
一个直观的做法是根据题意进行模拟,只要 `num` 位数多于 $1$ 位就可以继续做。
代码:
```Java
class Solution {
public int addDigits(int num) {
while (num > 9) {
int t = 0;
while (num != 0) {
t += num % 10;
num /= 10;
}
num = t;
}
return num;... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.258` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/251-260/260. 只出现一次的数字 III（中等）.md | 260. 只出现一次的数字 III | https://leetcode-cn.com/problems/single-number-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-zgi4/ | 中等 | [
"模拟",
"哈希表",
"异或"
] | 给定一个整数数组 `nums`,其中恰好有两个元素只出现一次,其余所有元素均出现两次。
找出只出现一次的那两个元素,你可以按任意顺序返回答案。
示例 1:
```
输入:nums = [1,2,1,3,2,5]
输出:[3,5]
解释:[5, 3] 也是有效的答案。
```
示例 2:
```
输入:nums = [-1,0]
输出:[-1,0]
```
示例 3:
```
输入:nums = [0,1]
输出:[1,0]
```
提示:
* $2 <= nums.length <= 3 \times 10^4$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* 除两个只出现一次的整数外... | ### 哈希表
朴素的做法是利用哈希表进行统计,最后将统计次数为 $1$ 的元素加入答案。
Java 代码:
```Java
class Solution {
public int[] singleNumber(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
int[] ans = new int[2];
int idx = 0;
for (int i : ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.260` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2511-2520/2520. 统计能整除数字的位数（简单）.md | 2520. 统计能整除数字的位数 | https://leetcode.cn/problems/count-the-digits-that-divide-a-number/solutions/2498966/gong-shui-san-xie-jian-dan-mo-ni-ti-shi-0ad2c/?envType=daily-question&envId=2023-10-26 | 简单 | [
"模拟"
] | 给你一个整数 `num`,返回 `num` 中能整除 `num` 的数位的数目。
如果满足 `nums % val == 0`,则认为整数 `val` 可以整除 `nums`。
示例 1:
```
输入:num = 7
输出:1
解释:7 被自己整除,因此答案是 1 。
```
示例 2:
```
输入:num = 121
输出:2
解释:121 可以被 1 整除,但无法被 2 整除。由于 1 出现两次,所以返回 2 。
```
示例 3:
```
输入:num = 1248
输出:4
解释:1248 可以被它每一位上的数字整除,因此答案是 4 。
```
提示:
* $1 <= num <= 10^9$
* `n... | ### 模拟
根据题意进行模拟即可。
假设起始值为 `num`,符合要求的数位个数为 `ans`,按照「从低到高」的方式循环处理 `num` 中的每个数位:
1. 每次仅对当前数值 `num` 的最低位进行判断(当前数值 `num` 会被不断更新),**通过「模 $10$」的方式来「截取当前数值的最低位」**,并根据要求进行判断,若当前数位符合要求,对 `ans` 进行加一;
2. 判断完当前数组 `num` 的最低位后,**通过「与 $10$ 地板除」的方式来「摒弃当前数值的最低位」**,并以此更新 `num`;
3. 循环步骤 `1` 和步骤 `2`,直到 `num` 所有数位均被处理完,即 `num = 0`。
用... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2520` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2551-2560/2558. 从数量最多的堆取走礼物（简单）.md | 2558. 从数量最多的堆取走礼物 | https://leetcode.cn/problems/take-gifts-from-the-richest-pile/solutions/2501825/gong-shui-san-xie-ke-shi-hua-shou-xie-du-pp3a/ | 简单 | [
"优先队列(堆)"
] | 给你一个整数数组 `gifts`,表示各堆礼物的数量。
每一秒,你需要执行以下操作:
* 选择礼物数量最多的那一堆。
* 如果不止一堆都符合礼物数量最多,从中选择任一堆即可。
* 选中的那一堆留下平方根数量的礼物(向下取整),取走其他的礼物。
返回在 `k` 秒后剩下的礼物数量。
示例 1:
```
输入:gifts = [25,64,9,4,100], k = 4
输出:29
解释:
按下述方式取走礼物:
- 在第一秒,选中最后一堆,剩下 10 个礼物。
- 接着第二秒选中第二堆礼物,剩下 8 个礼物。
- 然后选中第一堆礼物,剩下 5 个礼物。
- 最后,再次选中最后一堆礼物,剩下 3 个礼物。
最后剩下的礼物... | ### 基本思想
为了方便,将 `gifts` 记为 `gs`。
从题面看,数组大小和执行次数范围均为 $1e3$,那么暴力做法的复杂度为 $O(n^2)$,计算量为 $1e6$,是可以通过的。
稍有数据结构基础的同学,容易进一步联想:存在一种数据结构,能够快速查得集合最值,使复杂度降低。
该数据结构是「堆」,在某些 `STL` 里面又称为「优先队列」。
---
### 手写堆入门
所有高级数据结构(例如之前讲过的 [字典树 Trie] 或 [并查集],都可以使用数组进行模拟,堆自然也不例外。
**堆本质是数据集合,只不过区别于简单数组而言,其具有 $O(1)$ 查找最值特性。**
既然我们使用数组来实现堆,同时... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2558` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2581-2590/2586. 统计范围内的元音字符串数（简单）.md | 2586. 统计范围内的元音字符串数 | https://leetcode.cn/problems/count-the-number-of-vowel-strings-in-range/solutions/2515898/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-di1t/ | 简单 | [
"模拟"
] | 给你一个下标从 $0$ 开始的字符串数组 `words` 和两个整数:`left` 和 `right`。
如果字符串以元音字母开头并以元音字母结尾,那么该字符串就是一个 元音字符串 ,其中元音字母是 `'a'`、`'e'`、`'i'`、`'o'`、`'u'`。
返回 $words[i]$ 是元音字符串的数目,其中 `i` 在闭区间 $[left, right]$ 内。
示例 1:
```
输入:words = ["are","amy","u"], left = 0, right = 2
输出:2
解释:
- "are" 是一个元音字符串,因为它以 'a' 开头并以 'e' 结尾。
- "amy" 不是元音字符串,因为它没有... | ### 模拟
检查下标范围在 $[left, right]$ 内的字符串 $words[i]$,若当前 $words[i]$ 首尾字母为 `aeiou` 之一,进行计数。
Java 代码:
```Java
class Solution {
public int vowelStrings(String[] words, int left, int right) {
int ans = 0;
for (int i = left; i <= right; i++) {
String s = words[i];
char a = s.charAt(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2586` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2601-2610/2609. 最长平衡子字符串（简单）.md | 2609. 最长平衡子字符串 | https://leetcode.cn/problems/find-the-longest-balanced-substring-of-a-binary-string/solutions/2517437/gong-shui-san-xie-on-shi-jian-o1-kong-ji-i8e7/ | 简单 | [
"模拟"
] | 给你一个仅由 `0` 和 `1` 组成的二进制字符串 `s` 。
如果子字符串中 所有的 `0` 都在 `1` 之前 且其中 `0` 的数量等于 `1` 的数量,则认为 `s` 的这个子字符串是平衡子字符串。
请注意,空子字符串也视作平衡子字符串。
返回 `s` 中最长的平衡子字符串长度。
子字符串是字符串中的一个连续字符序列。
示例 1:
```
输入:s = "01000111"
输出:6
解释:最长的平衡子字符串是 "000111" ,长度为 6 。
```
示例 2:
```
输入:s = "00111"
输出:4
解释:最长的平衡子字符串是 "0011" ,长度为 4 。
```
示例 3:
`... | ### 模拟
根据题意,平衡子字符串必然满足 `0...01...1` 格式(前半段全是 `0`,后半段全是 `1`,前后两段长度相同)。
使用变量 `idx` 对 `s` 进行遍历。在每轮处理过程中,按照如下流程进行:
1. 先统计连续段 `0` 的长度,记为 `a`;再统计连续段 `1` 的长度,记为 `b`(此操作满足:子串中 `0` 均在 `1` 前面)
2. 在 `a` 和 `b` 中取较小值,进行乘 $2$ 操作,作为当前平衡子字符串的长度,用于更新答案(此操作满足:子串中 `0` 和 `1` 数量相同)
3. 从当前轮的结束位置 `idx`,再进行下轮处理(重复步骤 $1$ 和步骤 $2$),直到 `s` 处理完... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2609` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/261-270/263. 丑数（简单）.md | 263. 丑数 | https://leetcode-cn.com/problems/ugly-number/solution/gong-shui-san-xie-jian-dan-de-fen-qing-k-dlvg/ | 简单 | [
"数学",
"模拟"
] | 给你一个整数 `n` ,请你判断 n 是否为 丑数 。如果是,返回 `true` ;否则,返回 `false` 。
丑数 就是只包含质因数 `2`、`3` 和 `5` 的正整数。
示例 1:
```
输入:n = 6
输出:true
解释:6 = 2 × 3
```
示例 2:
```
输入:n = 8
输出:true
解释:8 = 2 × 2 × 2
```
示例 3:
```
输入:n = 14
输出:false
解释:14 不是丑数,因为它包含了另外一个质因数 7 。
```
示例 4:
```
输入:n = 1
输出:true
解释:1 通常被视为丑数。
```
提示:
* $-2^{31} <= n ... | ### 朴素解法
输入范围是 $-2^{31} <= n <= 2^{31} - 1$,我们只需要对输入进行分情况讨论即可:
* 如果 $n$ 不是正整数(即小于等于 0):必然不是丑数,直接返回 `false`。
* 如果 $n$ 是正整数:我们对 $n$ 执行 `2`、 `3`、 `5` 的整除操作即可,直到 $n$ 被除干净,如果 $n$ 最终为 1 说明是丑数,否则不是丑数。
注意,`2` `3` `5` 先除哪一个都是可以的,因为乘法本身具有交换律。
代码:
```java
class Solution {
public boolean isUgly(int n) {
if (n <= 0)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.263` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/261-270/264. 丑数 II（中等）.md | 264. 丑数 II | https://leetcode-cn.com/problems/ugly-number-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-3nvs/ | 中等 | [
"多路归并",
"优先队列(堆)"
] | 给你一个整数 `n` ,请你找出并返回第 `n` 个 丑数 。
丑数 就是只包含质因数 `2`、`3` 和 `5` 的正整数。
示例 1:
```
输入:n = 10
输出:12
解释:[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。
```
示例 2:
```
输入:n = 1
输出:1
解释:1 通常被视为丑数。
```
提示:
* $1 <= n <= 1690$ | ### 基本思路
根据丑数的定义,我们有如下结论:
* $1$ 是最小的丑数。
* 对于任意一个丑数 $x$,其与任意的质因数($2$、$3$、$5$)相乘,结果($2x$、$3x$、$5x$)仍为丑数。
---
### 优先队列(小根堆)
有了基本的分析思路,一个简单的解法是使用优先队列:
1. 起始先将最小丑数 $1$ 放入队列
2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的丑数 $2x$、$3x$ 和 $5x$ 进行入队。
3. 对步骤 2 循环多次,第 $n$ 次出队的值即是答案。
为了防止同一丑数多次进队,我们需要使用数据结构 $Set$ 来记录入过队列的丑数。
Java 代码:
```Jav... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.264` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/261-270/268. 丢失的数字（简单）.md | 268. 丢失的数字 | https://leetcode-cn.com/problems/missing-number/solution/gong-shui-san-xie-yi-ti-wu-jie-pai-xu-ji-te3s/ | 简单 | [
"模拟",
"哈希表",
"位运算",
"数学"
] | 给定一个包含 $[0, n]$ 中 $n$ 个数的数组 $nums$ ,找出 $[0, n]$ 这个范围内没有出现在数组中的那个数。
示例 1:
```
输入:nums = [3,0,1]
输出:2
解释:n = 3,因为有 3 个数字,所以所有的数字都在范围 [0,3] 内。2 是丢失的数字,因为它没有出现在 nums 中。
```
示例 2:
```
输入:nums = [0,1]
输出:2
解释:n = 2,因为有 2 个数字,所以所有的数字都在范围 [0,2] 内。2 是丢失的数字,因为它没有出现在 nums 中。
```
示例 3:
```
输入:nums = [9,6,4,2,3,5,7,0,1]
输出:8
... | ### 排序
一个简单的做法是直接对 $nums$ 进行排序,找到符合 $nums[i] \neq i$ 的位置即是答案,如果不存在 $nums[i] \neq i$ 的位置,则 $n$ 为答案。
代码;
```Java
class Solution {
public int missingNumber(int[] nums) {
int n = nums.length;
Arrays.sort(nums);
for (int i = 0; i < n; i++) {
if (nums[i] != i) return i;
}
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.268` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2641-2650/2646. 最小化旅行的价格总和（困难）.md | 2646. 最小化旅行的价格总和 | null | 困难 | [
"图",
"DFS"
] | 现有一棵无向、无根的树,树中有 `n` 个节点,按从 `0` 到 `n - 1` 编号。
给你一个整数 `n` 和一个长度为 `n - 1` 的二维整数数组 `edges`,其中 $edges[i] = [a_{i}, b_{i}]$ 表示树中节点 $a_{i}$ 和 $b_{i}$ 之间存在一条边。
每个节点都关联一个价格。给你一个整数数组 `price`,其中 `price[i]` 是第 `i` 个节点的价格。
给定路径的价格总和是该路径上所有节点的价格之和。
另给你一个二维整数数组 `trips`,其中 $trips[i] = [start_{i}, end_{i}]$ 表示您从节点 $start_{i}$ 开始第 $... | ### DFS
Java 代码:
```Java
class Solution {
int N = 55, M = N * 2, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] t... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2651-2660/2656. K 个元素的最大和（简单）.md | 2656. K 个元素的最大和 | https://leetcode.cn/problems/maximum-sum-with-exactly-k-elements/solutions/2527384/gong-shui-san-xie-deng-chai-shu-lie-qiu-b2g88/ | 简单 | [
"数学"
] | 给你一个下标从 `0` 开始的整数数组 `nums` 和一个整数 `k` 。
你需要执行以下操作恰好 `k` 次,最大化你的得分:
1. 从 `nums` 中选择一个元素 `m` 。
2. 将选中的元素 `m` 从数组中删除。
3. 将新元素 `m + 1` 添加到数组中。
4. 你的得分增加 `m` 。
请你返回执行以上操作恰好 `k` 次后的最大得分。
示例 1:
```
输入:nums = [1,2,3,4,5], k = 3
输出:18
解释:我们需要从 nums 中恰好选择 3 个元素并最大化得分。
第一次选择 5 。和为 5 ,nums = [1,2,3,4,6] 。
第二次选择 6 。和为 6 ,nums ... | ### 数学
为了使得分最高,每次应从 `nums` 中选最大值,选完后重放仍为最大值。
假设原始 `nums` 中的最大值为 `max`,那么问题转换为「等差数列」求和:首项为 `max`,末项为 `max + k - 1`,项数为 $k$,公差为 $1$。
Java 代码:
```Java
class Solution {
public int maximizeSum(int[] nums, int k) {
int max = 0;
for (int x : nums) max = Math.max(max, x);
return k * (max + max + ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2656` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2661-2670/2661. 找出叠涂元素（中等）.md | 2661. 找出叠涂元素 | https://leetcode.cn/problems/first-completely-painted-row-or-column/solutions/2549034/gong-shui-san-xie-chang-gui-ha-xi-biao-y-jkxa/ | 中等 | [
"模拟",
"哈希表",
"计数"
] | 给你一个下标从 $0$ 开始的整数数组 `arr` 和一个 $m \times n$ 的整数矩阵 `mat`。
`arr` 和 `mat` 都包含范围 $[1,m \times n]$ 内的所有整数。
从下标 $0$ 开始遍历 `arr` 中的每个下标 `i` ,并将包含整数 `arr[i]` 的 `mat` 单元格涂色。
请你找出 `arr` 中在 `mat` 的某一行或某一列上都被涂色且下标最小的元素,并返回其下标 $i$ 。
示例 1:
```
输入:arr = [1,3,4,2], mat = [[1,4],[2,3]]
输出:2
解释:遍历如上图所示,arr[2] 在矩阵中的第一行或第二列上都被涂色。
```... | ### 哈希表
利用 `mat` 的数值各不相同,先使用「哈希表」对 `mat` 进行转存,以 $mat[i][j]$ 为键,$(i, j)$ 为值,方便后续快速查询某个值所在位置。
创建数组 `c1` 和 `c2`,分别记录某行某列有多少单元格被涂色,如 `c1[x] = a` 代表第 $x$ 行被涂色单元格数量为 $a$ 个,`c2[y] = b` 代表第 $y$ 列被涂色单元格数量为 $b$ 个。
遍历所有的 $arr[i]$,查询到 $arr[i]$ 的所在位置 $(x, y)$ 后,更新 `c1` 和 `c2`,若某行或某列被完全涂色,返回当前下标。
Java 代码:
```Java
class Solution... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2661` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2698-2700/2698. 求一个整数的惩罚数（中等）.md | 2698. 求一个整数的惩罚数 | https://leetcode.cn/problems/find-the-punishment-number-of-an-integer/solutions/2497448/gong-shui-san-xie-jian-dan-di-gui-yun-yo-qdxl/ | 中等 | [
"递归",
"模拟",
"打表"
] | 给你一个正整数 $n$,请你返回 $n$ 的 惩罚数 。
$n$ 的 惩罚数 定义为所有满足以下条件 $i$ 的数的平方和:
* $1 <= i <= n$
* $i \times i$ 的十进制表示的字符串可以分割成若干连续子字符串,且这些子字符串对应的整数值之和等于 $i$ 。
示例 1:
```
输入:n = 10
输出:182
解释:总共有 3 个整数 i 满足要求:
- 1 ,因为 1 * 1 = 1
- 9 ,因为 9 * 9 = 81 ,且 81 可以分割成 8 + 1 。
- 10 ,因为 10 * 10 = 100 ,且 100 可以分割成 10 + 0 。
因此,10 的惩罚数为 1 + 81 + 1... | ### 递归
一个朴素的做法是遍历 $[1, i]$,若当前数值 $i$ 满足要求,则将 $i \times i$ 累加到答案中。
问题关键转为:如何判定 $i \times i$ 是否能够分割成多个整数,使其累加值为 $i$。
简单做法是通过递归来做:每次从当前值的低位开始截取,通过「取余」和「地板除」操作,得到截取部分和剩余部分,再继续递归处理。
Java 代码:
```Java
class Solution {
public int punishmentNumber(int n) {
int ans = 0;
for (int i = 1; i <= n; i++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2698` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/273. 整数转换英文表示（困难）.md | 273. 整数转换英文表示 | https://leetcode-cn.com/problems/integer-to-english-words/solution/gong-shui-san-xie-zi-fu-chuan-da-mo-ni-b-0my6/ | 困难 | [
"模拟"
] | 将非负整数 `num` 转换为其对应的英文表示。
示例 1:
```
输入:num = 123
输出:"One Hundred Twenty Three"
```
示例 2:
```
输入:num = 12345
输出:"Twelve Thousand Three Hundred Forty Five"
```
示例 3:
```
输入:num = 1234567
输出:"One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
```
示例 4:
```
输入:num = 1234567891
输出:"One Billion Two Hu... | ### 模拟
字符串大模拟,重点之一是考察大家对数字英文单词的熟练程度。🤣
首先,英文好的同学自然知道数字表示是每三位一组进行的,英文不好的可能需要通过样例来找找规律。
由于是每三位一组进行表示,首要考虑实现一个 `num2Str` 函数,将十进制长度小于等于 $3$ 位的数字表示出来,然后在后面配合 `Billion`、`Million` 和 `Thousand` 即可表示出范围不超过 $2^{32}-1$ 的任意数字。
从定义出发 `num2Str` 需要解决 $[0, 999]$ 范围内的所有整数,但由于该函数需要复用到更大的位数来配合 `Billion`、`Million` 和 `Thousand`,而 `Zero... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.273` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/274. H 指数（中等）.md | 274. H 指数 | https://leetcode.cn/problems/h-index/solutions/2502896/gong-shui-san-xie-cong-po-ti-dao-zhu-bu-7sug6/ | 中等 | [
"二分",
"数学"
] | 给你一个整数数组 `citations`,其中 `citations[i]` 表示研究者的第 `i` 篇论文被引用的次数。计算并返回该研究者的 h 指数。
根据维基百科上 `h` 指数的定义:`h` 代表“高引用次数”,一名科研人员的 h指数是指他(她)的 (`n` 篇论文中)总共有 `h` 篇论文分别被引用了至少 `h` 次。且其余的 `n - h` 篇论文每篇被引用次数 不超过 `h` 次。
如果 `h` 有多种可能的值,`h` 指数是其中最大的那个。
示例 1:
```
输入:citations = [3,0,6,1,5]
输出:3
解释:给定数组表示研究者总共有 5 篇论文,每篇论文相应的被引用了 3, 0, 6... | ### 基本分析
为了方便,将 `citations` 记为 `cs`。
所谓的 `h` 指数是指一个具体的数值,**该数值为“最大”的满足「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」定义的合法数,重点是“最大”**。
用题面的实例 $1$ 来举个 🌰,给定所有论文的引用次数情况为 `cs = [3,0,6,1,5]`,可统计满足定义的数值有哪些:
* $h = 0$,含义为「至少发表了 $0$ 篇,且这 $0$ 篇论文至少被引用 $0$ 次」,空集即满足,恒成立;
* $h = 1$,含义为「至少发表了 $1$ 篇,且这 $1$ 篇论文至少被引用 $1$ 次」,可以找到这样的组合,如 `[3]`,成... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.274` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/275. H 指数 II（中等）.md | 275. H 指数 II | https://leetcode.cn/problems/h-index-ii/solutions/2504414/gong-shui-san-xie-si-hua-guo-du-cong-xia-rs00/ | 中等 | [
"二分",
"数学"
] | 给你一个整数数组 `citations`,其中 `citations[i]` 表示研究者的第 `i` 篇论文被引用的次数,`citations` 已经按照 **升序排列 **。计算并返回该研究者的 `h` 指数。
`h` 指数的定义:`h` 代表“高引用次数”(high citations),一名科研人员的 `h` 指数是指他(她)的 (`n` 篇论文中)总共有 `h` 篇论文分别被引用了至少 `h` 次。
请你设计并实现对数时间复杂度的算法解决此问题。
示例 1:
```
输入:citations = [0,1,3,5,6]
输出:3
解释:给定数组表示研究者总共有 5 篇论文,每篇论文相应的被引用了 0, 1, 3,... | ### 与前置题关系
本题与前置题 [274. H 指数](https://leetcode.cn/problems/h-index/) 的不同,主要体现在两个方面:
1. 数据范围不同:在 [274. H 指数](https://leetcode.cn/problems/h-index/) 里 $n$ 的范围为 $5000$,而本题 $n$ 的范围为 $10^5$;
2. 数组是否有序:在 [274. H 指数](https://leetcode-cn.com/problems/h-index/) 中数组不确保有序,本题则是有序。
增加了数组有序特性,又扩大了数据范围。
容易联想,利用此特性,存在复杂度更低的算法。
--... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.275` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/278. 第一个错误的版本（简单）.md | 278. 第一个错误的版本 | https://leetcode-cn.com/problems/first-bad-version/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-8hpv/ | 简单 | [
"二分"
] | 你是产品经理,目前正在带领一个团队开发新的产品。不幸的是,你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的,所以错误的版本之后的所有版本都是错的。
假设你有 `n` 个版本 `[1, 2, ..., n]`,你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 `bool isBadVersion(version)` 接口来判断版本号 `version` 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 `API` 的次数。
示例:
```
给定 n = 5,并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> fal... | ### 二分
一道交互题,根据题意可知,是尽可能少调用 `isBadVersion` 方法来找到分割点。
考虑存在「**没有错误版本**」和「**全是错误版本**」的情况,但如果往头部插入一个正确版本,往尾部插入一个错误版本作为哨兵,仍然具有「**二段性**」。
实际上,只需要进行这样的思考即可,不需要真正插入这样的哨兵,把这个哨兵逻辑放到最后返回的时候判断一下即可。
那么只需要将 `isBadVersion` 当做 `check` 函数进行二分即可。
**二分通常有以下两种写法,分别代表「找到最靠近中心的 `True`」 和「找到最靠近中心的 `False`」。**
另外根据数据范围需要注意计算 `mid` 时的爆 `... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.278` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/279. 完全平方数（中等）.md | 279. 完全平方数 | https://leetcode-cn.com/problems/perfect-squares/solution/gong-shui-san-xie-xiang-jie-wan-quan-bei-nqes/ | 中等 | [
"完全背包",
"动态规划",
"背包问题"
] | 给定正整数 n,找到若干个完全平方数(比如 1, 4, 9, 16, ...)使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。
给你一个整数 n ,返回和为 n 的完全平方数的 最少数量 。
完全平方数 是一个整数,其值等于另一个整数的平方;换句话说,其值等于一个整数自乘的积。例如,1、4、9 和 16 都是完全平方数,而 3 和 11 不是。
示例 1:
```
输入:n = 12
输出:3
解释:12 = 4 + 4 + 4
```
示例 2:
```
输入:n = 13
输出:2
解释:13 = 4 + 9
```
提示:
* 1 <= n <= $10^4$ | ### 完全背包(朴素解法)
首先「完全平方数」有无限个,但要凑成的数字是给定的。
因此第一步可以将范围在 $[1, n]$ 内的「完全平方数」预处理出来。
这一步其实就是把所有可能用到的「物品」预处理出来。
从而将问题转换为:**给定了若干个数字,每个数字可以被使用无限次,求凑出目标值 $n$ 所需要用到的是最少数字个数是多少。**
由于题目没有限制我们相同的「完全平方数」只能使用一次,属于「完全背包」模型。
目前我们学过的两类背包问题(01 背包 & 完全背包)的原始状态定义都是两维:
* 第一维 $i$ 代表物品编号
* 第二维 $j$ 代表容量
其中第二维 $j$ 又有「不超过容量 $j$」和「容量恰好为 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.279` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2731-2740/2736. 最大和查询（困难）.md | 2736. 最大和查询 | https://leetcode.cn/problems/maximum-sum-queries/solutions/2530269/gong-shui-san-xie-cong-yi-wei-xian-zhi-d-ww8r/ | 困难 | [
"排序",
"离散化",
"树状数组"
] | 给你两个长度为 `n`、下标从 `0` 开始的整数数组 `nums1` 和 `nums2`,另给你一个下标从 `1` 开始的二维数组 `queries`,其中 $queries[i] = [x_{i}, y_{i}]$ 。
对于第 `i` 个查询,在所有满足 $nums1[j] >= x_{i}$ 且 $nums2[j] >= y_{i}$ 的下标 `j` ($0 <= j < n$) 中,找出 $nums1[j] + nums2[j]$ 的 最大值 ,如果不存在满足条件的 `j` 则返回 $-1$。
返回数组 `answer`,其中 `answer[i]` 是第 `i` 个查询的答案。
示例 1:
```
输入:nums1 ... | ### 离散化 + 排序 + 树状数组
根据题意,两个等长数组 `num1` 和 `nums2`,只能是相同下标的元素凑成一对。
不妨用两个一维数组 `nums1` 和 `nums2` 构建出一个二维数组 `nums`,方便后续处理,其中 $nums[i] = [nums1[i], nums2[i]]$。
同时对 `queries` 进行简单拓展,构建新的二维数组 `nq`,目的是对原有下标信息进行记录,其中 $nq[i] = [queries[i][0], queries[i][1], i]$(此处构建新 `nq` 的作用,下文会说)。
好了,现在我们有两个新的数组 `nums` 和 `nq`,接下来所有讨论都会针对新数... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2751-2760/2760. 最长奇偶子数组（简单）.md | 2698. 求一个整数的惩罚数 | https://leetcode.cn/problems/longest-even-odd-subarray-with-threshold/solutions/2528837/gong-shui-san-xie-chou-si-bo-chong-tu-ji-n9r1/ | 简单 | [
"双指针",
"滑动窗口"
] | 给你一个下标从 $0$ 开始的整数数组 `nums` 和一个整数 `threshold`。
请你从 `nums` 的子数组中找出以下标 `l` 开头、下标 `r` 结尾 ($0 <= l <= r < nums.length$) 且满足以下条件的 最长子数组 :
* `nums[l] % 2 == 0`
* 对于范围 $[l, r - 1]$ 内的所有下标 `i`,`nums[i] % 2 != nums[i + 1] % 2`
* 对于范围 $[l, r]$ 内的所有下标 `i`,`nums[i] <= threshold`
以整数形式返回满足题目要求的最长子数组的长度。
注意:子数组 是数组中的一个连续非空元素序列。
... | ### 双指针
整体题意:找 `nums` 中的最长的子数组 $[l, r]$,对于任意 $nums[i]$ 不超过 `threshold`,且从 $nums[l]$ 开始按照「先偶后奇」顺序交替。
假设子数组的左端点为 `i`,且“最远的”合法右端点为 `j`,那么在 $[i, j]$ 之间的任意右端点 `k`,即使能够使得 $nums[i...k]$ 合法,对统计答案而言,也是没有意义的,因为我们求的是最长。
基于此,我们容易想到:**找到所有的合法左端点 `i`,并统计该合法左端点的最远右端点 `j`。跳过 $[i, j]$ 之间的点作为左端点的情况,直接从结束位置 `j` 开始找下一个合法左端点。**
该做法可将朴素... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2760` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/281-290/282. 给表达式添加运算符（困难）.md | 282. 给表达式添加运算符 | https://leetcode-cn.com/problems/peeking-iterator/solution/gong-shui-san-xie-die-dai-qi-ji-ben-ren-b77lz/ | 困难 | [
"DFS",
"数学"
] | 给定一个仅包含数字 `0-9` 的字符串 `num` 和一个目标值整数 `target` ,在 `num` 的数字之间添加 二元 运算符(不是一元)`+`、`-` 或 `*` ,返回所有能够得到目标值的表达式。
示例 1:
```
输入: num = "123", target = 6
输出: ["1+2+3", "1*2*3"]
```
示例 2:
```
输入: num = "232", target = 8
输出: ["2*3+2", "2+3*2"]
```
示例 3:
```
输入: num = "105", target = 5
输出: ["1*0+5","10-5"]
```
示例 4:
```
输入: nu... | ### 回溯算法
最开始的想法是先使用 `DFS` 搜出来所有的表达式,然后套用 [(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 方案,计算所有表达式的结果,并将计算结果为 $target$ 的表达式加到结果集。
假设原字符串 $num$ 的长度为 $n$,由于每个位置之间存在四种插入决策(不插入符号、`+`、`-` 和 `*`),共有 $n - 1$ 个位置需要决策,因此搜索所有表达式的复杂度为 $O(4^{n - 1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.282` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/281-290/284. 顶端迭代器（中等）.md | 284. 顶端迭代器 | https://leetcode-cn.com/problems/peeking-iterator/solution/gong-shui-san-xie-die-dai-qi-ji-ben-ren-b77lz/ | 中等 | [
"数据结构",
"模拟"
] | 请你设计一个迭代器,除了支持 `hasNext` 和 `next` 操作外,还支持 `peek` 操作。
实现 `PeekingIterator` 类:
* `PeekingIterator(int[] nums)` 使用指定整数数组 `nums` 初始化迭代器。
* `int next()` 返回数组中的下一个元素,并将指针移动到下个元素处。
* `bool hasNext()` 如果数组中存在下一个元素,返回 `true` ;否则,返回 `false`。
* `int peek()` 返回数组中的下一个元素,但 **不** 移动指针。
示例:
```
输入:
["PeekingIterator", "next", "peek... | ### 迭代器基本认识 + 模拟
常规的迭代器的「访问」只支持两种操作:
* `hasNext()` 操作:如果存在下一元素,返回 `True`,否则返回 `False`。实现上,就是判断游标是否到达结尾位置;
* `next()` 操作:返回下一元素(当不存在下一元素时,返回 `null`)。实现上,就是返回游标指向的元素,并让游标后移。
在本题,还需要我们额外支持 `peek()` 操作,即在移动游标的前提下,返回游标指向的元素。
实现上,我们可以让操作提前一步进行,事先调用一次 `next()` 并使用该变量 $next$ 存起该元素,通过外部调用 `peek()` 还是 `next()` 来决定是否要更新 $next... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.284` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/281-290/287. 寻找重复数（中等）.md | 287. 寻找重复数 | https://leetcode.cn/problems/find-the-duplicate-number/solution/by-ac_oier-az8v/ | 中等 | [
"桶排序",
"原地哈希"
] | 给定一个包含 `n + 1` 个整数的数组 `nums`,其数字都在 $[1, n]$ 范围内(包括 $1$ 和 $n$),可知至少存在一个重复的整数。
假设 `nums` 只有 一个重复的整数 ,返回 这个重复的数 。
你设计的解决方案必须 不修改 数组 `nums` 且只用常量级 $O(1)$ 的额外空间。
示例 1:
```
输入:nums = [1,3,4,2,2]
输出:2
```
示例 2:
```
输入:nums = [3,1,3,4,2]
输出:3
```
提示:
* $1 <= n <= 10^5$
* $nums.length = n + 1$
* $1 <= nums[i] <= n$
* `num... | ### 原地哈希
数组长度为 $n + 1$,同时给定的 $nums[i]$ 都在 $[1, n]$ 范围内,因此我们可以设定哈希规则为 $nums[idx] = idx + 1$,即数值 `x` 会放在下标 $x - 1$ 的位置。
如此一来,对于只出现一次的数值而言,必然能够顺利放在目标位置,而出现多次的数值必然会因为位置冲突而被找出。
Java 代码:
```Java
class Solution {
public int findDuplicate(int[] nums) {
for (int i = 0; i < nums.length; ) {
int t = num... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.287` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2821-2830/2824. 统计和小于目标的下标对数目（简单）.md | 2824. 统计和小于目标的下标对数目 | https://leetcode.cn/problems/count-pairs-whose-sum-is-less-than-target/solutions/2539761/gong-shui-san-xie-xiang-jie-zuo-zhao-you-1yji/ | 简单 | [
"排序",
"二分",
"双指针"
] | 给你一个下标从 `0` 开始长度为 `n` 的整数数组 `nums` 和一个整数 `target`,请你返回满足 `0 <= i < j < n` 且 `nums[i] + nums[j] < target` 的下标对 $(i, j)$ 的数目。
示例 1:
```
输入:nums = [-1,1,2,3,1], target = 2
输出:3
解释:总共有 3 个下标对满足题目描述:
- (0, 1) ,0 < 1 且 nums[0] + nums[1] = 0 < target
- (0, 2) ,0 < 2 且 nums[0] + nums[2] = 1 < target
- (0, 4) ,0 < 4 且 nums[... | ### 基本分析
为了方便,先对 `nums` 进行排序。
当 `nums` 有了有序特性后,剩下的便是「遍历右端点,在右端点左侧找最大合法左端点」或「遍历左端点,在左端点右侧找最大合法右端点」过程。
---
### 排序 + 二分
这是一种「遍历右端点,在右端点左侧找最大合法左端点」做法。
遍历右端点 `i`,然后在 $[0, i - 1]$ 范围内进行二分,找到最大的满足 $nums[j] + nums[i] < target$ 的位置 `j`。
若存在这样左端点 `j`,说明以 $nums[i]$ 为右端点时,共有 $j + 1$ 个(范围为 $[0, j]$ )个合法左端点,需要被统计。
Java 代码:
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2824` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2871-2880/2876. 有向图访问计数（困难）.md | 2876. 有向图访问计数 | https://leetcode.cn/problems/count-visited-nodes-in-a-directed-graph/solutions/2512278/gong-shui-san-xie-sha-shi-nei-xiang-wai-d3lm9/ | 困难 | [
"基环森林",
"内向基环树",
"拓扑排序",
"图",
"BFS"
] | 现有一个有向图,其中包含 `n` 个节点,节点编号从 `0` 到 `n - 1`。此外,该图还包含了 `n` 条有向边。
给你一个下标从 `0` 开始的数组 `edges`,其中 `edges[i]` 表示存在一条从节点 `i` 到节点 `edges[i]` 的边。
想象在图上发生以下过程:
你从节点 `x` 开始,通过边访问其他节点,直到你在 此过程 中再次访问到之前已经访问过的节点。
返回数组 `answer` 作为答案,其中 `answer[i]` 表示如果从节点 `i` 开始执行该过程,你可以访问到的不同节点数。
示例 1:
```
输入:edges = [1,2,0,0]
输出:[3,3,3,4]
解释:从... | ### 内向基环森林 + 拓扑排序
根据题意,共 `n` 个点,`n` 条边,利用 `edges`,将 `i` 向 `edges[i]` 连有向边,可知每个点有唯一的出边,因此这是一张可能包含多棵「内向基环树」的「基环森林」。
基环树是指其具有 $n$ 个点 $n$ 条边的联通块,而「内向」是指树中任意节点有且只有一条出边,对应的「外向」是指树中任意节点有且只有一条入边。
例如,左图内向,右图外向:
显然,可根据当前节点是否在“环内”进行分情况讨论:
* 对于「环内」节点来说,其答案为环节点个数;
* 对于「环外」节点来说,直观感受应该是由环上节点转移而来。但由于本题给定的是「内向基环树」,因此我们需要对原图进行“反向”,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2876` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/292. Nim 游戏（简单）.md | 292. Nim 游戏 | https://leetcode-cn.com/problems/nim-game/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-wmz2t/ | 简单 | [
"博弈论"
] | 你和你的朋友,两个人一起玩 `Nim` 游戏:
* 桌子上有一堆石头。
* 你们轮流进行自己的回合,你作为先手。
* 每一回合,轮到的人拿掉 `1-3` 块石头。
* 拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数,来判断你是否可以在给定石头数量为 `n` 的情况下赢得游戏。如果可以赢,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:n = 4
输出:false
解释:如果堆中有 4 块石头,那么你永远不会赢得比赛;
因为无论你拿走 1 块、2 块 还是 3 块石头,最后一块石头总是会被你的朋友拿走。
```
示例 2:
```
输入:n = 1
输出:... | ### 博弈论
这是一道 Nim 游戏的简化版。
**在不知晓博弈论结论前,可以先通过找规律得到猜想,然后再从「何种情况下,先手会处于必胜态」的角度来进行分析。**
根据题意,我们尝试从小范围数据的情况进行讨论:
1. 如果落到先手的局面为「**石子数量为 `1-3`**」的话,那么**先手必胜**;
2. 如果落到先手的局面为「**石子数量为 `4`**」的话,那么先手决策完(无论何种决策),交到后手的局面为「石子数量为 `1-3`」,即此时后手必胜,对应**先手必败**(到这里我们有一个推论:如果交给先手的局面为 `4` 的话,那么先手必败);
3. 如果落到先手的局面为「**石子数量为 `5-7`**」的话,那么先手可... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.292` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/295. 数据流的中位数（困难）.md | 295. 数据流的中位数 | https://leetcode-cn.com/problems/find-median-from-data-stream/solution/gong-shui-san-xie-jing-dian-shu-ju-jie-g-pqy8/ | 困难 | [
"优先队列(堆)"
] | 中位数是有序列表中间的数。如果列表长度是偶数,中位数则是中间两个数的平均值。
例如,
* `[2,3,4]` 的中位数是 $3$
* `[2,3]` 的中位数是 $(2 + 3) / 2 = 2.5$
设计一个支持以下两种操作的数据结构:
* `void addNum(int num)` - 从数据流中添加一个整数到数据结构中。
* `double findMedian()` - 返回目前所有元素的中位数。
示例:
```
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2
```
进阶:
* 如果数据流中所有整数都在 $0$ 到 $10... | ### 优先队列(堆)
这是一道经典的数据结构运用题。
具体的,**我们可以使用两个优先队列(堆)来维护整个数据流数据,令维护数据流左半边数据的优先队列(堆)为 `l`,维护数据流右半边数据的优先队列(堆)为 `r`**。
显然,**为了可以在 $O(1)$ 的复杂度内取得当前中位数,我们应当令 `l` 为大根堆,`r` 为小根堆,并人为固定 `l` 和 `r` 之前存在如下的大小关系**:
* **当数据流元素数量为偶数:`l` 和 `r` 大小相同,此时动态中位数为两者堆顶元素的平均值;**
* **当数据流元素数量为奇数:`l` 比 `r` 多一,此时动态中位数为 `l` 的堆顶原数。**
为了满足上述说的奇偶性堆大... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.295` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/297. 二叉树的序列化与反序列化（困难）.md | 297. 二叉树的序列化与反序列化 | https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof/solution/gong-shui-san-xie-er-cha-shu-de-xu-lie-h-n89a/ | 困难 | [
"二叉树",
"层序遍历"
] | 序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。
示例 1:
```
输入:root = [1,2,3,null,null,4,5]
输出:[1,2,3... | ### 基本思路
无论使用何种「遍历方式」进行二叉树存储,为了方便,我们都需要对空节点有所表示。
其实题目本身的样例就给我们提供了很好的思路:**使用层序遍历的方式进行存储,对于某个叶子节点的空节点进行存储,同时确保不递归存储空节点对应的子节点。**
---
### 层序遍历
根据节点值的数据范围 `-1000 <= Node.val <= 1000`(我是在 [297. 二叉树的序列化与反序列化](https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/) 看的,你也可以不使用数字,使用某个特殊字符进行表示,只要能在反序列时有所区分即可... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.297` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/299. 猜数字游戏（中等）.md | 299. 猜数字游戏 | https://leetcode-cn.com/problems/bulls-and-cows/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-tdhs/ | 中等 | [
"模拟"
] | 你在和朋友一起玩 猜数字(`Bulls and Cows`)游戏,该游戏规则如下:
写出一个秘密数字,并请朋友猜这个数字是多少。朋友每猜测一次,你就会给他一个包含下述信息的提示:
* 猜测数字中有多少位属于数字和确切位置都猜对了(称为 `"Bulls"`, 公牛),
* 有多少位属于数字猜对了但是位置不对(称为 `"Cows"`, 奶牛)。也就是说,这次猜测中有多少位非公牛数字可以通过重新排列转换成公牛数字。
给你一个秘密数字 `secret` 和朋友猜测的数字 `guess`,请你返回对朋友这次猜测的提示。
提示的格式为 `"xAyB"` ,`x` 是公牛个数, `y` 是奶牛个数,`A` 表示公牛,`B` 表示奶牛。
... | ### 模拟
根据题意,我们可以对 $secret$ 和 $guess$ 进行诸位比较,统计公牛数量 $a$ 和奶牛数量 $b$。
对于字符相同的位置,我们可以直接对 $a$ 进行自增;对于字符不同的位置,使用「哈希表」进行分别统计 $secret$ 和 $guess$ 的词频,某个数字 $x$ 在两者词频中的较小值,即为该数字对应的奶牛数量,统计所有数字 $[0, 9]$ 的奶牛数量总和即为 $b$。
代码:
```Java
class Solution {
public String getHint(String secret, String guess) {
int n = secret.leng... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.299` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/301. 删除无效的括号（困难）.md | 301. 删除无效的括号 | https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/yi-fen-zhong-nei-kan-dong-jiang-gua-hao-aya6k/ | 困难 | [
"括号问题",
"回溯算法",
"DFS"
] | 给你一个由若干括号和字母组成的字符串 `s`,删除最小数量的无效括号,使得输入的字符串有效。
返回所有可能的结果。答案可以按 任意顺序 返回。
示例 1:
```
输入: "()())()"
输出: ["()()()", "(())()"]
```
示例 2:
```
输入: "(a)())()"
输出: ["(a)()()", "(a())()"]
```
示例 3:
```
输入: ")("
输出: [""]
```
提示:
* $1 <= s.length <= 25$
* `s` 由小写英文字母以及括号 `'('` 和 `')'` 组成
* `s` 中至多含 `20` 个括号 | ### 搜索 + 剪枝
由于题目要求我们将所有(最长)合法方案输出,因此不可能有别的优化,只能进行「爆搜」。
我们可以使用 `DFS` 实现回溯搜索。
基本思路:
我们知道所有的合法方案,必然有左括号的数量与右括号数量相等。
首先我们令左括号的得分为 $1$;右括号的得分为 $-1$。则会有如下性质:
1. 对于一个合法的方案而言,必然有最终得分为 $0$;
2. 搜索过程中不会出现得分值为 **负数** 的情况(当且仅当子串中某个前缀中「右括号的数量」大于「左括号的数量」时,会出现负数,此时不是合法方案)。
同时我们可以预处理出「爆搜」过程的最大得分: `max = min(左括号的数量, 右括号的数量)`
**P... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.301` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/303. 区域和检索 - 数组不可变（简单）.md | 303. 区域和检索 - 数组不可变 | https://leetcode-cn.com/problems/range-sum-query-immutable/solution/sha-shi-qian-zhui-he-ya-tu-jie-qian-zhui-0rla/ | 简单 | [
"前缀和",
"区间求和问题"
] | 给定一个整数数组 `nums`,求出数组从索引 `i` 到 `j`(`i ≤ j`)范围内元素的总和,包含 `i`、`j` 两点。
实现 `NumArray` 类:
* `NumArray(int[] nums)` 使用数组 `nums` 初始化对象
* `int sumRange(int i, int j)` 返回数组 `nums` 从索引 `i` 到 `j`(`i ≤ j`)范围内元素的总和,包含 i、j 两点(也就是 `sum(nums[i], nums[i + 1], ... , nums[j])`)
示例:
```
输入:
["NumArray", "sumRange", "sumRange", "sumRange"]... | ### 前缀和(一维)
这是一道前缀和裸题。
当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。
所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。
设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。
有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。
通用公式:`ans = sum[j] - sum[i - 1]`。
由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.303` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/304. 二维区域和检索 - 矩阵不可变（中等）.md | 304. 二维区域和检索 - 矩阵不可变 | https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/ | 中等 | [
"前缀和",
"区间求和问题"
] | 给定一个二维矩阵,计算其子矩形范围内元素的总和,该子矩阵的左上角为 (row1, col1) ,右下角为 (row2, col2) 。
上图子矩阵左上角 (row1, col1) = (2, 1) ,右下角(row2, col2) = (4, 3),该子矩形内元素的总和为 8。
示例:
```
给定 matrix = [
[3, 0, 1, 4, 2],
[5, 6, 3, 2, 1],
[1, 2, 0, 1, 5],
[4, 1, 0, 1, 7],
[1, 0, 3, 0, 5]
]
sumRegion(2, 1, 4, 3) -> 8
sumRegion(1, 1, 2, 2) -> 11
sumR... | ### 前缀和解法(二维)
真就是今天的「每日一题」呗 ~
这是一道「二维前缀和」的裸题。
「二维前缀和」解决的是二维矩阵中的矩形区域求和问题。
**二维前缀和数组中的每一个格子记录的是「以当前位置为区域的右下角(区域左上角恒定为原数组的左上角)的区域和」**
贴一张官解示意图,我觉得很清晰:
**如果觉得不清晰,请将将 f[i][j] 理解成是以 (i, j) 为右下角,(0, 0) 为左上角的区域和。**
因此当我们要求 (x1, y1) 作为左上角,(x2, y2) 作为右下角 的区域和的时候,可以直接利用前缀和数组快速求解:
`sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.304` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/306. 累加数（中等）.md | 306. 累加数 | https://leetcode-cn.com/problems/additive-number/solution/gong-shui-san-xie-hui-su-gao-jing-du-jia-6o6b/ | 中等 | [
"回溯算法",
"高精度"
] | 累加数 是一个字符串,组成它的数字可以形成累加序列。
一个有效的 累加序列 必须 至少 包含 `3` 个数。除了最开始的两个数以外,字符串中的其他数都等于它之前两个数相加的和。
给你一个只包含数字 `'0'-'9'` 的字符串,编写一个算法来判断给定输入是否是 累加数 。如果是,返回 `true` ;否则,返回 `false` 。
说明:累加序列里的数 不会 以 `0` 开头,所以不会出现 `1`, `2`, `03` 或者 `1`, `02`, `3` 的情况。
示例 1:
```
输入:"112358"
输出:true
解释:累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3... | ### 回溯 + 高精度加法
给定的 $nums$ 的长度只有 $35$,且要求序列的第三个数开始由前两个数相加而来。
容易想到通过 `DFS` 爆搜每个数的分割点,同时利用累加数的特性(第三个数起,每个数均由为前两数之和)进行剪枝。
具体的,我们可以实现一个 `boolean dfs(int u)` 函数,入参为当前决策到 $num$ 的哪一位,返回值为决策结果(序列)是否为累加数序列,爆搜过程中的分割数序列存放到 $list$ 中。
由于是 **从位置 $u$ 作为开始位置决策如何分割出当前数 $x$,我们可以枚举当前数的结束位置,范围为 $[u, n - 1]$,但需要注意分割数不能包含前导零,即如果 $num[u] ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.306` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/307. 区域和检索 - 数组可修改（中等）.md | 307. 区域和检索 - 数组可修改 | https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/ | 中等 | [
"区间和",
"树状数组",
"线段树"
] | 给你一个数组 `nums`,请你完成两类查询,其中一类查询要求更新数组下标对应的值,另一类查询要求返回数组中某个范围内元素的总和。
实现 `NumArray` 类:
* `NumArray(int[] nums)` 用整数数组 `nums` 初始化对象
* `void update(int index, int val)` 将 `nums[index]` 的值更新为 `val`
* `int sumRange(int left, int right)` 返回子数组 `nums[left, right]` 的总和(即,`nums[left] + nums[left + 1], ..., nums[right]`)
示例:
```
... | ### 解题思路
这是一道很经典的题目,通常还能拓展出一大类问题。
针对不同的题目,我们有不同的方案可以选择(假设我们有一个数组):
1. 数组不变,求区间和:「前缀和」、「树状数组」、「线段树」
2. 多次修改某个数(单点),求区间和:「树状数组」、「线段树」
3. 多次修改某个区间,输出最终结果:「差分」
4. 多次修改某个区间,求区间和:「线段树」、「树状数组」(看修改区间范围大小)
5. 多次将某个区间变成同一个数,求区间和:「线段树」、「树状数组」(看修改区间范围大小)
这样看来,「线段树」能解决的问题是最多的,那我们是不是无论什么情况都写「线段树」呢?
答案并不是,而且恰好相反,只有在我们遇到第 4/5 类问题... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.307` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/310. 最小高度树（中等）.md | 310. 最小高度树 | https://leetcode-cn.com/problems/minimum-height-trees/solution/by-ac_oier-7xio/ | 中等 | [
"树形 DP",
"DFS",
"动态规划"
] | 树是一个无向图,其中任何两个顶点只通过一条路径连接。 换句话说,一个任何没有简单环路的连通图都是一棵树。
给你一棵包含 $n$ 个节点的树,标记为 $0$ 到 $n - 1$ 。给定数字 $n$ 和一个有 $n - 1$ 条无向边的 `edges` 列表(每一个边都是一对标签),其中 $edges[i] = [a_i, b_i]$ 表示树中节点 $a_i$ 和 $b_i$ 之间存在一条无向边。
可选择树中任何一个节点作为根。当选择节点 $x$ 作为根节点时,设结果树的高度为 $h$ 。在所有可能的树中,具有最小高度的树(即,`min(h)`)被称为 最小高度树 。
请你找到所有的 **最小高度树** 并按 **任意顺序** 返... | ### 树形 DP
这是一道树形 DP 模板题。
当确定以某个点为根节点时,整棵树的形态唯一固定,不妨以编号为 $0$ 的节点作为根节点进行分析。
假设当前处理到的节点为 `u`,其是从父节点 `fa` 遍历而来,且将要遍历的子节点为 `j`。
即树的形态如图所示(一些可能有的出边用虚线表示):
**树形 DP 问题通常将问题根据「方向」进行划分**。
对于当前处理到的节点 `u` 而言,我们根据是否考虑「从 `fa` 到 `u` 的出边」将其分为「往上」和「往下」两个方向。
假设我们可以通过 `DFS` 预处理出 $f$ 数组和 $g$ 数组:
* $f[u]$ 代表在以 $0$ 号点为根节点的树中,以 `u` 节... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/31. 下一个排列（中等）.md | 31. 下一个排列 | https://leetcode-cn.com/problems/next-permutation/solution/miao-dong-xi-lie-100-cong-xia-yi-ge-pai-gog8j/ | 中等 | [
"模拟",
"数学"
] | 实现获**下一个排列**的函数,算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列,则将数字重新排列成最小的排列(即升序排列)。
必须「原地」修改,只允许使用额外常数空间。
示例 1:
```
输入:nums = [1,2,3]
输出:[1,3,2]
```
示例 2:
```
输入:nums = [3,2,1]
输出:[1,2,3]
```
示例 3:
```
输入:nums = [1,1,5]
输出:[1,5,1]
```
示例 4:
```
输入:nums = [1]
输出:[1]
```
提示:
* $1 <= nums.length <= 100$
* $0 <= num... | ### 模拟
找下一个排列的数,大家可以先想想大脑来是怎么完成这个找数的过程的。
**我们会尽可能的将低位的数字变大,这样才符合「下一个排列」的定义。**
也就是从低位往高位检查,观察某一位在「下一个排列」中是否可以被更大的数代替。
那么如何判断某一位能够被更大的数代替呢?
**其实就是将 `k` 位到低位的所有数作为候选,判断是否有更大的数可以填入 `k` 位中。**
假设当前我们检查到 `k` 位,要分析第 `k` 位在「下一个排列」中是否能被更大的数代替。
我们会先假定高位到 `k` 位的数不变,在 `k` 位到低位中是否有比 `k` 位上的数更大的数,如果有说明 `k` 在「下一个排列」中变大。
换句话说,我... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.31` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/32. 最长有效括号（困难）.md | 32. 最长有效括号 | https://leetcode.cn/problems/longest-valid-parentheses/solutions/577327/shua-chuan-lc-miao-dong-xi-lie-shi-yong-95ezk/ | 困难 | [
"栈",
"括号问题"
] | 给你一个只包含 `'('` 和 `')'` 的字符串,找出最长有效(格式正确且连续)括号子串的长度。
示例 1:
```
输入:s = "(()"
输出:2
解释:最长有效括号子串是 "()"
```
示例 2:
```
输入:s = ")()())"
输出:4
解释:最长有效括号子串是 "()()"
```
示例 3:
```
输入:s = ""
输出:0
```
提示:
* $0 <= s.length <= 3 \times 10^4$
* $s[i]$ 为 `'('` 或 `')'` | ### 栈
从前往后扫描字符串 `s`。
用 `i` 来记录当前遍历到的位置,用 `j` 来记录最近的最长有效括号的开始位置的「前一个位置」。
只对 `'('` 进行入栈(入栈的是对应的下标),当遍历到 `')'` 的时候,由于栈中只有 `'('`,所以可以直接弹出一个 `'('` 与之匹配(如果有的话)。
再检查栈中是否还有 `'('`,如果有使用栈顶元素的下标来计算长度,否则使用 `j` 下标来计算长度。
该做法的本质:**栈里只存放待匹配的 `(` 符号,虽然这些 `(` 在原字符串中的下标不一定连续,但 `(` 之间一定为有效括号,因此可以使用栈顶元素作为有效括号的左边界计算长度**。
举个 🌰,对于 `s` ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.32` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/33. 搜索旋转排序数组（中等）.md | 33. 搜索旋转排序数组 | https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/ | 中等 | [
"二分"
] | 整数数组 `nums` 按升序排列,数组中的值互不相同。
在传递给函数之前,`nums` 在预先未知的某个下标 $k$ ($0 <= k < nums.length$)上进行了**旋转**。
使数组变为 `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]`(下标 从 $0$ 开始计数)。
例如, `[0,1,2,4,5,6,7]` 在下标 $3$ 处经旋转后可能变为 `[4,5,6,7,0,1,2] `。
给你**旋转后**的数组 `nums` 和一个整数 `target` 。
如果 `nums` 中存在这个目标值 `target`... | ### 先找旋转点后二分
但凡是从有序序列中找某个数,我们第一反应应该是「二分」。
这道题是一个原本有序的数组在某个点上进行了旋转,其实就是将原本一段升序的数组分为了两段。
我们可以先找到旋转点 `idx`,然后对 `idx` 前后进行「二分」。
Java 代码:
```Java
class Solution {
public int search(int[] nums, int target) {
int n = nums.length, idx = -1;
for (int i = 0; i < n - 1 && idx == -1; i++) {
if (... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.33` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/34. 在排序数组中查找元素的第一个和最后一个位置（中等）.md | 34. 在排序数组中查找元素的第一个和最后一个位置 | https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/sha-sha-gao-bu-qing-ru-he-ding-yi-er-fen-rrj1/ | 中等 | [
"二分"
] | 给定一个按照升序排列的整数数组 `nums`,和一个目标值 `target`。
找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 `target`,返回 $[-1, -1]$。
**进阶:**
* 你可以设计并实现时间复杂度为 $O(\log{n})$ 的算法解决此问题吗?
示例 1:
```
输入:nums = [5,7,7,8,8,10], target = 8
输出:[3,4]
```
示例 2:
```
输入:nums = [5,7,7,8,8,10], target = 6
输出:[-1,-1]
```
示例 3:
```
输入:nums = [], target = 0
输出:[-1,... | ### 二分解法
这是一道「二分查找」的裸题。
「二分」有一个比较容易混淆的点是:当需要找目标值第一次出现的下标时,条件应该写成 `nums[mid] >= target` 还是 `nums[mid] <= target`。
其实有一个很好理解的方法:
**由于二分是从中间开始找起的,所以找的必然是条件区间中靠近中心的的边界值。**
文字不好理解,我们结合图片来看:
代码:
```Java
class Solution {
public int[] searchRange(int[] nums, int t) {
int[] ans = new int[]{-1, -1};
int... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.34` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/35. 搜索插入位置（简单）.md | 35. 搜索插入位置 | https://leetcode-cn.com/problems/search-insert-position/solution/shua-chuan-lc-jian-dan-mo-ni-ti-by-ac_oi-7d5t/ | 简单 | [
"模拟",
"二分"
] | 给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。
如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
```
输入: [1,3,5,6], 5
输出: 2
```
示例 2:
```
输入: [1,3,5,6], 2
输出: 1
```
示例 3:
```
输入: [1,3,5,6], 7
输出: 4
```
示例 4:
```
输入: [1,3,5,6], 0
输出: 0
``` | ### 朴素做法
一个朴素的做法,从前往后进行处理,直到遇到符合条件的位置。
代码:
```Java
class Solution {
public int searchInsert(int[] nums, int t) {
for (int i = 0; i < nums.length; i++) {
if (nums[i] == t || nums[i] > t) return i;
}
return nums.length;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 二分解法
利... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.35` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/36. 有效的数独（中等）.md | 36. 有效的数独 | https://leetcode-cn.com/problems/valid-sudoku/solution/gong-shui-san-xie-yi-ti-san-jie-ha-xi-bi-ssxp/ | 中等 | [
"哈希表",
"数组",
"位运算",
"数独问题"
] | 请你判断一个 `9 x 9` 的数独是否有效。只需要 根据以下规则 ,验证已经填入的数字是否有效即可。
1. 数字 `1-9` 在每一行只能出现一次。
2. 数字 `1-9` 在每一列只能出现一次。
3. 数字 `1-9` 在每一个以粗实线分隔的 `3 x 3` 宫内只能出现一次。(请参考示例图)
数独部分空格内已填入了数字,空白格用 `'.'` 表示。
注意:
* 一个有效的数独(部分已被填充)不一定是可解的。
* 只需要根据以上规则,验证已经填入的数字是否有效即可。
示例 1:
```
输入:board =
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1"... | ### 哈希表
由于只要我们判断是否为有效的数独。
所以我们只需要对 `board` 中出现的数进行判断,如果 `board` 中有数违反了数独的规则,返回 `false`,否则返回 `true`。
直观上,我们很容易想到使用 **哈希表** 来记录某行/某列/某个小方块出现过哪些数字,来帮助我们判断是否符合「有效数独」的定义。
这道题唯一的难点可能是在于如何确定某个数落在哪个小方块中,我们可以去小方块进行编号:
然后推导出小方块编号和行列的关系为: $idx = \left \lfloor i / 3 \right \rfloor * 3 + \left \lfloor j / 3 \right \rfloor$。
代... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.36` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/37. 解数独（困难）.md | 37. 解数独 | https://leetcode-cn.com/problems/sudoku-solver/solution/he-n-huang-hou-yi-yang-shi-yi-dao-hui-su-lfpd/ | 困难 | [
"回溯算法",
"DFS",
"数独问题"
] | 编写一个程序,通过填充空格来解决数独问题。
数独的解法需 遵循如下规则:
1. 数字 `1-9` 在每一行只能出现一次。
2. 数字 `1-9` 在每一列只能出现一次。
3. 数字 `1-9` 在每一个以粗实线分隔的 `3 x 3` 宫内只能出现一次。(请参考示例图)
数独部分空格内已填入了数字,空白格用 '.' 表示。
示例:
```
输入:board =
[["5","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".","."... | ### 回溯解法
和 N 皇后一样,是一道回溯解法裸题。
上一题「36. 有效的数独(中等)」是让我们判断给定的 `borad` 是否为有效数独。
这题让我们对给定 `board` 求数独,由于 `board` 固定是 `9 * 9` 的大小,我们可以使用回溯算法去做。
这一类题和 N 皇后一样,属于经典的回溯算法裸题。
这类题都有一个明显的特征,就是数据范围不会很大,如该题限制了范围为 `9 * 9`,而 N 皇后的 N 一般不会超过 13。
对每一个需要填入数字的位置进行填入,如果发现填入某个数会导致数独解不下去,则进行回溯。
代码:
```Java
class Solution {
boolean[][]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.37` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/38. 外观数列（简单）.md | 38. 外观数列 | https://leetcode-cn.com/problems/count-and-say/solution/shua-chuan-lc-100-mo-ni-ti-shi-yong-shao-w8jl/ | 简单 | [
"模拟"
] | 给定一个正整数 n ,输出外观数列的第 n 项。
「外观数列」是一个整数序列,从数字 1 开始,序列中的每一项都是对前一项的描述。
你可以将其视作是由递归公式定义的数字字符串序列:
* countAndSay(1) = "1"
* countAndSay(n) 是对 countAndSay(n-1) 的描述,然后转换成另一个数字字符串。
前五项如下:
```
1. 1
2. 11
3. 21
4. 1211
5. 111221
第一项是数字 1
描述前一项,这个数是 1 即 “ 一 个 1 ”,记作 "11"
描述前一项,这个数是 11 即 “ 二 个 1 ” ,记作 "21"
描述前... | ### 模拟
一个朴素的想法是:根据题意进行模拟,从起始条件 $k = 1$ 时 `ans = "1"` 出发,逐步递推到 $k = n$ 的情况,对于第 $k$ 项而言,其实就是对第 $k - 1$ 项的「连续段」的描述,而求「连续段」长度,可以使用双指针实现。
代码:
```Java
class Solution {
public String countAndSay(int n) {
String ans = "1";
for (int i = 2; i <= n; i++) {
String cur = "";
int m = ans... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.38` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/39. 组合总和（中等）.md | 39. 组合总和 | https://leetcode-cn.com/problems/combination-sum/solution/dfs-hui-su-suan-fa-yi-ji-ru-he-que-ding-wpbo5/ | 中等 | [
"回溯算法",
"DFS",
"组合总和问题"
] | 给定一个无重复元素的数组 `candidates` 和一个目标数 `target` ,找出 `candidates` 中所有可以使数字和为 `target` 的组合。
`candidates` 中的数字可以无限制重复被选取。
说明:
* 所有数字(包括 `target`)都是正整数。
* 解集不能包含重复的组合。
示例 1:
```
输入:candidates = [2,3,6,7], target = 7,
所求解集为:
[
[7],
[2,2,3]
]
```
示例 2:
```
输入:candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3... | ### DFS
这道题很明显就是在考察回溯算法。
之前跟你分享过的 [37. 解数独(困难)](https://mp.weixin.qq.com/s/0y4lGAH43U3w5loTgaeyoQ) 里面有提到我们应该如何快速判断一道题是否应该使用 DFS + 回溯算法来爆搜。
总的来说,你可以从两个方面来考虑:
* **1. 求的是所有的方案,而不是方案数。** 由于求的是所有方案,不可能有什么特别的优化,我们只能进行枚举。这时候可能的解法有动态规划、记忆化搜索、DFS + 回溯算法。
* **2. 通常数据范围不会太大,只有几十。** 如果是动态规划或是记忆化搜索的题的话,由于它们的特点在于低重复/不重复枚举,所... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.39` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/40. 组合总和 II（中等）.md | 40. 组合总和 II | https://leetcode-cn.com/problems/combination-sum-ii/solution/dfs-hui-su-jie-fa-yi-ji-ru-he-pan-duan-s-xlwy/ | 中等 | [
"回溯算法",
"DFS",
"组合总和问题"
] | 给定一个数组 `candidates` 和一个目标数 `target` ,找出 `candidates` 中所有可以使数字和为 `target` 的组合。
`candidates` 中的每个数字在每个组合中只能使用一次。
说明:
* 所有数字(包括目标数)都是正整数。
* 解集不能包含重复的组合。
示例 1:
```
输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
```
示例 2:
```
输入: candidates = [2,5,2,1,2], target ... | ### DFS + 回溯
这道题和「39. 组合总和(中等)」几乎一样。
唯一的不同是这题每个数只能使用一次,而「39. 组合总和(中等)」中可以使用无限次。
我们再来回顾一下应该如何快速判断一道题是否应该使用 DFS + 回溯算法来爆搜。
这个判断方法,最早三叶在 [37. 解数独(困难)](https://mp.weixin.qq.com/s/0y4lGAH43U3w5loTgaeyoQ) 讲过。
总的来说,你可以从两个方面来考虑:
* **1. 求的是所有的方案,而不是方案数。** 由于求的是所有方案,不可能有什么特别的优化,我们只能进行枚举。这时候可能的解法有动态规划、记忆化搜索、DFS + 回溯算法。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.40` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/312. 戳气球（困难）.md | 312. 戳气球 | https://leetcode.cn/problems/burst-balloons/solution/by-ac_oier-9r9c/ | 困难 | [
"区间 DP",
"动态规划"
] | 有 `n` 个气球,编号为 `0` 到 `n - 1`,每个气球上都标有一个数字,这些数字存在数组 `nums` 中。
现在要求你戳破所有的气球。
戳破第 `i` 个气球,你可以获得 `nums[i - 1] * nums[i] * nums[i + 1]` 枚硬币。 这里的 `i - 1` 和 `i + 1` 代表和 `i` 相邻的两个气球的序号。
如果 `i - 1` 或 `i + 1` 超出了数组的边界,那么就当它是一个数字为 `1` 的气球。
求所能获得硬币的最大数量。
示例 1:
```
输入:nums = [3,1,5,8]
输出:167
解释:
nums = [3,1,5,8] --> [3,5,8] -... | ### 区间 DP
定义 $f[l][r]$ 为考虑将 $(l, r)$ 范围内(不包含 `l` 和 `r` 边界)的气球消耗掉,所能取得的最大价值。
根据题意,我们可以对 `nums` 进行扩充,将其从长度为 $n$ 的 `nums` 变为长度 $n + 2$ 的 `arr`,其中 $arr[1...n]$ 对应了原数组 `nums`,而 $arr[0] = arr[n + 1] = 1$。
此时易知 $f[0][n + 1]$ 即是答案,不失一般性考虑 $f[l][r]$ 该如何转移,假设在 $(l, r)$ 范围内最后剩下的气球的编号为 $k$,此时的 $f[l][r]$ 由「以 $k$ 为分割点的两端所产生的价值」和「... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.312` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/313. 超级丑数（中等）.md | 313. 超级丑数 | https://leetcode-cn.com/problems/super-ugly-number/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-jyow/ | 中等 | [
"优先队列(堆)",
"多路归并"
] | 超级丑数 是一个正整数,并满足其所有质因数都出现在质数数组 primes 中。
给你一个整数 n 和一个整数数组 primes ,返回第 n 个 超级丑数 。
题目数据保证第 n 个 超级丑数 在 32-bit 带符号整数范围内。
示例 1:
```
输入:n = 12, primes = [2,7,13,19]
输出:32
解释:给定长度为 4 的质数数组 primes = [2,7,13,19],前 12 个超级丑数序列为:[1,2,4,7,8,13,14,16,19,26,28,32] 。
```
示例 2:
```
输入:n = 1, primes = [2,3,5]
输出:1
解释:1 不含质因数,因此它的... | ### 基本分析
类似的题目在之前的每日一题也出现过。
本题做法与 [264. 丑数 II](https://leetcode-cn.com/problems/ugly-number-ii/) 类似,相关题解在 [这里](https://leetcode-cn.com/problems/ugly-number-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-3nvs/)。
回到本题,根据丑数的定义,我们有如下结论:
* $1$ 是最小的丑数。
* 对于任意一个丑数 $x$,其与任意给定的质因数 $primes[i]$ 相乘,结果仍为丑数。
---
### 优先队列... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.313` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/318. 最大单词长度乘积（中等）.md | 318. 最大单词长度乘积 | https://leetcode-cn.com/problems/maximum-product-of-word-lengths/solution/gong-shui-san-xie-jian-dan-wei-yun-suan-cqtxq/ | 中等 | [
"模拟",
"位运算",
"哈希表"
] | 给定一个字符串数组 `words`,找到 $length(word[i]) * length(word[j])$ 的最大值,并且这两个单词不含有公共字母。你可以认为每个单词只包含小写字母。如果不存在这样的两个单词,返回 $0$。
示例 1:
```
输入: ["abcw","baz","foo","bar","xtfn","abcdef"]
输出: 16
解释: 这两个单词为 "abcw", "xtfn"。
```
示例 2:
```
输入: ["a","ab","abc","d","cd","bcd","abcd"]
输出: 4
解释: 这两个单词为 "ab", "cd"。
```
示例 3:
```
输入: ["... | ### 模拟
根据题意进行模拟即可,利用每个 $words[i]$ 只有小写字母,且只需要区分两字符是否有字母重复。
我们可以使用一个 `int` 来代指某个 $word[i]$:低 $26$ 来代指字母 `a-z` 是否出现过。
然后对每个「字符对」所对应的两个 `int` 值执行 `&` 操作(若两字符无重复字符,则结果为 $0$),并得出最终答案。
代码:
```Java
class Solution {
public int maxProduct(String[] words) {
int n = words.length, idx = 0;
int[] masks = new... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.318` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/319. 灯泡开关（中等）.md | 319. 灯泡开关 | https://leetcode-cn.com/problems/bulb-switcher/solution/gong-shui-san-xie-jing-dian-shu-lun-tui-upnnb/ | 中等 | [
"数学"
] | 初始时有 `n` 个灯泡处于关闭状态。第一轮,你将会打开所有灯泡。接下来的第二轮,你将会每两个灯泡关闭一个。
第三轮,你每三个灯泡就切换一个灯泡的开关(即,打开变关闭,关闭变打开)。
第 `i` 轮,你每 `i` 个灯泡就切换一个灯泡的开关。直到第 `n` 轮,你只需要切换最后一个灯泡的开关。
找出并返回 `n` 轮后有多少个亮着的灯泡。
示例 1:
```
输入:n = 3
输出:1
解释:
初始时, 灯泡状态 [关闭, 关闭, 关闭].
第一轮后, 灯泡状态 [开启, 开启, 开启].
第二轮后, 灯泡状态 [开启, 关闭, 开启].
第三轮后, 灯泡状态 [开启, 关闭, 关闭].
你应该返回 1,因为只有... | ### 数学
这是一道经典的数论题。
整理一下题意:**第 $i$ 轮改变所有编号为 $i$ 的倍数的灯泡的状态(其中灯泡编号从 $1$ 开始)。**
**一个编号为 $x$ 的灯泡经过 $n$ 轮后处于打开状态的充要条件为「该灯泡被切换状态次数为奇数次」。**
同时,一个灯泡切换状态的次数为其约数的个数(去重)。
于是问题转换为:**在 $[1,n]$ 内有多少个数,其约数的个数为奇数**。这些约数个数为奇数的灯泡就是最后亮着的灯泡。
又根据「约数」的定义,我们知道如果某个数 $k$ 为 $x$ 的约数,那么 $\frac{x}{k}$ 亦为 $x$ 的约数,即「约数」总是成对出现,那么某个数的约数个数为奇数,意味着某... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.319` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/322. 零钱兑换（中等）.md | 322. 零钱兑换 | https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/ | 中等 | [
"完全背包",
"动态规划",
"背包问题"
] | 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 -1。
你可以认为每种硬币的数量是无限的。
示例 1:
```
输入:coins = [1, 2, 5], amount = 11
输出:3
解释:11 = 5 + 5 + 1
```
示例 2:
```
输入:coins = [2], amount = 3
输出:-1
```
示例 3:
```
输入:coins = [1], amount = 0
输出:0
```
示例 4:
```
输入:coins = [1], amount = 1
输出:1
```
示例 5:
... | ### 完全背包(朴素解法)
硬币相当于我们的物品,每种硬币可以选择「无限次」,我们应该很自然的想到「完全背包」。
如果不能,那么从现在开始就要培养这样的习惯:
**当看到题目是给定一些「物品」,让我们从中进行选择,以达到「最大价值」或者「特定价值」时,我们应该联想到「背包问题」。**
**这本质上其实是一个组合问题:被选物品之间不需要满足特定关系,只需要选择物品,以达到「全局最优」或者「特定状态」即可。**
再根据物品的选择次数限制来判断是何种背包问题。
本题每种硬币可以被选择「无限次」,我们可以直接套用「完全背包」的状态定义进行微调:
**定义 $f[i][j]$ 为考虑前 $i$ 件物品,凑成总和为 $j$ 所需... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.322` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/324. 摆动排序 II（中等）.md | 324. 摆动排序 II | https://leetcode.cn/problems/wiggle-sort-ii/solution/by-ac_oier-22bq/ | 中等 | [
"构造",
"排序",
"快速选择"
] | 给你一个整数数组 `nums`,将它重新排列成 `nums[0] < nums[1] > nums[2] < nums[3]...` 的顺序。
你可以假设所有输入数组都可以得到满足题目要求的结果。
示例 1:
```
输入:nums = [1,5,1,1,6,4]
输出:[1,6,1,5,1,4]
解释:[1,4,1,5,1,6] 同样是符合题目要求的结果,可以被判题程序接受。
```
示例 2:
```
输入:nums = [1,3,2,2,3,1]
输出:[2,3,1,3,1,2]
```
提示:
* $1 <= nums.length <= 5 \times 10^4$
* $0 <= nums[i] <= 500... | ### 构造(快选 + 三数排序)
这道题即使不考虑空间 $O(1)$ 的进阶要求,只要求做到 $O(n)$ 时间的话,在 LC 上也属于难题了。如果大家是第一次做,并且希望在有限时间(不超过 $20$ 分钟)内做出来,可以说是难上加难。
本质上,题目要我们实现一种构造方法,能够将 `nums` 调整为满足「摆动」要求。
具体的构造方法:
1. 找到 `nums` 的中位数,这一步可以通过「快速选择」算法来做,时间复杂度为 $O(n)$,空间复杂度为 $O(\log{n})$,假设找到的中位数为 `x`;
2. 根据 $nums[i]$ 与 `x` 的大小关系,将 $nums[i]$ 分为三类(小于/等于/大于),划分三类... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.324` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/326. 3的幂（简单）.md | 326. 3的幂 | https://leetcode-cn.com/problems/power-of-three/solution/gong-shui-san-xie-yi-ti-san-jie-shu-xue-8oiip/ | 简单 | [
"数学",
"打表"
] | 给定一个整数,写一个函数来判断它是否是 $3$ 的幂次方。如果是,返回 $true$ ;否则,返回 $false$ 。
整数 $n$ 是 $3$ 的幂次方需满足:存在整数 $x$ 使得 $n == 3^x$
示例 1:
```
输入:n = 27
输出:true
```
示例 2:
```
输入:n = 0
输出:false
```
示例 3:
```
输入:n = 9
输出:true
```
示例 4:
```
输入:n = 45
输出:false
```
提示:
* -$2^{31}$ <= n <= $2^{31}$ - 1 | ### 数学
一个不能再朴素的做法是将 $n$ 对 $3$ 进行试除,直到 $n$ 不再与 $3$ 呈倍数关系,最后判断 $n$ 是否为 $3^0 = 1$ 即可。
代码:
```Java
class Solution {
public boolean isPowerOfThree(int n) {
if (n <= 0) return false;
while (n % 3 == 0) n /= 3;
return n == 1;
}
}
```
* 时间复杂度:$O(\log_{3}n)$
* 空间复杂度:$O(1)$
---
### 倍数 & 约数
题目... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.326` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/327. 区间和的个数（困难）.md | 327. 区间和的个数 | https://leetcode.cn/problems/count-of-range-sum/solution/by-ac_oier-b36o/ | 困难 | [
"前缀和",
"离散化",
"树状数组",
"线段树(动态开点)"
] | 给你一个整数数组 `nums` 以及两个整数 `lower` 和 `upper` 。求数组中,值位于范围 $[lower, upper]$ (包含 `lower` 和 `upper`)之内的 区间和的个数 。
区间和 $S(i, j)$ 表示在 `nums` 中,位置从 $i$ 到 $j$ 的元素之和,包含 $i$ 和 $j$ (`i ≤ j`)。
示例 1:
```
输入:nums = [-2,5,-1], lower = -2, upper = 2
输出:3
解释:存在三个区间:[0,0]、[2,2] 和 [0,2] ,对应的区间和分别是:-2 、-1 、2 。
```
示例 2:
```
输入:nums = [0], ... | ### 树状数组(离散化)
由于区间和的定义是子数组的元素和,容易想到「前缀和」来快速求解。
对于每个 $nums[i]$ 而言,我们需要统计以每个 $nums[i]$ 为右端点的合法子数组个数(合法子数组是指区间和值范围为 $[lower, upper]$ 的子数组)。
我们可以从前往后处理 $nums$,假设当前我们处理到位置 $k$,同时下标 $[0, k]$ 的前缀和为 $s$,那么以 $nums[k]$ 为右端点的合法子数组个数,等价于在下标 $[0, k - 1]$ 中前缀和范围在 $[s - upper, s - lower]$ 的数的个数。
我们需要使用一个数据结构来维护「遍历过程中的前缀和」,每遍历 $nu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.327` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/331. 验证二叉树的前序序列化（中等）.md | 331. 验证二叉树的前序序列化 | https://leetcode-cn.com/problems/verify-preorder-serialization-of-a-binary-tree/solution/xiang-xin-ke-xue-xi-lie-xiang-jie-zhi-gu-e3y9/ | 中等 | [
"二叉树"
] | 序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时,我们可以记录下这个节点的值。如果它是一个空节点,我们可以使用一个标记值记录,例如 #。
```
_9_
/ \
3 2
/ \ / \
4 1 # 6
/ \ / \ / \
# # # # # #
```
例如,上面的二叉树可以被序列化为字符串 "9,3,4,#,#,1,#,#,2,#,6,#,#",其中 # 代表一个空节点。
给定一串以逗号分隔的序列,验证它是否是正确的二叉树的前序序列化。编写一个在不重构树的条件下的可行算法。
每个以逗号分隔的字符或为一个整数或为一个表示 null 指针的 '#' 。... | ### 二叉树规律解法
事实上,我们能利用「二叉树」的特性来做。
由于**每一个非空节点都对应了 2 个出度,空节点都对应了 0 个出度;除了根节点,每个节点都有一个入度。**
我们可以使用 `in` 和 `out` 来分别记录「入度」和「出度」的数量;`m` 和 `n` 分别代表「非空节点数量」和「空节点数量」。
同时,一颗合格的二叉树最终结果必然满足 `in == out`。
**但我们又不能只利用最终 `in == out` 来判断是否合法,这很容易可以举出反例:考虑将一个合法序列的空节点全部提前,这样最终结果仍然满足 `in == out`,但这样的二叉树是不存在的。**
**我们还需要一些额外的特性,支持我们在... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.331` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/334. 递增的三元子序列（中等）.md | 334. 递增的三元子序列 | https://leetcode-cn.com/problems/increasing-triplet-subsequence/solution/gong-shui-san-xie-zui-chang-shang-sheng-xa08h/ | 中等 | [
"LIS",
"最长上升子序列",
"贪心",
"二分"
] | 给你一个整数数组 `nums`,判断这个数组中是否存在长度为 $3$ 的递增子序列。
如果存在这样的三元组下标 `(i, j, k)` 且满足 `i < j < k` ,使得 `nums[i] < nums[j] < nums[k]` ,返回 `true` ;否则,返回 `false`。
示例 1:
```
输入:nums = [1,2,3,4,5]
输出:true
解释:任何 i < j < k 的三元组都满足题意
```
示例 2:
```
输入:nums = [5,4,3,2,1]
输出:false
解释:不存在满足题意的三元组
```
示例 3:
```
输入:nums = [2,1,5,0,4,6]
输出:t... | ### 最长上升子序列(贪心 + 二分)
题目要我们判断是否存在长度为 $3$ 的上升子序列,问题可以转换为求 $nums$ 的最长上升子序列(`LIS` 问题)的长度。
如果 $nums$ 的最长上升子序列长度大于等于 $3$,那么原问题答案为 `True`,否则为 `False`。
而求最长上升子序列的最优解是有基于「贪心 + 二分」的 $O(n\log{n})$ 做法,对此不了解的同学,可以先看前置 🧀 :[LCS 问题与 LIS 问题的相互关系,以及 LIS 问题的最优解证明](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.334` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/335. 路径交叉（困难）.md | 335. 路径交叉 | https://leetcode-cn.com/problems/self-crossing/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-zdrb/ | 困难 | [
"找规律",
"脑筋急转弯",
"模拟"
] | 给你一个整数数组 `distance` 。
从 `X-Y` 平面上的点 $(0,0)$ 开始,先向北移动 `distance[0]` 米,然后向西移动 `distance[1]` 米,向南移动 `distance[2]` 米,向东移动 `distance[3]` 米,持续移动。也就是说,每次移动后你的方位会发生逆时针变化。
判断你所经过的路径是否相交。如果相交,返回 `true` ;否则,返回 `false`。
示例 1:
```
输入:distance = [2,1,1,2]
输出:true
```
示例 2:
```
输入:distance = [1,2,3,4]
输出:false
```
示例 3:
```
输... | ### 找规律 + 分情况讨论
这是一道画图找规律的题目。
**首先显然的是,至少需要 $4$ 条边才 可能 存在相交路径,如果 $distance$ 的长度小于 $4$,可直接返回 `False`,同时这引导我们如果某条边 $distance[i]$ 发生相交,不可能是与 $distance[i - 1]$ 或 $distance[i - 2]$ 之间发生的(基于条件 $1 <= distance[i] <= 10^5$)。**
为了方便,我们分别使用 $a$、$b$、$c$ 和 $d$ 来分别代指「往上」、「往左」、「往下」和「往右」的四类方向边。
然后对可能相交情况进行分情况讨论,假设当前枚举到的边为 $distanc... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.335` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/338. 比特位计数（简单）.md | 338. 比特位计数 | https://leetcode-cn.com/problems/counting-bits/solution/po-su-jie-fa-dong-tai-gui-hua-jie-fa-by-vvail/ | 简单 | [
"位运算",
"数学",
"线性 DP"
] | 给定一个非负整数 `num`。对于 `0 ≤ i ≤ num` 范围中的每个数字 `i`,计算其二进制数中的 $1$ 的数目并将它们作为数组返回。
示例 1:
```
输入: 2
输出: [0,1,1]
```
示例 2:
```
输入: 5
输出: [0,1,1,2,1,2]
```
进阶:
* 给出时间复杂度为 $O(n \times sizeof(integer))$ 的解答非常容易。但你可以在线性时间 $O(n)$ 内用一趟扫描做到吗?
* 要求算法的空间复杂度为 $O(n)$ 。
* 你能进一步完善解法吗?要求在 `C++` 或任何其他语言中不使用任何内置函数(如 `C++` 中的 `__builtin_popcou... | ### 模拟
这道题要对每个数进行统计,因此不会有比 $O(n)$ 更低的做法。
而很容易想到的朴素做法是对每个数进行「位运算」计数,每个数都是 $32$ 位的,因此是一个 $O(32n)$ 的做法。
代码:
```Java
class Solution {
public int[] countBits(int n) {
int[] ans = new int[n + 1];
for (int i = 0; i <= n; i++) ans[i] = getCnt(i);
return ans;
}
int getCnt(int u) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.338` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/341-350/341. 扁平化嵌套列表迭代器（中等）.md | 341. 扁平化嵌套列表迭代器 | https://leetcode-cn.com/problems/flatten-nested-list-iterator/solution/yi-ti-shuang-jie-dfsdui-lie-di-gui-zhan-kvwhy/ | 中等 | [
"DFS",
"队列",
"栈"
] | 给你一个嵌套的整型列表。请你设计一个迭代器,使其能够遍历这个整型列表中的所有整数。
列表中的每一项或者为一个整数,或者是另一个列表。其中列表的元素也可能是整数或是其他列表。
示例 1:
```
输入: [[1,1],2,[1,1]]
输出: [1,1,2,1,1]
解释: 通过重复调用 next 直到 hasNext 返回 false,next 返回的元素的顺序应该是: [1,1,2,1,1]。
```
示例 2:
```
输入: [1,[4,[6]]]
输出: [1,4,6]
解释: 通过重复调用 next 直到 hasNext 返回 false,next 返回的元素的顺序应该是: [1,4,6]。
``` | ### DFS + 队列
由于所有的元素都是在初始化时提供的,因此一个朴素的做法是在初始化的时候进行处理。
由于存在嵌套,比较简单的做法是通过 DFS 进行处理,将元素都放至队列。
代码:
```java []
public class NestedIterator implements Iterator<Integer> {
Deque<Integer> queue = new ArrayDeque<>();
public NestedIterator(List<NestedInteger> nestedList) {
dfs(nestedList);
}
@Overri... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.341` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/341-350/342. 4的幂（简单）.md | 342. 4的幂 | https://leetcode-cn.com/problems/power-of-four/solution/gong-shui-san-xie-zhuan-hua-wei-2-de-mi-y21lq/ | 简单 | [
"数学",
"位运算"
] | 给定一个整数,写一个函数来判断它是否是 4 的幂次方。如果是,返回 true ;否则,返回 false 。
整数 n 是 4 的幂次方需满足:存在整数 x 使得 n == $4^x$
示例 1:
```
输入:n = 16
输出:true
```
示例 2:
```
输入:n = 5
输出:false
```
示例 3:
```
输入:n = 1
输出:true
```
提示:
* -$2^{31}$ <= n <= $2^{31}$ - 1
进阶:
你能不使用循环或者递归来完成本题吗? | ### 基本分析
一个数 $n$ 如果是 $4$ 的幂,等价于 $n$ 为质因数只有 $2$ 的平方数。
因此我们可以将问题其转换:判断 $\sqrt{n}$ 是否为 $2$ 的幂。
判断某个数是否为 $2$ 的幂的分析在[(题解)231. 2 的幂](https://leetcode-cn.com/problems/power-of-two/solution/gong-shui-san-xie-2-de-mi-by-ac_oier-qm6e/) 这里。
---
### sqrt + lowbit
我们可以先对 $n$ 执行 `sqrt` 函数,然后应用 `lowbit` 函数快速判断 $\sqrt{n}$ 是否为 $2... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/341-350/345. 反转字符串中的元音字母（简单）.md | 345. 反转字符串中的元音字母 | https://leetcode-cn.com/problems/reverse-vowels-of-a-string/solution/gong-shui-san-xie-note-bie-pian-shuang-z-c8ii/ | 简单 | [
"双指针",
"模拟"
] | 编写一个函数,以字符串作为输入,反转该字符串中的元音字母。
示例 1:
```
输入:"hello"
输出:"holle"
```
示例 2:
```
输入:"leetcode"
输出:"leotcede"
```
提示:
* 元音字母不包含字母 "y" 。 | ### 双指针
一个朴素的做法是利用「双指针」进行前后扫描,当左右指针都是元音字母时,进行互换并移到下一位。
由于元音字母相对固定,因此我们可以使用容器将其存储,并使用 `static` 修饰,确保整个容器的创建和元音字母的填入在所有测试样例中只会发生一次。
我们期望该容器能在 $O(1)$ 的复杂度内判断是否为元音字母,可以使用语言自带的哈希类容器($P2$ 代码)或是使用数组模拟($P1$ 代码)。
> 一些细节:由于题目没有说字符串中只包含字母,因此在使用数组模拟哈希表时,我们需要用当前字符减去 ASCII 码的最小值(空字符),而不是 'A'
代码:
```Java
class Solution {
sta... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.345` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/351-360/352. 将数据流变为多个不相交区间（困难）.md | 352. 将数据流变为多个不相交区间 | https://leetcode-cn.com/problems/data-stream-as-disjoint-intervals/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-afrk/ | 困难 | [
"二分",
"模拟"
] | 给你一个由非负整数 `a1, a2, ..., an` 组成的数据流输入,请你将到目前为止看到的数字总结为不相交的区间列表。
实现 `SummaryRanges` 类:
* `SummaryRanges()` 使用一个空数据流初始化对象。
* `void addNum(int val)` 向数据流中加入整数 `val` 。
* `int[][] getIntervals()` 以不相交区间 `[starti, endi]` 的列表形式返回对数据流中整数的总结。
示例:
```
输入:
["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "a... | ### 二分查找 + 朴素维护区间
一个朴素的做法是直接使用 `ArrayList`(数组)来维护所有的不相交区间,然后调用 `addNum` 时先通过二分找到当前值相邻的区间,然后根据题意进行模拟即可。
同时为了简化复杂的分情况讨论,起始时我们可以先往 `ArrayList` 添加两个哨兵分别代表正无穷和负无穷。
代码(不使用哨兵的代码见 $P2$):
```Java
class SummaryRanges {
List<int[]> list = new ArrayList<>();
int[] head = new int[]{-10, -10}, tail = new int[]{10010, 1001... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.352` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/351-360/354. 俄罗斯套娃信封问题（困难）.md | 354. 俄罗斯套娃信封问题 | https://leetcode-cn.com/problems/russian-doll-envelopes/solution/zui-chang-shang-sheng-zi-xu-lie-bian-xin-6s8d/ | 困难 | [
"二分",
"序列 DP"
] | 给你一个二维整数数组 envelopes ,其中 envelopes[i] = [wi, hi] ,表示第 i 个信封的宽度和高度。
当另一个信封的宽度和高度都比这个信封大的时候,这个信封就可以放进另一个信封里,如同俄罗斯套娃一样。
请计算「最多能有多少个」信封能组成一组“俄罗斯套娃”信封(即可以把一个信封放到另一个信封里面)。
注意:不允许旋转信封。
示例 1:
```
输入:envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出:3
解释:最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。
```
示例 2:
```
输入:envelopes = [[1,1],[... | ### 动态规划
这是一道经典的 DP 模型题目:最长上升子序列(LIS)。
首先我们先对 `envelopes` 进行排序,确保信封是从小到大进行排序。
问题就转化为我们从这个序列中选择 `k` 个信封形成新的序列,使得新序列中的每个信封都能严格覆盖前面的信封(宽高都严格大于)。
我们可以**定义状态 $f[i]$ 为考虑前 i 个物品,并以第 $i$ 个物品为结尾的最大值。**
对于每个$f[i]$ 而言,最小值为 $1$,代表只选择自己一个信封。
那么对于一般的 $f[i]$ 该如何求解呢?因为第 i 件物品是必须选择的。我们可以枚举前面的 $i - 1$ 件物品,哪一件可以作为第 $i$ 件物品的上一件物品。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.354` 篇,系列开始于 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.