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/501-510/507. 完美数（简单）.md | 507. 完美数 | https://leetcode-cn.com/problems/perfect-number/solution/gong-shui-san-xie-jian-dan-mo-ni-tong-ji-e6jk/ | 简单 | [
"模拟",
"数论",
"数学"
] | 对于一个 正整数,如果它和除了它自身以外的所有 **正因子** 之和相等,我们称它为 「完美数」。
给定一个 整数 `n`, 如果是完美数,返回 `true`,否则返回 `false`。
示例 1:
```
输入:num = 28
输出:true
解释:28 = 1 + 2 + 4 + 7 + 14
1, 2, 4, 7, 和 14 是 28 的所有正因子。
```
示例 2:
```
输入:num = 6
输出:true
```
示例 3:
```
输入:num = 496
输出:true
```
示例 4:
```
输入:num = 8128
输出:true
```
示例 5:
```
输入:num = 2
输出... | ### 数学
我们知道正因数总是成对的出现,因此我们可以仅枚举每对正因数的较小数,即从 $[1, \sqrt{num}]$ 范围内进行枚举(其中 $nums > 1$)。
同时为避免使用 `sqrt` 库函数和溢出,使用 $i <= \frac{num}{i}$ 作为上界判断。
代码:
```Java
class Solution {
public boolean checkPerfectNumber(int num) {
if (num == 1) return false;
int ans = 1;
for (int i = 2; i <= num / i; i++)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.507` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/508. 出现次数最多的子树元素和（中等）.md | 508. 出现次数最多的子树元素和 | https://leetcode.cn/problems/most-frequent-subtree-sum/solution/by-ac_oier-t3y4/ | 中等 | [
"树的遍历",
"DFS",
"哈希表"
] | 给你一个二叉树的根结点 `root`,请返回出现次数最多的子树元素和。如果有多个元素出现的次数相同,返回所有出现次数最多的子树元素和(不限顺序)。
一个结点的 「子树元素和」 定义为以该结点为根的二叉树上所有结点的元素之和(包括结点本身)。
示例 1:
```
输入: root = [5,2,-3]
输出: [2,-3,4]
```
示例 2:
```
输入: root = [5,2,-5]
输出: [2]
```
提示:
* 节点数在 $[1, 10^4]$ 范围内
* $-10^5 <= Node.val <= 10^5$ | ### DFS
使用 `DFS` 对树进行遍历,同时将每棵子树的总和值存入哈希表(以元素和为 `key`,出现次数为 `value`),并实时维护最大子树和,使用变量 `max` 存储。
当遍历完整棵树后,将哈希表中值为 `max` 的键存入答案。
代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
int max = 0;
public int[] findFrequentTreeSum(TreeNode root) {
dfs(root);
List<Integer> li... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.508` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/51-60/53. 最大子数组和（中等）.md | 53. 最大子数组和 | https://leetcode.cn/problems/maximum-subarray/solutions/2534027/gong-shui-san-xie-cong-on-de-chang-gui-l-22hq/ | 中等 | [
"前缀和",
"区间求和问题",
"线性 DP",
"分治"
] | 给你一个整数数组 `nums`,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
子数组是数组中的一个连续部分。
示例 1:
```
输入:nums = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。
```
示例 2:
```
输入:nums = [1]
输出:1
```
示例 3:
```
输入:nums = [5,4,-1,7,8]
输出:23
```
提示:
* $1 <= nums.length <= 10^5$
* $-10^4 <= nums[i] <= 10^4$
进阶:如果你已经实现复杂度为 $O(n... | ### 前缀和 or 线性 DP
当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。
所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。
设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。
有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。
通用公式:`ans = sum[j] - sum[i - 1]`。
由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1$ 开始。在进... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.53` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/51-60/54. 螺旋矩阵（中等）.md | 59. 螺旋矩阵 | https://leetcode-cn.com/problems/spiral-matrix/solution/xiang-jie-xing-zhuang-jie-fa-fang-xiang-3qmhf/ | 中等 | [
"模拟"
] | 给你一个 $m$ 行 $n$ 列的矩阵 `matrix`,请按照顺时针螺旋顺序,返回矩阵中的所有元素。
示例 1:
```
输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出:[1,2,3,6,9,8,7,4,5]
```
示例 2:
```
输入:matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出:[1,2,3,4,8,12,11,10,9,5,6,7]
```
提示:
* $m == matrix.length$
* $n == matrix[i].length$
* $1 <= m, n <= 10$
* $-100 <= matrix[i][... | ### 按照「形状」进行模拟
我们可以按「圈」进行划分打印。
使用「左上角」$(x1,y1)$ &「右下角」$(x2,y2)$ 来确定某个「圈」,进行打印。
完成后,令「左上角」&「右下角」往里收,分别得到 $(x1 + 1, y1 + 1)$ 和 $(x2 - 1, y2 - 1)$,执行相同的打印规则。
代码 :
```Java
class Solution {
public List<Integer> spiralOrder(int[][] mat) {
List<Integer> ans = new ArrayList<>();
int m = mat.length, n = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.54` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/51-60/58. 最后一个单词的长度（简单）.md | 58. 最后一个单词的长度 | https://leetcode-cn.com/problems/length-of-last-word/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-tt6t/ | 简单 | [
"模拟"
] | 给你一个字符串 `s`,由若干单词组成,单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
**单词**是指仅由字母组成、不包含任何空格字符的最大子字符串。
示例 1:
```
输入:s = "Hello World"
输出:5
```
示例 2:
```
输入:s = " fly me to the moon "
输出:4
```
示例 3:
```
输入:s = "luffy is still joyboy"
输出:6
```
提示:
* 1 <= s.length <= $10^4$
* s 仅有英文字母和空格 ' ' 组成
* s 中至少存在一个单词 | ### 模拟
根据题意,我们可以「从后往前」对字符串进行遍历,使用两个指针 $i$ 和 $j$ 来代指最后一个单词的范围($i$ 最终会指向目标单词首个字符的前一个字符,$j$ 最终会指向目标单词的最后一个字符),最终 $j - i$ 即是答案。
代码:
```Java
class Solution {
public int lengthOfLastWord(String s) {
int n = s.length();
int j = n - 1;
while (j >= 0 && s.charAt(j) == ' ') j--;
int i = j;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.58` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/51-60/59. 螺旋矩阵 II（中等）.md | 59. 螺旋矩阵 II | https://leetcode-cn.com/problems/spiral-matrix-ii/solution/yi-ti-shuang-jie-xiang-jie-xing-zhuang-j-24x8/ | 中等 | [
"模拟"
] | 给你一个正整数 $n$ ,生成一个包含 $1$ 到 $n^2$ 所有元素,且元素按顺时针顺序螺旋排列的 `n x n` 正方形矩阵 `matrix` 。
示例 1:
```
输入:n = 3
输出:[[1,2,3],[8,9,4],[7,6,5]]
```
示例 2:
```
输入:n = 1
输出:[[1]]
```
提示:
* $1 <= n <= 20$ | ### 按照「形状」进行模拟
我们可以按「圈」进行构建。
使用「左上角」$(x1,y1)$ &「右下角」$(x2,y2)$ 来确定某个「圈」,进行构建。
完成后,令「左上角」&「右下角」往里收,分别得到 $(x1 + 1, y1 + 1)$ 和 $(x2 - 1, y2 - 1)$,执行相同的构建规则。
代码:
```Java
class Solution {
public int[][] generateMatrix(int n) {
int[][] ans = new int[n][n];
circle(0, 0, n - 1, n - 1, 1, ans);
re... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.59` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/511-520/513. 找树左下角的值（中等）.md | 513. 找树左下角的值 | https://leetcode.cn/problems/find-bottom-left-tree-value/solution/by-ac_oier-sv59/ | 中等 | [
"BFS",
"DFS",
"树的遍历"
] | 给定一个二叉树的 根节点 `root`,请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。
示例 1:
```
输入: root = [2,1,3]
输出: 1
```
示例 2:
```
输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7
```
提示:
* 二叉树的节点个数的范围是 $[1,10^4]$
* $-2^{31} <= Node.val <= 2^{31} - 1$ | ### BFS
使用 `BFS` 进行「层序遍历」,每次用当前层的首个节点来更新 `ans`,当 `BFS` 结束后,`ans` 存储的是最后一层最靠左的节点。
代码:
```Java
class Solution {
public int findBottomLeftValue(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
int ans = 0;
while (!d.isEmpty()) {
int sz = d.size();
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.513` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/511-520/515. 在每个树行中找最大值（中等）.md | 515. 在每个树行中找最大值 | https://leetcode.cn/problems/find-largest-value-in-each-tree-row/solution/by-ac_oier-vc06/ | 中等 | [
"DFS",
"BFS"
] | 给定一棵二叉树的根节点 `root`,请找出该二叉树中每一层的最大值。
示例1:
```
输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]
```
示例2:
```
输入: root = [1,2,3]
输出: [1,3]
```
提示:
* 二叉树的节点个数的范围是 $[0,10^4]$
* $-2^{31} <= Node.val <= 2^{31} - 1$ | ### BFS
使用 `BFS` 进行层序遍历,单次 `BFS` 逻辑将整一层的元素进行出队,维护当前层的最大值,并将最大值加入答案。
代码:
```Java
class Solution {
public List<Integer> largestValues(TreeNode root) {
List<Integer> ans = new ArrayList<>();
if (root == null) return ans;
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.515` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/511-520/516. 最长回文子序列（中等）.md | 516. 最长回文子序列 | https://leetcode-cn.com/problems/longest-palindromic-subsequence/solution/gong-shui-san-xie-qu-jian-dp-qiu-jie-zui-h2ya/ | 中等 | [
"动态规划",
"区间 DP"
] | 给你一个字符串 `s` ,找出其中最长的回文子序列,并返回该序列的长度。
子序列定义为:不改变剩余字符顺序的情况下,删除某些字符或者不删除任何字符形成的一个序列。
示例 1:
```
输入:s = "bbbab"
输出:4
解释:一个可能的最长回文子序列为 "bbbb" 。
```
示例 2:
```
输入:s = "cbbd"
输出:2
解释:一个可能的最长回文子序列为 "bb" 。
```
提示:
* $1 <= s.length <= 1000$
* `s` 仅由小写英文字母组成 | ### 动态规划
这是一道经典的区间 DP 题。
**之所以可以使用区间 DP 进行求解,是因为在给定一个回文串的基础上,如果在回文串的边缘分别添加两个新的字符,可以通过判断两字符是否相等来得知新串是否回文。**
也就是说,使用小区间的回文状态可以推导出大区间的回文状态值。
**从图论意义出发就是,任何一个长度为 $len$ 的回文串,必然由「长度为 $len - 1$」或「长度为 $len - 2$」的回文串转移而来。**
**两个具有公共回文部分的回文串之间存在拓扑序(存在由「长度较小」回文串指向「长度较大」回文串的有向边)。**
通常区间 DP 问题都是,常见的基本流程为:
1. 从小到大枚举区间大小 $len$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.516` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/511-520/517. 超级洗衣机（困难）.md | 517. 超级洗衣机 | https://leetcode-cn.com/problems/super-washing-machines/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-mzqia/ | 困难 | [
"贪心"
] | 假设有 `n` 台超级洗衣机放在同一排上。开始的时候,每台洗衣机内可能有一定量的衣服,也可能是空的。
在每一步操作中,你可以选择任意 `m` (`1 <= m <= n`) 台洗衣机,与此同时将每台洗衣机的一件衣服送到相邻的一台洗衣机。
给定一个整数数组 `machines` 代表从左至右每台洗衣机中的衣物数量,请给出能让所有洗衣机中剩下的衣物的数量相等的 最少的操作步数 。如果不能使每台洗衣机中衣物的数量相等,则返回 `-1` 。
示例 1:
```
输入:machines = [1,0,5]
输出:3
解释:
第一步: 1 0 <-- 5 => 1 1 4
第二步: 1 ... | ### 基本分析
由于最终是要让所有洗衣机衣服相等,因此无解的情况很好分析,如果衣服数量 $sum$ 不能整除洗衣机数量 $n$ 的话,则返回 $-1$,否则必然有解(最坏情况下,每次只移动一件衣服,也可以使得衣服均分),要求最小移动次数。
由于每次操作都可以选任意台机器进行,不难猜想到最小移动次数为 **所有机器的「最小运输衣服数量」中的最大值**。
计算某台洗衣机的「最小运输衣服数量」为经过当前机器的衣服数量(每次只能运输一件衣服),其值等于「起始左边衣服总量 与 最终左边衣服总量 的差值」+「起始右边衣服总量 与 最终右边衣服总量 的差值」,这里的差值都需要与 $0$ 取 $\max$ 代指缺少衣服的数量(因为如果是多余... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.517` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/511-520/518. 零钱兑换 II（中等）.md | 518. 零钱兑换 II | https://leetcode-cn.com/problems/coin-change-2/solution/gong-shui-san-xie-xiang-jie-wan-quan-bei-6hxv/ | 中等 | [
"背包问题",
"完全背包",
"动态规划"
] | 给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。
示例 1:
```
输入: amount = 5, coins = [1, 2, 5]
输出: 4
解释: 有四种方式可以凑成总金额:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1
```
示例 2:
```
输入: amount = 3, coins = [2]
输出: 0
解释: 只用面额2的硬币不能凑成总金额3。
```
示例 3:
```
输入: amount = 10, coins = [10]
输出: 1
```
注意:
你可以假设:
* 0 <= amount (总金额) <= 50... | ### 完全背包(朴素解法)
在 [322. 零钱兑换](https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/) 中,我们求的是「取得特定价值所需要的最小物品个数」。
对于本题,我们求的是「取得特定价值的方案数量」。
**求的东西不一样,但问题的本质没有发生改变,同样属于「组合优化」问题。**
你可以这样来理解什么是组合优化问题:
**被选物品之间不需要满足特定关系,只需要选择物品,以达到「全局最优」或者「特定状态」即可。**
同时硬币相当于我们的物品,每种硬币可以选择「无限... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.518` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/511-520/519. 随机翻转矩阵（中等）.md | 519. 随机翻转矩阵 | https://leetcode-cn.com/problems/random-flip-matrix/solution/gong-shui-san-xie-note-bie-pian-yi-ti-sh-e6gi/ | 中等 | [
"哈希表",
"双指针"
] | 给你一个 $m x n$ 的二元矩阵 $matrix$,且所有值被初始化为 $0$。
请你设计一个算法,随机选取一个满足 `matrix[i][j] == 0` 的下标 $(i, j)$ ,并将它的值变为 $1$ 。
所有满足 `matrix[i][j] == 0` 的下标 $(i, j)$ 被选取的概率应当均等。
尽量最少调用内置的随机函数,并且优化时间和空间复杂度。
实现 `Solution` 类:
* `Solution(int m, int n)` 使用二元矩阵的大小 $m$ 和 $n$ 初始化该对象
* `int[] flip()` 返回一个满足 `matrix[i][j] == 0` 的随机下标 `[i, j]... | ### 双指针
矩阵大小的数据范围为 $10^4$,因此我们不能使用真实构建矩阵的做法来做,同时利用二维的坐标能够唯一对应出编号($idx = row * n + col$),可以将问题转换为一维问题。
一个最为朴素的做法是利用调用次数只有 $10^3$,我们可以在 $[0, m * n)$ 范围内随机出一个下标 $idx$(对应矩阵的某个具体位置),然后从 $idx$ 往两边进行扫描,找到最近一个未被使用的位置,将其进行标记翻转并返回。
该做法相比于一直随机的「拒绝采样」做法,能够确保单次 `flip` 操作中只会调用一次随机方法,同时利用矩阵只有 $10^3$ 个位置被翻转,因而复杂度上具有保证。
代码:
```Java... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.519` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/511-520/520. 检测大写字母（简单）.md | 520. 检测大写字母 | https://leetcode-cn.com/problems/detect-capital/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-rpor/ | 简单 | [
"模拟"
] | 我们定义,在以下情况时,单词的大写用法是正确的:
* 全部字母都是大写,比如 "USA" 。
* 单词中所有字母都不是大写,比如 "leetcode" 。
* 如果单词不只含有一个字母,只有首字母大写, 比如 "Google" 。
给你一个字符串 word 。如果大写用法正确,返回 true ;否则,返回 false 。
示例 1:
```
输入:word = "USA"
输出:true
```
示例 2:
```
输入:word = "FlaG"
输出:false
```
提示:
* 1 <= word.length <= 100
* word 由小写和大写英文字母组成 | ### 模拟
根据题意,分别进行三种规则的判断即可。
代码:
```Java
class Solution {
public boolean detectCapitalUse(String word) {
if (word.toUpperCase().equals(word)) return true;
if (word.toLowerCase().equals(word)) return true;
int n = word.length(), idx = 1;
if (Character.isUpperCase(word.charAt(0))) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.520` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/521-530/521. 最长特殊序列 Ⅰ（简单）.md | 521. 最长特殊序列 I | https://leetcode-cn.com/problems/longest-uncommon-subsequence-i/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-z-nj3w/ | 简单 | [
"脑筋急转弯"
] | 给你两个字符串 `a` 和 `b`,请返回 这两个字符串中 最长的特殊序列 。如果不存在,则返回 $-1$ 。
「最长特殊序列」 定义如下:该序列为 某字符串独有的最长子序列(即不能是其他字符串的子序列) 。
字符串 `s` 的子序列是在从 `s` 中删除任意数量的字符后可以获得的字符串。
例如,`“abc”` 是 `“aebdc”` 的子序列,因为您可以删除 `“aebdc”` 中的下划线字符来得到 `“abc”` 。 `“aebdc”` 的子序列还包括 `“aebdc”` 、 `“aeb”` 和 `“”` (空字符串)。
示例 1:
```
输入: a = "aba", b = "cdc"
输出: 3
解释: 最长... | ### 脑筋急转弯
当两字符串不同时,我们总能选择长度不是最小的字符串作为答案,而当两字符串相同时,我们无法找到特殊序列。
代码:
```Java
class Solution {
public int findLUSlength(String a, String b) {
return a.equals(b) ? -1 : Math.max(a.length(), b.length());
}
}
```
* 时间复杂度:字符串比较复杂度与长度成正比,复杂度为 $O(\max(n, m))$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.521` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/521-530/522. 最长特殊序列 II（中等）.md | 522. 最长特殊序列 II | https://leetcode.cn/problems/longest-uncommon-subsequence-ii/solution/by-ac_oier-vuez/ | 中等 | [
"LCS",
"最长公共子序列",
"序列 DP",
"枚举",
"动态规划"
] | 给定字符串列表 `strs`,返回其中 最长的特殊序列 。如果最长特殊序列不存在,返回 $-1$ 。
特殊序列 定义如下:该序列为某字符串 独有的子序列(即不能是其他字符串的子序列)。
`s` 的 子序列可以通过删去字符串 `s` 中的某些字符实现。
* 例如,`"abc"` 是 `"aebdc"` 的子序列,因为您可以删除 `"aebdc"` 中的下划线字符来得到 `"abc"` 。`"aebdc"` 的子序列还包括 `"aebdc"`、 `"aeb"` 和 `""` (空字符串)。
示例 1:
```
输入: strs = ["aba","cdc","eae"]
输出: 3
```
示例 2:
```
输入: strs... | ### LCS
记 `strs` 数组长度为 $n$,单个 $strs[i]$ 的最大长度 $m$。其中 $n$ 数据范围为 $50$,$m$ 数据范围为 $10$。
根据题意,我们可以枚举每个 $s1 = str[i]$,检查其是否为其他 $s2 = strs[j]$ 的子序列,这需要枚举所有点对,复杂度为 $O(n^2)$。同时记录遍历过程中的最大长度 `ans`,用于剪枝(对于字符串长度本身小于等于 `ans` 的 $strs[i]$ 可直接跳过)。
我们可以实现一个 `check` 函数来检查 `s1` 是否为 `s2` 的子序列,该问题可转化为求 `s1` 和 `s2` 的最长公共子序列长度。若最长公共子序列长度为 ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.522` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/521-530/523. 连续的子数组和（中等）.md | 523. 连续的子数组和 | https://leetcode-cn.com/problems/continuous-subarray-sum/solution/gong-shui-san-xie-tuo-zhan-wei-qiu-fang-1juse/ | 中等 | [
"前缀和"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组:
* 子数组大小至少为 `2` ,且
* 子数组元素总和为 `k` 的倍数。
如果存在,返回 `true`;否则,返回 `false`。
如果存在一个整数 `n` ,令整数 `x` 符合 `x = n * k` ,则称 `x` 是 `k` 的一个倍数。
示例 1:
```
输入:nums = [23,2,4,6,7], k = 6
输出:true
解释:[2,4] 是一个大小为 2 的子数组,并且和为 6 。
```
示例 2:
```
输入:nums = [23,2,6,4,7], k = 6
输出:t... | ### 基本分析
这是一道很经典的前缀和题目,类似的原题也在蓝桥杯出现过,坐标在 [K 倍区间](http://lx.lanqiao.cn/problem.page?gpid=T444) http://lx.lanqiao.cn/problem.page?gpid=T444。
本题与那道题不同在于:
* [K 倍区间] 需要求得所有符合条件的区间数量;本题需要判断是否存在。
* [K 倍区间] 序列全是正整数,不需要考虑 $0$ 值问题;本题需要考虑 $0$ 值问题。
数据范围为 $10^4$,因此无论是纯朴素的做法 ($O(n^3)$)还是简单使用前缀和优化的做法 ($O(n^2)$) 都不能满足要求。
我们需要从 $k... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.523` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/521-530/524. 通过删除字母匹配到字典里最长单词（中等）.md | 524. 通过删除字母匹配到字典里最长单词 | https://leetcode-cn.com/problems/longest-word-in-dictionary-through-deleting/solution/gong-shui-san-xie-xiang-jie-pai-xu-shuan-qi20/ | 中等 | [
"双指针",
"贪心",
"排序"
] | 给你一个字符串 `s` 和一个字符串数组 `dictionary` 作为字典,找出并返回字典中最长的字符串,该字符串可以通过删除 `s` 中的某些字符得到。
如果答案不止一个,返回长度最长且字典序最小的字符串。
如果答案不存在,则返回空字符串。
示例 1:
```
输入:s = "abpcplea", dictionary = ["ale","apple","monkey","plea"]
输出:"apple"
```
示例 2:
```
输入:s = "abpcplea", dictionary = ["a","b","c"]
输出:"a"
```
提示:
* $1 <= s.length <= 1000$
* $1 ... | ### 排序 + 双指针 + 贪心
根据题意,我们需要找到 `dictionary` 中为 `s` 的子序列,且「长度最长(优先级 $1$)」及「字典序最小(优先级 $2$)」的字符串。
数据范围全是 $1000$。
我们可以先对 `dictionary` 根据题意进行自定义排序:
1. 长度不同的字符串,按照字符串长度排倒序;
2. 长度相同的,则按照字典序排升序。
然后我们只需要对 `dictionary` 进行顺序查找,找到的第一个符合条件的字符串即是答案。
具体的,我们可以使用「贪心」思想的「双指针」实现来进行检查:
1. 使用两个指针 `i` 和 `j` 分别代表检查到 `s` 和 `dictionary[x... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.524` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/521-530/525. 连续数组（中等）.md | 525. 连续数组 | https://leetcode-cn.com/problems/contiguous-array/solution/gong-shui-san-xie-qian-zhui-he-ha-xi-bia-q400/ | 中等 | [
"前缀和",
"哈希表"
] | 给定一个二进制数组 `nums` , 找到含有相同数量的 $0$ 和 $1$ 的最长连续子数组,并返回该子数组的长度。
示例 1:
```
输入: nums = [0,1]
输出: 2
说明: [0, 1] 是具有相同数量0和1的最长连续子数组。
```
示例 2:
```
输入: nums = [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。
```
提示:
* $1 <= nums.length <= 10^5$
* `nums[i]` 不是 $0$ 就是 $1$ | ### 前缀和 + 哈希表
根据题意,我们可以轻易发现如下性质:如果答案非 $0$,那么子数组长度必然为偶数,且长度至少为 $2$。
具体的,我们在预处理前缀和时,将 $nums[i]$ 为 $0$ 的值当做 $-1$ 处理。
从而将问题转化为:**如何求得最长一段区间和为 $0$ 的子数组。** 同时使用「哈希表」来记录「某个前缀和出现的最小下标」是多少。
Java 代码:
```Java
class Solution {
public int findMaxLength(int[] nums) {
int n = nums.length, ans = 0;
int[] sum = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.525` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/521-530/526. 优美的排列（中等）.md | 526. 优美的排列 | https://leetcode-cn.com/problems/beautiful-arrangement/solution/gong-shui-san-xie-xiang-jie-liang-chong-vgsia/ | 中等 | [
"位运算",
"状压 DP",
"动态规划"
] | 假设有从 $1$ 到 $N$ 的 $N$ 个整数,如果从这 $N$ 个数字中成功构造出一个数组,使得数组的第 $i$ 位 ($1 <= i <= N$) 满足如下两个条件中的一个,我们就称这个数组为一个优美的排列。
条件:
* 第 $i$ 位的数字能被 $i$ 整除
* $i$ 能被第 $i$ 位上的数字整除
现在给定一个整数 $N$,请问可以构造多少个优美的排列?
示例1:
```
输入: 2
输出: 2
解释:
第 1 个优美的排列是 [1, 2]:
第 1 个位置(i=1)上的数字是1,1能被 i(i=1)整除
第 2 个位置(i=2)上的数字是2,2能被 i(i=2)整除
第 2 个优美的排列是 [2,... | ### 状态压缩 DP
利用数据范围不超过 $15$,我们可以使用「状态压缩 DP」进行求解。
**使用一个二进制数表示当前哪些数已被选,哪些数未被选,目的是为了可以使用位运算进行加速。**
我们可以通过一个具体的样例,来感受下「状态压缩」是什么意思:
例如 $(000...0101)_2$ 代表值为 $1$ 和值为 $3$ 的数字已经被使用了,而值为 $2$ 的节点尚未被使用。
然后再来看看使用「状态压缩」的话,一些基本的操作该如何进行:
假设变量 $state$ 存放了「当前数的使用情况」,当我们需要检查值为 $k$ 的数是否被使用时,可以使用位运算 `a = (state >> k) & 1`,来获取 $state... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.525` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/521-530/528. 按权重随机选择（中等）.md | 528. 按权重随机选择 | https://leetcode-cn.com/problems/random-pick-with-weight/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-8bx50/ | 中等 | [
"前缀和",
"二分",
"模拟"
] | 给定一个正整数数组 $w$ ,其中 $w[i]$ 代表下标 $i$ 的权重(下标从 $0$ 开始),请写一个函数 `pickIndex` ,它可以随机地获取下标 $i$,选取下标 $i$ 的概率与 $w[i]$ 成正比。
例如,对于 $w = [1, 3]$,挑选下标 $0$ 的概率为 $1 / (1 + 3) = 0.25$ (即,$25$%),而选取下标 $1$ 的概率为 $3 / (1 + 3) = 0.75$(即,$75$%)。
也就是说,选取下标 $i$ 的概率为 $w[i] / sum(w)$ 。
示例 1:
```
输入:
["Solution","pickIndex"]
[[[1]],[]]
输出:
[nu... | ### 前缀和 + 二分
根据题意,权重值 $w[i]$ 可以作为 `pickIndex` 调用总次数为 $\sum_{i = 0}^{w.length - 1} w[i]$ 时,下标 $i$ 的返回次数。
随机数的产生可以直接使用语言自带的 API,剩下的我们需要构造一个分布符合权重的序列。
由于 $1 <= w[i] <= 10^5$,且 $w$ 长度为 $10^4$,因此直接使用构造一个有 $w[i]$ 个的 $i$ 的数字会 MLE。
**我们可以使用「前缀和」数组来作为权重分布序列,权重序列的基本单位为 $1$。**
一个长度为 $n$ 的构造好的「前缀和」数组可以看是一个基本单位为 $1$ 的 $[1, sum... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.528` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/531-540/532. 数组中的 k-diff 数对（中等）.md | 532. 数组中的 k-diff 数对 | https://leetcode.cn/problems/k-diff-pairs-in-an-array/solution/by-ac_oier-ap3v/ | 中等 | [
"哈希表",
"离散化",
"二分",
"双指针"
] | 给定一个整数数组和一个整数 $k$,你需要在数组里找到 不同的 `k-diff` 数对,并返回不同的 `k-diff` 数对 的数目。
这里将 `k-diff` 数对定义为一个整数对 $(nums[i], nums[j])$,并满足下述全部条件:
* `0 <= i < j < nums.length`
* `|nums[i] - nums[j]| == k`
注意,`|val|` 表示 `val` 的绝对值。
示例 1:
```
输入:nums = [3, 1, 4, 1, 5], k = 2
输出:2
解释:数组中有两个 2-diff 数对, (1, 3) 和 (3, 5)。
尽管数组中有两个1,但我们只应返回不同的... | ### 哈希表
一个简单的想法是先使用「哈希表」进行计数。
对于每个 $x = nums[i]$ 而言,根据 $k$ 是否为 $0$ 进行分情况讨论:
* $k$ 为 $0$:此时只能 $(x, x)$ 组成数对,此时判断 $nums[i]$ 出现次数是否大于 $1$ 次,若满足则进行计数加一;
* $k$ 不为 $0$:此时 $x$ 能够与 $a = x - k$ 或 $b = x + k$ 组成数对,分别查询 $a$ 和 $b$ 是否出现过,若出现过则进行计数加一。
为了防止相同的 $x$ 进行重复计数,我们需要统计完 $x$ 后,清空其出现次数。
代码:
```Java
class Solution {
pu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.532` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/531-540/535. TinyURL 的加密与解密（中等）.md | 535. TinyURL 的加密与解密 | https://leetcode.cn/problems/encode-and-decode-tinyurl/solution/by-ac_oier-ca6o/ | 中等 | [
"哈希表",
"模拟"
] | `TinyURL` 是一种 `URL` 简化服务, 比如:当你输入一个 URL `https://leetcode.com/problems/design-tinyurl` 时,它将返回一个简化的URL `http://tinyurl.com/4e9iAk` 。
请你设计一个类来加密与解密 `TinyURL` 。
加密和解密算法如何设计和运作是没有限制的,你只需要保证一个 `URL` 可以被加密成一个 `TinyURL` ,并且这个 `TinyURL` 可以用解密方法恢复成原本的 `URL` 。
实现 `Solution` 类:
* `Solution()` 初始化 `TinyURL` 系统对象。
* `String enco... | ### 模拟 + 哈希表
对于每个 `longUrl` 我们都在「大写字母/小写字母/数字」中随机 $k = 6$ 位作为其映射标识,这需要使用一个哈希表 `tiny2Origin` 进行记录。
同时了防止相同的 `longUrl` 多次调用,确保 `encode` 服务的「幂等性」,我们再额外建立哈希表 `origin2Tiny` 来记录原串和映射标识的对应关系。
Java 代码:
```Java
public class Codec {
Map<String, String> origin2Tiny = new HashMap<>(), tiny2Origin = new HashMap<>();
Stri... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.535` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/531-540/537. 复数乘法（中等）.md | 537. 复数乘法 | https://leetcode-cn.com/problems/complex-number-multiplication/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-avlh/ | 中等 | [
"模拟"
] | 复数 可以用字符串表示,遵循 "实部+虚部i" 的形式,并满足下述条件:
* 实部 是一个整数,取值范围是 $[-100, 100]$
* 虚部 也是一个整数,取值范围是 $[-100, 100]$
* $i^2 == -1$
给你两个字符串表示的复数 `num1` 和 `num2` ,请你遵循复数表示形式,返回表示它们乘积的字符串。
示例 1:
```
输入:num1 = "1+1i", num2 = "1+1i"
输出:"0+2i"
解释:(1 + i) * (1 + i) = 1 + i2 + 2 * i = 2i ,你需要将它转换为 0+2i 的形式。
```
示例 2:
```
输入:num1 = "1+-1i"... | ### 模拟
本题考察的是「复数乘法法则」运用。
根据 $(a+bi)(c+di)=(ac-bd)+(bc+ad)i$,我们可以直接对 `nums1` 和 `nums2` 进行「实数」和「虚数」分割,按照法则运算后重新组成答案。
代码:
```Java
class Solution {
public String complexNumberMultiply(String num1, String num2) {
String[] ss1 = num1.split("\\+|i"), ss2 = num2.split("\\+|i");
int a = parse(ss1[0]), b =... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.537` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/531-540/538. 把二叉搜索树转换为累加树（中等）.md | 538. 把二叉搜索树转换为累加树 | https://leetcode.cn/problems/convert-bst-to-greater-tree/solutions/2555345/gong-shui-san-xie-li-yong-bst-de-zhong-x-vzqe/ | 中等 | [
"BST",
"中序遍历"
] | 给出二叉搜索树的根节点,该树的节点值各不相同,请你将其转换为累加树(Greater Sum Tree),使每个节点 `node` 的新值等于原树中大于或等于 `node.val` 的值之和。
提醒一下, 二叉搜索树满足下列约束条件:
* 节点的左子树仅包含键小于节点键的节点。
* 节点的右子树仅包含键大于节点键的节点。
* 左右子树也必须是二叉搜索树。
示例 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:
```... | ### 中序遍历
利用 **`BST` 的中序遍历是有序** 的特性,我们可以通过两次遍历 `BST` 来求解问题。
首先,通过一次遍历,计算出整棵树的节点总和 `tot`,然后在中序遍历过程中,不断对 `tot` 进行更新,将其作为当前未遍历到的节点的总和,用于给当前节点赋值。
假设当前遍历到的节点为 `x`(起始节点值为 `t`),那么将节点更新为当前节点 `tot` 后,更新 `tot = tot - t`。
这是常规的中序遍历做法,更进一步,如果将其中序遍历的顺序进行翻转(从「左中右」调整为「右中左」),则可实现一次遍历。
Java 代码:
```Java
class Solution {
int tot ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.538` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/531-540/539. 最小时间差（中等）.md | 539. 最小时间差 | https://leetcode-cn.com/problems/minimum-time-difference/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-eygg/ | 中等 | [
"模拟",
"排序",
"哈希表"
] | 给定一个 $24$ 小时制(小时:分钟 `"HH:MM"`)的时间列表,找出列表中任意两个时间的最小时间差并以分钟数表示。
示例 1:
```
输入:timePoints = ["23:59","00:00"]
输出:1
```
示例 2:
```
输入:timePoints = ["00:00","23:59","00:00"]
输出:0
```
提示:
* $2 <= timePoints <= 2 * 10^4$
* `timePoints[i]` 格式为 `"HH:MM"` | ### 模拟(排序)
根据题意,我们需要找出「时钟盘」中的夹角最小的两个时间点,其中包括了分布在 `00:00` 左右两侧(横跨了一天)的时间点。
因此,一种简单的方式是对于每个 $timePoints[i]$,我们不仅记录「当天该时间点」对应的的偏移量,还记录「下一天该时间点」对应的偏移量。
处理所有的 $timePoints[i]$ 后,对偏移量进行排序,遍历找到所有相邻元素之间的最小值。
**代码(感谢 [@Benhao](/u/himymben/) 和 [@🍭可乐可乐吗](/u/littletime_cc/) 同学提供的其他语言版本):**
```Java
class Solution {
public i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.539` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/531-540/540. 有序数组中的单一元素（中等）.md | 540. 有序数组中的单一元素 | https://leetcode-cn.com/problems/single-element-in-a-sorted-array/solution/gong-shui-san-xie-er-duan-xing-fen-xi-yu-17nv/ | 中等 | [
"二分",
"异或"
] | 给你一个仅由整数组成的有序数组,其中每个元素都会出现两次,唯有一个数只会出现一次。
请你找出并返回只出现一次的那个数。
你设计的解决方案必须满足 $O(\log n)$ 时间复杂度和 $O(1)$ 空间复杂度。
示例 1:
```
输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2
```
示例 2:
```
输入: nums = [3,3,7,7,10,11,11]
输出: 10
```
提示:
* $1 <= nums.length <= 10^5$
* $0 <= nums[i] <= 10^5$ | ### 遍历
数据范围为 $10^5$,最简单的方法是以「步长为 $2$」的方式进行从前往后的遍历,找到第一个不符合「与后一个数相等」条件的值即是答案。
或是利用单个元素只有一个(其余成对出现),从头到尾异或一遍,最终结果为单一元素值。
代码:
```Java
class Solution {
public int singleNonDuplicate(int[] nums) {
int n = nums.length;
for (int i = 0; i < n - 1; i += 2) {
if (nums[i] != nums[i + 1]) return ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.540` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/541-550/541. 反转字符串 II（简单）.md | 541. 反转字符串 II | https://leetcode-cn.com/problems/reverse-string-ii/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-p88f/ | 简单 | [
"模拟"
] | 给定一个字符串 s 和一个整数 k,从字符串开头算起,每 2k 个字符反转前 k 个字符。
* 如果剩余字符少于 k 个,则将剩余字符全部反转。
* 如果剩余字符小于 2k 但大于或等于 k 个,则反转前 k 个字符,其余字符保持原样。
示例 1:
```
输入:s = "abcdefg", k = 2
输出:"bacdfeg"
```
示例 2:
```
输入:s = "abcd", k = 2
输出:"bacd"
```
提示:
* 1 <= s.length <= $10^4$
* s 仅由小写英文组成
* 1 <= k <= $10^4$ | ### 模拟
使用 `l` 和 `r` 两个指针分别圈出每次需要翻转的“理论”范围,每次翻转完更新 `l` 和 `r`,同时注意范围 $[l, r]$ 内不足 $k$ 个的情况(将 `r` 与真实边界 `n - 1`取个 $min$)。
代码:
```Java
class Solution {
public String reverseStr(String s, int k) {
char[] cs = s.toCharArray();
int n = s.length();
for (int l = 0; l < n; l = l + 2 * k) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.541` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/541-550/543. 二叉树的直径（简单）.md | 543. 二叉树的直径 | https://leetcode.cn/problems/diameter-of-binary-tree/solutions/2454405/gong-shui-san-xie-jian-dan-dfs-yun-yong-vbf27/ | 简单 | [
"二叉树",
"DFS"
] | 给你一棵二叉树的根节点,返回该树的直径。
二叉树的直径是指树中任意两个节点之间最长路径的长度。
这条路径可能经过也可能不经过根节点 `root`。
两节点之间路径的长度由它们之间边数表示。
示例 1:
```
输入:root = [1,2,3,4,5]
输出:3
解释:3 ,取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
```
示例 2:
```
输入:root = [1,2]
输出:1
```
提示:
* 树中节点数目在范围 $[1, 10^4]$ 内
* $-100 <= Node.val <= 100$ | ### DFS
定义全局变量 `ans`(初始化为 `0`),用于记录二叉树的最大直径。
设计用于遍历二叉树的 `DFS` 函数:函数传入当前节点 `u`,返回以该节点为根时,方向“往下”的最大路径节点数量(注意这里是点数,而不是题目要求的边数)。
单次执行流程中,先递归处理当前节点 `u` 的左右节点,得到左右子树为根时的“往下”最大路径 `l` 和 `r`,两者中的较大值 `+1` 即是本次执行流程的返回值(`+1` 的含义是在子路径基础上增加当前节点)。
同时,`l + r` 则是以当前节点 `u` 为路径最高点时的路径长度,用此更新全局 `ans` 即可。
Java 代码:
```Java
class Soluti... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.543` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/551. 学生出勤记录 I（简单）.md | 551. 学生出勤记录 I | https://leetcode-cn.com/problems/student-attendance-record-i/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-hui7/ | 简单 | [
"模拟"
] | 给你一个字符串 s 表示一个学生的出勤记录,其中的每个字符用来标记当天的出勤情况(缺勤、迟到、到场)。记录中只含下面三种字符:
* 'A':Absent,缺勤
* 'L':Late,迟到
* 'P':Present,到场
如果学生能够 同时 满足下面两个条件,则可以获得出勤奖励:
按 总出勤 计,学生缺勤('A')严格 少于两天。
学生 不会 存在 连续 3 天或 3 天以上的迟到('L')记录。
如果学生可以获得出勤奖励,返回 true ;否则,返回 false 。
示例 1:
```
输入:s = "PPALLP"
输出:true
解释:学生缺勤次数少于 2 次,且不存在 3 天或以上的连续迟到记录。
```
示例 2... | ### 模拟
放大假,根据题意进行模拟即可。
代码:
```Java
class Solution {
public boolean checkRecord(String s) {
int n = s.length();
char[] cs = s.toCharArray();
for (int i = 0, cnt = 0; i < n; ) {
char c = cs[i];
if (c == 'A') {
cnt++;
if (cnt >= 2) retur... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.551` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/552. 学生出勤记录 II（困难）.md | 552. 学生出勤记录 II | https://leetcode-cn.com/problems/student-attendance-record-ii/solution/gong-shui-san-xie-yi-ti-san-jie-ji-yi-hu-fdfx/ | 困难 | [
"动态规划",
"状态机",
"记忆化搜索",
"矩阵快速幂",
"数学"
] | 可以用字符串表示一个学生的出勤记录,其中的每个字符用来标记当天的出勤情况(缺勤、迟到、到场)。
记录中只含下面三种字符:
* 'A':Absent,缺勤
* 'L':Late,迟到
* 'P':Present,到场
如果学生能够**同时**满足下面两个条件,则可以获得出勤奖励:
* 按**总出勤**计,学生缺勤('A')严格 少于两天。
* 学生**不会**存在 连续 3 天或 连续 3 天以上的迟到('L')记录。
给你一个整数 n ,表示出勤记录的长度(次数)。请你返回记录长度为 n 时,可能获得出勤奖励的记录情况 数量 。
答案可能很大,所以返回对 $10^9 + 7$ **取余**的结果。
示例 1:
```
... | ### 基本分析
根据题意,我们知道一个合法的方案中 `A` 的总出现次数最多为 $1$ 次,`L` 的连续出现次数最多为 $2$ 次。
**因此在枚举/统计合法方案的个数时,当我们决策到某一位应该选什么时,我们关心的是当前方案中已经出现了多少个 `A`(以决策当前能否填入 `A`)以及连续出现的 `L` 的次数是多少(以决策当前能否填入 `L`)。**
---
### 记忆化搜索
枚举所有方案的爆搜 `DFS` 代码不难写,大致的函数签名设计如下:
```Java
/**
* @param u 当前还剩下多少位需要决策
* @param acnt 当前方案中 A 的总出现次数
* @param lcnt 当前方案... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.552` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/553. 最优除法（中等）.md | 553. 最优除法 | https://leetcode-cn.com/problems/optimal-division/solution/gong-shui-san-xie-shu-xue-lei-tan-xin-yu-61sq/ | 中等 | [
"贪心",
"数学"
] | 给定一组正整数,相邻的整数之间将会进行浮点除法操作。例如, [2,3,4] -> 2 / 3 / 4 。
但是,你可以在任意位置添加任意数目的括号,来改变算数的优先级。你需要找出怎么添加括号,才能得到最大的结果,并且返回相应的字符串格式的表达式。你的表达式不应该含有冗余的括号。
示例:
```
输入: [1000,100,10,2]
输出: "1000/(100/10/2)"
解释:
1000/(100/10/2) = 1000/((100/10)/2) = 200
但是,以下加粗的括号 "1000/((100/10)/2)" 是冗余的,
因为他们并不影响操作的优先级,所以你需要返回 "1000/(100/10/2)"。
... | ### 数学 + 贪心
我们假定取得最优解的表示为 $\frac{a}{b}$,可以留意到任意的 $nums[i]$ 的范围为 $[2, 1000]$,因此我们应当让尽可能多的 $nums[i]$ 参与 $a$(分子)的构建中。
因此一种可以构成最优表示的方式为「将除第一位以外的所有数作为一组,进行连除(转乘法),从而将所有 **可以** 变成分子的数都参与到 $a$ 的构建中」。
即有:
$$
\frac{nums[0]}{nums[1] / nums[2] / ... / nums[n - 1]} = \frac{nums[0]}{nums[1] * \frac{1}{nums[2]} * ... * \frac{1}{n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.553` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/554. 砖墙（中等）.md | 554. 砖墙 | https://leetcode-cn.com/problems/brick-wall/solution/gong-shui-san-xie-zheng-nan-ze-fan-shi-y-gsri/ | 中等 | [
"哈希表"
] | 你的面前有一堵矩形的、由 n 行砖块组成的砖墙。
这些砖块高度相同(也就是一个单位高)但是宽度不同。每一行砖块的宽度之和相等。
你现在要画一条 自顶向下 的、穿过 最少 砖块的垂线。
如果你画的线只是从砖块的边缘经过,就不算穿过这块砖。
你不能沿着墙的两个垂直边缘之一画线,这样显然是没有穿过一块砖的。
给你一个二维数组 wall ,该数组包含这堵墙的相关信息。
其中,wall[i] 是一个代表从左至右每块砖的宽度的数组。
你需要找出怎样画才能使这条线 穿过的砖块数量最少 ,并且返回 穿过的砖块数量 。
示例 1:
```
输入:wall = [[1,2,2,1],[3,1,2],[1,3,2],[2,4],[... | ### 哈希表
题目要求穿过的砖块数量最少,等效于通过的间隙最多。
**我们可以使用「哈希表」记录每个间隙的出现次数,最终统计所有行中哪些间隙出现得最多,使用「总行数」减去「间隙出现的最多次数」即是答案。**
如何记录间隙呢?直接使用行前缀记录即可。
就用示例数据来举 🌰 :
* 第 1 行的间隙有 `[1,3,5]`
* 第 2 行的间隙有 `[3,4]`
* 第 3 行的间隙有 `[1,4]`
* 第 4 行的间隙有 `[2]`
* 第 5 行的间隙有 `[3,4]`
* 第 6 行的间隙有 `[1,4,5]`
对间隙计数完成后,遍历「哈希表」找出出现次数最多间隙 `4`,根据同一个间隙编号只会在单行内被统计一次,... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.554` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/556. 下一个更大元素 III（中等）.md | 556. 下一个更大元素 III | https://leetcode.cn/problems/next-greater-element-iii/solution/by-ac_oier-99bj/ | 中等 | [
"模拟",
"双指针"
] | 给你一个正整数 $n$,请你找出符合条件的最小整数,其由重新排列 $n$ 中存在的每位数字组成,并且其值大于 $n$。
如果不存在这样的正整数,则返回 $-1$ 。
注意 ,返回的整数应当是一个 $32$ 位整数 ,如果存在满足题意的答案,但不是 $32$ 位整数 ,同样返回 $-1$。
示例 1:
```
输入:n = 12
输出:21
```
示例 2:
```
输入:n = 21
输出:-1
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 模拟
根据题意,只有给定数字 $x$ 本身从高位到低位是「非严格降序」时,我们无法找到一个合法值。
首先,我们可以先对 $x$ 诸位取出,存成 `nums` 数组(数组的首位元素为原数 $x$ 的最低位)。
然后尝试找到第一个能够交换的位置 `idx`(若无法找到,说明不存在合法值,返回 $-1$),即从 $nums[0]$(原始 $x$ 的最低位)开始找,找到第一个「降序」的位置 `idx`,然后从 $[0, idx)$ 范围内找一个比 $nums[idx]$ 要大的最小数与其进行互换,也是从 $nums[0]$ 开始找,找到第一个满足比 $nums[idx]$ 大的数。
当互换完成后,此时比 $x$ 要大这一目标... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.556` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/558. 四叉树交集（中等）.md | 558. 四叉树交集 | https://leetcode.cn/problems/logical-or-of-two-binary-grids-represented-as-quad-trees/solution/by-ac_oier-2ri3/ | 中等 | [
"递归"
] | 二进制矩阵中的所有元素不是 $0$ 就是 $1$ 。
给你两个四叉树,`quadTree1` 和 `quadTree2`。
其中 `quadTree1` 表示一个 $n \times n$ 二进制矩阵,而 `quadTree2` 表示另一个 $n \times n$ 二进制矩阵。
请你返回一个表示 $n \times n$ 二进制矩阵的四叉树,它是 `quadTree1` 和 `quadTree2` 所表示的两个二进制矩阵进行 按位逻辑或运算 的结果。
注意,当 `isLeaf` 为 `False` 时,你可以把 `True` 或者 `False` 赋值给节点,两种值都会被判题机制 接受 。
四叉树数据结构中,每个内部节点... | ### 递归
为了方便,我们令 `quadTree1` 为 `t1`,令 `quadTree2` 为 `t2`。
根据题意,并利用给定函数作为递归函数,当 `t1` 和 `t2` 均为叶子节点数时,执行「与逻辑」,即若 `t1` 和 `t2` 任一值为 $1$ 时,返回该节点,否则(两者均为 $0$),返回任一节点。
然后考虑其他情况下,如何使用 `t1` 和 `t2` 构造新节点 `ans`,分别使用对应位置的进行「递归」构造即可(即使用 `t1.topLeft` 和 `t2.topLeft` 来赋值给 `ans.topLeft`,其余位置同理),要注意可能存在 `t1` 或 `t2` 其中一节点为叶子节点的情况,此时应当使... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.558` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/559. N 叉树的最大深度（简单）.md | 559. N 叉树的最大深度 | https://leetcode-cn.com/problems/brick-wall/solution/gong-shui-san-xie-zheng-nan-ze-fan-shi-y-gsri/ | 简单 | [
"DFS",
"BFS"
] | 给定一个 `N` 叉树,找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
`N` 叉树输入按层序遍历序列化表示,每组子节点由空值分隔(请参见示例)。
示例 1:
```
输入:root = [1,null,3,2,4,null,5,6]
输出:3
```
示例 2:
```
输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:5
```
提示:
* 树的深度不会超过 1000 。
* 树的节点数目位于 $[0, 10^4]$ 之间。 | ### DFS
根据题意,可以写出如下的 `DFS` 实现:从 $root$ 的所有子节点中的取最大深度,并在此基础上加一(统计 $root$ 节点)即是答案。
代码:
```Java
class Solution {
public int maxDepth(Node root) {
if (root == null) return 0;
int ans = 0;
for (Node node : root.children) {
ans = Math.max(ans, maxDepth(node));
}
retur... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.559` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/551-560/560. 和为 K 的子数组（中等）.md | 560. 和为 K 的子数组 | https://leetcode.cn/problems/subarray-sum-equals-k/solution/by-ac_oier-pttu/ | 中等 | [
"前缀和",
"哈希表"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,请你统计并返回该数组中和为 `k` 的子数组的个数 。
示例 1:
```
输入:nums = [1,1,1], k = 2
输出:2
```
示例 2:
```
输入:nums = [1,2,3], k = 3
输出:2
```
提示:
* $1 <= nums.length <= 2 \times 10^4$
* $-1000 <= nums[i] <= 1000$
* $-10^7 <= k <= 10^7$ | ### 前缀和 + 哈希表
这是一道经典的前缀和运用题。
统计以每一个 $nums[i]$ 为结尾,和为 $k$ 的子数组数量即是答案。
我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于求解以某一个 $nums[i]$ 为结尾的,和为 $k$ 的子数组数量,本质上是求解在 $[0, i]$ 中,`sum` 数组中有多少个值为 $sum[i + 1] - k$ 的数,这可以在遍历过程中使用「哈希表」进行同步记录。
Java 代码:
```Java
class Solution {
public int subarraySum(int[] nums, int k) {
in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.560` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/561-570/561. 数组拆分 I（简单）.md | 561. 数组拆分 I | https://leetcode-cn.com/problems/array-partition-i/solution/jue-dui-neng-kan-dong-de-zheng-ming-fan-f7trz/ | 简单 | [
"贪心"
] | 给定长度为 $2 \times n$ 的整数数组 `nums `,你的任务是将这些数分成 `n` 对, 例如 $(a_1, b_1), (a_2, b_2), ..., (a_n, b_n)$ ,使得从 `1` 到 `n` 的 $min(a_i, b_i)$ 总和最大。
返回该 最大总和 。
示例 1:
```
输入:nums = [1,4,3,2]
输出:4
解释:所有可能的分法(忽略元素顺序)为:
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1... | ### 贪心解法
我们先对数组进行排序。
由于每两个数,我们只能选择当前小的一个进行累加。
因此我们猜想应该从第一个位置进行选择,然后隔一步选择下一个数。这样形成的序列的求和值最大。
```java
class Solution {
public int arrayPairSum(int[] nums) {
int n = nums.length;
Arrays.sort(nums);
int ans = 0;
for (int i = 0; i < n; i += 2) ans += nums[i];
return ans;
}... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.561` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/561-570/563. 二叉树的坡度（简单）.md | 563. 二叉树的坡度 | https://leetcode-cn.com/problems/binary-tree-tilt/solution/gong-shui-san-xie-jian-dan-er-cha-shu-di-ekz4/ | 简单 | [
"二叉树",
"DFS"
] | 给定一个二叉树,计算**整个树**的坡度 。
一个树的 节点的坡度 定义即为,该节点左子树的节点之和和右子树节点之和的 差的绝对值 。
如果没有左子树的话,左子树的节点之和为 $0$ ;没有右子树的话也是一样。空结点的坡度是 $0$ 。
整个树 的坡度就是其所有节点的坡度之和。
示例 1:
```
输入:root = [1,2,3]
输出:1
解释:
节点 2 的坡度:|0-0| = 0(没有子节点)
节点 3 的坡度:|0-0| = 0(没有子节点)
节点 1 的坡度:|2-3| = 1(左子树就是左子节点,所以和是 2 ;右子树就是右子节点,所以和是 3 )
坡度总和:0 + 0 + 1 = 1
```
示例 2:... | ### 递归
根据题目对「坡度」的定义,我们可以直接写出对应的递归实现。
代码:
```Java
class Solution {
public int findTilt(TreeNode root) {
if (root == null) return 0;
return findTilt(root.left) + findTilt(root.right) + Math.abs(getSum(root.left) - getSum(root.right));
}
int getSum(TreeNode root) {
if (root == null) r... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.563` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/561-570/564. 寻找最近的回文数（困难）.md | 564. 寻找最近的回文数 | https://leetcode-cn.com/problems/find-the-closest-palindrome/solution/gong-shui-san-xie-tan-xin-fen-xi-shang-x-vtr6/ | 困难 | [
"贪心",
"脑筋急转弯"
] | 给定一个表示整数的字符串 $n$ ,返回与它最近的回文整数(不包括自身)。如果不止一个,返回较小的那个。
“最近的”定义为两个整数差的绝对值最小。
示例 1:
```
输入: n = "123"
输出: "121"
```
示例 2:
```
输入: n = "1"
输出: "0"
解释: 0 和 2是最近的回文,但我们返回最小的,也就是 0。
```
提示:
* $1 <= n.length <= 18$
* $n$ 只由数字组成
* $n$ 不含前导 $0$
* $n$ 代表在 $[1, 10^{18} - 1]$ 范围内的整数 | ### 上下界分析 + 边界处理
对于任意字符串数值 $s$ 而言(令其长度为 $n$),先考虑如何找到「第一个比其大」和「第一个比其小」的回文串数值(上下界)。
由于是找「最近」的数值,因此一个自然的想法是优先修改低位数字,但由于回文串本身的对称性质,每个「低位」的修改带来的副作用是需要同时修改对应的「高位」,因此一个真正可以修改的位置是(相对)中间的位置。
举个 🌰,对于长度为奇数回文串数值 $abcde$,其中 $de$ 的修改会导致 $ab$ 同步修改,因此最近一个可以修改的低位是 $c$;对于长度为偶数的回文串数值 $abcd$ 而言,其中 $d$ 的修改会导致 $a$ 同步修改,因此最近一个可以修改的位置是 $b... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.564` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/561-570/565. 数组嵌套（中等）.md | 565. 数组嵌套 | https://leetcode-cn.com/problems/find-the-closest-palindrome/solution/gong-shui-san-xie-tan-xin-fen-xi-shang-x-vtr6/ | 中等 | [
"模拟"
] | 索引从 $0$ 开始长度为 `N` 的数组 `A`,包含 $0$ 到 $N - 1$ 的所有整数。找到最大的集合 `S` 并返回其大小,其中 $S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }$ 且遵守以下的规则。
假设选择索引为 `i` 的元素 $A[i]$ 为 `S` 的第一个元素,`S` 的下一个元素应该是 $A[A[i]]$,之后是 $A[A[A[i]]]$ ... 以此类推,不断添加直到 `S` 出现重复的元素。
示例 1:
```
输入: A = [5,4,0,3,1,6,2]
输出: 4
解释:
A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A... | ### 模拟
将 $A[i]$ 与 $A[A[i]]$ 之间看作存在一条有向边,由于所有数范围都在 $[0, N - 1]$,且不重复,因此至少存在一个环,而问题本质是求所有环的最大长度。
直接根据题意记进行模拟即可,从前往后处理每个 $nums[i]$,并尝试从 $nums[i]$ 出发遍历其所在的环,为了防止某些环被重复处理,对于当前经过的 $nums[i]$ 标记为 $-1$,这样每个数被访问的次数最多不超过 $3$ 次,整体复杂度为 $O(n)$。
Java 代码:
```Java
class Solution {
public int arrayNesting(int[] nums) {
in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.565` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/561-570/566. 重塑矩阵（简单）.md | 566. 重塑矩阵 | https://leetcode-cn.com/problems/reshape-the-matrix/solution/jian-dan-ti-zhong-quan-chu-ji-ke-yi-kan-79gv5/ | 简单 | [
"模拟"
] | 在 MATLAB 中,有一个非常有用的函数 `reshape`,它可以将一个矩阵重塑为另一个大小不同的新矩阵,但保留其原始数据。
给出一个由二维数组表示的矩阵,以及两个正整数 `r` 和 `c`,分别表示想要的重构的矩阵的行数和列数。
重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。
如果具有给定参数的 `reshape` 操作是可行且合理的,则输出新的重塑矩阵;否则,输出原始矩阵。
示例 1:
```
输入:
nums =
[[1,2],
[3,4]]
r = 1, c = 4
输出:
[[1,2,3,4]]
解释:
行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前... | ### 模拟
按照题意,从头模拟一遍即可。
使用 $idx$ 记录新矩阵当前分配到的位置(一维),利用通用的一维转二维方式对应回行列坐标即可。
代码:
```Java
class Solution {
public int[][] matrixReshape(int[][] nums, int r, int c) {
int or = nums.length, oc = nums[0].length;
if (or * oc != r * c) return nums;
int[][] ans = new int[r][c];
for (int i = 0... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.566` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/561-570/567. 字符串的排列（中等）.md | 567. 字符串的排列 | https://leetcode-cn.com/problems/permutation-in-string/solution/an-zi-fu-hua-dong-ruo-bao-liao-lai-shi-s-h2xq/ | 中等 | [
"滑动窗口"
] | 给定两个字符串 s1 和 s2,写一个函数来判断 s2 是否包含 s1 的排列。
换句话说,第一个字符串的排列之一是第二个字符串的 子串 。
示例 1:
```
输入: s1 = "ab" s2 = "eidbaooo"
输出: True
解释: s2 包含 s1 的排列之一 ("ba").
```
示例 2:
```
输入: s1= "ab" s2 = "eidboaoo"
输出: False
```
提示:
* 输入的字符串只包含小写字母
* 两个字符串的长度都在 [1, 10,000] 之间 | ### 滑动窗口
由于是 `s2` 中判断是否包含 `s1` 的排列,而且 `s1` 和 `s2` 均为小数。
可以使用数组先对 `s1` 进行统计,之后使用滑动窗口进行扫描,每滑动一次检查窗口内的字符频率和 `s1` 是否相等 ~
以下代码,可以作为滑动窗口模板使用:
**PS. 你会发现以下代码和 [643. 子数组最大平均数 I](https://leetcode-cn.com/problems/maximum-average-subarray-i/) 和 [1423. 可获得的最大点数](https://leetcode-cn.com/problems/maximum-points-you-can-obtain-f... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.567` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/571-580/575. 分糖果（简单）.md | 575. 分糖果 | https://leetcode-cn.com/problems/distribute-candies/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-pjjxo/ | 简单 | [
"贪心"
] | 给定一个偶数长度的数组,其中不同的数字代表着不同种类的糖果,每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。
返回妹妹可以获得的最大糖果的种类数。
示例 1:
```
输入: candies = [1,1,2,2,3,3]
输出: 3
解析: 一共有三种种类的糖果,每一种都有两个。
最优分配方案:妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。
```
示例 2 :
```
输入: candies = [1,1,2,3]
输出: 2
解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1],妹妹有两种不同的糖果,弟弟只有一种。这样使得妹妹可以获得的糖果种类数... | ### 贪心
由于题目规定糖果数量 $n$ 为偶数,因此一定能将糖果平均分配成两份,每份数量固定为 $\frac{n}{2}$。
假设糖果种类数量为 $m$,那么单份中可使得糖果种类数量最大为 $\min(m, \frac{n}{2})$。
可以使用「分情况讨论」进行证明:
1. $m > \frac{n}{2}$:糖果种类大于单份的糖果数量。此时可以从 $m$ 类糖果中找出 $\frac{n}{2}$ 类不同的糖果组成单份,此时可取得的最大种类数量为 $\frac{n}{2}$;
2. $m = \frac{n}{2}$:糖果种类等于单份的糖果数量。同理,此时可以从 $m$ 类糖果中找出 $\frac{n}{2}$ 类不... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.575` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/571-580/576. 出界的路径数（中等）.md | 576. 出界的路径数 | https://leetcode-cn.com/problems/out-of-boundary-paths/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-asrz/ | 中等 | [
"路径 DP",
"动态规划",
"记忆化搜索"
] | 给你一个大小为 m x n 的网格和一个球。球的起始坐标为 [startRow, startColumn] 。
你可以将球移到在四个方向上相邻的单元格内(可以穿过网格边界到达网格之外)。
你**最多**可以移动 maxMove 次球。
给你五个整数 m、n、maxMove、startRow 以及 startColumn ,找出并返回可以将球移出边界的路径数量。
因为答案可能非常大,返回对 $10^9 + 7$ 取余 后的结果。
示例 1:
```
输入:m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
输出:6
```
示例 2:
```
输入:m =... | ### 基本分析
通常来说,朴素的路径 DP 问题之所以能够使用常规 DP 方式进行求解,是因为只能往某一个方向(一维棋盘的路径问题)或者只能往某两个方向(二维棋盘的路径问题)移动。
这样的移动规则意味着,我们不会重复进入同一个格子。
**从图论的意义出发:将每个格子视为点的话,如果能够根据移动规则从 `a` 位置一步到达 `b` 位置,则说明存在一条由 `a` 指向 `b` 的有向边。**
**也就是说,在朴素的路径 DP 问题中,“单向”的移动规则注定了我们的图不存在环,是一个存在拓扑序的有向无环图,因此我们能够使用常规 DP 手段来求解。**
回到本题,移动规则是四联通,并不是“单向”的,在某条出界的路径中,我们是有... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.576` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/581-590/581. 最短无序连续子数组（中等）.md | 581. 最短无序连续子数组 | https://leetcode-cn.com/problems/shortest-unsorted-continuous-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shuan-e1le/ | 中等 | [
"排序",
"双指针"
] | 给你一个整数数组 `nums` ,你需要找出一个 连续子数组 ,如果对这个子数组进行升序排序,那么整个数组都会变为升序排序。
请你找出符合题意的 最短 子数组,并输出它的长度。
示例 1:
```
输入:nums = [2,6,4,8,10,9,15]
输出:5
解释:你只需要对 [6, 4, 8, 10, 9] 进行升序排序,那么整个表都会变为升序排序。
```
示例 2:
```
输入:nums = [1,2,3,4]
输出:0
```
示例 3:
```
输入:nums = [1]
输出:0
```
提示:
* $1 <= nums.length <= 10^4$
* $-10^5 <= nums[i] <= ... | ### 双指针 + 排序
最终目的是让整个数组有序,那么我们可以先将数组拷贝一份进行排序,然后使用两个指针 $i$ 和 $j$ 分别找到左右两端第一个不同的地方,那么 $[i, j]$ 这一区间即是答案。
代码:
```Java
class Solution {
public int findUnsortedSubarray(int[] nums) {
int n = nums.length;
int[] arr = nums.clone();
Arrays.sort(arr);
int i = 0, j = n - 1;
while (i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.581` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/581-590/583. 两个字符串的删除操作（中等）.md | 583. 两个字符串的删除操作 | https://leetcode-cn.com/problems/delete-operation-for-two-strings/solution/gong-shui-san-xie-cong-liang-chong-xu-li-wqv7/ | 中等 | [
"最长公共子序列",
"序列 DP"
] | 给定两个单词 `s1` 和 `s2`,找到使得 `s1` 和 `s2` 相同所需的最小步数,每步可以删除任意一个字符串中的一个字符。
示例:
```
输入: "sea", "eat"
输出: 2
解释: 第一步将"sea"变为"ea",第二步将"eat"变为"ea"
```
提示:
* 给定单词的长度不超过 $500$。
* 给定单词中的字符只含有小写字母。 | ### 转换为 LCS 问题
首先,给定两字符 `s1` 和 `s2`,求经过多少次删除操作,可使得两个相等字符串。
该问题等价于求解两字符的「最长公共子序列」,若两者长度分别为 $n$ 和 $m$,而最长公共子序列长度为 $max$,则 $n - max + m - max$ 即为答案。
对「最长公共子序列(LCS)」不熟悉的同学,可以看 [(题解) 1143. 最长公共子序列](https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/)。
**$f[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.583` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/581-590/587. 安装栅栏（困难）.md | 587. 安装栅栏 | https://leetcode-cn.com/problems/erect-the-fence/solution/by-ac_oier-4xuu/ | 困难 | [
"计算几何",
"凸包"
] | 在一个二维的花园中,有一些用 $(x, y)$ 坐标表示的树。由于安装费用十分昂贵,你的任务是先用最短的绳子围起所有的树。只有当所有的树都被绳子包围时,花园才能围好栅栏。
你需要找到正好位于栅栏边界上的树的坐标。
示例 1:
```
输入: [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]
输出: [[1,1],[2,0],[4,2],[3,3],[2,4]]
```
示例 2:
```
输入: [[1,2],[2,2],[4,2]]
输出: [[1,2],[2,2],[4,2]]
解释:即使树都在一条直线上,你也需要先用绳子包围它们。
```
注意:
* 所有的树应当被围在一起。你不能剪... | ### 二维凸包(Andrew 算法)
这是一道「二维凸包」板子题,需要注意的是网上大多数 `Andrew` 算法的板子都是有问题的(下面会说)。
`Andrew` 算法正是用于求解凸包上的所有点(围成所有点的最小周长),其算法逻辑将凸包分为「上凸壳」和「下凸壳」,并分别画出(蓝色分割线将凸包分为两部分):
基本流程为:
1. 对所有点进行双关键字排序,先根据 $x$ 坐标排升序,后根据 $y$ 排升序;
根据 $x$ 排升序的目的,是为了我们能够往一个方向画出凸包边缘(从左往后画出一半凸壳,从右往左画出另外一半),而将 $y$ 升序目的是可以确保一旦我们现在从 $a$ 到 $b$ 进行连线,那么 $a$ 到 $b$... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.587` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/581-590/589. N 叉树的前序遍历（简单）.md | 589. N 叉树的前序遍历 | https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/solution/gong-shui-san-xie-shu-de-sou-suo-yun-yon-pse1/ | 简单 | [
"树的搜索",
"递归",
"迭代"
] | 给定一个 $n$ 叉树的根节点 $root$ ,返回 其节点值的 前序遍历 。
$n$ 叉树 在输入中按层序遍历进行序列化表示,每组子节点由空值 `null` 分隔(请参见示例)。
示例 1:
```
输入:root = [1,null,3,2,4,null,5,6]
输出:[1,3,5,6,2,4]
```
示例 2:
```
输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:[1,2,3,6,7,11,14,4,8,12,5,9,13,10]
```
提示:
... | ### 递归
常规做法,不再赘述。
代码:
```Java
class Solution {
List<Integer> ans = new ArrayList<>();
public List<Integer> preorder(Node root) {
dfs(root);
return ans;
}
void dfs(Node root) {
if (root == null) return ;
ans.add(root.val);
for (Node node : root.children) dfs(node... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.589` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/581-590/590. N 叉树的后序遍历（简单）.md | 590. N 叉树的后序遍历 | https://leetcode-cn.com/problems/n-ary-tree-postorder-traversal/solution/by-ac_oier-ul7t/ | 简单 | [
"递归",
"迭代",
"非递归",
"DFS",
"BFS"
] | 给定一个 $n$ 叉树的根节点 $root$ ,返回 其节点值的**后序遍历**。
$n$ 叉树在输入中按层序遍历进行序列化表示,每组子节点由空值 `null` 分隔(请参见示例)。
示例 1:
```
输入:root = [1,null,3,2,4,null,5,6]
输出:[5,6,3,2,4,1]
```
示例 2:
```
输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:[2,6,14,11,7,3,12,8,4,13,9,10,5,1]
```
提示:... | ### 递归
常规做法,不再赘述。
Java 代码:
```Java
class Solution {
List<Integer> ans = new ArrayList<>();
public List<Integer> postorder(Node root) {
dfs(root);
return ans;
}
void dfs(Node root) {
if (root == null) return;
for (Node node : root.children) dfs(node);
ans.add(roo... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.590` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/591-600/591. 标签验证器（困难）.md | 591. 标签验证器 | https://leetcode-cn.com/problems/tag-validator/solution/by-ac_oier-9l8z/ | 困难 | [
"模拟",
"栈"
] | 给定一个表示代码片段的字符串,你需要实现一个验证器来解析这段代码,并返回它是否合法。合法的代码片段需要遵守以下的所有规则:
1. 代码必须被合法的闭合标签包围。否则,代码是无效的。
2. 闭合标签(不一定合法)要严格符合格式:`<TAG_NAME>TAG_CONTENT</TAG_NAME>`。其中,`<TAG_NAME>` 是起始标签,`</TAG_NAME>` 是结束标签。起始和结束标签中的 `TAG_NAME` 应当相同。当且仅当 `TAG_NAME` 和 `TAG_CONTENT` 都是合法的,闭合标签才是合法的。
3. 合法的 `TAG_NAME` 仅含有大写字母,长度在范围 $[1,9]$ 之间。否则,该 `TAG_N... | ### 模拟(栈)
字符串大模拟,假设字符串 `s` 长度为 $n$,当前处理到的位置为 $i$,根据以下优先级进行检查:
1. 优先尝试检查以 $i$ 为开始的连续段是否为 `CDATA`,若能匹配到开头,则尝试匹配到 `CDATA` 的结尾处,并更新 $i$,若无法找到结尾,返回 `False`;
2. 尝试匹配 $s[i]$ 是否为 `<`,若满足,则根据 $s[i + 1]$ 是否为 `/` 来判断当前 `TAG_NAME` 是处于右边还是左边,然后将 `TAG_NAME` 取出,记为 $tag$,判断 $tag$ 长度是否合法,不合法返回 `False`,合法则根据是左边还是右边的 `TAG_NAME` 分情况讨论:
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.591` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/591-600/592. 分数加减运算（中等）.md | 592. 分数加减运算 | https://leetcode.cn/problems/fraction-addition-and-subtraction/solution/by-ac_oier-rmpy/ | 中等 | [
"表达式计算",
"模拟"
] | 给定一个表示分数加减运算的字符串 `expression`,你需要返回一个字符串形式的计算结果。
这个结果应该是不可约分的分数,即最简分数。 如果最终结果是一个整数,例如 $2$,你需要将它转换成分数形式,其分母为 $1$。所以在上述例子中, $2$ 应该被转换为 `2/1`。
示例 1:
```
输入: expression = "-1/2+1/2"
输出: "0/1"
```
示例 2:
```
输入: expression = "-1/2+1/2+1/3"
输出: "1/3"
```
示例 3:
```
输入: expression = "1/3-1/2"
输出: "-1/6"
```
提示:
* 输入和输出字符... | ### 表达式计算
为了方便,令 `expression` 为 `s`。
由于给定的表达式中只有 `+` 和 `-`,因此无须考虑优先级问题,直接从前往后计算即可。
使用变量 `ans` 代指计算过程中的结果,从前往后处理表达式 `s`,每次以 `±分子/分母` 的形式取出当前操作数(若为表达式的首个操作数,且为正数时,需要手动补一个 `+`)。
假设当前取出的操作数为 `num`,根据 `ans` 的情况进行运算:
* 若 `ans` 为空串,说明 `num` 是首个操作数,直接将 `num` 赋值给 `ans` 即可
* 若 `ans` 不为空串,此时计算 `num` 和 `ans` 的计算结果赋值给 `ans`
考... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.592` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/591-600/593. 有效的正方形（中等）.md | 593. 有效的正方形 | https://leetcode.cn/problems/valid-square/solution/by-ac_oier-lwdf/ | 中等 | [
"模拟",
"数学",
"计算几何"
] | 给定 `2D` 空间中四个点的坐标 `p1`, `p2`, `p3` 和 `p4`,如果这四个点构成一个正方形,则返回 `true` 。
点的坐标 `pi` 表示为 $[x_i, y_i]$ 。输入 不是 按任何顺序给出的。
一个 有效的正方形 有四条等边和四个等角(`90`度角)。
示例 1:
```
输入: p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,1]
输出: True
```
示例 2:
```
输入:p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,12]
输出:false
```
示例 3:
```
输入:p1 = [1,0],... | ### 计算几何
根据题意进行模拟即可。
从给定的 $4$ 个顶点中选 $3$ 个顶点,检查其能否形成「直角三角形」,同时保存下来首个直角三角形的直角边边长,供后续其余直角三角形进行对比(注意不能共点,即直角边长不能为 $0$)。
Java 代码:
```Java
class Solution {
long len = -1;
public boolean validSquare(int[] a, int[] b, int[] c, int[] d) {
return calc(a, b, c) && calc(a, b, d) && calc(a, c, d) && calc(b, c, d)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.593` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/591-600/594. 最长和谐子序列（简单）.md | 594. 最长和谐子序列 | https://leetcode-cn.com/problems/longest-harmonious-subsequence/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-quuh/ | 简单 | [
"模拟",
"双指针",
"滑动窗口",
"哈希表"
] | 和谐数组是指一个数组里元素的最大值和最小值之间的差别 **正好是 $1$**。
现在,给你一个整数数组 $nums$ ,请你在所有可能的子序列中找到最长的和谐子序列的长度。
数组的子序列是一个由数组派生出来的序列,它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。
示例 1:
```
输入:nums = [1,3,2,2,5,2,3,7]
输出:5
解释:最长的和谐子序列是 [3,2,2,2,3]
```
示例 2:
```
输入:nums = [1,2,3,4]
输出:2
```
示例 3:
```
输入:nums = [1,1,1,1]
输出:0
```
提示:
* $1 <= nums.leng... | ### 排序 + 滑动窗口
一个直观的想法是,先对 $nums$ 进行排序,然后从前往后使用「双指针」实现「滑动窗口」进行扫描,统计所有符合条件的窗口长度,并在所有长度中取最大值即是答案。
代码:
```Java
class Solution {
public int findLHS(int[] nums) {
Arrays.sort(nums);
int n = nums.length, ans = 0;
for (int i = 0, j = 0; j < n; j++) {
while (i < j && nums[j] - nums[i] >... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.594` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/591-600/598. 范围求和 II（简单）.md | 598. 范围求和 II | https://leetcode-cn.com/problems/range-addition-ii/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-006h/ | 简单 | [
"模拟"
] | 给定一个初始元素全部为 $0$,大小为 $m*n$ 的矩阵 $M$ 以及在 $M$ 上的一系列更新操作。
操作用二维数组表示,其中的每个操作用一个含有两个正整数 $a$ 和 $b$ 的数组表示,含义是将所有符合 $0 <= i < a$ 以及 $0 <= j < b$ 的元素 $M[i][j]$ 的值都增加 $14。
在执行给定的一系列操作后,你需要返回矩阵中含有最大整数的元素个数。
示例 1:
```
输入:
m = 3, n = 3
operations = [[2,2],[3,3]]
输出: 4
解释:
初始状态, M =
[[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]
执行完操作 [... | ### 模拟
由于每次都是对 $0 \leq i < a$ 和 $0 \leq j < b$ 进行操作,因此每次操作都会包含点 $(0, 0)$,最后的最大值一定出现在位置 $(0, 0)$ 上。
问题转换为:什么范围内的数与位置 $(0, 0)$ 上的值相等,即什么范围会被每一次操作所覆盖。
不难发现,在所有的 $ops[i]$ 中的横纵坐标 $(x, y)$ 与左上角 $(0, 0)$ 形成的区域面积可确保被每次操作覆盖,$x * y$ 即是答案。
代码:
```Java
class Solution {
public int maxCount(int m, int n, int[][] ops) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.598` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/591-600/599. 两个列表的最小索引总和（简单）.md | 599. 两个列表的最小索引总和 | https://leetcode-cn.com/problems/minimum-index-sum-of-two-lists/solution/by-ac_oier-oh5b/ | 简单 | [
"哈希表",
"模拟"
] | 假设 Andy 和 Doris 想在晚餐时选择一家餐厅,并且他们都有一个表示最喜爱餐厅的列表,每个餐厅的名字用字符串表示。
你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。 如果答案不止一个,则输出所有答案并且不考虑顺序。 你可以假设答案总是存在。
示例 1:
```
输入: list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"],list2 = ["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"]
输出: ["Shogun"]
解释: 他们唯一共同喜爱的餐... | ### 哈希表
为了快速判断某个字符串是否在另外一个数组中出现,我们可以先使用「哈希表」对 `list1` 中的字符串进行处理,以 $(list1[i]: i)$ 键值对形式进行存储。
然后遍历 `list2`,判断每个 $list2[i]$ 是否在哈希表中出现过,同时维护一个当前的 **最小索引总和** $min$,以及 **用于存储能够取得最小索引总和的字符串数组** $ans$。
假设当前遍历到的元素是 $list2[i]$,根据「$list2[i]$ 是否在哈希表中出现」以及「当前索引和与 $min$ 的大小关系」分情况讨论:
* 如果 $list2[i]$ 不在哈希表中,跳过:
* 如果 $list2[i]$ 在哈... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.599` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/591-600/600. 不含连续1的非负整数（困难）.md | 600. 不含连续1的非负整数 | https://leetcode-cn.com/problems/non-negative-integers-without-consecutive-ones/solution/gong-shui-san-xie-jing-dian-shu-wei-dp-y-mh92/ | 困难 | [
"数位 DP"
] | 给定一个正整数 n,找出小于或等于 n 的非负整数中,其二进制表示不包含**连续的1**的个数。
示例 1:
```
输入: 5
输出: 5
解释:
下面是带有相应二进制表示的非负整数<= 5:
0 : 0
1 : 1
2 : 10
3 : 11
4 : 100
5 : 101
其中,只有整数3违反规则(有两个连续的1),其他5个满足规则。
```
说明: 1 <= n <= 109 | ### 数位 DP
这是一道典型的「数位 DP」题。
**对于「数位 DP」题,都存在「询问 $[a, b]$($a$ 和 $b$ 均为正整数,且 $a < b$)区间内符合条件的数值个数为多少」的一般形式,通常我们需要实现一个查询 $[0, x]$ 有多少合法数值的函数 `int dp(int x)`,然后应用「容斥原理」求解出 $[a, b]$ 的个数:$dp(b) - dp(a - 1)$。**
对于本题,虽然只需要求解 $[0, n]$ 范围内数的个数,但其实拓展到求 $[a, b]$ 区间个数的也不会增加难度。
具体的,对于「数位 DP」问题通常是「从高位到低位」的分情况讨论。
不失一般性的考虑数值 $n$ 的某... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.600` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/601-610/606. 根据二叉树创建字符串（简单）.md | 606. 根据二叉树创建字符串 | https://leetcode-cn.com/problems/construct-string-from-binary-tree/solution/by-ac_oier-i2sk/ | 简单 | [
"二叉树",
"DFS",
"递归",
"迭代",
"栈"
] | 你需要采用前序遍历的方式,将一个二叉树转换成一个由括号和整数组成的字符串。
空节点则用一对空括号 `"()"` 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。
示例 1:
```
输入: 二叉树: [1,2,3,4]
1
/ \
2 3
/
4
输出: "1(2(4))(3)"
解释: 原本将是“1(2(4)())(3())”,
在你省略所有不必要的空括号对之后,
它将是“1(2(4))(3)”。
```
示例 2:
```
输入: 二叉树: [1,2,3,null,4]
1
/ \
... | ### 递归
生成字符串的规则其实就是在「前序遍历」输出节点值的同时,在每颗子树的左右添加一对 `()`(根节点除外),同时需要忽略掉一些不必要的 `()` 。
所谓的不必要就是指当以某个节点 $x$ 为根时,其只「有左子树」而「没有右子树」时,右子树的 `()` 可被忽略,或者「左右子树都没有」时,两者的 `()` 可被忽略。
或者反过来说,如果对于每个非空节点才添加 `()` 的话,那么当「有右子树」同时「没有左子树」时,左子树的 `()` 不能被忽略,需要额外添加,从而确保生成出来的字符串能够与「有左子树」同时「没有右子树」的情况区分开来,而不会产生二义性。
代码:
```Java
class Solution {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.606` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/61-70/61. 旋转链表（中等）.md | 61. 旋转链表 | https://leetcode-cn.com/problems/rotate-list/solution/kuai-man-zhi-zhen-ru-he-fen-bu-zou-jie-j-ns7u/ | 中等 | [
"链表"
] | 给你一个链表的头节点 `head`,旋转链表,将链表每个节点向右移动 `k` 个位置。
示例 1:
```
输入:head = [1,2,3,4,5], k = 2
输出:[4,5,1,2,3]
```
示例 2:
```
输入:head = [0,1,2], k = 4
输出:[2,0,1]
```
提示:
* 链表中节点的数目在范围 $[0, 500]$ 内
* $-100 <= Node.val <= 100$
* $0 <= k <= 2 * 10^9$ | ### 快慢指针
本质还是道模拟题,分步骤处理即可:
* 避免不必要的旋转:与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)
* 使用「快慢指针」找到倒数第 `k` 个节点(新头结点),然后完成基本的链接与断开与断开操作
Java 代码:
```Java
class Solution {
public ListNode rotateRight(ListNode head, int k) {
if (head == null || k == 0) return head;
// 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.61` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/61-70/65. 有效数字（困难）.md | 65. 有效数字 | https://leetcode-cn.com/problems/valid-number/solution/gong-shui-san-xie-zi-fu-chuan-mo-ni-by-a-7cgc/ | 困难 | [
"模拟"
] | 有效数字(按顺序)可以分成以下几个部分:
1. 一个 小数 或者 整数
2. (可选)一个 `'e'` 或 `'E'` ,后面跟着一个 整数
小数(按顺序)可以分成以下几个部分:
1. (可选)一个符号字符(`'+'` 或 `'-'`)
2. 下述格式之一:
1. 至少一位数字,后面跟着一个点 `'.'`
2. 至少一位数字,后面跟着一个点 `'.'` ,后面再跟着至少一位数字
3. 一个点 `'.'` ,后面跟着至少一位数字
整数(按顺序)可以分成以下几个部分:
1. (可选)一个符号字符(`'+'` 或 `'-'`)
2. 至少一位数字
部分有效数字列举如下:
* `["2", "0089", "-0.1",... | ### 模拟
字符串大模拟,根据「有效数字定义」梳理规则即可。
本题有多种解法:「正则」、「DFA」、「模拟」...
**「模拟」是在各类场景中最容易实现的方式,只要头脑不发热都能写出来。**
将字符串以 `e/E` 进行分割后,其实规则十分简单:
* 如果存在 `e/E` :左侧可以「整数」或「浮点数」,右侧必须是「整数」
* 如果不存在 `e/E` :整段可以是「整数」或「浮点数」
关键在于如何实现一个 `check` 函数用于判断「整数」或「浮点数」:
* `+/-` 只能出现在头部
* `.` 最多出现一次
* 至少存在一个数字
代码:
```Java
class Solution {
public ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.65` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/61-70/66. 加一（简单）.md | 66. 加一 | https://leetcode-cn.com/problems/plus-one/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-5av1/ | 简单 | [
"模拟"
] | 给定一个由 整数 组成的 非空 数组所表示的非负整数,在该数的基础上加一。
最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外,这个整数不会以零开头。
示例 1:
```
输入:digits = [1,2,3]
输出:[1,2,4]
解释:输入数组表示数字 123。
```
示例 2:
```
输入:digits = [4,3,2,1]
输出:[4,3,2,2]
解释:输入数组表示数字 4321。
```
示例 3:
```
输入:digits = [0]
输出:[1]
```
提示:
* 1 <= digits.length <= 100
* 0 <= digits[i]... | ### 模拟
这是 [2. 两数相加](https://leetcode-cn.com/problems/add-two-numbers/solution/po-su-jie-fa-shao-bing-ji-qiao-by-ac_oie-etln/) 的简化版,其中一个操作固定为 $1$。
只需要按照题目进行模拟即可,使用 $t$ 记录进位。
代码:
```Java
class Solution {
public int[] plusOne(int[] digits) {
int n = digits.length;
digits[n - 1]++;
List<Integ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.66` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/61-70/68. 文本左右对齐（困难）.md | 68. 文本左右对齐 | https://leetcode-cn.com/problems/text-justification/solution/gong-shui-san-xie-zi-fu-chuan-mo-ni-by-a-s3v7/ | 困难 | [
"模拟",
"字符串"
] | 给定一个单词数组和一个长度 `maxWidth`,重新排版单词,使其成为每行恰好有 `maxWidth` 个字符,且左右两端对齐的文本。
你应该使用“贪心算法”来放置给定的单词;也就是说,尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充,使得每行恰好有 `maxWidth` 个字符。
要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配,则左侧放置的空格数要多于右侧的空格数。
文本的最后一行应为左对齐,且单词之间不插入额外的空格。
说明:
* 单词是指由非空格字符组成的字符序列
* 每个单词的长度大于 $0$,小于等于 `maxWidth`
* 输入单词数组 `words` 至少包含一个单词
示例... | ### 模拟
字符串大模拟,分情况讨论即可:
1. 如果当前行只有一个单词,特殊处理为左对齐;
2. 如果当前行为最后一行,特殊处理为左对齐;
3. 其余为一般情况,分别计算「当前行单词总长度」、「当前行空格总长度」和「往下取整后的单位空格长度」,然后依次进行拼接。当空格无法均分时,每次往靠左的间隙多添加一个空格,直到剩余的空格能够被后面的间隙所均分。
代码:
```Java
class Solution {
public List<String> fullJustify(String[] words, int maxWidth) {
List<String> ans = new ArrayList<>... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.68` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/611-620/611. 有效三角形的个数（中等）.md | 611. 有效三角形的个数 | https://leetcode-cn.com/problems/valid-triangle-number/solution/gong-shui-san-xie-yi-ti-san-jie-jian-dan-y1we/ | 中等 | [
"排序",
"二分",
"双指针"
] | 给定一个包含非负整数的数组,你的任务是统计其中可以组成三角形三条边的三元组个数。
示例 1:
```
输入: [2,2,3,4]
输出: 3
解释:
有效的组合是:
2,3,4 (使用第一个 2)
2,3,4 (使用第二个 2)
2,2,3
```
注意:
1. 数组长度不超过 $1000$。
2. 数组里整数的范围为 $[0, 1000]$。 | ### 基本分析
**根据题意,是要我们统计所有符合 $nums[k] + nums[j] > nums[i]$ 条件的三元组 $(k,j,i)$ 的个数。**
为了防止统计重复的三元组,我们可以先对数组进行排序,然后采取「先枚举较大数;在下标不超过较大数下标范围内,找次大数;在下标不超过次大数下标范围内,找较小数」的策略。
---
### 排序 + 暴力枚举
根据「基本分析」,我们可以很容易写出「排序 + 三层循环」的实现。
代码:
```Java
class Solution {
public int triangleNumber(int[] nums) {
int n = nums.leng... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.611` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/621-630/621. 任务调度器（中等）.md | 621. 任务调度器 | https://leetcode.cn/problems/task-scheduler/solution/by-ac_oier-3560/ | 中等 | [
"构造",
"脑筋急转弯"
] | 给你一个用字符数组 `tasks` 表示的 `CPU` 需要执行的任务列表,其中每个字母表示一种不同种类的任务。
任务可以以任意顺序执行,并且每个任务都可以在 `1` 个单位时间内执行完。
在任何一个单位时间,`CPU` 可以完成一个任务,或者处于待命状态。
然而,两个相同种类的任务之间必须有长度为整数 `n` 的冷却时间,因此至少有连续 `n` 个单位时间内 `CPU` 在执行不同的任务,或者在待命状态。
你需要计算完成所有任务所需要的最短时间。
示例 1:
```
输入:tasks = ["A","A","A","B","B","B"], n = 2
输出:8
解释:A -> B -> (待命) -> A -> B... | ### 构造
先考虑最为简单的情况:假设只有一类任务,除了最后一个任务以外,其余任务在安排后均需要增加 $n$ 个单位的冻结时间。
将任务数记为 $m$ 个,其中前 $m - 1$ 个任务均要消耗 $n + 1$ 的单位时间,最后一个任务仅消耗 $1$ 个单位时间,即所需要的时间为 $(n + 1) \times (m - 1) + 1$。
**当存在多个任务时,由于每一类任务都需要被完成,因此本质上我们最需要考虑的是将数量最大的任务安排掉,其他任务则是间插其中。**
假设数量最大的任务数为 `max`,共有 `tot` 个任务数为 `max` 的任务种类。
实际上,当任务总数不超过 $(n + 1) \times (\m... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.621` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/621-630/622. 设计循环队列（中等）.md | 622. 设计循环队列 | https://leetcode.cn/problems/design-circular-queue/solution/by-ac_oier-y11p/ | 中等 | [
"设计数据结构",
"队列"
] | 设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 `FIFO`(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。
你的实现应该支持如下操作:
* `MyCircularQueue(k)`: 构造器,设置队列长度为 $k$ 。
* `Front`: 从队首获取元素。如果队列为空,返回 $-1$ 。
* `Rear`: 获取队尾元素。如果队列为空,返回 $-1$ 。
* `enQueue(v... | ### 数据结构
创建一个长度为 $k$ 的数组充当循环队列,使用两个变量 `he` 和 `ta` 来充当队列头和队列尾(起始均为 $0$),整个过程 `he` 始终指向队列头部,`ta` 始终指向队列尾部的下一位置(待插入元素位置)。
两变量始终自增,通过与 $k$ 取模来确定实际位置。
分析各类操作的基本逻辑:
* `isEmpty` 操作:当 `he` 和 `ta` 相等,队列存入元素和取出元素的次数相同,此时队列为空;
* `isFull` 操作:`ta - he` 即队列元素个数,当元素个数为 $k$ 个时,队列已满;
* `enQueue` 操作:若队列已满,返回 $-1$,否则在 `nums[ta % k]` 位... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.622` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/621-630/623. 在二叉树中增加一行（中等）.md | 623. 在二叉树中增加一行 | https://leetcode.cn/problems/add-one-row-to-tree/solution/by-ac_oier-sc34/ | 中等 | [
"二叉树",
"BFS",
"DFS"
] | 给定一个二叉树的根 `root` 和两个整数 `val` 和 `depth`,在给定的深度 `depth` 处添加一个值为 `val` 的节点行。
注意,根节点 `root` 位于深度 $1$ 。
加法规则如下:
* 给定整数 `depth`,对于深度为 `depth - 1` 的每个非空树节点 `cur`,创建两个值为 `val` 的树节点作为 `cur` 的左子树根和右子树根。
* `cur` 原来的左子树应该是新的左子树根的左子树。
* `cur` 原来的右子树应该是新的右子树根的右子树。
* 如果 `depth == 1` 意味着 `depth - 1` 根本没有深度,那么创建一个树节点,值 `val` 作为整个原始树... | ### BFS
根据 `BFS` 来做,每次 `BFS` 将整一层进行拓展,同时记录当前深度,当到达第 `depth - 1` 层,则进行加点操作。
Java 代码:
```Java
class Solution {
public TreeNode addOneRow(TreeNode root, int val, int depth) {
if (depth == 1) return new TreeNode(val, root, null);
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.623` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/621-630/629. K个逆序对数组（困难）.md | 629. K个逆序对数组 | https://leetcode-cn.com/problems/k-inverse-pairs-array/solution/gong-shui-san-xie-yi-dao-xu-lie-dp-zhuan-tm01/ | 困难 | [
"序列 DP",
"前缀和"
] | 给出两个整数 `n` 和 `k`,找出所有包含从 `1` 到 `n` 的数字,且恰好拥有 `k` 个逆序对的不同的数组的个数。
逆序对的定义如下:对于数组的第 `i` 个和第 `j` 个元素,如果满 `i < j` 且 `a[i] > a[j]`,则其为一个逆序对;否则不是。
由于答案可能很大,只需要返回 答案 mod $10^9 + 7$ 的值。
示例 1:
```
输入: n = 3, k = 0
输出: 1
解释:
只有数组 [1,2,3] 包含了从1到3的整数并且正好拥有 0 个逆序对。
```
示例 2:
```
输入: n = 3, k = 1
输出: 2
解释:
数组 [1,3,2] 和 [2,1,3... | ### 序列 DP
从 $n$ 和 $k$ 数据范围均为 $10^3$ 可以看出这是一道二维的动态规划题。
**定义 $f[i][j]$ 为考虑使用数值 $[1,i]$,凑成逆序对数量恰好为 $j$ 的数组个数。**
不失一般性的考虑 $f[i][j]$ 该如何计算,对第 $i$ 个数(即数值为 $i$ 的数)所在位置进行讨论,共有 $i$ 种选择。
假设第 $i$ 个数所在位置为 $k$,由于数值 $i$ 为整个数组的最大值,因此数值 $i$ 与前面所有数均不形成逆序对,与后面的所有数均形成逆序对。因此与数值 $i$ 直接相关的逆向对的数量为 $(i - 1)- k$,由此也得出与 $i$ 不相关的逆序对数量为 $j - ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.629` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/621-630/630. 课程表 III（困难）.md | 630. 课程表 III | https://leetcode-cn.com/problems/course-schedule-iii/solution/gong-shui-san-xie-jing-dian-tan-xin-yun-ghii2/ | 困难 | [
"贪心"
] | 这里有 $n$ 门不同的在线课程,按从 $1$ 到 $n$ 编号。给你一个数组 $courses$ ,其中 $courses[i] = [durationi, lastDayi]$ 表示第 $i$ 门课将会 持续 上 $duration_i$ 天课,并且必须在不晚于 $lastDay_i$ 的时候完成。
你的学期从第 $1$ 天开始。且不能同时修读两门及两门以上的课程。
返回你最多可以修读的课程数目。
示例 1:
```
输入:courses = [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]]
输出:3
解释:
这里一共有 4 门课程,但是你最多可以修 3 门:
... | ### 贪心 + 优先队列(堆)
这是一道很好的题目。
题目是要我们构造出一种可行的排列,排列中每个课程的实际结束时间满足「最晚完成时间」要求,求可行排序的最大长度(每个课程对答案的贡献都是 $1$)。
这容易引导我们往「泛化背包」方面进行思考:简单来说,对于某个物品(课程)而言,在不同条件下成本不同,在时间轴 $[1, courses[i][1] - courses[i][0]]$ 上该物品可被选,成本为其持续时间,在比该范围大的数轴上无法被选,成本为正无穷。因此某一段特定的时间轴上,问题可抽象成有条件限制的组合优化问题。
**由于数据范围为 $10^4$,泛化背包做法需要记录的维度大于一维,不予考虑。**
再然后容易想... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.630` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/631-640/633. 平方数之和（中等）.md | 633. 平方数之和 | https://leetcode-cn.com/problems/sum-of-square-numbers/solution/gong-shui-san-xie-yi-ti-san-jie-mei-ju-s-7qi5/ | 中等 | [
"数学",
"双指针"
] | 给定一个非负整数 c ,你要判断是否存在两个整数 a 和 b,使得 $a^2$ + $b^2$ = c 。
示例 1:
```
输入:c = 5
输出:true
解释:1 * 1 + 2 * 2 = 5
```
示例 2:
```
输入:c = 3
输出:false
```
示例 3:
```
输入:c = 4
输出:true
```
示例 4:
```
输入:c = 2
输出:true
```
示例 5:
```
输入:c = 1
输出:true
```
提示:
* 0 <= c <= $2^{31}$ - 1 | ### 基本分析
**根据等式 $a^2 + b^2 = c$,可得知 `a` 和 `b` 的范围均为 $[0,\sqrt{c}]$。**
基于此我们会有以下几种做法。
---
### 枚举
我们可以枚举 `a` ,边枚举边检查是否存在 `b` 使得等式成立。
这样做的复杂度为 $O(\sqrt{c})$。
代码:
```Java
class Solution {
public boolean judgeSquareSum(int c) {
int max = (int)Math.sqrt(c);
for (int a = 0; a <= max; a++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.633` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/631-640/636. 函数的独占时间（中等）.md | 636. 函数的独占时间 | https://leetcode.cn/problems/exclusive-time-of-functions/solution/by-ac_oier-z3ed/ | 中等 | [
"模拟",
"栈"
] | 有一个单线程 `CPU` 正在运行一个含有 `n` 道函数的程序。
每道函数都有一个位于 `0` 和 `n-1` 之间的唯一标识符。
函数调用存储在一个调用栈上 :当一个函数调用开始时,它的标识符将会推入栈中。而当一个函数调用结束时,它的标识符将会从栈中弹出。标识符位于栈顶的函数是当前正在执行的函数。每当一个函数开始或者结束时,将会记录一条日志,包括函数标识符、是开始还是结束、以及相应的时间戳。
给你一个由日志组成的列表 `logs` ,其中 `logs[i]` 表示第 `i` 条日志消息,该消息是一个按 `"{function_id}:{"start" | "end"}:{timestamp}"` 进行格式化的字符串。
... | ### 模拟
我们使用「栈」来模拟执行过程:当一个函数被调用(`op = start`)时,压入栈内,当函数调用完成(`op = end`)时,从栈顶弹出(此时栈顶元素必然是该结束函数的入栈记录),使用变量 `cur` 记录当前时间。
从前往后处理所有的 $log[i]$,根据 $log[i]$ 是属于函数调用还是函数结束进行分情况讨论:
* 当 $log[i]$ 为函数调用:此时从该函数的调用发起时间 `ts` 到上一次记录的当前时间,都是前一函数的执行时间,因此可以将 `ts - cur` 累加到栈帧中的前一函数。即若栈不为空,则将该时间累加到栈顶对应的函数上,然后将 $log[i]$ 入栈,同时更新当前时间;
* 当 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.636` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/631-640/638. 大礼包（中等）.md | 638. 大礼包 | https://leetcode-cn.com/problems/shopping-offers/solution/gong-shui-san-xie-yi-ti-shuang-jie-zhuan-qgk1/ | 中等 | [
"完全背包",
"背包问题",
"DFS"
] | 在 LeetCode 商店中, 有 `n` 件在售的物品。每件物品都有对应的价格。然而,也有一些大礼包,每个大礼包以优惠的价格捆绑销售一组物品。
给你一个整数数组 `price` 表示物品价格,其中 `price[i]` 是第 `i` 件物品的价格。另有一个整数数组 `needs` 表示购物清单,其中 `needs[i]` 是需要购买第 `i` 件物品的数量。
还有一个数组 special 表示大礼包,`special[i]` 的长度为 `n + 1` ,其中 `special[i][j]` 表示第 `i` 个大礼包中内含第 `j` 件物品的数量,且 `special[i][n]` (也就是数组中的最后一个整数)为第 `i` 个... | ### 转换 DFS(转换为礼包处理)
对于某个 $need[i]$ 而言,既可以「单买」也可以使用「礼包形式购买」,同时两种购买方式都存在对「份数」的决策(单买多少份/买多少个相应的礼包)。
利用物品数量和礼包数量数据范围都较少,我们可以先对「单买」情况进行预处理,将其转换为「礼包」形式。若 $price[0] = 100$,则使用礼包 $[1, 0, 0, ...,0, 100]$ 来代指。
然后再预处理每个礼包最多选多少个,并使用哈希表进行存储。
最后使用 `DFS` 对每个「礼包」如何选择进行爆搜即可。
代码:
```Java
class Solution {
int ans = 0x3f3f3f3f;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.638` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/631-640/639. 解码方法 II（困难）.md | 639. 解码方法 II | https://leetcode-cn.com/problems/decode-ways-ii/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-902h/ | 困难 | [
"线性 DP",
"枚举"
] | 一条包含字母 A-Z 的消息通过以下的方式进行了编码:
```
'A' -> 1
'B' -> 2
...
'Z' -> 26
```
要 解码 一条已编码的消息,所有的数字都必须分组,然后按原来的编码方案反向映射回字母(可能存在多种方式)。例如,"11106" 可以映射为:
* "AAJF" 对应分组 (1 1 10 6)
* "KJF" 对应分组 (11 10 6)
注意,像 (1 11 06) 这样的分组是无效的,因为 "06" 不可以映射为 'F' ,因为 "6" 与 "06" 不同。
除了 上面描述的数字字母映射方案,编码消息中可能包含 `'*'` 字符,可以表示从 '1' 到 '9' 的任一数字(不包括 '0')。例... | ### 分情况讨论 DP
这是一道普通的线性 DP 题(之所以说普通,是因为状态定义比较容易想到),也是 [(题解)91. 解码方法](https://leetcode-cn.com/problems/decode-ways/solution/gong-shui-san-xie-gen-ju-shu-ju-fan-wei-ug3dd/) 的进阶题。
我们称一个解码内容为一个 `item`。
**定义 $f[i]$ 为考虑以 $s[i]$ 为结尾的字符串,共有多少种解码方案。**
那么最终答案为 $f[n - 1]$,同时我们有显而易见的起始状态 `f[0] = s[0] == '*' ? 9 : (s[0] != '0' ?... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.639` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/631-640/640. 求解方程（中等）.md | 640. 求解方程 | https://leetcode.cn/problems/solve-the-equation/solution/by-ac_oier-fvee/ | 中等 | [
"模拟",
"数学",
"双指针"
] | 求解一个给定的方程,将 `x` 以字符串 `"x=#value"` 的形式返回。该方程仅包含 `'+'` , `'-'` 操作,变量 `x` 和其对应系数。
如果方程没有解,请返回 `"No solution"`。如果方程有无限解,则返回 `"Infinite solutions"`。
题目保证,如果方程中只有一个解,则 'x' 的值是一个整数。
示例 1:
```
输入: equation = "x+5-3+x=6+x-2"
输出: "x=2"
```
示例 2:
```
输入: equation = "x=x"
输出: "Infinite solutions"
```
示例 3:
```
输入: equation = ... | ### 模拟
为了方便,我们令 `equation` 为 `s`。
由于运算符只有 `+` 和 `-`,因此无须考虑运算优先级,可在遍历过程中进行计算。
使用变量 `x` 和 `num` 分别代指当前运算结果中 $x$ 的系数以及数值部分,从前往后处理 `s` 的每个字符,根据字符类型进行分情况讨论,假设当前处理到的数值为 $s[i]$:
* 若 $s[i] =$ `+/-`:此时影响的是下一个运算数值的正负,修改对应的 `op` 标识;
* 若 $s[i] =$ `数值`:此时将完整的运算值进行取出(运算值可能是关于 $x$ 的描述,可能是纯数值),假设连续段 $s[i:j - 1]$ 之间为当前运算值,根据 $s[j -... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.640` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/641-650/641. 设计循环双端队列（中等）.md | 641. 设计循环双端队列 | https://leetcode.cn/problems/design-circular-deque/solution/by-ac_oier-fwhm/ | 中等 | [
"数组",
"链表",
"数据结构"
] | 设计实现双端队列。
实现 `MyCircularDeque` 类:
* `MyCircularDeque(int k)` :构造函数,双端队列最大为 $k$ 。
* `boolean insertFront()`:将一个元素添加到双端队列头部。 如果操作成功返回 `true` ,否则返回 `false` 。
* `boolean insertLast()` :将一个元素添加到双端队列尾部。如果操作成功返回 `true` ,否则返回 `false` 。
* `boolean deleteFront()` :从双端队列头部删除一个元素。 如果操作成功返回 `true` ,否则返回 `false` 。
* `boolean delet... | ### 基本分析
一个基本的实现,需要满足除构造函数以外复杂度为 $O(k)$ 以外,其余操作均为 $O(1)$。
常规实现包含两种方式:**数组实现** 与 **链表实现**。
其中数组实现可以利用调用次数较小,开成调用次数 $3$ 倍大小,然后从中间开始往两边存储,这样做就不用考虑下标边的界问题;而更为常规的解法是构造一个与限定空间 $k$ 等大的数组,使用两下标并配合坐标转换来做,对于下标自增操作而言,只需要进行「加一取模」即可,而对于下标自减操作,由于考虑负值问题,需要进行「增加限定空间偏移后,进行减一再取模」。
而链表实现则无须考虑额外的下标转换问题,但需要额外定义类。
---
### 数组
使用两坐标 `h... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.641` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/641-650/643. 子数组最大平均数 I（简单）.md | 643. 子数组最大平均数 I | https://leetcode-cn.com/problems/maximum-average-subarray-i/solution/hua-dong-chuang-kou-luo-ti-han-mo-ban-by-buo3/ | 简单 | [
"滑动窗口"
] | 给定 n 个整数,找出平均数最大且长度为 k 的连续子数组,并输出该最大平均数。
示例:
```
输入:[1,12,-5,-6,50,3], k = 4
输出:12.75
解释:最大平均数 (12-5-6+50)/4 = 51/4 = 12.75
```
提示:
* 1 <= k <= n <= 30,000。
* 所给数据范围 [-10,000,10,000]。 | ### 滑动窗口
这是一道道滑动窗口裸题。
以下代码,可以作为滑动窗口模板使用:
1. 初始化将滑动窗口压满,取得第一个滑动窗口的目标值
2. 继续滑动窗口,每往前滑动一次,需要删除一个和添加一个元素
代码:
```Java
class Solution {
public double findMaxAverage(int[] nums, int k) {
double ans = 0, sum = 0;
for (int i = 0; i < k; i++) sum += nums[i];
ans = sum / k;
for (int i = k;... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.643` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/641-650/645. 错误的集合（简单）.md | 645. 错误的集合 | https://leetcode-cn.com/problems/set-mismatch/solution/gong-shui-san-xie-yi-ti-san-jie-ji-shu-s-vnr9/ | 简单 | [
"模拟",
"哈希表",
"数学",
"桶排序"
] | 集合 `s` 包含从 `1` 到 `n` 的整数。不幸的是,因为数据错误,导致集合里面某一个数字复制了成了集合里面的另外一个数字的值,导致集合 丢失了一个数字 并且 有一个数字重复 。
给定一个数组 `nums` 代表了集合 `S` 发生错误后的结果。
请你找出重复出现的整数,再找到丢失的整数,将它们以数组的形式返回。
示例 1:
```
输入:nums = [1,2,2,4]
输出:[2,3]
```
示例 2:
```
输入:nums = [1,1]
输出:[1,2]
```
提示:
* 2 <= nums.length <= $10^4$
* 1 <= nums[i] <= $10^4$ | ### 计数
一个朴素的做法是,使用「哈希表」统计每个元素出现次数,然后在 $[1, n]$ 查询每个元素的出现次数。
在「哈希表」中出现 $2$ 次的为重复元素,未在「哈希表」中出现的元素为缺失元素。
由于这里数的范围确定为 $[1, n]$,我们可以使用数组来充当「哈希表」,以减少「哈希表」的哈希函数执行和冲突扩容的时间开销。
代码:
```Java
class Solution {
public int[] findErrorNums(int[] nums) {
int n = nums.length;
int[] cnts = new int[n + 1];
f... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.645` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/641-650/646. 最长数对链（中等）.md | 646. 最长数对链 | https://leetcode.cn/problems/maximum-length-of-pair-chain/solution/by-ac_oier-z91l/ | 中等 | [
"贪心",
"排序",
"二分",
"序列 DP",
"LIS"
] | 给出 `n` 个数对。 在每一个数对中,第一个数字总是比第二个数字小。
现在,我们定义一种跟随关系,当且仅当 `b < c` 时,数对 $(c, d)$ 才可以跟在 $(a, b)$ 后面。我们用这种形式来构造一个数对链。
给定一个数对集合,找出能够形成的最长数对链的长度。你不需要用到所有的数对,你可以以任何顺序选择其中的一些数对来构造。
示例:
```
输入:[[1,2], [2,3], [3,4]]
输出:2
解释:最长的数对链是 [1,2] -> [3,4]
```
提示:
* 给出数对的个数在 $[1, 1000]$ 范围内。 | ### 排序 + 贪心 DP
起始先将 `pairs` 根据第一维排升序(或直接双关键字排升序)。
考虑定义 $f[i]$ 为以 $pairs[i]$ 为结尾的最长数对链长度,所有 $f[i]$ 中的最大值为答案。
不失一般性考虑 $f[i]$ 该如何转移:不难发现 $f[i]$ 为所有满足「下标范围在 $[0, i - 1]$,且 $pairs[j][1] < pairs[i][0]$」条件的 $f[j] + 1$ 的最大值。
但实际上,我们只需要从 $j = i - 1$ 开始往回找,找到第一个满足 $pairs[j][1] < pairs[i][0]$ 的位置 $j$ 即可。
容易证明该做法的正确性:**假设贪心解(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/641-650/648. 单词替换（中等）.md | 648. 单词替换 | https://leetcode.cn/problems/replace-words/solution/by-ac_oier-jecf/ | 中等 | [
"字典树"
] | 在英语中,我们有一个叫做 词根(`root`) 的概念,可以词根后面添加其他一些词组成另一个较长的单词——我们称这个词为 继承词(`successor`)。例如,词根`an`,跟随着单词 `other`(其他),可以形成新的单词 `another`(另一个)。
现在,给定一个由许多词根组成的词典 `dictionary` 和一个用空格分隔单词形成的句子 `sentence`。你需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根,则用最短的词根替换它。
你需要输出替换之后的句子。
示例 1:
```
输入:dictionary = ["cat","bat","rat"], sentence = "the ca... | ### 基本分析
这是一道 `Trie` 的模板题,还不了解 `Trie` 的同学可以先看前置 🧀:[【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)
前置 🧀 通过图解形式讲解了 `Trie` 的结构与原理,以及提供了两种实现 `Trie` 的方式。
回到本题,为了方便,我们令 `ds` 为 `dictionary`,令 `s` 为 `sentence`。
---
### 二维数组
一个比较习惯的做法,是... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.648` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/641-650/649. Dota2 参议院（中等）.md | 649. Dota2 参议院 | https://leetcode.cn/problems/dota2-senate/solutions/2402101/gong-shui-san-xie-jie-he-shu-ju-jie-gou-x581k/ | 中等 | [
"贪心",
"红黑树",
"有序集合",
"队列"
] | Dota2 的世界里有两个阵营:`Radiant`(天辉)和 `Dire`(夜魇)。
Dota2 参议院由来自两派的参议员组成,现在参议院希望对一个 Dota2 游戏里的改变作出决定,他们以一个基于轮为过程的投票进行。
在每一轮中,每一位参议员都可以行使两项权利中的一项:
* 禁止一名参议员的权利:参议员可以让另一位参议员在这一轮和随后的几轮中丧失所有的权利 。
* 宣布胜利:如果参议员发现有权利投票的参议员都是同一个阵营的,他可以宣布胜利并决定在游戏中的有关变化。
给你一个字符串 `s` 代表每个参议员的阵营。字母 `'R'` 和 `'D'`分别代表了 `Radiant`(天辉)和 `Dire`(夜魇)。
然后,如果有 ... | ### 基本分析
整理题意:每次选择对方的一个成员进行消除,直到所有剩余成员均为我方时,宣布胜利。
由于每个对方成员执行权利都意味着我方损失一名成员,因此最佳方式是 **尽量让对方的权利不执行,或延迟执行(意味着我方有更多执行权利的机会)**。因此,最优决策为 **每次都选择对方的下一个行权成员进行消除**。
---
### 贪心
这个找“最近一个”对方行权成员的操作既可以使用「有序集合」来做,也可以使用「循环队列」来做。
先说使用「有序集合」的做法。
起始我们先将 `s` 中的 `Radiant` 和 `Dire` 分别存入有序集合 `rs` 和 `ds` 当中,然后从前往后模拟消除过程,过程中使用 `idx` 代表... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.649` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/641-650/650. 只有两个键的键盘（中等）.md | 650. 只有两个键的键盘 | https://leetcode-cn.com/problems/2-keys-keyboard/solution/gong-shui-san-xie-yi-ti-san-jie-dong-tai-f035/ | 中等 | [
"动态规划",
"线性 DP",
"数学",
"打表"
] | 最初记事本上只有一个字符 `'A'` 。你每次可以对这个记事本进行两种操作:
* `Copy All(复制全部)`:复制这个记事本中的所有字符(不允许仅复制部分字符)。
* `Paste(粘贴)`:粘贴 上一次 复制的字符。
给你一个数字 `n` ,你需要使用最少的操作次数,在记事本上输出 恰好 `n` 个 `'A'` 。返回能够打印出 `n` 个 `'A'` 的最少操作次数。
示例 1:
```
输入:3
输出:3
解释:
最初, 只有一个字符 'A'。
第 1 步, 使用 Copy All 操作。
第 2 步, 使用 Paste 操作来获得 'AA'。
第 3 步, 使用 Paste 操作来获得 'AAA'。
```
... | ### 动态规划
**定义 $f[i][j]$ 为经过最后一次操作后,当前记事本上有 $i$ 个字符,粘贴板上有 $j$ 个字符的最小操作次数。**
由于我们粘贴板的字符必然是经过 `Copy All` 操作而来,因此对于一个合法的 $f[i][j]$ 而言,必然有 $j <= i$。
不失一般性地考虑 $f[i][j]$ 该如何转移:
* 最后一次操作是 `Paste` 操作:此时粘贴板的字符数量不会发生变化,即有 $f[i][j] = f[i - j][j] + 1$;
* 最后一次操作是 `Copy All` 操作:那么此时的粘贴板的字符数与记事本上的字符数相等(满足 $i = j$),此时的 $f[i][j] = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.650` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/651-660/652. 寻找重复的子树（中等）.md | 652. 寻找重复的子树 | https://leetcode.cn/problems/find-duplicate-subtrees/solution/by-ac_oier-ly58/ | 中等 | [
"二叉树",
"哈希表",
"DFS"
] | 给定一棵二叉树 `root`,返回所有重复的子树。
对于同一类的重复子树,你只需要返回其中任意一棵的根结点即可。
如果两棵树具有相同的结构和相同的结点值,则它们是重复的。
示例 1:
```
输入:root = [1,2,3,4,null,2,4,null,null,4]
输出:[[2,4],[4]]
```
示例 2:
```
输入:root = [2,1,1]
输出:[[1]]
```
示例 3:
```
输入:root = [2,2,2,3,null,3,null]
输出:[[2,3],[3]]
```
提示:
* 树中的结点数在 $[1,10^4]$ 范围内。
* $-200 <= Node.val <=... | ### DFS + 哈希表
设计递归函数 `String dfs(TreeNode root)`,含义为返回以传入参数 `root` 为根节点的子树所对应的指纹标识。
对于标识的设计只需使用 `"_"` 分割不同的节点值,同时对空节点进行保留(定义为空串 `" "`)即可。
使用哈希表记录每个标识(子树)出现次数,当出现次数为 $2$(首次判定为重复出现)时,将该节点加入答案。
Java 代码:
```Java
class Solution {
Map<String, Integer> map = new HashMap<>();
List<TreeNode> ans = new ArrayList<>();... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.652` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/651-660/653. 两数之和 IV - 输入 BST（简单）.md | 650. 只有两个键的键盘 | https://leetcode-cn.com/problems/two-sum-iv-input-is-a-bst/solution/by-ac_oier-zr4o/ | 简单 | [
"二叉树",
"迭代",
"中序遍历",
"双指针",
"哈希表",
"树的搜索"
] | 给定一个二叉搜索树 `root` 和一个目标结果 `k`,如果 `BST` 中存在两个元素且它们的和等于给定的目标结果,则返回 `true`。
示例 1:
```
输入: root = [5,3,6,2,4,null,7], k = 9
输出: true
```
示例 2:
```
输入: root = [5,3,6,2,4,null,7], k = 28
输出: false
```
提示:
* 二叉树的节点个数的范围是 $[1, 10^4]$
* $-10^4 <= Node.val <= 10^4$
* `root` 为二叉搜索树
* $-10^5 <= k <= 10^5$ | ### 哈希表 + 树的搜索
在递归搜索过程中记录下相应的节点值(使用 `Set` 集合),如果在遍历某个节点 $x$ 时发现集合中存在 $k - x.val$,说明存在两个节点之和等于 $k$,返回 `True`,若搜索完整棵树都没有则返回 `False`。
代码:
```Java
class Solution {
Set<Integer> set = new HashSet<>();
public boolean findTarget(TreeNode root, int k) {
if (root == null) return false;
if (set.contains... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.653` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/651-660/654. 最大二叉树（中等）.md | 654. 最大二叉树 | https://leetcode.cn/problems/maximum-binary-tree/solution/by-ac_oier-s0wc/ | 中等 | [
"二叉树",
"递归",
"分治",
"线段树",
"单调栈"
] | 给定一个不重复的整数数组 `nums`。
最大二叉树 可以用下面的算法从 `nums` 递归地构建:
1. 创建一个根节点,其值为 `nums` 中的最大值。
2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回 `nums` 构建的最大二叉树。
示例 1:
```
输入:nums = [3,2,1,6,0,5]
输出:[6,3,5,null,2,0,null,null,1]
解释:递归调用如下所示:
- [3,2,1,6,0,5] 中的最大值是 6 ,左边部分是 [3,2,1] ,右边部分是 [0,5] 。
- [3,2,1] 中的最大... | ### 基本分析
根据题目描述,可知该问题本质是「区间求最值」问题(RMQ)。
而求解 RMQ 有多种方式:递归分治、有序集合/ST/线段树 和 单调栈。
其中递归分治做法复杂度为 $O(n^2)$,对本题来说可过;而其余诸如线段树的方式需要 $O(n\log{n})$ 的建树和单次 $O(\log{n})$ 的查询,整体复杂度为 $O(n\log{n})$;单调栈解法则是整体复杂度为 $O(n)$。
---
### 递归分治
设置递归函数 `TreeNode build(int[] nums, int l, int r)` 含义为从 `nums` 中的 $[l, r]$ 下标范围进行构建,返回构建后的头结点。
当 $... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.654` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/651-660/655. 输出二叉树（中等）.md | 655. 输出二叉树 | https://leetcode.cn/problems/print-binary-tree/solution/by-ac_oier-mays/ | 中等 | [
"二叉树",
"递归"
] | 给你一棵二叉树的根节点 root ,请你构造一个下标从 0 开始、大小为 m x n 的字符串矩阵 res ,用以表示树的 格式化布局 。构造此格式化布局矩阵需要遵循以下规则:
* 树的 高度 为 $height$,矩阵的行数 $m$ 应该等于 $height + 1$。
* 矩阵的列数 $n$ 应该等于 $2^{height+1 - 1}$ 。
* 根节点 需要放置在 顶行 的 正中间 ,对应位置为 $res[0][(n-1)/2]$ 。
* 对于放置在矩阵中的每个节点,设对应位置为 $res[r][c]$ ,将其左子节点放置在 $res[r+1][c-2^{height-r-1}]$ ,右子节点放置在 $res[r+1][c+... | ### DFS
根据题意,我们可以先设计 `dfs1` 递归函数得到树的高度 `h`,以及与其相关的矩阵行列大小(并初始化矩阵)。
随后根据填充规则,设计 `dfs2` 递归函数往矩阵进行填充。
Java 代码:
```Java
class Solution {
int h, m, n;
List<List<String>> ans;
public List<List<String>> printTree(TreeNode root) {
dfs1(root, 0);
m = h + 1; n = (1 << (h + 1)) - 1;
ans = new... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.655` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/651-660/658. 找到 K 个最接近的元素（中等）.md | 658. 找到 K 个最接近的元素 | https://leetcode.cn/problems/find-k-closest-elements/solution/by-ac_oier-8xh5/ | 中等 | [
"二分",
"双指针"
] | 给定一个 排序好 的数组 `arr`,两个整数 `k` 和 `x` ,从数组中找到最靠近 `x`(两数之差最小)的 `k` 个数。返回的结果必须要是按升序排好的。
整数 `a` 比整数 `b` 更接近 `x` 需要满足:
* `|a - x| < |b - x|` 或者
* `|a - x| == |b - x|` 且 `a < b`
示例 1:
```
输入:arr = [1,2,3,4,5], k = 4, x = 3
输出:[1,2,3,4]
```
示例 2:
```
输入:arr = [1,2,3,4,5], k = 4, x = -1
输出:[1,2,3,4]
```
提示:
* $1 <= k <= arr... | ### 二分 + 双指针
容易想到先通过「二分」找到与 `x` 差值最小的位置 `idx`,然后从 `idx` 开始使用「双指针」往两边进行拓展(初始化左端点 $i = idx - 1$,右端点 $j = idx + 1$),含义为 $[i + 1, j - 1]$ 范围内子数组为候选区间,不断根据两边界与 `x` 的差值关系进行扩充,直到候选区间包含 $k$ 个数。
Java 代码:
```Java
class Solution {
public List<Integer> findClosestElements(int[] arr, int k, int x) {
int n = arr.length... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.658` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/661-670/661. 图片平滑器（简单）.md | 661. 图片平滑器 | https://leetcode-cn.com/problems/image-smoother/solution/by-ac_oier-nn3v/ | 简单 | [
"模拟",
"前缀和"
] | 图像平滑器 是大小为 $3 * 3$ 的过滤器,用于对图像的每个单元格平滑处理,平滑处理后单元格的值为该单元格的平均灰度。
每个单元格的 平均灰度 定义为:该单元格自身及其周围的 $8$ 个单元格的平均值,结果需向下取整。(即,需要计算蓝色平滑器中 $9$ 个单元格的平均值)。
如果一个单元格周围存在单元格缺失的情况,则计算平均灰度时不考虑缺失的单元格(即,需要计算红色平滑器中 $4$ 个单元格的平均值)。
给你一个表示图像灰度的 $m * n$ 整数矩阵 `img` ,返回对图像的每个单元格平滑处理后的图像 。
示例 1:
```
输入:img = [[1,1,1],[1,0,1],[1,1,1]]
输出:[[0, ... | ### 朴素解法
为了方便,我们称每个单元格及其八连通方向单元格所组成的连通块为一个 `item`。
数据范围只有 $200$,我们可以直接对每个 `item` 进行遍历模拟。
代码:
```Java
class Solution {
public int[][] imageSmoother(int[][] img) {
int m = img.length, n = img[0].length;
int[][] ans = new int[m][n];
int[][] dirs = new int[][]{{0,0},{1,0},{-1,0},{0,1},{0,-1},... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.661` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/661-670/662. 二叉树最大宽度（中等）.md | 662. 二叉树最大宽度 | https://leetcode.cn/problems/maximum-width-of-binary-tree/solution/by-ac_oier-33er/ | 中等 | [
"二叉树",
"DFS",
"哈希表"
] | 给你一棵二叉树的根节点 `root`,返回树的最大宽度。
树的「最大宽度」是所有层中最大的宽度 。
每一层的宽度被定义为该层最左和最右的非空节点(即两个端点)之间的长度。
将这个二叉树视作与满二叉树结构相同,两端点间会出现一些延伸到这一层的 `null` 节点,这些 `null` 节点也计入长度。
题目数据保证答案将会在 `32` 位 带符号整数范围内。
示例 1:
```
输入:root = [1,3,2,5,3,null,9]
输出:4
解释:最大宽度出现在树的第 3 层,宽度为 4 (5,3,null,9) 。
```
示例 2:
```
输入:root = [1,3,2,5,null,null,9,6,n... | ### DFS
根据满二叉树的节点编号规则:若根节点编号为 `u`,则其左子节点编号为 `u << 1`,其右节点编号为 `u << 1 | 1`。
一个朴素的想法是:我们在 `DFS`过程中使用两个哈希表分别记录每层深度中的最小节点编号和最大节点编号,两者距离即是当前层的宽度,最终所有层数中的最大宽度即是答案。
而实现上,我们可以利用先 `DFS` 左节点,再 `DFS` 右节点的性质可知,每层的最左节点必然是最先被遍历到,因此我们只需要记录当前层最先被遍历到点编号(即当前层最小节点编号),并在 `DFS` 过程中计算宽度,更新答案即可。
> 看到评论区有同学讨论关于编号溢出问题,之所以溢出仍能 `AC` 是因为测试数组中... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.662` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/661-670/664. 奇怪的打印机（困难）.md | 664. 奇怪的打印机 | https://leetcode-cn.com/problems/strange-printer/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-xqeo9/ | 困难 | [
"区间 DP"
] | 有台奇怪的打印机有以下两个特殊要求:
* 打印机每次只能打印由 同一个字符 组成的序列。
* 每次可以在任意起始和结束位置打印新字符,并且会覆盖掉原来已有的字符。
给你一个字符串 `s`,你的任务是计算这个打印机打印它需要的最少打印次数。
示例 1:
```
输入:s = "aaabbb"
输出:2
解释:首先打印 "aaa" 然后打印 "bbb"。
```
示例 2:
```
输入:s = "aba"
输出:2
解释:首先打印 "aaa" 然后在第二个位置打印 "b" 覆盖掉原来的字符 'a'。
```
提示:
* $1 <= s.length <= 100$
* `s` 由小写英文字母组成 | ### 基本分析
首先,根据题意我们可以分析出一个重要推论:**连续相同的一段字符,必然可以归到同一次打印中,而不会让打印次数变多。注意,这里说的是「归到一次」,而不是说「单独作为一次」。**
怎么理解这句话呢?
举个 🌰,对于诸如 `...bbaaabb...` 的样例数据,其中多个连续的 `a` 必然可以归到同一次打印中,但这一次打印可能只是将 `aaa` 作为整体进行打印;也有可能是 `aaa` 与前面或者后面的 `a` 作为整体被打印(然后中间的 `b` 被后来的打印所覆盖)。但无论是何种情况连续一段的 `aaa` 必然是可以「归到同一次打印」中。
**我们可以不失一般性证明「连续相同的一段字符,必然可以归到同一次... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.664` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/661-670/667. 优美的排列 II（中等）.md | 667. 优美的排列 II | https://leetcode.cn/problems/beautiful-arrangement-ii/solution/by-ac_oier-lyns/ | 中等 | [
"构造",
"脑筋急转弯"
] | 给你两个整数 `n` 和 `k` ,请你构造一个答案列表 `answer`,该列表应当包含从 `1` 到 `n` 的 `n` 个不同正整数,并同时满足下述条件:
假设该列表是 $answer = [a_1, a_2, a_3, ... , a_n]$ ,那么列表 $[|a_1 - a_2|, |a_2 - a_3|, |a_3 - a_4|, ... , |a_{n-1} - a_n|]$ 中应该有且仅有 k 个不同整数。
返回列表 `answer`。如果存在多种答案,只需返回其中 任意一种 。
示例 1:
```
输入:n = 3, k = 1
输出:[1, 2, 3]
解释:[1, 2, 3] 包含 3 个范围在 1-... | ### 构造
给定范围在 $[1, n]$ 的 $n$ 个数,当「直接升序/降序」排列时,相邻项差值为 $1$,仅一种;而从首位开始按照「升序」间隔排列,次位开始按照「降序」间隔排列(即排列为 `[1, n, 2, n - 1, 3, ...]`)时,相邻差值会从 $n - 1$ 开始递减至 $1$,共 $n - 1$ 种。
那么当我们需要构造 $k$ 种序列时,我们可以先通过「直接升序」的方式构造出若干个 $1$,然后再通过「间隔位分别升降序」的方式构造出从 $k$ 到 $1$ 的差值,共 $k$ 个。
显然,我们需要 $k + 1$ 个数来构造出 $k$ 个差值。因此我们可以先从 $1$ 开始,使用 $n - (k + 1... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.667` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/661-670/668. 乘法表中第k小的数（困难）.md | 668. 乘法表中第k小的数 | https://leetcode.cn/problems/kth-smallest-number-in-multiplication-table/solution/by-ac_oier-7pmt/ | 困难 | [
"二分",
"计数"
] | 几乎每一个人都用 乘法表,但是你能在乘法表中快速找到第 $k$ 小的数字吗?
给定高度 $m$ 、宽度 $n$ 的一张 $m \times n$ 的乘法表,以及正整数 $k$,你需要返回表中第 $k$ 小的数字。
例 1:
```
输入: m = 3, n = 3, k = 5
输出: 3
解释:
乘法表:
1 2 3
2 4 6
3 6 9
第5小的数字是 3 (1, 2, 2, 3, 3).
```
例 2:
```
输入: m = 2, n = 3, k = 6
输出: 6
解释:
乘法表:
1 2 3
2 4 6
第6小的数字是 6 (1, 2, 2, 3, 4, 6).
```
注意:
* $m$ 和 ... | ### 二分 + 计数判定
由于 $n$ 和 $m$ 的数据范围都是 $3 \times 10^4$,总数本身就超过了 $10^7$,我们考虑线性复杂度往下的对数复杂度。
题目要求我们求一维展开有序序列中的第 $k$ 小的数,问题本身具有「二段性」:
* 答案右边的每个数均 **满足**「其在一维展开有序序列中左边数的个数大于等于 $k$ 个」
* 答案左边的每个数均 **不满足**「其在一维展开有序序列中左边数的个数大于等于 $k$ 个」
我们考虑如何进行「二分答案」: 假设当前我们二分到的值是 $mid$,对于乘法表中的每行和每列均是单调递增,我们可以通过累加统计 每行/每列 中比 $mid$ 小的数,记作 $a$,累加... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.668` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/661-670/669. 修剪二叉搜索树（中等）.md | 669. 修剪二叉搜索树 | https://leetcode.cn/problems/trim-a-binary-search-tree/solution/by-ac_oier-help/ | 中等 | [
"BST",
"二叉树",
"递归",
"迭代"
] | 给你二叉搜索树的根节点 `root`,同时给定最小边界 `low` 和最大边界 `high`。通过修剪二叉搜索树,使得所有节点的值在 $[low, high]$ 中。修剪树 不应该 改变保留在树中的元素的相对结构 (即,如果没有被移除,原有的父代子代关系都应当保留)。 可以证明,存在 唯一的答案 。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意,根节点可能会根据给定的边界发生改变。
示例 1:
```
输入:root = [1,0,2], low = 1, high = 2
输出:[1,null,2]
```
示例 2:
```
输入:root = [3,0,4,null,2,null,null,1], low =... | ### 递归
由于被修剪的是二叉搜索树,因此修剪过程必然能够顺利进行。
容易想到使用原函数作为递归函数:
* 若 `root.val` 小于边界值 `low`,则 `root` 的左子树必然均小于边界值,我们递归处理 `root.right` 即可;
* 若 `root.val` 大于边界值 `high`,则 `root` 的右子树必然均大于边界值,我们递归处理 `root.left` 即可;
* 若 `root.val` 符合要求,则 `root` 可被保留,递归处理其左右节点并重新赋值即可。
Java 代码:
```Java
class Solution {
public TreeNode trimBST(Tre... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.669` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/661-670/670. 最大交换（中等）.md | 670. 最大交换 | https://leetcode.cn/problems/maximum-swap/solution/by-ac_oier-jxmh/ | 中等 | [
"模拟"
] | 给定一个非负整数,你至多可以交换一次数字中的任意两位。
返回你能得到的最大值。
示例 1 :
```
输入: 2736
输出: 7236
解释: 交换数字2和数字7。
```
示例 2 :
```
输入: 9973
输出: 9973
解释: 不需要交换。
```
注意:
* 给定数字的范围是 $[0, 10^8]$ | ### 模拟
根据题意,我们应当将大的数放置在高位,而当有数值相同的多个大数时,我们应当选择低位的数字。
因此,我们可以先将 `num` 的每一位处理出来存放到数组 `list` 中,随后预处理一个与 `list` 等长的数组 `idx`,带来代指 `num` 后缀中最大值对应的下标,即当 `idx[i] = j` 含义为在下标为 $[0, i]$ 位中 $num[j]$ 对应的数值最大。
同时由于我们需要遵循「当有数值相同的多个大数时,选择低位的数字」原则,我们应当出现采取严格大于才更新的方式来预处理 `idx`。
最后则是从高位往低位遍历,找到第一个替换的位置进行交换,并重新拼凑回答案。
Java 代码:
```Jav... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.670` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/671-680/671. 二叉树中第二小的节点（简单）.md | 671. 二叉树中第二小的节点 | https://leetcode-cn.com/problems/second-minimum-node-in-a-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-d-eupu/ | 简单 | [
"二叉树",
"树的遍历",
"递归"
] | 给定一个非空特殊的二叉树,每个节点都是正数,并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话,那么该节点的值等于两个子节点中较小的一个。
更正式地说,root.val = min(root.left.val, root.right.val) 总成立。
给出这样的一个二叉树,你需要输出所有节点中的第二小的值。如果第二小的值不存在的话,输出 -1 。
示例 1:
```
输入:root = [2,2,5,null,null,5,7]
输出:5
解释:最小的值是 2 ,第二小的值是 5 。
```
示例 2:
```
输入:root = [2,2,2]
输出:-1
解释:最小的值是 2, 但... | ### 树的遍历
一个朴素的做法是,直接对树进行遍历(广度 & 深度),使用 `HashSet` 进行存储,得到所有去重后的节点大小。
然后找次小值的方式有多种:可以通过排序找次小值,复杂度为 $O(n\log{n})$;也可以使用经典的两个变量 & 一次遍历的方式,找到次小值,复杂度为 $O(n)$。
代码:
```Java
class Solution {
Set<Integer> set = new HashSet<>();
public int findSecondMinimumValue(TreeNode root) {
dfs(root);
if (set.size(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.671` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/671-680/672. 灯泡开关 Ⅱ（中等）.md | 672. 灯泡开关 II | https://leetcode.cn/problems/bulb-switcher-ii/solution/by-ac_oier-3ttx/ | 中等 | [
"脑筋急转弯",
"找规律"
] | 房间中有 `n` 只已经打开的灯泡,编号从 `1` 到 `n` 。
墙上挂着 `4` 个开关 ,这 `4` 个开关各自都具有不同的功能,其中:
* 开关 1 :反转当前所有灯的状态(即开变为关,关变为开)
* 开关 2 :反转编号为偶数的灯的状态(即 `2, 4, ...`)
* 开关 3 :反转编号为奇数的灯的状态(即 `1, 3, ...`)
* 开关 4 :反转编号为 `j = 3k + 1` 的灯的状态,其中 `k = 0, 1, 2, ...`(即 `1, 4, 7, 10, ...`)
你必须 恰好 按压开关 `presses` 次。每次按压,你都需要从 `4` 个开关中选出一个来执行按压操作。
给你两个整数 `... | ### 分情况讨论
记灯泡数量为 $n$(至少为 $1$),翻转次数为 $k$(至少为 $0$),使用 `1` 代表灯亮,使用 `0` 代表灯灭。
我们根据 $n$ 和 $k$ 的数值分情况讨论:
* 当 $k = 0$ 时,无论 $n$ 为何值,都只有起始(全 `1`)一种状态;
* 当 $k > 0$ 时,根据 $n$ 进一步分情况讨论:
* 当 $n = 1$ 时,若 $k$ 为满足「$k > 0$」的最小值 $1$ 时,能够取满「`1`/`0`」两种情况,而其余更大 $k$ 值情况能够使用操作无效化(不影响灯的状态);
* 当 $n = 2$ 时,若 $k = 1$,能够取得「`00`/`10`/`01... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.672` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/671-680/673. 最长递增子序列的个数（中等）.md | 673. 最长递增子序列的个数 | https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/solution/gong-shui-san-xie-lis-de-fang-an-shu-wen-obuz/ | 中等 | [
"动态规划",
"序列 DP",
"树状数组",
"最长上升子序列"
] | 给定一个未排序的整数数组,找到最长递增子序列的个数。
示例 1:
```
输入: [1,3,5,4,7]
输出: 2
解释: 有两个最长递增子序列,分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。
```
示例 2:
```
输入: [2,2,2,2,2]
输出: 5
解释: 最长递增子序列的长度是1,并且存在5个子序列的长度为1,因此输出5。
注意: 给定的数组长度不超过 2000 并且结果一定是32位有符号整数。
```
提示:
* $1 <= nums.length <= 2000$
* $-10^6 <= nums[i] <= 10^6$ | ### 序列 DP
与朴素的 LIS 问题(问长度)相比,本题问的是最长上升子序列的个数。
我们只需要在朴素 LIS 问题的基础上通过「记录额外信息」来进行求解即可。
在朴素的 LIS 问题中,我们定义 **$f[i]$ 为考虑以 $nums[i]$ 为结尾的最长上升子序列的长度。** 最终答案为所有 $f[0...(n - 1)]$ 中的最大值。
不失一般性地考虑 $f[i]$ 该如何转移:
* 由于每个数都能独自一个成为子序列,因此起始必然有 $f[i] = 1$;
* 枚举区间 $[0, i)$ 的所有数 $nums[j]$,如果满足 $nums[j] < nums[i]$,说明 $nums[i]$ 可以接在 $nu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.673` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/671-680/675. 为高尔夫比赛砍树（困难）.md | 675. 为高尔夫比赛砍树 | https://leetcode.cn/problems/cut-off-trees-for-golf-event/solution/by-ac_oier-ksth/ | 困难 | [
"图论 BFS",
"AStar 算法",
"启发式搜索",
"并查集"
] | 你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 $m \times n$ 的矩阵表示, 在这个矩阵中:
* $0$ 表示障碍,无法触碰
* $1$ 表示地面,可以行走
* 比 $1$ 大的数 表示有树的单元格,可以行走,数值表示树的高度
每一步,你都可以向上、下、左、右四个方向之一移动一个单位,如果你站的地方有一棵树,那么你可以决定是否要砍倒它。
你需要按照树的高度从低向高砍掉所有的树,每砍过一颗树,该单元格的值变为 $1$(即变为地面)。
你将从 $(0, 0)$ 点开始工作,返回你砍完所有树需要走的最小步数。 如果你无法砍完所有的树,返回 $-1$ 。
可以保证的是,没有两棵树的高度是相同的,并且你至少需要砍倒一... | ### 基本分析
基本题意为:给定一个 $n \times m$ 的矩阵,每次能够在当前位置往「四联通」移动一个单位,其中 $0$ 的位置代表障碍(无法访问),$1$ 的位置代表平地(可直接访问,且无须进行任何决策),其余大于 $1$ 的位置代表有树,经过该位置的时候可以考虑将树砍掉(相应值变为平地 $1$)。
同时题目限定了我们只能按照「从低到高」的顺序进行砍树,并且图中不存在高度相等的两棵树,这意味着 **整个砍树的顺序唯一确定,就是对所有有树的地方进行「高度」排升序,即是完整的砍树路线。**
而另外一个更为重要的性质是:**点与点之间的最短路径,不会随着砍树过程的进行而发生变化(某个树点被砍掉,只会变为平地,不会变为阻... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.675` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/671-680/676. 实现一个魔法字典（中等）.md | 676. 实现一个魔法字典 | https://leetcode.cn/problems/cut-off-trees-for-golf-event/solution/by-ac_oier-ksth/ | 中等 | [
"字典树",
"DFS"
] | 设计一个使用单词列表进行初始化的数据结构,单词列表中的单词 互不相同 。 如果给出一个单词,请判定能否只将这个单词中一个字母换成另一个字母,使得所形成的新单词存在于你构建的字典中。
实现 `MagicDictionary` 类:
* `MagicDictionary()` 初始化对象
* `void buildDict(String[] dictionary)` 使用字符串数组 `dictionary` 设定该数据结构,`dictionary` 中的字符串互不相同
* `bool search(String searchWord)` 给定一个字符串 `searchWord`,判定能否只将字符串中 一个 字母换成另一个字母,使得所... | ### Trie + DFS
为了方便,我们令 `dictionary` 为 `ss`,令 `searchWord` 为 `s`。
整体题意:给定字符串 `s`,问能否存在替换掉 `s` 中的某个字符,使得新字符串出现在 `ss` 数组中。
考虑如何使用「字典树/`Trie`」求解该问题:
* `buildDict` 操作:我们可以将所有的 $ss[i]$ 存入字典树中,方便后续检索;
* `search` 操作:设计递归函数 `boolean query(String s, int idx, int p, int limit)`,其中 `s` 为待检索的字符串,`idx` 为当前处理到字符串 `s` 的哪一位,`p` 为... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.676` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/671-680/677. 键值映射（中等）.md | 677. 键值映射 | https://leetcode-cn.com/problems/map-sum-pairs/solution/gong-shui-san-xie-jie-he-dfs-de-trie-yun-i4xa/ | 中等 | [
"字典树",
"DFS",
"哈希表"
] | 实现一个 `MapSum` 类,支持两个方法,`insert` 和 `sum`:
* `MapSum()` 初始化 `MapSum` 对象
* `void insert(String key, int val)` 插入 `key-val` 键值对,字符串表示键 `key` ,整数表示值 `val` 。如果键 `key` 已经存在,那么原来的键值对将被替代成新的键值对。
* `int sum(string prefix)` 返回所有以该前缀 `prefix` 开头的键 `key` 的值的总和。
示例:
```
输入:
["MapSum", "insert", "sum", "insert", "sum"]
[[], ["apple... | ### Trie + DFS
从需要实现「存储字符串(映射关系)」并「检索某个字符串前缀的总和」来看,可以知道这是与 $Trie$ 相关的题目,还不了解 $Trie$ 的同学可以先看前置 🧀:[实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=59039721&l... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.677` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/671-680/678. 有效的括号字符串（中等）.md | 678. 有效的括号字符串 | https://leetcode-cn.com/problems/valid-parenthesis-string/solution/gong-shui-san-xie-yi-ti-shuang-jie-dong-801rq/ | 中等 | [
"有效括号问题",
"动态规划",
"模拟"
] | 给定一个只包含三种字符的字符串:`(` ,`)` 和 `*`,写一个函数来检验这个字符串是否为有效字符串。
有效字符串具有如下规则:
* 任何左括号 `(` 必须有相应的右括号 `)`。
* 任何右括号 `)` 必须有相应的左括号 `(` 。
* 左括号 `(` 必须在对应的右括号之前 `)`。
* 可以被视为单个右括号 `)` ,或单个左括号 `(` ,或一个空字符串。
* 一个空字符串也被视为有效字符串。
示例 1:
```
输入: "()"
输出: True
```
示例 2:
```
输入: "(*)"
输出: True
```
示例 3:
```
输入: "(*))"
输出: True
```
注意:
* 字... | ### 动态规划
**定义 $f[i][j]$ 为考虑前 $i$ 个字符(字符下标从 $1$ 开始),能否与 $j$ 个右括号形成合法括号序列。**
起始时只有 $f[0][0]$ 为 $true$,最终答案为 $f[n][0]$。
不失一般性的考虑 $f[i][j]$ 该如何转移:
* 当前字符为 `(` : 如果 $f[i][j]$ 为 $true$,必然有 $f[i - 1][j - 1]$ 为 $true$,反之亦然。即有 $f[i][j] = f[i - 1][j - 1]$;
* 当前字符为 `)` : 如果 $f[i][j]$ 为 $true$,必然有 $f[i - 1][j + 1]$ 为 $true$,反之... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.678` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/682. 棒球比赛（简单）.md | 682. 棒球比赛 | https://leetcode-cn.com/problems/baseball-game/solution/by-ac_oier-4mhz/ | 简单 | [
"模拟"
] | 你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成,过去几回合的得分可能会影响以后几回合的得分。
比赛开始时,记录是空白的。你会得到一个记录操作的字符串列表 `ops`,其中 $ops[i]$ 是你需要记录的第 $i$ 项操作,`ops` 遵循下述规则:
1. 整数 `x` - 表示本回合新获得分数 `x`
2. `"+"` - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。
3. `"D"` - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。
4. `"C"` - 表示前一次得分无效,将其从记录中移除。题目数据保证记录... | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
static int[] nums = new int[1010];
public int calPoints(String[] ops) {
int n = ops.length, idx = 0;
for (int i = 0; i < n; i++, idx++) {
if (ops[i].equals("+")) nums[idx] = nums[idx - 1] + nums[idx - 2];
else if (ops[... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.682` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/686. 重复叠加字符串匹配（中等）.md | 686. 重复叠加字符串匹配 | https://leetcode-cn.com/problems/repeated-string-match/solution/gong-shui-san-xie-yi-ti-san-jie-qia-chan-3hbr/ | 中等 | [
"字符串哈希",
"KMP"
] | 给定两个字符串 `a` 和 `b`,寻找重复叠加字符串 `a` 的最小次数,使得字符串 `b` 成为叠加后的字符串 `a` 的子串,如果不存在则返回 `-1`。
注意:字符串 `"abc"` 重复叠加 `0` 次是 `""`,重复叠加 `1` 次是 `"abc"`,重复叠加 `2` 次是 `"abcabc"`。
示例 1:
```
输入:a = "abcd", b = "cdabcdab"
输出:3
解释:a 重复叠加三遍后为 "abcdabcdabcd", 此时 b 是其子串。
```
示例 2:
```
输入:a = "a", b = "aa"
输出:2
```
示例 3:
```
输入:a = "a", b = "a... | ### 基本分析
首先,可以分析复制次数的「下界」和「上界」为何值:
**对于「下界」的分析是容易的:至少将 `a` 复制长度大于等于 `b` 的长度,才有可能匹配。**
在明确了「下界」后,再分析再经过多少次复制,能够明确得到答案,能够得到明确答案的最小复制次数即是上界。
**由于主串是由 `a` 复制多次而来,并且是从主串中找到子串 `b`,因此可以明确子串的起始位置,不会超过 `a` 的长度。**
即**长度越过 `a` 长度的起始匹配位置,必然在此前已经被匹配过了。**
由此,我们可知复制次数「上界」最多为「下界 + $1$」。
令 `a` 的长度为 $n$,`b` 的长度为 $m$,下界次数为 $c1$,上界... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.686` 篇,系列开始于 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.