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/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 原题链接和其他优选题解。 |
LeetCode/1051-1060/1052. 爱生气的书店老板（中等）.md | 1052. 爱生气的书店老板 | https://leetcode-cn.com/problems/grumpy-bookstore-owner/solution/hua-dong-chuang-kou-luo-ti-by-ac_oier-nunu/ | 中等 | [
"滑动窗口",
"双指针"
] | 今天,书店老板有一家店打算试营业 $customers.length$ 分钟。每分钟都有一些顾客($customers[i]$)会进入书店,所有这些顾客都会在那一分钟结束后离开。
在某些时候,书店老板会生气。 如果书店老板在第 $i$ 分钟生气,那么 $grumpy[i] = 1$,否则 $grumpy[i] = 0$。 当书店老板生气时,那一分钟的顾客就会不满意,不生气则他们是满意的。
书店老板知道一个秘密技巧,能抑制自己的情绪,可以让自己连续 $X$ 分钟不生气,但却只能使用一次。
请你返回这一天营业下来,最多有多少客户能够感到满意的数量。
示例:
```
输入:customers = [1,0,1,2,1,1,7,5]... | ### 滑动窗口
由于「技巧」只会将情绪将「生气」变为「不生气」,不生气仍然是不生气。
1. 我们可以先将原本就满意的客户加入答案,同时将对应的 $customers[i]$ 变为 $0$。
2. 之后的问题转化为:在 $customers$ 中找到连续一段长度为 $minutes$ 的子数组,使得其总和最大。这部分就是我们应用技巧所得到的客户。
代码:
```Java
class Solution {
public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
int n = customers.length, ans ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1052` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1071-1080/1074. 元素和为目标值的子矩阵数量（困难）.md | 1074. 元素和为目标值的子矩阵数量 | https://leetcode-cn.com/problems/number-of-submatrices-that-sum-to-target/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-uttw/ | 困难 | [
"前缀和",
"哈希表"
] | 给出矩阵 matrix 和目标值 target,返回元素总和等于目标值的非空子矩阵的数量。
子矩阵 x1, y1, x2, y2 是满足 x1 <= x <= x2 且 y1 <= y <= y2 的所有单元 matrix[x][y] 的集合。
如果 (x1, y1, x2, y2) 和 (x1', y1', x2', y2') 两个子矩阵中部分坐标不同(如:x1 != x1'),那么这两个子矩阵也不同。
示例 1:
```
输入:matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
输出:4
解释:四个只含 0 的 1x1 子矩阵。
```
示例 2:
```
输入:matri... | ### 朴素二维前缀和
从题面来看显然是一道「二维前缀和」的题目,如果你还不了解「二维前缀和」,可以看看 [(题解)304. 二维区域和检索 - 矩阵不可变](https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/)。本题预处理前缀和的复杂度为 $O(m * n)$。
搜索所有子矩阵需要枚举「矩形左上角」和「矩形右下角」,复杂度是 $O(m^2 * n^2)$。
因此,如果把本题当做二维前缀和模板题来做的话,整体复杂度是 $O(m^2 * n^2)$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1074` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1071-1080/1078. Bigram 分词（简单）.md | 1078. Bigram 分词 | https://leetcode-cn.com/problems/occurrences-after-bigram/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-qyki/ | 简单 | [
"模拟"
] | 给出第一个词 `first` 和第二个词 `second`,考虑在某些文本 `text` 中可能以 `"first second third"` 形式出现的情况,其中 `second` 紧随 `first` 出现,`third` 紧随 `second` 出现。
对于每种这样的情况,将第三个词 `"third"` 添加到答案中,并返回答案。
示例 1:
```
输入:text = "alice is a good girl she is a good student", first = "a", second = "good"
输出:["girl","student"]
```
示例 2:
```
输入:text = "we w... | ### 模拟
好像每次起晚都是简单题?🤣
根据题意进行模拟。
代码:
```Java
class Solution {
public String[] findOcurrences(String text, String a, String b) {
String[] ss = text.split(" ");
int n = ss.length;
List<String> list = new ArrayList<>();
for (int i = 0; i + 2 < n; i++) {
if (ss[i].equals(a... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1078` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1081-1090/1089. 复写零（简单）.md | 1089. 复写零 | https://leetcode.cn/problems/duplicate-zeros/solution/by-ac_oier-zivq/ | 简单 | [
"双指针"
] | 给你一个长度固定的整数数组 `arr`,请你将该数组中出现的每个零都复写一遍,并将其余的元素向右平移。
注意:请不要在超过该数组长度的位置写入元素。
要求:请对输入的数组 就地 进行上述修改,不要从函数返回任何东西。
示例 1:
```
输入:[1,0,2,3,0,4,5,0]
输出:null
解释:调用函数后,输入的数组将被修改为:[1,0,0,2,3,0,0,4]
```
示例 2:
```
输入:[1,2,3]
输出:null
解释:调用函数后,输入的数组将被修改为:[1,2,3]
```
提示:
* $1 <= arr.length <= 10000$
* $0 <= arr[i] <= 9$ | ### 双指针
这道题挺有意思的,建议大家在看文字的同时,在纸上推导一遍。
我们可以假设已经通过原数组 `arr` 处理出最终的目标数组 `ans`,起始使用指针 $i$ 指向原数组的开头位置,使用指针 $j$ 指向目标数组的开头位置。
然后开始同时从前往后处理,默认情况下,两个指针每次往后移动一位,当在原数组中出现 $arr[i] = 0$ 时,根据题意,我们需要在目标数组 $ans[j]$ 后面复写多一位,因此此时让 $j$ 多走一位。
当 $j$ 走到的位置已超出数组长度,此时 $i$ 也停在了该被截断的位置的下一位。
此时我们先将 $i$ 和 $j$ 同时往回走一步,确保 $i$ 落在真正的截断后的位置,但需要注意... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1089` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1091-1100/1092. 最短公共超序列（困难）.md | 1092. 最短公共超序列 | https://leetcode.cn/problems/shortest-common-supersequence/solution/by-ac_oier-s346/ | 困难 | [
"序列 DP",
"LCS",
"最长公共子序列",
"动态规划",
"构造",
"双指针"
] | 给出两个字符串 `str1` 和 `str2`,返回同时以 `str1` 和 `str2` 作为子序列的最短字符串。如果答案不止一个,则可以返回满足条件的任意一个答案。
(如果从字符串 `T` 中删除一些字符(也可能不删除,并且选出的这些字符可以位于 `T` 中的 任意位置),可以得到字符串 `S`,那么 `S` 就是 `T` 的子序列)
示例:
```
输入:str1 = "abac", str2 = "cab"
输出:"cabac"
解释:
str1 = "abac" 是 "cabac" 的一个子串,因为我们可以删去 "cabac" 的第一个 "c"得到 "abac"。
str2 = "cab" 是 "cabac" 的... | ### LCS 求具体方案 + 构造
为了方便,我们令 `str1` 为 `s1`,`str2` 为 `s2`,并将两者长度记为 $n$ 和 $m$。
容易想到最终的方案必然是由三部分组成:两字符串的公共子序列(且必然是最长公共子序列)+ 两者特有的字符部分。
基于此,我们可以先使用对两者求 `LCS`,并在求具体方案时遵循:属于最长公共子序列的字符只添加一次,而特有于 `s1` 或 `s2` 的字符则独自添加一次。
求解 `LCS` 部分我们定义 **$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度(为了方便,令下标从 $1$ 开始)。**
当有... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1092` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1091-1100/1094. 拼车（中等）.md | 1094. 拼车 | https://leetcode.cn/problems/car-pooling/solutions/2550276/gong-shui-san-xie-tu-jie-chai-fen-ru-men-opii/ | 中等 | [
"差分",
"前缀和"
] | 车上最初有 `capacity` 个空座位,车只能向一个方向行驶(不允许掉头或改变方向)。
给定整数 `capacity` 和一个数组 `trips`, $trip[i] = [numPassengers_{i}, from_{i}, to_{i}]$ 表示第 `i` 次旅行有 $numPassengers_{i}$ 乘客,接他们和放他们的位置分别是 $from_{i}$ 和 $to_{i}$ 。
这些位置是从汽车的初始位置向东的公里数。
当且仅当你可以在所有给定的行程中接送所有乘客时,返回 `true`,否则请返回 `false`。
示例 1:
```
输入:trips = [[2,1,5],[3,3,7]], capa... | ### 差分
从朴素的想法开始:创建一个数组 `cnt`,用于存储从某个站点出发时,车上的乘客数量。
例如 $cnt[x] = c$ 含义为在站点 $x$ 出发时(在该站点的下车和上车均完成),车上乘客数为 $c$ 个。
对于每个 $trips[i] = (c, a, b)$,我们需要对 $[a, b)$ 范围内的 $cnt[j]$ 进行加 $c$ 操作。
处理完 `trips` 后,检查所有站点的乘客人数,根据是否满足 `capacity` 限制返回答案。
因此,这是一个关于「区间修改,单点查询」的经典问题,可使用「差分」求解。
所谓“差分”,是指 **原数组中每个元素与前一元素之差所形成的数组**,与之相对应的是“前... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1094` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/11. 盛最多水的容器（中等）.md | 11. 盛最多水的容器 | https://leetcode-cn.com/problems/container-with-most-water/solution/shua-chuan-lc-shuang-zhi-zhen-tan-xin-ji-52gf/ | 中等 | [
"双指针",
"贪心"
] | 给你 $n$ 个非负整数 $a_1$,$a_2$,...,$a_n$,每个数代表坐标中的一个点 $(i, a_i)$ 。
在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 $(i, a_i)$ 和 $(i, 0)$ 。
找出其中的两条线,使得它们与 `x` 轴共同构成的容器可以容纳最多的水。
说明:你不能倾斜容器。
示例 1:
```
输入:[1,8,6,2,5,4,8,3,7]
输出:49
解释:图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。
```
示例 2:
```
输入:height = [1,1]
输出:1
```
示例... | ### 双指针 + 贪心
先用两个指针 `i` 和 `j` 指向左右边界,然后考虑指针应该怎么移动。
由于构成矩形的面积,取决于 `i` 和 `j` 之间的距离(记为 `w`) 和 `i` 和 `j` 下标对应的高度的最小值(记为 `h`)。
首先无论是 `i` 指针往右移动还是 `j` 指针往左移动都会导致 `w` 变小,所以想要能够枚举到更大的面积,我们应该让 `h` 在指针移动后变大。
不妨假设当前情况是 `height[i] < heigth[j]`(此时矩形的高度为 `height[i]`),然后分情况讨论:
* 让 `i` 和 `j` 两者高度小的指针移动,即 `i` 往右移动:
* 移动后,i 指针对应的... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/12. 整数转罗马数字（中等）.md | 12. 整数转罗马数字 | https://leetcode-cn.com/problems/integer-to-roman/solution/shua-chuan-lc-tan-xin-jie-fa-by-ac_oier-5kbw/ | 中等 | [
"模拟"
] | 罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。
```
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
```
例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字... | ### 模拟
现实中每一个「阿拉伯数字」固定对应一个「罗马数字」,不存在说一个「阿拉伯数字」能够对应出一个较长或者较短的「罗马数字」。
因此这是一个按照固定规则进行转换的「模拟」过程。
根据题意,我们可以列举出有限个罗马字符和其对应的数值。
然后从左到右构建罗马数字,优先构建数值高的罗马字符(如果有足够的分值,尽量尝试构建 "M",直到分值不够,再尽量尝试构建 "CM" ... )
代码:
```Java
class Solution {
int[] val = new int[]{1000,900,500,400,100,90,50,40,10,9,5,4,1};
String[] str = new S... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.12` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/13. 罗马数字转整数（简单）.md | 13. 罗马数字转整数 | https://leetcode-cn.com/problems/roman-to-integer/solution/shua-chuan-lc-ha-xi-biao-by-ac_oier-mooy/ | 简单 | [
"模拟",
"哈希表"
] | 罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。
```
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
```
例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字... | ### 模拟
与 [12. 整数转罗马数字](https://leetcode-cn.com/problems/integer-to-roman/solution/gong-shui-san-xie-12-zheng-shu-zhuan-luo-b9kw/) 类似,现实中每一个「罗马数字」固定对应一个「阿拉伯数字」。
因此这是一个按照固定规则进行转换的「模拟」过程。
根据题意,我们可以列举出有限个罗马字符和其对应的数值。
然后从左到右匹配罗马数字,优先匹配数值高的罗马字符即可。
代码:
```Java
class Solution {
int[] val = new int[]{1000,900,500,400,1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.13` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/14. 最长公共前缀（简单）.md | 14. 最长公共前缀 | https://leetcode-cn.com/problems/longest-common-prefix/solution/shua-chuan-lc-die-dai-mo-ni-by-ac_oier-8t4q/ | 简单 | [
"模拟"
] | 编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀,返回空字符串 `""`。
示例 1:
```
输入:strs = ["flower","flow","flight"]
输出:"fl"
```
示例 2:
```
输入:strs = ["dog","racecar","car"]
输出:""
解释:输入不存在公共前缀。
```
提示:
* $0 <= strs.length <= 200$
* $0 <= strs[i].length <= 200$
* `strs[i]` 仅由小写英文字母组成 | ### 朴素解法
对每个字符串进行逐位检查,直到不满足公共前缀。
代码:
```Java
class Solution {
public String longestCommonPrefix(String[] ss) {
String ans = "";
if (ss.length == 0) return ans;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
String s = ss[0];
if (i >= s.length()) return ans;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.14` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/15. 三数之和（中等）.md | 15. 三数之和 | https://leetcode-cn.com/problems/3sum/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-cd8r/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给你一个包含 $n$ 个整数的数组 `nums`,判断 `nums` 中是否存在三个元素 `a`,`b`,`c` ,使得 `a + b + c = 0` ?
请你找出所有和为 $0$ 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
示例 1:
```
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
```
示例 2:
```
输入:nums = []
输出:[]
```
示例 3:
```
输入:nums = [0]
输出:[]
```
提示:
* $0 <= nums.length <= 3000$
* $-10^5 <= nums[i] <= 10^5... | ### 排序 + 双指针
对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。
1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] == 0` 的所有组合。
2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :
* `sum` > 0:`k` 左移,使 `sum` 变小
* `sum` < 0:`j` 右移,使 `sum` 变大
* `sum` = 0:找... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.15` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/16. 最接近的三数之和（中等）.md | 16. 最接近的三数之和 | https://leetcode-cn.com/problems/3sum-closest/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-p2ou/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给定一个包括 $n$ 个整数的数组 `nums` 和 一个目标值 `target`。
找出 `nums` 中的三个整数,使得它们的和与 `target` 最接近。
返回这三个数的和。
每组输入只存在唯一答案。
示例:
```
输入:nums = [-1,2,1,-4], target = 1
输出:2
解释:与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
```
提示:
* $3 <= nums.length <= 10^3$
* $-10^3 <= nums[i] <= 10^3$
* $-10^4 <= target <= 10^4$ | ### 排序 + 双指针
对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。
1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k]` 最接近 `target` 的唯一解。
2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :
* `sum` > `target`:`k` 左移,使 `sum` 变小
* `sum` < `target`:`j` 右移,使 `sum`... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.16` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/17. 电话号码的字母组合（中等）.md | 17. 电话号码的字母组合 | https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/solution/shua-chuan-lc-dfs-hui-su-jie-fa-by-ac_oi-qa02/ | 中等 | [
"DFS",
"回溯算法"
] | 给定一个仅包含数字 `2-9` 的字符串,返回所有它能表示的字母组合。
答案可以按「任意顺序」返回。
给出数字到字母的映射如下(与电话按键相同)。注意 $1$ 不对应任何字母。
示例 1:
```
输入:digits = "23"
输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]
```
示例 2:
```
输入:digits = ""
输出:[]
```
示例 3:
```
输入:digits = "2"
输出:["a","b","c"]
```
提示:
* $0 <= digits.length <= 4$
* $digits[i]$ 是范围 `['2','9']... | ### 回溯算法
对于字符串 `ds` 中的每一位数字,都有其对应的字母映射数组。
在 DFS 中决策每一位数字应该对应哪一个字母,当决策的位数 `i == n`,代表整个 `ds` 字符串都被决策完毕,将决策结果添加到结果集:
代码:
```Java
class Solution {
Map<String, String[]> map = new HashMap<>(){{
put("2", new String[]{"a", "b", "c"});
put("3", new String[]{"d", "e", "f"});
put("4", new String[]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.17` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/18. 四数之和（中等）.md | 18. 四数之和 | https://leetcode-cn.com/problems/4sum/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-dqx7/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给定一个包含 $n$ 个整数的数组 `nums` 和一个目标值 `t`,判断 `nums` 中是否存在四个元素 `a`,`b`,`c` 和 `d` ,使得 `a + b + c + d` 的值与 `t` 相等?
找出所有满足条件且不重复的四元组。
注意:答案中不可以包含重复的四元组。
示例 1:
```
输入:nums = [1,0,-1,0,-2,2], t = 0
输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
```
示例 2:
```
输入:nums = [], t = 0
输出:[]
```
提示:
* $0 <= nums.length <= 200$
* $-10^9 <= n... | ### 排序 + 双指针
对数组进行排序,使用四个指针 `i`、`j` 、`k` 和 `p` 分别代表要找的四个数。
1. 通过枚举 `i` 确定第一个数,枚举 `j` 确定第二个数,另外两个指针 `k` 和 `p` 分别从左边 `j + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] + nums[p] == t` 的所有组合。
2. `k` 和 `p` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k] + nums[p]` :
* `sum` > `t`:`p` 左移,使 `sum` 变小
* `s... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.18` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/19. 删除链表的倒数第 N 个结点（中等）.md | 19. 删除链表的倒数第 N 个结点 | https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/solution/shua-chuan-lc-lian-biao-kuai-man-zhi-zhe-1gs1/ | 中等 | [
"链表",
"快慢指针",
"双指针"
] | 给你一个链表,删除链表的倒数第 `n` 个结点,并且返回链表的头结点。
进阶:你能尝试使用一趟扫描实现吗?
示例 1:
```
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
```
示例 2:
```
输入:head = [1], n = 1
输出:[]
```
示例 3:
```
输入:head = [1,2], n = 1
输出:[1]
```
提示:
* 链表中结点的数目为 `sz`
* $1 <= sz <= 30$
* $0 <= Node.val <= 100$
* $1 <= n <= sz$ | ### 快慢指针
删除链表的倒数第 `n` 个结点,首先要确定倒数第 `n` 个节点的位置。
我们可以设定两个指针,分别为 `slow` 和 `fast`,刚开始都指向 head。
然后先让 `fast` 往前走 `n` 步,`slow` 指针不动,这时候两个指针的距离为 `n`。
再让 `slow` 和 `fast` 同时往前走(保持两者距离不变),直到 `fast` 指针到达结尾的位置。
这时候 `slow` 会停在待删除节点的前一个位置,让 `slow.next = slow.next.next` 即可。
但这里有一个需要注意的边界情况是:如果链表的长度是 `L`,而我们恰好要删除的是倒数第 `L` 个节点(删除头... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.19` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/11-20/20. 有效的括号（简单）.md | 20. 有效的括号 | https://leetcode-cn.com/problems/valid-parentheses/solution/shua-chuan-lc-zhan-ascii-chai-zhi-jie-fa-00zo/ | 简单 | [
"栈",
"有效括号"
] | 给定一个只包括 `'(',')','{','}','[',']'` 的字符串 `s` ,判断字符串是否有效。
有效字符串需满足:
1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
示例 1:
```
输入:s = "()"
输出:true
```
示例 2:
```
输入:s = "()[]{}"
输出:true
```
示例 3:
```
输入:s = "(]"
输出:false
```
示例 4:
```
输入:s = "([)]"
输出:false
```
示例 5:
```
输入:s = "{[]}"
输出:true
```
提示:
* $1 <= s.length <= 10... | ### 栈 + 哈希表
这是道模拟题,同一类型的括号,一个右括号要对应一个左括号。
不难发现可以直接使用 `栈` 来解决:
代码:
```Java
class Solution {
HashMap<Character, Character> map = new HashMap<Character, Character>(){{
put(']', '[');
put('}', '{');
put(')', '(');
}};
public boolean isValid(String s) {
Deque<Character> d = new... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.20` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1104. 二叉树寻路（中等）.md | 1104. 二叉树寻路 | https://leetcode-cn.com/problems/path-in-zigzag-labelled-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-rw2d/ | 中等 | [
"二叉树",
"模拟",
"数学"
] | 在一棵无限的二叉树上,每个节点都有两个子节点,树中的节点 逐行 依次按 “之” 字形进行标记。
如下图所示,在奇数行(即,第一行、第三行、第五行......)中,按从左到右的顺序进行标记;
而偶数行(即,第二行、第四行、第六行......)中,按从右到左的顺序进行标记。
给你树上某一个节点的标号 label,请你返回从根节点到该标号为 label 节点的路径,该路径是由途经的节点标号所组成的。
示例 1:
```
输入:label = 14
输出:[1,3,4,14]
```
示例 2:
```
输入:label = 26
输出:[1,2,6,10,26]
```
提示:
* 1 <= label <= $10^6$ | ### 模拟
一个朴素的做法是根据题意进行模拟。
利用从根节点到任意一层都是满二叉树,我们可以先确定 `label` 所在的层级 `level`,然后计算出当前层起始节点值(最小值)和结束节点值(最大值)。
再利用「每层节点数量翻倍」&「隔层奇偶性翻转」,寻址出上一层的节点下标(令每层下标均「从左往右」计算,并从 $1$ 开始),直到构造出答案(寻址到根节点)。
代码:
```Java
class Solution {
// 第 level 层的起始节点值
int getStart(int level) {
return (int)Math.pow(2, level - 1);
}
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1104` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1106. 解析布尔表达式（困难）.md | 1106. 解析布尔表达式 | https://leetcode.cn/problems/parsing-a-boolean-expression/solution/by-ac_oier-jr29/ | 困难 | [
"栈",
"表达式计算"
] | 给你一个以字符串形式表述的 布尔表达式 `(boolean) expression`,返回该式的运算结果。
有效的表达式需遵循以下约定:
* `"t"`,运算结果为 `True`
* `"f"`,运算结果为 `False`
* `"!(expr)"`,运算过程为对内部表达式 `expr` 进行逻辑 非的运算(`NOT`)
* `"&(expr1,expr2,...)"`,运算过程为对 `2` 个或以上内部表达式 `expr1, expr2, ...` 进行逻辑 与的运算(`AND`)
* `"|(expr1,expr2,...)"`,运算过程为对 `2` 个或以上内部表达式 `expr1, expr2, ...` 进行逻辑 或的... | ### 双栈
为了方便,我们令 `expression` 为 `s`。
我们可以将 `t` 和 `f` 看做操作数,而 `|`、`&` 和 `!` 看做操作符,创建两个栈 `nums` 和 `ops` 分别对其进行存储。
剩余的 `()` 和 `,` 则只是优先级和分隔符,无须额外关注。
从前往后处理 `s`,根据当前处理的字符为何值进行分情况讨论:
* `,`:分隔符,直接跳过;
* `t` 或 `f`:操作数,添加到 `nums` 栈中;
* `|`、`&` 或 `!`:操作符,添加到 `ops` 栈中;
* `(`:子表达式的左端点,为了在我们从「双栈」中取出数值和符号计算时,可以知道某个子表达式计算完成,需要记录一... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1106` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1108. IP 地址无效化（简单）.md | 1108. IP 地址无效化 | https://leetcode.cn/problems/defanging-an-ip-address/solution/by-ac_oier-cndi/ | 简单 | [
"模拟"
] | 给你一个有效的 `IPv4` 地址 `address`,返回这个 `IP` 地址的无效化版本。
所谓无效化 `IP` 地址,其实就是用 `"[.]"` 代替了每个 `"."`。
示例 1:
```
输入:address = "1.1.1.1"
输出:"1[.]1[.]1[.]1"
```
示例 2:
```
输入:address = "255.100.50.0"
输出:"255[.]100[.]50[.]0"
```
提示:
* 给出的 `address` 是一个有效的 `IPv4` 地址 | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public String defangIPaddr(String s) {
StringBuilder sb = new StringBuilder();
int n = s.length(), idx = -1;
while (++idx < n) {
char c = s.charAt(idx);
if (c == '.') sb.append('[');
sb.append(c);
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1108` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1101-1110/1109. 航班预订统计（中等）.md | 1109. 航班预订统计 | https://leetcode-cn.com/problems/corporate-flight-bookings/solution/gong-shui-san-xie-yi-ti-shuang-jie-chai-fm1ef/ | 中等 | [
"区间求和问题",
"差分",
"线段树"
] | 这里有 $n$ 个航班,它们分别从 $1$ 到 $n$ 进行编号。
有一份航班预订表 `bookings`,表中第 $i$ 条预订记录 $bookings[i] = [first_i, last_i, seats_i]$ 意味着在从 $first_i$ 到 $last_i$ (包含 $first_i$ 和 $last_i$ )的 每个航班 上预订了 $seats_i$ 个座位。
请你返回一个长度为 $n$ 的数组 `answer`,其中 $answer[i]$ 是航班 $i$ 上预订的座位总数。
示例 1:
```
输入:bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5
输出:[1... | ### 基本分析
本题只涉及「区间修改 + 单点查询」,属于「区间求和」问题中的入门难度。
对于各类「区间求和」问题,该用什么方式进行求解,之前在 [这里](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 提到过。
此处可以再总结一下(加粗字体为最佳方案):
* 数组不变,区间查询:**前缀和**、树状数组、线段树;
* 数组单点修改,区间查询:**树状数组**、线段树;
* 数组区间修改,单点查询:**差分**、线段树;
* 数组区间修改,区间查... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1109` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/113. 路径总和 II（中等）.md | 113. 路径总和 II | https://acoier.com/2022/12/10/113.%20%E8%B7%AF%E5%BE%84%E6%80%BB%E5%92%8C%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"DFS",
"二叉树"
] | 给你二叉树的根节点 `root` 和一个整数目标和 `targetSum`,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1:
```
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:[[5,4,11,2],[5,8,4,5]]
```
示例 2:
```
输入:root = [1,2,3], targetSum = 5
输出:[]
```
示例 3:
```
输入:root = [1,2], targetSum = 0
输出:[]
```
提示:
* 树中节点总数在范围 $... | ### 树的遍历 - DFS
定义 `DFS` 函数 `void dfs(TreeNode root, int cur, int t, List<Integer> path)` 。
其中 `root` 为当前遍历到的节点;`cur` 为当前路径总和;`t` 为目标总和;`path` 为当前路径方案。
剩下的为常规的树的遍历,当 `root` 为叶子节点(既没有左子树,也没有右子树)时,根据 `cur` 是否与 `t` 相等,决定是否要把 `path` 添加到答案中。
代码:
```Java
class Solution {
List<List<Integer>> ans = new ArrayList<>();
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.113` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/115. 不同的子序列（困难）.md | 115. 不同的子序列 | https://leetcode.cn/problems/distinct-subsequences/solution/xiang-jie-zi-fu-chuan-pi-pei-wen-ti-de-t-wdtk/ | 困难 | [
"线性 DP"
] | 给定一个字符串 `s` 和一个字符串 `t` ,计算在 `s` 的子序列中 `t` 出现的个数。
字符串的一个 子序列 是指,通过删除一些(也可以不删除)字符且不干扰剩余字符相对位置所组成的新字符串。(例如,`"ACE"` 是 `"ABCDE"` 的一个子序列,而 `"AEC"` 不是)
题目数据保证答案符合 `32` 位带符号整数范围。
示例 1:
```
输入:s = "rabbbit", t = "rabbit"
输出:3
解释:
如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
(上箭头符号 ^ 表示选取的字母)
rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
... | ### 基本思路
有两个字符串 `s` 和 `t`,长度数量级都为 $10^3$。
一个朴素的想法是,找出所有 `s` 的子序列,与 `t` 进行比较,找所有子序列的复杂度是 $O(2^n)$,肯定会超时。
因此,我们放弃这种朴素思路。
字符串匹配也不具有二段性质,不可能有 $log$ 级别的算法,那么复杂度再往下优化就是 $O(n * m)$ 的递推 DP 做法了。
***
### 动态规划
DP 的状态定义猜测通常是一门经验学科。
**但是,对于两个字符串匹配,一个非常通用的状态定义如下:**
**定义 $f[i][j]$ 为考虑 `s` 中 $[0,i]$ 个字符,`t` 中 $[0,j]$ 个字符的匹配个数... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.115` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/117. 填充每个节点的下一个右侧节点指针 II（中等）.md | 117. 填充每个节点的下一个右侧节点指针 II | https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/solutions/2510505/gong-shui-san-xie-xiang-xi-tu-jie-o1-kon-d6vg/ | 中等 | [
"BFS",
"链表"
] | 给定一个二叉树:
```
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
```
填充它的每个 `next` 指针,让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点,则将 `next` 指针设置为 `NULL`。
初始状态下,所有 `next` 指针都被设置为 `NULL`。
示例 1:
```
输入:root = [1,2,3,4,5,null,7]
输出:[1,#,2,3,#,4,5,7,#]
解释:给定二叉树如图 A 所示,你的函数应该填充它的每个 next 指针,以指向其下一个右侧节点,如图 B 所示。序列化输出... | ### BFS - 层序遍历
一个最直观的做法,是利用 `BFS` 对树进行「层序遍历」。
每个 `BFS` 回合中,对整层节点进行处理。
首先通过 `pop` 拿到当前节点,同时通过 `peek` 拿到当前层的下一节点,并建立 `next` 关系,注意需要跳过每层的最后一个节点。
Java 代码:
```Java
class Solution {
public Node connect(Node root) {
Node ans = root;
if (root == null) return ans;
Deque<Node> d = new ArrayDequ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.117` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/111-120/119. 杨辉三角 II（简单）.md | 119. 杨辉三角 II | https://leetcode-cn.com/problems/pascals-triangle-ii/solution/dong-tai-gui-hua-luo-ti-chang-jian-de-ko-n2xj/ | 简单 | [
"数学",
"线性 DP"
] | 给定一个非负索引 k,其中 k ≤ 33,返回杨辉三角的第 k 行。
在杨辉三角中,每个数是它左上方和右上方的数的和。
示例:
```
输入: 3
输出: [1,3,3,1]
```
进阶:
* 你可以优化你的算法到 O(k) 空间复杂度吗? | ### 动态规划
```java
class Solution {
public List<Integer> getRow(int idx) {
int[][] f = new int[idx + 1][idx + 1];
f[0][0] = 1;
for (int i = 1; i < idx + 1; i++) {
for (int j = 0; j < i + 1; j++) {
f[i][j] = f[i - 1][j];
if (j - 1 >= 0) f[i][j] += f[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.119` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1131-1140/1137. 第 N 个泰波那契数（简单）.md | 1137. 第 N 个泰波那契数 | https://leetcode-cn.com/problems/n-th-tribonacci-number/solution/gong-shui-san-xie-yi-ti-si-jie-die-dai-d-m1ie/ | 简单 | [
"动态规划",
"递归",
"递推",
"矩阵快速幂",
"打表"
] | 泰波那契序列 $T_{n}$ 定义如下:
$T_{0} = 0$, $T_{1} = 1$, $T_{2} = 1$, 且在 $n >= 0$ 的条件下 $T_{n+3} = T_{n} + T_{n+1} + T_{n+2}$
给你整数 $n$,请返回第 $n$ 个泰波那契数 $T_n$ 的值。
示例 1:
```
输入:n = 4
输出:4
解释:
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4
```
示例 2:
```
输入:n = 25
输出:1389537
```
提示:
* $0 <= n <= 37$
* 答案保证是一个 $32$ 位整数,即 $answer <= 2^... | ### 动态规划(迭代)
都直接给出状态转移方程了,其实就是道模拟题。
使用三个变量,从前往后算一遍即可。
Java 代码:
```Java
class Solution {
public int tribonacci(int n) {
if (n == 0) return 0;
if (n == 1 || n == 2) return 1;
int a = 0, b = 1, c = 1;
for (int i = 3; i <= n; i++) {
int d = a + b + c;
a = b; b ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1137` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1141-1150/1143. 最长公共子序列（中等）.md | 1143. 最长公共子序列 | https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/ | 中等 | [
"最长公共子序列",
"LCS",
"序列 DP"
] | 给定两个字符串 `s1` 和 `s2`,返回这两个字符串的最长公共子序列的长度。
如果不存在公共子序列,返回 $0$ 。
一个字符串的子序列是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。
* 例如,`"ace"` 是 `"abcde"` 的子序列,但 `"aec"` 不是 `"abcde"` 的子序列。
两个字符串的公共子序列是这两个字符串所共同拥有的子序列。
示例 1:
```
输入:s1 = "abcde", s2 = "ace"
输出:3
解释:最长公共子序列是 "ace" ,它的长度为 3 。
```
示例 2:
```
输入:s... | ### 动态规划(空格技巧)
这是一道「最长公共子序列(LCS)」的裸题。
对于这类题的都使用如下「状态定义」即可:
**$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度。**
当有了「状态定义」之后,基本上「转移方程」就是呼之欲出:
* `s1[i]==s2[j]` : $f[i][j]=f[i-1][j-1]+1$。代表**必然使用 $s1[i]$ 与 $s2[j]$ 时** LCS 的长度。
* `s1[i]!=s2[j]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表**必然不使用 $s1[i]$(但可能... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1143` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1151-1160/1154. 一年中的第几天（简单）.md | 1154. 一年中的第几天 | https://leetcode-cn.com/problems/day-of-the-year/solution/gong-shui-san-xie-jian-dan-qian-zhui-he-lwo2g/ | 简单 | [
"前缀和",
"模拟"
] | 给你一个字符串 `date`,按 `YYYY-MM-DD` 格式表示一个 现行公元纪年法 日期。
请你计算并返回该日期是当年的第几天。
通常情况下,我们认为 `1` 月 `1` 日是每年的第 `1` 天,`1` 月 `2` 日是每年的第 `2` 天,依此类推。每个月的天数与现行公元纪年法(格里高利历)一致。
示例 1:
```
输入:date = "2019-01-09"
输出:9
```
示例 2:
```
输入:date = "2019-02-10"
输出:41
```
示例 3:
```
输入:date = "2003-03-01"
输出:60
```
示例 4:
```
输入:date = "2004-03-01... | ### 模拟
根据题意进行模拟即可。
由于每年月份的天数都相对固定(仅有闰年 $2$ 月份不同),因此我们可以使用 `static` 进行打表预处理。
使用 `nums` 构建一个平年的月份数组,再通过「前缀和」得到平年的每个月的天数总和。
最后将 `date` 按照 `-` 分割为年月日,分别进行计数。
注意,当年份为闰年且当前月份超过了 $2$ 月份,要追加一天。
代码:
```Java
class Solution {
static int[] nums = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
static int[]... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1154` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1151-1160/1155. 掷骰子的N种方法（中等）.md | 1155. 掷骰子的N种方法 | https://leetcode-cn.com/problems/number-of-dice-rolls-with-target-sum/solution/dong-tai-gui-hua-bei-bao-wen-ti-yun-yong-axtf/ | 中等 | [
"背包问题",
"动态规划",
"分组背包"
] | 这里有 d 个一样的骰子,每个骰子上都有 f 个面,分别标号为 `1,2,...,f`。
我们约定:掷骰子的得到总点数为各骰子面朝上的数字的总和。
如果需要掷出的总点数为 target,请你计算出有多少种不同的组合情况(所有的组合情况总共有 $f^d$ 种),模 $10^9 + 7$ 后返回。
示例 1:
```
输入:d = 1, f = 6, target = 3
输出:1
```
示例 2:
```
输入:d = 2, f = 6, target = 7
输出:6
```
示例 3:
```
输入:d = 2, f = 5, target = 10
输出:1
```
示例 4:
```
输入:d = 1, f = ... | ### 分组背包
在 [分组背包问题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487504&idx=1&sn=9ac523ec0ac14c8634a229f8c3f919d7&chksm=fd9cbb0fcaeb32196b80a40e4408f6a7e2651167e0b9e31aa6d7c6109fbc2117340a59db12a1&token=1936267333&lang=zh_CN#rd) 中我们提到,分组背包不仅仅有「组内物品最多选择一个」的情况,还存在「组内物品必须选择一个」的情况。
对于本题,可以将每个骰子看作一个物品组,且每次 **... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1155` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1161-1170/1161. 最大层内元素和（中等）.md | 1161. 最大层内元素和 | https://leetcode.cn/problems/maximum-level-sum-of-a-binary-tree/solution/by-ac_oier-aemz/ | 中等 | [
"层序遍历",
"BFS"
] | 给你一个二叉树的根节点 `root`。设根节点位于二叉树的第 $1$ 层,而根节点的子节点位于第 $2$ 层,依此类推。
请返回层内元素之和 最大 的那几层(可能只有一层)的层号,并返回其中 最小 的那个。
示例 1:
```
输入:root = [1,7,0,7,-8,null,null]
输出:2
解释:
第 1 层各元素之和为 1,
第 2 层各元素之和为 7 + 0 = 7,
第 3 层各元素之和为 7 + -8 = -1,
所以我们返回第 2 层的层号,它的层内元素之和最大。
```
示例 2:
```
输入:root = [989,null,10250,98693,-89388,null,null,null,-... | ### 层序遍历
根据题意,使用 `BFS` 进行层序遍历即可。
每次以「层」为单位进行拓展,统计该层的元素和,维护处理过程中的最大值层数和,以及层深度。
Java 代码:
```Java
class Solution {
public int maxLevelSum(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
int max = -0x3f3f3f3f, depth = 1, ans = 0;
d.addLast(root);
while (!d.isEmpty()) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1161` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1161-1170/1162. 地图分析（中等）.md | 1162. 地图分析 | https://leetcode-cn.com/problems/as-far-from-land-as-possible/solution/gong-shui-san-xie-ru-he-shi-yong-duo-yua-vlea/ | 中等 | [
"图论 BFS",
"多源 BFS"
] | 你现在手里有一份大小为 $N \times N$ 的 网格 $grid$,上面的每个 单元格 都用 $0$ 和 $1$ 标记好了。
其中 $0$ 代表海洋,$1$ 代表陆地,请你找出一个海洋单元格,这个海洋单元格到离它最近的陆地单元格的距离是最大的。
我们这里说的距离是「曼哈顿距离」:$(x_0, y_0)$ 和 $(x_1, y_1)$ 这两个单元格之间的距离是 $|x_0 - x_1| + |y_0 - y_1|$。
如果网格上只有陆地或者海洋,请返回 $-1$。
示例 1:
```
输入:[[1,0,1],[0,0,0],[1,0,1]]
输出:2
解释:海洋单元格 (1, 1) 和所有陆地单元格之间的距离都达到... | ### 单源 BFS
通常我们使用 BFS 求最短路,都是针对如下场景:从特定的起点出发,求解到达特定终点的最短距离。
**这是一类特殊的「单源最短路」问题:本质是在一个边权为 $1$ 的图上,求从特定「源点」出发到达特定「汇点」的最短路径。**
对于本题,如果套用「单源最短路」做法,我们需要对每个「海洋」位置做一次 BFS:求得每个「海洋」的最近陆地距离,然后在所有的距离中取 $max$ 作为答案。
单次 BFS 的最坏情况需要扫描完整个矩阵,复杂度为 $O(n^2)$。
同时,最多有 $n^2$ 个海洋区域需要做 BFS,因此这样的做法复杂度为 $O(n^4)$,并且 $O(n^4)$ 可直接取满。
PS. 数据范围... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1162` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1171-1180/1175. 质数排列（简单）.md | 1175. 质数排列 | https://leetcode.cn/problems/prime-arrangements/solution/by-ac_oier-t3lk/ | 简单 | [
"数学",
"组合数",
"二分",
"打表"
] | 请你帮忙给从 $1$ 到 $n$ 的数设计排列方案,使得所有的「质数」都应该被放在「质数索引」(索引从 $1$ 开始)上;你需要返回可能的方案总数。
让我们一起来回顾一下「质数」:质数一定是大于 $1$ 的,并且不能用两个小于它的正整数的乘积来表示。
由于答案可能会很大,所以请你返回答案 模 `mod` $10^9 + 7$ 之后的结果即可。
示例 1:
```
输入:n = 5
输出:12
解释:举个例子,[1,2,5,4,3] 是一个有效的排列,但 [5,2,3,4,1] 不是,因为在第二种情况里质数 5 被错误地放在索引为 1 的位置上。
```
示例 2:
```
输入:n = 100
输出:682289015
`... | ### 打表 + 二分 + 数学
根据题意,可将问题转换为求 $n$ 以内的质数个数,记为 $a$,同时可得非质数个数为 $b = n - a$。
质数的放置方案数为 $a!$,而非质数的放置方案数为 $b!$,根据「乘法原理」总的放置方案数为 $a! \times b!$。
我们可以通过「打表」的方式将 $100$ 以内的质数预处理到数组 `list` 中,对于每个 $n$ 而言,我们找到第一个满足「值小于等于 $n$」的位置,从而得知 $n$ 范围以内的质数个数。
代码:
```Java
class Solution {
static int MOD = (int)1e9+7;
static List<I... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1175` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1171-1180/1178. 猜字谜（困难）.md | 1178. 猜字谜 | https://leetcode-cn.com/problems/number-of-valid-words-for-each-puzzle/solution/xiang-jin-zhu-shi-xiang-jie-po-su-wei-yu-3cr2/ | 困难 | [
"状态压缩",
"位运算",
"哈希表"
] | 外国友人仿照中国字谜设计了一个英文版猜字谜小游戏,请你来猜猜看吧。
字谜的迷面 puzzle 按字符串形式给出,如果一个单词 word 符合下面两个条件,那么它就可以算作谜底:
* 单词 word 中包含谜面 puzzle 的第一个字母。
* 单词 word 中的每一个字母都可以在谜面 puzzle 中找到。
例如,如果字谜的谜面是 "abcdefg",那么可以作为谜底的单词有 "faced", "cabbage", 和 "baggage";而 "beefed"(不含字母 "a")以及 "based"(其中的 "s" 没有出现在谜面中)都不能作为谜底。
返回一个答案数组 answer,数组中的每个元素 answer[i] 是... | ### 朴素位运算解法(TLE)
根据「谜底」和「谜面」的对应条件:
* 单词 `word` 中包含谜面 `puzzle` 的第一个字母。
* 单词 `word` 中的每一个字母都可以在谜面 `puzzle` 中找到
`puzzle` 本身长度只有 7 位,而且不重复;我们可以发现对应条件与 `word` 的重复字母无关。
因此我们可以使用「二进制」数来表示每一个 `word` 和 `puzzle`:
一个长度为 26 的二进制数来表示(直接使用长度为 32 的 int 即可,使用低 26 位),假如有 `str = "abz"` 则对应了 `100...011`(共 26 位,从右往左是 a - z)。
至此我们可以已经... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1178` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1184. 公交站间的距离（简单）.md | 1184. 公交站间的距离 | https://leetcode.cn/problems/distance-between-bus-stops/solution/by-ac_oier-fow3/ | 简单 | [
"模拟"
] | 环形公交路线上有 $n$ 个站,按次序从 $0$ 到 $n - 1$ 进行编号。我们已知每一对相邻公交站之间的距离,$distance[i]$ 表示编号为 $i$ 的车站和编号为 `(i + 1) % n` 的车站之间的距离。
环线上的公交车都可以按顺时针和逆时针的方向行驶。
返回乘客从出发点 `start` 到目的地 `destination` 之间的最短距离。
示例 1:
```
输入:distance = [1,2,3,4], start = 0, destination = 1
输出:1
解释:公交站 0 和 1 之间的距离是 1 或 9,最小值是 1。
```
示例 2:
```
输入:distance = ... | ### 模拟
根据题意进行模拟即可。
用 `i` 和 `j` 分别代表往前和往后走的指针,`a` 和 `b` 分别统计两种走法的总成本。
Java 代码:
```Java
class Solution {
public int distanceBetweenBusStops(int[] dist, int s, int t) {
int n = dist.length, i = s, j = s, a = 0, b = 0;
while (i != t) {
a += dist[i];
if (++i == n) i = 0;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1184` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1185. 一周中的第几天（简单）.md | 1185. 一周中的第几天 | https://leetcode-cn.com/problems/day-of-the-week/solution/gong-shui-san-xie-jian-dan-ri-qi-tong-ji-czt6/ | 简单 | [
"模拟"
] | 给你一个日期,请你设计一个算法来判断它是对应一周中的哪一天。
输入为三个整数:`day`、`month` 和 `year`,分别表示日、月、年。
您返回的结果必须是这几个值中的一个 `{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}`。
示例 1:
```
输入:day = 31, month = 8, year = 2019
输出:"Saturday"
```
示例 2:
```
输入:day = 18, month = 7, year = 1999
输出:"Sunday"
```
示例 3:
```
输入:day... | ### 模拟
题目保证日期是在 `1971` 到 `2100` 之间,我们可以计算给定日期距离 `1970` 的最后一天(星期四)间隔了多少天,从而得知给定日期是周几。
具体的,可以先通过循环处理计算年份在 $[1971, year - 1]$ 时间段,经过了多少天(注意平年为 $365$,闰年为 $366$);然后再处理当前年 $year$ 的月份在 $[1, month - 1]$ 时间段 ,经过了多少天(注意当天年是否为闰年,特殊处理 $2$ 月份),最后计算当前月 $month$ 经过了多少天,即再增加 $day$ 天。
得到距离 `1970` 的最后一天(星期四)的天数后进行取模,即可映射回答案。
代码:
```J... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1185` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1189. “气球” 的最大数量（简单）.md | 1189. “气球” 的最大数量 | https://leetcode-cn.com/problems/maximum-number-of-balloons/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-9px4/ | 简单 | [
"模拟"
] | 给你一个字符串 `text`,你需要使用 `text` 中的字母来拼凑尽可能多的单词 `"balloon"`(气球)。
字符串 `text` 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 `"balloon"`。
示例 1:
```
输入:text = "nlaebolko"
输出:1
```
示例 2:
```
输入:text = "loonbalxballpoon"
输出:2
```
示例 3:
```
输入:text = "leetcode"
输出:0
```
提示:
* $1 <= text.length <= 10^4$
* `text` 全部由小写英文字母组成 | ### 模拟
根据题意模拟即可。
先统计 `text` 中与单词 $balloon$ 相关的字符数量,由于一个单词需要消耗两个 `l` 和 `o` 字符,对其统计数量进行除 $2$ 下取整,然后所有字符的最小出现次数即是能够凑成 $balloon$ 的最大数量。
代码:
```Java
class Solution {
public int maxNumberOfBalloons(String text) {
int[] cnts = new int[5];
for (int i = 0; i < text.length(); i++) {
char c = te... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1189` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1181-1190/1190. 反转每对括号间的子串（中等）.md | 1190. 反转每对括号间的子串 | https://leetcode-cn.com/problems/reverse-substrings-between-each-pair-of-parentheses/solution/gong-shui-san-xie-shi-yong-shuang-duan-d-r35q/ | 中等 | [
"双端队列",
"栈"
] | 给出一个字符串 `s`(仅含有小写英文字母和括号)。
请你按照从括号内到外的顺序,逐层反转每对匹配括号中的字符串,并返回最终的结果。
注意,您的结果中 不应 包含任何括号。
示例 1:
```
输入:s = "(abcd)"
输出:"dcba"
```
示例 2:
```
输入:s = "(u(love)i)"
输出:"iloveu"
```
示例 3:
```
输入:s = "(ed(et(oc))el)"
输出:"leetcode"
```
示例 4:
```
输入:s = "a(bcdefghijkl(mno)p)q"
输出:"apmnolkjihgfedcbq"
```
提示:
* $0 <= s.lengt... | ### 双端队列
根据题意,我们可以设计如下处理流程:
* 从前往后遍历字符串,将不是 `)` 的字符串从「尾部」放入队列中
* 当遇到 `)` 时,从队列「尾部」取出字符串,直到遇到 `(` 为止,并对取出字符串进行翻转
* 将翻转完成后字符串重新从「尾部」放入队列
* 循环上述过程,直到原字符串全部出来完成
* 从队列「头部」开始取字符,得到最终的答案
可以发现,上述过程需要用到双端队列(或者栈,使用栈的话,需要在最后一步对取出字符串再进行一次翻转)。
在 `Java` 中,双端队列可以使用自带的 `ArrayDeque`, 也可以直接使用数组进行模拟。
代码(使用 `ArrayDeque` ):
```Java
cl... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1190` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1201-1210/1206. 设计跳表（困难）.md | 1206. 设计跳表 | https://leetcode.cn/problems/design-skiplist/solution/by-ac_oier-38rd/ | 困难 | [
"链表",
"数据结构"
] | 不使用任何库函数,设计一个 跳表 。
跳表 是在 $O(log{n})$ 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树,其功能与性能相当,并且跳表的代码长度相较下更短,其设计思想与链表相似。
例如,一个跳表包含 `[30, 40, 50, 60, 70, 90]`,然后增加 `80`、`45` 到跳表中,以下图的方式操作:
跳表中有很多层,每一层是一个短的链表。在第一层的作用下,增加、删除和搜索操作的时间复杂度不超过 $O(n)$。跳表的每一个操作的平均时间复杂度是 $O(\log{n})$,空间复杂度是 $O(n)$。
在本题中,你的设计应该要包含这些函数:
* `bool search(int ta... | ### 数据结构
对于单链表而言,所有的操作(增删改查)都遵循「先查找,再操作」的步骤,这导致在单链表上所有操作复杂度均为 $O(n)$(瓶颈在于查找过程)。
跳表相对于单链表,则是通过引入「多层」链表来优化查找过程,其中每层链表均是「有序」链表:
* 对于单链表的 `Node` 设计而言,我们只需存储对应的节点值 `val`,以及当前节点的下一节点的指针 `ne` 即可(`ne` 为一指针变量)
* 对于跳表来说,除了存储对应的节点值 `val` 以外,我们需要存储当前节点在「每一层」的下一节点指针 `ne`(`ne` 为指针数组)
跳表的 `level` 编号从下往上递增,最下层的链表为元素最全的有序单链表,而查找过程... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1206` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1201-1210/1208. 尽可能使字符串相等（中等）.md | 1208. 尽可能使字符串相等 | https://leetcode-cn.com/problems/get-equal-substrings-within-budget/solution/ni-bu-ke-neng-kan-bu-dong-de-qian-zhui-h-u4l1/ | 中等 | [
"前缀和",
"二分",
"滑动窗口"
] | 给你两个长度相同的字符串,s 和 t。
将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销(开销可能为 0),也就是两个字符的 ASCII 码值的差的绝对值。
用于变更字符串的最大预算是 maxCost。在转化字符串时,总开销应当小于等于该预算,这也意味着字符串的转化可能是不完全的。
如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串,则返回可以转化的最大长度。
如果 s 中没有子字符串可以转化成 t 中对应的子字符串,则返回 0。
示例 1:
```
输入:s = "abcd", t = "bcdf", maxCost = 3
输出:3
解释:s 中的 "a... | ### 前缀和 + 二分 + 滑动窗口
给定了长度相同的 `s` 和 `t`,那么对于每一位而言,修改的成本都是相互独立而确定的。
我们可以先预处理出修改成本的前缀和数组 `sum`。
当有了前缀和数组之后,对于任意区间 `[i,j]` 的修改成本,便可以通过 `sum[j] - sum[i - 1]` 得出。
那么接下来我们只需要找出成本不超过 `maxCost` 的最大长度区间,这个长度区间其实就是滑动窗口长度,滑动窗口长度的范围为 `[1, n]` (n 为字符串的长度)。
通过枚举来找答案可以吗?
我们可以通过数据范围大概分析一下哈,共有 `n` 个滑动窗口长度要枚举,复杂度为 $O(n)$,对于每个滑动窗口长度... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1208` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1201-1210/1210. 穿过迷宫的最少移动次数（困难）.md | 1210. 穿过迷宫的最少移动次数 | null | 困难 | [
"BFS"
] | 你还记得那条风靡全球的贪吃蛇吗?
我们在一个 `n*n` 的网格上构建了新的迷宫地图,蛇的长度为 `2`,也就是说它会占去两个单元格。蛇会从左上角(`(0, 0)` 和 `(0, 1)`)开始移动。我们用 `0` 表示空单元格,用 `1` 表示障碍物。
蛇需要移动到迷宫的右下角(`(n-1, n-2)` 和 `(n-1, n-1)`)。
每次移动,蛇可以这样走:
* 如果没有障碍,则向右移动一个单元格。并仍然保持身体的水平/竖直状态。
* 如果没有障碍,则向下移动一个单元格。并仍然保持身体的水平/竖直状态。
* 如果它处于水平状态并且其下面的两个单元都是空的,就顺时针旋转 `90` 度。蛇从(`(r, c)`、`(r, c+... | ### BFS
题目要我们求从特定起点到特定终点的最少步数,由于我们蛇的长度固定为 $2$,因此我们可用三元组 $(x, y, cd)$ 来代表蛇的实际位置。其中 $(x, y)$ 代表蛇尾位置,$cd$ 代表当前蛇的方向状态,$0$ 代表水平状态,$1$ 代表竖直状态。
蛇尾加上方向状态可确定其蛇头位置 :`tx = cd == 0 ? nx : nx + 1`、`ty = cd == 0 ? ny + 1 : ny`。
对四种移动规则所导致三元组变化进行分情况讨论:
1. 往右移动:对于蛇尾而言,只有维度 $y$ 进行加一,其余维度不变。三元组变化总结为 $(0, 1, 0)$
2. 往下移动:对于蛇尾而言,只有维度 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1210` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/121-130/124. 二叉树中的最大路径和（困难）.md | 124. 二叉树中的最大路径和 | https://leetcode.cn/problems/binary-tree-maximum-path-sum/solutions/2451624/gong-shui-san-xie-jian-dan-di-gui-shu-xi-nlci/ | 困难 | [
"递归",
"二叉树",
"DFS",
"树形 DP",
"动态规划"
] | 二叉树中的 路径 被定义为一条节点序列,序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点,且不一定经过根节点。
路径和 是路径中各节点值的总和。
给你一个二叉树的根节点 `root`,返回其 最大路径和 。
示例 1:
```
输入:root = [1,2,3]
输出:6
解释:最优路径是 2 -> 1 -> 3 ,路径和为 2 + 1 + 3 = 6
```
示例 2:
```
输入:root = [-10,9,20,null,null,15,7]
输出:42
解释:最优路径是 15 -> 20 -> 7 ,路径和为 15 + 20 + 7 = 42
``... | ### 递归
一个简单的做法是直接递归来做:设计 `DFS` 函数,传入当前节点 `cur`,返回以该节点“往下”延伸所能取得的最大路径和。
即在 **仅使用当前节点**、**使用当前节点和左子树路径** 和 **使用当前节点和右子树路径** 三者中取最大值进行返回。
同时在 `DFS` 过程中,我们计算「以当前节点 `cur` 为路径最高点」时的最大路径和,并用此来更新全局变量 `ans`。
具体的,在以节点 `cur` 为路径最高点时的最大路径和,首先包含当前节点本身(`cur.val`),以及可选的左右节点路径和(`dfs(cur.left)` 和 `dfs(cur.right)`)。当左右节点路径和不为负数时,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.124` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/121-130/127. 单词接龙（困难）.md | 127. 单词接龙 | https://leetcode-cn.com/problems/word-ladder/solution/gong-shui-san-xie-ru-he-shi-yong-shuang-magjd/ | 困难 | [
"双向 BFS",
"启发式搜索",
"AStar 算法"
] | 字典 `wordList` 中从单词 `beginWord `和 `endWord` 的 转换序列 是一个按下述规格形成的序列:
* 序列中第一个单词是 `beginWord` 。
* 序列中最后一个单词是 `endWord` 。
* 每次转换只能改变一个字母。
* 转换过程中的中间单词必须是字典 `wordList` 中的单词。
给你两个单词 `beginWord `和 `endWord `和一个字典 `wordList `,找到从 `beginWord `到 `endWord `的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列,返回 $0$。
示例 1:
```
输入:beginWord = "hit", en... | ### 基本分析
根据题意,每次只能替换一个字符,且每次产生的新单词必须在 `wordList` 出现过。
一个朴素的实现方法是,使用 BFS 的方式求解。
从 `beginWord` 出发,枚举所有替换一个字符的方案,如果方案存在于 `wordList` 中,则加入队列中,这样队列中就存在所有替换次数为 $1$ 的单词。然后从队列中取出元素,继续这个过程,直到遇到 `endWord` 或者队列为空为止。
同时为了「防止重复枚举到某个中间结果」和「记录每个中间结果是经过多少次转换而来」,我们需要建立一个「哈希表」进行记录。
哈希表的 KV 形式为 `{ 单词 : 由多少次转换得到 }`。
当枚举到新单词 `str` 时,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.127` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1217. 玩筹码（简单）.md | 1217. 玩筹码 | https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position/solution/by-ac_oier-j6js/ | 简单 | [
"贪心",
"枚举"
] | 有 `n` 个筹码。第 $i$ 个筹码的位置是 `position[i]`。
我们需要把所有筹码移到同一个位置。在一步中,我们可以将第 $i$ 个筹码的位置从 $position[i]$ 改变为:
* `position[i] + 2 或 position[i] - 2`,此时 `cost = 0`
* `position[i] + 1 或 position[i] - 1`,此时 `cost = 1`
返回将所有筹码移动到同一位置上所需要的 最小代价 。
示例 1:
```
输入:position = [1,2,3]
输出:1
解释:第一步:将位置3的筹码移动到位置1,成本为0。
第二步:将位置2的筹码移动到位置1,成... | ### 贪心 + 枚举目标位置
假设移动的目标位置是 $a$,当前所在位置是 $b$,将小球从 $b$ 移动到 $a$ 的成本取决于两位置距离的「奇偶性」,距离为偶数时成本固定为 $0$,距离为奇数时成本固定为 $1$。
同时我们可以通过「分情况讨论」来证明,所有小球移动到一个全新位置(起始没有小球的位置),结果不会变好,假设所选择的最终(全新)位置为 $t$:
* 假设选择的位置 $t$ 导致所有数到位置 $t$ 距离均为偶数,此时总成本为 $0$,同时可知所有数的位置奇偶性相同,此时选择所有数中的任意一个的位置,同样可得总成本为 $0$ 的结果,因此选全新的位置不会让结果变好;
* 假设选择的位置 $t$ 导致所有数到位置... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1217` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1218. 最长定差子序列（中等）.md | 1218. 最长定差子序列 | https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-difference/solution/gong-shui-san-xie-jie-he-tan-xin-de-zhua-dj1k/ | 中等 | [
"贪心",
"序列 DP",
"状态机 DP",
"哈希表"
] | 给你一个整数数组 `arr` 和一个整数 `difference`,请你找出并返回 `arr` 中最长等差子序列的长度,该子序列中相邻元素之间的差等于 `difference` 。
子序列 是指在不改变其余元素顺序的情况下,通过删除一些元素或不删除任何元素而从 `arr` 派生出来的序列。
示例 1:
```
输入:arr = [1,2,3,4], difference = 1
输出:4
解释:最长的等差子序列是 [1,2,3,4]。
```
示例 2:
```
输入:arr = [1,3,5,7], difference = 1
输出:1
解释:最长的等差子序列是任意单个元素。
```
示例 3:
```
输入:arr... | ### 状态机序列 DP + 哈希表
**定义 $f[i][j]$($j$ 非 $0$ 即 $1$) 为代表考虑前 $i$ 个数,且第 $i$ 个数的选择情况为 $j$ 时,得到的最长定差子序列长度。**
最终答案为 $\max(f[n - 1][0], f[n - 1][1])$,同时我们有显然的初始化条件 $f[0][0] = 0$ 和 $f[0][1] = 1$。
不失一般性考虑 $f[i][j]$ 如何转移:
* $f[i][0]$:明确了第 $i$ 个不选,那么此时最大长度为前一个位置的结果。即有:
$$
f[i][0] = \max(f[i - 1][0], f[i - 1][1])
$$
* $f[i][1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1218` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1219. 黄金矿工（中等）.md | 1219. 黄金矿工 | https://leetcode-cn.com/problems/path-with-maximum-gold/solution/gong-shui-san-xie-hui-su-suan-fa-yun-yon-scxo/ | 中等 | [
"图论搜索",
"DFS",
"回溯算法"
] | 你要开发一座金矿,地质勘测学家已经探明了这座金矿中的资源分布,并用大小为 `m * n` 的网格 $grid$ 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量;如果该单元格是空的,那么就是 $0$。
为了使收益最大化,矿工需要按以下规则来开采黄金:
* 每当矿工进入一个单元,就会收集该单元格中的所有黄金。
* 矿工每次可以从当前位置向上下左右四个方向走。
* 每个单元格只能被开采(进入)一次。
* 不得开采(进入)黄金数目为 $0$ 的单元格。
* 矿工可以从网格中 **任意一个** 有黄金的单元格出发或者是停止。
示例 1:
```
输入:grid = [[0,6,0],[5,8,7],[0,9,0]]
输出:... | ### 回溯算法
根据题意,我们可以枚举每个黄金点作为起点,然后使用 `DFS` 回溯搜索以该点作为起点所能得到的最大收益。
代码:
```Java
class Solution {
int[][] g;
boolean[][] vis;
int m, n;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
public int getMaximumGold(int[][] grid) {
g = grid;
m = g.length; n = g[0].length;
vis = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1219` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1211-1220/1220. 统计元音字母序列的数目（困难）.md | 1220. 统计元音字母序列的数目 | https://leetcode-cn.com/problems/count-vowels-permutation/solution/gong-shui-san-xie-yi-ti-shuang-jie-xian-n8f4o/ | 困难 | [
"线性 DP",
"矩阵快速幂"
] | 给你一个整数 `n`,请你帮忙统计一下我们可以按下述规则形成多少个长度为 `n` 的字符串:
字符串中的每个字符都应当是小写元音字母('a', 'e', 'i', 'o', 'u')
* 每个元音 `'a'` 后面都只能跟着 `'e'`
* 每个元音 `'e'` 后面只能跟着 `'a'` 或者是 `'i'`
* 每个元音 `'i'` 后面 不能 再跟着另一个 `'i'`
* 每个元音 `'o'` 后面只能跟着 `'i'` 或者是 `'u'`
* 每个元音 `'u'` 后面只能跟着 `'a'`
由于答案可能会很大,所以请你返回 模 $10^9 + 7$ 之后的结果。
示例 1:
```
输入:n = 1
输出:5
解释:所有... | ### 线性 DP
**定义 $f[i][j]$ 为考虑长度为 $i + 1$ 的字符串,且结尾元素为 $j$ 的方案数(其中 $j$ 代表数组 `['a', 'e', 'i', 'o', 'u']` 下标)。**
不失一般性考虑 $f[i][j]$ 该如何计算。
**我们可以从题意给定的规则进行出发,从 $f[i]$ 出发往前更新 $f[i + 1]$,也可以直接利用对称性进行反向分析。**
为了方便大家理解,还是将常规的「从 $f[i]$ 出发往前更新 $f[i + 1]$」作为主要分析方法吧。
根据条件可以容易写出转移方程:
* 每个元音 `'a'` 后面都只能跟着 `'e'` :$f[i + 1][1] += f... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1220` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1129. 颜色交替的最短路径（中等）.md | 1129. 颜色交替的最短路径 | null | 中等 | [
"BFS",
"最短路"
] | 在一个有向图中,节点分别标记为 `0, 1, ..., n-1`。
图中每条边为红色或者蓝色,且存在自环或平行边。
`red_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的红色有向边。
类似地,`blue_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的蓝色有向边。
返回长度为 `n` 的数组 `answer`,其中 `answer[X]` 是从节点 `0` 到节点 `X` 的红色边和蓝色边交替出现的最短路径的长度。
如果不存在这样的路径,那么 `answer[x] = -1`。
示例 1:
```
输入:n = 3, red_edges = [[... | ### 朴素 BFS
为了方便,将 `redEdges` 记为 `rs`,将 `blueEdges` 记为 `bs`。
使用两数组进行建图,利用点数和边数关系(稀疏图),使用「邻接表」方式进行建图。
将所有红色有向边权值记为 `1`,将所有蓝色有向边权值记为 `-1`。注意这里的权重仅表示该边的颜色,并非代表经过该边的真实成本。
也正是经过所有边的成本均相同,对于原问题「从 `0` 号节点进行出发,求到所有点的颜色交替的最短路径」,我们容易想到使用 `BFS` 进行求解。
`BFS` 过程中将三元组 $(point, last, step)$ 进行入队:
* `point` 代表当前所在点编号
* `last` 代表... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1129` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1221. 分割平衡字符串（简单）.md | 1221. 分割平衡字符串 | https://leetcode-cn.com/problems/split-a-string-in-balanced-strings/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-wumnk/ | 简单 | [
"贪心",
"双指针"
] | 在一个 平衡字符串 中,'L' 和 'R' 字符的数量是相同的。
给你一个平衡字符串 s,请你将它分割成尽可能多的平衡字符串。
注意:分割得到的每个字符串都必须是平衡字符串。
返回可以通过分割得到的平衡字符串的 最大数量 。
示例 1:
```
输入:s = "RLRRLLRLRL"
输出:4
解释:s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
```
示例 2:
```
输入:s = "RLLLLRRRLR"
输出:3
解释:s 可以分割为 "RL"、"LLLRRR"、"LR" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。
```
... | ### 基本分析
题目确保了 `s` 为一个平衡字符串,即必然能分割成若干个 `LR` 子串。
一个合法的 `LR` 子串满足 `L` 字符和 `R` 字符数量相等,常规检查一个字符串是否为合格的 `LR` 子串可以使用 $O(n)$ 的遍历方式,可以使用记录前缀信息的数据结构,而对于成对结构的元素统计,更好的方式是转换为数学判定,使用 `1` 来代指 `L` 得分,使用 `-1` 来代指 `R` 得分。
那么一个子串为合格 `LR` 子串的充要条件为 **整个 `LR` 子串的总得分为 $0$**。
这种方式最早应该在 [(题解) 301. 删除无效的括号](https://leetcode-cn.com/problems... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1221` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1222. 可以攻击国王的皇后（中等）.md | 1222. 可以攻击国王的皇后 | https://leetcode.cn/problems/queens-that-can-attack-the-king/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-hlgkx/ | 中等 | [
"模拟",
"BFS"
] | 在一个 `8x8` 的棋盘上,放置着若干「黑皇后」和一个「白国王」。
给定一个由整数坐标组成的数组 `queens`,表示黑皇后的位置;以及一对坐标 `king`,表示白国王的位置,返回所有可以攻击国王的皇后的坐标(任意顺序)。
示例 1:
```
输入:queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]
输出:[[0,1],[1,0],[3,3]]
解释:
[0,1] 的皇后可以攻击到国王,因为他们在同一行上。
[1,0] 的皇后可以攻击到国王,因为他们在同一列上。
[3,3] 的皇后可以攻击到国王,因为他们在同一条对角线上。
[0,4] 的皇... | ### 模拟
创建一个二维数组 `dirs` 来表示八个方向的坐标偏移,同时使用变量 `step` 来表示从国王位置出发的步数。
在每个方向 `i` 上,通过 `step` 步可以到达的坐标为 $(x + dirs[i][0] \times step, y + dirs[i][1] \times step)$。
模拟过程中,我们可使用布尔数组 `checked` 来记录已处理的方向,当我们遇到皇后或越过棋盘时,可标记该方向已处理。
Java 代码:
```Java
class Solution {
int[][] dirs = new int[][]{{1,0},{0,1},{0,-1},{-1,0},{1,1},... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1222` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1224. 最大相等频率（困难）.md | 1224. 最大相等频率 | https://leetcode.cn/problems/maximum-equal-frequency/solution/by-ac_oier-fviv/ | 困难 | [
"模拟",
"哈希表",
"计数"
] | 给你一个正整数数组 `nums`,请你帮忙从该数组中找出能满足下面要求的最长前缀,并返回该前缀的长度:
* 从前缀中 恰好删除一个 元素后,剩下每个数字的出现次数都相同。
如果删除这个元素后没有剩余元素存在,仍可认为每个数字都具有相同的出现次数(也就是 $0$ 次)。
示例 1:
```
输入:nums = [2,2,1,1,5,3,3,5]
输出:7
解释:对于长度为 7 的子数组 [2,2,1,1,5,3,3],如果我们从中删去 nums[4] = 5,就可以得到 [2,2,1,1,3,3],里面每个数字都出现了两次。
```
示例 2:
```
输入:nums = [1,1,1,2,2,2,3,3,3,4,4,4,5... | ### 模拟(计数 + 分情况讨论)
我们使用 `cnt` 数组记录每个数的出现次数(即 `cnt[i] = x` 含义为数值 $i$ 的出现次数为 $x$ 次),以及使用 `sum` 来记录出现次数为某个值的数有多少个(即 `sum[i] = x` 含义为出现次数为 $i$ 的数值共有 $x$ 个),同时使用 `max` 来记录最大出现次数 $cnt[i]$。
从前往后处理 `nums`,假设当前处理到的数值为 $t = nums[i]$(前缀所含数量为 $len = i + 1$)有如下几种情况,我们可以更新最大长度 `ans`:
* $max = 1$:说明当前处理到的所有 $nums[i]$ 均只出现了一次,此时任意删... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1224` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1221-1230/1233. 删除子文件夹（中等）.md | 1233. 删除子文件夹 | null | 中等 | [
"字典树"
] | 你是一位系统管理员,手里有一份文件夹列表 `folder`,你的任务是要删除该列表中的所有 子文件夹,并以 任意顺序 返回剩下的文件夹。
如果文件夹 `folder[i]` 位于另一个文件夹 `folder[j]` 下,那么 `folder[i]` 就是 `folder[j]` 的 子文件夹 。
文件夹的「路径」是由一个或多个按以下格式串联形成的字符串:`'/'` 后跟一个或者多个小写英文字母。
例如,`"/leetcode"` 和 `"/leetcode/problems"` 都是有效的路径,而空字符串和 "/" 不是。
示例 1:
```
输入:folder = ["/a","/a/b","/c/d","/c/d/e",... | ### 字典树
一道字典树裸题,不熟悉字典树的同学可以看前置 🧀 : [【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)。
定义类 `Trie` 代表字典树节点,对应物理含义为某个文件夹。该节点含有属性 `s`、`isEnd` 和 `stries`,分别代表「当前节点所代表文件夹名」、「是否为当前路径的最终文件夹」以及「当前文件夹下的子文件夹集合」。
并且由于每个文件夹名的长度不定,我们使用 `Map<String,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1223` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1231-1240/1235. 规划兼职工作（困难）.md | 1235. 规划兼职工作 | https://leetcode.cn/problems/maximum-profit-in-job-scheduling/solution/by-ac_oier-rgup/ | 困难 | [
"序列 DP",
"二分",
"排序"
] | 你打算利用空闲时间来做兼职工作赚些零花钱。
这里有 `n` 份兼职工作,每份工作预计从 `startTime[i]` 开始到 `endTime[i]` 结束,报酬为 `profit[i]`。
给你一份兼职工作表,包含开始时间 `startTime`,结束时间 `endTime` 和预计报酬 `profit` 三个数组,请你计算并返回可以获得的最大报酬。
注意,时间上出现重叠的 `2` 份工作不能同时进行。
如果你选择的工作在时间 `X` 结束,那么你可以立刻进行在时间 `X` 开始的下一份工作。
示例 1:
```
输入:startTime = [1,2,3,3], endTime = [3,4,5,6], profit... | ### 序列 DP + 二分
为了方便,我们令 `startTime` 为 `st`,`endTime` 为 `endTime`,`profit` 为 `ps`,同时定义三元组 $job[i] = (st[i], et[i], ps[i])$ 来代指某份工作。
我们知道,在理想情况下,若能将所有工作排成不重叠的直线,我们便能通过完成所有工作来取得最大收益。
归结到每个工作,我们总有「选择完成该工作」和「选择不完成该工作」两种决策。
**定义 $f[i]$ 为考虑前 $i$ 个工作,所能取得的最大收益(注意 $job[i]$ 不一定被选择完成),为了方便,我们令下标从 $1$ 开始:**
* 当不选择该工作时:由于 $job... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1235` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1231-1240/1239. 串联字符串的最大长度（中等）.md | 1239. 串联字符串的最大长度 | https://leetcode-cn.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/solution/gong-shui-san-xie-yi-ti-san-jie-jian-zhi-nfeb/ | 中等 | [
"DFS",
"二进制枚举",
"模拟退火",
"随机化",
"启发式搜索"
] | 给定一个字符串数组 `arr`,字符串 `s` 是将 `arr` 某一子序列字符串连接所得的字符串,如果 `s` 中的每一个字符都只出现过一次,那么它就是一个可行解。
请返回所有可行解 `s` 中最长长度。
示例 1:
```
输入:arr = ["un","iq","ue"]
输出:4
解释:所有可能的串联组合是 "","un","iq","ue","uniq" 和 "ique",最大长度为 4。
```
示例 2:
```
输入:arr = ["cha","r","act","ers"]
输出:6
解释:可能的解答有 "chaers" 和 "acters"。
```
示例 3:
```
输入:arr = ["abcd... | ### 基本分析
根据题意,可以将本题看做一类特殊的「数独问题」:在给定的 `arr` 字符数组中选择,尽可能多的覆盖一个 $1 \times 26$ 的矩阵。
对于此类「精确覆盖」问题,换个角度也可以看做「组合问题」。
通常有几种做法:`DFS`、剪枝 `DFS`、二进制枚举、模拟退火、`DLX`。
其中一头一尾解法过于简单和困难,有兴趣的同学自行了解与实现。
---
### 剪枝 DFS
根据题意,可以有如下的剪枝策略:
1. 预处理掉「本身具有重复字符」的无效字符串,并去重;
2. 由于只关心某个字符是否出现,而不关心某个字符在原字符串的位置,因此可以将字符串使用 `int` 进行表示;
3. 由于使用 `in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1239` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1251-1260/1252. 奇数值单元格的数目（简单）.md | 1252. 奇数值单元格的数目 | https://leetcode.cn/problems/cells-with-odd-values-in-a-matrix/solution/by-ac_oier-p0za/ | 简单 | [
"模拟",
"位运算",
"计数"
] | 给你一个 $m \times n$ 的矩阵,最开始的时候,每个单元格中的值都是 $0$。
另有一个二维索引数组 `indices`,$indices[i] = [r_i, c_i]$ 指向矩阵中的某个位置,其中 $r_i$ 和 $c_i$ 分别表示指定的行和列(从 $0$ 开始编号)。
对 $indices[i]$ 所指向的每个位置,应同时执行下述增量操作:
* $r_i$ 行上的所有单元格,加 $1$ 。
* $c_i$ 列上的所有单元格,加 $1$ 。
给你 $m$、$n$ 和 $indices$ 。请你在执行完所有 $indices$ 指定的增量操作后,返回矩阵中 奇数值单元格 的数目。
示例 1:
```
输入:m... | ### 基本分析
容易想到时间复杂度为 $O(l + m \times n)$,空间复杂度为 $O(m + n)$ 的做法,在此不再赘述。
对于某个位置最终累加值为奇数的充要条件为「所在行被累加次数的奇偶性」与「所在列被累加次数的奇偶性」不同。
因此我们可以统计累加次数为奇数的行数 $a$(累加次数为偶数的行数为 $m - a$),累加次数为奇数的列数 $b$(累加次数为偶数的列数为 $n - b$),根据乘法原理,最终答案为 $a \times (n - b) + (m - a) \times b$。
---
### 计数模拟
由于我们只需关系某个位置的奇偶性,而不关心具体的累加值,我们可以创建两个数组 `r` 和 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1252` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1251-1260/1253. 重构 2 行二进制矩阵（中等）.md | 1253. 重构 2 行二进制矩阵 | null | 中等 | [
"模拟",
"贪心",
"构造"
] | 给你一个 `2` 行 `n` 列的二进制数组:
* 矩阵是一个二进制矩阵,这意味着矩阵中的每个元素不是 0 就是 1。
* 第 `0` 行的元素之和为 `upper`。
* 第 `1` 行的元素之和为 `lower`。
* 第 `i` 列(从 `0` 开始编号)的元素之和为 `colsum[i]`,`colsum` 是一个长度为 `n` 的整数数组。
你需要利用 `upper`,`lower` 和 `colsum` 来重构这个矩阵,并以二维整数数组的形式返回它。
如果有多个不同的答案,那么任意一个都可以通过本题。
如果不存在符合要求的答案,就请返回一个空的二维数组。
示例 1:
```
输入:upper = 2, lowe... | ### 贪心 + 构造
创建数组 `a` 和 `b` 分别代表目标二进制矩阵的第 `0` 行和第 `1` 行。
从前往后处理 `colsum`,复用 `upper` 和 `lower` 分别代表两行剩余 $1$ 的个数。
根据当前的 $colsum[i]$ 进行分情况讨论:
* 若 $colsum[i] = 0$,只有一种情况,当前位置两行均为 $0$
* 若 $colsum[i] = 2$,只有一种情况,当前位置两行均为 $1$
* 若 $colsum[i] = 1$,选剩余 `1` 个数较大的行,填入 $1$,另外行则填入 $0$
若处理完 `colsum` 后,两行剩余 $1$ 个数恰好均为 $0$,说明构造出了合... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1253` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1251-1260/1260. 二维网格迁移（简单）.md | 1260. 二维网格迁移 | https://leetcode.cn/problems/shift-2d-grid/solution/by-ac_oier-1blt/ | 简单 | [
"模拟",
"构造"
] | 给你一个 `m` 行 `n` 列的二维网格 `grid` 和一个整数 `k`。
你需要将 `grid` 迁移 `k` 次。
每次「迁移」操作将会引发下述活动:
* 位于 `grid[i][j]` 的元素将会移动到 `grid[i][j + 1]`
* 位于 `grid[i][n - 1]` 的元素将会移动到 `grid[i + 1][0]`
* 位于 `grid[m - 1][n - 1]` 的元素将会移动到 `grid[0][0]`
* 请你返回 `k` 次迁移操作后最终得到的 二维网格
示例 1:
```
输入:grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1
输出:[[9,1,2],[... | ### 模拟
为了方便,我们令 `grid` 为 `g`,令 `n` 和 `m` 分别为 `g` 的行数和列数。
由于迁移过程存在明显规律性,因此我们可以直接 $O(1)$ 算得**每一列最终所在的列下标** `tcol = (i + k) % m`(其中 `i` 为原本的列下标),同时 $O(1)$ 算得**当前列的首行元素在新列中的行下标** `trow = ((i + k) / m) % n`,之后就是简单的遍历赋值操作。
Java 代码:
```Java
class Solution {
public List<List<Integer>> shiftGrid(int[][] g, int k) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1260` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1261-1270/1268. 搜索推荐系统（中等）.md | 1268. 搜索推荐系统 | https://leetcode.cn/problems/search-suggestions-system/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-gnmu/ | 中等 | [
"排序",
"字典树",
"哈希表",
"二分"
] | 给你一个产品数组 `products` 和一个字符串 `searchWord`,`products` 数组中每个产品都是一个字符串。
请你设计一个推荐系统,在依次输入单词 `searchWord` 的每一个字母后,推荐 `products` 数组中前缀与 `searchWord` 相同的最多三个产品。如果前缀相同的可推荐产品超过三个,请按字典序返回最小的三个。
请你以二维列表的形式,返回在输入 `searchWord` 每个字母后相应的推荐产品的列表。
示例 1:
```
输入:products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord =... | ### 排序 + 字典树 + 哈希表
为了方便,将 `products` 记为 `ps`,将 `searchWord` 记为 `w`。
这是一个 `"Suggestion string"` 问题,容易想到字典树进行求解,不了解字典树的同学,可看 [前置 🧀](https://mp.weixin.qq.com/s/DBTQyNYsEgmN0Vb5fbolUg)。
由于题目要求「若有超过三个的产品可推荐,返回字典序最小的三个」,我们不妨先对 `ps` 进行排序,使 `ps` 从前往后满足字典序从小到大。
**将所有 `ps[i]` 按顺序添加到字典树 `tr` 中,添加过程中,使用两个哈希表 `minMap` 和 `maxMa... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1268` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1261-1270/1269. 停在原地的方案数（困难）.md | 1269. 停在原地的方案数 | https://leetcode-cn.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps/solution/gong-shui-san-xie-xiang-jie-xian-xing-dp-m9q9/ | 困难 | [
"线性 DP"
] | 有一个长度为 arrLen 的数组,开始有一个指针在索引 0 处。
每一步操作中,你可以将指针向左或向右移动 1 步,或者停在原地(指针不能被移动到数组范围外)。
给你两个整数 steps 和 arrLen ,请你计算并返回:在恰好执行 steps 次操作以后,指针仍然指向索引 0 处的方案数。
由于答案可能会很大,请返回方案数 模 $10^9$ + 7 后的结果。
示例 1:
```
输入:steps = 3, arrLen = 2
输出:4
解释:3 步后,总共有 4 种不同的方法可以停在索引 0 处。
向右,向左,不动
不动,向右,向左
向右,不动,向左
不动,不动,不动
```
示例 2:
```
输入:ste... | ### 动态规划
这道题的可变维度分析不算复杂,因此这次就不从 `DFS` 开始给大家分析了。
**定义 $f[i][j]$ 代表当前剩余操作数为 $i$,所在位置为 $j$ 的所有方案数。**
起始位置为 $0$,操作次数为 $step$,即有初始化条件 $f[step][0] = 1$,$f[0][0]$ 则是我们的最终答案。
不失一般性的考虑 $f[i][j]$ 可以由哪些状态转移而来:
* 由「原地」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j]$ 转移而来
* 由「向左」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j + 1]$ 转移而来
* 由「向右」操作到达当前状态... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1269` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1281-1290/1282. 用户分组（中等）.md | 1282. 用户分组 | https://leetcode.cn/problems/group-the-people-given-the-group-size-they-belong-to/solution/by-ac_oier-z1bg/ | 中等 | [
"哈希表",
"模拟"
] | 有 `n` 个人被分成数量未知的组。每个人都被标记为一个从 $0$ 到 $n - 1$ 的唯一`ID` 。
给定一个整数数组 `groupSizes`,其中 `groupSizes[i]` 是第 $i$ 个人所在的组的大小。例如,如果 `groupSizes[1] = 3`,则第 $1$ 个人必须位于大小为 $3$ 的组中。
返回一个组列表,使每个人 $i$ 都在一个大小为 `groupSizes[i]` 的组中。
每个人应该恰好只出现在 一个组中,并且每个人必须在一个组中。如果有多个答案,返回其中任何一个。可以保证给定输入至少有一个有效的解。
示例 1:
```
输入:groupSizes = [3,3,3,3,3,1... | ### 哈希表 + 模拟
我们可以使用「哈希表」将所属组大小相同的下标放到一起。假设组大小为 $k$ 的元素有 $m$ 个,然后我们再将这 $m$ 个元素按照 $k$ 个一组进行划分即可。
Java 代码:
```Java
class Solution {
public List<List<Integer>> groupThePeople(int[] gs) {
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < gs.length; i++) {
List<Integer> ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1282` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1301-1310/1302. 层数最深叶子节点的和（中等）.md | 1302. 层数最深叶子节点的和 | https://leetcode.cn/problems/deepest-leaves-sum/solution/by-ac_oier-srst/ | 中等 | [
"DFS",
"BFS",
"树的遍历"
] | 给你一棵二叉树的根节点 `root`,请你返回 层数最深的叶子节点的和 。
示例 1:
```
输入:root = [1,2,3,4,5,null,6,7,null,null,null,null,8]
输出:15
```
示例 2:
```
输入:root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
输出:19
```
提示:
* 树中节点数目在范围 $[1, 10^4]$ 之间。
* $1 <= Node.val <= 100$ | ### BFS
使用 `BFS` 进行树的遍历,处理过程中记录最大深度 `depth` 以及使用哈希表记录每层元素和。
Java 代码:
```Java
class Solution {
public int deepestLeavesSum(TreeNode root) {
Map<Integer, Integer> map = new HashMap<>();
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
int depth = 0;
while (!d.isEmpty(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1302` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1301-1310/1305. 两棵二叉搜索树中的所有元素（中等）.md | 1305. 两棵二叉搜索树中的所有元素 | https://leetcode-cn.com/problems/all-elements-in-two-binary-search-trees/solution/by-ac_oier-c8fv/ | 中等 | [
"中序遍历",
"归并排序"
] | 给你 `root1` 和` root2` 这两棵二叉搜索树。请你返回一个列表,其中包含 两棵树 中的所有整数并按 升序 排序。.
示例 1:
```
输入:root1 = [2,1,4], root2 = [1,0,3]
输出:[0,1,1,2,3,4]
```
示例 2:
```
输入:root1 = [1,null,8], root2 = [8,1]
输出:[1,1,8,8]
```
提示:
* 每棵树的节点数在 $[0, 5000]$ 范围内
* $-10^5 <= Node.val <= 10^5$ | ### 中序遍历 + 归并排序
利用 `BST` 中序遍历的有序性质,我们可以先对两棵树进行中序遍历,从而将树的结构转换为线性结构。
将两个有序序列合并成一个有序序列则是利用了经典的「归并排序」。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
List<Integer> ans = new ArrayList<>();
List<Integer> l1 = new ArrayList<... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1301-1310/1310. 子数组异或查询（中等）.md | 1310. 子数组异或查询 | https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/ | 中等 | [
"数学",
"树状数组",
"前缀和"
] | 有一个正整数数组 arr,现给你一个对应的查询数组 queries,其中 queries[i] = [Li, Ri]。
对于每个查询 i,请你计算从 Li 到 Ri 的 XOR 值(即 arr[Li] xor arr[Li+1] xor ... xor arr[Ri])作为本次查询的结果。
并返回一个包含给定查询 queries 所有结果的数组。
示例 1:
```
输入:arr = [1,3,4,8], queries = [[0,1],[1,2],[0,3],[3,3]]
输出:[2,7,14,8]
解释:
数组中元素的二进制表示形式是:
1 = 0001
3 = 0011
4 = 0100
8 = 1000 ... | ### 基本分析
令数组 `arr` 和数组 `queries` 的长度分别为 `n` 和 `m`。
`n` 和 `m` 的数据范围均为 $10^4$,因此 $O(m * n)$ 的暴力做法我们不用考虑了。
数据范围要求我们做到「对数复杂度」或「线性复杂度」。
**本题主要利用异或运算中的「相同数值进行运算结果为 $0$」的特性。**
对于特定数组 $[a1, a2, a3, ... , an]$,要求得任意区间 $[l, r]$ 的异或结果,可以通过 $[1, r]$ 和 $[1, l - 1]$ 的异或结果得出:
$$
xor(l, r) = xor(1, r) ⊕ xor(1, l - 1)
$$
**本质上还是... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/131. 分割回文串（中等）.md | 131. 分割回文串 | https://leetcode-cn.com/problems/palindrome-partitioning/solution/wei-sha-yao-zhe-yang-bao-sou-ya-shi-ru-h-41gf/ | 中等 | [
"回文串",
"回溯算法",
"动态规划"
] | 给你一个字符串 `s`,请你将 `s` 分割成一些子串,使每个子串都是回文串。
返回 `s` 所有可能的分割方案。
回文串是正着读和反着读都一样的字符串。
示例 1:
```
输入:s = "aab"
输出:[["a","a","b"],["aa","b"]]
```
示例 2:
```
输入:s = "a"
输出:[["a"]]
```
提示:
* $1 <= s.length <= 16$
* `s` 仅由小写英文字母组成 | ### 动态规划 + 回溯算法
求所有的分割方案,凡是求所有方案的题基本上都没有什么优化方案,就是「爆搜」。
问题在于,爆搜什么?显然我们可以爆搜每个回文串的起点。如果有连续的一段是回文串,我们再对剩下连续的一段继续爆搜。
为什么能够直接接着剩下一段继续爆搜?
因为任意的子串最终必然能够分割成若干的回文串(最坏的情况下,每个回文串都是一个字母)。
所以我们每次往下爆搜时,只需要保证自身连续一段是回文串即可。
举个🌰 来感受下我们的爆搜过程,假设有样例 `abababa`,刚开始我们从起点第一个 a 进行爆搜:
1. 发现 `a` 是回文串,先将 `a` 分割出来,再对剩下的 `bababa` 进行爆搜
2. 发现 `... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.131` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/132. 分割回文串 II（困难）.md | 132. 分割回文串 II | https://leetcode-cn.com/problems/palindrome-partitioning-ii/solution/xiang-jie-liang-bian-dong-tai-gui-hua-ji-s5xr/ | 困难 | [
"回文串",
"线性 DP"
] | 给你一个字符串 `s`,请你将 `s` 分割成一些子串,使每个子串都是回文。
返回符合要求的 最少分割次数 。
示例 1:
```
输入:s = "aab"
输出:1
解释:只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。
```
示例 2:
```
输入:s = "a"
输出:0
```
示例 3:
```
输入:s = "ab"
输出:1
```
提示:
* $1 <= s.length <= 2000$
* `s` 仅由小写英文字母组成 | ### 动态规划
如果在 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8&chksm=fd9ca558caeb2c4eb1bff4f0878ff796feabe523657c2aafea0b2d1c7026e1c0572ab1e6d205&token=635532356&lang=zh_CN#rd) 你有使用到 DP 进行预处理的话。
这道题就很简单了,就是一道常规的动态规划题。
为了方便,我们约定所有下标从 $1$ 开始。
即对于长度... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.132` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/134. 加油站（中等）.md | 134. 加油站 | https://leetcode-cn.com/problems/gas-station/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-zsgqp/ | 中等 | [
"DFA",
"KMP"
] | 在一条环路上有 `N` 个加油站,其中第 `i` 个加油站有汽油 `gas[i]` 升。
你有一辆油箱容量无限的的汽车,从第 `i` 个加油站开往第 `i+1` 个加油站需要消耗汽油 `cost[i]` 升。你从其中的一个加油站出发,开始时油箱为空。
如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 `-1`。
说明:
* 如果题目有解,该答案即为唯一答案。
* 输入数组均为非空数组,且长度相同。
* 输入数组中的元素均为非负数。
示例 1:
```
输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]
输出: 3
解释:
从 3 号加油站(索引为 3 处)出发,可获得 4... | ### 基本分析/朴素解法
这是一道比较经典的题目。
估计在 LeetCode 也是有一段时间了,所以连数据范围都没有。
我这里直接规定一下数据范围为 $10^5$,这意味着我们不能使用 $O(n^2)$ 做法了。
但朴素做法往往是优化的出发点,所以我们还是先分析一下,朴素的做法是怎么样的:
* 题目要求「合法起点」的下标,因此我们可以枚举所有的「起点」
* 然后按照「油量 & 成本」模拟一遍,看是否能走完一圈
共有 $n$ 个「起点」,检查某个「起点」合法性的复杂度是 $O(n)$ 的。因此整体复杂度为 $O(n^2)$ 的。
代码:
```java
class Solution {
public int... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.134` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/137. 只出现一次的数字 II（中等）.md | 137. 只出现一次的数字 II | https://leetcode-cn.com/problems/single-number-ii/solution/gong-shui-san-xie-yi-ti-san-jie-ha-xi-bi-fku8/ | 中等 | [
"哈希表",
"位运算"
] | 给你一个整数数组 `nums`,除某个元素仅出现一次外,其余每个元素都恰出现三次。请你找出并返回那个只出现了一次的元素。
示例 1:
```
输入:nums = [2,2,3,2]
输出:3
```
示例 2:
```
输入:nums = [0,1,0,1,0,1,99]
输出:99
```
提示:
* $1 <= nums.length <= 3 \times 10^4$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* `nums` 中,除某个元素仅出现 一次 外,其余每个元素都恰出现 三次
进阶:你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗? | ### 哈希表
一个朴素的做法是使用「哈希表」进行计数,然后将计数为 $1$ 的数字进行输出。
哈希表以「数值 : 数值出现次数」形式进行存储。
代码:
```Java
class Solution {
public int singleNumber(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
for (int x : nums) {
map.put(x, map.getOrDefault(x, 0) + 1);
}
for (int x : map.keyS... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.137` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/138. 复制带随机指针的链表（中等）.md | 138. 复制带随机指针的链表 | https://leetcode-cn.com/problems/copy-list-with-random-pointer/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-pqek/ | 中等 | [
"哈希表",
"链表"
] | 给你一个长度为 `n` 的链表,每个节点包含一个额外增加的随机指针 `random`,该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 `n` 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 `next` 指针和 `random` 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如,如果原链表中有 `X` 和 `Y` 两个节点,其中 `X.random --> Y` 。那么在复制链表中对应的两个节点 `x` 和 `y` ,同样有 `x.random --> y` 。
返回复制链... | ### 模拟 + 哈希表
如果不考虑 `random` 指针的话,对一条链表进行拷贝,我们只需要使用两个指针:一个用于遍历原链表,一个用于构造新链表(始终指向新链表的尾部)即可。这一步操作可看做是「创建节点 + 构建 `next` 指针关系」。
现在在此基础上增加一个 `random` 指针,我们可以将 `next` 指针和 `random` 指针关系的构建拆开进行:
1. 先不考虑 `random` 指针,和原本的链表复制一样,创建新新节点,并构造 `next` 指针关系,同时使用「哈希表」记录原节点和新节点的映射关系;
2. 对原链表和新链表进行同时遍历,对于原链表的每个节点上的 `random` 都通过「哈希表」找到对应... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.138` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/131-140/139. 单词拆分（中等）.md | 139. 单词拆分 | https://leetcode.cn/problems/word-break/solution/by-ac_oier-gh00/ | 中等 | [
"动态规划",
"哈希表",
"序列 DP"
] | 给你一个字符串 `s` 和一个字符串列表 `wordDict` 作为字典。请你判断是否可以利用字典中出现的单词拼接出 `s` 。
注意:不要求字典中出现的单词全部都使用,并且字典中的单词可以重复使用。
示例 1:
```
输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
```
示例 2:
```
输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "app... | ### 序列 DP
将字符串 `s` 长度记为 $n$,`wordDict` 长度记为 $m$。为了方便,我们调整字符串 `s` 以及将要用到的动规数组的下标从 $1$ 开始。
定义 $f[i]$ 为考虑前 $i$ 个字符,能否使用 `wordDict` 拼凑出来:当 $f[i] = true$ 代表 $s[1...i]$ 能够使用 `wordDict` 所拼凑,反之则不能。
不失一般性考虑 $f[i]$ 该如何转移:由于 $f[i]$ 需要考虑 $s[1...i]$ 范围内的字符,若 $f[i]$ 为 `True` 说明整个 $s[1...i]$ 都能够使用 `wordDict` 拼凑,自然也包括最后一个字符 $s[i]$ ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.139` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1331-1340/1331. 数组序号转换（简单）.md | 1331. 数组序号转换 | https://leetcode.cn/problems/rank-transform-of-an-array/solution/by-ac_oier-j70n/ | 简单 | [
"模拟",
"哈希表",
"排序"
] | 给你一个整数数组 `arr`,请你将数组中的每个元素替换为它们排序后的序号。
序号代表了一个元素有多大。序号编号的规则如下:
* 序号从 $1$ 开始编号。
* 一个元素越大,那么序号越大。如果两个元素相等,那么它们的序号相同。
* 每个数字的序号都应该尽可能地小。
示例 1:
```
输入:arr = [40,10,20,30]
输出:[4,1,2,3]
解释:40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。
```
示例 2:
```
输入:arr = [100,100,100]
输出:[1,1,1]
解释:所有元素有相同的序号。
```
示例 3:
```
输入:arr ... | ### 模拟
根据题意进行模拟即可。
对 `arr` 进行拷贝操作得到新数组 `clone`,对 `clone` 数组进行排序,再使用哈希表记录元素与序号的映射关系,最后根据映射关系构造答案。
Java 代码:
```Java
class Solution {
public int[] arrayRankTransform(int[] arr) {
int[] clone = arr.clone();
Arrays.sort(clone);
Map<Integer, Integer> map = new HashMap<>();
int n = arr.l... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1331` 篇,系列开始于 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.