file_path stringlengths 27 66 | url_title stringlengths 6 38 | url stringlengths 60 237 ⌀ | difficulty stringclasses 3
values | tags sequencelengths 1 8 | question stringlengths 107 2.73k | solution stringlengths 163 28.6k | final stringlengths 308 330 |
|---|---|---|---|---|---|---|---|
LeetCode/1-10/1. 两数之和（简单）.md | 1. 两数之和 | https://leetcode-cn.com/problems/two-sum/solution/po-su-jie-fa-ha-xi-biao-jie-fa-by-ac_oie-yf7o/ | 简单 | [
"哈希表",
"模拟"
] | 给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出「和为目标值」的那「两个」整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
```
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
```
示例 2:
```
输入:nums = [3,2,4], target = 6
输出:[1,2]
```
示例 3:
```
输入:nums = [3,3], target = 6
... | ### 朴素解法
由于我们每次要从数组中找两个数。
因此一个很简单的思路是:使用两重循环枚举下标 $i$ 和 $j$ ,分别代表要找的两个数。
然后判断 $nums[i] + nums[j] = target$ 是否成立。
另外为了防止得到重复的解,我们需要在第一层循环中让 $i$ 从 $0$ 开始,到 $n - 2$ 结束(确保能取到下一位数作为 j );在第二层循环中让 $j$ 从 $i + 1$ 开始,到 $n - 1$ 结束。
代码:
```Java
class Solution {
public int[] twoSum(int[] nums, int t) {
int n = nums... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/10. 正则表达式匹配（困难）.md | 10. 正则表达式匹配 | https://leetcode-cn.com/problems/regular-expression-matching/solution/shua-chuan-lc-dong-tai-gui-hua-jie-fa-by-zn9w/ | 困难 | [
"动态规划",
"序列 DP"
] | 给你一个字符串 `s` 和一个字符规律 `p`,请你来实现一个支持 `'.'` 和 `'*'` 的正则表达式匹配。
* `'.'` 匹配任意单个字符
* `'*'` 匹配零个或多个前面的那一个元素
所谓匹配,是要涵盖整个字符串 `s` 的,而不是部分字符串。
示例 1:
```
输入:s = "aa" p = "a"
输出:false
解释:"a" 无法匹配 "aa" 整个字符串。
```
示例 2:
```
输入:s = "aa" p = "a*"
输出:true
解释:因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此,字符串 "aa" 可被视为 'a' 重复了一次。
```... | ### 动态规划
整理一下题意,对于字符串 `p` 而言,有三种字符:
* 普通字符:需要和 `s` 中同一位置的字符完全匹配
* `'.'`:能够匹配 `s` 中同一位置的任意字符
* `'*'`:不能够单独使用 `'*'`,必须和前一个字符同时搭配使用,数据保证了 `'*'` 能够找到前面一个字符。能够匹配 `s` 中同一位置字符任意次。
所以本题关键是分析当出现 `a*` 这种字符时,是匹配 $0$ 个 `a`、还是 $1$ 个 `a`、还是 $2$ 个 `a` ...
本题可以使用动态规划进行求解:
* 状态定义:`f(i,j)` 代表考虑 `s` 中以 `i` 为结尾的子串和 `p` 中的 `j` 为结尾的子串是... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.10` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/2. 两数相加（中等）.md | 2. 两数相加 | https://leetcode-cn.com/problems/add-two-numbers/solution/po-su-jie-fa-shao-bing-ji-qiao-by-ac_oie-etln/ | 中等 | [
"递归",
"链表",
"数学",
"模拟"
] | 给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。
请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 $0$ 之外,这两个数都不会以 $0$ 开头。
示例 1:
```
输入:l1 = [2,4,3], l2 = [5,6,4]
输出:[7,0,8]
解释:342 + 465 = 807.
```
示例 2:
```
输入:l1 = [0], l2 = [0]
输出:[0]
```
示例 3:
```
输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出:[8,9,9,9,0,0,0,1]
`... | ### 朴素解法(哨兵技巧)
这是道模拟题,模拟人工竖式做加法的过程:
从最低位至最高位,逐位相加,如果和大于等于 $10$,则保留个位数字,同时向前一位进 1 如果最高位有进位,则需在最前面补 $1$。
做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。
代码:
```Java
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode dummy = new ListNode(0);
ListNode tmp = dummy;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/3. 无重复字符的最长子串（中等）.md | 3. 无重复字符的最长子串 | https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/solution/shua-chuan-lc-shuang-zhi-zhen-ha-xi-biao-q08m/ | 中等 | [
"哈希表",
"双指针",
"滑动窗口"
] | 给定一个字符串,请你找出其中不含有重复字符的「最长子串」的长度。
示例 1:
```
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
```
示例 2:
```
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
```
示例 3:
```
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
```
示例 4:
```
输入: s = ""
输... | ### 滑动窗口
定义两个指针 `start` 和 `end`, `[start:end]` 表示当前处理到的子串。
子串 `[start:end]` 始终满足要求:无重复字符。
从前往后进行扫描 `s`,用哈希表记录 `[start:end]` 中每字符的出现次数。
遍历过程中,`end` 不断自增,将第 `end` 个字符在哈希表中出现的次数加一。
令 `right` 为下标 `end` 对应的字符,当满足 `map.get(right) > 1` 时,代表此前出现过第 `end` 位对应的字符。
此时更新 `start` 的位置(使其右移),直到不满足 `map.get(right) > 1` (代表 `[star... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.3` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/4. 寻找两个正序数组的中位数（困难）.md | 4. 寻找两个正序数组的中位数 | https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/shua-chuan-lc-po-su-jie-fa-fen-zhi-jie-f-wtu2/ | 困难 | [
"二分",
"分治"
] | 给定两个大小分别为 $m$ 和 $n$ 的正序(从小到大)数组 `nums1` 和 `nums2`。
请你找出并返回这两个正序数组的「中位数」。
示例 1:
```
输入:nums1 = [1,3], nums2 = [2]
输出:2.00000
解释:合并数组 = [1,2,3] ,中位数 2
```
示例 2:
```
输入:nums1 = [1,2], nums2 = [3,4]
输出:2.50000
解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5
```
示例 3:
```
输入:nums1 = [0,0], nums2 = [0,0]
输出:0.00000
```
示例 ... | ### 朴素解法
如果忽略进阶的 $O(\log{(m + n)})$ 要求,这道题就非常简单。
一个比较直观的做法:将两个数组合并,排序,然后分别取得 `total / 2` 和 `(total - 1) / 2` 两个位置的数,取两者平均值。
这样做的目的是为了避免分情况讨论:合并后的数组长度是奇数还是偶数。
```Java
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
int[] ar... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.4` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/5. 最长回文子串（中等）.md | 5. 最长回文子串 | https://leetcode-cn.com/problems/longest-palindromic-substring/solution/shua-chuan-lc-po-su-jie-fa-manacher-suan-i2px/ | 中等 | [
"模拟",
"回文串"
] | 给你一个字符串 `s`,找到 `s` 中最长的回文子串。
示例 1:
```
输入:s = "babad"
输出:"bab"
解释:"aba" 同样是符合题意的答案。
```
示例 2:
```
输入:s = "cbbd"
输出:"bb"
```
示例 3:
```
输入:s = "a"
输出:"a"
```
示例 4:
```
输入:s = "ac"
输出:"a"
```
提示:
* $1 <= s.length <= 1000$
* `s` 仅由数字和英文字母(大写和/或小写)组成 | ### 朴素解法
这道题有一个很容易就能想到的简单做法:枚举字符串 `s` 中的每一位,作为回文串的中心点,左右进行扩展,直到达到边界或者不满足回文串定义为止。
这样做的思路必然是正确的。
但很显然这是一个朴素(暴力)做法,那么我们如何确定这一做法是否可行呢?
还记得我们上一节的分析思路吗?当我们有了一个简单的实现方法之后,需要从**题目的数据规模**、**计算机的处理速度**和**实现方法的计算量**出发,判断这样的做法是否不会超时。
由于字符串长度最多只有 1000,而我们的实现方法是 $O(n^2)$,因此我们算法的计算量应该在 $10^6$ 以内,是在计算机每秒的处理范围内的。
首先枚举回文串的中心 i,然后分两... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.5` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/6. Z 字形变换（中等）.md | 6. Z 字形变换 | https://leetcode-cn.com/problems/zigzag-conversion/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-naz6/ | 中等 | [
"模拟",
"数学"
] | 将一个给定字符串 `s` 根据给定的行数 `numRows` ,以从上往下、从左到右进行 `Z` 字形排列。
比如输入字符串为 `"PAYPALISHIRING"` 行数为 $3$ 时,排列如下:
```
P A H N
A P L S I I G
Y I R
```
之后,你的输出需要从左往右逐行读取,产生出一个新的字符串,比如 `"PAHNAPLSIIGYIR"` 。
请你实现这个将字符串进行指定行数变换的函数:`string convert(string s, int numRows);`
示例 1:
```
输入:s = "PAYPALISHIRING", numRows = 3
输出:"PAHN... | ### 模拟
由于最终是要我们对 `Z` 型矩阵进行从上往下、从左往右的构建输出。
因此可以构建一个矩阵 `g` 存储 `Z` 型中的每行字符(忽略 `Z` 中的空格间隙),同时使用 `idxs` 存储 `Z` 型中每行用到的下标。
目标 `Z` 型 和 矩阵 `g` 以及 `idxs` 三者关系:
```
P I N PIN 3
A L S I G => ALSIG => 5
Y A H R YAHR 4
P I ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.6` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/7. 整数反转（简单）.md | 7. 整数反转 | https://leetcode-cn.com/problems/reverse-integer/solution/shua-chuan-lc-bu-wan-mei-jie-fa-wan-mei-919rd/ | 简单 | [
"数学",
"模拟"
] | 给你一个 $32$ 位的有符号整数 `x` ,返回将 `x` 中的数字部分反转后的结果。
如果反转后整数超过 $32$ 位的有符号整数的范围 $[−2^{31}, 2^{31} − 1]$ ,就返回 $0$。
假设环境不允许存储 $64$ 位整数(有符号或无符号)。
示例 1:
```
输入:x = 123
输出:321
```
示例 2:
```
输入:x = -123
输出:-321
```
示例 3:
```
输入:x = 120
输出:21
```
示例 4:
```
输入:x = 0
输出:0
```
提示:
* -$2^{31} <= x <= 2^{31}$ - 1 | ### 不完美解法
在机试或者周赛这种需要快速 AC 的场景中,遇到这种从文字上进行限制的题目,可以选择性的忽略限制。
对于本题,题目从文字上限制我们只能使用 $32$ 位的数据结构(`int`)。
但由于数据范围过大,使用 `int` 会有溢出的风险,所以我们使用 `long` 来进行计算,在返回再转换为 `int`。
代码:
```Java
class Solution {
public int reverse(int x) {
long ans = 0;
while (x != 0) {
ans = ans * 10 + x % 10;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.7` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/8. 字符串转换整数 (atoi)（中等）.md | 8. 字符串转换整数 (atoi) | https://leetcode-cn.com/problems/string-to-integer-atoi/solution/shua-chuan-lc-jian-ji-jie-fa-by-ac_oier-69tp/ | 中等 | [
"模拟"
] | 请你来实现一个 `myAtoi(string s)` 函数,使其能将字符串转换成一个 32 位有符号整数(类似 C/C++ 中的 atoi 函数)。
函数 `myAtoi(string s)` 的算法如下:
* 读入字符串并丢弃无用的前导空格
* 检查下一个字符(假设还未到字符末尾)为正还是负号,读取该字符(如果有)。 确定最终结果是负数还是正数。 如果两者都不存在,则假定结果为正。
* 读入下一个字符,直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
* 将前面步骤读入的这些数字转换为整数(即,`"123" -> 123`, `"0032" -> 32`)。如果没有读入数字,则整数为 $0$ 。必要时更改符... | ### 朴素解法
这是道模拟题。
一看这题目描述,多少有点做工程项目各种判断的意思了。
但对于这类题目,切忌一上来直接写代码,很容易会陷入各种边界判断。
这时候一个比较推荐的做法是先对要求进行提炼整理:
1. 忽略前导空格
2. 首字符只能是 正号/负号/数字,否则不合法(返回 0)
3. 继续往后匹配字符,直到结尾或不为数字为止(匹配过程中如果出现溢出,根据正负直接返回 `Integer.MAX_VALUE` 或 `Integer.MIN_VALUE`)。
当整理出来具体的逻辑之后,记得再次检查是否有遗漏掉某些边界情况。
确定逻辑之后,代码就好写了。
代码:
```Java
class Solution {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.8` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1-10/9. 回文数（简单）.md | 9. 回文数 | https://leetcode-cn.com/problems/palindrome-number/solution/shua-chuan-lc-zi-fu-chuan-fei-zi-fu-chua-e8l0/ | 简单 | [
"数学",
"回文串"
] | 给你一个整数 `x` ,如果 `x` 是一个回文整数,返回 `true` ;否则,返回 `false` 。
回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。
例如,$121$ 是回文,而 $123$ 不是。
示例 1:
```
输入:x = 121
输出:true
```
示例 2:
```
输入:x = -121
输出:false
解释:从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
```
示例 3:
```
输入:x = 10
输出:false
解释:从右向左读, 为 01 。因此它不是一个回文数。
```
示例 4:
```
输入:x = -101
输出:... | ### 字符串解法
虽然进阶里提到了不能用字符串来解决,但还是提供一下吧。
代码:
```Java
class Solution {
public boolean isPalindrome(int x) {
String s = String.valueOf(x);
StringBuilder sb = new StringBuilder(s);
sb.reverse();
return sb.toString().equals(s);
}
}
```
* 时间复杂度:数字 $n$ 的位数,数字大约有 $\log_{10}^n$ 位,翻转操作要执行循... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.9` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1001. 网格照明（困难）.md | 1001. 网格照明 | https://leetcode-cn.com/problems/grid-illumination/solution/gong-shui-san-xie-ha-xi-biao-xian-ying-s-s48d/ | 困难 | [
"模拟",
"哈希表"
] | 在大小为 `n x n` 的网格 `grid` 上,每个单元格都有一盏灯,最初灯都处于 关闭 状态。
给你一个由灯的位置组成的二维数组 `lamps`,其中 $lamps[i] = [row_i, col_i]$ 表示 打开 位于 `grid[rowi][coli]` 的灯。即便同一盏灯可能在 `lamps` 中多次列出,不会影响这盏灯处于 打开 状态。
当一盏灯处于打开状态,它将会照亮 自身所在单元格 以及同一 行 、同一 列 和两条 对角线 上的 所有其他单元格 。
另给你一个二维数组 `queries`,其中 $queries[j] = [row_j, col_j]$ 。对于第 $j$ 个查询,如果单元格 $[row_j... | ### 哈希表 + 线映射
棋盘大小的数据范围为 $n = 10^9$,硬模拟「亮灯」的操作必然会 `TLE`,而 `lamps` 和 `queries` 数据范围为 $20000$ 是一个较为常见的突破口。
由于点亮每一盏灯,可以使得当前 **行、列 和 对角线** 的位置被照亮,行列可直接使用棋盘坐标的 $(x, y)$ 来代指,而对角线则可以使用「截距」来进行代指,即使用 $x + y$ 和 $x - y$ 进行代指。
分别使用四个「哈希表」`row`、`col`、`left` 和 `right` 来记录 **行、列 和 对角线** 的点亮情况(`key` 为线编号,`value` 为点亮次数)。
这样我们可以在 $O... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1001` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1004. 最大连续1的个数 III（中等）.md | 1004. 最大连续1的个数 III | https://leetcode-cn.com/problems/max-consecutive-ones-iii/solution/san-chong-jie-fa-cong-dong-tai-gui-hua-d-gxks/ | 中等 | [
"双指针",
"滑动窗口",
"二分",
"前缀和"
] | 给定一个由若干 $0$ 和 $1$ 组成的数组 `A`,我们最多可以将 $K$ 个值从 $0$ 变成 $1$ 。
返回仅包含 $1$ 的最长(连续)子数组的长度。
示例 1:
```
输入:A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出:6
解释:
[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1,最长的子数组长度为 6。
```
示例 2:
```
输入:A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出:10
解释:
[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻... | ### 动态规划(TLE)
看到本题,其实首先想到的是 DP,但是 DP 是 $O(nk)$ 算法。
看到了数据范围是 $10^4$,那么时空复杂度应该都是 $10^8$。
空间可以通过「滚动数组」优化到 $10^4$,但时间无法优化,会超时。
**PS. 什么时候我们会用 DP 来解本题?通过如果 K 的数量级不超过 1000 的话,DP 应该是最常规的做法。**
定义 $f[i,j]$ 代表考虑前 $i$ 个数(并以 $A[i]$ 为结尾的),最大翻转次数为 $j$ 时,连续 $1$ 的最大长度。
* 如果 $A[i]$ 本身就为 1 的话,无须消耗翻转次数,$f[i][j] = f[i - 1][j] + 1$。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1004` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1005. K 次取反后最大化的数组和（简单）.md | 1005. K 次取反后最大化的数组和 | https://leetcode-cn.com/problems/maximize-sum-of-array-after-k-negations/solution/gong-shui-san-xie-jian-dan-fen-qing-kuan-6qwu/ | 简单 | [
"优先队列(堆)",
"模拟",
"贪心"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,按以下方法修改该数组:
* 选择某个下标 `i` 并将 `nums[i]` 替换为 `-nums[i]` 。
重复这个过程恰好 `k` 次。可以多次选择同一个下标 `i` 。
以这种方式修改数组后,返回数组 可能的最大和 。
示例 1:
```
输入:nums = [4,2,3], k = 1
输出:5
解释:选择下标 1 ,nums 变为 [4,-2,3] 。
```
示例 2:
```
输入:nums = [3,-1,0,2], k = 3
输出:6
解释:选择下标 (1, 2, 2) ,nums 变为 [3,1,0,2] 。
```
示例 3:
```
输... | ### 贪心 + 分情况讨论 + 模拟
假设取反前的总和为 $sum$,取反一个任意值 $x$ 后,对 $sum$ 的影响为 $- 2 * x$。
即取反一个负数会使得结果变大,取反正数会使结果变小,取反 $0$ 值对结果没有影响。
因此,为了让取反后的结果尽可能的大,我们应当取反 $-2*x$ 尽可能大的数值。即按照「负数从小到大的顺序进行取反」。
对取反次数 $k$ 和 负数个数 $cnt$ 进行分情况讨论:
* $k <= cnt$:按照负数从小到大的顺序进行取反即可;
* $k > cnt$:按照负数从小到大的顺序进行取反后,根据「是否存在 $0$ 值」和「剩余取反次数的奇偶性」进行分情况讨论:
* 存在 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1005` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1001-1010/1006. 笨阶乘（中等）.md | 1006. 笨阶乘 | https://leetcode-cn.com/problems/clumsy-factorial/solution/gong-shui-san-xie-tong-yong-biao-da-shi-nngfp/ | 中等 | [
"数学",
"栈"
] | 通常,正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。
例如,factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。
相反,我们设计了一个笨阶乘 clumsy:在整数的递减序列中,我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符:乘法(*),除法(/),加法(+)和减法(-)。
例如,clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而,这些运算仍然使用通常的算术运算顺序:我们在任何加、减步骤之前执行所有的乘法和除法步骤,并且按从左到右处理乘法和除法步骤。
另外,我们使用的除法是地板除法(floor... | ### 通用表达式解法
第一种解法是我们的老朋友解法了,使用「双栈」来解决通用表达式问题。
**事实上,我提供这套解决方案不仅仅能解决只有 `+ - ( )`([224. 基本计算器](https://leetcode-cn.com/problems/basic-calculator/)) 或者 `+ - * /`([227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/)) 的表达式问题,还能能解决 `+ - * / ^ % ( )` 的完全表达式问题。**
甚至支持自定义运算符,只要在运算优先级上进行维护即可。
**对于「... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1006` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/101-110/108. 将有序数组转换为二叉搜索树（简单）.md | 108. 将有序数组转换为二叉搜索树 | https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/solutions/2436639/gong-shui-san-xie-jian-dan-di-gui-fen-zh-nzqx/ | 简单 | [
"二叉树",
"树的搜索",
"分治"
] | 给你一个整数数组 `nums`,其中元素已经按 升序 排列,请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 $1$ 」的二叉树。
示例 1:
```
输入:nums = [-10,-3,0,5,9]
输出:[0,-3,9,-10,null,5]
解释:[0,-10,5,null,-3,null,9] 也将被视为正确答案:
```
示例 2:
```
输入:nums = [1,3]
输出:[3,1]
解释:[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。
```
提示:
* $1 <= nums.length <= 10^4$
* $... | ### 递归分治
题目给定的 `nums` 严格有序,为满足构造出来的 `BST` 整体平衡,我们需要保证每个子树的构造也是平衡的。
一个容易想到的思路:使用 `nums` 中最靠近中心的位置作为整棵 `BST` 的根节点,例如下标 $mid = \left \lfloor \frac{l + r}{2} \right \rfloor$ 的位置,确保左右子树节点数量平衡。随后递归构造 `nums` 中下标范围为 $[0, mid - 1]$ 作为左子树,递归构造 `nums` 中下标范围为 $[mid + 1, n - 1]$ 作为右子树。
Java 代码:
```Java
class Solution {
publ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.108` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/101-110/109. 有序链表转换二叉搜索树（中等）.md | 109. 有序链表转换二叉搜索树 | https://leetcode.cn/problems/convert-sorted-list-to-binary-search-tree/solutions/2436644/gong-shui-san-xie-jian-dan-di-gui-fen-zh-6t1x/ | 中等 | [
"二叉树",
"树的搜索",
"分治",
"中序遍历"
] | 给定一个单链表的头节点 `head`,其中的元素 按升序排序 ,将其转换为高度平衡的二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差不超过 $1$。
示例 1:
```
输入: head = [-10,-3,0,5,9]
输出: [0,-3,9,-10,null,5]
解释: 一个可能的答案是[0,-3,9,-10,null,5],它表示所示的高度平衡的二叉搜索树。
```
示例 2:
```
输入: head = []
输出: []
```
提示:
* `head` 中的节点数在 $[0, 2 \times 10^4]$ 范围内
* $-10^5 <= Node.val <= ... | ### 递归分治
与上一题 [108. 将有序数组转换为二叉搜索树](https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/solutions/2436639/gong-shui-san-xie-jian-dan-di-gui-fen-zh-nzqx/) 类似,但链表相对于数组,无法 $O(1)$ 找到构建当前 `BST` 根节点的“中点”下标。
一个仍可确保 $O(n)$ 时间复杂度(瓶颈在于需要创建 $n$ 个节点),但需要 $O(n)$ 空间复杂度的做法是:对链表进行一次遍历,转成数组后套用上一题的做法。
一个不使用 $O(n)$ ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.109` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1011-1020/1011. 在 D 天内送达包裹的能力（中等）.md | 1011. 在 D 天内送达包裹的能力 | https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/ | 中等 | [
"二分"
] | 传送带上的包裹必须在 `D` 天内从一个港口运送到另一个港口。
传送带上的第 `i` 个包裹的重量为 $weights[i]$。
每一天,我们都会按给出重量的顺序往传送带上装载包裹。
我们装载的重量不会超过船的最大运载重量。
返回能在 `D` 天内将传送带上的所有包裹送达的船的最低运载能力。
示例 1:
```
输入:weights = [1,2,3,4,5,6,7,8,9,10], D = 5
输出:15
解释:
船舶最低载重 15 就能够在 5 天内送达所有包裹,如下所示:
第 1 天:1, 2, 3, 4, 5
第 2 天:6, 7
第 3 天:8
第 4 天:9
第 5 天:10
请注意,货物必须按照给定的顺... | ### 二分解法(精确边界)
假定「`D` 天内运送完所有包裹的最低运力」为 `ans`,那么在以 `ans` 为分割点的数轴上具有「二段性」:
* 数值范围在 $(-\infty, ans)$ 的运力必然「不满足」 `D` 天内运送完所有包裹的要求
* 数值范围在 $[ans, +\infty)$ 的运力必然「满足」 `D`天内运送完所有包裹的要求
**我们可以通过「二分」来找到恰好满足 `D`天内运送完所有包裹的分割点 `ans`。**
接下来我们要确定二分的范围,由于不存在包裹拆分的情况,考虑如下两种边界情况:
* 理论最低运力:只确保所有包裹能够被运送,自然也包括重量最大的包裹,此时理论最低运力为 `max`,`max... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1011-1020/1012. 至少有 1 位重复的数字（困难）.md | 1012. 至少有 1 位重复的数字 | https://leetcode-cn.com/problems/numbers-with-repeated-digits/solution/by-ac_oier-2szj/ | 困难 | [
"动态规划",
"数位 DP",
"容斥原理"
] | 给定正整数 $n$,返回在 $[1, n]$ 范围内具有 至少 1 位 重复数字的正整数的个数。
示例 1:
```
输入:n = 20
输出:1
解释:具有至少 1 位重复数字的正数(<= 20)只有 11 。
```
示例 2:
```
输入:n = 100
输出:10
解释:具有至少 1 位重复数字的正数(<= 100)有 11,22,33,44,55,66,77,88,99 和 100 。
```
示例 3:
```
输入:n = 1000
输出:262
```
提示:
* $1 <= n <= 10^9$ | ### 数位 DP
**首先 $[1, n]$ 共有 $n$ 个数,而求解 $[1, n]$ 范围内有多少个「至少有 $1$ 位重复数字」的数的个数,等价于「总数 $n$」减去「没有重复数的数的个数」。**
于是问题转换为:**如何求解「没有重复数」的数的个数,同时为了更具一般性,我们将求解 $[1, n]$ 范围内「没有重复数」的数的个数,修改为求解 $[0, n]$ 范围内「没有重复数」的数的个数**。
>即将问题转换为 [(题解) 357. 统计各位数字都不同的数字个数](https://leetcode-cn.com/problems/count-numbers-with-unique-digits/solution/... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1012` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1011-1020/1020. 飞地的数量（中等）.md | 1020. 飞地的数量 | 中等 | [
"DFS",
"并查集"
] | 给你一个大小为 $m x n$ 的二进制矩阵 $grid$ ,其中 $0$ 表示一个海洋单元格、$1$ 表示一个陆地单元格。
一次 移动 是指从一个陆地单元格走到另一个相邻(上、下、左、右)的陆地单元格或跨过 $grid$ 的边界。
返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。
示例 1:
```
输入:grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
输出:3
解释:有三个 1 被 0 包围。一个 1 没有被包围,因为它在边界上。
```
示例 2:
```
输入:grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,... | ### 并查集 + DFS
根据题目定义,我们知道需要统计所有不和「边缘陆地」相连通的「普通陆地」数量。
我们可以用「并查集」来维护连通块,使用 `DFS` 对所有「边缘陆地连通块」进行标记(设定编号为 $0$ 的超级源点,对于所有的「边缘陆地连通块」,将其与超级源点联通)。
具体的,我们按照如下流程进行处理:
* 初始化并查集:起始让每个单元格独立作为一个连通块;
* 使用 `DFS` 标记所有「边缘陆地连通块」:从位于边缘的「边缘陆地」进行出发,将其所在连通块与超级源点 $0$ 进行联通标记(同时为了确保复杂度,我们在进行 `DFS` 前需要先检查当前陆地与超级源点的联通关系,如果已联通,说明当前陆地隶属于之前的某个连... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 | |
LeetCode/1021-1030/1021. 删除最外层的括号（简单）.md | 1021. 删除最外层的括号 | https://leetcode.cn/problems/remove-outermost-parentheses/solution/by-ac_oier-jmxi/ | 简单 | [
"模拟",
"双指针"
] | 有效括号字符串为空 `""`、`"(" + A + ")"` 或 `A + B` ,其中 `A` 和 `B` 都是有效的括号字符串,`+` 代表字符串的连接。
例如,`""`,`"()"`,`"(())()"` 和 `"(()(()))"` 都是有效的括号字符串。
如果有效字符串 `s` 非空,且不存在将其拆分为 `s = A + B` 的方法,我们称其为原语(`primitive`),其中 `A` 和 `B` 都是非空有效括号字符串。
给出一个非空有效字符串 `s`,考虑将其进行原语化分解,使得:`s = P_1 + P_2 + ... + P_k`,其中 `P_i` 是有效括号字符串原语。
对 `s` 进行原语化分解,删... | ### 双指针模拟
和其他「有效括号」问题一样,我们将 `(` 记为 $1$ 分,将 `)` 记为 $-1$。
由于 `s` 本身为有效字符串,因此我们可以从前往后进行处理,每一次找到符合 $socre = 0$ 的连续段 $[i, j)$,然后再结合题意,删掉外层括号,即将 $[i + 1, j - 1)$ 加入答案。
代码:
```Java
class Solution {
public String removeOuterParentheses(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1021` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1021-1030/1022. 从根到叶的二进制数之和（简单）.md | 1022. 从根到叶的二进制数之和 | https://leetcode.cn/problems/sum-of-root-to-leaf-binary-numbers/solution/by-ac_oier-1905/ | 简单 | [
"DFS",
"BFS",
"二叉树",
"树的遍历"
] | 给出一棵二叉树,其上每个结点的值都是 $0$ 或 $1$ 。每一条从根到叶的路径都代表一个从最高有效位开始的二进制数。
例如,如果路径为 `0 -> 1 -> 1 -> 0 -> 1`,那么它表示二进制数 `01101`,也就是 $13$ 。
对树上的每一片叶子,我们都要找出从根到该叶子的路径所表示的数字。
返回这些数字之和。题目数据保证答案是一个 $32$ 位 整数。
示例 1:
```
输入:root = [1,0,1,0,1,0,1]
输出:22
解释:(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
```
示例 2:
```
输入:root = [0]
输出... | ### 递归
容易想到「递归」进行求解,在 `DFS` 过程中记录下当前的值为多少,假设遍历到当前节点 $x$ 前,记录的值为 $cur$,那么根据题意,我们需要先将 $cur$ 进行整体左移(腾出最后一位),然后将节点 $x$ 的值放置最低位来得到新的值,并继续进行递归。
递归有使用「函数返回值」和「全局变量」两种实现方式。
代码:
```Java
class Solution {
public int sumRootToLeaf(TreeNode root) {
return dfs(root, 0);
}
int dfs(TreeNode root, int cur) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1022` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1032. 字符流（困难）.md | 1032. 字符流 | https://leetcode.cn/problems/stream-of-characters/solution/by-ac_oier-ihd4/ | 困难 | [
"字典树",
"枚举",
"剪枝"
] | 设计一个算法:接收一个字符流,并检查这些字符的后缀是否是字符串数组 `words` 中的一个字符串。
例如,`words = ["abc", "xyz"]` 且字符流中逐个依次加入 $4$ 个字符 `'a'`、`'x'`、`'y'` 和 `'z'` ,你所设计的算法应当可以检测到 `"axyz"` 的后缀 `"xyz"` 与 `words` 中的字符串 `"xyz"` 匹配。
按下述要求实现 `StreamChecker` 类:
* `StreamChecker(String[] words)` :构造函数,用字符串数组 `words` 初始化数据结构。
* `boolean query(char letter)`:从字符流中... | ### Trie + 枚举
先考虑最为简单的做法:将给定的所有 $words[i]$ 顺序插入字典树,根据数据范围可知这一步计算量为 $2000 \times 200$,其中最大的 $words[i]$ 长度只有 $200$。
然后利用$words[i]$ 长度只有 $200$ 这一条件,直接使用「枚举」的方式来实现 `query`。
具体的,我们可以先使用一个字符串 `s` 来记录 `query` 操作产生的数据流,然后实现一个 `boolean query(int start, int end)` 方法,该方法会检查字典树中是否存在 $s[i...j]$ 子串。
由于 $words[i]$ 长度只有 $200$(假设当前... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1032` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1034. 边界着色（中等）.md | 1034. 边界着色 | https://leetcode-cn.com/problems/coloring-a-border/solution/gong-shui-san-xie-tu-lun-sou-suo-zhuan-t-snvw/ | 中等 | [
"图论 DFS",
"图论 BFS"
] | 给你一个大小为 `m x n` 的整数矩阵 `grid`,表示一个网格。另给你三个整数 `row`、`col` 和 `color` 。网格中的每个值表示该位置处的网格块的颜色。
当两个网格块的颜色相同,而且在四个方向中任意一个方向上相邻时,它们属于同一 连通分量 。
连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻(四个方向上)的所有网格块,或者在网格的边界上(第一行/列或最后一行/列)的所有网格块。
请你使用指定颜色 `color` 为所有包含网格块 `grid[row][col]` 的 连通分量的边界 进行着色,并返回最终的网格 `grid` 。
示例 1:
```
输入:grid = [[1,1],[1,2... | ### 基本分析
这是一道结合「阅读理解」的常规图论搜索题。
基本题意为:从题目给定的 $(row, col)$ 进行出发,如果遍历到「**连通分量的边界**」格子,则使用 $color$ 进行上色。
同一「连通分量」的「非边界」格子满足:**当前格子的四联通方向均存在相邻格子,且当前格子与四联通相邻格子颜色一致。**
也就是说,我们从 $(row, col)$ 进行出发,遍历 $(row, col)$ 所在的「连通分量」,如果遍历到的「连通分量」格子不满足上述条件(边界格子),则进行上色。
---
### BFS
具体的,我们可以使用 `BFS` 进行求解:
* 构造 $ans$ 矩阵作为答案,同时 $ans$ 也... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1034` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1035. 不相交的线（中等）.md | 1035. 不相交的线 | https://leetcode-cn.com/problems/uncrossed-lines/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bkaas/ | 中等 | [
"最长公共子序列",
"序列 DP",
"LCS"
] | 在两条独立的水平线上按给定的顺序写下 `s1` 和 `s2` 中的整数。
现在,可以绘制一些连接两个数字 $s1[i]$ 和 $s2[j]$ 的直线,这些直线需要同时满足满足:
* $s1[i] = s2[j]$
* 且绘制的直线不与任何其他连线(非水平线)相交。
请注意,连线即使在端点也不能相交:每个数字只能属于一条连线。
以这种方法绘制线条,并返回可以绘制的最大连线数。
示例 1:
<img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/28/142.png" style="zoom:18%;" />
```
输入:... | ### 动态规划
这是一道「[最长公共子序列(LCS)](https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/)」的轻度变形题。
对于这类题都使用如下「状态定义」即可:
**$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度。**
然后不失一般性的考虑 $f[i][j]$ 如何转移。
**由于我们的「状态定义」只是说「考虑前 $i$ 个和考虑前 $j$ 个字符」,并没有说「一... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1035` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1036. 逃离大迷宫（困难）.md | 1036. 逃离大迷宫 | https://leetcode-cn.com/problems/escape-a-large-maze/solution/gong-shui-san-xie-bfs-gei-ding-zhang-ai-8w63o/ | 困难 | [
"几何",
"BFS"
] | 在一个 $10^6 \times 10^6$ 的网格中,每个网格上方格的坐标为 $(x, y)$ 。
现在从源方格 $source = [s_x, s_y]$ 开始出发,意图赶往目标方格 $target = [t_x, t_y]$ 。
数组 $blocked$ 是封锁的方格列表,其中每个 $blocked[i] = [x_i, y_i]$ 表示坐标为 $(x_i, y_i)$ 的方格是禁止通行的。
每次移动,都可以走到网格中在四个方向上相邻的方格,只要该方格 不 在给出的封锁列表 $blocked$ 上。同时,不允许走出网格。
只有在可以通过一系列的移动从源方格 $source$ 到达目标方格 $target$ 时才返回 $... | ### BFS + 给定障碍物所能围成的最大面积
为了方便,我们用 $s$ 代指 $source$,用 $t$ 代指 $target$,用 $n$ 来代指 $blocked$ 大小。
整理题意为:在一个足够大的空间里,有少数的障碍物,问两点是否连通。
当两点相隔较远时,常规的 `BFS` 做法可能会搜完整个棋盘,而棋盘大小为 $10^6 \times 10^6$,会 `TLE`。
考虑什么情况下两点会不连通?
当两个点中的任意一点被障碍物围住时,两点将无法连通。
一个很容易想到的思路是:**从 $s$ 跑一遍 `BFS`,然后从 $t$ 跑一遍 `BFS`,同时设定一个最大访问点数量 `MAX`,若从两者出发能够访问的点... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1036` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1037. 有效的回旋镖（简单）.md | 1037. 有效的回旋镖 | https://leetcode.cn/problems/valid-boomerang/solution/by-ac_oier-eory/ | 简单 | [
"计算几何",
"数学"
] | 给定一个数组 `points`,其中 $points[i] = [x_i, y_i]$ 表示 `X-Y` 平面上的一个点,如果这些点构成一个 回旋镖 则返回 `true`。
回旋镖 定义为一组三个点,这些点 各不相同 且 不在一条直线上 。
示例 1:
```
输入:points = [[1,1],[2,3],[3,2]]
输出:true
```
示例 2:
```
输入:points = [[1,1],[2,2],[3,3]]
输出:false
```
提示:
* $points.length == 3$
* $points[i].length == 2$
* $0 <= x_i, y_i <= 100$ | ### 计算几何
共三个点,分别使用两个点计算向量,随后判断向量叉积是否为 $0$。
代码:
```Java
class Solution {
public boolean isBoomerang(int[][] ps) {
return (ps[1][0] - ps[0][0]) * (ps[2][1] - ps[0][1]) != (ps[2][0] - ps[0][0]) * (ps[1][1] - ps[0][1]);
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1037` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1031-1040/1038. 从二叉搜索树到更大和树（中等）.md | 1038. 从二叉搜索树到更大和树 | https://leetcode.cn/problems/binary-search-tree-to-greater-sum-tree/solutions/2552959/gong-shui-san-xie-bst-de-zhong-xu-bian-l-vtu1/ | 中等 | [
"BST",
"中序遍历"
] | 给定一个二叉搜索树 `root` (BST),请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。
提醒一下, 二叉搜索树满足下列约束条件:
* 节点的左子树仅包含键小于节点键的节点。
* 节点的右子树仅包含键大于节点键的节点。
* 左右子树也必须是二叉搜索树。
示例 1:
```
输入:[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出:[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
```
示例 2:
```
输入:root = [0,null,1]
输出:[1,null,1]
`... | ### 中序遍历
利用 **`BST` 的中序遍历是有序** 的特性,我们可以通过两次遍历 `BST` 来求解问题。
首先,通过一次遍历,计算出整棵树的节点总和 `tot`,然后在中序遍历过程中,不断对 `tot` 进行更新,将其作为当前未遍历到的节点的总和,用于给当前节点赋值。
假设当前遍历到的节点为 `x`(起始节点值为 `t`),那么将节点更新为当前节点 `tot` 后,更新 `tot = tot - t`。
这是常规的中序遍历做法,更进一步,如果将其中序遍历的顺序进行翻转(从「左中右」调整为「右中左」),则可实现一次遍历。
Java 代码:
```Java
class Solution {
int tot ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1038` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1041. 困于环中的机器人（中等）.md | 1041. 困于环中的机器人 | https://leetcode.cn/problems/robot-bounded-in-circle/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-hgdtp/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 在无限的平面上,机器人最初位于 $(0, 0)$ 处,面朝北方。注意:
* 北方向 是 `y` 轴的正方向。
* 南方向 是 `y` 轴的负方向。
* 东方向 是 `x` 轴的正方向。
* 西方向 是 `x` 轴的负方向。
机器人可以接受下列三条指令之一:
* `"G"`:直走 $1$ 个单位
* `"L"`:左转 $90$ 度
* `"R"`:右转 $90$ 度
机器人按顺序执行指令 `instructions`,并一直重复它们。
只有在平面中存在环使得机器人永远无法离开时,返回 `true`。否则,返回 `false`。
示例 1:
```
输入:instructions = "GGLLGG"
输出:true
解... | ### 模拟
为了方便,将 `instructions` 记为 `s`,“北西南东”四个方向分别记为“上左下右”四个逆时针方向。
起始位置在 $(0,0)$,方向为上,我们可以将「位置 + 方向」统称为「状态」。
所谓“循环”,则是指执行若干次的 `s` 后,会回到相同的状态。
我们可以按 `s` 执行一遍,假设执行完所在位置为 $(x, y)$,所在位置为 $k$,先根据 **位置** 分情况讨论:
1. $(x, y)$ 为 $(0, 0)$,此时无论执行一遍后的方向为何值,必然能在若干次执行后回到起始状态。
即只需要确保 `(n * k) % 4` 为 $0$ 即可,机器人会陷入循环;
2. $(x, y)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1041` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1044. 最长重复子串（困难）.md | 1044. 最长重复子串 | https://leetcode-cn.com/problems/longest-duplicate-substring/solution/gong-shui-san-xie-zi-fu-chuan-ha-xi-ying-hae9/ | 困难 | [
"字符串哈希",
"二分",
"后缀数组"
] | 给你一个字符串 `s` ,考虑其所有 重复子串 :即 `s` 的连续子串,在 `s` 中出现 $2$ 次或更多次。这些出现之间可能存在重叠。
返回 任意一个 可能具有最长长度的重复子串。如果 `s` 不含重复子串,那么答案为 `""` 。
示例 1:
```
输入:s = "banana"
输出:"ana"
```
示例 2:
```
输入:s = "abcd"
输出:""
```
提示:
* $2 <= s.length <= 3 * 10^4$
* `s` 由小写英文字母组成 | ### 字符串哈希 + 二分
题目要求得「能取得最大长度的任一方案」,首先以「最大长度」为分割点的数轴具有「二段性」:
* 小于等于最大长度方案均存在(考虑在最大长度方案上做删减);
* 大于最大长度的方案不存在。
二分范围为 $[0, n]$,关键在于如何 `check` 函数,即实现「检查某个长度 $len$ 作为最大长度,是否存在合法方案」。
对于常规做法而言,可枚举每个位置作为起点,得到长度为 $len$ 的子串,同时使用 `Set<String>` 容器记录已被处理过子串有哪些,当容器中出现过当前子串,说明存在合法方案。
但是该做法实现的 `check` 并非线性,子串的生成和存入容器的时执行的哈希函数执行均和子... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1044` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1047. 删除字符串中的所有相邻重复项（简单）.md | 1047. 删除字符串中的所有相邻重复项 | https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/solution/cong-30-dao-100wu-chong-shi-xian-jie-jue-vkah/ | 简单 | [
"队列",
"模拟"
] | 给出由小写字母组成的字符串 S,重复项删除操作会选择两个相邻且相同的字母,并删除它们。
在 S 上反复执行重复项删除操作,直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
示例:
```
输入:"abbaca"
输出:"ca"
解释:
例如,在 "abbaca" 中,我们可以删除 "bb" 由于两字母相邻且相同,这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca",其中又只有 "aa" 可以执行重复项删除操作,所以最后的字符串为 "ca"。
```
提示:
* 1 <= S.length <= 20000
* S 仅由小写英文字母组成。 | ### (自带) 栈解法
```java
class Solution {
public String removeDuplicates(String s) {
char[] cs = s.toCharArray();
Deque<Character> d = new ArrayDeque<>();
for (char c : cs) {
if (!d.isEmpty() && d.peekLast().equals(c)) {
d.pollLast();
} else {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1047` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1041-1050/1049. 最后一块石头的重量 II（中等）.md | 1049. 最后一块石头的重量 II | https://leetcode-cn.com/problems/last-stone-weight-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-neng-jgxik/ | 中等 | [
"动态规划",
"背包问题",
"01 背包",
"数学"
] | 有一堆石头,用整数数组 `stones` 表示。
其中 `stones[i]` 表示第 `i` 块石头的重量。
每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 `x` 和 `y`,且 `x <= y`。那么粉碎的可能结果如下:
* 如果 `x == y`,那么两块石头都会被完全粉碎;
* 如果 `x != y`,那么重量为 `x` 的石头将会完全粉碎,而重量为 `y` 的石头新重量为 `y-x`。
最后,最多只会剩下一块 石头。返回此石头最小的可能重量 。
如果没有石头剩下,就返回 `0`。
示例 1:
```
输入:stones = [2,7,4,1,8,1]
输出:1
解释:
组合 2 和 4... | ### 基本分析
看到标题,心里咯噔了一下 🤣
一般性的石子合并问题通常是只能操作相邻的两个石子,要么是「区间 DP」要么是「四边形不等式」,怎么到 LeetCode 就成了中等难度的题目(也太卷了 🤣
仔细看了一下题目,可对任意石子进行操作,重放回的重量也不是操作石子的总和,而是操作石子的差值。
哦,那没事了 ~ 🤣
也是基于此启发,我们可以这样进行分析。
假设想要得到最优解,我们需要按照如下顺序操作石子:$[(sa, sb), (sc, sd), ... ,(si, sj), (sp, sq)]$。
其中 $abcdijpq$ 代表了石子编号,**字母顺序不代表编号的大小关系**。
**如果不考虑「有放回」... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1049` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1051-1060/1051. 高度检查器（简单）.md | 1051. 高度检查器 | https://leetcode.cn/problems/height-checker/solution/by-ac_oier-8xoj/ | 简单 | [
"排序",
"模拟"
] | 学校打算为全体学生拍一张年度纪念照。根据要求,学生需要按照 非递减 的高度顺序排成一行。
排序后的高度情况用整数数组 `expected` 表示,其中 `expected[i]` 是预计排在这一行中第 `i` 位的学生的高度(下标从 $0$ 开始)。
给你一个整数数组 `heights`,表示 当前学生站位 的高度情况。`heights[i]` 是这一行中第 `i` 位学生的高度(下标从 $0$ 开始)。
返回满足 `heights[i] != expected[i]` 的 下标数量 。
示例:
```
输入:heights = [1,1,4,2,1,3]
输出:3
解释:
高度:[1,1,4,2,1,3]
预期:[1... | ### 排序
先排序得到目标序列,再将目标序列和原序列进行逐一对比,得到答案。
排序部分,可以使用复杂度为 $O(n\log{n})$ 的双轴快排,也可以利用数据范围为 $100$,利用计数排序思想来构建目标序列,复杂度为 $O(C + n)$。
代码(快排 $P1$,计数排序 $P2$):
```Java
class Solution {
public int heightChecker(int[] heights) {
int[] t = heights.clone();
Arrays.sort(t);
int n = heights.length, ans = 0;... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1051` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
End of preview. Expand in Data Studio
extract from LogicStack-LeetCode 公众号「宫水三叶的刷题日记」刷穿 LeetCode 系列文章源码
包括 编程题目、解析、tag、题目url
根据 leetcode 原始题目网页，修正了一些 文件名 和 文件内容 中标注的难度不一致的文件样本
- Downloads last month
- 14