file_path
stringlengths 27
66
| url_title
stringlengths 6
38
| url
stringlengths 60
237
⌀ | difficulty
stringclasses 3
values | tags
sequencelengths 1
8
| question
stringlengths 107
2.73k
| solution
stringlengths 163
28.6k
| final
stringlengths 308
330
|
|---|---|---|---|---|---|---|---|
LeetCode/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
输出:false
```
提示:
* $1 <= num <= 10^8$ | ### 数学
我们知道正因数总是成对的出现,因此我们可以仅枚举每对正因数的较小数,即从 $[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++) {
if (num % i == 0) {
ans += i;
if (i * i != num) ans += num / i;
}
}
return ans == num;
}
}
```
* 时间复杂度:$O(\sqrt{num})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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> list = new ArrayList<>();
for (int k : map.keySet()) {
if (map.get(k) == max) list.add(k);
}
int n = list.size();
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = list.get(i);
return ans;
}
int dfs(TreeNode root) {
if (root == null) return 0;
int cur = root.val + dfs(root.left) + dfs(root.right);
map.put(cur, map.getOrDefault(cur, 0) + 1);
max = Math.max(max, map.get(cur));
return cur;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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$ 开始。在进行快速求和时,再根据原数组下标是否从 $1$ 开始,决定是否进行相应的下标偏移。
学习完一维前缀和后,回到本题。
先用 `nums` 预处理出前缀和数组 `sum`,然后在遍历子数组右端点 `j` 的过程中,通过变量 `m` 动态记录已访问的左端点 `i` 的前缀和最小值。最终,在所有 `sum[j] - m` 的取值中选取最大值作为答案。
代码实现上,我们无需明确计算前缀和数组 `sum`,而是使用变量 `s` 表示当前累计的前缀和(充当右端点),并利用变量 `m` 记录已访问的前缀和的最小值(充当左端点)即可。
**本题除了将其看作为「前缀和裸题用有限变量进行空间优化」以外,还能以「线性 DP」角度进行理解。**
定义 $f[i]$ 为考虑前 $i$ 个元素,且第 $nums[i]$ 必选的情况下,形成子数组的最大和。
不难发现,仅考虑前 $i$ 个元素,且 $nums[i]$ 必然参与的子数组中。要么是 $nums[i]$ 自己一个成为子数组,要么与前面的元素共同组成子数组。
因此,状态转移方程:
$$
f[i] = \max(f[i - 1] + nums[i], nums[i])
$$
由于 $f[i]$ 仅依赖于 $f[i - 1]$ 进行转移,可使用有限变量进行优化,因此写出来的代码也是和上述前缀和角度分析的类似。
Java 代码:
```Java
class Solution {
public int maxSubArray(int[] nums) {
int s = 0, m = 0, ans = -10010;
for (int x : nums) {
s += x;
ans = Math.max(ans, s - m);
m = Math.min(m, s);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int s = 0, m = 0, ans = -10010;
for (int x : nums) {
s += x;
ans = max(ans, s - m);
m = min(m, s);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
s, m, ans = 0, 0, -10010
for x in nums:
s += x
ans = max(ans, s - m)
m = min(m, s)
return ans
```
TypeScript 代码:
```TypeScript
function maxSubArray(nums: number[]): number {
let s = 0, m = 0, ans = -10010;
for (let x of nums) {
s += x;
ans = Math.max(ans, s - m);
m = Math.min(m, s);
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 分治
“分治法”的核心思路是将大问题拆分成更小且相似的子问题,通过递归解决这些子问题,最终合并子问题的解来得到原问题的解。
实现分治,关键在于对“递归函数”的设计(入参 & 返回值)。
在涉及数组的分治题中,左右下标 `l` 和 `r` 必然会作为函数入参,因为它能用于表示当前所处理的区间,即小问题的范围。
对于本题,仅将最大子数组和(答案)作为返回值并不足够,因为单纯从小区间的解无法直接推导出大区间的解,我们需要一些额外信息来辅助求解。
具体的,我们可以将返回值设计成四元组,分别代表 `区间和`,`前缀最大值`,`后缀最大值` 和 `最大子数组和`,用 `[sum, lm, rm, max]` 表示。
有了完整的函数签名 `int[] dfs(int[] nums, int l, int r)`,考虑如何实现分治:
1. 根据当前区间 $[l, r]$ 的长度进行分情况讨论:
1. 若 $l = r$,只有一个元素,区间和为 $nums[l]$,而 最大子数组和、前缀最大值 和 后缀最大值 由于允许“空数组”,因此均为 $\max(nums[l], 0)$
2. 否则,将当前问题划分为两个子问题,通常会划分为两个相同大小的子问题,划分为 $[l, mid]$ 和 $[mid + 1, r]$ 两份,递归求解,其中 $mid = \left \lfloor \frac{l + r}2{} \right \rfloor$
随后考虑如何用“子问题”的解合并成“原问题”的解:
1. **合并区间和 (`sum`):** 当前问题的区间和等于左右两个子问题的区间和之和,即 `sum = left[0] + right[0]`。
2. **合并前缀最大值 (`lm`):** 当前问题的前缀最大值可以是左子问题的前缀最大值,或者左子问题的区间和加上右子问题的前缀最大值。即 `lm = max(left[1], left[0] + right[1])`。
3. **合并后缀最大值 (`rm`):** 当前问题的后缀最大值可以是右子问题的后缀最大值,或者右子问题的区间和加上左子问题的后缀最大值。即 `rm = max(right[2], right[0] + left[2])`。
4. **合并最大子数组和 (`max`):** 当前问题的最大子数组和可能出现在左子问题、右子问题,或者跨越左右两个子问题的边界。因此,`max` 可以通过 `max(left[3], right[3], left[2] + right[1])` 来得到。
一些细节:由于我们在计算 `lm`、`rm` 和 `max` 的时候允许数组为空,而答案对子数组的要求是至少包含一个元素。因此对于 `nums` 全为负数的情况,我们会错误得出最大子数组和为 `0` 的答案。针对该情况,需特殊处理,遍历一遍 `nums`,若最大值为负数,直接返回最大值。
Java 代码:
```Java
class Solution {
// 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]
int[] dfs(int[] nums, int l, int r) {
if (l == r) {
int t = Math.max(nums[l], 0);
return new int[]{nums[l], t, t, t};
}
// 划分成两个子区间,分别求解
int mid = l + r >> 1;
int[] left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);
// 组合左右子区间的信息,得到当前区间的信息
int[] ans = new int[4];
ans[0] = left[0] + right[0]; // 当前区间和
ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值
ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值
ans[3] = Math.max(Math.max(left[3], right[3]), left[2] + right[1]); // 最大子数组和
return ans;
}
public int maxSubArray(int[] nums) {
int m = nums[0];
for (int x : nums) m = Math.max(m, x);
if (m <= 0) return m;
return dfs(nums, 0, nums.length - 1)[3];
}
}
```
C++ 代码:
```C++
class Solution {
public:
// 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]
vector<int> dfs(vector<int>& nums, int l, int r) {
if (l == r) {
int t = max(nums[l], 0);
return {nums[l], t, t, t};
}
// 划分成两个子区间,分别求解
int mid = l + r >> 1;
auto left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);
// 组合左右子区间的信息,得到当前区间的信息
vector<int> ans(4);
ans[0] = left[0] + right[0]; // 当前区间和
ans[1] = max(left[1], left[0] + right[1]); // 当前区间前缀最大值
ans[2] = max(right[2], right[0] + left[2]); // 当前区间后缀最大值
ans[3] = max({left[3], right[3], left[2] + right[1]}); // 最大子数组和
return ans;
}
int maxSubArray(vector<int>& nums) {
int m = nums[0];
for (int x : nums) m = max(m, x);
if (m <= 0) return m;
return dfs(nums, 0, nums.size() - 1)[3];
}
};
```
Python 代码:
```Python
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
def dfs(l, r):
if l == r:
t = max(nums[l], 0)
return [nums[l], t, t, t]
# 划分成两个子区间,分别求解
mid = (l + r) // 2
left, right = dfs(l, mid), dfs(mid + 1, r)
# 组合左右子区间的信息,得到当前区间的信息
ans = [0] * 4
ans[0] = left[0] + right[0] # 当前区间和
ans[1] = max(left[1], left[0] + right[1]) # 当前区间前缀最大值
ans[2] = max(right[2], right[0] + left[2]) # 当前区间后缀最大值
ans[3] = max(left[3], right[3], left[2] + right[1]) # 最大子数组和
return ans
m = max(nums)
if m <= 0:
return m
return dfs(0, len(nums) - 1)[3]
```
TypeScript 代码:
```TypeScript
function maxSubArray(nums: number[]): number {
const dfs = function (l: number, r: number): number[] {
if (l == r) {
const t = Math.max(nums[l], 0);
return [nums[l], t, t, t];
}
// 划分成两个子区间,分别求解
const mid = (l + r) >> 1;
const left = dfs(l, mid), right = dfs(mid + 1, r);
// 组合左右子区间的信息,得到当前区间的信息
const ans = Array(4).fill(0);
ans[0] = left[0] + right[0]; // 当前区间和
ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值
ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值
ans[3] = Math.max(left[3], right[3], left[2] + right[1]); // 最大子数组和
return ans;
}
const m = Math.max(...nums);
if (m <= 0) return m;
return dfs(0, nums.length - 1)[3];
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 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][j] <= 100$ | ### 按照「形状」进行模拟
我们可以按「圈」进行划分打印。
使用「左上角」$(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 = mat[0].length;
circle(mat, 0, 0, m - 1, n - 1, ans);
return ans;
}
// 遍历 以 (x1, y1) 作为左上角,(x2, y2) 作为右下角形成的「圈」
void circle(int[][] mat, int x1, int y1, int x2, int y2, List<Integer> ans) {
if (x2 < x1 || y2 < y1) return;
// 只有一行时,按「行」遍历
if (x1 == x2) {
for (int i = y1; i <= y2; i++) ans.add(mat[x1][i]);
return;
}
// 只有一列时,按「列」遍历
if (y1 == y2) {
for (int i = x1; i <= x2; i++) ans.add(mat[i][y2]);
return;
}
// 遍历当前「圈」
for (int i = y1; i < y2; i++) ans.add(mat[x1][i]);
for (int i = x1; i < x2; i++) ans.add(mat[i][y2]);
for (int i = y2; i > y1; i--) ans.add(mat[x2][i]);
for (int i = x2; i > x1; i--) ans.add(mat[i][y1]);
// 往里收一圈,继续遍历
circle(mat, x1 + 1, y1 + 1, x2 - 1, y2 - 1, ans);
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(1)$
---
### 按照「方向」进行模拟
事实上,我们还可以根据「方向」进行模拟。
因为每一圈的打印输出都是按照特定的「四个方向」进行的。
这种解法更为简洁。而触发方向转换的时机:
1. 下一步发生位置溢出
2. 回到了本圈的起点
代码:
```Java
class Solution {
int INF = 101;
public List<Integer> spiralOrder(int[][] mat) {
List<Integer> ans = new ArrayList<>();
int m = mat.length, n = mat[0].length;
// 定义四个方向
int[][] dirs = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};
for (int x = 0, y = 0, d = 0, i = 0; i < m * n; i++) {
ans.add(mat[x][y]);
mat[x][y] = INF;
// 下一步要到达的位置
int nx = x + dirs[d][0], ny = y + dirs[d][1];
// 如果下一步发生「溢出」或者已经访问过(说明四个方向已经走过一次)
if (nx < 0 || nx >= m || ny < 0 || ny >= n || mat[nx][ny] == INF) {
d = (d + 1) % 4;
nx = x + dirs[d][0]; ny = y + dirs[d][1];
}
x = nx; y = ny;
}
return ans;
}
}
```
-
```C++
class Solution {
public:
const int dir[4][2] = {{0,1}, {1,0},{0,-1},{-1,0}};
vector<int> spiralOrder(vector<vector<int>>& matrix) {
int idx = 0, m = matrix.size(), n = matrix[0].size();
vector<int> res;
for(int x = 0, y = 0, d = 0; idx < m * n; idx++){
res.push_back(matrix[x][y]);
matrix[x][y] = 101;
int t_x = x + dir[d][0], t_y = y + dir[d][1];
if(t_x < 0 or t_x >= m or t_y < 0 or t_y >= n or matrix[t_x][t_y] == 101){
d = (d + 1) % 4;
t_x = x + dir[d][0],t_y = y + dir[d][1];
}
x = t_x, y = t_y;
}
return res;
}
};
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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;
while (i >= 0 && s.charAt(i) != ' ') i--;
return j - i;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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);
return ans;
}
void circle(int x1, int y1, int x2, int y2, int start, int[][] ans) {
if (x2 < x1 || y2 < y1) return ;
if (x1 == x2) {
ans[x1][y1] = start;
return;
}
int val = start;
for (int i = y1; i < y2; i++) ans[x1][i] = val++;
for (int i = x1; i < x2; i++) ans[i][y2] = val++;
for (int i = y2; i > y1; i--) ans[x2][i] = val++;
for (int i = x2; i > x1; i--) ans[i][y1] = val++;
circle(x1 + 1, y1 + 1, x2 - 1, y2 - 1, val, ans);
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 按照「方向」进行模拟
事实上,我们还可以根据「方向」进行模拟。
因为每一圈的构建都是按照特定的「四个方向」进行的。
这种解法更为简洁。而触发方向转换的时机:
1. 下一步发生位置溢出
2. 回到了本圈的起点
代码:
```Java
class Solution {
public int[][] generateMatrix(int n) {
int[][] ans = new int[n][n];
// 定义四个方向
int[][] dirs = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};
for (int x = 0, y = 0, d = 0, i = 1; i <= n * n; i++) {
ans[x][y] = i;
// 下一步要到达的位置
int nx = x + dirs[d][0], ny = y + dirs[d][1];
// 如果下一步发生「溢出」或者已经访问过(说明四个方向已经走过一次)
if (nx < 0 || nx >= n || ny < 0 || ny >= n || ans[nx][ny] != 0) {
d = (d + 1) % 4;
nx = x + dirs[d][0]; ny = y + dirs[d][1];
}
x = nx; y = ny;
}
return ans;
}
}
```
-
```C++
class Solution {
public:
const int dir[4][2] = { {0,1},{1,0},{0,-1},{-1,0}};
vector<vector<int>> generateMatrix(int n) {
vector<vector<int>> res(n,vector<int>(n,0));
for(int i = 1, x = 0, y = 0, d = 0; i <= n * n; i++){
res[x][y] = i;
int t_x = x + dir[d][0],t_y = y + dir[d][1];
if(t_x < 0 or t_x >= n or t_y < 0 or t_y >= n or res[t_x][t_y] != 0){
d = (d + 1) % 4;
t_x = x + dir[d][0],t_y = y + dir[d][1];
}
x = t_x, y = t_y;
}
return res;
}
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 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();
ans = d.peek().val;
while (sz-- > 0) {
TreeNode poll = d.pollFirst();
if (poll.left != null) d.addLast(poll.left);
if (poll.right != null) d.addLast(poll.right);
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:最坏情况下所有节点都在同一层,复杂度为 $O(n)$
---
### DFS
同理,可以使用 `DFS` 进行树的遍历,每次优先 `DFS` 当前节点的左子树,每次第一次搜索到当前深度 `depth` 时,必然是当前深度的最左节点,此时用当前节点值来更新 `ans`。
代码:
```Java
class Solution {
int max, ans;
public int findBottomLeftValue(TreeNode root) {
dfs(root, 1);
return ans;
}
void dfs(TreeNode root, int depth) {
if (root == null) return ;
if (depth > max) {
max = depth; ans = root.val;
}
dfs(root.left, depth + 1);
dfs(root.right, depth + 1);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:最坏情况下退化成链,递归深度为 $n$。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 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);
while (!d.isEmpty()) {
int sz = d.size(), max = d.peek().val;
while (sz-- > 0) {
TreeNode node = d.pollFirst();
max = Math.max(max, node.val);
if (node.left != null) d.addLast(node.left);
if (node.right != null) d.addLast(node.right);
}
ans.add(max);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### DFS
同理,可以借助 `DFS` 进行求解,在 `DFS` 整棵树时,同时传递一个当前层深度 `depth`,使用「哈希表」维护所有深度的最大节点值,同时使用变量 `max` 记录最大深度。
结束 `DFS` 后,使用哈希表构造答案。
代码:
```Java
class Solution {
int max = 0;
Map<Integer, Integer> map = new HashMap<>();
public List<Integer> largestValues(TreeNode root) {
List<Integer> ans = new ArrayList<>();
dfs(root, 1);
for (int i = 1; i <= max; i++) ans.add(map.get(i));
return ans;
}
void dfs(TreeNode node, int depth) {
if (node == null) return ;
max = Math.max(max, depth);
map.put(depth, Math.max(map.getOrDefault(depth, Integer.MIN_VALUE), node.val));
dfs(node.left, depth + 1);
dfs(node.right, depth + 1);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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$
2. 枚举区间左端点 $l$,同时根据区间大小 $len$ 和左端点计算出区间右端点 $r = l + len - 1$
3. 通过状态转移方程求 $f[l][r]$ 的值
因此,我们 **定义 $f[l][r]$ 为考虑区间 $[l, r]$ 的最长回文子序列长度为多少。**
不失一般性的考虑 $f[l][r]$ 该如何转移。
由于我们的状态定义 **没有限制** 回文串中必须要选 $s[l]$ 或者 $s[r]$。
我们对边界字符 $s[l]$ 和 $s[r]$ 分情况讨论,最终的 $f[l][r]$ 应该在如下几种方案中取 $max$ :
* 形成的回文串一定不包含 $s[l]$ 和 $s[r]$,即完全不考虑 $s[l]$ 和 $s[r]$:
$$
f[l][r] = f[l + 1][r - 1]
$$
* 形成的回文串可能包含 $s[l]$,但一定不包含 $s[r]$:
$$
f[l][r] = f[l][r - 1]
$$
* 形成的回文串可能包含 $s[r]$,但一定不包含 $s[l]$:
$$
f[l][r] = f[l + 1][r]
$$
* 形成的回文串可能包含 $s[l]$,也可能包含 $s[r]$,根据 $s[l]$ 和 $s[r]$ 是否相等:
$$
f[l][r] = \begin{cases}
f[l + 1][r - 1] + 2 & s[l] = s[r] \\
f[l + 1][r - 1] & s[l] \neq s[r] \\
\end{cases}
$$
需要说明的是,上述几种情况可以确保我们做到「不漏」,但不能确保「不重」,对于求最值问题,我们只需要确保「不漏」即可,某些状态重复参与比较,不会影响结果的正确性。
> 一些细节:我们需要特判掉长度为 $1$ 和 $2$ 的两种基本情况。当长度为 $1$ 时,必然回文,当长度为 $2$ 时,当且仅当两字符相等时回文。
代码:
```Java
class Solution {
public int longestPalindromeSubseq(String s) {
int n = s.length();
char[] cs = s.toCharArray();
int[][] f = new int[n][n];
for (int len = 1; len <= n; len++) {
for (int l = 0; l + len - 1 < n; l++) {
int r = l + len - 1;
if (len == 1) {
f[l][r] = 1;
} else if (len == 2) {
f[l][r] = cs[l] == cs[r] ? 2 : 1;
} else {
f[l][r] = Math.max(f[l + 1][r], f[l][r - 1]);
f[l][r] = Math.max(f[l][r], f[l + 1][r - 1] + (cs[l] == cs[r] ? 2 : 0));
}
}
}
return f[0][n - 1];
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 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 <-- 1 <-- 4 => 2 1 3
第三步: 2 1 <-- 3 => 2 2 2
```
示例 2:
```
输入:machines = [0,3,0]
输出:2
解释:
第一步: 0 <-- 3 0 => 1 2 0
第二步: 1 2 --> 0 => 1 1 1
```
示例 3:
```
输入:machines = [0,2,0]
输出:-1
解释:
不可能让所有三个洗衣机同时剩下相同数量的衣物。
```
提示:
* $n = machines.length$
* $1 <= n <= 10^4$
* $0 <= machines[i] <= 10^5$ | ### 基本分析
由于最终是要让所有洗衣机衣服相等,因此无解的情况很好分析,如果衣服数量 $sum$ 不能整除洗衣机数量 $n$ 的话,则返回 $-1$,否则必然有解(最坏情况下,每次只移动一件衣服,也可以使得衣服均分),要求最小移动次数。
由于每次操作都可以选任意台机器进行,不难猜想到最小移动次数为 **所有机器的「最小运输衣服数量」中的最大值**。
计算某台洗衣机的「最小运输衣服数量」为经过当前机器的衣服数量(每次只能运输一件衣服),其值等于「起始左边衣服总量 与 最终左边衣服总量 的差值」+「起始右边衣服总量 与 最终右边衣服总量 的差值」,这里的差值都需要与 $0$ 取 $\max$ 代指缺少衣服的数量(因为如果是多余数量的话,可以通过同时传输来满足增加缺少的一边,减少多余的一边)。
我们猜想取所有机器中的「最小操作次数」的最大值即是答案。
**但这显然是理论的最小操作次数,我们来证明最终答案等于该值。**
假设理论最下操作次数为 $cnt$,真实答案为 $ans$,那么天然有 $ans \geq cnt$,我们需要通过证明 $ans \leq cnt$ 恒成立,来得证 $ans = cnt$。
可以通过「反证法」来证明 $ans \leq cnt$ 恒成立,假设 $ans > cnt$,即在某个特定序列中,实际最小操作次数 $ans$ 大于 $cnt$,假定我们是在位置 $x$ 中取得这个实际最小操作次数。
那么我们需要思考:**在没有无效传输的前提,什么情况下需要在 $x$ 位置传输大于 $cnt$ 件衣服来达到最终平衡。**
> 注:无效的意思是,衣服从位置 $x$ 的一边传到另外一边,随后又传输回来。
(注 1)当且仅当位置 $x$ 本身衣服为 $0$ 时,会发生该种情况。
也就是说首次传输,并没有实现「从 $x$ 左边往右边传输衣服」或者「从 $x$ 右边往左边传输衣服」的目的,而是需要先往位置 $x$ 填送衣服。
那么是否可能由起始衣服为 $0$ 的位置来取得 $ans$ 呢?我们通过「反证法」来证明「$ans$ 不可能由衣服为 $0$ 的起始位置得出」。
由于位置 $x$ 的起始数量为 $0$,那么位置 $x$ 必然至少有一侧的起始数量小于最终数量的(缺少衣服的),可以继续利用「反证法」来证明:
* 如果是两边都多于最终数量,说明最终是两边衣服流向位置 $x$,而且我们得到的 $ans$ 是两边的缺少总和,这种情况下得到的 $ans$ 为 $0$,但是整体衣服本身不相等,必然要消耗步数,必然不为 $0$,因此该情况不存在。
既然位置 $x$ 至少有一侧的起始数量小于最终数量的(缺少衣服的),那么自然我们可以将位置 $x$ 归到那一边,使得那一侧缺少衣服的数量更多,从而使答案 $ans$ 更大。这与 $ans$ 为所有位置中的「最小操作次数」最大的位置矛盾。
**得证,取得 $ans$ 的位置 $x$ 起始衣服必然不为 $0$。**
如果位置 $x$ 起始衣服必然不为 $0$,那么(注 1)的条件不成立,则 $ans > cnt$ 恒不成立,得证 $ans \leq cnt$ 恒成立。
**至此,我们通过三次「反证法」来证明了结论成立。首先通过「反证法」证明取得 $ans$ 的位置 $x$ 衣服不可能为 $0$;然后根据该位置起始衣服不为 $0$ 的前提条件,来证明 $ans > cnt$ 恒不成立,得证 $ans \leq cnt$ 恒成立,最终结合 $ans \geq cnt$ 来得证 $ans = cnt$。**
---
### 贪心
实现上,首先我们可以求得衣服总和 $sum$ 以及洗衣机数量 $n$,从而判断无解情况(`sum % n != 0`),或者计算最终每台洗衣机的衣服数量 $t = sum / n$。
然后使用两个变量 $ls$ 和 $rs$ 分别表示当前位置「左边的衣服总数」和「右边的衣服总数」,并在从左往右的遍历过程中实时维护。
对于某个位置 $x$ 而言,达到最终平衡需要从 $x$ 右边往左边运送的衣服数量为 $a = \max(i * t - ls, 0)$,即左边的当前的衣服数量与最终状态的衣服数量的差值,与 $0$ 取 $\max$ 含义代表为如果当前左边衣服多于最终衣服数量时,此时不需要消耗从右到左的移动次数(只需要消耗从 $x$ 左边到 $x$ 右边的移动次数);右边分析同理,我们可以得到达到最终平衡需要从 $x$ 左边到右运送的衣服数量为 $b = \max((n - i - 1) * t - rs, 0)$。
在所有位置的 $a + b$ 之间取最大值即是答案。
代码:
```Java
class Solution {
public int findMinMoves(int[] ms) {
int n = ms.length;
int sum = 0;
for (int i : ms) sum += i;
if (sum % n != 0) return -1;
int t = sum / n;
int ls = 0, rs = sum;
int ans = 0;
for (int i = 0; i < n; i++) {
rs -= ms[i];
int a = Math.max(t * i - ls, 0);
int b = Math.max((n - i - 1) * t - rs, 0);
ans = Math.max(ans, a + b);
ls += ms[i];
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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 (总金额) <= 5000
* 1 <= coin (硬币面额) <= 5000
* 硬币种类不超过 500 种
* 结果符合 32 位符号整数 | ### 完全背包(朴素解法)
在 [322. 零钱兑换](https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/) 中,我们求的是「取得特定价值所需要的最小物品个数」。
对于本题,我们求的是「取得特定价值的方案数量」。
**求的东西不一样,但问题的本质没有发生改变,同样属于「组合优化」问题。**
你可以这样来理解什么是组合优化问题:
**被选物品之间不需要满足特定关系,只需要选择物品,以达到「全局最优」或者「特定状态」即可。**
同时硬币相当于我们的物品,每种硬币可以选择「无限次」,很自然的想到「完全背包」。
这时候可以将「完全背包」的状态定义搬过来进行“微调”:
**定义 $f[i][j]$ 为考虑前 $i$ 件物品,凑成总和为 $j$ 的方案数量。**
为了方便初始化,我们一般让 $f[0][x]$ 代表不考虑任何物品的情况。
因此我们有显而易见的初始化条件:$f[0][0] = 1$,其余 $f[0][x] = 0$。
代表当没有任何硬币的时候,存在凑成总和为 0 的方案数量为 1;凑成其他总和的方案不存在。
当「状态定义」与「基本初始化」有了之后,我们不失一般性的考虑 $f[i][j]$ 该如何转移。
对于第 $i$ 个硬币我们有两种决策方案:
* 不使用该硬币:
$$
f[i - 1][j]
$$
* 使用该硬币:由于每个硬币可以被选择多次(容量允许的情况下),因此方案数量应当是选择「任意个」该硬币的方案总和:
$$
\sum_{k = 1}^{\left \lfloor {j / val} \right \rfloor}f[i - 1][j - k * val], val = nums[i - 1]
$$
代码:
```Java
class Solution {
public int change(int cnt, int[] cs) {
int n = cs.length;
int[][] f = new int[n + 1][cnt + 1];
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
int val = cs[i - 1];
for (int j = 0; j <= cnt; j++) {
f[i][j] = f[i - 1][j];
for (int k = 1; k * val <= j; k++) {
f[i][j] += f[i - 1][j - k * val];
}
}
}
return f[n][cnt];
}
}
```
* 时间复杂度:共有 $n * cnt$ 个状态需要转移,每个状态转移最多遍历 $cnt$ 次。整体复杂度为 $O(n * cnt^2)$。
* 空间复杂度:$O(n * cnt)$。
---
### 完全背包(一维优化)
显然二维完全背包求解方案复杂度有点高。
$n$ 的数据范围为 $10^2$,$cnt$ 的数据范围为 $10^3$,总的计算量为 $10^8$ 以上,处于超时边缘(实际测试可通过)。
我们需要对其进行「降维优化」,可以使用最开始讲的 [数学分析方式](https://leetcode-cn.com/problems/perfect-squares/solution/dong-tai-gui-hua-bei-bao-wen-ti-qiang-hu-hcmi/),或者上一讲讲的 [换元优化方式](https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/) 进行降维优化。
由于 [数学分析方式](https://leetcode-cn.com/problems/perfect-squares/solution/dong-tai-gui-hua-bei-bao-wen-ti-qiang-hu-hcmi/) 十分耗时,我们用得更多的 [换元优化方式](https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/)。两者同样具有「可推广」特性。
因为后者更为常用,所以我们再来回顾一下如何进行「直接上手写一维空间优化的版本」 :
1. 在二维解法的基础上,直接取消「物品维度」
2. 确保「容量维度」的遍历顺序为「从小到大」(适用于「完全背包」)
3. 将形如 $f[i - 1][j - k * val]$ 的式子更替为 $f[j - val]$,同时解决「数组越界」问题(将物品维度的遍历修改为从 $val$ 开始)
代码:
```java []
class Solution {
public int change(int cnt, int[] cs) {
int n = cs.length;
int[] f = new int[cnt + 1];
f[0] = 1;
for (int i = 1; i <= n; i++) {
int val = cs[i - 1];
for (int j = val; j <= cnt; j++) {
f[j] += f[j - val];
}
}
return f[cnt];
}
}
```
* 时间复杂度:共有 $n * cnt$ 个状态需要转移,整体复杂度为 $O(n * cnt)$。
* 空间复杂度:$O(cnt)$。 | ### 最后
这是我们「刷穿 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]` ,并将其对应格子中的值变为 $1$
* `void reset()` 将矩阵中所有的值重置为 $0$
示例:
```
输入
["Solution", "flip", "flip", "flip", "reset", "flip"]
[[3, 1], [], [], [], [], []]
输出
[null, [1, 0], [2, 0], [0, 0], null, [2, 0]]
解释
Solution solution = new Solution(3, 1);
solution.flip(); // 返回 [1, 0],此时返回 [0,0]、[1,0] 和 [2,0] 的概率应当相同
solution.flip(); // 返回 [2, 0],因为 [1,0] 已经返回过了,此时返回 [2,0] 和 [0,0] 的概率应当相同
solution.flip(); // 返回 [0, 0],根据前面已经返回过的下标,此时只能返回 [0,0]
solution.reset(); // 所有值都重置为 0 ,并可以再次选择下标返回
solution.flip(); // 返回 [2, 0],此时返回 [0,0]、[1,0] 和 [2,0] 的概率应当相同
```
提示:
* $1 <= m, n <= 10^4$
* 每次调用 `flip` 时,矩阵中至少存在一个值为 $0$ 的格子。
* 最多调用 1000 次 `flip` 和 `reset` 方法。 | ### 双指针
矩阵大小的数据范围为 $10^4$,因此我们不能使用真实构建矩阵的做法来做,同时利用二维的坐标能够唯一对应出编号($idx = row * n + col$),可以将问题转换为一维问题。
一个最为朴素的做法是利用调用次数只有 $10^3$,我们可以在 $[0, m * n)$ 范围内随机出一个下标 $idx$(对应矩阵的某个具体位置),然后从 $idx$ 往两边进行扫描,找到最近一个未被使用的位置,将其进行标记翻转并返回。
该做法相比于一直随机的「拒绝采样」做法,能够确保单次 `flip` 操作中只会调用一次随机方法,同时利用矩阵只有 $10^3$ 个位置被翻转,因而复杂度上具有保证。
代码:
```Java
class Solution {
int m, n;
Set<Integer> set = new HashSet<>();
Random random = new Random(300);
public Solution(int _m, int _n) {
m = _m; n = _n;
}
public int[] flip() {
int a = random.nextInt(m * n), b = a;
while (a >= 0 && set.contains(a)) a--;
while (b < m * n && set.contains(b)) b++;
int c = a >= 0 && !set.contains(a) ? a : b;
set.add(c);
return new int[]{c / n, c % n};
}
public void reset() {
set.clear();
}
}
```
* 时间复杂度:令最大调用次数为 $C = 1000$,即矩阵中最多有 $C$ 个位置被翻转。`flip` 操作的复杂度为 $O(C)$;`reset` 复杂度为 $O(C)$
* 空间复杂度:$O(C)$
---
### 哈希表 + swap
在解法一中,我们将二维问题转化为了一维问题。
起始时,我们只需要在 $[0, m * n)$ 这连续一段的区间内进行随机,但当我们经过了多次翻转后,该区间内的某些位置会被断开,使得数组不再连续。
如果我们希望在每次随机时都采用起始的方式(在连续一段内进行随机),需要确保某些位置被翻转后,剩余位置仍是连续。
具体的,我们可以使用「哈希表」多记录一层映射关系:起始时所有位置未被翻转,我们规定未被翻转的位置其映射值为编号本身($idx = row * n + col$),由于未被翻转的部分具有等值映射关系,因此无须在哈希表中真实存储。当随机到某个位置 $idx$ 时,进行分情况讨论:
* 该位置未被哈希表真实记录(未被翻转):说明 $idx$ 可被直接使用,使用 $idx$ 作为本次随机点。同时将右端点(未被使用的)位置的映射值放到该位置,将右端点左移。确保下次再随机到 $idx$,仍能直接使用 $idx$ 的映射值,同时维护了随机区间的连续性;
* 该位置已被哈希表真实记录(已被翻转):此时直接使用 $idx$ 存储的映射值(上一次交换时的右端点映射值)即可,然后用新的右端点映射值将其进行覆盖,更新右端点。确保下次再随机到 $idx$,仍能直接使用 $idx$ 的映射值,同时维护了随机区间的连续性。
代码:
```Java
class Solution {
int m, n, cnt; // cnt 为剩余数个数,同时 cnt - 1 为区间右端点位置
Map<Integer, Integer> map = new HashMap<>();
Random random = new Random(300);
public Solution(int _m, int _n) {
m = _m; n = _n; cnt = m * n;
}
public int[] flip() {
int x = random.nextInt(cnt--);
int idx = map.getOrDefault(x, x);
map.put(x, map.getOrDefault(cnt, cnt));
return new int[]{idx / n, idx % n};
}
public void reset() {
cnt = m * n;
map.clear();
}
}
```
* 时间复杂度:令最大调用次数为 $C = 1000$,即矩阵中最多有 $C$ 个位置被翻转。`flip` 操作的复杂度为 $O(1)$;`reset` 复杂度为 $O(C)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 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))) {
while (idx < n && Character.isLowerCase(word.charAt(idx))) idx++;
}
return idx == n;
}
}
```
* 时间复杂度:$O(n)$,常数为 $5$。
* 空间复杂度:算法执行过程会产生新的字符串,复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 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
解释: 最长特殊序列可为 "aba" (或 "cdc"),两者均为自身的子序列且不是对方的子序列。
```
示例 2:
```
输入:a = "aaa", b = "bbb"
输出:3
解释: 最长特殊序列是“aaa”和“bbb”。
```
示例 3:
```
输入:a = "aaa", b = "aaa"
输出:-1
解释: 字符串a的每个子序列也是字符串b的每个子序列。同样,字符串b的每个子序列也是字符串a的子序列。
```
提示:
* $1 <= a.length, b.length <= 100$
* `a` 和 `b` 由小写英文字母组成 | ### 脑筋急转弯
当两字符串不同时,我们总能选择长度不是最小的字符串作为答案,而当两字符串相同时,我们无法找到特殊序列。
代码:
```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 = ["aaa","aaa","aa"]
输出: -1
```
提示:
* $2 <= strs.length <= 50$
* $1 <= strs[i].length <= 10$
* `strs[i]` 只包含小写英文字母 | ### 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` 的最长公共子序列长度。若最长公共子序列长度为 `s1` 长度,说明 `s1` 为 `s2` 的子序列,此时 $strs[i]$ 不满足条件,否则我们使用 $strs[i]$ 的长度来更新 `ans`。`check` 函数的复杂度为 $O(m^2)$。
> **不了解 LCS 的同学可以看前置 🧀 : [LCS 模板题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492097&idx=1&sn=f51f29d86df809d8ac43a40a1369b3d6)**
因此总的计算量为 $n^2 \times m^2 = 2.5 * 10^5$,可以过。
代码:
```Java
class Solution {
public int findLUSlength(String[] strs) {
int n = strs.length, ans = -1;
for (int i = 0; i < n; i++) {
if (strs[i].length() <= ans) continue;
boolean ok = true;
for (int j = 0; j < n && ok; j++) {
if (i == j) continue;
if (check(strs[i], strs[j])) ok = false;
}
if (ok) ans = strs[i].length();
}
return ans;
}
boolean check(String s1, String s2) {
int n = s1.length(), m = s2.length();
if (m < n) return false;
int[][] f = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = s1.charAt(i - 1) == s2.charAt(j - 1) ? f[i - 1][j - 1] + 1 : f[i - 1][j - 1];
f[i][j] = Math.max(f[i][j], f[i - 1][j]);
f[i][j] = Math.max(f[i][j], f[i][j - 1]);
if (f[i][j] == n) return true;
}
}
return false;
}
}
```
* 时间复杂度:检查每个 $strs[i]$ 是否符合要求,需要枚举所有的点对,复杂度为 $O(n^2)$;求解 LCS 问题的复杂度为 $O(m^2)$。整体复杂度为 $O(n^2 \times m^2)$
* 空间复杂度:$O(m^2)$ | ### 最后
这是我们「刷穿 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
输出:true
解释:[23, 2, 6, 4, 7] 是大小为 5 的子数组,并且和为 42 。
42 是 6 的倍数,因为 42 = 7 * 6 且 7 是一个整数。
```
示例 3:
```
输入:nums = [23,2,6,4,7], k = 13
输出:false
```
提示:
* $1 <= nums.length <= 10^5$
* $0 <= nums[i] <= 10^9$
* $0 <= sum(nums[i]) <= 2^{31} - 1$
* $1 <= k <= 2^{31} - 1$ | ### 基本分析
这是一道很经典的前缀和题目,类似的原题也在蓝桥杯出现过,坐标在 [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$ 的倍数作为切入点来做。
预处理前缀和数组 $sum$,方便快速求得某一段区间的和。然后假定 $[i, j]$ 是我们的目标区间,那么有:
$$
sum[j] - sum[i - 1] = n * k
$$
经过简单的变形可得:
$$
\frac{sum[j]}{k} - \frac{sum[i - 1]}{k} = n
$$
**要使得两者除 $k$ 相减为整数,需要满足 $sum[j]$ 和 $sum[i - 1]$ 对 $k$ 取余相同。**
也就是说,我们只需要枚举右端点 $j$,然后在枚举右端点 $j$ 的时候检查之前是否出现过左端点 $i$,使得 $sum[j]$ 和 $sum[i - 1]$ 对 $k$ 取余相同。
---
### 前缀和 + HashSet
具体的,使用 `HashSet` 来保存出现过的值。
让循环从 $2$ 开始枚举右端点(根据题目要求,子数组长度至少为 $2$),每次将符合长度要求的位置的取余结果存入 `HashSet`。
如果枚举某个右端点 $j$ 时发现存在某个左端点 $i$ 符合要求,则返回 `True`。
代码:
```Java
class Solution {
public boolean checkSubarraySum(int[] nums, int k) {
int n = nums.length;
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
Set<Integer> set = new HashSet<>();
for (int i = 2; i <= n; i++) {
set.add(sum[i - 2] % k);
if (set.contains(sum[i] % k)) return true;
}
return false;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 拓展(求方案数)
蓝桥杯官网登录经常性罢工,我登录十几次都没登录上去,这里直接截图了 [K 倍区间] 的题目给大家。
写了代码,但很可惜没 OJ 可以测试 🤣
比较简单,应该没啥问题,可以直接参考 🤣
代码:
```Java
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), k = sc.nextInt();
long[] s = new long[n + 1];
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + sc.nextLong();
long ans = 0;
Map<Long, Integer> map = new HashMap<>();
map.put(0L, 1);
for (int i = 1 ; i <= n; i++) {
long u = s[i] % k;
if (map.containsKey(u)) ans += map.get(u);
map.put(u, map.getOrDefault(u, 0) + 1);
}
System.out.println(ans);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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.length <= 1000$
* $1 <= dictionary[i].length <= 1000$
* `s` 和 `dictionary[i]` 仅由小写英文字母组成 | ### 排序 + 双指针 + 贪心
根据题意,我们需要找到 `dictionary` 中为 `s` 的子序列,且「长度最长(优先级 $1$)」及「字典序最小(优先级 $2$)」的字符串。
数据范围全是 $1000$。
我们可以先对 `dictionary` 根据题意进行自定义排序:
1. 长度不同的字符串,按照字符串长度排倒序;
2. 长度相同的,则按照字典序排升序。
然后我们只需要对 `dictionary` 进行顺序查找,找到的第一个符合条件的字符串即是答案。
具体的,我们可以使用「贪心」思想的「双指针」实现来进行检查:
1. 使用两个指针 `i` 和 `j` 分别代表检查到 `s` 和 `dictionary[x]` 中的哪位字符;
2. 当 `s[i] != dictionary[x][j]`,我们使 `i` 指针右移,直到找到 `s` 中第一位与 `dictionary[x][j]` 对得上的位置,然后当 `i` 和 `j` 同时右移,匹配下一个字符;
3. 重复步骤 $2$,直到整个 `dictionary[x]` 被匹配完。
> 证明:对于某个字符 `dictionary[x][j]` 而言,选择 `s` 中 **当前** 所能选择的下标最小的位置进行匹配,对于后续所能进行选择方案,会严格覆盖不是选择下标最小的位置,因此结果不会变差。
Java 代码:
```Java
class Solution {
public String findLongestWord(String s, List<String> dictionary) {
Collections.sort(dictionary, (a,b)->{
if (a.length() != b.length()) return b.length() - a.length();
return a.compareTo(b);
});
int n = s.length();
for (String ss : dictionary) {
int m = ss.length();
int i = 0, j = 0;
while (i < n && j < m) {
if (s.charAt(i) == ss.charAt(j)) j++;
i++;
}
if (j == m) return ss;
}
return "";
}
}
```
C++ 代码:
```C++
class Solution {
public:
string findLongestWord(string s, vector<string>& dictionary) {
sort(dictionary.begin(), dictionary.end(), [](const string& a, const string& b) {
if (a.length() != b.length()) return b.length() < a.length();
return a < b;
});
int n = s.length();
for (const string& word : dictionary) {
int m = word.length();
int i = 0, j = 0;
while (i < n && j < m) {
if (s[i] == word[j]) j++;
i++;
}
if (j == m) return word;
}
return "";
}
};
```
Python 代码:
```Python
class Solution:
def findLongestWord(self, s: str, dictionary: List[str]) -> str:
dictionary.sort(key=lambda x: (-len(x), x))
n = len(s)
for word in dictionary:
m = len(word)
i, j = 0, 0
while i < n and j < m:
if s[i] == word[j]: j += 1
i += 1
if j == m: return word
return ""
```
TypeScript 代码:
```TypeScript
function findLongestWord(s: string, dictionary: string[]): string {
dictionary.sort((a, b) => {
if (a.length !== b.length) return b.length - a.length;
return a.localeCompare(b);
});
const n = s.length;
for (const word of dictionary) {
const m = word.length;
let i = 0, j = 0;
while (i < n && j < m) {
if (s[i] === word[j]) j++;
i++;
}
if (j === m) return word;
}
return "";
};
```
* 时间复杂度:令 `n` 为 `s` 的长度,`m` 为 `dictionary` 的长度。排序复杂度为 $O(m\log{m})$;对 `dictionary` 中的每个字符串进行检查,单个字符串的检查复杂度为 $O(\min(n, dictionary[i]))\approx O(n)$。整体复杂度为 $O(m\log{m} + m \times n)$
* 空间复杂度:$O(\log{m})$ | ### 最后
这是我们「刷穿 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 = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1);
Map<Integer, Integer> map = new HashMap<>();
map.put(0, 0);
for (int i = 1; i <= n; i++) {
int t = sum[i];
if (map.containsKey(t)) ans = Math.max(ans, i - map.get(t));
if (!map.containsKey(t)) map.put(t, i);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function findMaxLength(nums: number[]): number {
let n = nums.length, ans = 0
const sum = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1)
const map = new Map<number, number>()
map.set(0, 0)
for (let i = 1; i <= n; i++) {
const t = sum[i]
if (map.has(t)) ans = Math.max(ans, i - map.get(t))
if (!map.has(t)) map.set(t, i)
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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, 1]:
第 1 个位置(i=1)上的数字是2,2能被 i(i=1)整除
第 2 个位置(i=2)上的数字是1,i(i=2)能被 1 整除
```
说明:
* $N$ 是一个正整数,并且不会超过 $15$。 | ### 状态压缩 DP
利用数据范围不超过 $15$,我们可以使用「状态压缩 DP」进行求解。
**使用一个二进制数表示当前哪些数已被选,哪些数未被选,目的是为了可以使用位运算进行加速。**
我们可以通过一个具体的样例,来感受下「状态压缩」是什么意思:
例如 $(000...0101)_2$ 代表值为 $1$ 和值为 $3$ 的数字已经被使用了,而值为 $2$ 的节点尚未被使用。
然后再来看看使用「状态压缩」的话,一些基本的操作该如何进行:
假设变量 $state$ 存放了「当前数的使用情况」,当我们需要检查值为 $k$ 的数是否被使用时,可以使用位运算 `a = (state >> k) & 1`,来获取 $state$ 中第 $k$ 位的二进制表示,如果 `a` 为 $1$ 代表值为 $k$ 的数字已被使用,如果为 $0$ 则未被访问。
**定义 $f[i][state]$ 为考虑前 $i$ 个数,且当前选择方案为 $state$ 的所有方案数量。**
一个显然的初始化条件为 $f[0][0] = 1$,代表当我们不考虑任何数($i = 0$)的情况下,一个数都不被选择($state = 0$)为一种合法方案。
不失一般性的考虑 $f[i][state]$ 该如何转移,由于本题是求方案数,我们的转移方程必须做到「不重不漏」。
我们可以通过枚举当前位置 $i$ 是选哪个数,假设位置 $i$ 所选数值为 $k$,首先 $k$ 值需要同时满足如下两个条件:
* $state$ 中的第 $k$ 位为 $1$;
* 要么 $k$ 能被 $i$ 整除,要么 $i$ 能被 $k$ 整除。
那么根据状态定义,位置 $i$ 选了数值 $k$,通过位运算我们可以直接得出决策位置 $i$ 之前的状态是什么:$state \& (\lnot (1 << (k - 1)))$,代表将 $state$ 的二进制表示中的第 $k$ 位置 $0$。
最终的 $f[i][state]$ 为当前位置 $i$ 选择的是所有合法的 $k$ 值的方案数之和:
$$
f[i][state] = \sum_{k = 1}^{n} f[i - 1][state \& (\lnot (1 << (k - 1)))]
$$
> 一些细节:由于给定的数值范围为 $[1,n]$,但实现上为了方便,我们使用 $state$ 从右往左的第 $0$ 位表示数值 $1$ 选择情况,第 $1$ 位表示数值 $2$ 的选择情况 ... 即对选择数值 $k$ 做一个 $-1$ 的偏移。
代码:
```Java
class Solution {
public int countArrangement(int n) {
int mask = 1 << n;
int[][] f = new int[n + 1][mask];
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
// 枚举所有的状态
for (int state = 0; state < mask; state++) {
// 枚举位置 i(最后一位)选的数值是 k
for (int k = 1; k <= n; k++) {
// 首先 k 在 state 中必须是 1
if (((state >> (k - 1)) & 1) == 0) continue;
// 数值 k 和位置 i 之间满足任一整除关系
if (k % i != 0 && i % k != 0) continue;
// state & (~(1 << (k - 1))) 代表将 state 中数值 k 的位置置零
f[i][state] += f[i - 1][state & (~(1 << (k - 1)))];
}
}
}
return f[n][mask - 1];
}
}
```
* 时间复杂度:共有 $n * 2^n$ 的状态需要被转移,每次转移复杂度为 $O(n)$,整体复杂度为 $O(n^2 * 2^n)$
* 空间复杂度:$O(n * 2^n)$
---
### 状态压缩 DP(优化)
通过对朴素的状压 DP 的分析,我们发现,在决策第 $i$ 位的时候,理论上我们应该使用的数字数量也应该为 $i$ 个。
但这一点在朴素状压 DP 中并没有体现,这就导致了我们在决策第 $i$ 位的时候,仍然需要对所有的 $state$ 进行计算检查(即使是那些二进制表示中 $1$ 的出现次数不为 $i$ 个的状态)。
因此我们可以换个思路进行枚举(使用新的状态定义并优化转移方程)。
**定义 $f[state]$ 为当前选择数值情况为 $state$ 时的所有方案的数量。**
这样仍然有 $f[0] = 1$ 的初始化条件,最终答案为 $f[(1 << n) - 1]$。
不失一般性考虑 $f[state]$ 如何计算:
**从当前状态 $state$ 进行出发,检查 $state$ 中的每一位 $1$ 作为最后一个被选择的数值,这样仍然可以确保方案数「不重不漏」的被统计,同时由于我们「从小到大」对 $state$ 进行枚举,因此计算 $f[state]$ 所依赖的其他状态值必然都已经被计算完成。**
同样的,我们仍然需要确保 $state$ 中的那一位作为最后一个的 $1$ 需要与所放的位置成整除关系。
因此我们需要一个计算 $state$ 的 $1$ 的个数的方法,这里使用 $lowbit$ 实现即可。
最终的 $f[state]$ 为当前位置选择的是所有合法值的方案数之和:
$$
f[state] = \sum_{i = 0}^{n}f[state \& ( \lnot (1 << i))]
$$
代码:
```Java
class Solution {
int getCnt(int x) {
int ans = 0;
while (x != 0) {
x -= (x & -x); // lowbit
ans++;
}
return ans;
}
public int countArrangement(int n) {
int mask = 1 << n;
int[] f = new int[mask];
f[0] = 1;
// 枚举所有的状态
for (int state = 1; state < mask; state++) {
// 计算 state 有多少个 1(也就是当前排序长度为多少)
int cnt = getCnt(state);
// 枚举最后一位数值为多少
for (int i = 0; i < n; i++) {
// 数值在 state 中必须是 1
if (((state >> i) & 1) == 0) continue;
// 数值(i + 1)和位置(cnt)之间满足任一整除关系
if ((i + 1) % cnt != 0 && cnt % (i + 1) != 0) continue;
// state & (~(1 << i)) 代表将 state 中所选数值的位置置零
f[state] += f[state & (~(1 << i))];
}
}
return f[mask - 1];
}
}
```
* 时间复杂度:共有 $2^n$ 的状态需要被转移,每次转移复杂度为 $O(n)$,整体复杂度为 $O(n * 2^n)$
* 空间复杂度:$O(2^n)$
---
### 总结
不难发现,其实两种状态压缩 DP 的思路其实是完全一样的。
只不过在朴素状压 DP 中我们是显式的枚举了考虑每一种长度的情况(存在维度 $i$),而在状压 DP(优化)中利用则 $state$ 中的 $1$ 的个数中蕴含的长度信息。 | ### 最后
这是我们「刷穿 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]],[]]
输出:
[null,0]
解释:
Solution solution = new Solution([1]);
solution.pickIndex(); // 返回 0,因为数组中只有一个元素,所以唯一的选择是返回下标 0。
```
示例 2:
```
输入:
["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
[[[1,3]],[],[],[],[],[]]
输出:
[null,1,1,1,1,0]
解释:
Solution solution = new Solution([1, 3]);
solution.pickIndex(); // 返回 1,返回下标 1,返回该下标概率为 3/4 。
solution.pickIndex(); // 返回 1
solution.pickIndex(); // 返回 1
solution.pickIndex(); // 返回 1
solution.pickIndex(); // 返回 0,返回下标 0,返回该下标概率为 1/4 。
由于这是一个随机问题,允许多个答案,因此下列输出都可以被认为是正确的:
[null,1,1,1,1,0]
[null,1,1,1,1,1]
[null,1,1,1,0,0]
[null,1,1,1,0,1]
[null,1,0,1,0,0]
......
诸若此类。
```
提示:
* $1 <= w.length <= 10000$
* $1 <= w[i] <= 10^5$
* `pickIndex` 将被调用不超过 $10000$ 次 | ### 前缀和 + 二分
根据题意,权重值 $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[n - 1]]$ 数轴。
使用随机函数参数产生 $[1, sum[n - 1]]$ 范围内的随机数,通过「二分」前缀和数组即可找到分布位置对应的原始下标值。
代码:
```Java
class Solution {
int[] sum;
public Solution(int[] w) {
int n = w.length;
sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + w[i - 1];
}
public int pickIndex() {
int n = sum.length;
int t = (int) (Math.random() * sum[n - 1]) + 1;
int l = 1, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (sum[mid] >= t) r = mid;
else l = mid + 1;
}
return r - 1;
}
}
```
* 时间复杂度:`Solution` 类的构造方法整体复杂度为 $O(n)$;`pickIndex` 的复杂度为 $O(\log{n})$
* 空间复杂度:$O(n)$
---
### 模拟(桶轮询)
利用 OJ 不太聪明(对权重分布做近似检查),我们可以构造一个最小轮询序列(权重精度保留到小数点一位),并使用 $(i, cnt)$ 的形式进行存储,代表下标 $i$ 在最小轮询序列中出现次数为 $cnt$。
然后使用两个编号 $bid$ 和 $iid$ 来对桶进行轮询返回(循环重置 & 跳到下一个桶)。
**该解法的最大好处是不需要使用 random 函数,同时返回的连续序列满足每一段(长度不短于最小段)都符合近似权重分布。**
代码:
```Java
class Solution {
// 桶编号 / 桶内编号 / 总数
int bid, iid, tot;
List<int[]> list = new ArrayList<>();
public Solution(int[] w) {
int n = w.length;
double sum = 0, min = 1e9;
for (int i : w) {
sum += i;
min = Math.min(min, i);
}
double minv = min / sum;
int k = 1;
while (minv * k < 1) k *= 10;
for (int i = 0; i < n; i++) {
int cnt = (int)(w[i] / sum * k);
list.add(new int[]{i, cnt});
tot += cnt;
}
}
public int pickIndex() {
if (bid >= list.size()) {
bid = 0; iid = 0;
}
int[] info = list.get(bid);
int id = info[0], cnt = info[1];
if (iid >= cnt) {
bid++; iid = 0;
return pickIndex();
}
iid++;
return id;
}
}
```
* 时间复杂度:计算 $k$ 的操作只会发生一次,可以看作是一个均摊到每个下标的常数计算,`Solution` 类的构造方法的整体复杂度可看作 $O(n)$;`pickIndex` 的复杂度为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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,但我们只应返回不同的数对的数量。
```
示例 2:
```
输入:nums = [1, 2, 3, 4, 5], k = 1
输出:4
解释:数组中有四个 1-diff 数对, (1, 2), (2, 3), (3, 4) 和 (4, 5)。
```
示例 3:
```
输入:nums = [1, 3, 1, 5, 4], k = 0
输出:1
解释:数组中只有一个 0-diff 数对,(1, 1)。
```
提示:
* $1 <= nums.length <= 10^4$
* $-10^7 <= nums[i] <= 10^7$
* $0 <= k <= 10^7$ | ### 哈希表
一个简单的想法是先使用「哈希表」进行计数。
对于每个 $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 {
public int findPairs(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
int ans = 0;
for (int i : nums) {
if (map.get(i) == 0) continue;
if (k == 0) {
if (map.get(i) > 1) ans++;
} else {
int a = i - k, b = i + k;
if (map.getOrDefault(a, 0) > 0) ans++;
if (map.getOrDefault(b, 0) > 0) ans++;
}
map.put(i, 0);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 离散化 + 二分
我们知道可以使用「数组」充当「哈希表」来减少常数,但由于 $nums[i]$ 的值域大小为 $2 \times 10^7$,可能会有 `MLE` 风险。
我们需要对 $nums$ 进行离散化,预处理出一个去重且有序的数组 `list`。
在统计答案时,我们不再需要在 `nums` 基础上统计,而可以直接在去重数组 `list` 上进行统计,同时将对「数值」的统计操作转换为对「下标」的统计操作。
代码:
```Java
class Solution {
static int[] cnt = new int[10010];
List<Integer> list;
int find(int x) {
int n = list.size(), l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (list.get(mid) >= x) r = mid;
else l = mid + 1;
}
return list.get(r) == x ? r : -1;
}
public int findPairs(int[] nums, int k) {
Arrays.sort(nums);
list = new ArrayList<>();
for (int i : nums) {
if (list.isEmpty() || i != list.get(list.size() - 1)) list.add(i);
}
Arrays.fill(cnt, 0);
for (int i : nums) cnt[find(i)]++;
int ans = 0, idx = 0;
for (int i : list) {
if (k == 0) {
if (cnt[idx] > 1) ans++;
} else {
int a = find(i - k), b = find(i + k);
if (a != -1 && cnt[a] > 0) ans++;
if (b != -1 && cnt[b] > 0) ans++;
}
cnt[idx++] = 0;
}
return ans;
}
}
```
* 时间复杂度:排序离散化复杂度为 $O(n\log{n})$,统计答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 离散化 + 双指针
跟进一步的,对于 $x = nums[i]$ 而言,我们每次都在整段的 `list` 中二分找 $a = nums[i] - k$ 和 $b = nums[i] + k$ 的下标,导致我们统计 $nums[i]$ 对答案的贡献时复杂度为 $O(\log{n})$,统计所有 $nums[i]$ 对答案的贡献为 $O(n\log{n})$。
实际上,利用 `list` 本身的有序性,我们在从前往后处理每个 $nums[idx]$ 时,对应的 $a$ 和 $b$ 也必然是逐步增大,因此我们可以使用「双指针」来避免「二分」操作,使得统计所有 $nums[i]$ 对答案贡献的复杂度从 $O(n\log{n})$ 下降到 $O(n)$。
代码:
```Java
class Solution {
static int[] cnt = new int[10010];
public int findPairs(int[] nums, int k) {
Arrays.sort(nums);
List<Integer> list = new ArrayList<>();
for (int i : nums) {
if (list.isEmpty() || i != list.get(list.size() - 1)) list.add(i);
}
Arrays.fill(cnt, 0);
for (int i = 0, j = 0; i < nums.length; i++) {
if (nums[i] != list.get(j)) j++;
cnt[j]++;
}
int n = list.size(), idx = 0, ans = 0, l = 0, r = 0;
for (int i : list) {
if (k == 0) {
if (cnt[idx] > 1) ans++;
} else {
int a = i - k, b = i + k;
while (l < n && list.get(l) < a) l++;
while (r < n && list.get(r) < b) r++;
if (l < n && list.get(l) == a && cnt[l] > 0) ans++;
if (r < n && list.get(r) == b && cnt[r] > 0) ans++;
}
cnt[idx++] = 0;
}
return ans;
}
}
```
* 时间复杂度:排序离散化复杂度为 $O(n\log{n})$,统计答案复杂度为 $O(n)$,整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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 encode(String longUrl)` 返回 `longUrl` 对应的 `TinyURL` 。
* `String decode(String shortUrl)` 返回 `shortUrl` 原本的 `URL`。题目数据保证给定的 `shortUrl` 是由同一个系统对象加密的。
示例:
```
输入:url = "https://leetcode.com/problems/design-tinyurl"
输出:"https://leetcode.com/problems/design-tinyurl"
解释:
Solution obj = new Solution();
string tiny = obj.encode(url); // 返回加密后得到的 TinyURL 。
string ans = obj.decode(tiny); // 返回解密后得到的原本的 URL 。
```
提示:
* $1 <= url.length <= 10^4$
* 题目数据保证 `url` 是一个有效的 `URL` | ### 模拟 + 哈希表
对于每个 `longUrl` 我们都在「大写字母/小写字母/数字」中随机 $k = 6$ 位作为其映射标识,这需要使用一个哈希表 `tiny2Origin` 进行记录。
同时了防止相同的 `longUrl` 多次调用,确保 `encode` 服务的「幂等性」,我们再额外建立哈希表 `origin2Tiny` 来记录原串和映射标识的对应关系。
Java 代码:
```Java
public class Codec {
Map<String, String> origin2Tiny = new HashMap<>(), tiny2Origin = new HashMap<>();
String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
String prefix = "https://acoier.com/tags/";
int k = 6;
Random random = new Random();
public String encode(String longUrl) {
while (!origin2Tiny.containsKey(longUrl)) {
char[] cs = new char[k];
for (int i = 0; i < k; i++) cs[i] = str.charAt(random.nextInt(str.length()));
String cur = prefix + String.valueOf(cs);
if (tiny2Origin.containsKey(cur)) continue;
tiny2Origin.put(cur, longUrl);
origin2Tiny.put(longUrl, cur);
}
return origin2Tiny.get(longUrl);
}
public String decode(String shortUrl) {
return tiny2Origin.get(shortUrl);
}
}
```
Python 代码:
```Python
class Codec:
def __init__(self):
self.origin_to_tiny = {}
self.tiny_to_origin = {}
self.k = 6
self.prefix = 'https://acoier.com/tags/'
self.ss = string.ascii_letters + string.digits
def encode(self, longUrl: str) -> str:
while longUrl not in self.origin_to_tiny.keys():
cur = ''.join([self.ss[random.randint(0,len(self.ss) - 1)] for _ in range(self.k)])
if cur in self.tiny_to_origin.keys():
continue
self.tiny_to_origin[cur] = longUrl
self.origin_to_tiny[longUrl] = cur
return self.origin_to_tiny[longUrl]
def decode(self, shortUrl: str) -> str:
return self.tiny_to_origin[shortUrl]
```
* 时间复杂度:`encode` 操作复杂度为 $O(C + L)$,其中 $C = 6$ 为短串长度,$L$ 为传入参数 `longUrl` 的长度(存入哈希表需要计算 `longUrl` 哈希值,该过程需要遍历 `longUrl`);`decode` 操作复杂度为 $O(C)$,其中 $L$ 为传入参数 `shortUrl` 的长度,该长度固定为 `prefix` 长度加 $6$
* 空间复杂度:$O(K \times L)$,其中 $K$ 为调用次数,$L$ 为平均 `longUrl` 长度
---
### 关于使用「自增 `id`」的答疑
群里有同学问到为啥要使用「哈希存储映射关系」的方式,而不是用「自增 `id`」的方式,感觉可能是一部分同学的共同疑惑,这里统一回答一下。
其中两点较为致命的弊端是:
1. 使用「自增 `id`」更容易被枚举;
(再补充,提出原问题的好奇宝宝又问了另外一个问题)关于被枚举的坏处:粗略来说会导致安全性下降,被攻击的可能性大大增强。因为可枚举意味着,不能光靠 URL 特定发放来确保安全。
结合具体场景来说,假设某个活动日期生成了短 URL 的活动链接,只有特定用户可以访问,可枚举意味着竞品只需要大概知道你自增 id 当前在什么范围即可拿到活动链接,即使活动链接做了鉴权,也能通过攻击手段导致服务请求数量突增,影响真实的活动用户使用。
或许这个场景并不致命,竞品要拿到活动链接有很多方式,未必是通过枚举短 URL 来做到。
但另外一个场景则是致命的,就是可枚举会导致使用短 URL 服务的「验证服务」失效。
例如某个服务会通过「邮件/短信」发送短 URL 链接,让用户通过点击短 URL 来验证是否为某个「邮箱/手机号」的拥有者,短 URL 可枚举,意味着只需要知道当前自增 `id` 大概范围,就可通过枚举的方式访问到真实的验证地址,从而实现「不收到某个邮件/短信」也可以通过验证的目的。
2. 相比于使用「哈希存储映射关系」的方式,不好重用:
举个🌰,例如映射关系都是 $7$ 天过期,每天会产生了 $10$ 个短 URL,当进行到第 $8$ 天,此时 `id` 已经自增到 $71$,同时第一天产生的短 URL 已过期,但是实现上,我们不好将 `id` 进行回拨(需要考虑当重用数字用完后要回到 $71$ 的位置)。也就是说,发现而且重用某些数字段(过期的 `id`)会为“自增”带来困扰,而引入「重用池」则违背了选择自增方案的初衷。
但「哈希存储映射关系」要实现重用则是简单的,如果随机产生的短 URL 发生冲突,只需要直接拒绝进行重试即可,一旦产生短 URL 无冲突,则可以直接使用。同时由于随机通常服从某种分布,我们无须引入「过期时间戳」等信息,即可达到「某个短 URL 在使用后的一段时间后,都不会被随机到(不会在过期后就被迅速重用)」的作用,这一点可以通过调大 $k$ 值来进一步保证。
防杠声明:当然,如果你只是在单纯的做算法题,就当我没说 🤣 | ### 最后
这是我们「刷穿 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", num2 = "1+-1i"
输出:"0+-2i"
解释:(1 - i) * (1 - i) = 1 + i2 - 2 * i = -2i ,你需要将它转换为 0+-2i 的形式。
```
提示:
* `num1` 和 `num2` 都是有效的复数表示。 | ### 模拟
本题考察的是「复数乘法法则」运用。
根据 $(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 = parse(ss1[1]);
int c = parse(ss2[0]), d = parse(ss2[1]);
int A = a * c - b * d, B = b * c + a * d;
return A + "+" + B + "i";
}
int parse(String s) {
return Integer.parseInt(s);
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别为两字符串长度,复杂度上界取决于正则分割,正则复杂度与字符串长度呈正比,整体复杂度为 $O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 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:
```
输入:root = [0,null,1]
输出:[1,null,1]
```
提示:
* 树中的节点数在 $[1, 100]$ 范围内。
* $0 <= Node.val <= 100$
* 树中的所有值均不重复 。 | ### 中序遍历
利用 **`BST` 的中序遍历是有序** 的特性,我们可以通过两次遍历 `BST` 来求解问题。
首先,通过一次遍历,计算出整棵树的节点总和 `tot`,然后在中序遍历过程中,不断对 `tot` 进行更新,将其作为当前未遍历到的节点的总和,用于给当前节点赋值。
假设当前遍历到的节点为 `x`(起始节点值为 `t`),那么将节点更新为当前节点 `tot` 后,更新 `tot = tot - t`。
这是常规的中序遍历做法,更进一步,如果将其中序遍历的顺序进行翻转(从「左中右」调整为「右中左」),则可实现一次遍历。
Java 代码:
```Java
class Solution {
int tot = 0;
public TreeNode convertBST(TreeNode root) {
dfs(root);
return root;
}
void dfs(TreeNode root) {
if (root == null) return ;
dfs(root.right);
tot += root.val;
root.val = tot;
dfs(root.left);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int tot = 0;
TreeNode* convertBST(TreeNode* root) {
dfs(root);
return root;
}
void dfs(TreeNode* root) {
if (root == nullptr) return;
dfs(root->right);
tot += root->val;
root->val = tot;
dfs(root->left);
}
};
```
Python 代码:
```Python
class Solution:
def convertBST(self, root: TreeNode) -> TreeNode:
tot = 0
def dfs(root):
nonlocal tot
if not root: return
dfs(root.right)
tot += root.val
root.val = tot
dfs(root.left)
dfs(root)
return root
```
TypeScript 代码:
```TypeScript
function convertBST(root: TreeNode | null): TreeNode | null {
let tot = 0;
const dfs = function(root: TreeNode | null): void {
if (!root) return ;
dfs(root.right);
tot += root.val;
root.val = tot;
dfs(root.left);
}
dfs(root);
return root;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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 int findMinDifference(List<String> timePoints) {
int n = timePoints.size() * 2;
int[] nums = new int[n];
for (int i = 0, idx = 0; i < n / 2; i++, idx += 2) {
String[] ss = timePoints.get(i).split(":");
int h = Integer.parseInt(ss[0]), m = Integer.parseInt(ss[1]);
nums[idx] = h * 60 + m;
nums[idx + 1] = nums[idx] + 1440;
}
Arrays.sort(nums);
int ans = nums[1] - nums[0];
for (int i = 0; i < n - 1; i++) ans = Math.min(ans, nums[i + 1] - nums[i]);
return ans;
}
}
```
-
```Python3
class Solution:
def findMinDifference(self, timePoints: List[str]) -> int:
n = len(timePoints) * 2
nums, idx = [0] * n, 0
for time in timePoints:
h, m = int(time[:2]), int(time[-2:])
nums[idx] = h * 60 + m
nums[idx + 1] = nums[idx] + 1440
idx += 2
nums.sort()
return min(nums[i + 1] - nums[i] for i in range(n - 1))
```
-
```Go
func findMinDifference(timePoints []string) int {
n := len(timePoints) * 2
nums := make([]int, n)
for i, idx := 0, 0; i < n / 2; i++ {
ss := strings.Split(timePoints[i], ":")
h, _ := strconv.Atoi(ss[0])
m, _ := strconv.Atoi(ss[1])
nums[idx] = h * 60 + m
nums[idx + 1] = nums[idx] + 1440
idx += 2
}
sort.Ints(nums)
ans := nums[1] - nums[0];
for i := 1; i < n - 1; i++ {
if v := nums[i + 1] - nums[i]; v < ans {
ans = v
}
}
return ans
}
```
-
```C++
class Solution {
public:
int findMinDifference(vector<string>& timePoints) {
int n = timePoints.size() * 2;
vector<int> nums(n);
for(int i = 0, idx = 0; i < n / 2; i++, idx += 2){
string ss = timePoints[i];
auto pos = ss.find(':');
int h = stoi(ss.substr(0, pos)), m = stoi(ss.substr(pos + 1));
nums[idx] = h * 60 + m;
nums[idx + 1] = nums[idx] + 1440;
}
sort(nums.begin(), nums.end());
int ans = nums[1] - nums[0];
for(int i = 0; i < n - 1; i++){
ans = min(ans, nums[i + 1] - nums[i]);
}
return ans;
}
};
```
-
```C
int min(int a,int b){ return a > b ? b : a; }
int cmp(const void* a , const void* b){ return (*(int*)a) - (*(int*)b); }
int findMinDifference(char ** timePoints, int timePointsSize){
int n = timePointsSize * 2;
int* nums = (int*) malloc(sizeof(int) * n);
for(int i = 0, idx = 0; i < n / 2; i++, idx += 2){
timePoints[i][2] = '\0';
int h = atoi(timePoints[i]), m = atoi(timePoints[i] + 3);
nums[idx] = h * 60 + m;
nums[idx + 1] = nums[idx] + 1440;
}
qsort(nums, n, sizeof(nums[0]), cmp);
int ans = nums[1] - nums[0];
for(int i = 0; i < n - 1; i++){
ans = min(ans, nums[i + 1] - nums[i]);
}
free(nums);
nums = NULL;
return ans;
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 模拟(哈希表计数)
利用当天最多只有 $60 * 24 = 1440$ 个不同的时间点(跨天的话则是双倍),我们可以使用数组充当哈希表进行计数,同时根据「抽屉原理」,若 $timePoints$ 数量大于 $1440$,必然有两个相同时间点,用作剪枝。
然后找到间隔最小两个时间点,这种利用「桶排序」的思路避免了对 $timePoints$ 所对应的偏移量进行排序,而 $O(C)$ 的复杂度使得所能处理的数据范围没有上限。
代码:
```Java
class Solution {
public int findMinDifference(List<String> timePoints) {
int n = timePoints.size();
if (n > 1440) return 0;
int[] cnts = new int[1440 * 2 + 10];
for (String s : timePoints) {
String[] ss = s.split(":");
int h = Integer.parseInt(ss[0]), m = Integer.parseInt(ss[1]);
cnts[h * 60 + m]++;
cnts[h * 60 + m + 1440]++;
}
int ans = 1440, last = -1;
for (int i = 0; i <= 1440 * 2 && ans != 0; i++) {
if (cnts[i] == 0) continue;
if (cnts[i] > 1) ans = 0;
else if (last != -1) ans = Math.min(ans, i - last);
last = i;
}
return ans;
}
}
```
* 时间复杂度:$O(C)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 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 nums[i];
}
return nums[n - 1];
}
}
```
-
```Java
class Solution {
public int singleNonDuplicate(int[] nums) {
int ans = 0;
for (int i : nums) ans ^= i;
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 二分
这道题的「二段性」分析需要一点点「脑筋急转弯」。
由于给定数组有序 且 常规元素总是两两出现,**因此如果不考虑“特殊”的单一元素的话,我们有结论:成对元素中的第一个所对应的下标必然是偶数,成对元素中的第二个所对应的下标必然是奇数。**
然后再考虑存在单一元素的情况,假如单一元素所在的下标为 $x$,那么下标 $x$ 之前(左边)的位置仍满足上述结论,而下标 $x$ 之后(右边)的位置由于 $x$ 的插入,导致结论翻转。
存在这样的二段性,指导我们根据当前二分点 $mid$ 的奇偶性进行分情况讨论:
* $mid$ 为偶数下标:根据上述结论,正常情况下偶数下标的值会与下一值相同,因此如果满足该条件,可以确保 $mid$ 之前并没有插入单一元素。正常情况下,此时应该更新 $l = mid$,否则应当让 $r = mid - 1$,但需要注意这样的更新逻辑,会因为更新 $r$ 时否决 $mid$ 而错过答案,我们可以将否决 $mid$ 的动作放到更新 $l$ 的一侧,即需要将更新逻辑修改为 $l = mid + 1$ 和 $r = mid$ ;
* $mid$ 为奇数下标:同理,根据上述结论,正常情况下奇数下标的值会与上一值相同,因此如果满足该条件,可以确保 $mid$ 之前并没有插入单一元素,相应的更新 $l$ 和 $r$。
代码:
```Java
class Solution {
public int singleNonDuplicate(int[] nums) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (mid % 2 == 0) {
if (mid + 1 < n && nums[mid] == nums[mid + 1]) l = mid + 1;
else r = mid;
} else {
if (mid - 1 >= 0 && nums[mid - 1] == nums[mid]) l = mid + 1;
else r = mid;
}
}
return nums[r];
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 二分(异或技巧)
不难发现,上述解法对奇偶下标的分情况讨论仅在于当前值 $nums[i]$ 是与 $nums[i + 1]$(当 $i$ 为偶数时)还是 $nums[i - 1]$(当 $i$ 为奇数时)进行比较。
而这样的「连续段 偶奇 两两成对」的组合,适合使用「异或」来找相应的成组对象。
实际上,该技巧广泛地应用在图论存图中:**使用邻接表(链式向前星)存无向图时,直接访问「当前边 $e$」所对应的「反向边 $e'$」。这也是为什么在「链式向前星」中我们只需要使用「单链表」并设定 $idx$ 从 $0$ 开始进行存图即可:能够满足遍历所有出边,同时如果有访问相应反向边的需求,只需要通过 `e[i^1]` 访问。**
对这种存图方式不熟悉的同学,可以看前置 🧀:[涵盖所有的「存图方式」与「最短路算法(详尽注释)」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=381012359&lang=zh_CN#rd)。
代码:
```Java
class Solution {
public int singleNonDuplicate(int[] nums) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] == nums[mid ^ 1]) l = mid + 1;
else r = mid;
}
return nums[r];
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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) {
int r = l + k - 1;
reverse(cs, l, Math.min(r, n - 1));
}
return String.valueOf(cs);
}
void reverse(char[] cs, int l, int r) {
while (l < r) {
char c = cs[l];
cs[l] = cs[r];
cs[r] = c;
l++; r--;
}
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:Java 中 `String` 属于不可变,复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 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 Solution {
int ans = 0;
public int diameterOfBinaryTree(TreeNode root) {
dfs(root);
return ans;
}
int dfs(TreeNode u) {
if (u == null) return 0;
int l = dfs(u.left), r = dfs(u.right);
ans = Math.max(ans, l + r);
return Math.max(l, r) + 1;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int ans = 0;
int diameterOfBinaryTree(TreeNode* root) {
dfs(root);
return ans;
}
int dfs(TreeNode* u) {
if (u == NULL) return 0;
int l = dfs(u->left), r = dfs(u->right);
ans = max(ans, l + r);
return max(l, r) + 1;
}
};
```
Python 代码:
```Python
class Solution:
def diameterOfBinaryTree(self, root: TreeNode) -> int:
ans = 0
def dfs(u):
nonlocal ans
if not u: return 0
left, right = dfs(u.left), dfs(u.right)
ans = max(ans, left + right)
return max(left, right) + 1
dfs(root)
return ans
```
TypeScript 代码:
```TypeScript
function diameterOfBinaryTree(root: TreeNode | null): number {
let ans = 0;
const dfs = function(u: TreeNode): number {
if (!u) return 0;
const l = dfs(u.left), r = dfs(u.right);
ans = Math.max(ans, l + r);
return Math.max(l, r) + 1;
};
dfs(root);
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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:
```
输入:s = "PPALLL"
输出:false
解释:学生最后三天连续迟到,所以不满足出勤奖励的条件。
```
提示:
* 1 <= s.length <= 1000
* s[i] 为 'A'、'L' 或 'P' | ### 模拟
放大假,根据题意进行模拟即可。
代码:
```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) return false;
} else if (c == 'L') {
int j = i;
while (j < n && cs[j] == 'L') j++;
int len = j - i;
if (len >= 3) return false;
i = j;
continue;
}
i++;
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用 `charAt` 代替 `toCharArray` 的话为 $O(1)$,否则为 $O(n)$ | ### 最后
这是我们「刷穿 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:
```
输入:n = 2
输出:8
解释:
有 8 种长度为 2 的记录将被视为可奖励:
"PP" , "AP", "PA", "LP", "PL", "AL", "LA", "LL"
只有"AA"不会被视为可奖励,因为缺勤次数为 2 次(需要少于 2 次)。
```
示例 2:
```
输入:n = 1
输出:3
```
示例 3:
```
输入:n = 10101
输出:183236316
```
提示:
* 1 <= n <= $10^5$ | ### 基本分析
根据题意,我们知道一个合法的方案中 `A` 的总出现次数最多为 $1$ 次,`L` 的连续出现次数最多为 $2$ 次。
**因此在枚举/统计合法方案的个数时,当我们决策到某一位应该选什么时,我们关心的是当前方案中已经出现了多少个 `A`(以决策当前能否填入 `A`)以及连续出现的 `L` 的次数是多少(以决策当前能否填入 `L`)。**
---
### 记忆化搜索
枚举所有方案的爆搜 `DFS` 代码不难写,大致的函数签名设计如下:
```Java
/**
* @param u 当前还剩下多少位需要决策
* @param acnt 当前方案中 A 的总出现次数
* @param lcnt 当前方案中结尾 L 的连续出现次数
* @param cur 当前方案
* @param ans 结果集
*/
void dfs(int u, int acnt, int lcnt, String cur, List<String> ans);
```
实际上,我们不需要枚举所有的方案数,因此我们只需要保留函数签名中的前三个参数即可。
同时由于我们在计算某个 $(u, acnt, lcnt)$ 的方案数时,其依赖的状态可能会被重复使用,考虑加入记忆化,将结果缓存起来。
根据题意,$n$ 的取值范围为 $[0, n]$,$acnt$ 取值范围为 $[0,1]$,$lcnt$ 取值范围为 $[0, 2]$。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
int[][][] cache;
public int checkRecord(int n) {
cache = new int[n + 1][2][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 3; k++) {
cache[i][j][k] = -1;
}
}
}
return dfs(n, 0, 0);
}
int dfs(int u, int acnt, int lcnt) {
if (acnt >= 2) return 0;
if (lcnt >= 3) return 0;
if (u == 0) return 1;
if (cache[u][acnt][lcnt] != -1) return cache[u][acnt][lcnt];
int ans = 0;
ans = dfs(u - 1, acnt + 1, 0) % mod; // A
ans = (ans + dfs(u - 1, acnt, lcnt + 1)) % mod; // L
ans = (ans + dfs(u - 1, acnt, 0)) % mod; // P
cache[u][acnt][lcnt] = ans;
return ans;
}
}
```
* 时间复杂度:有 $O(n * 2 * 3)$ 个状态需要被计算,复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 状态机 DP
通过记忆化搜索的分析我们发现,当我们在决策下一位是什么的时候,依赖于前面已经填入的 `A` 的个数以及当前结尾处的 `L` 的连续出现次数。
**也就说是,状态 $f[u][acnt][lcnt]$ 必然被某些特定状态所更新,或者说由 $f[u][[acnt][lcnt]$ 出发,所能更新的状态是固定的。**
因此这其实是一个状态机模型的 DP 问题。
**根据「更新 $f[u][acnt][lcnt]$ 需要哪些状态值」还是「从 $f[u][acnt][lcnt]$ 出发,能够更新哪些状态」,我们能够写出两种方式(方向)的 DP 代码:**
**一类是从 $f[u][acnt][lcnt]$ 往回找所依赖的状态;一类是从 $f[u][acnt][lcnt]$ 出发往前去更新所能更新的状态值。**
无论是何种方式(方向)的 DP 实现都只需搞清楚「当前位的选择对 $acnt$ 和 $lcnt$ 的影响」即可。
代码:
```Java
// 从 f[u][acnt][lcnt] 往回找所依赖的状态
class Solution {
int mod = (int)1e9+7;
public int checkRecord(int n) {
int[][][] f = new int[n + 1][2][3];
f[0][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 3; k++) {
if (j == 1 && k == 0) { // A
f[i][j][k] = (f[i][j][k] + f[i - 1][j - 1][0]) % mod;
f[i][j][k] = (f[i][j][k] + f[i - 1][j - 1][1]) % mod;
f[i][j][k] = (f[i][j][k] + f[i - 1][j - 1][2]) % mod;
}
if (k != 0) { // L
f[i][j][k] = (f[i][j][k] + f[i - 1][j][k - 1]) % mod;
}
if (k == 0) { // P
f[i][j][k] = (f[i][j][k] + f[i - 1][j][0]) % mod;
f[i][j][k] = (f[i][j][k] + f[i - 1][j][1]) % mod;
f[i][j][k] = (f[i][j][k] + f[i - 1][j][2]) % mod;
}
}
}
}
int ans = 0;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 3; k++) {
ans += f[n][j][k];
ans %= mod;
}
}
return ans;
}
}
```
```Java
// 从 f[u][acnt][lcnt] 出发往前去更新所能更新的状态值
class Solution {
int mod = (int)1e9+7;
public int checkRecord(int n) {
int[][][] f = new int[n + 1][2][3];
f[0][0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 3; k++) {
if (j != 1) f[i + 1][j + 1][0] = (f[i + 1][j + 1][0] + f[i][j][k]) % mod; // A
if (k != 2) f[i + 1][j][k + 1] = (f[i + 1][j][k + 1] + f[i][j][k]) % mod; // L
f[i + 1][j][0] = (f[i + 1][j][0] + f[i][j][k]) % mod; // P
}
}
}
int ans = 0;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 3; k++) {
ans += f[n][j][k];
ans %= mod;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 矩阵快速幂
之所以在动态规划解法中强调更新状态的方式(方向)是「往回」还是「往前」,是因为对于存在线性关系(同时又具有结合律)的递推式,我们能够通过「矩阵快速幂」来进行加速。
矩阵快速幂的基本分析之前在 [(题解) 1137. 第 N 个泰波那契数](https://leetcode-cn.com/problems/n-th-tribonacci-number/solution/gong-shui-san-xie-yi-ti-si-jie-die-dai-d-m1ie/) 详细讲过。
由于 $acnt$ 和 $lcnt$ 的取值范围都很小,其组合的状态只有 $2 * 3 = 6$ 种,我们使用 $idx = acnt * 3 + lcnt$ 来代指组合(通用的二维转一维方式):
* $idx = 0$ :$acnt = 0、lcnt = 0$;
* $idx = 1$ :$acnt = 1、lcnt = 0$;
...
* $idx = 5$ :$acnt = 1、lcnt = 2$;
最终答案为 $ans = \sum_{idx = 0}^{5} f[n][idx]$,将答案依赖的状态整理成列向量:
$$
g[n] = \begin{bmatrix}
f[n][0]\\
f[n][1]\\
f[n][2]\\
f[n][3]\\
f[n][4]\\
f[n][5]
\end{bmatrix}
$$
根据状态机逻辑,可得:
$$
g[n] = \begin{bmatrix}
f[n][0]\\
f[n][1]\\
f[n][2]\\
f[n][3]\\
f[n][4]\\
f[n][5]
\end{bmatrix}
= \begin{bmatrix}
f[n - 1][0] * 1 + f[n - 1][1] * 1 + f[n - 1][2] * 1 + f[n - 1][3] * 0 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\
f[n - 1][0] * 1 + f[n - 1][1] * 0 + f[n - 1][2] * 0 + f[n - 1][3] * 0 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\
f[n - 1][0] * 0 + f[n - 1][1] * 1 + f[n - 1][2] * 0 + f[n - 1][3] * 0 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\
f[n - 1][0] * 1 + f[n - 1][1] * 1 + f[n - 1][2] * 1 + f[n - 1][3] * 1 + f[n - 1][4] * 1 + f[n - 1][5] * 1\\
f[n - 1][0] * 0 + f[n - 1][1] * 0 + f[n - 1][2] * 0 + f[n - 1][3] * 1 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\
f[n - 1][0] * 0 + f[n - 1][1] * 0 + f[n - 1][2] * 0 + f[n - 1][3] * 0 + f[n - 1][4] * 1 + f[n - 1][5] * 0
\end{bmatrix}
$$
我们令:
$$
mat = \begin{bmatrix}
1 &1 &1 &0 &0 &0 \\
1 &0 &0 &0 &0 &0 \\
0 &1 &0 &0 &0 &0 \\
1 &1 &1 &1 &1 &1 \\
0 &0 &0 &1 &0 &0 \\
0 &0 &0 &0 &1 &0
\end{bmatrix}
$$
根据「矩阵乘法」即有:
$$
g[n] = mat * g[n - 1]
$$
起始时,我们只有 $g[0]$,根据递推式得:
$$
g[n] = mat * mat * ... * mat * g[0]
$$
再根据矩阵乘法具有「结合律」,最终可得:
$$
g[n] = mat^n * g[0]
$$
计算 $mat^n$ 可以套用「快速幂」进行求解。
代码:
```Java
class Solution {
int N = 6;
int mod = (int)1e9+7;
long[][] mul(long[][] a, long[][] b) {
int r = a.length, c = b[0].length, z = b.length;
long[][] ans = new long[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < z; k++) {
ans[i][j] += a[i][k] * b[k][j];
ans[i][j] %= mod;
}
}
}
return ans;
}
public int checkRecord(int n) {
long[][] ans = new long[][]{
{1}, {0}, {0}, {0}, {0}, {0}
};
long[][] mat = new long[][]{
{1, 1, 1, 0, 0, 0},
{1, 0, 0, 0, 0, 0},
{0, 1, 0, 0, 0, 0},
{1, 1, 1, 1, 1, 1},
{0, 0, 0, 1, 0, 0},
{0, 0, 0, 0, 1, 0}
};
while (n != 0) {
if ((n & 1) != 0) ans = mul(mat, ans);
mat = mul(mat, mat);
n >>= 1;
}
int res = 0;
for (int i = 0; i < N; i++) {
res += ans[i][0];
res %= mod;
}
return res;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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)"。
其他用例:
1000/(100/10)/2 = 50
1000/(100/(10/2)) = 50
1000/100/10/2 = 0.5
1000/100/(10/2) = 2
```
说明:
* 输入数组的长度在 $[1, 10]$ 之间。
* 数组中每个元素的大小都在 $[2, 1000]$ 之间。
* 每个测试用例只有一个最优除法解。 | ### 数学 + 贪心
我们假定取得最优解的表示为 $\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}{nums[n - 1]}} = \frac{nums[0] * nums[2] * ... * nums[n - 1]}{nums[1]}
$$
综上,我们只需要从前往后进行构建出连除的答案,如果 $nums$ 的长度大于 $2$,再追加一对大括号即可。
$[a_0, a_1, ... , a_n]$ => $a_0/a_1/.../a_n$ => $a_0/(a_1/.../a_n)$
代码:
```Java
class Solution {
public String optimalDivision(int[] nums) {
int n = nums.length;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) {
sb.append(nums[i]);
if (i + 1 < n) sb.append("/");
}
if (n > 2) {
sb.insert(sb.indexOf("/") + 1, "(");
sb.append(")");
}
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n * C)$,其中 $C$ 为 $nums[i]$ 的最大长度,对于本题 $C = 4$ | ### 最后
这是我们「刷穿 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],[3,1,2],[1,3,1,1]]
输出:2
```
示例 2:
```
输入:wall = [[1],[1],[1]]
输出:3
```
提示:
* n == wall.length
* 1 <= n <= $10^4$
* 1 <= wall[i].length <= $10^4$
* 1 <= sum(wall[i].length) <= 2 * $10^4$
* 对于每一行 i ,sum(wall[i]) 是相同的
* 1 <= `wall[i][j]` <= $2^{31}$ - 1 | ### 哈希表
题目要求穿过的砖块数量最少,等效于通过的间隙最多。
**我们可以使用「哈希表」记录每个间隙的出现次数,最终统计所有行中哪些间隙出现得最多,使用「总行数」减去「间隙出现的最多次数」即是答案。**
如何记录间隙呢?直接使用行前缀记录即可。
就用示例数据来举 🌰 :
* 第 1 行的间隙有 `[1,3,5]`
* 第 2 行的间隙有 `[3,4]`
* 第 3 行的间隙有 `[1,4]`
* 第 4 行的间隙有 `[2]`
* 第 5 行的间隙有 `[3,4]`
* 第 6 行的间隙有 `[1,4,5]`
对间隙计数完成后,遍历「哈希表」找出出现次数最多间隙 `4`,根据同一个间隙编号只会在单行内被统计一次,用总行数减去出现次数,即得到「最少穿过的砖块数」。
代码:
```Java
class Solution {
public int leastBricks(List<List<Integer>> wall) {
int n = wall.size();
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0, sum = 0; i < n; i++, sum = 0) {
for (int cur : wall.get(i)) {
sum += cur;
map.put(sum, map.getOrDefault(sum, 0) + 1);
}
map.remove(sum); // 不能从两边穿过,需要 remove 掉最后一个
}
int ans = n;
for (int u : map.keySet()) {
int cnt = map.get(u);
ans = Math.min(ans, n - cnt);
}
return ans;
}
}
```
* 时间复杂度:记所有砖块数量为 `n`,所有砖块都会被扫描。复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 关于是否需要考虑「溢出」的说明
类似的问题,在之前 [题解](https://leetcode-cn.com/problems/combination-sum-iv/solution/gong-shui-san-xie-yu-wan-quan-bei-bao-we-x0kn/) 也说过,这里再提一下 ~
**当 Java 发生溢出时,会直接转成负数来处理**。因此对于本题不会影响正确性(不重复溢出的话)。
可以通过以下例子来体会:
```Java
{
System.out.println(Integer.MIN_VALUE); // -2147483648
int a = Integer.MAX_VALUE;
System.out.println(a); // 2147483647
a += 1;
System.out.println(a); // -2147483648
a -= 1;
System.out.println(a); //2147483647
}
```
这意味着,如果我们在运算过程中如果只涉及「纯加减运算」,而不涉及「乘除」、「取最大值/最小值」和「数值大小判断」的话,Java 是不需要使用 `Long` 来确保正确性的,因为最终溢出会被转化回来。
按道理,CPP 本身对于 `int` 溢出的转化处理也是一样的。
**但在 LC 上的 CPP 发生溢出时,不会直接转成负数来处理,而是直接抛出异常**。因此同样的代码在 LC 上是无法被正常执行的:
```C++ []
{
cout << INT_MIN << endl; //-2147483648
int a = INT_MAX;
cout << a << endl; // 2147483647
a += 1; // 溢出报错
cout << a << endl;
a -= 1;
cout << a << endl;
}
```
**这是一般性的,对于 LC 上的同一道题,Java 不需要处理溢出,CPP 需要处理的原因。**
***
其实对应到本题,我这里不使用 long long,是因为猜想「题目」中的条件写错了:
```Java
1 <= sum(wall[i]) <= 2 * 10^4
错写成了
1 <= sum(wall[i].length) <= 2 * 10^4
```
因为在给定下面两个条件的情况下:
```
1 <= n <= 10^4
1 <= wall[i].length <= 10^4
```
$1 <= sum(wall[i].length) <= 2 * 10^4$ 十分多余。
针对反例:
```Java
[
[2147483647,2147483647,2147483647,2147483647,1,2],
[2,2147483647,2147483647,2147483647,2147483647,1]
]
```
我用官方提供的代码,跑的也是 0,所以如果是以官方的代码为评测标准的话,用 long long 反而是 WA 了 🤣 | ### 最后
这是我们「刷穿 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$ 要大这一目标已由第 `idx` 位所保证(后续的排序应该按照从小到大放置),同时互换结束后的 $[0, idx)$ 仍然满足「非严格升序」特性,因此我们可以对其运用「双指针」进行翻转。
Java 代码:
```Java
class Solution {
public int nextGreaterElement(int x) {
List<Integer> nums = new ArrayList<>();
while (x != 0) {
nums.add(x % 10);
x /= 10;
}
int n = nums.size(), idx = -1;
for (int i = 0; i < n - 1 && idx == -1; i++) {
if (nums.get(i + 1) < nums.get(i)) idx = i + 1;
}
if (idx == -1) return -1;
for (int i = 0; i < idx; i++) {
if (nums.get(i) > nums.get(idx)) {
swap(nums, i, idx);
break;
}
}
for (int l = 0, r = idx - 1; l < r; l++, r--) swap(nums, l, r);
long ans = 0;
for (int i = n - 1; i >= 0; i--) ans = ans * 10 + nums.get(i);
return ans > Integer.MAX_VALUE ? -1 : (int)ans;
}
void swap(List<Integer> nums, int a, int b) {
int c = nums.get(a);
nums.set(a, nums.get(b));
nums.set(b, c);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int nextGreaterElement(int x) {
vector<int> nums;
while (x != 0) {
nums.push_back(x % 10);
x /= 10;
}
int n = nums.size(), idx = -1;
for (int i = 0; i < n - 1 && idx == -1; i++) {
if (nums[i + 1] < nums[i]) idx = i + 1;
}
if (idx == -1) return -1;
for (int i = 0; i < idx; i++) {
if (nums[i] > nums[idx]) {
swap(nums[i], nums[idx]);
break;
}
}
reverse(nums.begin(), nums.begin() + idx);
long long ans = 0;
for (int i = n - 1; i >= 0; i--) ans = ans * 10 + nums[i];
return ans > INT_MAX ? -1 : static_cast<int>(ans);
}
};
```
Python 代码:
```Python
class Solution:
def nextGreaterElement(self, x: int) -> int:
nums = []
while x != 0:
nums.append(x % 10)
x //= 10
n, idx = len(nums), -1
for i in range(n - 1):
if nums[i + 1] < nums[i]:
idx = i + 1
break
if idx == -1: return -1
for i in range(idx):
if nums[i] > nums[idx]:
nums[i], nums[idx] = nums[idx], nums[i]
break
l, r = 0, idx - 1
while l < r:
nums[l], nums[r] = nums[r], nums[l]
l, r = l + 1, r - 1
ans = 0
for num in nums[::-1]: ans = ans * 10 + num
return -1 if ans > 2**31 - 1 else ans
```
TypeScript 代码:
```TypeScript
function nextGreaterElement(x: number): number {
const nums = [];
while (x !== 0) {
nums.push(x % 10);
x = Math.floor(x / 10);
}
const n = nums.length;
let idx = -1;
for (let i = 0; i < n - 1 && idx == -1; i++) {
if (nums[i + 1] < nums[i]) idx = i + 1;
}
if (idx == -1) return -1;
for (let i = 0; i < idx; i++) {
if (nums[i] > nums[idx]) {
[nums[i], nums[idx]] = [nums[idx], nums[i]];
break;
}
}
for (let l = 0, r = idx - 1; l < r; l++, r--) [nums[l], nums[r]] = [nums[r], nums[l]];
let ans = 0;
for (let i = n - 1; i >= 0; i--) ans = ans * 10 + nums[i];
return ans > 2**31 - 1 ? -1 : ans;
};
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 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` 赋值给节点,两种值都会被判题机制 接受 。
四叉树数据结构中,每个内部节点只有四个子节点。此外,每个节点都有两个属性:
* `val`:储存叶子结点所代表的区域的值。$1$ 对应 `True`,$0$ 对应 `False`;
* `isLeaf`: 当这个节点是一个叶子结点时为 `True`,如果它有 $4$ 个子节点则为 `False` 。
```
class Node {
public boolean val;
public boolean isLeaf;
public Node topLeft;
public Node topRight;
public Node bottomLeft;
public Node bottomRight;
}
```
我们可以按以下步骤为二维区域构建四叉树:
1. 如果当前网格的值相同(即,全为 $0$ 或者全为 $1$),将 `isLeaf` 设为 `True` ,将 `val` 设为网格相应的值,并将四个子节点都设为 `Null` 然后停止。
2. 如果当前网格的值不同,将 `isLeaf` 设为 `False`, 将 `val` 设为任意值,然后如下图所示,将当前网格划分为四个子网格。
3. 使用适当的子网格递归每个子节点。
四叉树格式:
输出为使用层序遍历后四叉树的序列化形式,其中 null 表示路径终止符,其下面不存在节点。
它与二叉树的序列化非常相似。唯一的区别是节点以列表形式表示 `[isLeaf, val]` 。
如果 `isLeaf` 或者 `val` 的值为 `True` ,则表示它在列表 `[isLeaf, val]` 中的值为 $1$ ;如果 `isLeaf` 或者 `val` 的值为 `False` ,则表示值为 $0$ 。
示例 1:
```
输入:quadTree1 = [[0,1],[1,1],[1,1],[1,0],[1,0]]
, quadTree2 = [[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
输出:[[0,0],[1,1],[1,1],[1,1],[1,0]]
解释:quadTree1 和 quadTree2 如上所示。由四叉树所表示的二进制矩阵也已经给出。
如果我们对这两个矩阵进行按位逻辑或运算,则可以得到下面的二进制矩阵,由一个作为结果的四叉树表示。
注意,我们展示的二进制矩阵仅仅是为了更好地说明题意,你无需构造二进制矩阵来获得结果四叉树。
```
示例 2:
```
输入:quadTree1 = [[1,0]]
, quadTree2 = [[1,0]]
输出:[[1,0]]
解释:两个数所表示的矩阵大小都为 1*1,值全为 0
结果矩阵大小为 1*1,值全为 0 。
```
示例 3:
```
输入:quadTree1 = [[0,0],[1,0],[1,0],[1,1],[1,1]]
, quadTree2 = [[0,0],[1,1],[1,1],[1,0],[1,1]]
输出:[[1,1]]
```
示例 4:
```
输入:quadTree1 = [[0,0],[1,1],[1,0],[1,1],[1,1]]
, quadTree2 = [[0,0],[1,1],[0,1],[1,1],[1,1],null,null,null,null,[1,1],[1,0],[1,0],[1,1]]
输出:[[0,0],[1,1],[0,1],[1,1],[1,1],null,null,null,null,[1,1],[1,0],[1,0],[1,1]]
```
示例 5:
```
输入:quadTree1 = [[0,1],[1,0],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
, quadTree2 = [[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,0],[1,1],[1,1]]
输出:[[0,0],[0,1],[0,1],[1,1],[1,0],[1,0],[1,0],[1,1],[1,1],[1,0],[1,0],[1,1],[1,1]]
```
提示:
* `quadTree1` 和 `quadTree2` 都是符合题目要求的四叉树,每个都代表一个 $n \times n$ 的矩阵。
* $n == 2^x$ ,其中 $0 <= x <= 9$ | ### 递归
为了方便,我们令 `quadTree1` 为 `t1`,令 `quadTree2` 为 `t2`。
根据题意,并利用给定函数作为递归函数,当 `t1` 和 `t2` 均为叶子节点数时,执行「与逻辑」,即若 `t1` 和 `t2` 任一值为 $1$ 时,返回该节点,否则(两者均为 $0$),返回任一节点。
然后考虑其他情况下,如何使用 `t1` 和 `t2` 构造新节点 `ans`,分别使用对应位置的进行「递归」构造即可(即使用 `t1.topLeft` 和 `t2.topLeft` 来赋值给 `ans.topLeft`,其余位置同理),要注意可能存在 `t1` 或 `t2` 其中一节点为叶子节点的情况,此时应当使用当前叶子节点和另一节点的子节点进行构造。
最后考虑什么情况下,会产生新的叶子节点:若当前节点 `ans` 的四个子节点均为叶子节点,并且值相同时,`ans` 会成为叶子节点,`ans` 值为叶子节点的值,此时需要执行的操作为将 `isLeaf` 设定为 `True`,修改 `val` 为原子节点的值,将四个原子节点置空。
Java 代码:
```Java
class Solution {
public Node intersect(Node t1, Node t2) {
if (t1.isLeaf && t2.isLeaf) {
if (t1.val) return t1;
else if (t2.val) return t2;
else return t1;
}
Node ans = new Node();
ans.topLeft = intersect(t1.isLeaf ? t1 : t1.topLeft, t2.isLeaf ? t2 : t2.topLeft);
ans.topRight = intersect(t1.isLeaf ? t1 : t1.topRight, t2.isLeaf ? t2 : t2.topRight);
ans.bottomLeft = intersect(t1.isLeaf ? t1 : t1.bottomLeft, t2.isLeaf ? t2 : t2.bottomLeft);
ans.bottomRight = intersect(t1.isLeaf ? t1 : t1.bottomRight, t2.isLeaf ? t2 : t2.bottomRight);
boolean a = ans.topLeft.isLeaf && ans.topRight.isLeaf && ans.bottomLeft.isLeaf && ans.bottomRight.isLeaf;
boolean b = ans.topLeft.val && ans.topRight.val && ans.bottomLeft.val && ans.bottomRight.val;
boolean c = ans.topLeft.val || ans.topRight.val || ans.bottomLeft.val || ans.bottomRight.val;
ans.isLeaf = a && (b || !c);
ans.val = ans.topLeft.val;
if (ans.isLeaf) ans.topLeft = ans.topRight = ans.bottomLeft = ans.bottomRight = null;
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function intersect(t1: Node | null, t2: Node | null): Node | null {
if (t1.isLeaf && t2.isLeaf) {
if (t1.val) return t1
else if (t2.val) return t2
else return t1
}
const ans: Node = new Node()
ans.topLeft = intersect(t1.isLeaf ? t1 : t1.topLeft, t2.isLeaf ? t2 : t2.topLeft)
ans.topRight = intersect(t1.isLeaf ? t1 : t1.topRight, t2.isLeaf ? t2 : t2.topRight)
ans.bottomLeft = intersect(t1.isLeaf ? t1 : t1.bottomLeft, t2.isLeaf ? t2 : t2.bottomLeft)
ans.bottomRight = intersect(t1.isLeaf ? t1 : t1.bottomRight, t2.isLeaf ? t2 : t2.bottomRight)
const a: boolean = ans.topLeft.isLeaf && ans.topRight.isLeaf && ans.bottomLeft.isLeaf && ans.bottomRight.isLeaf
const b: boolean = ans.topLeft.val && ans.topRight.val && ans.bottomLeft.val && ans.bottomRight.val
const c: boolean = ans.topLeft.val || ans.topRight.val || ans.bottomLeft.val || ans.bottomRight.val
ans.isLeaf = a && (b || !c)
ans.val = ans.topLeft.val
if (ans.isLeaf) ans.topLeft = ans.topRight = ans.bottomLeft = ans.bottomRight = null
return ans
};
```
* 时间复杂度:复杂度与最终矩阵大小相关,而最终矩阵大小不会超过原矩阵大小,复杂度为 $O(n^2)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 加餐
**另外一道也是「四叉树」相关的递归运用题 : [【综合笔试题】难度 2/5,递归运用及前缀和优化](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492391&idx=1&sn=bf2b27842d461bba6766b1ca2b426eff) 🎉🎉** | ### 最后
这是我们「刷穿 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));
}
return ans + 1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### BFS
同理,可以使用 `BFS` 进行求解:其本质是对多叉树进行层序处理,当 `BFS` 过程结束,意味着达到最大层数(深度),所记录的最大层数(深度)即是答案。
代码:
```Java
class Solution {
public int maxDepth(Node root) {
if (root == null) return 0;
int ans = 0;
Deque<Node> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
int size = d.size();
while (size-- > 0) {
Node t = d.pollFirst();
for (Node node : t.children) {
d.addLast(node);
}
}
ans++;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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) {
int n = nums.length, ans = 0;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
Map<Integer, Integer> map = new HashMap<>();
map.put(0, 1);
for (int i = 1; i <= n; i++) {
int t = sum[i], d = t - k;
ans += map.getOrDefault(d, 0);
map.put(t, map.getOrDefault(t, 0) + 1);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function subarraySum(nums: number[], k: number): number {
let n = nums.length, ans = 0
const sum = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1]
const map = new Map<number, number>()
map.set(0, 1)
for (let i = 1; i <= n; i++) {
const t = sum[i], d = t - k
if (map.has(d)) ans += map.get(d)
map.set(t, map.has(t) ? map.get(t) + 1 : 1)
}
return ans
};
```
* 时间复杂度:预处理前缀和的复杂度为 $O(n)$,统计答案的复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
所以最大总和为 4
```
示例 2:
```
输入:nums = [6,2,6,5,1,2]
输出:9
解释:最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9
```
提示:
* $1 <= n <= 10^4$
* $nums.length = 2 \times n$
* $-10^4 <= nums[i] <= 10^4$ | ### 贪心解法
我们先对数组进行排序。
由于每两个数,我们只能选择当前小的一个进行累加。
因此我们猜想应该从第一个位置进行选择,然后隔一步选择下一个数。这样形成的序列的求和值最大。
```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;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$
***
### 证明
我们用反证法来证明下,为什么这样选择的序列的求和值一定是最大的:
猜想:对数组进行排序,从第一个位置进行选择,然后隔一步选择下一个数。这样形成的序列的求和值最大(下图黑标,代表当前被选择的数字)。
之所以我们能这么选择,是因为每一个被选择的数的「下一位位置」都对应着一个「大于等于」当前数的值(假设位置为 `k` ),使得当前数在 `min(a,b)` 关系中能被选择(下图红标,代表保证前面一个黑标能够被选择的辅助数)。
假如我们这样选择的序列求和不是最大值,那么说明至少我们有一个值选错了,应该选择更大的数才对。
那么意味着我们「某一位置」的黑标应该从当前位置指向更后的位置。
**PS. 因为要满足 min(a, b) 的数才会被累加,因此每一个红标右移(变大)必然导致原本所对应的黑标发生「同样程度 或 不同程度」的右移(变大)**
这会导致我们所有的红标黑标同时往后平移。
最终会导致我们最后一个黑标出现在最后一位,这时候最后一位黑标不得不与我们第 `k` 个位置的数形成一对。
我们看看这是求和序列的变化( `k` 位置前的求和项没有发生变化,我们从 `k` 位置开始分析):
1. 原答案 = `nums[k] + nums[k + 2] + ... + nums[n - 1]`
2. 调整后答案 = `nums[k + 1] + nums[k + 3] + ... + nums[n - 2] + min(nums[n], nums[k])`
由于 `min(nums[n], nums[k])` 中必然是 `nums[k]` 被选择。因此:
调整后答案 = `nums[k] + nums[k + 1] + nums[k + 3] + ... + nums[n - 2]`
显然从原答案的每一项都「大于等于」调整后答案的每一项,因此**不可能在「假想序列」中通过选择别的更大的数得到更优解,假想得证。**
***
### 为什么要「证明」或「理解证明」?
证明的意义在于,**你知道为什么这样做是对的**。
带来的好处是:
1. 一道「贪心」题目能搞清楚证明,那么同类的「贪心」题目你就都会做了。**否则就会停留在“我知道这道题可以这样贪心,别的题我不确定是否也能这样做”**。
2. 在「面试」阶段,**你可以很清晰讲解你的思路**。让面试官从你的「思维方式」上喜欢上你( emmm 当然从颜值上也可以 :)
...
***
### 更多与证明/分析相关的题解:
[765. 情侣牵手](https://leetcode-cn.com/problems/couples-holding-hands/) : [为什么交换任意一个都是对的?:两种 100% 的解法:并查集 & 贪心](https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/)
[1579. 保证图可完全遍历](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/) : [为什么先处理公共边是对的?含贪心证明 + 数组模板 ~](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/solution/tan-xin-bing-cha-ji-shu-zu-shi-xian-jian-w7ko/)
[1631. 最小体力消耗路径](https://leetcode-cn.com/problems/path-with-minimum-effort/) : [反证法证明思路的合法性](https://leetcode-cn.com/problems/path-with-minimum-effort/solution/fan-zheng-fa-zheng-ming-si-lu-de-he-fa-x-ohby/)
[11. 盛最多水的容器](https://leetcode-cn.com/problems/container-with-most-water/) : [双指针+贪心解法【含证明】](https://leetcode-cn.com/problems/container-with-most-water/solution/shua-chuan-lc-shuang-zhi-zhen-tan-xin-ji-52gf/) | ### 最后
这是我们「刷穿 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:
```
输入:root = [4,2,9,3,5,null,7]
输出:15
解释:
节点 3 的坡度:|0-0| = 0(没有子节点)
节点 5 的坡度:|0-0| = 0(没有子节点)
节点 7 的坡度:|0-0| = 0(没有子节点)
节点 2 的坡度:|3-5| = 2(左子树就是左子节点,所以和是 3 ;右子树就是右子节点,所以和是 5 )
节点 9 的坡度:|0-7| = 7(没有左子树,所以和是 0 ;右子树正好是右子节点,所以和是 7 )
节点 4 的坡度:|(3+5+2)-(9+7)| = |10-16| = 6(左子树值为 3、5 和 2 ,和是 10 ;右子树值为 9 和 7 ,和是 16 )
坡度总和:0 + 0 + 0 + 2 + 7 + 6 = 15
```
示例 3:
```
输入:root = [21,7,14,1,1,2,2,3,3]
输出:9
```
提示:
* 树中节点数目的范围在 $[0, 10^4]$ 内
* $-1000 <= Node.val <= 1000$ | ### 递归
根据题目对「坡度」的定义,我们可以直接写出对应的递归实现。
代码:
```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) return 0;
return getSum(root.left) + getSum(root.right) + root.val;
}
}
```
* 时间复杂度:每个节点被访问的次数与其所在深度有关。复杂度为 $O(n^2)$
* 空间复杂度:忽略递归来带的额外空间消耗。复杂度为 $O(1)$
---
### 递归
上述解法之所以为 $O(n^2)$ 的时间复杂度,是因为我们将「计算子树坡度」和「计算子树权值和」两个操作分开进行。
事实上,我们可以在计算子树权值和的时候将坡度进行累加,从而将复杂度降为 $O(n)$。
代码:
```Java
class Solution {
int ans;
public int findTilt(TreeNode root) {
dfs(root);
return ans;
}
int dfs(TreeNode root) {
if (root == null) return 0;
int l = dfs(root.left), r = dfs(root.right);
ans += Math.abs(l - r);
return l + r + root.val;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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$ 同步修改,因此最近一个可以修改的位置是 $bc$。
**当对目标位置进行修改后,其余位置的数值可由回文串性质唯一确定,因此只需要找到可修改位置相邻数值即可。**
例如对于 $abcde$ 来说,最近的回文数值的前三位可能是 $abc$、$abc+1$ 和 $abc-1$ 三者之一,其他位置的数值随着前三位的确定而唯一确定。
上述分析对于一般情况成立,而边界情况是指 $abc + 1$ 和 $abc - 1$ 导致整体长度发生变化,即 $abc=999$ 和 $abc=100$ 的情况,此时直接套用上述方法得到的值分别为 $1000001$ 和 $999$,但真实最近的值为 $100001$ 和 $9999$。
> 展开来说就是:对于 $abc = 999$(对应原串为 $999xx$ 的情况)而言,按照上述逻辑得到的是 $1000$,进行回文补充后得到 $1000001$(事实上应该是 $100001$ 更优);对于 $abc = 100$(对应原串为 $100xx$ 的情况)而言,按照上述逻辑得到是 $99$,进行回文补充后得到 $999$(事实上应该是 $9999$ 更优)。
因此对于长度为 $n$ 的数值,值考虑枚举前一半数的三种情况(前一半数不变,前一半数加一或减一)可能会错过最优解,我们需要将与长度相关的边界值也纳入考虑,即将「长度为 $n - 1$ 的回文串最大值($99...99$)」和「长度为 $n + 1$ 的回文串最小值($10...01$)」也纳入考虑,也就是对应的 $10^{n - 1} - 1$ 和 $10^n + 1$ 也纳入考虑,最后从上述 $5$ 个值中选绝对差值最小的作为答案。
> 一些细节:在枚举完前一半数后,我们需要根据原串长度的奇偶性来决定,如何生成后一半数,从而确保构建的回文串长度仍和原串长度相等。
> 即对于原串长度 $n$ 为奇数的 $abcde$ 而言,在处理完 $abc$ 之后,生成后一半数时,只需要根据前两位 $ab$ 生成对应的 $ba$,而无须处理中间字符 $c$;而对于原串长度 $n$ 为偶数的 $abcd$ 而言,在处理完 $ab$ 之后,生成另外一般数值需要根据整一个 $ab$ 来生成 $ba$,没有中间字符需要被跳过。
>
> 另外由于数据范围为 $[1, 10^{18} - 1]$,而 $999999999999999999$ 也属于合法输入($2022/03/03$ 目前样例里还没有这个数据),因此我们需要考虑 `getNum` 爆 `long` 的问题,一个比直接特判更好做法是:利用答案长度必然不会超过 $19$ 来做处理,对于长度超过 $19$ 的直接当成 $-1$ 来处理,由于个位数均为回文,$-1$ 注定不会成为答案。
代码:
```Java
class Solution {
public String nearestPalindromic(String s) {
int n = s.length();
long cur = Long.parseLong(s);
Set<Long> set = new HashSet<>();
set.add((long) Math.pow(10, (n - 1)) - 1);
set.add((long) Math.pow(10, n) + 1);
long t = Long.parseLong(s.substring(0, (n + 1) / 2));
for (long i = t - 1; i <= t + 1; i++) {
long temp = getNum(i, n % 2 == 0);
if (temp != cur) set.add(temp);
}
long ans = -1;
for (long i : set) {
if (ans == -1) ans = i;
else if (Math.abs(i - cur) < Math.abs(ans - cur)) ans = i;
else if (Math.abs(i - cur) == Math.abs(ans - cur) && i < ans) ans = i;
}
return String.valueOf(ans);
}
long getNum(long k, boolean isEven) {
StringBuilder sb = new StringBuilder();
sb.append(k);
int n = sb.length(), idx = isEven ? n - 1 : n - 2;
while (idx >= 0) sb.append(sb.charAt(idx--));
String str = sb.toString();
return str.length() > 19 ? -1 : Long.parseLong(str);
}
}
```
* 时间复杂度:令 $N$ 为字符串 `s` 所代指的数值,$n$ 为字符串 `s` 的长度,复杂度为 $O(\log{N})$ 或者说是 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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[4] = 1, A[5] = 6, A[6] = 2.
其中一种最长的 S[K]:
S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
```
提示:
* `N` 是 $[1, 20,000]$ 之间的整数。
* `A` 中不含有重复的元素。
* `A` 中的元素大小在 $[0, N-1]$ 之间。 | ### 模拟
将 $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) {
int n = nums.length, ans = 0;
for (int i = 0; i < n; i++) {
int cur = i, cnt = 0;
while (nums[cur] != -1) {
cnt++;
int c = cur;
cur = nums[cur];
nums[c] = -1;
}
ans = Math.max(ans, cnt);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function arrayNesting(nums: number[]): number {
let n = nums.length, ans = 0
for (let i = 0; i < n; i++) {
let cur = i, cnt = 0
while (nums[cur] != -1) {
cnt++
const c = cur
cur = nums[cur]
nums[c] = -1
}
ans = Math.max(ans, cnt)
}
return ans
};
```
* 时间复杂度:每个数字被访问的次数为常数次,复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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 矩阵, 用之前的元素值一行一行填充新矩阵。
```
示例 2:
```
输入:
nums =
[[1,2],
[3,4]]
r = 2, c = 4
输出:
[[1,2],
[3,4]]
解释:
没有办法将 2 * 2 矩阵转化为 2 * 4 矩阵。 所以输出原矩阵。
```
注意:
* 给定矩阵的宽和高范围在 $[1, 100]$。
* 给定的 $r$ 和 $c$ 都是正数。 | ### 模拟
按照题意,从头模拟一遍即可。
使用 $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, idx = 0; i < or; i++) {
for (int j = 0; j < oc; j++, idx++) {
ans[idx / c][idx % c] = nums[i][j];
}
}
return ans;
}
}
```
* 时间复杂度:$O(r * c)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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-from-cards/) 代码很相似,因为是一套模板。**
1. 初始化将滑动窗口压满,取得第一个滑动窗口的目标值
2. 继续滑动窗口,每往前滑动一次,需要删除一个和添加一个元素
代码:
```java
class Solution {
public boolean checkInclusion(String s1, String s2) {
int m = s1.length(), n = s2.length();
if (m > n) return false;
int[] cnt = new int[26];
for (char c : s1.toCharArray()) cnt[c - 'a']++;
int[] cur = new int[26];
for (int i = 0; i < m; i++) cur[s2.charAt(i) - 'a']++;
if (check(cnt, cur)) return true;
for (int i = m; i < n; i++) {
cur[s2.charAt(i) - 'a']++;
cur[s2.charAt(i - m) - 'a']--;
if (check(cnt, cur)) return true;
}
return false;
}
boolean check(int[] cnt1, int[] cnt2) {
for (int i = 0; i < 26; i++) {
if (cnt1[i] != cnt2[i]) return false;
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
经过了前面几天的「滑动窗口」,相信你做这题已经很有感觉了。
但其实这是某道困难题的简化版,本题根据「字符」滑动,而 [30. 串联所有单词的子串](https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/) 则是根据「单词」来。但基本思路都是一样的,强烈建议你来试试 ~
***
### 相关链接
[30. 串联所有单词的子串:【刷穿LC】朴素哈希表解法 + 滑动窗口解法](https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/solution/shua-chuan-lc-po-su-ha-xi-biao-jie-fa-hu-ml3x/)
[643. 子数组最大平均数 I:滑动窗口裸题 (含模板)~](https://leetcode-cn.com/problems/maximum-average-subarray-i/solution/hua-dong-chuang-kou-luo-ti-han-mo-ban-by-buo3/)
[1423. 可获得的最大点数:详解滑动窗口基本思路(含模板)~](https://leetcode-cn.com/problems/maximum-points-you-can-obtain-from-cards/solution/jian-dan-de-hua-dong-chuang-kou-he-kuai-1go5h/)
*** | ### 最后
这是我们「刷穿 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],妹妹有两种不同的糖果,弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。
```
注意:
* 数组的长度为[2, 10,000],并且确定为偶数。
* 数组中数字的大小在范围[-100,000, 100,000]内。 | ### 贪心
由于题目规定糖果数量 $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}$ 类不同的糖果组成单份,此时可取得的最大种类数量为 $m = \frac{n}{2}$;
3. $m < \frac{n}{2}$:糖果种类小于单份的糖果数量。此时先从 $m$ 类糖果中找出 $m$ 类不同糖果组成单份,再使用相同种类的糖果凑齐 $\frac{n}{2}$,此时可取得的最大种类数量为 $m$。
综上,无论糖果种类数与单份糖果数呈何种关系,我们可取得的最大糖果种类数量均为 $\min(m, \frac{n}{2})$。
代码:
```Java
class Solution {
public int distributeCandies(int[] candyType) {
Set<Integer> set = new HashSet<>();
for (int i : candyType) set.add(i);
return Math.min(candyType.length / 2, set.size());
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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 = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
输出:12
```
提示:
* 1 <= m, n <= 50
* 0 <= maxMove <= 50
* 0 <= startRow < m
* 0 <= startColumn < n | ### 基本分析
通常来说,朴素的路径 DP 问题之所以能够使用常规 DP 方式进行求解,是因为只能往某一个方向(一维棋盘的路径问题)或者只能往某两个方向(二维棋盘的路径问题)移动。
这样的移动规则意味着,我们不会重复进入同一个格子。
**从图论的意义出发:将每个格子视为点的话,如果能够根据移动规则从 `a` 位置一步到达 `b` 位置,则说明存在一条由 `a` 指向 `b` 的有向边。**
**也就是说,在朴素的路径 DP 问题中,“单向”的移动规则注定了我们的图不存在环,是一个存在拓扑序的有向无环图,因此我们能够使用常规 DP 手段来求解。**
回到本题,移动规则是四联通,并不是“单向”的,在某条出界的路径中,我们是有可能重复进入某个格子,即存在环。
因此我们需要换一种 DP 思路进行求解。
---
### 记忆化搜索
通常在直接 DP 不好入手的情况下,我们可以先尝试写一个「记忆化搜索」的版本。
那么如果是让你设计一个 DFS 函数来解决本题,你会如何设计?
我大概会这样设计:
```Java
int dfs(int x, int y, int k) {}
```
重点放在几个「可变参数」与「返回值」上:$(x,y)$ 代表当前所在的位置,$k$ 代表最多使用多少步,返回值代表路径数量。
根据 [DP-动态规划 第八讲](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485297&idx=1&sn=5ee4ce31c42d368af0653f60aa263c82&chksm=fd9cac6ecaeb25787e6da90423c5467e1679da0a8aaf1a3445475199a8f148d8629e851fea57&scene=178&cur_album_id=1773144264147812354#rd) 的学习中,我们可以确定递归出口为:
1. 当前到达了棋盘外的位置,说明找到了一条出界路径,返回 $1$;
2. 在条件 $1$ 不满足的前提下,当剩余步数为 $0$(不能再走下一步),说明没有找到一条合法的出界路径,返回 $0$。
主逻辑则是根据四联通规则进行移动即可,最终答案为 `dfs(startRow, startColumn, maxMove)`。
代码:
```Java
class Solution {
int MOD = (int)1e9+7;
int m, n, max;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
int[][][] cache;
public int findPaths(int _m, int _n, int _max, int r, int c) {
m = _m; n = _n; max = _max;
cache = new int[m][n][max + 1];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k <= max; k++) {
cache[i][j][k] = -1;
}
}
}
return dfs(r, c, max);
}
int dfs(int x, int y, int k) {
if (x < 0 || x >= m || y < 0 || y >= n) return 1;
if (k == 0) return 0;
if (cache[x][y][k] != -1) return cache[x][y][k];
int ans = 0;
for (int[] d : dirs) {
int nx = x + d[0], ny = y + d[1];
ans += dfs(nx, ny, k - 1);
ans %= MOD;
}
cache[x][y][k] = ans;
return ans;
}
}
```
---
### 动态规划
根据我们的「记忆化搜索」,我们可以设计一个二维数组 $f[][]$ 作为我们的 dp 数组:
* **第一维代表 DFS 可变参数中的 $(x,y)$ 所对应 $index$。取值范围为 $[0, m*n)$**
* **第二维代表 DFS 可变参数中的 $k$。取值范围为 $[0,max]$**
**dp 数组中存储的就是我们 `DFS` 的返回值:路径数量。**
根据 dp 数组中的维度设计和存储目标值,我们可以得知「状态定义」为:
**$f[i][j]$ 代表从位置 $i$ 出发,可用步数不超过 $j$ 时的路径数量。**
至此,我们只是根据「记忆化搜索」中的 `DFS` 函数的签名,就已经得出我们的「状态定义」了,接下来需要考虑「转移方程」。
当有了「状态定义」之后,我们需要从「最后一步」来推导出「转移方程」:
由于题目允许往四个方向进行移动,因此我们的最后一步也要统计四个相邻的方向。
由此可得我们的状态转移方程:
$$
f[(x,y)][step] = f[(x-1,y)][step-1]+f[(x+1,y)][step-1]+f[(x,y-1)][step-1]+f[(x,y+1)][step-1]
$$
注意,转移方程中 dp 数组的第一维存储的是 $(x,y)$ 对应的 $idx$。
从转移方程中我们发现,更新 $f[i][j]$ 依赖于 $f[x][j-1]$,因此我们转移过程中需要将最大移动步数进行「从小到大」枚举。
至此,我们已经完成求解「路径规划」问题的两大步骤:「状态定义」&「转移方程」。
但这还不是所有,我们还需要一些 **有效值** 来滚动下去。
**其实就是需要一些「有效值」作为初始化状态。**
观察我们的「转移方程」可以发现,整个转移过程是一个累加过程,如果没有一些有效的状态(非零值)进行初始化的话,整个递推过程并没有意义。
那么哪些值可以作为成为初始化状态呢?
显然,当我们已经位于矩阵边缘的时候,我们可以一步跨出矩阵,这算作一条路径。
同时,由于我们能够往四个方向进行移动,因此不同的边缘格子会有不同数量的路径。
换句话说,我们需要先对边缘格子进行初始化操作,预处理每个边缘格子直接走出矩阵的路径数量。
目的是为了我们整个 DP 过程可以有效的递推下去。
**可以发现,动态规划的实现,本质是将问题进行反向:原问题是让我们求从棋盘的特定位置出发,出界的路径数量。实现时,我们则是从边缘在状态出发,逐步推导回起点的出界路径数量为多少。**
代码:
```Java
class Solution {
int MOD = (int)1e9+7;
int m, n, max;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
public int findPaths(int _m, int _n, int _max, int r, int c) {
m = _m; n = _n; max = _max;
int[][] f = new int[m * n][max + 1];
// 初始化边缘格子的路径数量
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i == 0) add(i, j, f);
if (j == 0) add(i, j, f);
if (i == m - 1) add(i, j, f);
if (j == n - 1) add(i, j, f);
}
}
// 从小到大枚举「可移动步数」
for (int k = 1; k <= max; k++) {
// 枚举所有的「位置」
for (int idx = 0; idx < m * n; idx++) {
int[] info = parseIdx(idx);
int x = info[0], y = info[1];
for (int[] d : dirs) {
int nx = x + d[0], ny = y + d[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
int nidx = getIdx(nx, ny);
f[idx][k] += f[nidx][k - 1];
f[idx][k] %= MOD;
}
}
}
return f[getIdx(r, c)][max];
}
void add(int x, int y, int[][] f) {
for (int k = 1; k <= max; k++) {
f[getIdx(x, y)][k]++;
}
}
int getIdx(int x, int y) {
return x * n + y;
}
int[] parseIdx(int idx) {
return new int[]{idx / n, idx % n};
}
}
```
* 时间复杂度:共有 $m * n * max$ 个状态需要转移,复杂度为 $O(m * n * max)$
* 空间复杂度:$O(m * n * max)$ | ### 最后
这是我们「刷穿 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] <= 10^5$
* 进阶:你可以设计一个时间复杂度为 $O(n)$ 的解决方案吗? | ### 双指针 + 排序
最终目的是让整个数组有序,那么我们可以先将数组拷贝一份进行排序,然后使用两个指针 $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 <= j && nums[i] == arr[i]) i++;
while (i <= j && nums[j] == arr[j]) j--;
return j - i + 1;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 双指针 + 线性扫描
另外一个做法是,我们把整个数组分成三段处理。
起始时,先通过双指针 $i$ 和 $j$ 找到左右两次侧满足 **单调递增** 的分割点。
即此时 $[0, i]$ 和 $[j, n)$ 满足升序要求,而中间部分 $(i, j)$ **不确保有序**。
然后我们对中间部分 $[i, j]$ 进行遍历:
* 发现 $nums[x] < nums[i - 1]$:由于对 $[i, j]$ 部分进行排序后 $nums[x]$ 会出现在 $nums[i - 1]$ 后,将不满足整体升序,此时我们需要调整分割点 $i$ 的位置;
* 发现 $nums[x] > nums[j + 1]$:由于对 $[i, j]$ 部分进行排序后 $nums[x]$ 会出现在 $nums[j + 1]$ 前,将不满足整体升序,此时我们需要调整分割点 $j$ 的位置。
> 一些细节:在调整 $i$ 和 $j$ 的时候,我们可能会到达数组边缘,这时候可以建立两个哨兵:数组左边存在一个足够小的数,数组右边存在一个足够大的数。
代码:
```Java
class Solution {
int MIN = -100005, MAX = 100005;
public int findUnsortedSubarray(int[] nums) {
int n = nums.length;
int i = 0, j = n - 1;
while (i < j && nums[i] <= nums[i + 1]) i++;
while (i < j && nums[j] >= nums[j - 1]) j--;
int l = i, r = j;
int min = nums[i], max = nums[j];
for (int u = l; u <= r; u++) {
if (nums[u] < min) {
while (i >= 0 && nums[i] > nums[u]) i--;
min = i >= 0 ? nums[i] : MIN;
}
if (nums[u] > max) {
while (j < n && nums[j] < nums[u]) j++;
max = j < n ? nums[j] : MAX;
}
}
return j == i ? 0 : (j - 1) - (i + 1) + 1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 个字符(但最长公共子序列中不一定包含 $s1[i]$ 或者 $s2[j]$)时形成的「最长公共子序列(LCS)」长度。**
当有了「状态定义」之后,基本上「转移方程」就是呼之欲出:
* `s1[i]==s2[j]` : $f[i][j]=f[i-1][j-1]+1$。代表 **必然使用 $s1[i]$ 与 $s2[j]$ 时** LCS 的长度。
* `s1[i]!=s2[j]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表 **必然不使用 $s1[i]$(但可能使用$s2[j]$)时** 和 **必然不使用 $s2[j]$(但可能使用$s1[i]$)时** LCS 的长度。
可以发现,上述两种讨论已经包含了「不使用 $s1[i]$ 和 $s2[j]$」、「仅使用 $s1[i]$」、「仅使用 $s2[j]$」和「使用 $s1[i]$ 和 $s2[j]$」四种情况。
虽然「不使用 $s1[i]$ 和 $s2[j]$」会被 $f[i - 1][j]$ 和 $f[i][j - 1]$ 重复包含,但对于求最值问题,重复比较并不想影响答案正确性。
因此最终的 $f[i][j]$ 为上述两种讨论中的最大值。
一些编码细节:
通常会习惯性往字符串头部追加一个空格,以减少边界判断(使下标从 1 开始,并很容易构造出可滚动的「有效值」)。但实现上,不用真的往字符串中最佳空格,只需在初始化动规值时假定存在首部空格,以及对最后的 LCS 长度进行减一操作即可。
Java 代码:
```Java
class Solution {
public int minDistance(String s1, String s2) {
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
int n = s1.length(), m = s2.length();
int[][] f = new int[n + 1][m + 1];
// 假定存在哨兵空格,初始化 f[0][x] 和 f[x][0]
for (int i = 0; i <= n; i++) f[i][0] = 1;
for (int j = 0; j <= m; j++) f[0][j] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
if (cs1[i - 1] == cs2[j - 1]) f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);
}
}
int max = f[n][m] - 1; // 减去哨兵空格
return n - max + m - max;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minDistance(string s1, string s2) {
int n = s1.size(), m = s2.size();
vector<vector<int>> f(n + 1, vector<int>(m + 1));
for (int i = 0; i <= n; i++) f[i][0] = 1;
for (int j = 0; j <= m; j++) f[0][j] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = max(f[i - 1][j], f[i][j - 1]);
if (s1[i - 1] == s2[j - 1]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
}
}
int max = f[n][m] - 1;
return n - max + m - max;
}
};
```
Python 代码:
```Python
class Solution:
def minDistance(self, s1: str, s2: str) -> int:
n, m = len(s1), len(s2)
f = [[1]* (m + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(1, m + 1):
f[i][j] = max(f[i - 1][j], f[i][j - 1])
if s1[i - 1] == s2[j - 1]:
f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1)
max_val = f[n][m] - 1
return n - max_val + m - max_val
```
TypeScript 代码:
```TypeScript
function minDistance(s1: string, s2: string): number {
const n = s1.length, m = s2.length;
const f: number[][] = Array(n + 1).fill(0).map(() => Array(m + 1).fill(1));
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
if (s1[i - 1] === s2[j - 1]) {
f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);
}
}
}
const max = f[n][m] - 1;
return n - max + m - max;
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$
---
### 序列 DP
上述解决方案是套用了「最长公共子序列(LCS)」进行求解,最后再根据 LCS 长度计算答案。
而更加契合题意的状态定义是根据「最长公共子序列(LCS)」的原始状态定义进行微调:**定义 $f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 个字符(最终字符串不一定包含 $s1[i]$ 或 $s2[j]$)时形成相同字符串的最小删除次数。**
同理,不失一般性的考虑 $f[i][j]$ 该如何计算:
* `s1[i]==s2[j]`:$f[i][j] = f[i - 1][j - 1]$,代表可以不用必然删掉 $s1[i]$ 和 $s2[j]$ 形成相同字符串;
* `s1[i]!=s2[j]`:$f[i][j] = \min(f[i - 1][j] + 1, f[i][j - 1] + 1)$,代表至少一个删除 $s1[i]$ 和 $s2[j]$ 中的其中一个。
$f[i][j]$ 为上述方案中的最小值,最终答案为 $f[n][m]$。
Java 代码:
```Java
class Solution {
public int minDistance(String s1, String s2) {
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
int n = s1.length(), m = s2.length();
int[][] f = new int[n + 1][m + 1];
for (int i = 0; i <= n; i++) f[i][0] = i;
for (int j = 0; j <= m; j++) f[0][j] = j;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);
if (cs1[i - 1] == cs2[j - 1]) f[i][j] = Math.min(f[i][j], f[i - 1][j - 1]);
}
}
return f[n][m];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minDistance(string s1, string s2) {
int n = s1.size(), m = s2.size();
vector<vector<int>> f(n + 1, vector<int>(m + 1));
for(int i = 0; i <= n; i++) f[i][0] = i;
for(int j = 0; j <= m; j++) f[0][j] = j;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
if (s1[i - 1] == s2[j - 1]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);
}
}
return f[n][m];
}
};
```
Python 代码:
```Python
class Solution:
def minDistance(self, s1: str, s2: str) -> int:
n, m = len(s1), len(s2)
f = [[0]* (m + 1) for _ in range(n + 1)]
for i in range(n + 1):
f[i][0] = i
for i in range(m + 1):
f[0][i] = i
for i in range(1, n + 1):
for j in range(1, m + 1):
f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1)
if s1[i - 1] == s2[j - 1]:
f[i][j] = min(f[i][j], f[i - 1][j - 1])
return f[n][m]
```
TypeScript 代码:
```TypeScript
function minDistance(s1: string, s2: string): number {
const n = s1.length, m = s2.length;
const f: number[][] = Array.from({length: n + 1}, () => Array(m + 1).fill(0));
for(let i = 0; i <= n; i++) f[i][0] = i;
for(let i = 0; i <= m; i++) f[0][i] = i;
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);
if (s1.charAt(i - 1) == s2.charAt(j - 1)) f[i][j] = Math.min(f[i][j], f[i - 1][j - 1]);
}
}
return f[n][m];
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 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]]
解释:即使树都在一条直线上,你也需要先用绳子包围它们。
```
注意:
* 所有的树应当被围在一起。你不能剪断绳子来包围树或者把树分成一组以上。
* 输入的整数在 $0$ 到 $100$ 之间。
* 花园至少有一棵树。
* 所有树的坐标都是不同的。
* 输入的点没有顺序。输出顺序也没有要求。 | ### 二维凸包(Andrew 算法)
这是一道「二维凸包」板子题,需要注意的是网上大多数 `Andrew` 算法的板子都是有问题的(下面会说)。
`Andrew` 算法正是用于求解凸包上的所有点(围成所有点的最小周长),其算法逻辑将凸包分为「上凸壳」和「下凸壳」,并分别画出(蓝色分割线将凸包分为两部分):
基本流程为:
1. 对所有点进行双关键字排序,先根据 $x$ 坐标排升序,后根据 $y$ 排升序;
根据 $x$ 排升序的目的,是为了我们能够往一个方向画出凸包边缘(从左往后画出一半凸壳,从右往左画出另外一半),而将 $y$ 升序目的是可以确保一旦我们现在从 $a$ 到 $b$ 进行连线,那么 $a$ 到 $b$ 之间的所有点能够确保被围住;
2. 使用栈来维护所有凸包上的点,或者说凸包上的边,会更为准确,凸包起点元素会在栈中出现两次(首尾),因此更为准确的描述应该是使用栈维护凸包的所有的边,栈中相邻元素代表凸包上的一条边;
3. 分别「从前往后」和「从后往前」处理排序好的所有点,来分别画出凸包的两半部分,根据画的是第一部分还是第二部分,维护栈内元的处理逻辑稍有不同:
**a. 画的是凸包的第一部分:**
* 若栈内元素少于 $2$ 个,组成一条线至少需要两个点,说明此时第一条边都还没画出,直接将元素添加到栈中;
* 若栈内元素不少于 $2$ 个,考虑是否要将栈顶的边删掉(由栈顶前两个元素组成的边)假设栈顶元素为 $b$,栈顶元素的下一位为 $a$,即栈顶存在一条 $a$ 到 $b$ 的边,当前处理到的点为 $c$,此时我们根据 $ac$ 边是否在 $ab$ 边的时针方向来决定是否要将 $ab$ 边去掉:
按照上述逻辑处理完所有点,凸包第一部分的点(边)都存在于栈中。
**b. 画的是凸包的第二部分:逻辑同理,唯一需要注意的是,第一部分的凸包边我们不能删去,假定处理完第一部分凸包,我们栈内有 $m$ 个元素,我们需要将上述「栈顶元素不少于 $2$ 个」的逻辑替换为「栈顶元素大于 $m$ 个」,同时已参与到凸包第一部分的点,不能再考虑,因此需要额外使用一个 $vis$ 数组来记录使用过的点。**
一些细节,为了方便取得栈顶的前两位元素,我们使用数组实现栈,$stk$ 代表栈容器,$tp$ 代表栈顶元素下标。
正如刚刚讲到,起点会被入栈两次(对应第一条边和最后一条边),因此输出方案时,栈顶和栈底我们只选其一即可。
代码:
```Java
class Solution {
int[] subtraction(int[] a, int[] b) { // 向量相减
return new int[]{a[0] - b[0], a[1] - b[1]};
}
double cross(int[] a, int[] b) { // 叉乘
return a[0] * b[1] - a[1] * b[0];
}
double getArea(int[] a, int[] b, int[] c) { // 向量 ab 转为 向量 ac 过程中扫过的面积
return cross(subtraction(b, a), subtraction(c, a));
}
public int[][] outerTrees(int[][] trees) {
Arrays.sort(trees, (a, b)->{
return a[0] != b[0] ? a[0] - b[0] : a[1] - b[1];
});
int n = trees.length, tp = 0;
int[] stk = new int[n + 10];
boolean[] vis = new boolean[n + 10];
stk[++tp] = 0; // 不标记起点
for (int i = 1; i < n; i++) {
int[] c = trees[i];
while (tp >= 2) {
int[] a = trees[stk[tp - 1]], b = trees[stk[tp]];
if (getArea(a, b, c) > 0) vis[stk[tp--]] = false;
else break;
}
stk[++tp] = i;
vis[i] = true;
}
int size = tp;
for (int i = n - 1; i >= 0; i--) {
if (vis[i]) continue;
int[] c = trees[i];
while (tp > size) {
int[] a = trees[stk[tp - 1]], b = trees[stk[tp]];
if (getArea(a, b, c) > 0) tp--;
// vis[stk[tp--]] = false; // 非必须
else break;
}
stk[++tp] = i;
// vis[i] = true; // 非必须
}
int[][] ans = new int[tp - 1][2];
for (int i = 1; i < tp; i++) ans[i - 1] = trees[stk[i]];
return ans;
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,统计凸包上的点复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 网上 `Andrew` 板子问题
由于我太久没写计算几何了,翻了一下以前在其他 OJ 提交的题,找回自己几年前的板子,好奇心驱使,想看看现在是否有板子上的突破(通常很难,尤其对于计算几何而言),结果发现网上绝大多数板子都存在严重逻辑错误:
1. 最为严重的错误是,处理凸包第一部分和第二部分,都是使用「栈顶元素不少于 $2$ 个」的逻辑:即使存在 $vis$ 数组也无法避免该逻辑错误,在某些数据上,该逻辑**会导致最右边的一些点无法被围住**;
2. 存在对 `vis` 数组的错误理解:`vis` 的作用仅是为了处理凸包第二部分的时候,不要使用到凸包第一部分的点而已。**含义并非是处理过的点,或者当前凸包上的点**,因此你可以看到我代码注释中写了「不标记起点」和「非必须」,在画第二部分的凸包时,只需要确保第一部分使用的点不参与即可,**重复点问题本身就由遍历所保证,而并非 $vis$ 数组**。当然,为了记忆方便,让模板更具有“对称性”,也可以保留在画第二部分凸包的时候,保留对 $vis$ 的维护逻辑,但千万不要搞错了 $vis$ 的含义。 | ### 最后
这是我们「刷穿 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]
```
提示:
* 节点总数在范围 $[0, 10^4]$ 内
* $0 <= Node.val <= 10^4$
* $n$ 叉树的高度小于或等于 $1000$
进阶:递归法很简单,你可以使用迭代法完成此题吗? | ### 递归
常规做法,不再赘述。
代码:
```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);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 迭代
针对本题,使用「栈」模拟递归过程。
迭代过程中记录 `(node = 当前节点, cnt = 当前节点遍历过的子节点数量)` 二元组,每次取出栈顶元素,如果当前节点是首次出队(当前遍历过的子节点数量为 $cnt = 0$),则将当前节点的值加入答案,然后更新当前元素遍历过的子节点数量,并重新入队,即将 $(node, cnt + 1)$ 入队,以及将下一子节点 $(node.children[cnt], 0)$ 进行首次入队。
代码;
```Java
class Solution {
public List<Integer> preorder(Node root) {
List<Integer> ans = new ArrayList<>();
Deque<Object[]> d = new ArrayDeque<>();
d.addLast(new Object[]{root, 0});
while (!d.isEmpty()) {
Object[] poll = d.pollLast();
Node t = (Node)poll[0]; Integer cnt = (Integer)poll[1];
if (t == null) continue;
if (cnt == 0) ans.add(t.val);
if (cnt < t.children.size()) {
d.addLast(new Object[]{t, cnt + 1});
d.addLast(new Object[]{t.children.get(cnt), 0});
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 通用「递归」转「迭代」
另外一种「递归」转「迭代」的做法,是直接模拟系统执行「递归」的过程,这是一种更为通用的做法。
**由于现代编译器已经做了很多关于递归的优化,现在这种技巧已经无须掌握。**
在迭代过程中记录当前栈帧位置状态 `loc`,在每个状态流转节点做相应操作。
代码:
```Java
class Solution {
public List<Integer> preorder(Node root) {
List<Integer> ans = new ArrayList<>();
Deque<Object[]> d = new ArrayDeque<>();
d.addLast(new Object[]{0, root});
while (!d.isEmpty()) {
Object[] poll = d.pollLast();
Integer loc = (Integer)poll[0]; Node t = (Node)poll[1];
if (t == null) continue;
if (loc == 0) {
ans.add(t.val);
d.addLast(new Object[]{1, t});
} else if (loc == 1) {
int n = t.children.size();
for (int i = n - 1; i >= 0; i--) {
d.addLast(new Object[]{0, t.children.get(i)});
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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]
```
提示:
* 节点总数在范围 $[0, 10^4]$ 内
* $0 <= Node.val <= 10^4$
* $n$ 叉树的高度小于或等于 $1000$
进阶:递归法很简单,你可以使用迭代法完成此题吗? | ### 递归
常规做法,不再赘述。
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(root.val);
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> postorder(Node* root) {
vector<int> ans;
dfs(root, ans);
return ans;
}
void dfs(Node* root, vector<int>& ans) {
if (!root) return;
for (Node* child : root->children) dfs(child, ans);
ans.push_back(root->val);
}
};
```
Python 代码:
```Python
class Solution:
def postorder(self, root: 'Node') -> List[int]:
def dfs(root, ans):
if not root: return
for child in root.children:
dfs(child, ans)
ans.append(root.val)
ans = []
dfs(root, ans)
return ans
```
TypeScript 代码:
```TypeScript
function postorder(root: Node | null): number[] {
const dfs = function(root: Node | null, ans: number[]): void {
if (!root) return ;
for (const child of root.children) dfs(child, ans);
ans.push(root.val);
};
const ans: number[] = [];
dfs(root, ans);
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 非递归
针对本题,使用「栈」模拟递归过程。
迭代过程中记录 `(cnt = 当前节点遍历过的子节点数量, node = 当前节点)` 二元组,每次取出栈顶元素,如果当前节点已经遍历完所有的子节点(当前遍历过的子节点数量为 $cnt = 子节点数量$),则将当前节点的值加入答案。
否则更新当前元素遍历过的子节点数量,并重新入队,即将 $(cnt + 1, node)$ 入队,以及将下一子节点 $(0, node.children[cnt])$ 进行首次入队。
Java 代码:
```Java
class Solution {
public List<Integer> postorder(Node root) {
List<Integer> ans = new ArrayList<>();
Deque<Object[]> d = new ArrayDeque<>();
d.addLast(new Object[]{0, root});
while (!d.isEmpty()) {
Object[] poll = d.pollLast();
Integer cnt = (Integer)poll[0]; Node t = (Node)poll[1];
if (t == null) continue;
if (cnt == t.children.size()) ans.add(t.val);
if (cnt < t.children.size()) {
d.addLast(new Object[]{cnt + 1, t});
d.addLast(new Object[]{0, t.children.get(cnt)});
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> postorder(Node* root) {
vector<int> ans;
stack<pair<int, Node*>> st;
st.push({0, root});
while (!st.empty()) {
auto [cnt, t] = st.top();
st.pop();
if (!t) continue;
if (cnt == t->children.size()) ans.push_back(t->val);
if (cnt < t->children.size()) {
st.push({cnt + 1, t});
st.push({0, t->children[cnt]});
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def postorder(self, root: 'Node') -> List[int]:
ans = []
stack = [(0, root)]
while stack:
cnt, t = stack.pop()
if not t: continue
if cnt == len(t.children):
ans.append(t.val)
if cnt < len(t.children):
stack.append((cnt + 1, t))
stack.append((0, t.children[cnt]))
return ans
```
TypeScript 代码:
```TypeScript
function postorder(root: Node | null): number[] {
const ans = [], stack = [];
stack.push([0, root]);
while (stack.length > 0) {
const [cnt, t] = stack.pop()!;
if (!t) continue;
if (cnt === t.children.length) ans.push(t.val);
if (cnt < t.children.length) {
stack.push([cnt + 1, t]);
stack.push([0, t.children[cnt]]);
}
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 通用「非递归」
另外一种「递归」转「迭代」的做法,是直接模拟系统执行「递归」的过程,这是一种更为通用的做法。
**由于现代编译器已经做了很多关于递归的优化,现在这种技巧已经无须掌握。**
在迭代过程中记录当前栈帧位置状态 `loc`,在每个状态流转节点做相应操作。
Java 代码:
```Java
class Solution {
public List<Integer> postorder(Node root) {
List<Integer> ans = new ArrayList<>();
Deque<Object[]> d = new ArrayDeque<>();
d.addLast(new Object[]{0, root});
while (!d.isEmpty()) {
Object[] poll = d.pollLast();
Integer loc = (Integer)poll[0]; Node t = (Node)poll[1];
if (t == null) continue;
if (loc == 0) {
d.addLast(new Object[]{1, t});
int n = t.children.size();
for (int i = n - 1; i >= 0; i--) d.addLast(new Object[]{0, t.children.get(i)});
} else if (loc == 1) {
ans.add(t.val);
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> postorder(Node* root) {
vector<int> ans;
stack<pair<int, Node*>> st;
st.push({0, root});
while (!st.empty()) {
int loc = st.top().first;
Node* t = st.top().second;
st.pop();
if (!t) continue;
if (loc == 0) {
st.push({1, t});
for (int i = t->children.size() - 1; i >= 0; i--) {
st.push({0, t->children[i]});
}
} else if (loc == 1) {
ans.push_back(t->val);
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def postorder(self, root: 'Node') -> List[int]:
ans = []
stack = [(0, root)]
while stack:
loc, t = stack.pop()
if not t: continue
if loc == 0:
stack.append((1, t))
for child in reversed(t.children):
stack.append((0, child))
elif loc == 1:
ans.append(t.val)
return ans
```
TypeScript 代码:
```TypeScript
function postorder(root: Node | null): number[] {
const ans: number[] = [];
const stack: [number, Node | null][] = [[0, root]];
while (stack.length > 0) {
const [loc, t] = stack.pop()!;
if (!t) continue;
if (loc === 0) {
stack.push([1, t]);
for (let i = t.children.length - 1; i >= 0; i--) {
stack.push([0, t.children[i]]);
}
} else if (loc === 1) {
ans.push(t.val);
}
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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_NAME` 是不合法的。
4. 合法的 `TAG_CONTENT` 可以包含其他合法的闭合标签,`cdata` ( 请参考规则 $7$ )和任意字符( 注意参考规则 $1$ )除了不匹配的 `<`、不匹配的起始和结束标签、不匹配的或带有不合法 `TAG_NAME` 的闭合标签。否则,`TAG_CONTENT` 是不合法的。
5. 一个起始标签,如果没有具有相同 `TAG_NAME` 的结束标签与之匹配,是不合法的。反之亦然。不过,你也需要考虑标签嵌套的问题。
6. 一个 `<`,如果你找不到一个后续的 `>` 与之匹配,是不合法的。并且当你找到一个 `<` 或`</` 时,所有直到下一个 `>` 的前的字符,都应当被解析为 `TAG_NAME`(不一定合法)。
7. `cdata` 有如下格式:`<![CDATA[CDATA_CONTENT]]>`。`CDATA_CONTENT` 的范围被定义成 `<![CDATA[` 和后续的第一个 `]]>`之间的字符。
8. `CDATA_CONTENT` 可以包含任意字符。`cdata` 的功能是阻止验证器解析 `CDATA_CONTENT`,所以即使其中有一些字符可以被解析为标签(无论合法还是不合法),也应该将它们视为常规字符。
合法代码的例子:
```
输入: "<DIV>This is the first line <![CDATA[<div>]]></DIV>"
输出: True
解释:
代码被包含在了闭合的标签内: <DIV> 和 </DIV> 。
TAG_NAME 是合法的,TAG_CONTENT 包含了一些字符和 cdata 。
即使 CDATA_CONTENT 含有不匹配的起始标签和不合法的 TAG_NAME,它应该被视为普通的文本,而不是标签。
所以 TAG_CONTENT 是合法的,因此代码是合法的。最终返回True。
输入: "<DIV>>> ![cdata[]] <![CDATA[<div>]>]]>]]>>]</DIV>"
输出: True
解释:
我们首先将代码分割为: start_tag|tag_content|end_tag 。
start_tag -> "<DIV>"
end_tag -> "</DIV>"
tag_content 也可被分割为: text1|cdata|text2 。
text1 -> ">> ![cdata[]] "
cdata -> "<![CDATA[<div>]>]]>" ,其中 CDATA_CONTENT 为 "<div>]>"
text2 -> "]]>>]"
start_tag 不是 "<DIV>>>" 的原因参照规则 6 。
cdata 不是 "<![CDATA[<div>]>]]>]]>" 的原因参照规则 7 。
```
不合法代码的例子:
```
输入: "<A> <B> </A> </B>"
输出: False
解释: 不合法。如果 "<A>" 是闭合的,那么 "<B>" 一定是不匹配的,反之亦然。
输入: "<DIV> div tag is not closed <DIV>"
输出: False
输入: "<DIV> unmatched < </DIV>"
输出: False
输入: "<DIV> closed tags with invalid tag name <b>123</b> </DIV>"
输出: False
输入: "<DIV> unmatched tags with invalid tag name </1234567890> and <CDATA[[]]> </DIV>"
输出: False
输入: "<DIV> unmatched start tag <B> and unmatched end tag </C> </DIV>"
输出: False
```
注意:
* 为简明起见,你可以假设输入的代码(包括提到的任意字符)只包含`数字`, `字母`, `'<'`,`'>'`,`'/'`,`'!'`,`'['`,`']'`和`' '`。 | ### 模拟(栈)
字符串大模拟,假设字符串 `s` 长度为 $n$,当前处理到的位置为 $i$,根据以下优先级进行检查:
1. 优先尝试检查以 $i$ 为开始的连续段是否为 `CDATA`,若能匹配到开头,则尝试匹配到 `CDATA` 的结尾处,并更新 $i$,若无法找到结尾,返回 `False`;
2. 尝试匹配 $s[i]$ 是否为 `<`,若满足,则根据 $s[i + 1]$ 是否为 `/` 来判断当前 `TAG_NAME` 是处于右边还是左边,然后将 `TAG_NAME` 取出,记为 $tag$,判断 $tag$ 长度是否合法,不合法返回 `False`,合法则根据是左边还是右边的 `TAG_NAME` 分情况讨论:
* 位于左边的 `TAG_NAME`:将其加入栈中,等待右边的 `TAG_NAME` 与其匹配;
* 位于右边的 `TAG_NAME`:将其与当前栈顶的元素进行匹配,若栈为空或匹配不上,返回 `False`(注意:由于整个 `s` 应当被一对 `TAG_NAME` 所包裹,因此如果取出后栈顶元素匹配后,栈为空,同时又还没处理完整个 `s`,此时 `s` 也不合法,返回 `Fasle`);
3. 其余情况则为普通字符。
最后由于整个 `s` 应当被一对 `TAG_NAME` 所包裹,因此当 $i = 0$ 时,不能是情况 $1$ 和情况 $3$,需要特判一下。
代码:
```Java
class Solution {
String CDATA1 = "<![CDATA[", CDATA2 = "]]>";
public boolean isValid(String s) {
Deque<String> d = new ArrayDeque<>();
int n = s.length(), i = 0;
while (i < n) {
if (i + 8 < n && s.substring(i, i + 9).equals(CDATA1)) {
if (i == 0) return false;
int j = i + 9;
boolean ok = false;
while (j < n && !ok) {
if (j + 2 < n && s.substring(j, j + 3).equals(CDATA2)) {
j = j + 3; ok = true;
} else {
j++;
}
}
if (!ok) return false;
i = j;
} else if (s.charAt(i) == '<') {
if (i == n - 1) return false;
boolean isEnd = s.charAt(i + 1) == '/';
int p = isEnd ? i + 2 : i + 1, j = p;
while (j < n && s.charAt(j) != '>') {
if (!Character.isUpperCase(s.charAt(j))) return false;
j++;
}
if (j == n) return false;
int len = j - p;
if (len < 1 || len > 9) return false;
String tag = s.substring(p, j);
i = j + 1;
if (!isEnd) {
d.addLast(tag);
} else {
if (d.isEmpty() || !d.pollLast().equals(tag)) return false;
if (d.isEmpty() && i < n) return false;
}
} else {
if (i == 0) return false;
i++;
}
}
return d.isEmpty();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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"
```
提示:
* 输入和输出字符串只包含 `'0'` 到 `'9'` 的数字,以及 `'/'`, `'+'` 和 `'-'`。
* 输入和输出分数格式均为 `±分子/分母`。如果输入的第一个分数或者输出的分数是正数,则 `'+'` 会被省略掉。
* 输入只包含合法的最简分数,每个分数的分子与分母的范围是 $[1,10]$。 如果分母是 $1$,意味着这个分数实际上是一个整数。
* 输入的分数个数范围是 $[1,10]$。
* 最终结果的分子与分母保证是 $32$ 位整数范围内的有效整数。 | ### 表达式计算
为了方便,令 `expression` 为 `s`。
由于给定的表达式中只有 `+` 和 `-`,因此无须考虑优先级问题,直接从前往后计算即可。
使用变量 `ans` 代指计算过程中的结果,从前往后处理表达式 `s`,每次以 `±分子/分母` 的形式取出当前操作数(若为表达式的首个操作数,且为正数时,需要手动补一个 `+`)。
假设当前取出的操作数为 `num`,根据 `ans` 的情况进行运算:
* 若 `ans` 为空串,说明 `num` 是首个操作数,直接将 `num` 赋值给 `ans` 即可
* 若 `ans` 不为空串,此时计算 `num` 和 `ans` 的计算结果赋值给 `ans`
考虑实现一个计算函数 `String calc(String a, String b)` 计算两个操作 `a` 和 `b` 的结果,其中入参 `a` 和 `b` 以及返回值均满足 `±分子/分母` 形式。
首先通过读取 `a` 和 `b` 的首个字符,得到两操作数的正负情况。若为一正一负,通过交换的形式,确保 `a` 为正数,`b` 为负数。
然后通过 `parse` 方法拆解出字符串操作数的分子和分母,`parse` 使用指针扫描的方式实现即可,以数组形式将结果返回(第 $0$ 位为分子数值,第 $1$ 位分母数值)。
假设操作数 `a` 对应的值为 $\frac{p[0]}{p[1]}$,操作数的值为 $\frac{q[0]}{q[1]}$,先将其转换为 $\frac{p[0] \times q[1]}{p[1] \times q[1]}$ 和 $\frac{q[0] \times p[1]}{q[1] \times p[1]}$,进行运算后,再通过求最大公约数 `gcd` 的方式进行化简。
Java 代码:
```Java
class Solution {
public String fractionAddition(String s) {
int n = s.length();
char[] cs = s.toCharArray();
String ans = "";
for (int i = 0; i < n; ) {
int j = i + 1;
while (j < n && cs[j] != '+' && cs[j] != '-') j++;
String num = s.substring(i, j);
if (cs[i] != '+' && cs[i] != '-') num = "+" + num;
if (!ans.equals("")) ans = calc(num, ans);
else ans = num;
i = j;
}
return ans.charAt(0) == '+' ? ans.substring(1) : ans;
}
String calc(String a, String b) {
boolean fa = a.charAt(0) == '+', fb = b.charAt(0) == '+';
if (!fa && fb) return calc(b, a);
long[] p = parse(a), q = parse(b);
long p1 = p[0] * q[1], q1 = q[0] * p[1];
if (fa && fb) {
long r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2);
return "+" + (r1 / c) + "/" + (r2 / c);
} else if (!fa && !fb) {
long r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2);
return "-" + (r1 / c) + "/" + (r2 / c);
} else {
long r1 = p1 - q1, r2 = p[1] * q[1], c = gcd(Math.abs(r1), r2);
String ans = (r1 / c) + "/" + (r2 / c);
if (p1 >= q1) ans = "+" + ans;
return ans;
}
}
long[] parse(String s) {
int n = s.length(), idx = 1;
while (idx < n && s.charAt(idx) != '/') idx++;
long a = Long.parseLong(s.substring(1, idx)), b = Long.parseLong(s.substring(idx + 1));
return new long[]{a, b};
}
long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
}
```
TypeScript 代码:
```TypeScript
function fractionAddition(s: string): string {
const n = s.length
let ans = ""
for (let i = 0; i < n; ) {
let j = i + 1
while (j < n && s[j] != '+' && s[j] != '-') j++
let num = s.substring(i, j)
if (s[i] != '+' && s[i] != '-') num = "+" + num
if (ans != "") ans = calc(num, ans)
else ans = num
i = j
}
return ans[0] == "+" ? ans.substring(1) : ans
};
function calc(a: string, b: string): string {
const fa = a[0] == "+", fb = b[0] == "+"
if (!fa && fb) return calc(b, a)
const p = parse(a), q = parse(b)
const p1 = p[0] * q[1], q1 = q[0] * p[1]
if (fa && fb) {
const r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2)
return "+" + (r1 / c) + "/" + (r2 / c)
} else if (!fa && !fb) {
const r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2)
return "-" + (r1 / c) + "/" + (r2 / c)
} else {
const r1 = p1 - q1, r2 = p[1] * q[1], c = gcd(Math.abs(r1), r2)
let ans = (r1 / c) + "/" + (r2 / c)
if (p1 > q1) ans = "+" + ans
return ans
}
}
function parse(s: string): number[] {
let n = s.length, idx = 1
while (idx < n && s[idx] != "/") idx++
const a = Number(s.substring(1, idx)), b = Number(s.substring(idx + 1))
return [a, b]
}
function gcd(a: number, b: number): number {
return b == 0 ? a : gcd(b, a % b)
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 加餐 & 加练
**加餐一道更贴合笔试面试的「表达式计算」问题 : [双栈 : 表达式计算问题的通用解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 🎉🎉** | ### 最后
这是我们「刷穿 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], p2 = [-1,0], p3 = [0,1], p4 = [0,-1]
输出:true
```
提示:
* $p1.length == p2.length == p3.length == p4.length == 2$
* $-10^4 <= x_i, y_i <= 10^4$ | ### 计算几何
根据题意进行模拟即可。
从给定的 $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);
}
boolean calc(int[] a, int[] b, int[] c) {
long l1 = (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]);
long l2 = (a[0] - c[0]) * (a[0] - c[0]) + (a[1] - c[1]) * (a[1] - c[1]);
long l3 = (b[0] - c[0]) * (b[0] - c[0]) + (b[1] - c[1]) * (b[1] - c[1]);
boolean ok = (l1 == l2 && l1 + l2 == l3) || (l1 == l3 && l1 + l3 == l2) || (l2 == l3 && l2 + l3 == l1);
if (!ok) return false;
if (len == -1) len = Math.min(l1, l2);
else if (len == 0 || len != Math.min(l1, l2)) return false;
return true;
}
}
```
TypeScript 代码:
```TypeScript
let len = -1
function validSquare(a: number[], b: number[], c: number[], d: number[]): boolean {
len = -1
return calc(a, b, c) && calc(a, b, d) && calc(a, c, d) && calc(b, c, d)
};
function calc(a: number[], b: number[], c: number[]): boolean {
const l1 = (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1])
const l2 = (a[0] - c[0]) * (a[0] - c[0]) + (a[1] - c[1]) * (a[1] - c[1])
const l3 = (b[0] - c[0]) * (b[0] - c[0]) + (b[1] - c[1]) * (b[1] - c[1])
const ok = (l1 == l2 && l1 + l2 == l3) || (l1 == l3 && l1 + l3 == l2) || (l2 == l3 && l2 + l3 == l1)
if (!ok) return false
if (len == -1) len = Math.min(l1, l2)
else if (len == 0 || len != Math.min(l1, l2)) return false
return true
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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.length <= 2 * 10^4$
* $-10^9 <= nums[i] <= 10^9$ | ### 排序 + 滑动窗口
一个直观的想法是,先对 $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] > 1) i++;
if (nums[j] - nums[i] == 1) ans = Math.max(ans, j - i + 1);
}
return ans;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$,通过双指针实现的滑动窗口复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 哈希计数
题目规定的「和谐子序列」中的最值差值正好为 $1$,因而子序列排序后必然符合 $[a,a,..,a+1,a+1]$ 形式,即符合条件的和谐子序列长度为相邻两数(差值为 $1$) 的出现次数之和。
我们可以使用「哈希表」记录所有 $nums[i]$ 的出现次数,然后通过 $O(n)$ 的复杂度找出所有可能的数对(两数差值为 $1$),并在所有符合条件的数对所能构成的「和谐子序列」长度中取最大值。
代码:
```Java
class Solution {
public int findLHS(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
int ans = 0;
for (int i : nums) {
if (map.containsKey(i - 1)) {
ans = Math.max(ans, map.get(i) + map.get(i - 1));
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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]]
执行完操作 [2,2] 后, M =
[[1, 1, 0],
[1, 1, 0],
[0, 0, 0]]
执行完操作 [3,3] 后, M =
[[2, 2, 1],
[2, 2, 1],
[1, 1, 1]]
M 中最大的整数是 2, 而且 M 中有4个值为2的元素。因此返回 4。
```
注意:
* $m$ 和 $n$ 的范围是 $[1,40000]$。
* $a$ 的范围是 $[1,m]$,$b$ 的范围是 $[1,n]$。
* 操作数目不超过 $10000$。 | ### 模拟
由于每次都是对 $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) {
for (int[] op : ops) {
m = Math.min(m, op[0]);
n = Math.min(n, op[1]);
}
return m * n;
}
}
```
* 时间复杂度:令 $k$ 为 $ops$ 数组的长度。复杂度为 $O(k)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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"]
解释: 他们唯一共同喜爱的餐厅是“Shogun”。
```
示例 2:
```
输入:list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"],list2 = ["KFC", "Shogun", "Burger King"]
输出: ["Shogun"]
解释: 他们共同喜爱且具有最小索引和的餐厅是“Shogun”,它有最小的索引和1(0+1)。
```
提示:
* $1 <= list1.length, list2.length <= 1000$
* $1 <= list1[i].length, list2[i].length <= 30$
* $list1[i]$ 和 $list2[i]$ 由空格 `' '` 和英文字母组成。
* $list1$ 的所有字符串都是 唯一 的。
* $list2$ 中的所有字符串都是 唯一 的。 | ### 哈希表
为了快速判断某个字符串是否在另外一个数组中出现,我们可以先使用「哈希表」对 `list1` 中的字符串进行处理,以 $(list1[i]: i)$ 键值对形式进行存储。
然后遍历 `list2`,判断每个 $list2[i]$ 是否在哈希表中出现过,同时维护一个当前的 **最小索引总和** $min$,以及 **用于存储能够取得最小索引总和的字符串数组** $ans$。
假设当前遍历到的元素是 $list2[i]$,根据「$list2[i]$ 是否在哈希表中出现」以及「当前索引和与 $min$ 的大小关系」分情况讨论:
* 如果 $list2[i]$ 不在哈希表中,跳过:
* 如果 $list2[i]$ 在哈希表中:
* 索引之和等于 $min$,将 $list2[i]$ 加入 $ans$;
* 索引之和小于 $min$,更新 $min$,清空 $ans$,将 $list2[i]$ 加入 $ans$;
* 索引之和大于 $min$,跳过。
代码:
```Java
class Solution {
public String[] findRestaurant(String[] list1, String[] list2) {
int n = list1.length, m = list2.length;
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) map.put(list1[i], i);
List<String> ans = new ArrayList<>();
int min = 3000;
for (int i = 0; i < m; i++) {
String s = list2[i];
if (!map.containsKey(s)) continue;
if (i + map.get(s) < min) {
ans.clear();
min = i + map.get(s);
ans.add(s);
} else if (i + map.get(s) == min) {
ans.add(s);
}
}
return ans.toArray(new String[ans.size()]);
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n)$
---
### 答疑
评论区有位同学提出了一个挺有意思的疑问,或许是部分同学的共同疑问,这里集中答疑一下。
Q0: `for` 循环里的 `ans.clear()` 这个函数也是 $O(n)$ 复杂度吧,为什么合起来还是 $O(n)$ ?
A0: 在 `ArrayList` 源码中的 `clear` 实现会为了消除容器对对象的强引用,遍历容器内的内容并置空来帮助 GC。
但不代表这会导致复杂度上界变成 $n^2$。
不会导致复杂度退化的核心原因是:**由于 `clear` 导致的循环计算量总共必然不会超过 $n$**。因为最多只有 $n$ 个元素在 `ans` 里面,且同一元素不会被删除多次(即每个元素对 `clear` 的贡献不会超过 $1$)。
如果有同学还是觉得不好理解,可以考虑一种极端情况:`clear` 操作共发生 $n$ 次,但发生 $n$ 次的前提条件是每次 `ans` 中只有 $1$ 位元素,此时由 `clear` 操作带来的额外计算量为最大值 $n$。
因此这里的 `clear` 操作对复杂度影响是「累加」,而不是「累乘」,即复杂度仍为 $O(n)$,而不是 $O(n^2)$。
<br/>
Q1: 判断 $list[i]$ 是否在哈希中的操作,复杂度是多少?
A1: 在 Java 的 `HashMap` 实现中,当键值对中的键数据类型为 `String` 时,会先计算一次(之后使用缓存)该字符串的 `HashCode`,计算 `HashCode` 的过程需要遍历字符串,因此该操作是与字符串长度相关的(对于本题字符串长度不超过 $30$),然后根据 `HashCode`「近似」$O(1)$ 定位到哈希桶位置并进行插入/更新。
因此在 Java 中,该操作与「当前的字符串长度」相关,而与「当前容器所包含元素多少」无关。 | ### 最后
这是我们「刷穿 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$ 的某一位 $cur$ 是如何被处理的:
1. 如果当前位 $cur = 1$ 的话,由于我们需要满足「小于等于 $n$」的要求,因此如果该位填 $0$ 的话,后面的低位填什么都是满足要求的,因此我们期望能够查表得出「长度为 $i + 1$,且二进制位置 $i$ 数值为 $0$ 时」有多少合法数值,将其累加到答案中;
与此同时,我们需要确保当前位选 $1$ 是合法的,即我们需要记录上一位 $prev$ 是什么,确保 $cur$ 和 $prev$ 不同时为 $1$。
2. 如果当前位 $cur = 0$ 的话,我们只能选 $0$,并决策下一位。
当出现「当前位无法填入 $cur$」或者「决策到最低位」时,则完成了所有合法答案的统计。
至于流程 $1$ 中的查表操作,我们可以使用 `static` 预处理出 `f` 数组,定义 $f[i][j]$ 为考虑二进制长度为 $i$,且最高位为 $j$($0$ or $1$)时的合法数个数(值不超过)。
PS. 值不超过的含义代表了不仅仅统计高位为 $j$ 的情况。例如 $f[4][1]$ 代表长度为 $4$,最高为 $1$,其包含了 1xxx 和 0xxx 的合法数的个数。
> 注意:为了防止重复计数问题,我们在不失一般性的计算 $f[i][0]$ 和 $f[i][1]$ 时,既能采用诸如 $f[i][cur] += f[i - 1][prev]$ 的 “后向查找依赖” 的方式进行转移,也能采用 $f[i + 1][cur] += f[i][prev]$ “前向主动更新” 的方式进行转移。
不失一般性的考虑 $f[i][0]$ 和 $f[i][1]$ 能够更新哪些状态:
* 如果期望当前位填 $0$ 的话,需要统计所有满足 $(0...)_2$ 形式的合法数值,当前位的低一位只能填 $1$(填 $0$ 会出现重复计数,即需要忽略前导零的数值),此时有:$f[i + 1][0] = f[i][1]$;
* 如果期望当前位填 $1$ 的话,需要统计所有满足 $(1...)_2$ 和 $(0...)_2$ 形式的合法数值:
* $(1...)_2$ 时,当前位的低一位只能填 $0$;此时有:$f[i + 1][1] += f[i][0]$;
* $(0...)_2$ 时,当前位的低一位只能填 $1$;此时有:$f[i + 1][1] += f[i][1]$。
代码:
```Java
class Solution {
static int N = 50;
// f[i][j] 为考虑二进制长度为 i,而且最高位为 j(0 or 1)时的合法数个数(值不超过)
// 如 f[2][1] 代表二进制长度为 2,且(值不超过)最高位为 1 的合法数的个数:10、01、00
static int[][] f = new int[N][2];
static {
f[1][0] = 1; f[1][1] = 2;
for (int i = 1; i < N - 1; i++) {
f[i + 1][0] = f[i][1];
f[i + 1][1] = f[i][0] + f[i][1];
}
}
int getLen(int n) {
for (int i = 31; i >= 0; i--) {
if (((n >> i) & 1) == 1) return i;
}
return 0;
}
public int findIntegers(int n) {
int len = getLen(n);
int ans = 0, prev = 0;
for (int i = len; i >= 0; i--) {
// 当前位是 0 还是 1
int cur = ((n >> i) & 1);
// 如果当前位是 1,那么填 0 的话,后面随便填都符合,将方案数累加
if (cur == 1) ans += f[i + 1][0];
// 出现连续位为 1,分支结束,方案数被计算完
if (prev == 1 && cur == 1) break;
prev = cur;
if (i == 0) ans++;
}
return ans;
}
}
```
* 时间复杂度:由于我们预处理 `f` 数组的操作使用了 `static` 修饰(在跑样例数据前已经预处理完,且预处理结果被所有样例数据所共享),因此访问 `f` 数组是 $O(1)$ 的查表操作;统计答案的复杂度与二进制长度相关,复杂度为 $O(\log{n})$。整体复杂度为 $O(\log{n})$
* 空间复杂度:令 $C$ 为预处理数值的大小,固定为 $50 * 2$,复杂度为 $O(C)$ | ### 最后
这是我们「刷穿 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
/ \
2 3
\
4
输出: "1(2()(4))(3)"
解释: 和第一个示例相似,
除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。
``` | ### 递归
生成字符串的规则其实就是在「前序遍历」输出节点值的同时,在每颗子树的左右添加一对 `()`(根节点除外),同时需要忽略掉一些不必要的 `()` 。
所谓的不必要就是指当以某个节点 $x$ 为根时,其只「有左子树」而「没有右子树」时,右子树的 `()` 可被忽略,或者「左右子树都没有」时,两者的 `()` 可被忽略。
或者反过来说,如果对于每个非空节点才添加 `()` 的话,那么当「有右子树」同时「没有左子树」时,左子树的 `()` 不能被忽略,需要额外添加,从而确保生成出来的字符串能够与「有左子树」同时「没有右子树」的情况区分开来,而不会产生二义性。
代码:
```Java
class Solution {
StringBuilder sb = new StringBuilder();
public String tree2str(TreeNode root) {
dfs(root);
return sb.substring(1, sb.length() - 1);
}
void dfs(TreeNode root) {
sb.append("(");
sb.append(root.val);
if (root.left != null) dfs(root.left);
else if (root.right != null) sb.append("()");
if (root.right != null) dfs(root.right);
sb.append(")");
}
}
```
* 时间复杂度:令点数为 $n$,边数为 $m$。整体复杂度为 $O(n + m)$
* 空间复杂度:$O(n)$
---
### 迭代(非递归)
自然也能使用「迭代(非递归)」来做,使用栈来模拟上述递归过程。
由于当以某个节点 $x$ 为根节点时,其需要在 **开始** 前序遍历当前子树时添加 `(`,在 **结束** 前序遍历时添加 `)`,因此某个节点需要出入队两次。
同时区分是首次出队(开始前序遍历)还是二次出队(结束前序遍历),这需要使用一个 `set` 来做记录,其余逻辑与「递归」做法类似。
代码:
```Java
class Solution {
public String tree2str(TreeNode root) {
StringBuilder sb = new StringBuilder();
Set<TreeNode> vis = new HashSet<>();
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode t = d.pollLast();
if (vis.contains(t)) {
sb.append(")");
} else {
d.addLast(t);
sb.append("(");
sb.append(t.val);
if (t.right != null) d.addLast(t.right);
if (t.left != null) d.addLast(t.left);
else if (t.right != null) sb.append("()");
vis.add(t);
}
}
return sb.substring(1, sb.length() - 1);
}
}
```
* 时间复杂度:令点数为 $n$,边数为 $m$。整体复杂度为 $O(n + m)$
* 空间复杂度:$O(n)$
---
### 迭代(通用非递归)
上述的「迭代(非递归)」解法,我们还是需要针对题目再做简单分析。
而利用通用的「递归」转「非递归」技巧,我们可以直接对「递归」解法进行改写,同时利用通用非递归过程中的 `loc` 可以帮助我们省掉用作区分是否首次出队的 `set` 结构。
需要特别说明的是:**由于现代编译器已经做了很多关于递归的优化,现在这种技巧已经无须掌握。**
代码:
```Java
class Solution {
public String tree2str(TreeNode root) {
StringBuilder sb = new StringBuilder();
Deque<Object[]> d = new ArrayDeque<>();
d.addLast(new Object[]{0, root});
while (!d.isEmpty()) {
Object[] poll = d.pollLast();
int loc = (Integer)poll[0]; TreeNode t = (TreeNode)poll[1];
if (loc == 0) {
sb.append("(");
sb.append(t.val);
d.addLast(new Object[]{1, t});
} else if (loc == 1) {
d.addLast(new Object[]{2, t});
if (t.right != null) d.addLast(new Object[]{0, t.right});
if (t.left != null) d.addLast(new Object[]{0, t.left});
else if (t.right != null) sb.append("()");
} else if (loc == 2) {
sb.append(")");
}
}
return sb.substring(1, sb.length() - 1);
}
}
```
* 时间复杂度:令点数为 $n$,边数为 $m$。整体复杂度为 $O(n + m)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)
int tot = 0;
ListNode tmp = head;
while (tmp != null && ++tot > 0) tmp = tmp.next;
k %= tot;
if (k == 0) return head;
// 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」
ListNode slow = head, fast = head;
while (k-- > 0) fast = fast.next;
while (fast.next != null) {
slow = slow.next;
fast = fast.next;
}
// 保存新头结点,并将新尾结点的 next 指针置空
ListNode nHead = slow.next;
slow.next = null;
// 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上
fast.next = head;
return nHead;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* rotateRight(ListNode* head, int k) {
if (head == NULL || k == 0) return head;
// 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)
int tot = 0;
ListNode* tmp = head;
while (tmp != NULL && ++tot > 0) tmp = tmp->next;
k %= tot;
// 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」
if (k == 0) return head;
// 使用快慢指针找到倒数第 k 个节点
ListNode* slow = head;
ListNode* fast = head;
while (k-- > 0) fast = fast->next;
while (fast->next != NULL) {
slow = slow->next;
fast = fast->next;
}
// 保存新头结点,并将新尾结点的 next 指针置空
ListNode* nHead = slow->next;
slow->next = NULL;
// 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上
fast->next = head;
return nHead;
}
};
```
Python 代码:
```Python
class Solution:
def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
if not head or k == 0: return head
# 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)
tot, tmp = 0, head
while tmp:
tmp = tmp.next
tot += 1
k %= tot
# 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」
if k == 0: return head
# 使用快慢指针找到倒数第 k 个节点
slow, fast = head, head
while k > 0:
fast = fast.next
k -= 1
while fast.next:
slow = slow.next
fast = fast.next
# 保存新头结点,并将新尾结点的 next 指针置空
nHead = slow.next
slow.next = None
# 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上
fast.next = head
return nHead
```
TypeScript 代码:
```TypeScript
function rotateRight(head: ListNode | null, k: number): ListNode | null {
if (head == null || k == 0) return head;
// 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)
let tot = 0, tmp = head;
while (tmp !== null && ++tot > 0) tmp = tmp.next;
k %= tot;
// 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」
if (k == 0) return head;
// 使用快慢指针找到倒数第 k 个节点
let slow = head, fast = head;
while (k-- > 0) fast = fast.next;
while (fast.next !== null) {
slow = slow.next;
fast = fast.next;
}
// 保存新头结点,并将新尾结点的 next 指针置空
let nHead = slow.next;
slow.next = null;
// 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上
fast.next = head;
return nHead;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 闭合成环
另外一个做法是,先成环,再断开:
* 找到原链表的最后一个节点,将其与原链表的头结点相连(成环),并统计链表长度,更新有效 `k` 值
* 从原链表的头节点出发,找到需要断开的点,进行断开
Java 代码:
```java
class Solution {
public ListNode rotateRight(ListNode head, int k) {
if (head == null || k == 0) return head;
// 先将链表成环,并记录链表的长度
// tmp 会记录住原链表最后一位节点
int tot = 1;
ListNode tmp = head;
while (tmp.next != null && ++tot > 0) tmp = tmp.next;
k %= tot;
if (k == 0) return head;
// 正式成环
tmp.next = head;
// 从原链表 head 出发,走 tot - k - 1 步,找到「新尾结点」进行断开,并将其下一个节点作为新节点返回
k = tot - k - 1;
while (k-- > 0) head = head.next;
ListNode nHead = head.next;
head.next = null;
return nHead;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* rotateRight(ListNode* head, int k) {
if (head == NULL || k == 0) return head;
// 先将链表成环,并记录链表的长度
// tmp 会记录住原链表最后一位节点
int tot = 1;
ListNode* tmp = head;
while (tmp->next != NULL && ++tot > 0) tmp = tmp->next;
k %= tot;
if (k == 0) return head;
// 正式成环
tmp->next = head;
// 从原链表 head 出发,走 tot - k - 1 步,找到「新尾结点」进行断开,并将其下一个节点作为新节点返回
k = tot - k - 1;
while (k-- > 0) head = head->next;
ListNode* nHead = head->next;
head->next = NULL;
return nHead;
}
};
```
Python 代码:
```Python
class Solution:
def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
if not head or k == 0: return head
# 先将链表成环,并记录链表的长度
# tmp 会记录住原链表最后一位节点
tot, tmp = 1, head
while tmp.next:
tmp = tmp.next
tot += 1
k %= tot
if k == 0: return head
# 正式成环
tmp.next = head
# 从原链表 head 出发,走 tot - k - 1 步,找到「新尾结点」进行断开,并将其下一个节点作为新节点返回
k = tot - k - 1
while k > 0:
head = head.next
k -= 1
nHead = head.next
head.next = None
return nHead
```
TypeScript 代码:
```TypeScript
function rotateRight(head: ListNode | null, k: number): ListNode | null {
if (head == null || k == 0) return head;
// 先将链表成环,并记录链表的长度
// tmp 会记录住原链表最后一位节点
let tot = 1, tmp = head;
while (tmp.next !== null && ++tot > 0) tmp = tmp.next;
k %= tot;
if (k == 0) return head;
// 正式成环
tmp.next = head;
k = tot - k - 1;
while (k-- > 0) head = head.next;
let nHead = head.next;
head.next = null;
return nHead;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]`
部分无效数字列举如下:
* `["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]`
给你一个字符串 `s`,如果 `s` 是一个 有效数字 ,请返回 `true`。
示例 1:
```
输入:s = "0"
输出:true
```
示例 2:
```
输入:s = "e"
输出:false
```
示例 3:
```
输入:s = "."
输出:false
```
示例 4:
```
输入:s = ".1"
输出:true
```
提示:
* $1 <= s.length <= 20$
* `s` 仅含英文字母(大写和小写),数字(`0-9`),加号 `'+'` ,减号 `'-'` ,或者点 `'.'` 。 | ### 模拟
字符串大模拟,根据「有效数字定义」梳理规则即可。
本题有多种解法:「正则」、「DFA」、「模拟」...
**「模拟」是在各类场景中最容易实现的方式,只要头脑不发热都能写出来。**
将字符串以 `e/E` 进行分割后,其实规则十分简单:
* 如果存在 `e/E` :左侧可以「整数」或「浮点数」,右侧必须是「整数」
* 如果不存在 `e/E` :整段可以是「整数」或「浮点数」
关键在于如何实现一个 `check` 函数用于判断「整数」或「浮点数」:
* `+/-` 只能出现在头部
* `.` 最多出现一次
* 至少存在一个数字
代码:
```Java
class Solution {
public boolean isNumber(String s) {
int n = s.length();
char[] cs = s.toCharArray();
int idx = -1;
for (int i = 0; i < n; i++) {
if (cs[i] == 'e' || cs[i] == 'E') {
if (idx == -1) idx = i;
else return false;
}
}
boolean ans = true;
if (idx != -1) {
ans &= check(cs, 0, idx - 1, false);
ans &= check(cs, idx + 1, n - 1, true);
} else {
ans &= check(cs, 0, n - 1, false);
}
return ans;
}
boolean check(char[] cs, int start, int end, boolean mustInteger) {
if (start > end) return false;
if (cs[start] == '+' || cs[start] == '-') start++;
boolean hasDot = false, hasNum = false;
for (int i = start; i <= end; i++) {
if (cs[i] == '.') {
if (mustInteger || hasDot) return false;
hasDot = true;
} else if (cs[i] >= '0' && cs[i] <= '9') {
hasNum = true;
} else {
return false;
}
}
return hasNum;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:将 `toCharArray` 替换为 `charAt` 为 $O(1)$,否则为 $O(n)$ | ### 最后
这是我们「刷穿 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] <= 9 | ### 模拟
这是 [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<Integer> list = new ArrayList<>();
for (int i = n - 1, t = 0; i >= 0 || t != 0; i--) {
int x = i >= 0 ? digits[i] + t : t;
list.add(x % 10);
t = x / 10;
}
Collections.reverse(list);
int[] ans = new int[list.size()];
for (int i = 0; i < list.size(); i++) ans[i] = list.get(i);
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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` 至少包含一个单词
示例:
```
输入:
words = ["This", "is", "an", "example", "of", "text", "justification."]
maxWidth = 16
输出:
[
"This is an",
"example of text",
"justification. "
]
```
示例 2:
```
输入:
words = ["What","must","be","acknowledgment","shall","be"]
maxWidth = 16
输出:
[
"What must be",
"acknowledgment ",
"shall be "
]
解释: 注意最后一行的格式应为 "shall be " 而不是 "shall be",
因为最后一行应为左对齐,而不是左右两端对齐。
第二行同样为左对齐,这是因为这行只包含一个单词。
```
示例 3:
```
输入:
words = ["Science","is","what","we","understand","well","enough","to","explain",
"to","a","computer.","Art","is","everything","else","we","do"]
maxWidth = 20
输出:
[
"Science is what we",
"understand well",
"enough to explain to",
"a computer. Art is",
"everything else we",
"do "
]
``` | ### 模拟
字符串大模拟,分情况讨论即可:
1. 如果当前行只有一个单词,特殊处理为左对齐;
2. 如果当前行为最后一行,特殊处理为左对齐;
3. 其余为一般情况,分别计算「当前行单词总长度」、「当前行空格总长度」和「往下取整后的单位空格长度」,然后依次进行拼接。当空格无法均分时,每次往靠左的间隙多添加一个空格,直到剩余的空格能够被后面的间隙所均分。
代码:
```Java
class Solution {
public List<String> fullJustify(String[] words, int maxWidth) {
List<String> ans = new ArrayList<>();
int n = words.length;
List<String> list = new ArrayList<>();
for (int i = 0; i < n; ) {
// list 装载当前行的所有 word
list.clear();
list.add(words[i]);
int cur = words[i++].length();
while (i < n && cur + 1 + words[i].length() <= maxWidth) {
cur += 1 + words[i].length();
list.add(words[i++]);
}
// 当前行为最后一行,特殊处理为左对齐
if (i == n) {
StringBuilder sb = new StringBuilder(list.get(0));
for (int k = 1; k < list.size(); k++) {
sb.append(" ").append(list.get(k));
}
while (sb.length() < maxWidth) sb.append(" ");
ans.add(sb.toString());
break;
}
// 如果当前行只有一个 word,特殊处理为左对齐
int cnt = list.size();
if (cnt == 1) {
String str = list.get(0);
while (str.length() != maxWidth) str += " ";
ans.add(str);
continue;
}
/**
* 其余为一般情况
* wordWidth : 当前行单词总长度;
* spaceWidth : 当前行空格总长度;
* spaceItem : 往下取整后的单位空格长度
*/
int wordWidth = cur - (cnt - 1);
int spaceWidth = maxWidth - wordWidth;
int spaceItemWidth = spaceWidth / (cnt - 1);
String spaceItem = "";
for (int k = 0; k < spaceItemWidth; k++) spaceItem += " ";
StringBuilder sb = new StringBuilder();
for (int k = 0, sum = 0; k < cnt; k++) {
String item = list.get(k);
sb.append(item);
if (k == cnt - 1) break;
sb.append(spaceItem);
sum += spaceItemWidth;
// 剩余的间隙数量(可填入空格的次数)
int remain = cnt - k - 1 - 1;
// 剩余间隙数量 * 最小单位空格长度 + 当前空格长度 < 单词总长度,则在当前间隙多补充一个空格
if (remain * spaceItemWidth + sum < spaceWidth) {
sb.append(" ");
sum++;
}
}
ans.add(sb.toString());
}
return ans;
}
}
```
* 时间复杂度:会对 $words$ 做线性扫描,最坏情况下每个 $words[i]$ 独占一行,此时所有字符串的长度为 $n * maxWidth$。复杂度为 $O(n * maxWidth)$
* 空间复杂度:最坏情况下每个 $words[i]$ 独占一行,复杂度为 $O(n * maxWidth)$ | ### 最后
这是我们「刷穿 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.length;
Arrays.sort(nums);
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i - 1; j >= 0; j--) {
for (int k = j - 1; k >= 0; k--) {
if (nums[j] + nums[k] > nums[i]) ans++;
}
}
}
return ans;
}
}
```
* 时间复杂度:排序时间复杂度为 $O(n\log{n})$;三层遍历找所有三元祖的复杂度为 $O(n^3)$。整体复杂度为 $O(n^3)$
* 空间复杂度:$O(\log{n})$
---
### 排序 + 二分
根据我们以前讲过的的 [优化枚举的基本思路](https://leetcode-cn.com/problems/number-of-submatrices-that-sum-to-target/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-uttw/),要找符合条件的三元组,其中一个切入点可以是「枚举三元组中的两个值,然后优化找第三数的逻辑」。
我们发现,在数组有序的前提下,**当枚举到较大数下标 $i$ 和次大数下标 $j$ 时,在 $[0, j)$ 范围内找的符合 $nums[k'] + nums[j] > nums[i]$ 条件的 $k'$ 的集合时,以符合条件的最小下标 $k$ 为分割点的数轴上具有「二段性」。**
令 $k$ 为符合条件的最小下标,那么在 $nums[i]$ 和 $nums[j]$ 固定时,$[0,j)$ 范围内:
* 下标大于等于 $k$ 的点集符合条件 $nums[k'] + nums[j] > nums[i]$;
* 下标小于 $k$ 的点集合不符合条件 $nums[k'] + nums[j] > nums[i]$。
因此我们可以通过「二分」找到这个分割点 $k$,在 $[k,j)$ 范围内即是固定 $j$ 和 $i$ 时,符合条件的 $k'$ 的个数。
代码:
```Java
class Solution {
public int triangleNumber(int[] nums) {
int n = nums.length;
Arrays.sort(nums);
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i - 1; j >= 0; j--) {
int l = 0, r = j - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] + nums[j] > nums[i]) r = mid;
else l = mid + 1;
}
if (l == r && nums[r] + nums[j] > nums[i]) ans += j - r;
}
}
return ans;
}
}
```
* 时间复杂度:排序时间复杂度为 $O(n\log{n})$;两层遍历加二分所有符合条件的三元组的复杂度为 $O(n^2*\log{n})$。整体复杂度为 $O(n^2*\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 排序 + 双指针
更进一步我们发现,当我们在枚举较大数下标 $i$,并在 $[0, i)$ 范围内逐步减小下标(由于数组有序,也就是逐步减少值)找次大值下标 $j$ 时,符合条件的 $k'$ 必然是从 $0$ 逐步递增(这是由三角不等式 $nums[k] + nums[j] > nums[i]$ 所决定的)。
因此,我们可以枚举较大数下标 $i$ 时,在 $[0, i)$ 范围内通过双指针,以逐步减少下标的方式枚举 $j$,并在遇到不满足条件的 $k$ 时,增大 $k$ 下标。从而找到所有符合条件三元组的个数。
代码:
```Java
class Solution {
public int triangleNumber(int[] nums) {
int n = nums.length;
Arrays.sort(nums);
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i - 1, k = 0; k < j; j--) {
while (k < j && nums[k] + nums[j] <= nums[i]) k++;
ans += j - k;
}
}
return ans;
}
}
```
* 时间复杂度:排序时间复杂度为 $O(n\log{n})$,双指针找所有符合条件的三元组的复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 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 -> (待命) -> A -> B
在本示例中,两个相同类型任务之间必须间隔长度为 n = 2 的冷却时间,而执行一个任务只需要一个单位时间,所以中间出现了(待命)状态。
```
示例 2:
```
输入:tasks = ["A","A","A","B","B","B"], n = 0
输出:6
解释:在这种情况下,任何大小为 6 的排列都可以满足要求,因为 n = 0
["A","A","A","B","B","B"]
["A","B","A","B","A","B"]
["B","B","B","A","A","A"]
...
诸如此类
```
示例 3:
```
输入:tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2
输出:16
解释:一种可能的解决方案是:
A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> (待命) -> (待命) -> A -> (待命) -> (待命) -> A
```
提示:
* $1 <= task.length <= 10^4$
* `tasks[i]` 是大写英文字母
* `n` 的取值范围为 $[0, 100]$ | ### 构造
先考虑最为简单的情况:假设只有一类任务,除了最后一个任务以外,其余任务在安排后均需要增加 $n$ 个单位的冻结时间。
将任务数记为 $m$ 个,其中前 $m - 1$ 个任务均要消耗 $n + 1$ 的单位时间,最后一个任务仅消耗 $1$ 个单位时间,即所需要的时间为 $(n + 1) \times (m - 1) + 1$。
**当存在多个任务时,由于每一类任务都需要被完成,因此本质上我们最需要考虑的是将数量最大的任务安排掉,其他任务则是间插其中。**
假设数量最大的任务数为 `max`,共有 `tot` 个任务数为 `max` 的任务种类。
实际上,当任务总数不超过 $(n + 1) \times (\max - 1) + tot$ 时,我们总能将其他任务插到空闲时间中去,不会引入额外的冻结时间(下左图);而当任务数超过该值时,我们可以在将其横向添加每个 $n + 1$ 块的后面,同时不会引入额外的冻结时间(下右图):
综上,我们所需要的最小时间为上述两种情况中的较大值即可:
$$
\max(task.length, (n + 1) \times (max - 1) + tot)
$$
Java 代码:
```Java
class Solution {
public int leastInterval(char[] tasks, int n) {
int[] cnts = new int[26];
for (char c : tasks) cnts[c - 'A']++;
int max = 0, tot = 0;
for (int i = 0; i < 26; i++) max = Math.max(max, cnts[i]);
for (int i = 0; i < 26; i++) tot += max == cnts[i] ? 1 : 0;
return Math.max(tasks.length, (n + 1) * (max - 1) + tot);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int leastInterval(vector<char>& tasks, int n) {
vector<int> cnts(26, 0);
for (char c : tasks) cnts[c - 'A']++;
int maxv = *max_element(cnts.begin(), cnts.end());
int tot = count(cnts.begin(), cnts.end(), maxv);
return max(static_cast<int>(tasks.size()), (n + 1) * (maxv - 1) + tot);
}
};
```
Python 代码:
```Python
class Solution:
def leastInterval(self, tasks: List[str], n: int) -> int:
cnts = [0] * 26
for c in tasks:
cnts[ord(c) - ord('A')] += 1
maxv, tot = 0, 0
for i in range(26):
maxv = max(maxv, cnts[i])
for i in range(26):
tot += 1 if maxv == cnts[i] else 0
return max(len(tasks), (n + 1) * (maxv - 1) + tot)
```
TypeScript 代码:
```TypeScript
function leastInterval(tasks: string[], n: number): number {
const cnts = new Array<number>(26).fill(0)
for (const c of tasks) cnts[c.charCodeAt(0) - 'A'.charCodeAt(0)]++
let max = 0, tot = 0
for (let i = 0; i < 26; i++) max = Math.max(max, cnts[i])
for (let i = 0; i < 26; i++) tot += max == cnts[i] ? 1 : 0
return Math.max(tasks.length, (n + 1) * (max - 1) + tot)
}
```
* 时间复杂度:$O(n + C)$
* 空间复杂度:$O(C)$,其中 $C = 26$ 为任务字符集大小 | ### 最后
这是我们「刷穿 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(value)`: 向循环队列插入一个元素。如果成功插入则返回真。
* `deQueue()`: 从循环队列中删除一个元素。如果成功删除则返回真。
* `isEmpty()`: 检查循环队列是否为空。
* `isFull()`: 检查循环队列是否已满。
示例:
```
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1); // 返回 true
circularQueue.enQueue(2); // 返回 true
circularQueue.enQueue(3); // 返回 true
circularQueue.enQueue(4); // 返回 false,队列已满
circularQueue.Rear(); // 返回 3
circularQueue.isFull(); // 返回 true
circularQueue.deQueue(); // 返回 true
circularQueue.enQueue(4); // 返回 true
circularQueue.Rear(); // 返回 4
```
提示:
* 所有的值都在 $0$ 至 $1000$ 的范围内;
* 操作数将在 $1$ 至 $1000$ 的范围内;
* 请不要使用内置的队列库。 | ### 数据结构
创建一个长度为 $k$ 的数组充当循环队列,使用两个变量 `he` 和 `ta` 来充当队列头和队列尾(起始均为 $0$),整个过程 `he` 始终指向队列头部,`ta` 始终指向队列尾部的下一位置(待插入元素位置)。
两变量始终自增,通过与 $k$ 取模来确定实际位置。
分析各类操作的基本逻辑:
* `isEmpty` 操作:当 `he` 和 `ta` 相等,队列存入元素和取出元素的次数相同,此时队列为空;
* `isFull` 操作:`ta - he` 即队列元素个数,当元素个数为 $k$ 个时,队列已满;
* `enQueue` 操作:若队列已满,返回 $-1$,否则在 `nums[ta % k]` 位置存入目标值,并将 `ta` 指针后移;
* `deQueue` 操作:若队列为空,返回 $-1$,否则将 `he` 指针后移,含义为弹出队列头部元素;
* `Front` 操作:若队列为空,返回 $-1$,否则返回 `nums[he % k]` 队头元素;
* `Rear` 操作:若队列为空,返回 $-1$,否则返回 `nums[(ta - 1) % k]` 队尾元素;
Java 代码:
```Java
class MyCircularQueue {
int k, he, ta;
int[] nums;
public MyCircularQueue(int _k) {
k = _k;
nums = new int[k];
}
public boolean enQueue(int value) {
if (isFull()) return false;
nums[ta % k] = value;
return ++ta >= 0;
}
public boolean deQueue() {
if (isEmpty()) return false;
return ++he >= 0;
}
public int Front() {
return isEmpty() ? -1 : nums[he % k];
}
public int Rear() {
return isEmpty() ? -1 : nums[(ta - 1) % k];
}
public boolean isEmpty() {
return he == ta;
}
public boolean isFull() {
return ta - he == k;
}
}
```
TypeScript 代码:
```TypeScript
class MyCircularQueue {
k: number = 0; he: number = 0; ta: number = 0;
nums: number[];
constructor(k: number) {
this.k = k
this.nums = new Array<number>(this.k)
}
enQueue(value: number): boolean {
if (this.isFull()) return false
this.nums[this.ta % this.k] = value
return this.ta++ >= 0
}
deQueue(): boolean {
if (this.isEmpty()) return false
return this.he++ >= 0
}
Front(): number {
return this.isEmpty() ? -1 : this.nums[this.he % this.k]
}
Rear(): number {
return this.isEmpty() ? -1 : this.nums[(this.ta - 1) % this.k]
}
isEmpty(): boolean {
return this.he == this.ta
}
isFull(): boolean {
return this.ta - this.he == this.k
}
}
```
* 时间复杂度:构造函数复杂度为 $O(k)$,其余操作复杂度为 $O(1)$
* 空间复杂度:$O(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` 作为整个原始树的新根,而原始树就是新根的左子树。
示例 1:
```
输入: root = [4,2,6,3,1,5], val = 1, depth = 2
输出: [4,1,1,2,null,null,6,3,1,5]
```
示例 2:
```
输入: root = [4,2,null,3,1], val = 1, depth = 3
输出: [4,2,null,1,1,3,null,null,1]
```
提示:
* 节点数在 $[1, 10^4]$ 范围内
* 树的深度在 $[1, 10^4]$范围内
* $-100 <= Node.val <= 100$
* $-10^5 <= val <= 10^5$
* $1 <= depth <= the depth of tree + 1$ | ### 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);
int cur = 1;
while (!d.isEmpty()) {
int sz = d.size();
while (sz-- > 0) {
TreeNode t = d.pollFirst();
if (cur == depth - 1) {
TreeNode a = new TreeNode(val), b = new TreeNode(val);
a.left = t.left; b.right = t.right;
t.left = a; t.right = b;
} else {
if (t.left != null) d.addLast(t.left);
if (t.right != null) d.addLast(t.right);
}
}
cur++;
}
return root;
}
}
```
TypeScript 代码:
```TypeScript
function addOneRow(root: TreeNode | null, val: number, depth: number): TreeNode | null {
if (depth == 1) return new TreeNode(v, root, null);
const stk = new Array<TreeNode>()
let he = 0, ta = 0, cur = 1
stk[ta++] = root
while (he < ta) {
let sz = ta - he
while (sz-- > 0) {
const t = stk[he++]
if (cur == depth - 1) {
const a = new TreeNode(val), b = new TreeNode(val)
a.left = t.left; b.right = t.right
t.left = a; t.right = b
} else {
if (t.left != null) stk[ta++] = t.left
if (t.right != null) stk[ta++] = t.right
}
}
cur++
}
return root
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### DFS
同理,使用 `DFS` 也可进行求解,在 `DFS` 过程中记录当前深度。
Java 代码:
```Java
class Solution {
int d, v;
public TreeNode addOneRow(TreeNode root, int val, int depth) {
d = depth; v = val;
if (d == 1) return new TreeNode(val, root, null);
dfs(root, 1);
return root;
}
void dfs(TreeNode root, int cur) {
if (root == null) return ;
if (cur == d - 1) {
TreeNode a = new TreeNode(v), b = new TreeNode(v);
a.left = root.left; b.right = root.right;
root.left = a; root.right = b;
} else {
dfs(root.left, cur + 1);
dfs(root.right, cur + 1);
}
}
}
```
TypeScript 代码:
```TypeScript
let d = 0, v = 0
function addOneRow(root: TreeNode | null, val: number, depth: number): TreeNode | null {
d = depth; v = val
if (d == 1) return new TreeNode(v, root, null);
dfs(root, 1)
return root
};
function dfs(root: TreeNode | null, cur: number): void {
if (root == null) return
if (cur == d - 1) {
const a = new TreeNode(v), b = new TreeNode(v)
a.left = root.left; b.right = root.right
root.left = a; root.right = b
} else {
dfs(root.left, cur + 1)
dfs(root.right, cur + 1)
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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] 都有 1 个逆序对。
```
说明:
* `n` 的范围是 `[1, 1000]` 并且 `k` 的范围是 `[0, 1000]`。 | ### 序列 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 - (i - 1 - k)$,而与 $i$ 不相关的逆序对数量由 $f[i - 1][x]$ 可得出。
举个 🌰 帮助大家理解:
* 当数值 $i$ 放置在下标为 $0$ 的位置上,那么由数值 $i$ 产生的逆序对数量为 $i - 1$,总的逆序对数量为 $j$,因此由数值范围为 $[1, i - 1]$(与数值 $i$ 不相关)构成的逆序对数量为 $j - (i - 1)$,即 $f[i - 1][j - (i - 1)]$;
* 当数值 $i$ 放置在下标为 $1$ 的位置上,那么由数值 $i$ 产生的逆序对数量为 $(i - 1) - 1$,总的逆序对数量为 $j$,因此由数值范围为 $[1, i - 1]$(与数值 $i$ 不相关)构成的逆序对数量为 $j - (i - 1 - 1)$,即 $f[i - 1][j - (i - 1 - 1)]$;
...
* 当数值 $i$ 放置在下标为 $k$ 的位置上,那么由数值 $i$ 产生的逆序对数量为 $(i - 1) - k$,总的逆序对数量为 $j$,因此由数值范围为 $[1, i - 1]$(与数值 $i$ 不相关)构成的逆序对数量为 $j - (i - 1 - k)$,即 $f[i - 1][j - (i - 1 - k)]$。
综上,最终 $f[i][j]$ 转移方程为($k$ 为数值 $i$ 放置的位置):
$$
f[i][j] = \sum_{k = 0}^{i - 1}(f[i - 1][j - (i - 1 - k)])
$$
共有 $n * k$ 个状态,每个 $f[i][j]$ 的计算需要枚举数值 $i$ 所在位置并进行累加,总的复杂度为 $O(n^2 *k)$,计算量为 $10^9$,会 TLE。
状态数量不可减少,考虑如何优化单个状态的转移过程。
不难发现 $\sum_{k = 0}^{i - 1}(f[i - 1][j - (i - 1 - k)])$ 部分为上一次转移结果 $f[i - 1][x]$ 的某个前缀,可以使用前缀和数组进行优化,从而将计算单个状态的复杂度从 $O(n)$ 降到 $O(1)$。
> 一些细节:为处理负数问题,我们可以在取模之前先加一次 mod;另外需要对 $j$ 和 $i$ 的大小进行分情况讨论,防止数值 $i$ 放置的位置“过于靠前”导致组成逆序对的数量超过 $j$。
代码($P1$ $P2$ 分别为使用 `long` 和不使用 `long`):
```Java
class Solution {
int mod = (int)1e9+7;
public int kInversePairs(int n, int k) {
long[][] f = new long[n + 1][k + 1];
long[][] sum = new long[n + 1][k + 1];
f[1][0] = 1;
Arrays.fill(sum[1], 1);
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= k; j++) {
f[i][j] = j < i ? sum[i - 1][j] : sum[i - 1][j] - sum[i - 1][j - (i - 1) - 1];
f[i][j] = (f[i][j] + mod) % mod;
sum[i][j] = j == 0 ? f[i][j] : sum[i][j - 1] + f[i][j];
sum[i][j] = (sum[i][j] + mod) % mod;
}
}
return (int)f[n][k];
}
}
```
```Java
class Solution {
int mod = (int)1e9+7;
public int kInversePairs(int n, int k) {
int[][] f = new int[n + 1][k + 1];
int[][] sum = new int[n + 1][k + 1];
f[1][0] = 1;
Arrays.fill(sum[1], 1);
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= k; j++) {
f[i][j] = j < i ? sum[i - 1][j] : (sum[i - 1][j] - sum[i - 1][j - (i - 1) - 1] + mod) % mod;
sum[i][j] = j == 0 ? f[i][j] : (sum[i][j - 1] + f[i][j]) % mod;
}
}
return f[n][k];
}
}
```
* 时间复杂度:$O(n \times k)$
* 空间复杂度:$O(n \times k)$ | ### 最后
这是我们「刷穿 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 门课,耗费 100 天,在第 100 天完成,在第 101 天开始下门课。
第二,修第 3 门课,耗费 1000 天,在第 1100 天完成,在第 1101 天开始下门课程。
第三,修第 2 门课,耗时 200 天,在第 1300 天完成。
第 4 门课现在不能修,因为将会在第 3300 天完成它,这已经超出了关闭日期。
```
示例 2:
```
输入:courses = [[1,2]]
输出:1
```
示例 3:
```
输入:courses = [[3,2],[4,3]]
输出:0
```
提示:
* $1 <= courses.length <= 10^4$
* $1 <= durationi, lastDayi <= 10^4$ | ### 贪心 + 优先队列(堆)
这是一道很好的题目。
题目是要我们构造出一种可行的排列,排列中每个课程的实际结束时间满足「最晚完成时间」要求,求可行排序的最大长度(每个课程对答案的贡献都是 $1$)。
这容易引导我们往「泛化背包」方面进行思考:简单来说,对于某个物品(课程)而言,在不同条件下成本不同,在时间轴 $[1, courses[i][1] - courses[i][0]]$ 上该物品可被选,成本为其持续时间,在比该范围大的数轴上无法被选,成本为正无穷。因此某一段特定的时间轴上,问题可抽象成有条件限制的组合优化问题。
**由于数据范围为 $10^4$,泛化背包做法需要记录的维度大于一维,不予考虑。**
再然后容易想到「二分」,显然在以最大选择数量 $ans$ 为分割点的数组上具有「二段性」:
* 使用数量小于等于 $ans$ 的课程能够构造出合法排序(考虑在最长合法序列上做减法即可);
* 使用数量大于 $ans$ 的课程无法构造出合法排列。
此时二分范围为 $[0, n]$,问题转化为:如何在 $O(n)$ 检查是否可构造出某个长度 $len$ 的合法排列(实现 `check` 方法)。
**常规的线性扫描做法无法确定是否存在某个长度的合法排列,因此二分不予考虑。**
我们需要运用「贪心」思维考虑可能的方案。
具体的,我们先根据「结束时间」对 $courses$ 排升序,从前往后考虑每个课程,处理过程中维护一个总时长 $sum$,对于某个课程 $courses[i]$ 而言,根据如果学习该课程,是否满足「最晚完成时间」要求进行分情况讨论:
* 学习该课程后,满足「最晚完成时间」要求,即 $sum + courses[i][0] <= courses[i][1]$,则进行学习;
* 学习该课程后,不满足「最晚完成时间」要求,此时从过往学习的课程中找出「持续时间」最长的课程进行「回退」操作(这个持续时长最长的课程有可能是当前课程)。
其中「记录当前已选课程」和「从过往学习的课程中找出持续时间最长的课程」操作可以使用优先队列(大根堆)实现。
可用「归纳法 + 反证法」证明该做法能够取到最优排列之一,定义最优排列为「总课程数最大,且总耗时最少」的合法排列。
1. 在课程数量相同的前提下,该做法得到的排列总耗时最少
这点可通过「反证法」来证明:当不满足「最后完成时间」时,我们总是弹出「持续时间」最长的课程来进行回退,因此在所有课程对答案的贡献都是 $1$ 的前提下,该做法能够确保总耗时最少。即当堆中元素数量被调整为 $x$ 时,必然是由元素数量为 $x + 1$ 时,将持续时间最长的课程弹出所得来。
2. 该做法能够确保取得最大课程数量
在得证第 $1$ 点后,可用「归纳法」进行证明第 $2$ 点:只考虑一个课程的情况下(假定 $courses[0][0] < courses[0][1]$),选该课程会比不选更好。
将 $courses[0]$ 的最优解排列记为 $s[0]$,当确定了 $s[0]$ 后再考虑如何处理 $courses[1]$ 来得到 $s[1]$。
首先可知 $s[1]$ 只有三种情况:
* $s[1] = s[0]$:意味着 $courses[1]$ 不参与到最优解排列当中;
* $s[1] \neq s[0]$,但两个最优解长度相同:意味着 $s[1]$ 是由 $courses[1]$ 替换了 $s[0]$ 中的某个课程而来(此时只有第 $0$ 个课程),且基于证明 $1$ 可以得证,被替换的课程持续时间比 $courses[1]$ 要长;
* $s[1] \neq s[0]$,且 $s[1]$ 长度比 $s[0]$ 大 $1$:意味着 $s[1]$ 是由 $courses[1]$ 最接追加到 $s[0]$ 而来。
综上,我们证明了,如果已知某个边界情况的最优解,那么由边界的最优解可推导出在此基础上多考虑一个课程时的最优解。即以上分析可以推广到任意的 $s[i - 1]$ 和 $s[i]$。
**需要注意,在推广到任意的 $s[i - 1]$ 和 $s[i]$ 时,还需要证明在已知 $s[i - 1]$ 时,多考虑一个 $courses[i]$ 不会出现 $s[i]$ 的和 $s[i - 1]$ 的长度差超过 $1$ 的情况。**
这个基于已得证的第 $1$ 点,再用反证法可证:如果在 $s[i - 1]$ 的基础上多考虑一个 $courses[i]$ 能够使得总长度增加超过 $1$,说明存在一个「之前没有被选的课程」+「课程 $courses[i]$」的持续时间比「被替换的课程」短。
那么使用这个「之前没有被选的课程」直接替换「被替换的课程」可得到长度与 $s[i - 1]$ 相同,且总耗时更短的排列方案,这与 $s[i - 1]$ 本身是最优排列冲突。
代码:
```Java
class Solution {
public int scheduleCourse(int[][] courses) {
Arrays.sort(courses, (a,b)->a[1]-b[1]);
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
int sum = 0;
for (int[] c : courses) {
int d = c[0], e = c[1];
sum += d;
q.add(d);
if (sum > e) sum -= q.poll();
}
return q.size();
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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++) {
int b = (int)Math.sqrt(c - a * a);
if (a * a + b * b == c) return true;
}
return false;
}
}
```
* 时间复杂度:$O(\sqrt{c})$
* 空间复杂度:$O(1)$
---
### 双指针
由于 `a` 和 `b` 的范围均为 $[0,\sqrt{c}]$,因此我们可以使用「双指针」在 $[0,\sqrt{c}]$ 范围进行扫描:
* $a^2 + b^2 == c$ : 找到符合条件的 `a` 和 `b`,返回 $true$
* $a^2 + b^2 < c$ : 当前值比目标值要小,`a++`
* $a^2 + b^2 > c$ : 当前值比目标值要大,`b--`
代码:
```Java
class Solution {
public boolean judgeSquareSum(int c) {
int a = 0, b = (int)Math.sqrt(c);
while (a <= b) {
int cur = a * a + b * b;
if (cur == c) {
return true;
} else if (cur > c) {
b--;
} else {
a++;
}
}
return false;
}
}
```
* 时间复杂度:$O(\sqrt{c})$
* 空间复杂度:$O(1)$
---
### 费马平方和
**费马平方和 : 奇质数能表示为两个平方数之和的充分必要条件是该质数被 4 除余 1 。**
翻译过来就是:**当且仅当一个自然数的质因数分解中,满足 `4k+3` 形式的质数次方数均为偶数时,该自然数才能被表示为两个平方数之和。**
因此我们对 `c` 进行质因数分解,再判断满足 `4k+3` 形式的质因子的次方数是否均为偶数即可。
代码:
```Java
public class Solution {
public boolean judgeSquareSum(int c) {
for (int i = 2, cnt = 0; i * i <= c; i++, cnt = 0) {
while (c % i == 0 && ++cnt > 0) c /= i;
if (i % 4 == 3 && cnt % 2 != 0) return false;
}
return c % 4 != 3;
}
}
```
* 时间复杂度:$O(\sqrt{c})$
* 空间复杂度:$O(1)$
---
### 我猜你问
* 三种解法复杂度都一样,哪个才是最优解呀?
前两套解法是需要「真正掌握」的,而「费马平方和」更多的是作为一种拓展。
你会发现从复杂度上来说,其实「费马平方和」并没有比前两种解法更好,但由于存在对 `c` 除质因数操作,导致「费马平方和」实际表现效果要优于同样复杂度的其他做法。但这仍然不成为我们必须掌握「费马平方和」的理由。
三者从复杂度上来说,都是 $O(\sqrt{c})$ 算法,不存在最不最优的问题。
* 是否有关于「费马平方和」的证明呢?
想要看 莱昂哈德·欧拉 对于「费马平方和」的证明在 [这里](https://zh.wikipedia.org/wiki/%E8%B4%B9%E9%A9%AC%E5%B9%B3%E6%96%B9%E5%92%8C%E5%AE%9A%E7%90%86),我这里直接引用 费马 本人的证明:
> 我确实发现了一个美妙的证明,但这里空白太小写不下。
* 我就是要学「费马平方和」,有没有可读性更高的代码?
有的,在这里。喜欢的话可以考虑背过:
```Java
public class Solution {
public boolean judgeSquareSum(int c) {
for (int i = 2; i * i <= c; i++) {
int cnt = 0;
while (c % i == 0) {
cnt++;
c /= i;
}
if (i % 4 == 3 && cnt % 2 != 0) return false;
}
return c % 4 != 3;
}
}
``` | ### 最后
这是我们「刷穿 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}"` 进行格式化的字符串。
例如,`"0:start:3"` 意味着标识符为 `0` 的函数调用在时间戳 `3` 的 起始开始执行 ;而 `"1:end:2"` 意味着标识符为 `1` 的函数调用在时间戳 `2` 的末尾结束执行。
注意,函数可以调用多次,可能存在递归调用 。
函数的「独占时间」定义是在这个函数在程序所有函数调用中执行时间的总和,调用其他函数花费的时间不算该函数的独占时间。
例如,如果一个函数被调用两次,一次调用执行 `2` 单位时间,另一次调用执行 `1` 单位时间,那么该函数的独占时间为 `2 + 1 = 3` 。
以数组形式返回每个函数的独占时间,其中第 `i` 个下标对应的值表示标识符 `i` 的函数的独占时间。
示例 1:
```
输入:n = 2, logs = ["0:start:0","1:start:2","1:end:5","0:end:6"]
输出:[3,4]
解释:
函数 0 在时间戳 0 的起始开始执行,执行 2 个单位时间,于时间戳 1 的末尾结束执行。
函数 1 在时间戳 2 的起始开始执行,执行 4 个单位时间,于时间戳 5 的末尾结束执行。
函数 0 在时间戳 6 的开始恢复执行,执行 1 个单位时间。
所以函数 0 总共执行 2 + 1 = 3 个单位时间,函数 1 总共执行 4 个单位时间。
```
示例 2:
```
输入:n = 1, logs = ["0:start:0","0:start:2","0:end:5","0:start:6","0:end:6","0:end:7"]
输出:[8]
解释:
函数 0 在时间戳 0 的起始开始执行,执行 2 个单位时间,并递归调用它自身。
函数 0(递归调用)在时间戳 2 的起始开始执行,执行 4 个单位时间。
函数 0(初始调用)恢复执行,并立刻再次调用它自身。
函数 0(第二次递归调用)在时间戳 6 的起始开始执行,执行 1 个单位时间。
函数 0(初始调用)在时间戳 7 的起始恢复执行,执行 1 个单位时间。
所以函数 0 总共执行 2 + 4 + 1 + 1 = 8 个单位时间。
```
示例 3:
```
输入:n = 2, logs = ["0:start:0","0:start:2","0:end:5","1:start:6","1:end:6","0:end:7"]
输出:[7,1]
解释:
函数 0 在时间戳 0 的起始开始执行,执行 2 个单位时间,并递归调用它自身。
函数 0(递归调用)在时间戳 2 的起始开始执行,执行 4 个单位时间。
函数 0(初始调用)恢复执行,并立刻调用函数 1 。
函数 1在时间戳 6 的起始开始执行,执行 1 个单位时间,于时间戳 6 的末尾结束执行。
函数 0(初始调用)在时间戳 7 的起始恢复执行,执行 1 个单位时间,于时间戳 7 的末尾结束执行。
所以函数 0 总共执行 2 + 4 + 1 = 7 个单位时间,函数 1 总共执行 1 个单位时间。
```
示例 4:
```
输入:n = 2, logs = ["0:start:0","0:start:2","0:end:5","1:start:7","1:end:7","0:end:8"]
输出:[8,1]
```
示例 5:
```
输入:n = 1, logs = ["0:start:0","0:end:0"]
输出:[1]
```
提示:
* $1 <= n <= 100$
* $1 <= logs.length <= 500$
* $0 <= function_id < n$
* $0 <= timestamp <= 10^9$
* 两个开始事件不会在同一时间戳发生
* 两个结束事件不会在同一时间戳发生
* 每道函数都有一个对应 `"start"` 日志的 `"end"` 日志 | ### 模拟
我们使用「栈」来模拟执行过程:当一个函数被调用(`op = start`)时,压入栈内,当函数调用完成(`op = end`)时,从栈顶弹出(此时栈顶元素必然是该结束函数的入栈记录),使用变量 `cur` 记录当前时间。
从前往后处理所有的 $log[i]$,根据 $log[i]$ 是属于函数调用还是函数结束进行分情况讨论:
* 当 $log[i]$ 为函数调用:此时从该函数的调用发起时间 `ts` 到上一次记录的当前时间,都是前一函数的执行时间,因此可以将 `ts - cur` 累加到栈帧中的前一函数。即若栈不为空,则将该时间累加到栈顶对应的函数上,然后将 $log[i]$ 入栈,同时更新当前时间;
* 当 $log[i]$ 为函数结束:此时栈顶元素必然是该函数的调用记录,此时 $log[i]$ 的结束时间与上一次记录的当前时间的时长 `ts - cur + 1`,必然是该函数的执行时间,将其累加到当前函数中,并更新当前时间。
Java 代码:
```Java
class Solution {
public int[] exclusiveTime(int n, List<String> logs) {
int[] ans = new int[n];
Deque<Integer> d = new ArrayDeque<>();
int cur = -1;
for (String log : logs) {
String[] ss = log.split(":");
int idx = Integer.parseInt(ss[0]), ts = Integer.parseInt(ss[2]);
if (ss[1].equals("start")) {
if (!d.isEmpty()) ans[d.peekLast()] += ts - cur;
d.addLast(idx);
cur = ts;
} else {
int func = d.pollLast();
ans[func] += ts - cur + 1;
cur = ts + 1;
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> exclusiveTime(int n, vector<string>& logs) {
vector<int> ans(n, 0);
stack<int> s;
int cur = -1;
for (auto log : logs) {
istringstream ss(log);
string buf;
vector<string> tokens;
while (getline(ss, buf, ':')) {
tokens.push_back(buf);
}
int idx = stoi(tokens[0]), ts = stoi(tokens[2]);
if (tokens[1] == "start") {
if (!s.empty()) ans[s.top()] += ts - cur;
s.push(idx);
cur = ts;
} else {
ans[s.top()] += ts - cur + 1;
s.pop();
cur = ts + 1;
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:
ans = [0] * n
s = []
cur = -1
for log in logs:
ss = log.split(':')
idx, ts = int(ss[0]), int(ss[2])
if ss[1] == "start":
if s: ans[s[-1]] += ts - cur
s.append(idx)
cur = ts
else:
ans[s.pop()] += ts - cur + 1
cur = ts + 1
return ans
```
TypeScript 代码:
```TypeScript
function exclusiveTime(n: number, logs: string[]): number[] {
const ans = new Array<number>(n).fill(0)
const stk = new Array<number>()
let he = 0, ta = 0, cur = -1
for (let log of logs) {
const ss = log.split(":")
const idx = Number(ss[0]), ts = Number(ss[2])
if (ss[1] == "start") {
if (he < ta) ans[stk[ta - 1]] += ts - cur
stk[ta++] = idx
cur = ts
} else {
const func = stk[--ta]
ans[func] += ts - cur + 1
cur = ts + 1
}
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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` 个大礼包的价格。
返回 确切 满足购物清单所需花费的最低价格,你可以充分利用大礼包的优惠活动。你不能购买超出购物清单指定数量的物品,即使那样会降低整体价格。任意大礼包可无限次购买。
示例 1:
```
输入:price = [2,5], special = [[3,0,5],[1,2,10]], needs = [3,2]
输出:14
解释:有 A 和 B 两种物品,价格分别为 ¥2 和 ¥5 。
大礼包 1 ,你可以以 ¥5 的价格购买 3A 和 0B 。
大礼包 2 ,你可以以 ¥10 的价格购买 1A 和 2B 。
需要购买 3 个 A 和 2 个 B , 所以付 ¥10 购买 1A 和 2B(大礼包 2),以及 ¥4 购买 2A 。
```
示例 2:
```
输入:price = [2,3,4], special = [[1,1,0,4],[2,2,1,9]], needs = [1,2,1]
输出:11
解释:A ,B ,C 的价格分别为 ¥2 ,¥3 ,¥4 。
可以用 ¥4 购买 1A 和 1B ,也可以用 ¥9 购买 2A ,2B 和 1C 。
需要买 1A ,2B 和 1C ,所以付 ¥4 买 1A 和 1B(大礼包 1),以及 ¥3 购买 1B , ¥4 购买 1C 。
不可以购买超出待购清单的物品,尽管购买大礼包 2 更加便宜。
```
提示:
* n == price.length
* n == needs.length
* 1 <= n <= 6
* 0 <= price[i] <= 10
* 0 <= needs[i] <= 10
* 1 <= special.length <= 100
* special[i].length == n + 1
* 0 <= special[i][j] <= 50 | ### 转换 DFS(转换为礼包处理)
对于某个 $need[i]$ 而言,既可以「单买」也可以使用「礼包形式购买」,同时两种购买方式都存在对「份数」的决策(单买多少份/买多少个相应的礼包)。
利用物品数量和礼包数量数据范围都较少,我们可以先对「单买」情况进行预处理,将其转换为「礼包」形式。若 $price[0] = 100$,则使用礼包 $[1, 0, 0, ...,0, 100]$ 来代指。
然后再预处理每个礼包最多选多少个,并使用哈希表进行存储。
最后使用 `DFS` 对每个「礼包」如何选择进行爆搜即可。
代码:
```Java
class Solution {
int ans = 0x3f3f3f3f;
List<Integer> price, needs;
List<List<Integer>> special;
Map<Integer, Integer> map = new HashMap<>();
int n, m;
public int shoppingOffers(List<Integer> _price, List<List<Integer>> _special, List<Integer> _needs) {
price = _price; special = _special; needs = _needs;
n = price.size();
List<Integer> temp = new ArrayList<>();
for (int i = 0; i < n; i++) temp.add(0);
for (int i = 0; i < n; i++) {
List<Integer> clone = new ArrayList<>(temp);
clone.set(i, 1);
clone.add(price.get(i));
special.add(clone);
}
m = special.size();
for (int i = 0; i < m; i++) {
List<Integer> x = special.get(i);
int max = 0;
for (int j = 0; j < n; j++) {
int a = x.get(j), b = needs.get(j);
if (a == 0 || b == 0) continue;
max = Math.max(max, (int)Math.ceil(b / a));
}
map.put(i, max);
}
dfs(0, needs, 0);
return ans;
}
void dfs(int u, List<Integer> list, int cur) {
if (cur >= ans) return ;
if (u == m) {
for (int i = 0; i < n; i++) {
if (list.get(i) != 0) return ;
}
ans = Math.min(ans, cur);
return ;
}
List<Integer> x = special.get(u);
out:for (int k = 0; k <= map.get(u); k++) {
List<Integer> clist = new ArrayList<>(list);
for (int i = 0; i < n; i++) {
int a = x.get(i), b = clist.get(i);
if (a * k > b) break out;
clist.set(i, b - a * k);
}
dfs(u + 1, clist, cur + k * x.get(n));
}
}
}
```
* 时间复杂度:令物品数量为 $n$,原礼包数量为 $m$。将「单买」预处理成「礼包」,共有 $n$ 中「单买」情况需要转换,同时每个转换需要对数组进行复制,复杂度为 $O(n^2)$,预处理完后,共有 $n + m$ 个礼包;预处理每个礼包所能选的最大数量,复杂度为 $O((n * m) * n)$;对礼包的选择方案进行决策,一个礼包最多选择 $k = \max(needs[i]) = 10$ 个,复杂度为 $O(k ^ {n + m})$
* 空间复杂度:$O(k ^ {n + m})$
---
### 完全背包
这还是一道很有意思的「完全背包」问题。
不了解「完全背包」的同学,可以先看前置🧀:[完全背包](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486107&idx=1&sn=e5fa523008fc5588737b7ed801caf4c3&chksm=fd9ca184caeb28926959c0987208a3932ed9c965267ed366b5b82a6fc16d42f1ff40c29db5f1&scene=178&cur_album_id=1751702161341628417#rd)。目前[「背包问题」专题](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzU4NDE3MTEyMA==&action=getalbum&album_id=1751702161341628417&scene=173&from_msgid=2247486107&from_itemidx=1&count=3&nolastread=1#wechat_redirect) 已经讲了 $21$ 篇,大概还有 $2$ - $4$ 篇彻底讲完,完全覆盖了所有的「背包问题」。
背包问题难点在于对「成本」和「价值」的抽象。
对于本题,我们可以定义 **$f[i, j_0, j_1, j_2, ... , j_{n - 1}]$ 为考虑前 $i$ 个大礼包,购买 $j_0$ 件物品 $0$,购买 $j_1$ 件物品 $1$,....,购买 $j_{n - 1}$ 件物品 $n - 1$ 时的最小花费。**
同时,我们有初始化条件 $f[0, 0, 0, ... , 0] = 0$(其余 $f[0, x_0, x_1, x_2, ..., x_n]$ 为正无穷)的初始化条件,最终答案为 $f[m - 1, need[0], need[1], ..., need[n - 1]]$。
这样的朴素完全背包做法复杂度过高,根据我们的前置🧀 [完全背包](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486107&idx=1&sn=e5fa523008fc5588737b7ed801caf4c3&chksm=fd9ca184caeb28926959c0987208a3932ed9c965267ed366b5b82a6fc16d42f1ff40c29db5f1&scene=178&cur_album_id=1751702161341628417#rd) 中的数学推导分析,我们发现完全背包的一维空间优化,是具有优化复杂度的意义。
因此,我们可以对礼包维度进行优化,使用 $f[need[0], need[1], ... , need[n - 1]]$ 来作为状态表示。
不失一般性的考虑 $f[j_0, j_1, ... , j_{n - 1}]$ 该如何转移(以物品 $0$ 为例进行分析,其他同理):
1. 不选择任何大礼包,只进行单买:$f[j_0, j_1, ... , j_{n - 1}] = min(f[j_0, j_1, ... , j_{n - 1}], f[j_0 - 1, j_1, ..., j_{n - 1}] + price[0]$;
2. 购买大礼包:$f[j_0, j_1, ... , j_{n - 1}] = min(f[j_0, j_1, ... , j_{n - 1}], f[j_0 - special[i][0], j_1 - special[i][1],, ..., j_{n - 1} - special[i][n - 1]] + special[i][n]$
最终的 $f[j_0, j_1, ... , j_{n - 1}]$ 为上述所有方案中的最小值。
>一些细节:实现时,为了防止过多的维度,以及可能存在的 MLE 风险,我们可以对维度进行压缩处理,而最简单的方式可以通过与排列数建立映射关系。
代码:
```Java
class Solution {
public int shoppingOffers(List<Integer> price, List<List<Integer>> special, List<Integer> needs) {
int n = price.size();
int[] g = new int[n + 1];
g[0] = 1;
for (int i = 1; i <= n; i++) {
g[i] = g[i - 1] * (needs.get(i - 1) + 1);
}
int mask = g[n];
int[] f = new int[mask];
int[] cnt = new int[n];
for (int state = 1; state < mask; state++) {
f[state] = 0x3f3f3f3f;
Arrays.fill(cnt, 0);
for (int i = 0; i < n; i++) {
cnt[i] = state % g[i + 1] / g[i];
}
for (int i = 0; i < n; i++) {
if (cnt[i] > 0) f[state] = Math.min(f[state], f[state - g[i]] + price.get(i));
}
out:for (List<Integer> x : special) {
int cur = state;
for (int i = 0; i < n; i++) {
if (cnt[i] < x.get(i)) continue out;
cur -= x.get(i) * g[i];
}
f[state] = Math.min(f[state], f[cur] + x.get(n));
}
}
return f[mask - 1];
}
}
```
* 时间复杂度:令物品数量为 $n$,原礼包数量为 $m$。每个物品最多需要 $k = \max(needs[i]) = 10$ 个,共有 $k^n$ 个状态需要转移,转移时需要考虑「单买」和「礼包」决策,复杂度分别为 $O(n)$ 和 $O(m * n)$。整体复杂度为 $O(k^n * (m * n))$
* 空间复杂度:$O(k^n * (m * n))$ | ### 最后
这是我们「刷穿 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')。例如,编码字符串 `"1*"` 可以表示 "11"、"12"、"13"、"14"、"15"、"16"、"17"、"18" 或 "19" 中的任意一条消息。对 "1*" 进行解码,相当于解码该字符串可以表示的任何编码消息。
给你一个字符串 s ,由数字和 '*' 字符组成,返回 解码 该字符串的方法 数目 。
由于答案数目可能非常大,返回对 $10^9 + 7$ 取余 的结果。
示例 1:
```
输入:s = "*"
输出:9
解释:这一条编码消息可以表示 "1"、"2"、"3"、"4"、"5"、"6"、"7"、"8" 或 "9" 中的任意一条。
可以分别解码成字符串 "A"、"B"、"C"、"D"、"E"、"F"、"G"、"H" 和 "I" 。
因此,"*" 总共有 9 种解码方法。
```
示例 2:
```
输入:s = "1*"
输出:18
解释:这一条编码消息可以表示 "11"、"12"、"13"、"14"、"15"、"16"、"17"、"18" 或 "19" 中的任意一条。
每种消息都可以由 2 种方法解码(例如,"11" 可以解码成 "AA" 或 "K")。
因此,"1*" 共有 9 * 2 = 18 种解码方法。
```
示例 3:
```
输入:s = "2*"
输出:15
解释:这一条编码消息可以表示 "21"、"22"、"23"、"24"、"25"、"26"、"27"、"28" 或 "29" 中的任意一条。
"21"、"22"、"23"、"24"、"25" 和 "26" 由 2 种解码方法,但 "27"、"28" 和 "29" 仅有 1 种解码方法。
因此,"2*" 共有 (6 * 2) + (3 * 1) = 12 + 3 = 15 种解码方法。
```
提示:
* $1$ <= s.length <= $10^5$
* s[i] 是 `0-9` 中的一位数字或字符 '*' | ### 分情况讨论 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' ? 1 : 0)`.
不失一般性考虑 $f[i]$ 该如何转移,$s[i]$ 要么是 `*`,要么是数字,对应一个分情况讨论过程:
* 当 $s[i]$ 为 `*`:此时考虑 $s[i]$ 是单独作为一个 `item`,还是与上一个字符共同作为一个 `item`:
* $s[i]$ 单独作为一个 `item`:由于 `*` 可以代指数字 `1-9`,因此有 $f[i] = f[i - 1] * 9$;
* $s[i]$ 与上一个字符共同作为一个 `item`:此时需要对上一个字符 $s[j]$ 进行讨论:
* $s[j]$ 为数字 `1`:此时 $s[i]$ 可以代指 `1-9`,对应了 `item` 为 `11-19` 这 $9$ 种情况,此时有 $f[i] = f[i - 2] * 9$(**如果 $f[i - 2]$ 取不到,则使用 $1$ 代指,下面同理**);
* $s[j]$ 为数字 `2`:此时 $s[i]$ 可以代指 `1-6`,对应了 `item` 为 `21-26` 这 $6$ 种情况,此时有 $f[i] = f[i - 2] * 6$;
* $s[j]$ 为字符 `*`:此时两个 `*` 对应了合法方案为 $11-19$ 和 $21-26$ 共 $15$ 种方案,此时有 $f[i] = f[i - 2] * 15$;
* 当 $s[i]$ 为数字:此时可以从「前一字符 $s[j]$ 为何种字符」和「当前 $s[i]$ 是否为 $0$」出发进行讨论:
* $s[j]$ 为字符 `*`,根据当前 $s[i]$ 是否为 $0$ 讨论:
* $s[i]$ 为数字 $0$:此时 $s[i]$ 无法独自作为一个 `item`,只能与 $s[j]$ 组合,对应了 $10$ 和 $20$ 两种情况,此时有 $f[i] = f[i - 2] * 2$;
* $s[i]$ 为数字 `1-9`,此时首先有 $s[i]$ 可以作为一个独立 `item` 的情况,即有 $f[i] = f[i - 1]$,然后对 $s[i]$ 的数值大小进一步分情况讨论:
* $s[i]$ 为数字 `1-6`,此时 $s[j]$ 可以代指 $1$ 和 $2$,对应了方案 $1x$ 和 $2x$,此时有 $f[i] = f[i - 2] * 2$;
* $s[i]$ 为数字 `7-9`,此时 $s[j]$ 可以代指 $1$,对应方案 $1x$,此时有 $f[i] = f[i - 2]$;
* $s[j]$ 为数字类型,此时从「当前 $s[i]$ 是否为 $0$」出发进行讨论:
* $s[i]$ 为数字 $0$:此时 $s[j]$ 只有为 $1$ 和 $2$ 时,才是合法方案,则有 $f[i] = f[i - 2]$;
* $s[i]$ 为数字 `1-9`:此时首先有 $s[i]$ 可以作为一个独立 `item` 的情况,即有 $f[i] = f[i - 1]$,然后再考虑能够与 $s[j]$ 组成合法 `item` 的情况:
* $s[j]$ 为数值 $1$:此时有 $f[i] = f[i - 2]$;
* $s[j]$ 为数值 $2$,且 $s[i]$ 为数值 `1-6`:此时有 $f[i] = f[i - 2]$。
由于是求方案数,因此最终的 $f[i]$ 为上述所有的合法的分情况讨论的累加值,并对 $1e9+ 7$ 取模。
> 一些细节:实现上了避免大量对 $f[i - 2]$ 是否可以取得的讨论,我们可以对 `s` 前追加一个空格作为哨兵(无须真正插入),以简化代码,同时由于 $f[i]$ 只依赖于 $f[i - 1]$ 和 $f[i - 1]$,可以使用「滚动数组」的形式进行空间空间优化(见 $P2$)。
> 另外,对于「滚动数组」的空间优化方式,还需要说明两点:转移前先使用变量保存 `(i-1)%3` 和 `(i-2)%3` 的计算结果,防止大量的重复计算;不能再偷懒使用 `toCharArray`,只能使用 `charAt`,因为 Java 为了遵循字符串不变的原则,会在调用 `toCharArray` 时返回新数组,这样复杂度就还是 $O(n)$ 的。
诸如此类的「滚动数组」优化方式,最早在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485638&idx=1&sn=d7468955c5b121664031fd5c1b5a6f10&chksm=fd9ca3d9caeb2acf2dd4e9f512b2d4dc820107489a094749ffe7cae646f0cc60de06f2d18898&scene=178&cur_album_id=1751702161341628417#rd) 讲过。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numDecodings(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
long[] f = new long[n];
f[0] = cs[0] == '*' ? 9 : (cs[0] != '0' ? 1 : 0);
for (int i = 1; i < n; i++) {
char c = cs[i], prev = cs[i - 1];
if (c == '*') {
// cs[i] 单独作为一个 item
f[i] += f[i - 1] * 9;
// cs[i] 与前一个字符共同作为一个 item
if (prev == '*') {
// 11 - 19 & 21 - 26
f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 15;
} else {
int u = (int)(prev - '0');
if (u == 1) {
f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 9;
} else if (u == 2) {
f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 6;
}
}
} else {
int t = (int)(c - '0');
if (prev == '*') {
if (t == 0) {
f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 2;
} else {
// cs[i] 单独作为一个 item
f[i] += f[i - 1];
// cs[i] 与前一个字符共同作为一个 item
if (t <= 6) {
f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 2;
} else {
f[i] += i - 2 >= 0 ? f[i - 2] : 1;
}
}
} else {
int u = (int)(prev - '0');
if (t == 0) {
if (u == 1 || u == 2) {
f[i] += i - 2 >= 0 ? f[i - 2] : 1;
}
} else {
// cs[i] 单独作为一个 item
f[i] += (f[i - 1]);
// cs[i] 与前一个字符共同作为一个 item
if (u == 1) {
f[i] += i - 2 >= 0 ? f[i - 2] : 1;
} else if (u == 2 && t <= 6) {
f[i] += i - 2 >= 0 ? f[i - 2] : 1;
}
}
}
}
f[i] %= mod;
}
return (int)(f[n - 1]);
}
}
```
```Java
class Solution {
int mod = (int)1e9+7;
public int numDecodings(String s) {
int n = s.length() + 1;
long[] f = new long[3];
f[0] = 1;
f[1] = s.charAt(0) == '*' ? 9 : (s.charAt(0) != '0' ? 1 : 0);
for (int i = 2; i < n; i++) {
char c = s.charAt(i - 1), prev = s.charAt(i - 2);
int p1 = (i - 1) % 3, p2 = (i - 2) % 3;
long cnt = 0;
if (c == '*') {
// cs[i] 单独作为一个 item
cnt += f[p1] * 9;
// cs[i] 与前一个字符共同作为一个 item
if (prev == '*') {
cnt += f[p2] * 15;
} else {
int u = (int)(prev - '0');
if (u == 1) cnt += f[p2] * 9;
else if (u == 2) cnt += f[p2] * 6;
}
} else {
int t = (int)(c - '0');
if (prev == '*') {
if (t == 0) {
cnt += f[p2]* 2;
} else {
// cs[i] 单独作为一个 item
cnt += f[p1];
// cs[i] 与前一个字符共同作为一个 item
if (t <= 6) cnt += f[p2] * 2;
else cnt += f[p2];
}
} else {
int u = (int)(prev - '0');
if (t == 0) {
if (u == 1 || u == 2) cnt += f[p2];
} else {
// cs[i] 单独作为一个 item
cnt += f[p1];
// cs[i] 与前一个字符共同作为一个 item
if (u == 1) cnt += f[p2];
else if (u == 2 && t <= 6) cnt += f[p2];
}
}
}
f[i % 3] = cnt % mod;
}
return (int)(f[(n - 1) % 3]);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用「滚动数组」进行优化,复杂度为 $O(1)$,否则为 $O(n)$
---
### 枚举 DP
上述解法之所以复杂,是因为不仅仅要对当前字符 $s[i]$ 分情况讨论,还需要对上一个字符 $s[j]$ 分情况讨论。
事实上,我们可以利用解码对象只有 `A-Z` 来进行枚举。
在从前往后处理字符串 `s` 时,枚举 $s[i]$ 参与构成的解码内容 `item` 是字母 `A-Z` 中哪一个,从而将分情况讨论转变成对应位的字符对比。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int numDecodings(String s) {
int n = s.length();
long[] f = new long[3];
f[0] = 1;
for (int i = 1; i <= n; i++) {
char c = s.charAt(i - 1);
int t = c - '0';
long cnt = 0;
int p1 = (i - 1) % 3, p2 = (i - 2) % 3;
// 枚举组成什么 item(A -> 1; B -> 2 ...)
for (int item = 1; item <= 26; item++) {
if (item < 10) { // 该 item 由一个字符组成
if (c == '*' || t == item) cnt += f[p1];
} else { // 该 item 由两个字符组成
if (i - 2 < 0) break;
char prev = s.charAt(i - 2);
int u = prev - '0';
int a = item / 10, b = item % 10;
if ((prev == '*' || u == a) && (t == b || (c == '*' && b != 0))) cnt += f[p2];
}
}
f[i % 3] = cnt % mod;
}
return (int)(f[n % 3]);
}
}
```
* 时间复杂度:$O(n * C)$,其中 $C$ 为解码内容字符集大小,固定为 $26$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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 = "2x=x"
输出: "x=0"
```
提示:
* $3 <= equation.length <= 1000$
* `equation` 只有一个 `'='`.
* `equation` 方程由整数组成,其绝对值在 $[0, 100]$ 范围内,不含前导零和变量 `'x'` 。 | ### 模拟
为了方便,我们令 `equation` 为 `s`。
由于运算符只有 `+` 和 `-`,因此无须考虑运算优先级,可在遍历过程中进行计算。
使用变量 `x` 和 `num` 分别代指当前运算结果中 $x$ 的系数以及数值部分,从前往后处理 `s` 的每个字符,根据字符类型进行分情况讨论,假设当前处理到的数值为 $s[i]$:
* 若 $s[i] =$ `+/-`:此时影响的是下一个运算数值的正负,修改对应的 `op` 标识;
* 若 $s[i] =$ `数值`:此时将完整的运算值进行取出(运算值可能是关于 $x$ 的描述,可能是纯数值),假设连续段 $s[i:j - 1]$ 之间为当前运算值,根据 $s[j - 1]$ 是否为字符 `x` 可知,是要将 $s[i:j - 2]$ 的数值累加到变量 `x`,还是将 $s[i:j - 1]$ 的数值累加到变量 `num`;
* 若 $s[i] =$ `=`:此时代表方程的左边已处理完,将变量 `x` 和 `num` 进行翻转(含义为将左边的运算结果移项到右边),并继续往后处理。
当整个字符串 `s` 处理完后,我们得到最终关于 $x$ 的系数 `x`,以及数值大小 `num`。
根据 `x` 是否为 $0$ 可知答案:
* 若 `x` 为 $0$:此时根据 `num` 是否为 $0$ 可知是 `Infinite solutions`(对应 `num` 为 $0$) 还是 `No solution`(对应 `num` 不为 $0$)
* 若 `x` 不为 $0$:对 `x` 和 `num` 进行约分后,返回对应答案。
Java 代码:
```Java
class Solution {
public String solveEquation(String s) {
int x = 0, num = 0, n = s.length();
char[] cs = s.toCharArray();
for (int i = 0, op = 1; i < n; ) {
if (cs[i] == '+') {
op = 1; i++;
} else if (cs[i] == '-') {
op = -1; i++;
} else if (cs[i] == '=') {
x *= -1; num *= -1; op = 1; i++;
} else {
int j = i;
while (j < n && cs[j] != '+' && cs[j] != '-' && cs[j] != '=') j++;
if (cs[j - 1] == 'x') x += (i < j - 1 ? Integer.parseInt(s.substring(i, j - 1)) : 1) * op;
else num += Integer.parseInt(s.substring(i, j)) * op;
i = j;
}
}
if (x == 0) return num == 0 ? "Infinite solutions" : "No solution";
else return "x=" + (num / -x);
}
}
```
TypeScript 代码:
```TypeScript
function solveEquation(s: string): string {
let x = 0, num = 0, n = s.length
for (let i = 0, op = 1; i < n; ) {
if (s[i] == '+') {
op = 1; i++;
} else if (s[i] == '-') {
op = -1; i++
} else if (s[i] == '=') {
x *= -1; num *= -1; op = 1; i++;
} else {
let j = i
while (j < n && s[j] != '+' && s[j] != '-' && s[j] != '=') j++
if (s[j - 1] == 'x') x += (i < j - 1 ? Number(s.substring(i, j - 1)) : 1) * op
else num += Number(s.substring(i, j)) * op
i = j
}
}
if (x == 0) return num == 0 ? "Infinite solutions" : "No solution"
else return "x=" + (num / -x)
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用 `charAt` 替换 `toCharArray`。复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 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 deleteLast()` :从双端队列尾部删除一个元素。如果操作成功返回 `true` ,否则返回 `false` 。
* `int getFront()` :从双端队列头部获得一个元素。如果双端队列为空,返回 `-1` 。
* `int getRear()` :获得双端队列的最后一个元素。 如果双端队列为空,返回 `-1` 。
* `boolean isEmpty()` :若双端队列为空,则返回 `true` ,否则返回 `false` 。
* `boolean isFull()` :若双端队列满了,则返回 `true` ,否则返回 `false` 。
示例 1:
```
输入
["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出
[null, true, true, true, false, 2, true, true, true, 4]
解释
MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3
circularDeque.insertLast(1); // 返回 true
circularDeque.insertLast(2); // 返回 true
circularDeque.insertFront(3); // 返回 true
circularDeque.insertFront(4); // 已经满了,返回 false
circularDeque.getRear(); // 返回 2
circularDeque.isFull(); // 返回 true
circularDeque.deleteLast(); // 返回 true
circularDeque.insertFront(4); // 返回 true
circularDeque.getFront(); // 返回 4
```
提示:
* $1 <= k <= 1000$
* $0 <= value <= 1000$
* `insertFront`, `insertLast`, `deleteFront`, `deleteLast`, `getFront`, `getRear`, `isEmpty`, `isFull` 调用次数不大于 `2000` 次 | ### 基本分析
一个基本的实现,需要满足除构造函数以外复杂度为 $O(k)$ 以外,其余操作均为 $O(1)$。
常规实现包含两种方式:**数组实现** 与 **链表实现**。
其中数组实现可以利用调用次数较小,开成调用次数 $3$ 倍大小,然后从中间开始往两边存储,这样做就不用考虑下标边的界问题;而更为常规的解法是构造一个与限定空间 $k$ 等大的数组,使用两下标并配合坐标转换来做,对于下标自增操作而言,只需要进行「加一取模」即可,而对于下标自减操作,由于考虑负值问题,需要进行「增加限定空间偏移后,进行减一再取模」。
而链表实现则无须考虑额外的下标转换问题,但需要额外定义类。
---
### 数组
使用两坐标 `he` 和 `ta` 分别代表队列头和尾(初始值均为 $0$),使用 `cnt` 记录当前队列元素大小,使用 `k` 记录初始化时指定的空间大小。
对各类操作进行逻辑控制:
* `insertFront` 操作:需要对 `he` 进行自减操作,即 `he = (he + k - 1) % k` 为目标位置,同时对 `cnt` 进行自增;
* `insertLast` 操作:需要对 `ta` 进行自增操作,但 `ta` 起始指向是待插入位置,因此 `ta` 为目标位置,随后更新 `ta = (ta + 1) % k`,同时对 `cnt` 进行自增;
* `deleteFront` 操作:需要对 `he` 进行自增操作,直接更新 `he = (he + 1) % k`,同时更新 `cnt` 进行自减;
* `deleteLast` 操作:需要对 `ta` 进行自减操作,更新 `ta = (ta + k - 1) % k`,同时更新 `cnt` 进行自减;
* `getFront` 操作:返回 `nums[he]` 即可, 若 `isFull` 为 `True`,返回 `-1`;
* `getRear` 操作:返回 `nums[ta - 1]`,由于存在负值问题,需要转换为返回 `nums[(ta + k - 1) % k]` 若 `isFull` 为 `True`,返回 `-1`;
* `isEmpty` 操作:根据 `cnt` 与 `k` 的关系进行返回;
* `isFull` 操作:根据 `cnt` 与 `k` 的关系进行返回;
Java 代码:
```Java
class MyCircularDeque {
int[] nums;
int he, ta, cnt, k;
public MyCircularDeque(int _k) {
k = _k;
nums = new int[k];
}
public boolean insertFront(int value) {
if (isFull()) return false;
he = (he + k - 1) % k;
nums[he] = value; cnt++;
return true;
}
public boolean insertLast(int value) {
if (isFull()) return false;
nums[ta++] = value; cnt++;
ta %= k;
return true;
}
public boolean deleteFront() {
if (isEmpty()) return false;
he = (he + 1) % k; cnt--;
return true;
}
public boolean deleteLast() {
if (isEmpty()) return false;
ta = (ta + k - 1) % k; cnt--;
return true;
}
public int getFront() {
return isEmpty() ? -1 : nums[he];
}
public int getRear() {
return isEmpty() ? -1 : nums[(ta + k - 1) % k];
}
public boolean isEmpty() {
return cnt == 0;
}
public boolean isFull() {
return cnt == k;
}
}
```
TypeScript 代码:
```TypeScript
class MyCircularDeque {
he = 0; ta = 0; cnt = 0; k = 0;
nums: number[];
constructor(_k: number) {
this.k = _k
this.he = this.ta = this.cnt = 0
this.nums = new Array<number>(this.k)
}
insertFront(value: number): boolean {
if (this.isFull()) return false
this.he = (this.he + this.k - 1) % this.k
this.nums[this.he] = value
this.cnt++
return true
}
insertLast(value: number): boolean {
if (this.isFull()) return false
this.nums[this.ta++] = value
this.ta %= this.k
this.cnt++
return true
}
deleteFront(): boolean {
if (this.isEmpty()) return false
this.he = (this.he + 1) % this.k
this.cnt--
return true
}
deleteLast(): boolean {
if (this.isEmpty()) return false
this.ta = (this.ta + this.k - 1) % this.k
this.cnt--
return true
}
getFront(): number {
return this.isEmpty() ? -1 : this.nums[this.he]
}
getRear(): number {
return this.isEmpty() ? -1 : this.nums[(this.ta + this.k - 1) % this.k]
}
isEmpty(): boolean {
return this.cnt == 0
}
isFull(): boolean {
return this.cnt == this.k
}
}
```
* 时间复杂度:除在初始化函数中构造容器复杂度为 $O(k)$ 以外,其余操作复杂度均为 $O(1)$
* 空间复杂度:$O(n)$
---
### 链表
创建 `Node` 代指每个操作的元素,使用双向链表来构造循环队列。
各类操作均对应基本的链表操作,不再赘述。
Java 代码:
```Java
class MyCircularDeque {
class Node {
Node prev, next;
int val;
Node (int _val) {
val = _val;
}
}
int cnt, k;
Node he, ta;
public MyCircularDeque(int _k) {
k = _k;
he = new Node(-1); ta = new Node(-1);
he.next = ta; ta.prev = he;
}
public boolean insertFront(int value) {
if (isFull()) return false;
Node node = new Node(value);
node.next = he.next;
node.prev = he;
he.next.prev = node;
he.next = node;
cnt++;
return true;
}
public boolean insertLast(int value) {
if (isFull()) return false;
Node node = new Node(value);
node.next = ta;
node.prev = ta.prev;
ta.prev.next = node;
ta.prev = node;
cnt++;
return true;
}
public boolean deleteFront() {
if (isEmpty()) return false;
he.next.next.prev = he;
he.next = he.next.next;
cnt--;
return true;
}
public boolean deleteLast() {
if (isEmpty()) return false;
ta.prev.prev.next = ta;
ta.prev = ta.prev.prev;
cnt--;
return true;
}
public int getFront() {
return isEmpty() ? -1 : he.next.val;
}
public int getRear() {
return isEmpty() ? -1 : ta.prev.val;
}
public boolean isEmpty() {
return cnt == 0;
}
public boolean isFull() {
return cnt == k;
}
}
```
TypeScript 代码:
```TypeScript
class TNode {
prev: TNode = null; next: TNode = null;
val: number = 0;
constructor(_val: number) {
this.val = _val
}
}
class MyCircularDeque {
he = null; ta = null;
cnt = 0; k = 0;
constructor(_k: number) {
this.cnt = 0; this.k = _k;
this.he = new TNode(-1); this.ta = new TNode(-1);
this.he.next = this.ta
this.ta.prev = this.he
}
insertFront(value: number): boolean {
if (this.isFull()) return false
const node = new TNode(value)
node.next = this.he.next
node.prev = this.he
this.he.next.prev = node
this.he.next = node
this.cnt++
return true
}
insertLast(value: number): boolean {
if (this.isFull()) return false
const node = new TNode(value)
node.next = this.ta
node.prev = this.ta.prev
this.ta.prev.next = node
this.ta.prev = node
this.cnt++
return true
}
deleteFront(): boolean {
if (this.isEmpty()) return false
this.he.next.next.prev = this.he
this.he.next = this.he.next.next
this.cnt--
return true
}
deleteLast(): boolean {
if (this.isEmpty()) return false
this.ta.prev.prev.next = this.ta
this.ta.prev = this.ta.prev.prev
this.cnt--
return true
}
getFront(): number {
return this.isEmpty() ? -1 : this.he.next.val
}
getRear(): number {
return this.isEmpty() ? -1 : this.ta.prev.val
}
isEmpty(): boolean {
return this.cnt == 0
}
isFull(): boolean {
return this.cnt == this.k
}
}
```
* 时间复杂度:所有操作复杂度均为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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; i < nums.length; i++) {
sum = sum + nums[i] - nums[i - k]; // int add = nums[i], del = nums[i - k];
ans = Math.max(ans, sum / k);
}
return ans;
}
}
```
* 时间复杂度:每个元素最多滑入和滑出窗口一次。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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];
for (int x : nums) cnts[x]++;
int[] ans = new int[2];
for (int i = 1; i <= n; i++) {
if (cnts[i] == 0) ans[1] = i;
if (cnts[i] == 2) ans[0] = i;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 数学
我们还可以利用数值范围为 $[1, n]$,只有一个数重复和只有一个缺失的特性,进行「作差」求解。
* 令 $[1, n]$ 的求和为 $tot$,这部分可以使用「等差数列求和公式」直接得出:$tot = \frac{n (1 + n)}{2}$ ;
* 令数组 $nums$ 的求和值为 $sum$,由循环累加可得;
* 令数组 $sums$ 去重求和值为 $set$,由循环配合「哈希表/数组」累加可得。
最终答案为 `(重复元素, 缺失元素) = (sum-set, tot-set)` 。
代码;
```Java
class Solution {
public int[] findErrorNums(int[] nums) {
int n = nums.length;
int[] cnts = new int[n + 1];
int tot = (1 + n) * n / 2;
int sum = 0, set = 0;
for (int x : nums) {
sum += x;
if (cnts[x] == 0) set += x;
cnts[x] = 1;
}
return new int[]{sum - set, tot - set};
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 桶排序
因为值的范围在 $[1, n]$,我们可以运用「桶排序」的思路,根据 $nums[i] = i + 1$ 的对应关系使用 $O(n)$ 的复杂度将每个数放在其应该落在的位置里。
然后线性扫描一遍排好序的数组,找到不符合 $nums[i] = i + 1$ 对应关系的位置,从而确定重复元素和缺失元素是哪个值。
代码:
```Java
class Solution {
public int[] findErrorNums(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {
swap(nums, i, nums[i] - 1);
}
}
int a = -1, b = -1;
for (int i = 0; i < n; i++) {
if (nums[i] != i + 1) {
a = nums[i];
b = i == 0 ? 1 : nums[i - 1] + 1;
}
}
return new int[]{a, b};
}
void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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$ 即可。
容易证明该做法的正确性:**假设贪心解(该做法)找到的位置 $j$ 不是最优位置,即存在比 $j$ 更小的合法下标 $j'$ 满足 $f[j'] > f[j]$。根据我们的排序规则必然有 $pairs[j'][0] <= pairs[j][0]$ 的性质,则可知 $pairs[j]$ 必然可以代替 $pairs[j']$ 接在原本以 $pairs[j']$ 为结尾的最优数链上(最优数链长度不变,结果不会变差),则至少有 $f[j'] = f[j]$。**
代码:
```Java
class Solution {
public int findLongestChain(int[][] pairs) {
Arrays.sort(pairs, (a,b)->a[0]-b[0]);
int n = pairs.length, ans = 1;
int[] f = new int[n];
for (int i = 0; i < n; i++) {
f[i] = 1;
for (int j = i - 1; j >= 0 && f[i] == 1; j--) {
if (pairs[j][1] < pairs[i][0]) f[i] = f[j] + 1;
}
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$;不考虑剪枝效果 `DP` 复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$
---
### 排序 + 贪心 DP(优化转移)
根据上述分析,我们知道对于一个特定的 $pairs[i]$ 而言,其所有合法(满足条件 $pairs[j][1] < pairs[i][0]$)的前驱状态 $f[j]$ 必然是非单调递增的。
根据 `LIS` 问题的贪心解的思路,我们可以额外使用一个数组记录下特定长度数链的最小结尾值,从而实现二分找前驱状态。
具体的,创建 $g$ 数组,其中 $g[len] = x$ 代表数链长度为 $len$ 时结尾元素的第二维最小值为 $x$。
如此一来,当我们要找 $f[i]$ 的前驱状态时,等价于在 $g$ 数组中找满足「小于 $pairs[i][0]$」的最大下标。同时,我们不再需要显式维护 $f$ 数组,只需要边转移变更新答案即可。
> **不了解 `LIS` 问题的同学可以看前置 🧀 : [LCS 问题与 LIS 问题的相互关系,以及 LIS 问题的最优解证明](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892) 🎉🎉🎉**
代码:
```Java
class Solution {
public int findLongestChain(int[][] pairs) {
Arrays.sort(pairs, (a,b)->a[0]-b[0]);
int n = pairs.length, ans = 1;
int[] g = new int[n + 10];
Arrays.fill(g, 0x3f3f3f3f);
for (int i = 0; i < n; i++) {
int l = 1, r = i + 1;
while (l < r) {
int mid = l + r >> 1;
if (g[mid] >= pairs[i][0]) r = mid;
else l = mid + 1;
}
g[r] = Math.min(g[r], pairs[i][1]);
ans = Math.max(ans, r);
}
return ans;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$;`DP` 复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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 cattle was rattled by the battery"
输出:"the cat was rat by the bat"
```
示例 2:
```
输入:dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs"
输出:"a a b c"
```
提示:
* $1 <= dictionary.length <= 1000$
* $1 <= dictionary[i].length <= 100$
* `dictionary[i]` 仅由小写字母组成。
* $1 <= sentence.length <= 10^6$
* `sentence` 仅由小写字母和空格组成。
* `sentence` 中单词的总量在范围 $[1, 1000]$ 内。
* `sentence` 中每个单词的长度在范围 $[1, 1000]$ 内。
* `sentence` 中单词之间由一个空格隔开。
* `sentence` 没有前导或尾随空格。 | ### 基本分析
这是一道 `Trie` 的模板题,还不了解 `Trie` 的同学可以先看前置 🧀:[【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)
前置 🧀 通过图解形式讲解了 `Trie` 的结构与原理,以及提供了两种实现 `Trie` 的方式。
回到本题,为了方便,我们令 `ds` 为 `dictionary`,令 `s` 为 `sentence`。
---
### 二维数组
一个比较习惯的做法,是使用「二维数组」来实现 `Trie`,配合 `static` 优化,可以有效控制 `new` 的次数,耗时相对稳定。
考虑两个 `Trie` 的基本操作:
* `add` 操作:变量入参字符串 `s`,将字符串中的每位字符映射到 $[0, 25]$,同时为了能够方便查询某个字符串(而不只是某个前缀)是否曾经存入过 `Trie` 中,额外使用一个布尔数组 `isEnd` 记录某个位置是否为单词结尾。
* `query` 操作:对变量入参字符串 `s` 进行遍历,如果在字典树不存在该字符串的任何前缀,直接返回 `s`,否则返回首个出现(最短)的前缀。
至于二维数组的大小估算,可以直接开成 $N \times C$,其中 $N$ 为要插入到 `Trie` 中的字符总数,$C$ 为对应的字符集大小。在 $N \times C$ 没有 `MLE` 风险时,可以直接开这么多;而当 $N \times C$ 较大(超过 $1e7$,甚至 $1e8$ 时),可以适当将 $N \times C$ 中的 $N$ 减少,使得总空间在 $1e7$ 左右,因为实际上由于二维数组中的某些行中会存储一个字符以上,实际上我们用不到这么多行。
代码(不使用 `static` 优化,耗时增加十倍):
```Java
class Solution {
static int N = 100000, M = 26;
static int[][] tr = new int[N][M];
static boolean[] isEnd = new boolean[N * M];
static int idx;
void add(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isEnd[p] = true;
}
String query(String s) {
for (int i = 0, p = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) break;
if (isEnd[tr[p][u]]) return s.substring(0, i + 1);
p = tr[p][u];
}
return s;
}
public String replaceWords(List<String> ds, String s) {
for (int i = 0; i <= idx; i++) {
Arrays.fill(tr[i], 0);
isEnd[i] = false;
}
for (String d : ds) add(d);
StringBuilder sb = new StringBuilder();
for (String str : s.split(" ")) sb.append(query(str)).append(" ");
return sb.substring(0, sb.length() - 1);
}
}
```
* 时间复杂度:令 $n = \sum_{i = 0}^{ds.length - 1} ds[i].length$,$m$ 为 `s` 长度,复杂度为 $O(n + m)$
* 空间复杂度:$O(n \times C)$,其中 $C = 26$ 为字符集大小
---
### TrieNode
另外一个能够有效避免「估数组大小」操作的方式,是使用 `TrieNode` 的方式实现 `Trie`:每次使用到新的格子再触发 `new` 操作。
至于为什么有了 `TrieNode` 的方式,我还是会采用「二维数组」优先的做法,在 [知乎](https://zhuanlan.zhihu.com/p/531180364) 上有同学问过我类似的问题,只不过原问题是「为什么有了动态开点线段树,直接 `build` 出 $4n$ 空间的做法仍有意义」,这对应到本题使用「二维数组」还是「TrieNode」是一样的道理:
除非某些语言在启动时,采用虚拟机的方式,并且预先分配了足够的内存,否则所有的 `new` 操作都需要反映到 os 上,而在 `linux` 分配时需要遍历红黑树,因此即使是总空间一样,一次性的 `new` 要比多次小空间的 `new` 更省时间,同时集中性的 `new` 也比分散性的 `new` 操作要更快,这也就是为什么我们不无脑使用 `TrieNode` 的原因。
代码:
```Java
class Solution {
class Node {
boolean isEnd;
Node[] tns = new Node[26];
}
Node root = new Node();
void add(String s) {
Node p = root;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (p.tns[u] == null) p.tns[u] = new Node();
p = p.tns[u];
}
p.isEnd = true;
}
String query(String s) {
Node p = root;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (p.tns[u] == null) break;
if (p.tns[u].isEnd) return s.substring(0, i + 1);
p = p.tns[u];
}
return s;
}
public String replaceWords(List<String> ds, String s) {
for (String str : ds) add(str);
StringBuilder sb = new StringBuilder();
for (String str : s.split(" ")) sb.append(query(str)).append(" ");
return sb.substring(0, sb.length() - 1);
}
}
```
* 时间复杂度:令 $n = \sum_{i = 0}^{ds.length - 1} ds[i].length$,$m$ 为 `s` 长度,复杂度为 $O(n + m)$
* 空间复杂度:$O(n \times C)$,其中 $C = 26$ 为字符集大小
---
### 加餐
**今天额外增加一道更贴合笔试面试的加餐题 : [结合 DFS 的 Trie 运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492188&idx=1&sn=a1436d1ffe2b8200a36c3196ca1c7ed1) 🎉🎉** | ### 最后
这是我们「刷穿 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`(夜魇)。
然后,如果有 `n` 个参议员,给定字符串的大小将是 `n`。
以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束,这一过程将持续到投票结束,所有失去权利的参议员将在过程中被跳过。
假设每一位参议员都足够聪明,会为自己的政党做出最好的策略,你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。
输出应该是 `"Radiant"` 或 `"Dire"`。
示例 1:
```
输入:s = "RD"
输出:"Radiant"
解释:
第 1 轮时,第一个参议员来自 Radiant 阵营,他可以使用第一项权利让第二个参议员失去所有权利。
这一轮中,第二个参议员将会被跳过,因为他的权利被禁止了。
第 2 轮时,第一个参议员可以宣布胜利,因为他是唯一一个有投票权的人。
```
示例 2:
```
输入:s = "RDD"
输出:"Dire"
解释:
第 1 轮时,第一个来自 Radiant 阵营的参议员可以使用第一项权利禁止第二个参议员的权利。
这一轮中,第二个来自 Dire 阵营的参议员会将被跳过,因为他的权利被禁止了。
这一轮中,第三个来自 Dire 阵营的参议员可以使用他的第一项权利禁止第一个参议员的权利。
因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利
```
提示:
* $n = s.length$
* $1 <= n <= 10^4$
* `senate[i]` 为 `'R'` 或 `'D'` | ### 基本分析
整理题意:每次选择对方的一个成员进行消除,直到所有剩余成员均为我方时,宣布胜利。
由于每个对方成员执行权利都意味着我方损失一名成员,因此最佳方式是 **尽量让对方的权利不执行,或延迟执行(意味着我方有更多执行权利的机会)**。因此,最优决策为 **每次都选择对方的下一个行权成员进行消除**。
---
### 贪心
这个找“最近一个”对方行权成员的操作既可以使用「有序集合」来做,也可以使用「循环队列」来做。
先说使用「有序集合」的做法。
起始我们先将 `s` 中的 `Radiant` 和 `Dire` 分别存入有序集合 `rs` 和 `ds` 当中,然后从前往后模拟消除过程,过程中使用 `idx` 代表当前处理到的成员下标,使用 `set` 记录当前哪些成员已被消除。
当轮到 `s[idx]` 行权时(若 `s[idx]` 已被消除,则跳过本轮),从对方的有序队列中取出 **首个大于等于 `idx` 的下标**(取出代表移除);若对方的有序序列不存在该下标,而行权过程又是循环进行的,说明此时下一个行权的对方成员是 **首个大于等于 $0$** 的下标,我们对其进行取出消除,随后往后继续决策。
Java 代码:
```Java
class Solution {
public String predictPartyVictory(String s) {
TreeSet<Integer> rs = new TreeSet<>(), ds = new TreeSet<>();
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == 'R') rs.add(i);
else ds.add(i);
}
Set<Integer> set = new HashSet<>();
int idx = 0;
while (rs.size() != 0 && ds.size() != 0) {
if (!set.contains(idx)) {
TreeSet<Integer> temp = null;
if (s.charAt(idx) == 'R') temp = ds;
else temp = rs;
Integer t = temp.ceiling(idx);
if (t == null) t = temp.ceiling(0);
set.add(t);
temp.remove(t);
}
idx = (idx + 1) % n;
}
return rs.size() != 0 ? "Radiant" : "Dire";
}
}
```
不难发现,虽然将所有成员存入有序集合和取出的复杂度均为 $O(n\log{n})$,但整体复杂度仍是大于 $O(n\log{n})$。
因为我们在每一轮的消除中,从 `idx` 位置找到下一个决策者,总是需要遍历那些已被消除的位置,而该无效遍历操作可使用「循环队列」优化。
---
### 优化
使用循环队列 `rd` 和 `dd` 来取代有序集合 `rs` 和 `ds`。起始将各个成员分类依次入队,每次从两队列队头中取出成员,假设从 `rs` 中取出成员下标为 `a`,从 `dd` 中取出成员下标为 `b`,对两者进行比较:
* 若有 `a < b`,说明 `a` 先行权,且其消除对象为 `b`,`a` 行权后需等到下一轮,对其进行大小为 $n$ 的偏移后重新添加到 `rd` 尾部(含义为本次行权后需要等到下一轮);
* 若有 `b < a`,同理,将 `a` 消除后,对 `b` 进行大小为 $n$ 的偏移后重新添加到 `dd` 尾部。
Java 代码:
```Java
class Solution {
public String predictPartyVictory(String s) {
Deque<Integer> rd = new ArrayDeque<>(), dd = new ArrayDeque<>();
int n = s.length();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == 'R') rd.addLast(i);
else dd.addLast(i);
}
while (rd.size() != 0 && dd.size() != 0) {
int a = rd.pollFirst(), b = dd.pollFirst();
if (a < b) rd.addLast(a + n);
else dd.addLast(b + n);
}
return rd.size() != 0 ? "Radiant" : "Dire";
}
}
```
C++ 代码:
```C++
class Solution {
public:
string predictPartyVictory(string s) {
deque<int> rd, dd;
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] == 'R') rd.push_back(i);
else dd.push_back(i);
}
while (!rd.empty() && !dd.empty()) {
int a = rd.front(), b = dd.front();
rd.pop_front();
dd.pop_front();
if (a < b) rd.push_back(a + n);
else dd.push_back(b + n);
}
return !rd.empty() ? "Radiant" : "Dire";
}
};
```
Python 代码:
```Python
from collections import deque
class Solution:
def predictPartyVictory(self, s: str) -> str:
rd, dd = deque(), deque()
n = len(s)
for i in range(n):
if s[i] == 'R':
rd.append(i)
else:
dd.append(i)
while rd and dd:
a, b = rd.popleft(), dd.popleft()
if a < b:
rd.append(a + n)
else:
dd.append(b + n)
return "Radiant" if rd else "Dire"
```
TypeScript 代码:
```TypeScript
function predictPartyVictory(s: string): string {
let rd: Array<number> = [], dd: Array<number> = [];
let n: number = s.length;
for (let i = 0; i < n; i++) {
if (s.charAt(i) == 'R') rd.push(i);
else dd.push(i);
}
while (rd.length != 0 && dd.length != 0) {
let a: number = rd.shift()!, b: number = dd.shift()!;
if (a < b) rd.push(a + n);
else dd.push(b + n);
}
return rd.length != 0 ? "Radiant" : "Dire";
};
```
* 时间复杂度:将所有成员进行分队,复杂度为 $O(n)$;每个回合会有一名成员被消除,最多有 $n$ 个成员,复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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'。
```
示例 2:
```
输入:n = 1
输出:0
```
提示:
* $1 <= n <= 1000$ | ### 动态规划
**定义 $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] = \min(f[i][x] + 1), 0 \leq x < i$。
我们发现最后一个合法的 $f[i][j]$(满足 $i = j$)依赖与前面 $f[i][j]$(满足 $j < i$)。
因此实现上,我们可以使用一个变量 $min$ 保存前面转移的最小值,用来更新最后的 $f[i][j]$。
再进一步,我们发现如果 $f[i][j]$ 的最后一次操作是由 `Paste` 而来,原来粘贴板的字符数不会超过 $i / 2$,因此在转移 $f[i][j]$(满足 $j < i$)时,其实只需要枚举 $[0, i/2]$ 即可。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
public int minSteps(int n) {
int[][] f = new int[n + 1][n + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
f[i][j] = INF;
}
}
f[1][0] = 0; f[1][1] = 1;
for (int i = 2; i <= n; i++) {
int min = INF;
for (int j = 0; j <= i / 2; j++) {
f[i][j] = f[i - j][j] + 1;
min = Math.min(min, f[i][j]);
}
f[i][i] = min + 1;
}
int ans = INF;
for (int i = 0; i <= n; i++) ans = Math.min(ans, f[n][i]);
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 数学
如果我们将「$1$ 次 `Copy All` + $x$ 次 `Paste`」看做一次“动作”的话。
那么 **一次“动作”所产生的效果就是将原来的字符串变为原来的 $x + 1$ 倍**。
最终的最小操作次数方案可以等价以下操作流程:
1. 起始对长度为 $1$ 的记事本字符进行 $1$ 次 `Copy All` + $k_1 - 1$ 次 `Paste` 操作(消耗次数为 $k_1$,得到长度为 $k_1$ 的记事本长度);
2. 对长度为为 $k_1$ 的记事本字符进行 $1$ 次 `Copy All` + $k_2 - 1$ 次 `Paste` 操作(消耗次数为 $k_1 + k_2$,得到长度为 $k_1 * k_2$ 的记事本长度)
...
最终经过 $k$ 次“动作”之后,得到长度为 $n$ 的记事本长度,即有:
$$
n = k_1 * k_2 * ... * k_x
$$
问题转化为:如何对 $n$ 进行拆分,可以使得 $k_1 + k_2 + ... + k_x$ 最小。
对于任意一个 $k_i$(合数)而言,根据定理 $a * b >= a + b$ 可知进一步的拆分必然不会导致结果变差。
因此,我们只需要使用「试除法」对 $n$ 执行分解质因数操作,累加所有的操作次数,即可得到答案。
代码:
```Java
class Solution {
public int minSteps(int n) {
int ans = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ans += i;
n /= i;
}
}
if (n != 1) ans += n;
return ans;
}
}
```
* 时间复杂度:$O(\sqrt{n})$
* 空间复杂度:$O(1)$
---
### 打表
我们发现,对于某个 $minSteps(i)$ 而言为定值,且数据范围只有 $1000$,因此考虑使用打表来做。
代码:
```Java
class Solution {
static int N = 1010;
static int[] g = new int[N];
static {
for (int k = 2; k < N; k++) {
int cnt = 0, n = k;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
cnt += i;
n /= i;
}
}
if (n != 1) cnt += n;
g[k] = cnt;
}
// System.out.println(Arrays.toString(g)); // 输出打表结果
}
public int minSteps(int n) {
return g[n];
}
}
```
```Java
class Solution {
static int[] g = new int[]{0, 0, 2, 3, 4, 5, 5, 7, 6, 6, 7, 11, 7, 13, 9, 8, 8, 17, 8, 19, 9, 10, 13, 23, 9, 10, 15, 9, 11, 29, 10, 31, 10, 14, 19, 12, 10, 37, 21, 16, 11, 41, 12, 43, 15, 11, 25, 47, 11, 14, 12, 20, 17, 53, 11, 16, 13, 22, 31, 59, 12, 61, 33, 13, 12, 18, 16, 67, 21, 26, 14, 71, 12, 73, 39, 13, 23, 18, 18, 79, 13, 12, 43, 83, 14, 22, 45, 32, 17, 89, 13, 20, 27, 34, 49, 24, 13, 97, 16, 17, 14, 101, 22, 103, 19, 15, 55, 107, 13, 109, 18, 40, 15, 113, 24, 28, 33, 19, 61, 24, 14, 22, 63, 44, 35, 15, 15, 127, 14, 46, 20, 131, 18, 26, 69, 14, 23, 137, 28, 139, 16, 50, 73, 24, 14, 34, 75, 17, 41, 149, 15, 151, 25, 23, 20, 36, 20, 157, 81, 56, 15, 30, 14, 163, 45, 19, 85, 167, 16, 26, 24, 25, 47, 173, 34, 17, 19, 62, 91, 179, 15, 181, 22, 64, 29, 42, 36, 28, 51, 16, 26, 191, 15, 193, 99, 21, 18, 197, 19, 199, 16, 70, 103, 36, 24, 46, 105, 29, 21, 30, 17, 211, 57, 74, 109, 48, 15, 38, 111, 76, 20, 30, 42, 223, 17, 16, 115, 227, 26, 229, 30, 21, 35, 233, 21, 52, 63, 82, 26, 239, 16, 241, 24, 15, 65, 19, 46, 32, 37, 86, 17, 251, 17, 34, 129, 25, 16, 257, 48, 44, 22, 35, 133, 263, 20, 58, 28, 92, 71, 269, 16, 271, 25, 23, 139, 21, 30, 277, 141, 37, 18, 281, 52, 283, 75, 27, 26, 48, 16, 34, 36, 100, 77, 293, 19, 64, 43, 20, 151, 36, 17, 50, 153, 104, 27, 66, 25, 307, 22, 106, 38, 311, 22, 313, 159, 18, 83, 317, 58, 40, 17, 110, 32, 36, 16, 23, 165, 112, 47, 54, 21, 331, 87, 43, 169, 72, 18, 337, 28, 116, 26, 42, 27, 21, 49, 31, 175, 347, 36, 349, 19, 22, 21, 353, 64, 76, 93, 27, 181, 359, 17, 38, 183, 25, 24, 78, 66, 367, 31, 47, 44, 60, 38, 373, 30, 18, 53, 42, 18, 379, 28, 130, 193, 383, 17, 23, 195, 49, 101, 389, 23, 40, 20, 134, 199, 84, 21, 397, 201, 29, 18, 401, 72, 44, 105, 17, 38, 48, 26, 409, 48, 140, 107, 66, 31, 88, 23, 142, 32, 419, 19, 421, 213, 53, 59, 27, 76, 68, 111, 27, 50, 431, 17, 433, 40, 37, 113, 42, 78, 439, 22, 20, 32, 443, 44, 94, 225, 152, 19, 449, 18, 52, 117, 154, 229, 25, 28, 457, 231, 26, 32, 461, 23, 463, 37, 39, 235, 467, 23, 74, 54, 160, 65, 54, 84, 29, 28, 59, 241, 479, 18, 50, 243, 33, 26, 102, 17, 487, 67, 166, 21, 491, 48, 46, 34, 22, 39, 78, 88, 499, 19, 170, 253, 503, 19, 106, 36, 29, 131, 509, 27, 80, 18, 28, 259, 108, 50, 58, 46, 176, 24, 521, 37, 523, 135, 20, 265, 48, 22, 46, 60, 65, 30, 54, 94, 112, 73, 182, 271, 25, 18, 541, 273, 184, 27, 114, 25, 547, 141, 67, 23, 48, 32, 86, 279, 45, 143, 557, 39, 56, 20, 31, 283, 563, 54, 118, 285, 19, 77, 569, 29, 571, 28, 194, 50, 33, 18, 577, 36, 196, 38, 90, 102, 64, 79, 24, 295, 587, 21, 50, 66, 200, 45, 593, 22, 29, 153, 202, 38, 599, 19, 601, 52, 73, 155, 27, 106, 607, 29, 39, 68, 60, 27, 613, 309, 49, 24, 617, 108, 619, 40, 32, 313, 96, 24, 20, 315, 33, 161, 54, 20, 631, 85, 214, 319, 132, 60, 27, 42, 77, 19, 641, 112, 643, 34, 51, 38, 647, 18, 70, 25, 41, 167, 653, 114, 136, 49, 79, 56, 659, 23, 661, 333, 33, 89, 31, 45, 52, 171, 226, 74, 72, 20, 673, 339, 19, 30, 677, 118, 104, 28, 230, 44, 683, 29, 142, 23, 232, 51, 66, 33, 691, 177, 24, 349, 144, 38, 58, 351, 236, 21, 701, 24, 56, 23, 55, 355, 108, 66, 709, 78, 85, 95, 54, 29, 29, 183, 242, 361, 719, 19, 110, 40, 244, 185, 39, 27, 727, 26, 18, 80, 60, 68, 733, 369, 22, 33, 78, 49, 739, 46, 35, 62, 743, 40, 154, 375, 89, 32, 114, 20, 751, 55, 254, 44, 156, 20, 757, 381, 37, 30, 761, 132, 116, 195, 28, 385, 72, 19, 769, 25, 260, 197, 773, 51, 41, 103, 47, 391, 60, 25, 82, 42, 38, 22, 162, 136, 787, 201, 266, 86, 120, 23, 74, 399, 61, 203, 797, 31, 64, 20, 95, 403, 84, 74, 35, 46, 272, 107, 809, 19, 811, 40, 274, 50, 168, 28, 62, 411, 26, 50, 821, 142, 823, 109, 24, 68, 827, 33, 829, 90, 280, 25, 31, 144, 172, 34, 40, 421, 839, 21, 58, 423, 284, 215, 31, 55, 29, 61, 286, 29, 60, 78, 853, 70, 30, 113, 857, 29, 859, 52, 51, 433, 863, 19, 178, 435, 37, 42, 90, 39, 80, 115, 103, 44, 22, 80, 877, 441, 296, 24, 881, 22, 883, 34, 67, 445, 887, 46, 134, 96, 23, 227, 66, 154, 184, 21, 39, 451, 60, 20, 70, 54, 53, 119, 186, 156, 907, 231, 107, 27, 911, 30, 94, 459, 69, 233, 138, 28, 919, 34, 310, 463, 84, 25, 47, 465, 109, 39, 929, 41, 33, 237, 314, 469, 33, 25, 937, 76, 316, 56, 941, 162, 64, 67, 21, 56, 947, 86, 86, 31, 320, 30, 953, 61, 196, 243, 43, 481, 144, 20, 62, 52, 113, 245, 198, 35, 967, 28, 39, 104, 971, 19, 146, 489, 26, 69, 977, 168, 100, 23, 115, 493, 983, 50, 202, 48, 57, 36, 66, 24, 991, 41, 334, 80, 204, 90, 997, 501, 46, 21, 31, 172, 76, 255, 75, 505, 72, 21, 1009};
public int minSteps(int n) {
return g[n];
}
}
```
* 时间复杂度:将打表逻辑配合 `static` 交给 OJ 执行,复杂度为 $O(C * \sqrt{C})$,$C$ 为常数,固定为 $1010$;将打表逻辑放到本地执行,复杂度为 $O(1)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 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 <= 200$ | ### DFS + 哈希表
设计递归函数 `String dfs(TreeNode root)`,含义为返回以传入参数 `root` 为根节点的子树所对应的指纹标识。
对于标识的设计只需使用 `"_"` 分割不同的节点值,同时对空节点进行保留(定义为空串 `" "`)即可。
使用哈希表记录每个标识(子树)出现次数,当出现次数为 $2$(首次判定为重复出现)时,将该节点加入答案。
Java 代码:
```Java
class Solution {
Map<String, Integer> map = new HashMap<>();
List<TreeNode> ans = new ArrayList<>();
public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
dfs(root);
return ans;
}
String dfs(TreeNode root) {
if (root == null) return " ";
StringBuilder sb = new StringBuilder();
sb.append(root.val).append("_");
sb.append(dfs(root.left)).append(dfs(root.right));
String key = sb.toString();
map.put(key, map.getOrDefault(key, 0) + 1);
if (map.get(key) == 2) ans.add(root);
return key;
}
}
```
Typescript 代码:
```Typescript
let ans: Array<TreeNode>
let map: Map<string, number>
function findDuplicateSubtrees(root: TreeNode | null): Array<TreeNode | null> {
ans = new Array<TreeNode>()
map = new Map<string, number>()
dfs(root)
return ans
};
function dfs(root: TreeNode | null): string {
if (root == null) return " "
let key = root.val + "_"
key += dfs(root.left)
key += dfs(root.right)
if (!map.has(key)) map.set(key, 1)
else map.set(key, map.get(key) + 1)
if (map.get(key) == 2) ans.push(root)
return key
}
```
* 时间复杂度:`DFS` 过程复杂度为 $O(n)$,对于每个子树需要构造出与子树同等规模的字符串,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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(k - root.val)) return true;
set.add(root.val);
return findTarget(root.left, k) | findTarget(root.right, k);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 双指针 + BST 中序遍历
解法一中没有利用 `BST` 特性,利用 `BST` 中序遍历有序的特性,我们可以实现类似「双指针」的效果。
起始先让 BST 的最左链和最右链完全入栈,此时栈顶元素为 BST 中的最小值和最大值,分别使用 `l` 和 `r` 充当指针代指,根据两指针指向的节点值之和与 $k$ 的大小关系来指导如何让 `l` 和 `r` 移动,`l` 的移动过程其实就是找下一个比 `l.val` 更大的值,而 `r` 的移动过程其实就是找下一个比 `r.val` 更小的值。
代码:
```Java
class Solution {
public boolean findTarget(TreeNode root, int k) {
Deque<TreeNode> ld = new ArrayDeque<>(), rd = new ArrayDeque<>();
TreeNode temp = root;
while (temp != null) {
ld.addLast(temp);
temp = temp.left;
}
temp = root;
while (temp != null) {
rd.addLast(temp);
temp = temp.right;
}
TreeNode l = ld.peekLast(), r = rd.peekLast();
while (l.val < r.val) {
int t = l.val + r.val;
if (t == k) return true;
else if (t < k) l = getNext(ld, true);
else r = getNext(rd, false);
}
return false;
}
TreeNode getNext(Deque<TreeNode> d, boolean isLeft) {
TreeNode cur = d.pollLast();
TreeNode node = isLeft ? cur.right : cur.left;
while (node != null) {
d.addLast(node);
node = isLeft ? node.left : node.right;
}
return d.peekLast();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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] 中的最大值是 3 ,左边部分是 [] ,右边部分是 [2,1] 。
- 空数组,无子节点。
- [2,1] 中的最大值是 2 ,左边部分是 [] ,右边部分是 [1] 。
- 空数组,无子节点。
- 只有一个元素,所以子节点是一个值为 1 的节点。
- [0,5] 中的最大值是 5 ,左边部分是 [0] ,右边部分是 [] 。
- 只有一个元素,所以子节点是一个值为 0 的节点。
- 空数组,无子节点。
```
示例 2:
```
输入:nums = [3,2,1]
输出:[3,null,2,null,1]
```
提示:
* $1 <= nums.length <= 1000$
* $0 <= nums[i] <= 1000$
* `nums` 中的所有整数 互不相同 | ### 基本分析
根据题目描述,可知该问题本质是「区间求最值」问题(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]$ 下标范围进行构建,返回构建后的头结点。
当 $l > r$ 时,返回空节点,否则在 $[l, r]$ 中进行扫描,找到最大值对应的下标 `idx` 并创建对应的头结点,递归构建 $[l, idx - 1]$ 和 $[idx + 1, r]$ 作为头节点的左右子树。
Java 代码:
```Java
class Solution {
public TreeNode constructMaximumBinaryTree(int[] nums) {
return build(nums, 0, nums.length - 1);
}
TreeNode build(int[] nums, int l, int r) {
if (l > r) return null;
int idx = l;
for (int i = l; i <= r; i++) {
if (nums[i] > nums[idx]) idx = i;
}
TreeNode ans = new TreeNode(nums[idx]);
ans.left = build(nums, l, idx - 1);
ans.right = build(nums, idx + 1, r);
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
return build(nums, 0, nums.size() - 1);
}
TreeNode* build(vector<int>& nums, int l, int r) {
if (l > r) return nullptr;
int idx = l;
for (int i = l; i <= r; ++i) {
if (nums[i] > nums[idx]) idx = i;
}
TreeNode* ans = new TreeNode(nums[idx]);
ans->left = build(nums, l, idx - 1);
ans->right = build(nums, idx + 1, r);
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
return self.build(nums, 0, len(nums) - 1)
def build(self, nums, l, r):
if l > r:
return None
idx = l
for i in range(l, r + 1):
if nums[i] > nums[idx]:
idx = i
node = TreeNode(nums[idx])
node.left = self.build(nums, l, idx - 1)
node.right = self.build(nums, idx + 1, r)
return node
```
TypeScript 代码:
```TypeScript
function constructMaximumBinaryTree(nums: number[]): TreeNode | null {
return build(nums, 0, nums.length - 1)
};
function build(nums: number[], l: number, r: number): TreeNode | null {
if (l > r) return null
let idx = l
for (let i = l; i <= r; i++) {
if (nums[i] > nums[idx]) idx = i
}
const ans = new TreeNode(nums[idx])
ans.left = build(nums, l, idx - 1)
ans.right = build(nums, idx + 1, r)
return ans
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 线段树
抽象成区间求和问题后,涉及「单点修改」和「区间查询」,再结合节点数量为 $1e3$,可使用 `build` $4n$ 空间不带懒标记的线段树进行求解。
设计线段树节点 `Node` 包含属性:左节点下标 `l`、右节点下标 `r` 和当前区间 $[l, r]$ 所对应的最值 $val$。
构建线段树的过程为基本的线段树模板内容,而构建答案树的过程与递归分治过程类型(将线性找最值过程用线段树优化)。
Java 代码:
```Java
class Solution {
class Node {
int l, r, val;
Node (int _l, int _r) {
l = _l; r = _r;
}
}
void build(int u, int l, int r) {
tr[u] = new Node(l, r);
if (l == r) return ;
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
}
void update(int u, int x, int v) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].val = Math.max(tr[u].val, v);
return ;
}
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) update(u << 1, x, v);
else update(u << 1 | 1, x, v);
pushup(u);
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;
int mid = tr[u].l + tr[u].r >> 1, ans = 0;
if (l <= mid) ans = query(u << 1, l, r);
if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));
return ans;
}
void pushup(int u) {
tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val);
}
Node[] tr = new Node[4010];
int[] hash = new int[1010];
public TreeNode constructMaximumBinaryTree(int[] nums) {
int n = nums.length;
build(1, 1, n);
for (int i = 0; i < n; i++) {
hash[nums[i]] = i + 1;
update(1, i + 1, nums[i]);
}
return dfs(nums, 1, n);
}
TreeNode dfs(int[] nums, int l, int r) {
if (l > r) return null;
int val = query(1, l, r), idx = hash[val];
TreeNode ans = new TreeNode(val);
ans.left = dfs(nums, l, idx - 1);
ans.right = dfs(nums, idx + 1, r);
return ans;
}
}
```
C++ 代码:
```C++
struct Node {
int l, r, val;
Node(int _l, int _r) : l(_l), r(_r), val(0) {}
Node() : l(0), r(0), val(0) {}
};
class Solution {
public:
vector<Node> tr;
unordered_map<int, int> hash;
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
int n = nums.size();
tr.resize(4010);
build(1, 1, n);
for (int i = 0; i < n; ++i) {
hash[nums[i]] = i + 1;
update(1, i + 1, nums[i]);
}
return dfs(nums, 1, n);
}
void build(int u, int l, int r) {
tr[u] = Node(l, r);
if (l == r) return;
int mid = (l + r) >> 1;
build((u << 1), l, mid);
build((u << 1) + 1, mid + 1, r);
}
void update(int u, int x, int v) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].val = max(tr[u].val, v);
return;
}
int mid = (tr[u].l + tr[u].r) >> 1;
if (x <= mid) update((u << 1), x, v);
else update((u << 1) + 1, x, v);
pushup(u);
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;
int mid = (tr[u].l + tr[u].r) >> 1, ans = 0;
if (l <= mid) ans = max(ans, query((u << 1), l, r));
if (r > mid) ans = max(ans, query((u << 1) + 1, l, r));
return ans;
}
void pushup(int u) {
tr[u].val = max(tr[(u << 1)].val, tr[(u << 1) + 1].val);
}
TreeNode* dfs(vector<int>& nums, int l, int r) {
if (l > r) return NULL;
int val = query(1, l, r), idx = hash[val];
TreeNode* ans = new TreeNode(val);
ans -> left = dfs(nums, l, idx - 1);
ans -> right = dfs(nums, idx + 1, r);
return ans;
}
};
```
Python 代码:
```Python
class Node:
def __init__(self, l=0, r=0, val=0):
self.l = l
self.r = r
self.val = val
class Solution:
def __init__(self):
self.tr = [Node() for _ in range(4010)]
self.hash = {}
def constructMaximumBinaryTree(self, nums):
n = len(nums)
self.build(1, 1, n)
for i, num in enumerate(nums):
self.hash[num] = i + 1
self.update(1, i + 1, num)
return self.dfs(nums, 1, n)
def build(self, u, l, r):
self.tr[u] = Node(l, r)
if l == r: return
mid = (l + r) >> 1
self.build(u << 1, l, mid)
self.build(u << 1 | 1, mid + 1, r)
def update(self, u, x, v):
if self.tr[u].l == x and self.tr[u].r == x:
self.tr[u].val = max(self.tr[u].val, v)
return
mid = (self.tr[u].l + self.tr[u].r) >> 1
if x <= mid: self.update(u << 1, x, v)
else: self.update(u << 1 | 1, x, v)
self.pushup(u)
def query(self, u, l, r):
if l <= self.tr[u].l and self.tr[u].r <= r: return self.tr[u].val
mid = (self.tr[u].l + self.tr[u].r) >> 1
ans = 0
if l <= mid: ans = max(ans, self.query(u << 1, l, r))
if r > mid: ans = max(ans, self.query(u << 1 | 1, l, r))
return ans
def pushup(self, u):
self.tr[u].val = max(self.tr[u << 1].val, self.tr[u << 1 | 1].val)
def dfs(self, nums, l, r):
if l > r: return None
val = self.query(1, l, r)
idx = self.hash[val]
node = TreeNode(val)
node.left = self.dfs(nums, l, idx - 1)
node.right = self.dfs(nums, idx + 1, r)
return node
```
TypeScript 代码:
```TypeScript
class TNode {
l = 0; r = 0; val = 0;
constructor (_l: number, _r: number) {
this.l = _l; this.r = _r;
}
}
const tr: TNode[] = new Array<TNode>(4010)
const hash: number[] = new Array<number>(1010)
function constructMaximumBinaryTree(nums: number[]): TreeNode | null {
const n = nums.length
build(1, 1, n)
for (let i = 0; i < n; i++) {
hash[nums[i]] = i + 1
update(1, i + 1, nums[i])
}
return dfs(nums, 1, n)
};
function build(u: number, l: number, r: number): void {
tr[u] = new TNode(l, r)
if (l == r) return
const mid = l + r >> 1
build(u << 1, l, mid)
build(u << 1 | 1, mid + 1, r)
}
function update(u: number, x: number, v: number): void {
if (tr[u].l == x && tr[u].r == x) {
tr[u].val = Math.max(tr[u].val, v)
return
}
const mid = tr[u].l + tr[u].r >> 1
if (x <= mid) update(u << 1, x, v)
else update(u << 1 | 1, x, v)
pushup(u)
}
function query(u: number, l: number, r: number): number {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].val
let mid = tr[u].l + tr[u].r >> 1, ans = 0
if (l <= mid) ans = query(u << 1, l, r)
if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r))
return ans
}
function pushup(u: number): void {
tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val)
}
function dfs(nums: number[], l: number, r: number): TreeNode {
if (l > r) return null
let val = query(1, l, r), idx = hash[val]
const ans = new TreeNode(val)
ans.left = dfs(nums, l, idx - 1)
ans.right = dfs(nums, idx + 1, r)
return ans
}
```
* 时间复杂度:构建线段树复杂度为 $O(n\log{n})$;构造答案树复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 单调栈
更进一步,根据题目对树的构建的描述可知,`nums` 中的任二节点所在构建树的水平截面上的位置仅由下标大小决定。
不难想到可抽象为找最近元素问题,可使用单调栈求解。
具体的,我们可以从前往后处理所有的 $nums[i]$,若存在栈顶元素并且栈顶元素的值比当前值要小,根据我们从前往后处理的逻辑,可确定栈顶元素可作为当前 $nums[i]$ 对应节点的左节点,同时为了确保最终 $nums[i]$ 的左节点为 $[0, i - 1]$ 范围的最大值,我们需要确保在构建 $nums[i]$ 节点与其左节点的关系时,$[0, i - 1]$ 中的最大值最后出队,此时可知容器栈具有「单调递减」特性。基于此,我们可以分析出,当处理完 $nums[i]$ 节点与其左节点关系后,可明确 $nums[i]$ 可作为未出栈的栈顶元素的右节点。
> 一些细节:`Java` 容易使用 `ArrayDeque` 充当容器,但为与 `TS` 保存一致,两者均使用数组充当容器。
Java 代码:
```Java
class Solution {
static TreeNode[] stk = new TreeNode[1010];
public TreeNode constructMaximumBinaryTree(int[] nums) {
int he = 0, ta = 0;
for (int x : nums) {
TreeNode node = new TreeNode(x);
while (he < ta && stk[ta - 1].val < x) node.left = stk[--ta];
if (he < ta) stk[ta - 1].right = node;
stk[ta++] = node;
}
return stk[0];
}
}
```
C++ 代码:
```C++
class Solution {
public:
TreeNode* stk[1010];
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
int he = 0, ta = 0;
for (int x : nums) {
TreeNode* node = new TreeNode(x);
while (he < ta && stk[ta - 1]->val < x) node->left = stk[--ta];
if (he < ta) stk[ta - 1]->right = node;
stk[ta++] = node;
}
return stk[0];
}
};
```
Python 代码:
```Python
class Solution:
def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
stk = [None] * 1010
he, ta = 0, 0
for x in nums:
node = TreeNode(x)
while he < ta and stk[ta - 1].val < x:
node.left = stk[ta - 1]
ta -= 1
if he < ta:
stk[ta - 1].right = node
stk[ta] = node
ta += 1
return stk[0]
```
TypeScript 代码:
```TypeScript
const stk = new Array<TreeNode>(1010)
function constructMaximumBinaryTree(nums: number[]): TreeNode | null {
let he = 0, ta = 0
for (const x of nums) {
const node = new TreeNode(x)
while (he < ta && stk[ta - 1].val < x) node.left = stk[--ta]
if (he < ta) stk[ta - 1].right = node
stk[ta++] = node
}
return stk[0]
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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+2^{height-r-1}]$ 。
* 继续这一过程,直到树中的所有节点都妥善放置。
* 任意空单元格都应该包含空字符串 `""` 。
返回构造得到的矩阵 `res` 。
示例 1:
```
输入:root = [1,2]
输出:
[["","1",""],
["2","",""]]
```
示例 2:
```
输入:root = [1,2,3,null,4]
输出:
[["","","","1","","",""],
["","2","","","","3",""],
["","","4","","","",""]]
```
提示:
* 树中节点数在范围 $[1, 2^{10}]$ 内
* $-99 <= Node.val <= 99$
* 树的深度在范围 $[1, 10]$ 内 | ### 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 ArrayList<>();
for (int i = 0; i < m; i++) {
List<String> cur = new ArrayList<>();
for (int j = 0; j < n; j++) cur.add("");
ans.add(cur);
}
dfs2(root, 0, (n - 1) / 2);
return ans;
}
void dfs1(TreeNode root, int depth) {
if (root == null) return ;
h = Math.max(h, depth);
dfs1(root.left, depth + 1);
dfs1(root.right, depth + 1);
}
void dfs2(TreeNode root, int x, int y) {
if (root == null) return ;
ans.get(x).set(y, String.valueOf(root.val));
dfs2(root.left, x + 1, y - (1 << (h - x - 1)));
dfs2(root.right, x + 1, y + (1 << (h - x - 1)));
}
}
```
Typescript 代码:
```Typescript
let h: number, m: number, n: number;
let ans: string[][];
function printTree(root: TreeNode | null): string[][] {
h = 0
dfs1(root, 0)
m = h + 1; n = (1 << (h + 1)) - 1
ans = new Array<Array<string>>()
for (let i = 0; i < m; i++) {
ans[i] = new Array<string>(n).fill("")
}
dfs2(root, 0, (n - 1) / 2)
return ans
};
function dfs1(root: TreeNode | null, depth: number): void {
if (root == null) return
h = Math.max(h, depth)
dfs1(root.left, depth + 1)
dfs1(root.right, depth + 1)
}
function dfs2(root: TreeNode | null, x: number, y: number): void {
if (root == null) return
ans[x][y] = root.val + "";
dfs2(root.left, x + 1, y - (1 << (h - x - 1)))
dfs2(root.right, x + 1, y + (1 << (h - x - 1)))
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 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.length$
* $1 <= arr.length <= 10^4$
* `arr` 按升序排列
* $-10^4 <= arr[i], x <= 10^4$ | ### 二分 + 双指针
容易想到先通过「二分」找到与 `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, l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (arr[mid] <= x) l = mid;
else r = mid - 1;
}
r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r;
int i = r - 1, j = r + 1;
while (j - i - 1 < k) {
if (i >= 0 && j < n) {
if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++;
else i--;
} else if (i >= 0) {
i--;
} else {
j++;
}
}
List<Integer> ans = new ArrayList<>();
for (int p = i + 1; p <= j - 1; p++) ans.add(arr[p]);
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function findClosestElements(arr: number[], k: number, x: number): number[] {
let n = arr.length, l = 0, r = n - 1
while (l < r) {
const mid = l + r + 1 >> 1
if (arr[mid] <= x) l = mid
else r = mid - 1
}
r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r
let i = r - 1, j = r + 1
while (j - i - 1 < k) {
if (i >= 0 && j < n) {
if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++
else i--
} else if (i >= 0) {
i--
} else {
j++
}
}
return arr.slice(i + 1, j);
};
```
* 时间复杂度:查找分割点复杂度为 $O(\log{n})$;从分割点往两边拓展复杂度为 $O(k)$。整体复杂度为 $O(\log{n} + k)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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, 0, 0],[0, 0, 0], [0, 0, 0]]
解释:
对于点 (0,0), (0,2), (2,0), (2,2): 平均(3/4) = 平均(0.75) = 0
对于点 (0,1), (1,0), (1,2), (2,1): 平均(5/6) = 平均(0.83333333) = 0
对于点 (1,1): 平均(8/9) = 平均(0.88888889) = 0
```
示例 2:
```
输入: img = [[100,200,100],[200,50,200],[100,200,100]]
输出: [[137,141,137],[141,138,141],[137,141,137]]
解释:
对于点 (0,0), (0,2), (2,0), (2,2): floor((100+200+200+50)/4) = floor(137.5) = 137
对于点 (0,1), (1,0), (1,2), (2,1): floor((200+200+50+200+100+100)/6) = floor(141.666667) = 141
对于点 (1,1): floor((50+200+200+200+200+100+100+100+100)/9) = floor(138.888889) = 138
```
提示:
* $m == img.length$
* $n == img[i].length$
* $1 <= m, n <= 200$
* $0 <= img[i][j] <= 255$ | ### 朴素解法
为了方便,我们称每个单元格及其八连通方向单元格所组成的连通块为一个 `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},{-1,-1},{-1,1},{1,-1},{1,1}};
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int tot = 0, cnt = 0;
for (int[] di : dirs) {
int nx = i + di[0], ny = j + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
tot += img[nx][ny]; cnt++;
}
ans[i][j] = tot / cnt;
}
}
return ans;
}
}
```
---
```Python
dirs = list(product(*[[-1,0,1]] * 2))
class Solution:
def imageSmoother(self, img: List[List[int]]) -> List[List[int]]:
m, n = len(img), len(img[0])
ans = [[0] * n for _ in range(m)]
for i in range(m):
for j in range(n):
tot, cnt = 0, 0
for di in dirs:
if 0 <= (nx := i + di[0]) < m and 0 <= (ny := j + di[1]) < n:
tot += img[nx][ny]
cnt += 1
ans[i][j] = tot // cnt
return ans
```
* 时间复杂度:$O(m \times n \times C)$,其中 $C$ 为灰度单位所包含的单元格数量,固定为 $9$
* 空间复杂度:$O(m \times n)$
---
### 前缀和
在朴素解法中,对于每个 $ans[i][j]$ 我们都不可避免的遍历 $8$ 联通方向,而利用「前缀和」我们可以对该操作进行优化。
对于某个 $ans[i][j]$ 而言,我们可以直接计算出其所在 `item` 的左上角 $(a, b) = (i - 1, j - 1)$ 以及其右下角 $(c, d) = (i + 1, j + 1)$,同时为了防止超出原矩阵,我们需要将 $(a, b)$ 与 $(c, d)$ 对边界分别取 `max` 和 `min`。
当有了合法的 $(a, b)$ 和 $(c, d)$ 后,我们可以直接计算出 `item` 的单元格数量(所包含的行列乘积)及 `item` 的单元格之和(前缀和查询),从而算得 $ans[i][j]$。
代码:
```Java
class Solution {
public int[][] imageSmoother(int[][] img) {
int m = img.length, n = img[0].length;
int[][] sum = new int[m + 10][n + 10];
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + img[i - 1][j - 1];
}
}
int[][] ans = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int a = Math.max(0, i - 1), b = Math.max(0, j - 1);
int c = Math.min(m - 1, i + 1), d = Math.min(n - 1, j + 1);
int cnt = (c - a + 1) * (d - b + 1);
int tot = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b];
ans[i][j] = tot / cnt;
}
}
return ans;
}
}
```
---
```Python
class Solution:
def imageSmoother(self, img: List[List[int]]) -> List[List[int]]:
m, n = len(img), len(img[0])
sum = [[0] * (n + 10) for _ in range(m + 10)]
for i in range(1, m + 1):
for j in range(1, n + 1):
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + img[i - 1][j - 1]
ans = [[0] * n for _ in range(m)]
for i in range(m):
for j in range(n):
a, b = max(0, i - 1), max(0, j - 1)
c, d = min(m - 1, i + 1), min(n - 1, j + 1)
cnt = (c - a + 1) * (d - b + 1)
tot = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b]
ans[i][j] = tot // cnt
return ans
```
* 时间复杂度:$O(m \times n)$
* 空间复杂度:$O(m \times n)$ | ### 最后
这是我们「刷穿 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,null,7]
输出:7
解释:最大宽度出现在树的第 4 层,宽度为 7 (6,null,null,null,null,null,7) 。
```
示例 3:
```
输入:root = [1,3,2,5]
输出:2
解释:最大宽度出现在树的第 2 层,宽度为 2 (3,2) 。
```
提示:
* 树中节点的数目范围是 $[1, 3000]$
* $-100 <= Node.val <= 100$ | ### DFS
根据满二叉树的节点编号规则:若根节点编号为 `u`,则其左子节点编号为 `u << 1`,其右节点编号为 `u << 1 | 1`。
一个朴素的想法是:我们在 `DFS`过程中使用两个哈希表分别记录每层深度中的最小节点编号和最大节点编号,两者距离即是当前层的宽度,最终所有层数中的最大宽度即是答案。
而实现上,我们可以利用先 `DFS` 左节点,再 `DFS` 右节点的性质可知,每层的最左节点必然是最先被遍历到,因此我们只需要记录当前层最先被遍历到点编号(即当前层最小节点编号),并在 `DFS` 过程中计算宽度,更新答案即可。
> 看到评论区有同学讨论关于编号溢出问题,之所以溢出仍能 `AC` 是因为测试数组中没有同层内「宽度」左端点不溢出,右端点溢出,同时该层就是最大宽度的数据点。
我们可以通过 `u = u - map.get(depth) + 1` 操作来对同层内的节点进行重新编号(使得同层最靠左的非空节点编号为 $1$)。
通过重编号操作 我们可以消除由于深度加深带来的编号溢出问题,同时 `TS` 代码不再需要使用 `bigint`。
Java 代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
int ans;
public int widthOfBinaryTree(TreeNode root) {
dfs(root, 1, 0);
return ans;
}
void dfs(TreeNode root, int u, int depth) {
if (root == null) return ;
if (!map.containsKey(depth)) map.put(depth, u);
ans = Math.max(ans, u - map.get(depth) + 1);
u = u - map.get(depth) + 1;
dfs(root.left, u << 1, depth + 1);
dfs(root.right, u << 1 | 1, depth + 1);
}
}
```
C++ 代码:
```C++
class Solution {
public:
unordered_map<int, int> map;
int ans = 0;
int widthOfBinaryTree(TreeNode* root) {
dfs(root, 1, 0);
return ans;
}
void dfs(TreeNode* root, int u, int depth) {
if (!root) return;
if (!map.count(depth)) map[depth] = u;
ans = max(ans, u - map[depth] + 1);
u = u - map[depth] + 1;
dfs(root->left, u << 1, depth + 1);
dfs(root->right, u << 1 | 1, depth + 1);
}
};
```
Python 代码:
```Python
class Solution:
def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
mapping = {}
ans = 0
def dfs(root, u, depth):
nonlocal ans
if not root:
return
if depth not in mapping:
mapping[depth] = u
ans = max(ans, u - mapping[depth] + 1)
u = u - mapping[depth] + 1
dfs(root.left, u << 1, depth + 1)
dfs(root.right, u << 1 | 1, depth + 1)
dfs(root, 1, 0)
return ans
```
TypeScript 代码:
```TypeScript
let map = new Map<number, number>()
let ans = 0
function widthOfBinaryTree(root: TreeNode | null): number {
map.clear()
ans = 0
dfs(root, 1, 0)
return ans
};
function dfs(root: TreeNode | null, u: number, depth: number): void {
if (root == null) return
if (!map.has(depth)) map.set(depth, u)
ans = Math.max(ans, u - map.get(depth) + 1)
u = u - map.get(depth) + 1
dfs(root.left, u << 1, depth + 1)
dfs(root.right, u << 1 | 1, depth + 1)
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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` 必然是可以「归到同一次打印」中。
**我们可以不失一般性证明「连续相同的一段字符,必然可以归到同一次打印中,而不会让打印次数变多」这个推理是否正确:**
假设有目标序列 $[...,ai,...,aj,...]$ 其中 $[i, j]$ 连续一段字符相同,假如这一段的打印被最后完成(注意最后完成不代表这一段要保留空白,这一段可以此前被打印多次),除了这一段以外所消耗的打印次数为 $x$,那么根据 $[i, j]$ 不同的打印方案有:
1. 将 $[i, j]$ 单纯划分为多段:总共打印的次数大于 $x + 1$(此方案不会取到打印最小值 $x + 1$,可忽略)
2. 将 $[i, j]$ 归到同一次打印:总共打印的次数等于 $x + 1$
3. 将 $[i, j]$ 结合之前的打印划分为多段,即 $[i, j]$ 一段的两段本身就是「目标字符」,我们本次只需要打印 $[i, j]$ 中间的部分。总共打印的次数等于 $x + 1$
由于同样的地方可以被重复打印,因此我们可以将情况 $3$ 中打印边缘扩展到 $i$ 和 $j$ 处,这样最终打印结果不变,而且总的打印次数没有增加。
到这一步,我们其实已经证明出「连续相同的一段字符,必然可以归到同一次打印中,而不会让打印次数变多」的推论成立了。
但可能会有同学提出疑问:怎么保证 $[i, j]$ 是被最后涂的?怎么保证 $[i, j]$ 不是和其他「不相邻的同样字符」一起打印的?
**答案是不用保证,因为不同状态(打印结果)之间相互独立,而有明确的最小转移成本。即从当前打印结果 `a` 变成打印结果 `b`,是具有明确的最小打印次数的(否则本题无解)。因此我们上述的分析可以看做任意两个中间状态转移的“最后一步”,而且不会整体的结果。**
对应到本题,题目给定的起始状态是空白字符串 `a`,目标状态是入参字符串 `s`。那么真实最优解中,从 `a` 状态到 `s` 状态中间可能会经过任意个中间状态,假设有两个中间状态 `p` 和 `q`,那么我们上述的分析就可以应用到中间状态 `p` 到 `q` 的转移中,可以令得 `p` 到 `q` 转移所花费的转移成本最低(最优),同时这个转移不会影响「`a` 到 `p` 的转移」和「`q` 到 `s` 的转移」,是相互独立的。
因此这个分析可以推广到真实最优转移路径中的任意一步,是一个具有一般性的结论。
上述分析是第一个切入点,第二个切入点是「重复打印会进行覆盖」,这意味着我们其实不需要确保 $[i,j]$ 这一段在目标字符串中完全相同,而只需要 $s[i] = s[j]$ 相同即可,即后续打印不会从边缘上覆盖 $[i,j]$ 区间的原有打印,否则 $[i,j]$ 这一段的打印就能用范围更小的区间所代替。
这样就引导出我们状态转移的关键:状态转移之间只需要确保首位字符相同。
---
### 动态规划
定义 $f[l][r]$ 为将 $[l, r]$ 这一段打印成目标结果所消耗的最小打印次数。
不失一般性考虑 $f[l][r]$ 该如何转移:
* 只染 $l$ 这个位置,此时 $f[l][r] = f[l + 1][r] + 1$
* 不只染 $l$ 这个位置,而是从 $l$ 染到 $k$(需要确保首位相同 $s[l] = s[k]$):$f[l][r] = f[l][k - 1] + f[k + 1][r], l < k <= r$
其中状态转移方程中的情况 $2$ 需要说明一下:由于我们只确保 $s[l] = s[k]$,并不确保 $[l, k]$ 之间的字符相同,根据我们基本分析可知,$s[k]$ 这个点可由打印 $s[l]$ 的时候一同打印,因此本身 $s[k]$ 并不独立消耗打印次数,所以这时候 $[l, k]$ 这一段的最小打印次数应该取 $f[l][k - 1]$,而不是 $f[l][k]$。
最终的 $f[l][r]$ 为上述所有方案中取 $min$。
代码:
```Java
class Solution {
public int strangePrinter(String s) {
int n = s.length();
int[][] f = new int[n + 1][n + 1];
for (int len = 1; len <= n; len++) {
for (int l = 0; l + len - 1 < n; l++) {
int r = l + len - 1;
f[l][r] = f[l + 1][r] + 1;
for (int k = l + 1; k <= r; k++) {
if (s.charAt(l) == s.charAt(k)) {
f[l][r] = Math.min(f[l][r], f[l][k - 1] + f[k + 1][r]);
}
}
}
}
return f[0][n - 1];
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n^2)$
---
### 总结
这道题的原型应该出自 [String painter](http://acm.hdu.edu.cn/showproblem.php?pid=2476)。
如果只是为了把题做出来,难度不算特别大,根据数据范围 $10^2$,可以猜到是 $O(n^3)$ 做法,通常就是区间 DP 的「枚举长度 + 枚举左端点 + 枚举分割点」的三重循环。
但是要搞懂为啥可以这样做,还是挺难,大家感兴趣的话可以好好想想 ~ 🤣 | ### 最后
这是我们「刷穿 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-3 的不同整数,并且 [1, 1] 中有且仅有 1 个不同整数:1
```
示例 2:
```
输入:n = 3, k = 2
输出:[1, 3, 2]
解释:[1, 3, 2] 包含 3 个范围在 1-3 的不同整数,并且 [2, 1] 中有且仅有 2 个不同整数:1 和 2
```
提示:
* $1 <= k < n <= 10^4$ | ### 构造
给定范围在 $[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)$ 个数来直接升序(通过方式一构造出若干个 $1$),然后从 $n - k$ 开始间隔升序排列,按照 $n$ 开始间隔降序排列,构造出剩下的序列。
Java 代码:
```Java
class Solution {
public int[] constructArray(int n, int k) {
int[] ans = new int[n];
int t = n - k - 1;
for (int i = 0; i < t; i++) ans[i] = i + 1;
for (int i = t, a = n - k, b = n; i < n; ) {
ans[i++] = a++;
if (i < n) ans[i++] = b--;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function constructArray(n: number, k: number): number[] {
const ans = new Array<number>(n).fill(0)
const t = n - k - 1
for (let i = 0; i < t; i++) ans[i] = i + 1
for (let i = t, a = n - k, b = n; i < n; ) {
ans[i++] = a++
if (i < n) ans[i++] = b--
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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$ 的范围在 $[1, 30000]$ 之间。
* $k$ 的范围在 $[1, m \times n]$ 之间。 | ### 二分 + 计数判定
由于 $n$ 和 $m$ 的数据范围都是 $3 \times 10^4$,总数本身就超过了 $10^7$,我们考虑线性复杂度往下的对数复杂度。
题目要求我们求一维展开有序序列中的第 $k$ 小的数,问题本身具有「二段性」:
* 答案右边的每个数均 **满足**「其在一维展开有序序列中左边数的个数大于等于 $k$ 个」
* 答案左边的每个数均 **不满足**「其在一维展开有序序列中左边数的个数大于等于 $k$ 个」
我们考虑如何进行「二分答案」: 假设当前我们二分到的值是 $mid$,对于乘法表中的每行和每列均是单调递增,我们可以通过累加统计 每行/每列 中比 $mid$ 小的数,记作 $a$,累加统计 每行/每列 中等于 $mid$ 的数,记作 $b$,那么 $cnt = a + b$ 即是整个乘法表中小于等于 $mid$ 的数的个数,再通过 $cnt$ 和 $k$ 的大小关系来指导左右指针的变化。
具体的,假设我们通过枚举行来统计 $a$ 和 $b$,当前枚举到的行号为 $i$(行号从 $1$ 开始),该行的最大数为 $i \times m$:
* 若 $i \times m < mid$,整行都是小于 $mid$ 的数,直接在 $a$ 基础上累加 $m$;
* 若 $i \times m >= mid$,根据 $mid$ 是否存在于该行进行分情况讨论:
* $mid$ 能够被 $i$ 整除,说明 $mid$ 存在于该行,那么比 $mid$ 小的数的个数为 $\frac{mid}{i} - 1$,将其累加到 $a$,同时对 $b$ 进行加一;
* $mid$ 不能够被 $i$ 整除,说明 $mid$ 不存在于该行,那么比 $mid$ 小的数的个数为 $\frac{mid}{i}$,将其累加到 $a$。
> 一些细节:由于乘法表具有对称性,我们统计时可以对 行和列 中较小的一方进行遍历。
代码:
```Java
class Solution {
int n, m, k;
public int findKthNumber(int _m, int _n, int _k) {
n = Math.min(_m, _n); m = Math.max(_m, _n); k = _k;
int l = 1, r = m * n;
while (l < r) {
int mid = l + r >> 1, cnt = getCnt(mid);
if (cnt >= k) r = mid;
else l = mid + 1;
}
return r;
}
int getCnt(int mid) {
int a = 0, b = 0;
for (int i = 1; i <= n; i++) {
if (i * m < mid) {
a += m;
} else {
if (mid % i == 0 && ++b >= 0) a += mid / i - 1;
else a += mid / i;
}
}
return a + b;
}
}
```
* 时间复杂度:$O(\min(n, m) \times \log{nm})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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 = 1, high = 3
输出:[3,2,null,1]
```
提示:
* 树中节点数在范围 $[1, 10^4]$ 内
* $0 <= Node.val <= 10^4$
* 树中每个节点的值都是 唯一 的
* 题目数据保证输入是一棵有效的二叉搜索树
* $0 <= low <= high <= 10^4$ | ### 递归
由于被修剪的是二叉搜索树,因此修剪过程必然能够顺利进行。
容易想到使用原函数作为递归函数:
* 若 `root.val` 小于边界值 `low`,则 `root` 的左子树必然均小于边界值,我们递归处理 `root.right` 即可;
* 若 `root.val` 大于边界值 `high`,则 `root` 的右子树必然均大于边界值,我们递归处理 `root.left` 即可;
* 若 `root.val` 符合要求,则 `root` 可被保留,递归处理其左右节点并重新赋值即可。
Java 代码:
```Java
class Solution {
public TreeNode trimBST(TreeNode root, int low, int high) {
if (root == null) return null;
if (root.val < low) return trimBST(root.right, low, high);
else if (root.val > high) return trimBST(root.left, low, high);
root.left = trimBST(root.left, low, high);
root.right = trimBST(root.right, low, high);
return root;
}
}
```
TypeScript 代码:
```TypeScript
function trimBST(root: TreeNode | null, low: number, high: number): TreeNode | null {
if (root == null) return null
if (root.val < low) return trimBST(root.right, low, high)
else if (root.val > high) return trimBST(root.left, low, high)
root.left = trimBST(root.left, low, high)
root.right = trimBST(root.right, low, high)
return root
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 迭代
自然能够使用「迭代」进行求解:起始先从给定的 `root` 进行出发,找到第一个满足值符合 $[low, high]$ 范围的节点,该节点为最后要返回的根节点 `ans`。
随后考虑如何修剪 `ans` 的左右节点:当根节点符合 $[low, high]$ 要求时,修剪左右节点过程中仅需考虑一边的边界值即可。即对于 `ans.left` 只需考虑将值小于 `low` 的节点去掉(因为二叉搜索树的特性,`ans` 满足不大于 `high` 要求,则其左节点必然满足);同理 `ans.right` 只需要考虑将大于 `high` 的节点去掉即可。
Java 代码:
```Java
class Solution {
public TreeNode trimBST(TreeNode root, int low, int high) {
while (root != null && (root.val < low || root.val > high)) root = root.val < low ? root.right : root.left;
TreeNode ans = root;
while (root != null) {
while (root.left != null && root.left.val < low) root.left = root.left.right;
root = root.left;
}
root = ans;
while (root != null) {
while (root.right != null && root.right.val > high) root.right = root.right.left;
root = root.right;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function trimBST(root: TreeNode | null, low: number, high: number): TreeNode | null {
while (root != null && (root.val < low || root.val > high)) root = root.val < low ? root.right : root.left
const ans = root
while (root != null) {
while (root.left != null && root.left.val < low) root.left = root.left.right
root = root.left
}
root = ans
while (root != null) {
while (root.right != null && root.right.val > high) root.right = root.right.left
root = root.right
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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 代码:
```Java
class Solution {
public int maximumSwap(int num) {
List<Integer> list = new ArrayList<>();
while (num != 0) {
list.add(num % 10); num /= 10;
}
int n = list.size(), ans = 0;
int[] idx = new int[n];
for (int i = 0, j = 0; i < n; i++) {
if (list.get(i) > list.get(j)) j = i;
idx[i] = j;
}
for (int i = n - 1; i >= 0; i--) {
if (list.get(idx[i]) != list.get(i)) {
int c = list.get(idx[i]);
list.set(idx[i], list.get(i));
list.set(i, c);
break;
}
}
for (int i = n - 1; i >= 0; i--) ans = ans * 10 + list.get(i);
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maximumSwap(int num) {
vector<int> list;
while (num != 0) {
list.push_back(num % 10); num /= 10;
}
int n = list.size(), ans = 0;
int* idx = new int[n];
for (int i = 0, j = 0; i < n; i++) {
if (list[i] > list[j]) j = i;
idx[i] = j;
}
for (int i = n - 1; i >= 0; i--) {
if (list[idx[i]] != list[i]) {
int c = list[idx[i]];
list[idx[i]] = list[i];
list[i] = c;
break;
}
}
for (int i = n - 1; i >= 0; i--) ans = ans * 10 + list[i];
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maximumSwap(self, num: int) -> int:
nums = []
while num != 0:
nums.append(num % 10); num //= 10
n, ans = len(nums), 0
idx = [0] * n
i, j = 0, 0
while i < n:
if nums[i] > nums[j]: j = i
idx[i] = j
i += 1
for i in range(n - 1, -1, -1):
if nums[idx[i]] != nums[i]:
c = nums[idx[i]]
nums[idx[i]] = nums[i]
nums[i] = c
break
for i in range(n - 1, -1, -1):
ans = ans * 10 + nums[i]
return ans
```
TypeScript 代码:
```TypeScript
function maximumSwap(num: number): number {
const list = new Array<number>()
while (num != 0) {
list.push(num % 10)
num = Math.floor(num / 10)
}
let n = list.length, ans = 0
const idx = new Array<number>()
for (let i = 0, j = 0; i < n; i++) {
if (list[i] > list[j]) j = i
idx.push(j)
}
for (let i = n - 1; i >= 0; i--) {
if (list[idx[i]] != list[i]) {
const c = list[idx[i]]
list[idx[i]] = list[i]
list[i] = c
break
}
}
for (let i = n - 1; i >= 0; i--) ans = ans * 10 + list[i];
return ans
};
```
* 时间复杂度:$O(\log{num})$
* 空间复杂度:$O(\log{num})$ | ### 最后
这是我们「刷穿 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, 但是不存在第二小的值。
```
提示:
* 树中节点数目在范围 $[1, 25]$ 内
* $1$ <= Node.val <= $2^{31}$ - 1
* 对于树中每个节点 root.val == min(root.left.val, root.right.val) | ### 树的遍历
一个朴素的做法是,直接对树进行遍历(广度 & 深度),使用 `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() < 2) return -1;
int first = Integer.MAX_VALUE, second = Integer.MAX_VALUE;
for (int i : set) {
if (i <= first) {
second = first;
first = i;
} else if (i <= second) {
second = i;
}
}
return second;
}
void dfs(TreeNode root) {
if (root == null) return;
set.add(root.val);
dfs(root.left);
dfs(root.right);
}
}
```
```Java
class Solution {
Set<Integer> set = new HashSet<>();
public int findSecondMinimumValue(TreeNode root) {
bfs(root);
if (set.size() < 2) return -1;
int first = Integer.MAX_VALUE, second = Integer.MAX_VALUE;
for (int i : set) {
if (i <= first) {
second = first;
first = i;
} else if (i <= second) {
second = i;
}
}
return second;
}
void bfs(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode poll = d.pollFirst();
set.add(poll.val);
if (poll.left != null) d.addLast(poll.left);
if (poll.right != null) d.addLast(poll.right);
}
}
}
```
* 时间复杂度:树的搜索复杂度为 $O(n)$,通过线性遍历找次小值,复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 递归
解法一显然没有利用到本题核心条件 :「`root.val = min(root.left.val, root.right.val)`」和「每个子节点数量要么是 `0` 要么是 `2`」。
我们可以设计如下递归函数,含义为 **从 `root` 为根的树进行搜索,找到值比 `cur` 大的最小数**。然后使用全局变量 `ans` 存储答案。
```Java
void dfs(TreeNode root, int cur)
```
那么最终搜索范围为 `dfs(root, root.val)`,这是因为 **性质 `root.val = min(root.left.val, root.right.val)`,即最小值会不断往上传递,最终根节点必然是全局最小值**。
然后再结合「每个子节点数量要么是 `0` 要么是 `2`」,我们可以特判一下 `ans` 是否为第一次赋值,如果给 `ans` 赋了新值或者更新了更小的 `ans`,则不再需要往下搜索了。
代码:
```Java
class Solution {
int ans = -1;
public int findSecondMinimumValue(TreeNode root) {
dfs(root, root.val);
return ans;
}
void dfs(TreeNode root, int cur) {
if (root == null) return ;
if (root.val != cur) {
if (ans == -1) ans = root.val;
else ans = Math.min(ans, root.val);
return ;
}
dfs(root.left, cur);
dfs(root.right, cur);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的空间开销。复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 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` 和 `presses`,执行完所有按压之后,返回 不同可能状态 的数量。
示例 1:
```
输入:n = 1, presses = 1
输出:2
解释:状态可以是:
- 按压开关 1 ,[关]
- 按压开关 2 ,[开]
```
示例 2:
```
输入:n = 2, presses = 1
输出:3
解释:状态可以是:
- 按压开关 1 ,[关, 关]
- 按压开关 2 ,[开, 关]
- 按压开关 3 ,[关, 开]
```
示例 3:
```
输入:n = 3, presses = 1
输出:4
解释:状态可以是:
- 按压开关 1 ,[关, 关, 关]
- 按压开关 2 ,[关, 开, 关]
- 按压开关 3 ,[开, 关, 开]
- 按压开关 4 ,[关, 开, 开]
```
提示:
* $1 <= n <= 1000$
* $0 <= presses <= 1000$ | ### 分情况讨论
记灯泡数量为 $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`」三种状态,当 $k = 2$ 时,能够取满「`11`/`10`/`01`/`00`」四种状态,其余更大 $k$ 可以通过前 $k - 1$ 步归结到任一状态,再通过最后一次的操作 $1$ 归结到任意状态;
* 当 $n = 3$ 时,若 $k = 1$ 时,对应 $4$ 种操作可取得 $4$ 种方案;当 $k = 2$ 时,可取得 $7$ 种状态;而当 $k = 3$ 时可取满 $2^3 = 8$ 种状态,更大的 $k$ 值可通过同样的方式归结到取满的 $8$ 种状态。
* 当 $n > 3$ 时,根据四类操作可知,灯泡每 $6$ 组一循环(对应序列 `k + 1`、`2k + 2`、`2k + 1` 和 `3k + 1`),即只需考虑 $n <= 6$ 的情况,而 $n = 4$、$n = 5$ 和 $n = 6$ 时,后引入的灯泡状态均不会产生新的组合(即新引入的灯泡状态由前三个灯泡的状态所唯一确定),因此均可归纳到 $n = 3$ 的情况。
Java 代码:
```Java
class Solution {
public int flipLights(int n, int k) {
if (k == 0) return 1;
if (n == 1) return 2;
else if (n == 2) return k == 1 ? 3 : 4;
else return k == 1 ? 4 : k == 2 ? 7 : 8;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int flipLights(int n, int k) {
if (k == 0) return 1;
if (n == 1) return 2;
else if (n == 2) return (k == 1) ? 3 : 4;
else return (k == 1) ? 4 : (k == 2) ? 7 : 8;
}
};
```
Python 3 代码:
```Python
class Solution:
def flipLights(self, n: int, k: int) -> int:
if k == 0:
return 1
if n == 1:
return 2
elif n == 2:
return 3 if k == 1 else 4
else:
return 4 if k == 1 else 7 if k == 2 else 8
```
TypeScript 代码:
```TypeScript
function flipLights(n: number, k: number): number {
if (k == 0) return 1
if (n == 1) return 2
else if (n == 2) return k == 1 ? 3 : 4;
else return k == 1 ? 4 : k == 2 ? 7 : 8;
};
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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]$ 可以接在 $nums[j]$ 后面形成上升子序列,此时使用 $f[j]$ 更新 $f[i]$,即有 $f[i] = f[j] + 1$。
回到本题,由于我们需要求解的是最长上升子序列的个数,因此需要额外定义 **$g[i]$ 为考虑以 $nums[i]$ 结尾的最长上升子序列的个数。**
结合 $f[i]$ 的转移过程,不失一般性地考虑 $g[i]$ 该如何转移:
* 同理,由于每个数都能独自一个成为子序列,因此起始必然有 $g[i] = 1$;
* 枚举区间 $[0, i)$ 的所有数 $nums[j]$,如果满足 $nums[j] < nums[i]$,说明 $nums[i]$ 可以接在 $nums[j]$ 后面形成上升子序列,这时候对 $f[i]$ 和 $f[j] + 1$ 的大小关系进行分情况讨论:
* 满足 $f[i] < f[j] + 1$:说明 $f[i]$ 会被 $f[j] + 1$ 直接更新,此时同步直接更新 $g[i] = g[j]$ 即可;
* 满足 $f[i] = f[j] + 1$:说明找到了一个新的符合条件的前驱,此时将值继续累加到方案数当中,即有 $g[i] += g[j]$。
在转移过程,我们可以同时记录全局最长上升子序列的最大长度 $max$,最终答案为所有满足 $f[i] = max$ 的 $g[i]$ 的累加值。
Java 代码:
```Java
class Solution {
public int findNumberOfLIS(int[] nums) {
int n = nums.length;
int[] f = new int[n], g = new int[n];
int max = 1;
for (int i = 0; i < n; i++) {
f[i] = g[i] = 1;
for (int j = 0; j < i; j++) {
if (nums[j] < nums[i]) {
if (f[i] < f[j] + 1) {
f[i] = f[j] + 1; g[i] = g[j];
} else if (f[i] == f[j] + 1) {
g[i] += g[j];
}
}
}
max = Math.max(max, f[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (f[i] == max) ans += g[i];
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int findNumberOfLIS(vector<int>& nums) {
int n = nums.size();
vector<int> f(n), g(n);
int maxv = 1;
for (int i = 0; i < n; i++) {
f[i] = g[i] = 1;
for (int j = 0; j < i; j++) {
if (nums[j] < nums[i]) {
if (f[i] < f[j] + 1) {
f[i] = f[j] + 1;
g[i] = g[j];
} else if (f[i] == f[j] + 1) {
g[i] += g[j];
}
}
}
maxv = max(maxv, f[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (f[i] == maxv) ans += g[i];
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def findNumberOfLIS(self, nums: List[int]) -> int:
n = len(nums)
f, g = [1] * n, [1] * n
maxv = 1
for i in range(1, n):
for j in range(i):
if nums[j] < nums[i]:
if f[i] < f[j] + 1:
f[i], g[i] = f[j] + 1, g[j]
elif f[i] == f[j] + 1:
g[i] += g[j]
maxv = max(maxv, f[i])
ans = 0
for i in range(n):
if f[i] == maxv: ans += g[i]
return ans
```
TypeScript 代码:
```TypeScript
function findNumberOfLIS(nums: number[]): number {
const n = nums.length;
let f = new Array(n).fill(1), g = new Array(n).fill(1);
let max = 1;
for (let i = 1; i < n; i++) {
for (let j = 0; j < i; j++) {
if (nums[j] < nums[i]) {
if (f[i] < f[j] + 1) {
f[i] = f[j] + 1;
g[i] = g[j];
} else if (f[i] == f[j] + 1) {
g[i] += g[j];
}
}
}
max = Math.max(max, f[i]);
}
let ans = 0;
for (let i = 0; i < n; i++) {
if (f[i] == max) ans += g[i];
}
return ans;
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
---
### LIS 问题的贪心解 + 树状数组
我们知道,对于朴素的 LIS 问题存在贪心解法,能够在 $O(n\log{n})$ 复杂度内求解 LIS 问题。
在贪心解中,我们会多开一个贪心数组 $q$,用来记录长度为 $len$ 的最长上升子序列的「最小结尾元素」为何值:**$q[len] = x$ 代表长度为 $len$ 的最长上升子序列的最小结尾元素为 $x$。**
**可以证明 $q$ 存在单调性,因此每次确定 $nums[i]$ 可以接在哪个 $nums[j]$ 后面会形成最长上升子序列时,可以通过「二分」来找到满足 $nums[j] < nums[i]$ 的最大下标来实现。**
对于本题,由于我们需要求最长上升子序列的个数,单纯使用一维的贪心数组记录最小结尾元素并不足以。
考虑对其进行扩展,期望能取到「最大长度」的同时,能够知道这个「最大长度」对应多少个子序列数量,同时期望该操作复杂度为 $O(\log{n})$。
我们可以使用「树状数组」维护二元组 $(len, cnt)$ 信息:
1. 因为数据范围较大($-10^6 <= nums[i] <= 10^6$),但数的个数为 $2000$,因此第一步先对 $nums$ 进行离散化操作;
2. 在遍历 $nums$ 时,每次从树状数组中查询值严格小于 $nums[i]$ 离散值(利用 $nums[i]$ 离散化后的值仍为正整数,我们可以直接查询小于等于 $nums[i]$ 离散值 $-1$ 的值)的最大长度,及最大长度对应的数量;
3. 对于流程 $2$ 中查得的 $(len, cnt)$,由于 $nums[i]$ 可以接在其后,因此首先长度加一,同时数量将 $cnt$ 累加到该离散值中。
Java 代码:
```Java
class Solution {
int n;
int[][] tr = new int[2010][2];
int lowbit(int x) {
return x & -x;
}
int[] query(int x) {
int len = 0, cnt = 0;
for (int i = x; i > 0; i -= lowbit(i)) {
if (len == tr[i][0]) {
cnt += tr[i][1];
} else if (len < tr[i][0]) {
len = tr[i][0];
cnt = tr[i][1];
}
}
return new int[]{len, cnt};
}
void add(int x, int[] info) {
for (int i = x; i <= n; i += lowbit(i)) {
int len = tr[i][0], cnt = tr[i][1];
if (len == info[0]) {
cnt += info[1];
} else if (len < info[0]) {
len = info[0];
cnt = info[1];
}
tr[i][0] = len; tr[i][1] = cnt;
}
}
public int findNumberOfLIS(int[] nums) {
n = nums.length;
// 离散化
int[] tmp = nums.clone();
Arrays.sort(tmp);
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0, idx = 1; i < n; i++) {
if (!map.containsKey(tmp[i])) map.put(tmp[i], idx++);
}
// 树状数组维护 (len, cnt) 信息
for (int i = 0; i < n; i++) {
int x = map.get(nums[i]);
int[] info = query(x - 1);
int len = info[0], cnt = info[1];
add(x, new int[]{len + 1, Math.max(cnt, 1)});
}
int[] ans = query(n);
return ans[1];
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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$ 。
可以保证的是,没有两棵树的高度是相同的,并且你至少需要砍倒一棵树。
示例 1:
```
输入:forest = [[1,2,3],[0,0,4],[7,6,5]]
输出:6
解释:沿着上面的路径,你可以用 6 步,按从最矮到最高的顺序砍掉这些树。
```
示例 2:
```
输入:forest = [[1,2,3],[0,0,0],[7,6,5]]
输出:-1
解释:由于中间一行被障碍阻塞,无法访问最下面一行中的树。
```
示例 3:
```
输入:forest = [[2,3,4],[0,0,5],[8,7,6]]
输出:6
解释:可以按与示例 1 相同的路径来砍掉所有的树。
(0,0) 位置的树,可以直接砍去,不用算步数。
```
提示:
* $m == forest.length$
* $n == forest[i].length$
* $1 <= m, n <= 50$
* $0 <= forest[i][j] <= 10^9$ | ### 基本分析
基本题意为:给定一个 $n \times m$ 的矩阵,每次能够在当前位置往「四联通」移动一个单位,其中 $0$ 的位置代表障碍(无法访问),$1$ 的位置代表平地(可直接访问,且无须进行任何决策),其余大于 $1$ 的位置代表有树,经过该位置的时候可以考虑将树砍掉(相应值变为平地 $1$)。
同时题目限定了我们只能按照「从低到高」的顺序进行砍树,并且图中不存在高度相等的两棵树,这意味着 **整个砍树的顺序唯一确定,就是对所有有树的地方进行「高度」排升序,即是完整的砍树路线。**
而另外一个更为重要的性质是:**点与点之间的最短路径,不会随着砍树过程的进行而发生变化(某个树点被砍掉,只会变为平地,不会变为阻碍点,仍可通过)。**
综上,**砍树的路线唯一确定,当我们求出每两个相邻的砍树点最短路径,并进行累加即是答案(整条砍树路径的最少步数)**。
---
### BFS
因此,再结合数据范围只有 $50$,并且点与点之间边权为 $1$(每次移动算一步),我们可以直接进行 `BFS` 进行求解。
先对整张图进行一次遍历,预处理出所有的树点(以三元组 $(height, x, y)$ 的形式进行存储),并对其以 $height$ 排升序,得到唯一确定的砍树路径。
之后就是计算砍树路径中相邻点的最短距离,运用 `BFS` 求解任意两点的最短路径复杂度为 $O(n \times m)$,我们最多有 $n \times m$ 个树点,因此整体复杂度为 $O(n^2 * \times m^2)$。
求解相邻点的最短距离的部分也是整个算法的复杂度上界,数据范围只有 $50$,计算量不超过 $10^7$,可以过。
代码:
```Java
class Solution {
int N = 50;
int[][] g = new int[N][N];
int n, m;
List<int[]> list = new ArrayList<>();
public int cutOffTree(List<List<Integer>> forest) {
n = forest.size(); m = forest.get(0).size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
g[i][j] = forest.get(i).get(j);
if (g[i][j] > 1) list.add(new int[]{g[i][j], i, j});
}
}
Collections.sort(list, (a,b)->a[0]-b[0]);
if (g[0][0] == 0) return -1;
int x = 0, y = 0, ans = 0;
for (int[] ne : list) {
int nx = ne[1], ny = ne[2];
int d = bfs(x, y, nx, ny);
if (d == -1) return -1;
ans += d;
x = nx; y = ny;
}
return ans;
}
int[][] dirs = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};
int bfs(int X, int Y, int P, int Q) {
if (X == P && Y == Q) return 0;
boolean[][] vis = new boolean[n][m];
Deque<int[]> d = new ArrayDeque<>();
d.addLast(new int[]{X, Y});
vis[X][Y] = true;
int ans = 0;
while (!d.isEmpty()) {
int size = d.size();
while (size-- > 0) {
int[] info = d.pollFirst();
int x = info[0], y = info[1];
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 0 || vis[nx][ny]) continue;
if (nx == P && ny == Q) return ans + 1;
d.addLast(new int[]{nx, ny});
vis[nx][ny] = true;
}
}
ans++;
}
return -1;
}
}
```
* 时间复杂度:预处理出所有树点的复杂度为 $O(n \times m)$,对树点进行排序的复杂度为 $O(nm \log{nm})$,最多有 $n \times m$ 个树点,对每两个相邻树点运用 `BFS` 求最短路的复杂度为 $O(n \times m)$,统计完整路径的复杂度为 $O(n^2 \times m^2)$
* 空间复杂度:$O(n \times m)$
---
### AStar 算法
**由于问题的本质是求最短路,同时原问题的边权为 $1$,因此套用其他复杂度比 `BFS` 高的最短路算法,对于本题而言是没有意义,但运用启发式搜索 AStar 算法来优化则是有意义。**
因为在 `BFS` 过程中,我们会无差别往「四联通」方向进行搜索,直到找到「当前树点的下一个目标位置」为止,而实际上,两点之间的最短路径往往与两点之间的相对位置相关。
举个 🌰,当前我们在位置 $S$,我们目标位置是 $T$,而 $T$ 在 $S$ 的右下方,此时我们应当优先搜索方向"往右下方"的路径,当无法从"往右下方"的路径到达 $T$,我们再考虑搜索其他大方向的路径:
如何设计这样带有优先级的搜索顺序,则是 AStar 算法「启发式函数」的设计过程,其本质是对应了对「最小步数」的估算,只有当我们确保「最小步数估算 $\leq $ 实际最小步数」,AStar 算法的正确性才得以保证。
因此我们往往会直接使用「理论最小步数」来作为启发式函数的,对于本题,可直接使用「曼哈顿距离」作为「理论最小步数」。
因此,如果我们是要从源点 $S$ 到汇点 $T$,并且当前位于中途点 $x$ 的话,点 $x$ 的最小步数估算包括两部分:**到点 $x$ 的实际步数 + 从点 $x$ 到点 $T$ 的理论最小步数(曼哈顿距离)**。使用「优先队列」按照「总的最小步数估算」进行出队,即可实现 AStar 算法的搜索顺序。
> **AStar 算法做过很多次了,相关合集可以在 [这里](https://sharingsource.github.io/tags/AStar-%E7%AE%97%E6%B3%95/) 看到。**
另外,网上很多对 AStar 正确性证明不了解的人,会缺少以下 `map.get(nidx) > step + 1` 判断逻辑。
简单来说,启发式函数的设计是针对汇点而言的,**因此 AStar 算法搜索过程只确保对 $T$ 的出入队次序能够对应回到点 $T$ 第 $k$ 短路,而对于其余点的出入队次序到其余点的最短路没有必然的对应关系,因此当某个点的最小步数被更新,我们是要将其进行再次入队的。**
代码:
```Java
class Solution {
int N = 50;
int[][] g = new int[N][N];
int n, m;
List<int[]> list = new ArrayList<>();
public int cutOffTree(List<List<Integer>> forest) {
n = forest.size(); m = forest.get(0).size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
g[i][j] = forest.get(i).get(j);
if (g[i][j] > 1) list.add(new int[]{g[i][j], i, j});
}
}
if (g[0][0] == 0) return -1;
Collections.sort(list, (a,b)->a[0]-b[0]);
int x = 0, y = 0, ans = 0;
for (int[] ne : list) {
int nx = ne[1], ny = ne[2];
int d = astar(x, y, nx, ny);
if (d == -1) return -1;
ans += d;
x = nx; y = ny;
}
return ans;
}
int[][] dirs = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};
int getIdx(int x, int y) {
return x * m + y;
}
int f(int X, int Y, int P, int Q) {
return Math.abs(X - P) + Math.abs(Y - Q);
}
int astar(int X, int Y, int P, int Q) {
if (X == P && Y == Q) return 0;
Map<Integer, Integer> map = new HashMap<>();
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]);
q.add(new int[]{f(X, Y, P, Q), X, Y});
map.put(getIdx(X, Y), 0);
while (!q.isEmpty()) {
int[] info = q.poll();
int x = info[1], y = info[2], step = map.get(getIdx(x, y));
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny);
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 0) continue;
if (nx == P && ny == Q) return step + 1;
if (!map.containsKey(nidx) || map.get(nidx) > step + 1) {
q.add(new int[]{step + 1 + f(nx, ny, P, Q), nx, ny});
map.put(nidx, step + 1);
}
}
}
return -1;
}
}
```
* 时间复杂度:启发式搜索分析时空复杂度意义不大
* 空间复杂度:启发式搜索分析时空复杂度意义不大
---
### AStar 算法 + 并查集预处理无解
我们知道,AStar 算法使用到了「优先队列(堆)」来进行启发式搜索,而对于一些最佳路径方向与两点相对位置相反(例如 $T$ 在 $S$ 的右边,但由于存在障碍,最短路径需要先从左边绕一圈才能到 $T$),AStar 反而会因为优先队列(堆)而多一个 $\log$ 的复杂度。
因此一个可行的优化是,我们先提前处理「无解」的情况,常见的做法是在预处理过程中运用「并查集」来维护连通性。
这种对于不影响复杂度上界的预处理相比后续可能出现的大量无效搜索(最终无解)的计算量而言,是有益的。
代码:
```Java
class Solution {
int N = 50;
int[][] g = new int[N][N];
int n, m;
int[] p = new int[N * N + 10];
List<int[]> list = new ArrayList<>();
void union(int a, int b) {
p[find(a)] = p[find(b)];
}
boolean query(int a, int b) {
return find(a) == find(b);
}
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int getIdx(int x, int y) {
return x * m + y;
}
public int cutOffTree(List<List<Integer>> forest) {
n = forest.size(); m = forest.get(0).size();
// 预处理过程中,同时使用「并查集」维护连通性
for (int i = 0; i < n * m; i++) p[i] = i;
int[][] tempDirs = new int[][]{{0,-1},{-1,0}};
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
g[i][j] = forest.get(i).get(j);
if (g[i][j] > 1) list.add(new int[]{g[i][j], i, j});
if (g[i][j] == 0) continue;
// 只与左方和上方的区域联通即可确保不重不漏
for (int[] di : tempDirs) {
int nx = i + di[0], ny = j + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] != 0) union(getIdx(i, j), getIdx(nx, ny));
}
}
}
// 若不满足所有树点均与 (0,0),提前返回无解
for (int[] info : list) {
int x = info[1], y = info[2];
if (!query(getIdx(0, 0), getIdx(x, y))) return -1;
}
Collections.sort(list, (a,b)->a[0]-b[0]);
int x = 0, y = 0, ans = 0;
for (int[] ne : list) {
int nx = ne[1], ny = ne[2];
int d = astar(x, y, nx, ny);
if (d == -1) return -1;
ans += d;
x = nx; y = ny;
}
return ans;
}
int f(int X, int Y, int P, int Q) {
return Math.abs(X - P) + Math.abs(Y - Q);
}
int[][] dirs = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};
int astar(int X, int Y, int P, int Q) {
if (X == P && Y == Q) return 0;
Map<Integer, Integer> map = new HashMap<>();
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]);
q.add(new int[]{f(X, Y, P, Q), X, Y});
map.put(getIdx(X, Y), 0);
while (!q.isEmpty()) {
int[] info = q.poll();
int x = info[1], y = info[2], step = map.get(getIdx(x, y));
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny);
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 0) continue;
if (nx == P && ny == Q) return step + 1;
if (!map.containsKey(nidx) || map.get(nidx) > step + 1) {
q.add(new int[]{step + 1 + f(nx, ny, P, Q), nx, ny});
map.put(nidx, step + 1);
}
}
}
return -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`,判定能否只将字符串中 一个 字母换成另一个字母,使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以,返回 `true`;否则,返回 `false`。
示例:
```
输入
["MagicDictionary", "buildDict", "search", "search", "search", "search"]
[[], [["hello", "leetcode"]], ["hello"], ["hhllo"], ["hell"], ["leetcoded"]]
输出
[null, null, false, true, false, false]
解释
MagicDictionary magicDictionary = new MagicDictionary();
magicDictionary.buildDict(["hello", "leetcode"]);
magicDictionary.search("hello"); // 返回 False
magicDictionary.search("hhllo"); // 将第二个 'h' 替换为 'e' 可以匹配 "hello" ,所以返回 True
magicDictionary.search("hell"); // 返回 False
magicDictionary.search("leetcoded"); // 返回 False
```
提示:
* $1 <= dictionary.length <= 100$
* $1 <= dictionary[i].length <= 100$
* `dictionary[i]` 仅由小写英文字母组成
* `dictionary` 中的所有字符串 互不相同
* $1 <= searchWord.length <= 100$
* `searchWord` 仅由小写英文字母组成
* `buildDict` 仅在 `search` 之前调用一次
* 最多调用 $100$ 次 `search` | ### 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` 为当前搜索到字典树的索引编号(起始有 $p = 0$),`limit` 为当前剩余的替换字符次数,根据题意,`limit` 固定为 $1$,含义为必须替换掉 `s` 的一个字符。
对于 $s[idx]$ 而言,我们可以枚举新字符串在当前位置是何种字符($C = 26$ 个选择),若当前枚举到的字符与 $s[idx]$ 一致,则不消耗替换次数。
爆搜过程中替换次数为负数直接剪枝,当爆搜到结尾位置,再检查当前的字典树索引 $p$ 是否为单词结尾节点(对应查询数组 `ss` 中是否存在该字符串),以及剩余的替换次数 `limit` 是否为 $0$。
> **不了解「Trie / 字典树」的同学可以看前置 🧀:[字典树入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)。里面通过图例展示了字典树基本形态,以及提供了「数组实现」和「TrieNode 实现」两种方式,还有「数组大小估算方式」和「Trie 应用面」介绍**
Java 代码:
```Java
class MagicDictionary {
int N = 100 * 100, M = 26, idx = 0;
int[][] tr = new int[N][M];
boolean[] isEnd = new boolean[N * M];
void add(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isEnd[p] = true;
}
boolean query(String s, int idx, int p, int limit) {
if (limit < 0) return false;
if (idx == s.length()) return isEnd[p] && limit == 0;
int u = s.charAt(idx) - 'a';
for (int i = 0; i < 26; i++) {
if (tr[p][i] == 0) continue;
if (query(s, idx + 1, tr[p][i], i == u ? limit : limit - 1)) return true;
}
return false;
}
public void buildDict(String[] ss) {
for (String s : ss) add(s);
}
public boolean search(String s) {
return query(s, 0, 0, 1);
}
}
```
TypeScript 代码:
```TypeScript
class MagicDictionary {
N: number = 100 * 100; M: number = 26; idx: number = 0;
tr: number[][] = new Array<Array<number>>(this.N)
isEnd: boolean[] = new Array<boolean>(this.N * this.M).fill(false)
add(s: string): void {
let p = 0
for (let i = 0; i < s.length; i++) {
const u = s.charCodeAt(i) - 'a'.charCodeAt(0)
if (this.tr[p] == undefined) this.tr[p] = new Array<number>(this.M).fill(0)
if (this.tr[p][u] == 0) this.tr[p][u] = ++this.idx
p = this.tr[p][u]
}
this.isEnd[p] = true
}
query(s: string, idx: number, p: number, limit: number): boolean {
if (limit < 0) return false
if (idx == s.length) return this.isEnd[p] && limit == 0
const u = s.charCodeAt(idx) - 'a'.charCodeAt(0)
for (let i = 0; i < 26; i++) {
if (this.tr[p] == undefined || this.tr[p][i] == 0) continue
if (this.query(s, idx + 1, this.tr[p][i], i == u ? limit : limit - 1)) return true
}
return false
}
buildDict(ss: string[]): void {
for (const s of ss) this.add(s)
}
search(s: string): boolean {
return this.query(s, 0, 0, 1)
}
}
```
* 时间复杂度:`buildDict` 操作需要将所有字符存入 `Trie`,复杂度为 $\sum_{i = 0}^{n - 1} len(ss[i]])$;`search` 操作在不考虑 `limit` 以及字典树中最多只有 $100$ 具体方案所带来的剪枝效果的话,最坏情况下要搜索所有 $C^L$ 个方案,其中 $C = 26$ 为字符集大小,$L = 100$ 为搜索字符串的最大长度
* 空间复杂度:$O(N \times L \times C)$,其中 $N = 100$ 为存入 `Trie` 的最大方案数,$L = 100$ 为存入字符串的最大长度,$C = 26$ 为字符集大小
---
### 模拟
当然,利用数据范围只有 $100$,直接使用模拟也是可以的。
Java 代码:
```Java
class MagicDictionary {
String[] ss;
public void buildDict(String[] _ss) {
ss = _ss;
}
public boolean search(String str) {
for (String s : ss) {
int cnt = 0;
for (int i = 0; s.length() == str.length() && i < s.length() && cnt <= 1; i++) {
if (s.charAt(i) != str.charAt(i)) cnt++;
}
if (cnt == 1) return true;
}
return false;
}
}
```
TypeScript 代码:
```TypeScript
class MagicDictionary {
ss: string[]
buildDict(_ss: string[]): void {
this.ss = _ss
}
search(s: string): boolean {
for (const str of this.ss) {
let cnt = 0
for (let i = 0; str.length == s.length && i < s.length && cnt <= 1; i++) {
if (s.charAt(i) != str.charAt(i)) cnt++
}
if (cnt == 1) return true
}
return false
}
}
```
* 时间复杂度:`buildDict` 操作复杂度为 $O(1)$;`search` 操作复杂度为 $O(n \times L)$,其中 $n$ 为数组 `ss` 的长度,$L$ 为查询字符串的长度
* 空间复杂度:$O(n)$
---
### 加餐
1. 前置练习题 [可用 Trie 进阶的模拟题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492214&idx=1&sn=40fa070fe3b014873297f7ff740ba60f)
2. 另外一道 [结合 DFS 的 Trie 运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492188&idx=1&sn=a1436d1ffe2b8200a36c3196ca1c7ed1) | ### 最后
这是我们「刷穿 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", 3], ["ap"], ["app", 2], ["ap"]]
输出:
[null, null, 3, null, 5]
解释:
MapSum mapSum = new MapSum();
mapSum.insert("apple", 3);
mapSum.sum("ap"); // return 3 (apple = 3)
mapSum.insert("app", 2);
mapSum.sum("ap"); // return 5 (apple + app = 3 + 2 = 5)
```
提示:
* $1 <= key.length, prefix.length <= 50$
* `key` 和 `prefix` 仅由小写英文字母组成
* `1 <= val <= 1000`
* 最多调用 `50` 次 `insert` 和 `sum` | ### Trie + DFS
从需要实现「存储字符串(映射关系)」并「检索某个字符串前缀的总和」来看,可以知道这是与 $Trie$ 相关的题目,还不了解 $Trie$ 的同学可以先看前置 🧀:[实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=59039721&lang=zh_CN#rd) 。
考虑如何实现两个操作:
* `insert` :在基本的 $Trie$ 插入操作的基础上进行拓展即可。与常规的插入操作的唯一区别为,不能简单记录单词的结束位置,还要存储 $key$ 对应的 $val$ 是多少。具体的我们可以使用 `int` 类型的数组 $hash$ 来代替原有的 `boolean` 类型的数组 $isWord$;
* `sum` : 先对入参 $prefix$ 进行字典树搜索,到达尾部后再使用 `DFS` 搜索后面的所有方案,并累加结果。
代码(`static` 优化代码见 $P2$,避免每个样例都 `new` 大数组):
```Java
class MapSum {
int[][] tr = new int[2510][26];
int[] hash = new int[2510];
int idx;
public void insert(String key, int val) {
int p = 0;
for (int i = 0; i < key.length(); i++) {
int u = key.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
hash[p] = val;
}
public int sum(String prefix) {
int p = 0;
for (int i = 0; i < prefix.length(); i++) {
int u = prefix.charAt(i) - 'a';
if (tr[p][u] == 0) return 0;
p = tr[p][u];
}
return dfs(p);
}
int dfs(int p) {
int ans = hash[p];
for (int u = 0; u < 26; u++) {
if (tr[p][u] != 0) ans += dfs(tr[p][u]);
}
return ans;
}
}
```
```Java
class MapSum {
static int[][] tr = new int[2510][26];
static int[] hash = new int[2510];
static int idx;
public MapSum() {
for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);
Arrays.fill(hash, 0);
idx = 0;
}
public void insert(String key, int val) {
int p = 0;
for (int i = 0; i < key.length(); i++) {
int u = key.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
hash[p] = val;
}
public int sum(String prefix) {
int p = 0;
for (int i = 0; i < prefix.length(); i++) {
int u = prefix.charAt(i) - 'a';
if (tr[p][u] == 0) return 0;
p = tr[p][u];
}
return dfs(p);
}
int dfs(int p) {
int ans = hash[p];
for (int u = 0; u < 26; u++) {
if (tr[p][u] != 0) ans += dfs(tr[p][u]);
}
return ans;
}
}
```
* 时间复杂度:令 $key$ 的最大长度为 $n$,最大调用次数为 $m$,字符集大小为 $C$( 本题 $C$ 固定为 $26$ ),`insert` 操作的复杂度为 $O(n)$;从 `DFS` 的角度分析,`sum` 操作的复杂度为 $O(C^n)$,但事实上,对于本题具有明确的计算量上界,搜索所有的格子的复杂度为 $O(n \times m \times C)$
* 空间复杂度:$O(n \times m \times C)$
---
### Trie 记录前缀字符串总和
为降低 `sum` 操作的复杂度,我们可以在 `insert` 操作中同时记录(累加)每个前缀的总和。
代码(`static` 优化代码见 $P2$,避免每个样例都 `new` 大数组):
```Java
class MapSum {
int N = 2510;
int[][] tr = new int[N][26];
int[] hash = new int[N];
int idx;
Map<String, Integer> map = new HashMap<>();
public void insert(String key, int val) {
int _val = val;
if (map.containsKey(key)) val -= map.get(key);
map.put(key, _val);
for (int i = 0, p = 0; i < key.length(); i++) {
int u = key.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
hash[p] += val;
}
}
public int sum(String prefix) {
int p = 0;
for (int i = 0; i < prefix.length(); i++) {
int u = prefix.charAt(i) - 'a';
if (tr[p][u] == 0) return 0;
p = tr[p][u];
}
return hash[p];
}
}
```
```Java
class MapSum {
static int N = 2510;
static int[][] tr = new int[N][26];
static int[] hash = new int[N];
static int idx;
static Map<String, Integer> map = new HashMap<>();
public MapSum() {
for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);
Arrays.fill(hash, 0);
idx = 0;
map.clear();
}
public void insert(String key, int val) {
int _val = val;
if (map.containsKey(key)) val -= map.get(key);
map.put(key, _val);
for (int i = 0, p = 0; i < key.length(); i++) {
int u = key.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
hash[p] += val;
}
}
public int sum(String prefix) {
int p = 0;
for (int i = 0; i < prefix.length(); i++) {
int u = prefix.charAt(i) - 'a';
if (tr[p][u] == 0) return 0;
p = tr[p][u];
}
return hash[p];
}
}
```
* 时间复杂度:令 $key$ 的最大长度为 $n$,`insert` 操作的复杂度为 $O(n)$;`sum` 操作的复杂度为 $O(n)$
* 空间复杂度:令 $key$ 的最大长度为 $n$,最大调用次数为 $m$,字符集大小为 $C$( 本题 $C$ 固定为 $26$ ),复杂度为 $O(n \times m \times C)$ | ### 最后
这是我们「刷穿 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
```
注意:
* 字符串大小将在 $[1,100]$ 范围内。 | ### 动态规划
**定义 $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$,反之亦然。即有 $f[i][j] = f[i - 1][j + 1]$;
* 当前字符为 `*` : 根据 `*` 代指的符号不同,分为三种情况,只有有一种情况为 $true$ 即可。即有 $f[i][j] = f[i - 1][j - 1] ∨ f[i - 1][j + 1] ∨ f[i - 1][j]$。
代码:
```Java
class Solution {
public boolean checkValidString(String s) {
int n = s.length();
boolean[][] f = new boolean[n + 1][n + 1];
f[0][0] = true;
for (int i = 1; i <= n; i++) {
char c = s.charAt(i - 1);
for (int j = 0; j <= i; j++) {
if (c == '(') {
if (j - 1 >= 0) f[i][j] = f[i - 1][j - 1];
} else if (c == ')') {
if (j + 1 <= i) f[i][j] = f[i - 1][j + 1];
} else {
f[i][j] = f[i - 1][j];
if (j - 1 >= 0) f[i][j] |= f[i - 1][j - 1];
if (j + 1 <= i) f[i][j] |= f[i - 1][j + 1];
}
}
}
return f[n][0];
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 模拟
通过解法一,我们进一步发现,对于某个 $f[i][x]$ 而言(即动规数组中的某一行),值为 $true$ 的必然为连续一段。
即 **由于存在可变化的 `*` 符号,因此考虑在考虑前 $i$ 个字符,其能与消耗的左括号的数量具有明确的「上界与下界」。且当前上界与下界的变化,仅取决于「当前为何种字符」,以及「处理上一个字符时上界与下界为多少」。**
但直接记录所能消耗的左括号上限和下限需要处理较多的边界问题。
我们可以使用与[(题解)301. 删除无效的括号](https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/yi-fen-zhong-nei-kan-dong-jiang-gua-hao-aya6k/) 类似的思路:
令左括号的得分为 $1$;右括号的得分为 $-1$。那么对于合法的方案而言,必定满足最终得分为 $0$。
同时由于本题存在 `*`,因此我们需要记录得分的区间区间是多少,而不仅是一个具体的得分。
具体的,使用两个变量 `l` 和 `r` 分别表示「最低得分」和「最高得分」。
根据当前处理到的字符进行分情况讨论:
* 当前字符为 `(` : `l` 和 `r` 同时加一;
* 当前字符为 `)` : `l` 和 `r` 同时减一;
* 当前字符为 `*` : 如果 `*` 代指成 `(` 的话,`l` 和 `r` 都进行加一;如果 `*` 代指成 `)` 的话,`l` 和 `r` 都进行减一;如果 `*` 不变的话,`l` 和 `r` 均不发生变化。因此总的 `l` 的变化为减一,总的 `r` 的变化为加一。
需要注意的是,在匹配过程中如果 `l` 为负数,需要重置为 $0$,因为如果当前序列本身为不合法括号序列的话,增加 `(` 必然还是不合法。同时,当出现 `l > r` 说明上界为负数,即右括号过多,必然为非合法方案,返回 $false$。
代码:
```Java
class Solution {
public boolean checkValidString(String s) {
int l = 0, r = 0;
for (char c : s.toCharArray()) {
if (c == '(') {
l++; r++;
} else if (c == ')') {
l--; r--;
} else {
l--; r++;
}
l = Math.max(l, 0);
if (l > r) return false;
}
return l == 0;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 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"` - 表示前一次得分无效,将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。
请你返回记录中所有得分的总和。
示例 1:
```
输入:ops = ["5","2","C","D","+"]
输出:30
解释:
"5" - 记录加 5 ,记录现在是 [5]
"2" - 记录加 2 ,记录现在是 [5, 2]
"C" - 使前一次得分的记录无效并将其移除,记录现在是 [5].
"D" - 记录加 2 * 5 = 10 ,记录现在是 [5, 10].
"+" - 记录加 5 + 10 = 15 ,记录现在是 [5, 10, 15].
所有得分的总和 5 + 10 + 15 = 30
```
示例 2:
```
输入:ops = ["5","-2","4","C","D","9","+","+"]
输出:27
解释:
"5" - 记录加 5 ,记录现在是 [5]
"-2" - 记录加 -2 ,记录现在是 [5, -2]
"4" - 记录加 4 ,记录现在是 [5, -2, 4]
"C" - 使前一次得分的记录无效并将其移除,记录现在是 [5, -2]
"D" - 记录加 2 * -2 = -4 ,记录现在是 [5, -2, -4]
"9" - 记录加 9 ,记录现在是 [5, -2, -4, 9]
"+" - 记录加 -4 + 9 = 5 ,记录现在是 [5, -2, -4, 9, 5]
"+" - 记录加 9 + 5 = 14 ,记录现在是 [5, -2, -4, 9, 5, 14]
所有得分的总和 5 + -2 + -4 + 9 + 5 + 14 = 27
```
示例 3:
```
输入:ops = ["1"]
输出:1
```
提示:
* $1 <= ops.length <= 1000$
* $ops[i]$ 为 `"C"`、`"D"`、`"+"`,或者一个表示整数的字符串。整数范围是 $[-3 * 10^4, 3 * 10^4]$
* 对于 `"+"` 操作,题目数据保证记录此操作时前面总是存在两个有效的分数
* 对于 `"C"` 和 `"D"` 操作,题目数据保证记录此操作时前面总是存在一个有效的分数 | ### 模拟
根据题意进行模拟即可。
代码:
```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[i].equals("D")) nums[idx] = nums[idx - 1] * 2;
else if (ops[i].equals("C")) idx -= 2;
else nums[idx] = Integer.parseInt(ops[i]);
}
int ans = 0;
for (int i = 0; i < idx; i++) ans += nums[i];
return ans;
}
}
```
```python
nums = [0] * 1010
class Solution:
def calPoints(self, ops: List[str]) -> int:
idx = 0
for x in ops:
if x == '+':
nums[idx] = nums[idx - 1] + nums[idx - 2]
elif x == 'D':
nums[idx] = nums[idx - 1] * 2
elif x == 'C':
idx -= 2
else:
nums[idx] = int(x)
idx += 1
return sum(nums[:idx])
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 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"
输出:1
```
示例 4:
```
输入:a = "abc", b = "wxyz"
输出:-1
```
提示:
* $1 <= a.length <= 10^4$
* $1 <= b.length <= 10^4$
* `a` 和 `b` 由小写英文字母组成 | ### 基本分析
首先,可以分析复制次数的「下界」和「上界」为何值:
**对于「下界」的分析是容易的:至少将 `a` 复制长度大于等于 `b` 的长度,才有可能匹配。**
在明确了「下界」后,再分析再经过多少次复制,能够明确得到答案,能够得到明确答案的最小复制次数即是上界。
**由于主串是由 `a` 复制多次而来,并且是从主串中找到子串 `b`,因此可以明确子串的起始位置,不会超过 `a` 的长度。**
即**长度越过 `a` 长度的起始匹配位置,必然在此前已经被匹配过了。**
由此,我们可知复制次数「上界」最多为「下界 + $1$」。
令 `a` 的长度为 $n$,`b` 的长度为 $m$,下界次数为 $c1$,上界次数为 $c2 = c1 + 1$。
因此我们可以对 `a` 复制 $c2$ 次,得到主串后匹配 `b`,如果匹配成功后的结束位置不超过了 $n * c1$,说明复制 $c1$ 即可,返回 $c1$,超过则返回 $c2$;匹配不成功则返回 $-1$。
---
### 卡常
这是我最开始的 AC 版本。
虽然这是道挺显然的子串匹配问题,但是昨晚比平时晚睡了一个多小时,早上起来精神状态不是很好,身体的每个细胞都在拒绝写 KMP 🤣
就动了歪脑筋写了个「卡常」做法。
通过该做法再次印证了 LC 的评测机制十分奇葩:居然不是对每个用例单独计时,也不是算总的用例用时,而是既算单用例耗时,又算总用时??
导致我直接 `TLE` 了 $6$ 次才通过(从 $700$ 试到了 $100$),其中有 $4$ 次 `TLE` 是显示通过了所有样例,但仍然 `TLE`,我不理解为什么要设置这样迷惑的机制。
回到该做法本身,首先对 `a` 进行复制确保长度大于等于 `b`,然后在一定时间内,不断的「复制 - 检查」,如果在规定时间内能够找到则返回复制次数,否则返回 `-1`。
代码:
```Java
import java.time.Clock;
class Solution {
public int repeatedStringMatch(String a, String b) {
StringBuilder sb = new StringBuilder();
int ans = 0;
while (sb.length() < b.length() && ++ans > 0) sb.append(a);
Clock clock = Clock.systemDefaultZone();
long start = clock.millis();
while (clock.millis() - start < 100) {
if (sb.indexOf(b) != -1) return ans;
sb.append(a);
ans++;
}
return -1;
}
}
```
* 时间复杂度:$O(C)$
* 空间复杂度:$O(C)$
---
### 上下界性质
通过「基本分析」后,我们发现「上下界」具有准确的大小关系,其实不需要用到「卡常」做法。
只需要进行「上界」次复制后,尝试匹配,根据匹配结果返回答案即可。
代码:
```Java
class Solution {
public int repeatedStringMatch(String a, String b) {
StringBuilder sb = new StringBuilder();
int ans = 0;
while (sb.length() < b.length() && ++ans > 0) sb.append(a);
sb.append(a);
int idx = sb.indexOf(b);
if (idx == -1) return -1;
return idx + b.length() > a.length() * ans ? ans + 1 : ans;
}
}
```
* 时间复杂度:需要 $\left \lceil \frac{m}{n} \right \rceil + 1$ 次拷贝 和 一次子串匹配。复杂度为 $O(n * (\left \lceil \frac{m}{n} \right \rceil + 1))$
* 空间复杂度:$O(n * (\left \lceil \frac{m}{n} \right \rceil + 1))$
---
### KMP
其中 `indexOf` 部分可以通过 KMP/字符串哈希 实现,不熟悉 KMP 的同学,可以查看 [一文详解 KMP 算法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486317&idx=1&sn=9c2ff2fa5db427133cce9c875064e7a4&chksm=fd9ca072caeb29642bf1f5c151e4d5aaff4dc10ba408b23222ea1672cfc41204a584fede5c05&token=1782709324&lang=zh_CN#rd),里面通过大量配图讲解了 KMP 的匹配过程与提供了实用模板。
使用 KMP 代替 `indexOf` 可以有效利用主串是由多个 `a` 复制而来的性质。
代码:
```Java
class Solution {
public int repeatedStringMatch(String a, String b) {
StringBuilder sb = new StringBuilder();
int ans = 0;
while (sb.length() < b.length() && ++ans > 0) sb.append(a);
sb.append(a);
int idx = strStr(sb.toString(), b);
if (idx == -1) return -1;
return idx + b.length() > a.length() * ans ? ans + 1 : ans;
}
int strStr(String ss, String pp) {
if (pp.isEmpty()) return 0;
// 分别读取原串和匹配串的长度
int n = ss.length(), m = pp.length();
// 原串和匹配串前面都加空格,使其下标从 1 开始
ss = " " + ss;
pp = " " + pp;
char[] s = ss.toCharArray();
char[] p = pp.toCharArray();
// 构建 next 数组,数组长度为匹配串的长度(next 数组是和匹配串相关的)
int[] next = new int[m + 1];
// 构造过程 i = 2,j = 0 开始,i 小于等于匹配串长度 【构造 i 从 2 开始】
for (int i = 2, j = 0; i <= m; i++) {
// 匹配不成功的话,j = next(j)
while (j > 0 && p[i] != p[j + 1]) j = next[j];
// 匹配成功的话,先让 j++
if (p[i] == p[j + 1]) j++;
// 更新 next[i],结束本次循环,i++
next[i] = j;
}
// 匹配过程,i = 1,j = 0 开始,i 小于等于原串长度 【匹配 i 从 1 开始】
for (int i = 1, j = 0; i <= n; i++) {
// 匹配不成功 j = next(j)
while (j > 0 && s[i] != p[j + 1]) j = next[j];
// 匹配成功的话,先让 j++,结束本次循环后 i++
if (s[i] == p[j + 1]) j++;
// 整一段匹配成功,直接返回下标
if (j == m) return i - m;
}
return -1;
}
}
```
* 时间复杂度:需要 $\left \lceil \frac{m}{n} \right \rceil + 1$ 次拷贝 和 一次子串匹配。复杂度为 $O(n * (\left \lceil \frac{m}{n} \right \rceil + 1))$
* 空间复杂度:$O(n * (\left \lceil \frac{m}{n} \right \rceil + 1))$
---
### 字符串哈希
结合「基本分析」,我们知道这本质是一个子串匹配问题,我们可以使用「字符串哈希」来解决。
令 `a` 的长度为 $n$,`b` 的长度为 $m$。
仍然是先将 `a` 复制「上界」次,得到主串 `ss`,目的是从 `ss` 中检测是否存在子串为 `b`。
在字符串哈希中,为了方便,我们将 `ss` 和 `b` 进行拼接,设拼接后长度为 $len$,那么 `b` 串的哈希值为 $[len - m + 1, len]$ 部分(下标从 $1$ 开始),记为 $target$。
然后在 $[1, n]$ 范围内枚举起点,尝试找长度为 $m$ 的哈希值与 $target$ 相同的哈希值。
代码:
```Java
class Solution {
public int repeatedStringMatch(String a, String b) {
StringBuilder sb = new StringBuilder();
int ans = 0;
while (sb.length() < b.length() && ++ans > 0) sb.append(a);
sb.append(a);
int idx = strHash(sb.toString(), b);
if (idx == -1) return -1;
return idx + b.length() > a.length() * ans ? ans + 1 : ans;
}
int strHash(String ss, String b) {
int P = 131;
int n = ss.length(), m = b.length();
String str = ss + b;
int len = str.length();
int[] h = new int[len + 10], p = new int[len + 10];
h[0] = 0; p[0] = 1;
for (int i = 0; i < len; i++) {
p[i + 1] = p[i] * P;
h[i + 1] = h[i] * P + str.charAt(i);
}
int r = len, l = r - m + 1;
int target = h[r] - h[l - 1] * p[r - l + 1]; // b 的哈希值
for (int i = 1; i <= n; i++) {
int j = i + m - 1;
int cur = h[j] - h[i - 1] * p[j - i + 1]; // 子串哈希值
if (cur == target) return i - 1;
}
return -1;
}
}
```
* 时间复杂度:需要 $\left \lceil \frac{m}{n} \right \rceil + 1$ 次拷贝 和 一次子串匹配。复杂度为 $O(n * (\left \lceil \frac{m}{n} \right \rceil + 1))$
* 空间复杂度:$O(n * (\left \lceil \frac{m}{n} \right \rceil + 1))$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.686` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
Subsets and Splits