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/681-690/687. 最长同值路径（中等）.md | 687. 最长同值路径 | https://leetcode.cn/problems/longest-univalue-path/solution/by-ac_oier-8ue8/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给定一个二叉树的 `root`,返回 最长的路径的长度 ,这个路径中的 每个节点具有相同值 。 这条路径可以经过也可以不经过根节点。
两个节点之间的路径长度 由它们之间的边数表示。
示例 1:
```
输入:root = [5,4,5,1,1,5]
输出:2
```
示例 2:
```
输入:root = [1,4,5,4,4,5]
输出:2
```
提示:
* 树的节点数的范围是 $[0, 10^4] $
* $-1000 <= Node.val <= 1000$
* 树的深度将不超过 `1000` | ### 递归
设计递归函数 `int dfs(TreeNode root)`,含义为传入根节点 `root`,返回以该节点为起点,往下走同值路径所能经过的最大路径长度(即不能同时往左右节点走),同时使用全局变量 `max` 记录答案路径所能经过最大路径长度。
在递归函数内部,先通过递归 `root` 的左右子节点,拿到以 `root.left` 和 `root.right` 为起点的最大路径长度 `l` 和 `r`,然后根据当前节点值和左右子节点值的相等关系来更新 `ans`,同时用 `cur` 维护「以当前节点 `root` 为目标路径中深度最小(位置最高)节点时」所经过的最大路径长度。
Java 代码:
```Java
class Solution {
int max = 0;
public int longestUnivaluePath(TreeNode root) {
dfs(root);
return max;
}
int dfs(TreeNode root) {
if (root == null) return 0;
int ans = 0, cur = 0, l = dfs(root.left), r = dfs(root.right);
if (root.left != null && root.left.val == root.val) {
ans = l + 1; cur += l + 1;
}
if (root.right != null && root.right.val == root.val) {
ans = Math.max(ans, r + 1); cur += r + 1;
}
max = Math.max(max, cur);
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxv = 0;
int dfs(TreeNode* root) {
if (root == nullptr) return 0;
int ans = 0, cur = 0;
int l = dfs(root->left), r = dfs(root->right);
if (root->left != nullptr && root->left->val == root->val) {
ans = l + 1; cur += l + 1;
}
if (root->right != nullptr && root->right->val == root->val) {
ans = max(ans, r + 1); cur += r + 1;
}
maxv = max(maxv, cur);
return ans;
}
int longestUnivaluePath(TreeNode* root) {
dfs(root);
return maxv;
}
};
```
Python 代码:
```Python
class Solution:
def longestUnivaluePath(self, root: Optional[TreeNode]) -> int:
maxv = 0
def dfs(root):
nonlocal maxv
if not root: return 0
ans, cur = 0, 0
l, r = dfs(root.left), dfs(root.right)
if root.left and root.left.val == root.val:
ans = l + 1
cur += l + 1
if root.right and root.right.val == root.val:
ans = max(ans, r + 1)
cur += r + 1
maxv = max(maxv, cur)
return ans
dfs(root)
return maxv
```
TypeScript 代码:
```TypeScript
let max = 0;
function longestUnivaluePath(root: TreeNode | null): number {
max = 0
dfs(root)
return max
};
function dfs(root: TreeNode | null): number {
if (root == null) return 0
let ans = 0, cur = 0, l = dfs(root.left), r = dfs(root.right)
if (root.left != null && root.left.val == root.val) {
ans = l + 1; cur += l + 1
}
if (root.right != null && root.right.val == root.val) {
ans = Math.max(ans, r + 1); cur += r + 1
}
max = Math.max(max, cur)
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.687` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/688. 骑士在棋盘上的概率（中等）.md | 688. 骑士在棋盘上的概率 | https://leetcode-cn.com/problems/knight-probability-in-chessboard/solution/gong-shui-san-xie-jian-dan-qu-jian-dp-yu-st8l/ | 中等 | [
"线性 DP"
] | 在一个 $n \times n$ 的国际象棋棋盘上,一个骑士从单元格 $(row, column)$ 开始,并尝试进行 $k$ 次移动。行和列是 从 $0$ 开始 的,所以左上单元格是 $(0,0)$ ,右下单元格是 $(n - 1, n - 1)$ 。
象棋骑士有 $8$ 种可能的走法,如下图所示。每次移动在基本方向上是两个单元格,然后在正交方向上是一个单元格。
每次骑士要移动时,它都会随机从 $8$ 种可能的移动中选择一种(即使棋子会离开棋盘),然后移动到那里。
骑士继续移动,直到它走了 $k$ 步或离开了棋盘。
返回 骑士在棋盘停止移动后仍留在棋盘上的概率 。
示例 1:
```
输入: n = 3, k = 2, row = 0, column = 0
输出: 0.0625
解释: 有两步(到(1,2),(2,1))可以让骑士留在棋盘上。
在每一个位置上,也有两种移动可以让骑士留在棋盘上。
骑士留在棋盘上的总概率是0.0625。
```
示例 2:
```
输入: n = 1, k = 0, row = 0, column = 0
输出: 1.00000
```
提示:
* $1 <= n <= 25$
* $0 <= k <= 100$
* $0 <= row, column <= n$ | ### 线性 DP
**定义 $f[i][j][p]$ 为从位置 $(i, j)$ 出发,使用步数不超过 $p$ 步,最后仍在棋盘内的概率。**
不失一般性考虑 $f[i][j][p]$ 该如何转移,根据题意,移动规则为「八连通」,对下一步的落点 $(nx, ny)$ 进行分情况讨论即可:
* 由于计算的是仍在棋盘内的概率,因此对于 $(nx, ny)$ 在棋盘外的情况,无须考虑;
* 若下一步的落点 $(nx, ny)$ 在棋盘内,其剩余可用步数为 $p - 1$,则最后仍在棋盘的概率为 $f[nx][ny][p - 1]$,则落点 $(nx, ny)$ 对 $f[i][j][p]$ 的贡献为 $f[nx][ny][p - 1] \times \frac{1}{8}$,其中 $\frac{1}{8}$ 为事件「**从 $(i, j)$ 走到 $(nx, ny)$**」的概率(八连通移动等概率发生),该事件与「**到达 $(nx, ny)$ 后进行后续移动并留在棋盘**」为相互独立事件。
最终的 $f[i][j][p]$ 为「八连通」落点的概率之和,即有:
$$
f[i][j][p] = \sum {f[nx][ny][p - 1] \times \frac{1}{8}}
$$
代码:
```Java
class Solution {
int[][] dirs = new int[][]{{-1,-2},{-1,2},{1,-2},{1,2},{-2,1},{-2,-1},{2,1},{2,-1}};
public double knightProbability(int n, int k, int row, int column) {
double[][][] f = new double[n][n][k + 1];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
f[i][j][0] = 1;
}
}
for (int p = 1; p <= k; p++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int[] d : dirs) {
int nx = i + d[0], ny = j + d[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
f[i][j][p] += f[nx][ny][p - 1] / 8;
}
}
}
}
return f[row][column][k];
}
}
```
* 时间复杂度:令某个位置可联通的格子数量 $C = 8$,复杂度为 $O(n^2 \times k \times C)$
* 空间复杂度:$O(n^2 \times k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.688` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/689. 三个无重叠子数组的最大和（困难）.md | 689. 三个无重叠子数组的最大和 | https://leetcode-cn.com/problems/maximum-sum-of-3-non-overlapping-subarrays/solution/gong-shui-san-xie-jie-he-qian-zhui-he-de-ancx/ | 困难 | [
"序列 DP",
"前缀和"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,找出三个长度为 `k` 、互不重叠、且 `3 * k` 项的和最大的子数组,并返回这三个子数组。
以下标的数组形式返回结果,数组中的每一项分别指示每个子数组的起始位置(下标从 $0$ 开始)。如果有多个结果,返回字典序最小的一个。
示例 1:
```
输入:nums = [1,2,1,2,6,7,5,1], k = 2
输出:[0,3,5]
解释:子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。
也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。
```
示例 2:
```
输入:nums = [1,2,1,2,1,2,1,2,1], k = 2
输出:[0,2,4]
```
提示:
* $1 <= nums.length <= 2 * 10^4$
* $1 <= nums[i] < 2^{16}$
* $1 <= k <= floor(nums.length / 3)$ | ### 前缀和 + 序列 DP
若不考虑输出方案,仅是求「三个无重叠子数组的最大和」的最大值。
只需要使用动态规划求解即可:**定义 $f[i][j]$ 为考虑前 $i$ 个数,凑成无重叠子数组数量为 $j$ 个时的最大值。**
最终答案为 $f[n - 1][3]$。
不失一般性的考虑 $f[i][j]$ 该如何计算(以最优方案是否包含 $nums[i]$ 进行讨论):
* 最优方案中包含 $num[i]$:由于这 $j$ 个无重叠,因此前面的 $j - 1$ 个子数组不能覆盖 $[i - k + 1, i]$。即只能在 $[0, i - k]$ 中选 $j - 1$ 个子数组。此时有:
$$
f[i][j] = f[i - k][j - 1] + \sum_{idx = i - k + 1}^{i} nums[idx]
$$
> 其中求解 $\sum_{idx = i - k + 1}^{i} nums[idx]$ 部分可以使用「前缀和」优化
* 最优方案不包含 $num[i]$:当明确了 $nums[i]$ 对最优方案无贡献,此时问题等价于考虑前 $i - 1$ 个数,凑成 $j$ 个不重叠子数组的最大值。此时有:
$$
f[i][j] = f[i - 1][j]
$$
最终 $f[i][j]$ 为上述两种方案中的最大值。
然后考虑「如何回溯出字典序最小的具体方案」,常规的回溯具体方案的做法是,从最终答案 $f[n - 1][3]$ 开始往回追溯。
利用 $f[n - 1][3]$ 仅由两个可能的节点($f[n - 2][3]$ 和 $f[n - 1 - k][2]$)转移而来,通过判断 $f[n - 1][3]$ 等于 $f[n - 2][3]$ 还是 $f[n - 1 - k][2] + \sum_{idx = n - k }^{n - 1} nums[idx]$ 来决定回溯点为何值。
但该做法只能确保回溯出字典序最大的方案是正确(当两个可能的前驱节点都能转移到 $f[i][j]$ 时优先采纳靠后的位置),而我们需要回溯出字典序最小的方案。
在上述解法的基础上,有两种「求解字典序最小具体方案」的做法:
1. 将正序 DP 调整为反序 DP。修改状态定义为 $f[i][j]$ 为考虑 $[i, n - 1]$ 中进行选择,凑出无重叠子数组数量为 $j$ 个时的最大值(最终答案为 $f[0][3]$)。转移过程分析同理,然后从下标 $idx = 0$ 开始进行回溯,优先采纳 $idx$ 小的方案即可;
2. 仍然采取正序 DP 的做法,但对原数组进行翻转,从而将回溯「字典序最大」转换为「字典序最小」具体方案。
> 一些细节:为了避免对边界的处理,我们令动规数组 $f$ 和前缀和数组 $sun$ 的下标从 $1$ 开始。
代码($P1$ 为反序 DP 做法,$P2$ 为翻转数组做法):
```Java
class Solution {
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
int n = nums.length;
long[] sum = new long[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
long[][] f = new long[n + 10][4];
for (int i = n - k + 1; i >= 1; i--) {
for (int j = 1; j < 4; j++) {
f[i][j] = Math.max(f[i + 1][j], f[i + k][j - 1] + sum[i + k - 1] - sum[i - 1]);
}
}
int[] ans = new int[3];
int i = 1, j = 3, idx = 0;
while (j > 0) {
if (f[i + 1][j] > f[i + k][j - 1] + sum[i + k - 1] - sum[i - 1]) {
i++;
} else {
ans[idx++] = i - 1;
i += k; j--;
}
}
return ans;
}
}
```
```Java
class Solution {
public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
int n = nums.length;
reverse(nums);
long[] sum = new long[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
long[][] f = new long[n + 10][4];
for (int i = k; i <= n; i++) {
for (int j = 1; j < 4; j++) {
f[i][j] = Math.max(f[i - 1][j], f[i - k][j - 1] + sum[i] - sum[i - k]);
}
}
int[] ans = new int[3];
int i = n, j = 3, idx = 0;
while (j > 0) {
if (f[i - 1][j] > f[i - k][j - 1] + sum[i] - sum[i - k]) {
i--;
} else {
ans[idx++] = n - i;
i -= k; j--;
}
}
return ans;
}
void reverse(int[] nums) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int c = nums[l];
nums[l++] = nums[r];
nums[r--] = c;
}
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.689` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/681-690/690. 员工的重要性（简单）.md | 690. 员工的重要性 | https://leetcode-cn.com/problems/employee-importance/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-s79x/ | 简单 | [
"BFS",
"DFS",
"队列"
] | 给定一个保存员工信息的数据结构,它包含了员工 唯一的 id ,重要度 和 直系下属的 id 。
比如,员工 1 是员工 2 的领导,员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工 1 的数据结构是 [1, 15, [2]] ,员工 2的 数据结构是 [2, 10, [3]] ,员工 3 的数据结构是 [3, 5, []] 。注意虽然员工 3 也是员工 1 的一个下属,但是由于 并不是直系 下属,因此没有体现在员工 1 的数据结构中。
现在输入一个公司的所有员工信息,以及单个员工 id ,返回这个员工和他所有下属的重要度之和。
示例:
```
输入:[[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
输出:11
解释:
员工 1 自身的重要度是 5 ,他有两个直系下属 2 和 3 ,而且 2 和 3 的重要度均为 3 。因此员工 1 的总重要度是 5 + 3 + 3 = 11 。
```
提示:
* 一个员工最多有一个 直系 领导,但是可以有多个 直系 下属
* 员工数量不超过 2000 。 | ### 递归 / DFS
一个直观的做法是,写一个递归函数来统计某个员工的总和。
统计自身的 $importance$ 值和直系下属的 $importance$ 值。同时如果某个下属还有下属的话,则递归这个过程。
代码:
```Java
class Solution {
Map<Integer, Employee> map = new HashMap<>();
public int getImportance(List<Employee> es, int id) {
int n = es.size();
for (int i = 0; i < n; i++) map.put(es.get(i).id, es.get(i));
return getVal(id);
}
int getVal(int id) {
Employee master = map.get(id);
int ans = master.importance;
for (int oid : master.subordinates) {
Employee other = map.get(oid);
ans += other.importance;
for (int sub : other.subordinates) ans += getVal(sub);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 迭代 / BFS
另外一个做法是使用「队列」来存储所有将要计算的 $Employee$ 对象,每次弹出时进行统计,并将其「下属」添加到队列尾部。
代码:
```Java
class Solution {
public int getImportance(List<Employee> es, int id) {
int n = es.size();
Map<Integer, Employee> map = new HashMap<>();
for (int i = 0; i < n; i++) map.put(es.get(i).id, es.get(i));
int ans = 0;
Deque<Employee> d = new ArrayDeque<>();
d.addLast(map.get(id));
while (!d.isEmpty()) {
Employee poll = d.pollFirst();
ans += poll.importance;
for (int oid : poll.subordinates) {
d.addLast(map.get(oid));
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.690` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/691. 贴纸拼词（困难）.md | 691. 贴纸拼词 | https://leetcode.cn/problems/stickers-to-spell-word/solution/by-ac_oier-5vv3/ | 困难 | [
"记忆化搜索",
"DFS",
"状压 DP",
"爆搜",
"动态规划",
"二进制枚举",
"状态压缩"
] | 我们有 $n$ 种不同的贴纸。每个贴纸上都有一个小写的英文单词。
您想要拼写出给定的字符串 `target` ,方法是从收集的贴纸中切割单个字母并重新排列它们。如果你愿意,你可以多次使用每个贴纸,每个贴纸的数量是无限的。
返回你需要拼出 `target` 的最小贴纸数量。如果任务不可能,则返回 $-1$ 。
注意:在所有的测试用例中,所有的单词都是从 $1000$ 个最常见的美国英语单词中随机选择的,并且 `target` 被选择为两个随机单词的连接。
示例 1:
```
输入: stickers = ["with","example","science"], target = "thehat"
输出:3
解释:
我们可以使用 2 个 "with" 贴纸,和 1 个 "example" 贴纸。
把贴纸上的字母剪下来并重新排列后,就可以形成目标 “thehat“ 了。
此外,这是形成目标字符串所需的最小贴纸数量。
```
示例 2:
```
输入:stickers = ["notice","possible"], target = "basicbasic"
输出:-1
解释:我们不能通过剪切给定贴纸的字母来形成目标“basicbasic”。
```
提示:
* $n == stickers.length$
* $1 <= n <= 50$
* $1 <= stickers[i].length <= 10$
* $1 <= target <= 15$
* `stickers[i]` 和 `target` 由小写英文单词组成 | ### 动态规划(记忆化搜索)
为了方便,我们记 $ss = stickers$,$t = target$,其中 $t$ 的长度为 $n$。
我们使用一个 $state$(一个 `int` 类型变量)来代表当前 $t$ 的凑成情况:若 $t[i]$ 已被凑成,则在 $state$ 中低 $i$ 位为 $1$,否则为 $0$。
起始时有 `state = 0`,最终若能凑成 $t$,则有 `state = (1 << n) - 1`。
由于每个 $ss[i]$ 可以被使用多次,因此对于一个特定的 $state$ 而言,其转换为最终的 `(1 << n) - 1` 的最小步数固定,因此我们可以使用「记忆化搜索」来避免对相同的 $state$ 进行重复搜索。
而在单步的搜索过程中,我们枚举每个 $ss[i]$ 来更新 $state$,假设使用某个 $ss[i]$ 得到的新状态为 $nstate$,则所有的 `dfs(nstate) + 1` 的最小值即是 $f[state]$。
代码:
```Java
class Solution {
int N = 20, M = 1 << 20, INF = 50;
int[] f = new int[M];
String[] ss;
String t;
int dfs(int state) {
int n = t.length();
if (state == ((1 << n) - 1)) return 0;
if (f[state] != -1) return f[state];
int ans = INF;
for (String s : ss) {
int nstate = state;
out:for (char c : s.toCharArray()) {
for (int i = 0; i < n; i++) {
if (t.charAt(i) == c && ((nstate >> i) & 1) == 0) {
nstate |= (1 << i);
continue out;
}
}
}
if (nstate != state) ans = Math.min(ans, dfs(nstate) + 1);
}
return f[state] = ans;
}
public int minStickers(String[] stickers, String target) {
ss = stickers; t = target;
Arrays.fill(f, -1);
int ans = dfs(0);
return ans == INF ? -1 : ans;
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别代表字符串 `t` 的长度和数组 `ss` 的长度。共有 $2^n$ 个状态,单次状态的计算复杂度为 $$O(\sum_{i = 0}^{m - 1}ss[i].length \times n)$$。整体复杂度为 $$O(2^n \times \sum_{i = 0}^{m - 1}ss[i].length \times n)$$
* 空间复杂度:$O(2^n)$
---
### 动态规划
定义 $f[state]$ 为当前 $t$ 的凑成情况为 $state$ 时,使用的最少贴纸数量。
对应的我们有 $f[0] = 0$,代表当 $t$ 的任何一位都不被凑成时,所需要的最小贴纸数量为 $0$。
每次我们尝试使用有效的状态 $s$($f[s]$ 不为 `INF` 为有效状态)来更新新状态 $ns$,状态转移过程与解法一类似,每次尝试使用任意的 $ss[i]$ 来得到新的 $ns$。
代码:
```Java
class Solution {
static int N = 15, INF = 20;
static int[] f = new int[1 << N];
public int minStickers(String[] ss, String t) {
int n = ss.length, m = t.length(), mask = 1 << m;
Arrays.fill(f, INF);
f[0] = 0;
for (int s = 0; s < mask; s++) {
if (f[s] == INF) continue;
for (String str : ss) {
int ns = s, len = str.length();
for (int i = 0; i < len; i++) {
int c = str.charAt(i) - 'a';
for (int j = 0; j < m; j++) {
if (t.charAt(j) - 'a' == c && (((ns >> j) & 1) == 0)) {
ns |= (1 << j);
break;
}
}
}
f[ns] = Math.min(f[ns], f[s] + 1);
}
}
return f[mask - 1] == INF ? -1 : f[mask - 1];
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别代表字符串 `t` 的长度和数组 `ss` 的长度。共有 $2^n$ 个状态,单次状态的计算复杂度为 $$O(\sum_{i = 0}^{m - 1}ss[i].length \times n)$$。整体复杂度为 $$O(2^n \times \sum_{i = 0}^{m - 1}ss[i].length \times n)$$
* 空间复杂度:$O(2^n)$
---
### 预处理优化
在解法一和解法二的状态转移过程中,我们每次都尝试枚举所有的 $ss[i]$ 来将 $s$ 更新为 $ns$。
实际上,可以有效填充 $t$ 中尚未被占用字符的 $ss[i]$ 可能只是少数,因此我们可以先预处理每个 $ss[i]$ 到底能够提供那些字符。
在将状态 $s$ 更新为 $ns$ 时,我们只枚举那些有效的 $ss[i]$。
代码:
```Java
class Solution {
static int N = 15, INF = 20;
static int[] f = new int[1 << N];
public int minStickers(String[] ss, String t) {
int n = ss.length, m = t.length(), mask = 1 << m;
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < n; i++) {
String str = ss[i];
for (char c : str.toCharArray()) {
int d = c - 'a';
List<Integer> list = map.getOrDefault(d, new ArrayList<>());
if (list.size() == 0 || list.get(list.size() - 1) != i) list.add(i);
map.put(d, list);
}
}
Arrays.fill(f, INF);
f[0] = 0;
for (int s = 0; s < mask; s++) {
if (f[s] == INF) continue;
int loc = -1;
for (int i = 0; i < m && loc == -1; i++) {
if (((s >> i) & 1) == 0) loc = i;
}
if (loc == -1) continue;
List<Integer> list = map.getOrDefault(t.charAt(loc) - 'a', new ArrayList<>());
for (int i = 0; i < list.size(); i++) {
String str = ss[list.get(i)];
int ns = s, len = str.length();
for (int j = 0; j < len; j++) {
char c = str.charAt(j);
for (int k = 0; k < m; k++) {
if (t.charAt(k) == c && (((ns >> k) & 1) == 0)) {
ns |= (1 << k);
break;
}
}
}
f[ns] = Math.min(f[ns], f[s] + 1);
}
}
return f[mask - 1] == INF ? -1 : f[mask - 1];
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别代表字符串 `t` 的长度和数组 `ss` 的长度。共有 $2^n$ 个状态,单次状态的计算复杂度为 $$O(\sum_{i = 0}^{m - 1}ss[i].length \times n)$$。整体复杂度为 $$O(2^n \times \sum_{i = 0}^{m - 1}ss[i].length \times n)$$
* 空间复杂度:$O(2^n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.691` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/692. 前K个高频单词（中等）.md | 692. 前K个高频单词 | https://leetcode-cn.com/problems/top-k-frequent-words/solution/gong-shui-san-xie-xiang-jie-shi-yong-ha-8dxt2/ | 中等 | [
"哈希表",
"优先队列(堆)"
] | 给一非空的单词列表,返回前 `k` 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。
如果不同的单词有相同出现频率,按字母顺序排序。
示例 1:
```
输入: ["i", "love", "leetcode", "i", "love", "coding"], k = 2
输出: ["i", "love"]
解析: "i" 和 "love" 为出现次数最多的两个单词,均为2次。
注意,按字母顺序 "i" 在 "love" 之前。
```
示例 2:
```
输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
输出: ["the", "is", "sunny", "day"]
解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词,
出现次数依次为 4, 3, 2 和 1 次。
```
注意:
* 假定 `k` 总为有效值,`1 ≤ k ≤ 集合元素数`。
* 输入的单词均由小写字母组成。
扩展练习:
* 尝试以 $O(n\log{k})$ 时间复杂度和 $O(n)$ 空间复杂度解决。 | ### 哈希表 & 优先队列(堆)
这道题是在「优先队列(堆)」裸题的基础上增加了字典序大小的比较。
相应的,我们不能只根据「词频大小」构建小根堆来获取前 $k$ 个元素,还需要结合字典序大小来做。
具体的,我们可以使用「哈希表」&「优先队列」进行求解:
1. 使用「哈希表」来统计所有的词频
2. 构建大小为 $k$ 按照「词频升序 + (词频相同)字典序倒序」的优先队列:
* 如果词频不相等,根据词频进行升序构建,确保堆顶元素是堆中词频最小的元素
* 如果词频相等,根据字典序大小进行倒序构建,结合 $2.1$ 可以确保堆顶元素是堆中「词频最小 & 字典序最大」的元素
3. 对所有元素进行遍历,尝试入堆:
* 堆内元素不足 $k$ 个:直接入堆
* 词频大于堆顶元素:堆顶元素不可能是前 $k$ 大的元素。将堆顶元素弹出,并将当前元素添加到堆中
* 词频小于堆顶元素;当前元素不可能是前 $k$ 大的元素,直接丢弃。
* 词频等于堆顶元素:根据当前元素与堆顶元素的字典序大小决定(如果字典序大小比堆顶元素要小则入堆)
4. 输出堆内元素,并翻转
代码:
```Java
class Solution {
public List<String> topKFrequent(String[] ws, int k) {
Map<String, Integer> map = new HashMap<>();
for (String w : ws) map.put(w, map.getOrDefault(w, 0) + 1);
PriorityQueue<Object[]> q = new PriorityQueue<>(k, (a, b)->{
// 如果词频不同,根据词频升序
int c1 = (Integer)a[0], c2 = (Integer)b[0];
if (c1 != c2) return c1 - c2;
// 如果词频相同,根据字典序倒序
String s1 = (String)a[1], s2 = (String)b[1];
return s2.compareTo(s1);
});
for (String s : map.keySet()) {
int cnt = map.get(s);
if (q.size() < k) { // 不足 k 个,直接入堆
q.add(new Object[]{cnt, s});
} else {
Object[] peek = q.peek();
if (cnt > (Integer)peek[0]) { // 词频比堆顶元素大,弹出堆顶元素,入堆
q.poll();
q.add(new Object[]{cnt, s});
} else if (cnt == (Integer)peek[0]) { // 词频与堆顶元素相同
String top = (String)peek[1];
if (s.compareTo(top) < 0) { // 且字典序大小比堆顶元素小,弹出堆顶元素,入堆
q.poll();
q.add(new Object[]{cnt, s});
}
}
}
}
List<String> ans = new ArrayList<>();
while (!q.isEmpty()) ans.add((String)q.poll()[1]);
Collections.reverse(ans);
return ans;
}
}
```
* 时间复杂度:使用哈希表统计词频,复杂度为 $O(n)$;使用最多 $n$ 个元素维护一个大小为 $k$ 的堆,复杂度为 $O(n\log{k})$;输出答案复杂度为 $O(k)$(同时 $k \leq n$)。整体复杂度为 $O(n\log{k})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.692` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/693. 交替位二进制数（简单）.md | 693. 交替位二进制数 | https://leetcode-cn.com/problems/binary-number-with-alternating-bits/solution/gong-si-shui-by-ac_oier-zuw7/ | 简单 | [
"模拟",
"位运算"
] | 给定一个正整数,检查它的二进制表示是否总是 $0$、$1$ 交替出现:换句话说,就是二进制表示中相邻两位的数字永不相同。
示例 1:
```
输入:n = 5
输出:true
解释:5 的二进制表示是:101
```
示例 2:
```
输入:n = 7
输出:false
解释:7 的二进制表示是:111.
```
示例 3:
```
输入:n = 11
输出:false
解释:11 的二进制表示是:1011.
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 遍历
根据题意,对 $n$ 的每一位进行遍历检查。
代码:
```Java
class Solution {
public boolean hasAlternatingBits(int n) {
int cur = -1;
while (n != 0) {
int u = n & 1;
if ((cur ^ u) == 0) return false;
cur = u; n >>= 1;
}
return true;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 位运算
另外一种更为巧妙的方式是利用交替位二进制数性质。
当给定值 $n$ 为交替位二进制数时,将 $n$ 右移一位得到的值 $m$ 仍为交替位二进制数,且与原数 $n$ 错开一位,两者异或能够得到形如 $0000...1111$ 的结果 $x$,此时对 $x$ 执行加法(进位操作)能够得到形如 $0000...10000$ 的结果,将该结果与 $x$ 执行按位与后能够得到全 $0$ 结果。
代码:
```Java
class Solution {
public boolean hasAlternatingBits(int n) {
int x = n ^ (n >> 1);
return (x & (x + 1)) == 0;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.693` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/697. 数组的度（简单）.md | 697. 数组的度 | https://leetcode-cn.com/problems/degree-of-an-array/solution/shu-zu-ji-shu-ha-xi-biao-ji-shu-jie-fa-y-a0mg/ | 简单 | [
"哈希表"
] | 给定一个非空且只包含非负数的整数数组 nums,数组的度的定义是指数组里任一元素出现频数的最大值。
你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组,返回其长度。
示例 1:
```
输入:[1, 2, 2, 3, 1]
输出:2
解释:
输入数组的度是2,因为元素1和2的出现频数最大,均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2,所以返回2.
```
示例 2:
```
输入:[1,2,2,3,1,4,2]
输出:6
```
提示:
* nums.length 在1到 50,000 区间范围内。
* nums[i] 是一个在 0 到 49,999 范围内的整数。 | ### 数组计数
由于已知值的范围是 `[0, 49999]`。
我们可以使用数组 `cnt` 来统计每个值出现的次数,数组 `first` 和 `last` 记录每个值「首次出现」和「最后出现」的下标。
同时统计出最大词频为 `max`。
然后再遍历一次数组,对于那些满足词频为 `max` 的数值进行长度计算。
```Java
class Solution {
int N = 50009;
public int findShortestSubArray(int[] nums) {
int n = nums.length;
int[] cnt = new int[N];
int[] first = new int[N], last = new int[N];
Arrays.fill(first, -1);
int max = 0;
for (int i = 0; i < n; i++) {
int t = nums[i];
max = Math.max(max, ++cnt[t]);
if (first[t] == -1) first[t] = i;
last[t] = i;
}
int ans = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int t = nums[i];
if (cnt[t] == max) ans = Math.min(ans, last[t] - first[t] + 1);
}
return ans;
}
}
```
* 时间复杂度:对数组进行常数次扫描。复杂度为 $O(n)$
* 空间复杂度:$O(n)$
***
### 哈希表计数
同样的,除了使用静态数组,我们还可以使用哈希表进行计数。
```java
class Solution {
public int findShortestSubArray(int[] nums) {
int n = nums.length;
Map<Integer, Integer> cnt = new HashMap<>();
Map<Integer, Integer> first = new HashMap<>(), last = new HashMap<>();
int max = 0;
for (int i = 0; i < n; i++) {
int t = nums[i];
cnt.put(t, cnt.getOrDefault(t, 0) + 1);
max = Math.max(max, cnt.get(t));
if (!first.containsKey(t)) first.put(t, i);
last.put(t, i);
}
int ans = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int t = nums[i];
if (cnt.get(t) == max) {
ans = Math.min(ans, last.get(t) - first.get(t) + 1);
}
}
return ans;
}
}
```
* 时间复杂度:对数组进行常数次扫描。复杂度为 $O(n)$
* 空间复杂度:$O(n)$
***
### 总结
我们知道 `哈希表 = 哈希函数 + 数组`,由于哈希函数计算需要消耗时间(Java 中首先涉及自动装箱/拆箱,之后还要取对象的 hashCode 进行右移异或,最后才计算哈希桶的下标),以及处理哈希冲突的开销。
其效率必然比不上使用我们静态数组进行计数。
因此我建议,对于那些 **数值范围确定且不太大($10^6$ 以内都可以使用,本题数量级在 $10^4$)** 的计算场景,使用数组进行计数,而不是使用哈希表。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.697` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/698. 划分为k个相等的子集（中等）.md | 698. 划分为k个相等的子集 | https://leetcode.cn/problems/partition-to-k-equal-sum-subsets/solution/by-ac_oier-mryw/ | 中等 | [
"搜索",
"爆搜",
"剪枝",
"模拟退火",
"启发式搜索",
"回溯算法",
"贪心"
] | 给定一个整数数组 `nums` 和一个正整数 `k`,找出是否有可能把这个数组分成 `k` 个非空子集,其总和都相等。
示例 1:
```
输入: nums = [4, 3, 2, 3, 5, 2, 1], k = 4
输出: True
说明: 有可能将其分成 4 个子集(5),(1,4),(2,3),(2,3)等于总和。
```
示例 2:
```
输入: nums = [1,2,3,4], k = 3
输出: false
```
提示:
* $1 <= k <= len(nums) <= 16$
* $0 < nums[i] < 10000$
* 每个元素的频率在 $[1,4]$ 范围内 | ### 搜索 + 剪枝(贪心策略)
将 $n$ 个数均分成 $k$ 份,且 $n$ 与 $k$ 数据范围为 $16$,容易想到搜索剪枝。
先对一些显然的无解情况进行分析:记 $tot = \sum_{i = 0}^{n - 1}nums[i]$,**若 $tot$ 不为 $k$ 的倍数,必然是无法实现均分,直接返回 `false`(可行性剪枝)**。同时可知单个集合的总和为 $t = \frac{tot}{k}$。
设计搜索函数为 `boolean dfs(int idx, int cur, int cnt, boolean[] vis)`,各项参数含义如下:
* `cur` 为当前集合的元素和(初始值为 $0$);
* `cnt` 是已凑成多少个总和为 $t$ 的集合(初始值为 $0$,当 $cnt = k$ 时,我们搜索到了合法方案,返回 `true`,否则对 `cnt` 进行加一操作,并将 `cur` 置零,搜索下个集合);
* `vis` 用于记录哪些 $nums[i]$ 已被使用;
* `idx` 是搜索关键,其含义为搜索空间的分割点。即对于当前正在搜索的集合,我们不会每次都扫描整个 `nums` 来找添加到该集合的下一个元素,而是能够明确下一个元素必然在 $idx$ 的左边或右边。
具体的,我们知道若最终存在合法方案,必然每个 $nums[i]$ 都均棣属于某个具体集合。我们考虑搜索某个集合的组成元素时,按照「从大到小」的方式进行搜索(起始先对 `nums` 进行排序),这样能够**确保若上一个被加入该集合的元素为 $nums[i]$,则下一个被添加的元素 $nums[j]$ 必然位于 $nums[i]$ 的左边,即从下标 $i - 1$ 开始往前搜索(顺序性剪枝)**;
同时,也正是我们按照「从大到小」的方式进行搜索,**确保了当前集合的搜索,无须对已搜索到的集合进行调整**。
也就是说我们搜索的第一个集合是所有 $nums[i]$ 中的最大值所在的那个集合;二次搜索是所有 $nums[i]$ 减去第一个集合后剩余元素中最大值所在的集合 ...
这引导我们,**如果当前集合如果连第一个值都无法搜到(即剩余元素的最大值不能作为当前集合的元素),必然无解(可行性剪枝)**。
这样的「搜索 + 剪枝」的解法本质是利用了「贪心」来做策略:**我们每个回合的搜索总是在搜索「剩余未使用元素的最大值」所在的那个集合,并且按照「优先使用大数值」的原则来构造。**
可证明该做法的正确性:由于搜索的是「剩余未使用元素的最大值」所在的那个集合,因此剩余未使用元素必然在集合内,若被搜索到的其余元素参与集合构造导致有解变无解(即需要将其余元素进行替换才能确保有解),根据我们「从大到小」搜索下一个元素原则,替换过程必然不会使集合元素个数变少,即总是会拿不少于 $K$ 个的元素来替换当前集合的 $K$ 个元素(总和相同),从而可推断该替换并非必须。
Java 代码:
```Java
class Solution {
int[] nums;
int n, t, k;
public boolean canPartitionKSubsets(int[] _nums, int _k) {
nums = _nums; k = _k;
int tot = 0;
for (int x : nums) tot += x;
if (tot % k != 0) return false; // 可行性剪枝
Arrays.sort(nums);
n = nums.length; t = tot / k;
return dfs(n - 1, 0, 0, new boolean[n]);
}
boolean dfs(int idx, int cur, int cnt, boolean[] vis) {
if (cnt == k) return true;
if (cur == t) return dfs(n - 1, 0, cnt + 1, vis);
for (int i = idx; i >= 0; i--) { // 顺序性剪枝
if (vis[i] || cur + nums[i] > t) continue; // 可行性剪枝
vis[i] = true;
if (dfs(i - 1, cur + nums[i], cnt, vis)) return true;
vis[i] = false;
if (cur == 0) return false; // 可行性剪枝
}
return false;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> nums;
int n, t, k;
bool dfs(int idx, int cur, int cnt, vector<bool>& vis) {
if (cnt == k) return true;
if (cur == t) return dfs(n - 1, 0, cnt + 1, vis);
for (int i = idx; i >= 0; i--) {
if (vis[i] || cur + nums[i] > t) continue;
vis[i] = true;
if (dfs(i - 1, cur + nums[i], cnt, vis)) return true;
vis[i] = false;
if (cur == 0) return false;
}
return false;
}
bool canPartitionKSubsets(vector<int>& _nums, int _k) {
nums = _nums; k = _k;
int tot = 0;
for (int x : nums) tot += x;
if (tot % k != 0) return false;
sort(nums.begin(), nums.end());
n = nums.size(); t = tot / k;
vector<bool> vis(n, false);
return dfs(n - 1, 0, 0, vis);
}
};
```
Python 代码:
```Python
class Solution:
def canPartitionKSubsets(self, _nums, _k):
nums, k = _nums, _k
tot = sum(nums)
if tot % k != 0:
return False
nums.sort()
n, t = len(nums), tot // k
def dfs(idx, cur, cnt, vis):
if cnt == k:
return True
if cur == t:
return dfs(n - 1, 0, cnt + 1, vis)
for i in range(idx, -1, -1):
if vis[i] or cur + nums[i] > t:
continue
vis[i] = True
if dfs(i - 1, cur + nums[i], cnt, vis):
return True
vis[i] = False
if cur == 0:
return False
return False
return dfs(n - 1, 0, 0, [False] * n)
```
TypeScript 代码:
```TypeScript
let nums: number[];
let n: number, t: number, k: number;
function canPartitionKSubsets(_nums: number[], _k: number): boolean {
nums = _nums; k = _k;
let tot = 0
for (let x of nums) tot += x
if (tot % k != 0) return false
nums.sort((a,b)=>a-b)
n = nums.length; t = tot / k
return dfs(n - 1, 0, 0, new Array<boolean>(n).fill(false))
};
function dfs(idx: number, cur: number, cnt: number, vis: boolean[]): boolean {
if (cnt == k) return true
if (cur == t) return dfs(n - 1, 0, cnt + 1, vis)
for (let i = idx; i >= 0; i--) {
if (vis[i] || cur + nums[i] > t) continue
vis[i] = true
if (dfs(idx - 1, cur + nums[i], cnt, vis)) return true
vis[i] = false
if (cur == 0) return false
}
return false
}
```
* 时间复杂度:爆搜剪枝不分析时空复杂度
* 空间复杂度:爆搜剪枝不分析时空复杂度
---
### 模拟退火
数据范围为 $16$ 自然也是很好的调参运用题。
**因为将 $n$ 个数划分为 $k$ 份,等效于用 $n$ 个数构造出一个「特定排列」,然后对「特定排列」进行固定模式的构造逻辑,就能实现「答案」与「目标排列」的对应关系。**
基于此,我们可以使用「模拟退火」进行求解。
单次迭代的基本流程:
1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」
2. 如果温度下降(交换后的序列更优),进入下一次迭代
3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)
我们可以制定如下规则来衡量当前排列与合法排列的差异程度:将当前的 `nums` 从前往后划分成总和不超过 $t$ 的 $k$ 份,并将 $k$ 份与 $t$ 的差值之和,作为对当前排列的差异程度评级 `diff`,当出现 `diff = 0` 说明找到了合法排列,可结束搜索。
该计算规则可确保排列变化的连续性能有效体现在 `diff` 数值上。
Java 代码(`2024/06/01` 可通过):
```Java
class Solution {
int[] nums;
int n, tval, k;
Random random = new Random(20220920);
double hi = 1e9, lo = 1e-4, fa = 0.95;
int N = 600;
boolean ans;
int calc() {
int diff = tval * k;
for (int i = 0, j = 0; i < n && j < k; j++) {
int cur = 0;
while (i < n && cur + nums[i] <= tval) cur += nums[i++];
diff -= cur;
}
if (diff == 0) ans = true;
return diff;
}
void sa() {
shuffle(nums);
for (double t = hi; t > lo && !ans; t *= fa) {
int a = random.nextInt(n), b = random.nextInt(n);
if (a == b) continue;
int prev = calc();
swap(nums, a, b);
int cur = calc();
int diff = cur - prev;
if (Math.log(diff / t) > random.nextDouble()) swap(nums, a, b);
}
}
public boolean canPartitionKSubsets(int[] _nums, int _k) {
nums = _nums; k = _k;
int tot = 0;
for (int x : nums) tot += x;
if (tot % k != 0) return false;
n = nums.length; tval = tot / k;
while (!ans && N-- > 0) sa();
return ans;
}
void shuffle(int[] nums) {
for (int i = n; i > 0; i--) swap(nums, random.nextInt(i), i - 1);
}
void swap(int[] nums, int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
}
```
TypeScript 代码(`2024/06/01` 可通过):
```TypeScript
let nums: number[];
let n: number, tval: number, k: number
let ans: boolean
let hi: number, lo: number, fa: number, N: number
function getRandom(max: number): number {
return Math.floor(Math.random() * (max + 1))
}
function calc(): number {
let diff = tval * k
for (let i = 0, j = 0; i < n && j < k; j++) {
let cur = 0
while (i < n && cur + nums[i] <= tval) cur += nums[i++]
diff -= cur
}
if (diff == 0) ans = true
return diff
}
function sa(): void {
shuffle(nums)
for (let t = hi; t > lo && !ans; t *= fa) {
const a = getRandom(n - 1), b = getRandom(n - 1)
if (a == b) continue
const prev = calc()
swap(nums, a, b)
const cur = calc()
const diff = cur - prev
if (Math.log(diff / t) > Math.random()) swap(nums, a, b)
}
}
function canPartitionKSubsets(_nums: number[], _k: number): boolean {
nums = _nums; k = _k
let tot = 0
for (let x of nums) tot += x
if (tot % k != 0) return false
n = nums.length; tval = tot / k
hi = 1e7; lo = 1e-4; fa = 0.977; N = 420;
ans = false
while (!ans && N-- > 0) sa()
return ans
}
function shuffle(nums: number[]): void {
for (let i = n; i > 0; i--) swap(nums, getRandom(i), i - 1)
}
function swap(nums: number[], a: number, b: number): void {
const c = nums[a]
nums[a] = nums[b]
nums[b] = c
}
```
* 时间复杂度:启发式搜索不分析时空复杂度
* 空间复杂度:启发式搜索不分析时空复杂度 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.698` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/699. 掉落的方块（困难）.md | 699. 掉落的方块 | https://leetcode.cn/problems/falling-squares/solution/by-ac_oier-zpf0/ | 困难 | [
"线段树(动态开点)",
"线段树"
] | 在无限长的数轴(即 `x` 轴)上,我们根据给定的顺序放置对应的正方形方块。
第 i 个掉落的方块(`positions[i] = (left, side_length)`)是正方形,其中 `left` 表示该方块最左边的点位置(`positions[i][0]`),`side_length` 表示该方块的边长(`positions[i][1]`)。
每个方块的底部边缘平行于数轴(即 `x` 轴),并且从一个比目前所有的落地方块更高的高度掉落而下。在上一个方块结束掉落,并保持静止后,才开始掉落新方块。
方块的底边具有非常大的粘性,并将保持固定在它们所接触的任何长度表面上(无论是数轴还是其他方块)。邻接掉落的边不会过早地粘合在一起,因为只有底边才具有粘性。
返回一个堆叠高度列表 `ans`。每一个堆叠高度 `ans[i]` 表示在通过 `positions[0], positions[1], ..., positions[i]` 表示的方块掉落结束后,目前所有已经落稳的方块堆叠的最高高度。
示例 1:
```
输入: [[1, 2], [2, 3], [6, 1]]
输出: [2, 5, 5]
解释:
第一个方块 positions[0] = [1, 2] 掉落:
_aa
_aa
-------
方块最大高度为 2 。
第二个方块 positions[1] = [2, 3] 掉落:
__aaa
__aaa
__aaa
_aa__
_aa__
--------------
方块最大高度为5。
大的方块保持在较小的方块的顶部,不论它的重心在哪里,因为方块的底部边缘有非常大的粘性。
第三个方块 positions[1] = [6, 1] 掉落:
__aaa
__aaa
__aaa
_aa
_aa___a
--------------
方块最大高度为5。
因此,我们返回结果[2, 5, 5]。
```
示例 2:
```
输入: [[100, 100], [200, 100]]
输出: [100, 100]
解释: 相邻的方块不会过早地卡住,只有它们的底部边缘才能粘在表面上。
```
注意:
* $1 <= positions.length <= 1000$
* $1 <= positions[i][0] <= 10^8$
* $1 <= positions[i][1] <= 10^6$ | ### 基本分析
为了方便,我们使用 `ps` 来代指 `positions`。
每次从插入操作都附带一次询问,因此询问次数为 $1e3$,左端点的最大值为 $10e8$,边长最大值为 $1e6$,由此可知值域范围大于 $1e8$,但不超过 $1e9$。
对于值域范围大,但查询次数有限的区间和问题,不久前曾经总结过 : [求解常见「值域爆炸,查询有限」区间问题的几种方式](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491187&idx=2&sn=bb2d8b7e89c535914da8107387e951a2),可作为前置 🧀 进行了解。
而我的个人习惯,一般要么使用「离散化 + 线段树」,要么使用「线段树(动态开点)」进行求解。
本题为「非强制在线」问题,因此可以先对 `ps` 数组进行离散化,将值域映射到较小的空间,然后套用固定占用 $4 \times n$ 空间的线段树求解。
但更为灵活(能够同时应对强制在线问题)的求解方式是「线段树(动态开点)」。
同时实现动态开点的方式有两种:
1. 根据操作次数对使用到的最大点数进行预估,并采用数组方式进行实现线段树(解法一);
2. 使用动态指针(解法二);
方式一在不久之前的每日一题 [933. 最近的请求次数](https://sharingsource.github.io/2022/05/06/933.%20%E6%9C%80%E8%BF%91%E7%9A%84%E8%AF%B7%E6%B1%82%E6%AC%A1%E6%95%B0%EF%BC%88%E7%AE%80%E5%8D%95%EF%BC%89/) 讲过,因此今天把方式二也写一下。
具体的,我们将顺序放置方块的操作(假设当前方块的左端点为 $a$,边长为 $len$,则有右端点为 $b = a + len$),分成如下两步进行:
* 查询当前范围 $[a, b]$ 的最大高度为多少,假设为 $cur$;
* 更新当前范围 $[a, b]$ 的最新高度为 $cur + len$。
因此这本质上是一个「区间修改 + 区间查询」的问题,我们需要实现带「懒标记」的线段树,从而确保在进行「区间修改」时复杂度仍为 $O(\log{n})$。
> 另外有一个需要注意的细节是:不同方块之间的边缘可以重合,但不会导致方块叠加,因此我们当我们对一个区间 $[a, b]$ 进行操作(查询或插入)时,可以将其调整为 $[a, b - 1]$,从而解决边缘叠加操作高度错误的问题。
---
### 线段树(动态开点 - 估点)
估点的基本方式在前置 🧀 [求解常见「值域爆炸,查询有限」区间问题的几种方式](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491187&idx=2&sn=bb2d8b7e89c535914da8107387e951a2) 详细讲过。
简单来说,可以直接估算为 $6 \times m \times \log{n}$ 即可,其中 $m$ 为询问次数(对应本题就是 `ps` 的长度),而 $n$ 为值域大小(对应本题可直接取成 $1e9$);而另外一个比较实用(避免估算)的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开(不考虑字节对齐,或者结构体过大的情况,`Java` 的 $128M$ 可以开到 $5 \times 10^6$ 以上)。
代码:
```Java
class Solution {
class Node {
// ls 和 rs 分别代表当前区间的左右子节点所在 tr 数组中的下标
// val 代表当前区间的最大高度,add 为懒标记
int ls, rs, val, add;
}
int N = (int)1e9, cnt = 0;
Node[] tr = new Node[1000010];
void update(int u, int lc, int rc, int l, int r, int v) {
if (l <= lc && rc <= r) {
tr[u].val = v;
tr[u].add = v;
return ;
}
pushdown(u);
int mid = lc + rc >> 1;
if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);
if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);
pushup(u);
}
int query(int u, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return tr[u].val;
pushdown(u);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);
if (r > mid) ans = Math.max(ans, query(tr[u].rs, mid + 1, rc, l, r));
return ans;
}
void pushdown(int u) {
if (tr[u] == null) tr[u] = new Node();
if (tr[u].ls == 0) {
tr[u].ls = ++cnt;
tr[tr[u].ls] = new Node();
}
if (tr[u].rs == 0) {
tr[u].rs = ++cnt;
tr[tr[u].rs] = new Node();
}
if (tr[u].add == 0) return ;
int add = tr[u].add;
tr[tr[u].ls].add = add; tr[tr[u].rs].add = add;
tr[tr[u].ls].val = add; tr[tr[u].rs].val = add;
tr[u].add = 0;
}
void pushup(int u) {
tr[u].val = Math.max(tr[tr[u].ls].val, tr[tr[u].rs].val);
}
public List<Integer> fallingSquares(int[][] ps) {
List<Integer> ans = new ArrayList<>();
tr[1] = new Node();
for (int[] info : ps) {
int x = info[0], h = info[1], cur = query(1, 1, N, x, x + h - 1);
update(1, 1, N, x, x + h - 1, cur + h);
ans.add(tr[1].val);
}
return ans;
}
}
```
* 时间复杂度:令 $m$ 为查询次数,$n$ 为值域大小,复杂度为 $O(m\log{n})$
* 空间复杂度:$O(m\log{n})$
---
### 线段树(动态开点 - 动态指针)
利用「动态指针」实现的「动态开点」可以有效避免数组估点问题,更重要的是可以有效避免 `new` 大数组的初始化开销,对于 LC 这种还跟你算所有样例总时长的 OJ 来说,在不考虑 `static` 优化/全局数组优化 的情况下,动态指针的方式要比估点的方式来得好。
代码:
```Java
class Solution {
int N = (int)1e9;
class Node {
// ls 和 rs 分别代表当前区间的左右子节点
Node ls, rs;
// val 代表当前区间的最大高度,add 为懒标记
int val, add;
}
Node root = new Node();
void update(Node node, int lc, int rc, int l, int r, int v) {
if (l <= lc && rc <= r) {
node.add = v;
node.val = v;
return ;
}
pushdown(node);
int mid = lc + rc >> 1;
if (l <= mid) update(node.ls, lc, mid, l, r, v);
if (r > mid) update(node.rs, mid + 1, rc, l, r, v);
pushup(node);
}
int query(Node node, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return node.val;
pushdown(node);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = query(node.ls, lc, mid, l, r);
if (r > mid) ans = Math.max(ans, query(node.rs, mid + 1, rc, l, r));
return ans;
}
void pushdown(Node node) {
if (node.ls == null) node.ls = new Node();
if (node.rs == null) node.rs = new Node();
if (node.add == 0) return ;
node.ls.add = node.add; node.rs.add = node.add;
node.ls.val = node.add; node.rs.val = node.add;
node.add = 0;
}
void pushup(Node node) {
node.val = Math.max(node.ls.val, node.rs.val);
}
public List<Integer> fallingSquares(int[][] ps) {
List<Integer> ans = new ArrayList<>();
for (int[] info : ps) {
int x = info[0], h = info[1], cur = query(root, 0, N, x, x + h - 1);
update(root, 0, N, x, x + h - 1, cur + h);
ans.add(root.val);
}
return ans;
}
}
```
* 时间复杂度:令 $m$ 为查询次数,$n$ 为值域大小,复杂度为 $O(m\log{n})$
* 空间复杂度:$O(m\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.699` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/691-700/700. 二叉搜索树中的搜索（简单）.md | 700. 二叉搜索树中的搜索 | https://leetcode-cn.com/problems/search-in-a-binary-search-tree/solution/gong-shui-san-xie-er-cha-shu-de-sou-suo-8z7hj/ | 简单 | [
"树的搜索",
"迭代",
"递归"
] | 给定二叉搜索树(BST)的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在,则返回 NULL。
例如,
```
给定二叉搜索树:
4
/ \
2 7
/ \
1 3
和值: 2
```
你应该返回如下子树:
```
2
/ \
1 3
```
在上述示例中,如果要找的值是 5,但因为没有节点值为 5,我们应该返回 NULL。 | ### 递归
根据题意,进行「递归」搜索即可。
代码:
```Java
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if (root == null || root.val == val) return root;
return root.val < val ? searchBST(root.right, val) : searchBST(root.left, val);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(n)$
---
### 迭代
同理,可以使用「迭代」进行搜索。
代码:
```Java
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
while (root != null && root.val != val) {
root = root.val < val ? root.right : root.left;
}
return root;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.700` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/703. 数据流中的第 K 大元素（简单）.md | 703. 数据流中的第 K 大元素 | https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/solution/jian-da-ti-de-duo-chong-jie-fa-mou-pao-p-d1qi/ | 简单 | [
"Top K",
"排序",
"优先队列(堆)"
] | 设计一个找到数据流中第 `k` 大元素的类(class)。注意是排序后的第 `k` 大元素,不是第 `k` 个不同的元素。
请实现 `KthLargest` 类:
* `KthLargest(int k, int[] nums)` 使用整数 `k` 和整数流 `nums` 初始化对象。
* `int add(int val)` 将 `val` 插入数据流 `nums` 后,返回当前数据流中第 `k` 大的元素。
示例:
```
输入:
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
输出:
[null, 4, 5, 5, 8, 8]
解释:
KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3); // return 4
kthLargest.add(5); // return 5
kthLargest.add(10); // return 5
kthLargest.add(9); // return 8
kthLargest.add(4); // return 8
```
提示:
* $1 <= k <= 10^4$
* $0 <= nums.length <= 10^4$
* $-10^4 <= nums[i] <= 10^4$
* $-10^4 <= val <= 10^4$
* 最多调用 `add` 方法 $10^4$ 次
* 题目数据保证,在查找第 `k` 大元素时,数组中至少有 `k` 个元素 | ### 冒泡排序 (TLE)
每次调用 `add` 时先将数装入数组,然后遍历 `k` 次,通过找 `k` 次最大值来找到 Top K。
代码:
```Java
class KthLargest {
int k;
List<Integer> list = new ArrayList<>(10009);
public KthLargest(int _k, int[] _nums) {
k = _k;
for (int i : _nums) list.add(i);
}
public int add(int val) {
list.add(val);
int cur = 0;
for (int i = 0; i < k; i++) {
int idx = findMax(cur, list.size() - 1);
swap(cur++, idx);
}
return list.get(cur - 1);
}
int findMax(int start, int end) {
int ans = 0, max = Integer.MIN_VALUE;
for (int i = start; i <= end; i++) {
int t = list.get(i);
if (t > max) {
max = t;
ans = i;
}
}
return ans;
}
void swap(int a, int b) {
int c = list.get(a);
list.set(a, list.get(b));
list.set(b, c);
}
}
```
* 时间复杂度:$O(nk)$
* 空间复杂度:$O(n)$
---
### 快速排序
上述的解法时间复杂度是 $O(nk)$ 的,当 `k` 很大的时候会超时。
我们可以使用快排来代替冒泡,将复杂度变为 $O(n\log{n})$。
代码:
```Java
class KthLargest {
int k;
List<Integer> list = new ArrayList<>(10009);
public KthLargest(int _k, int[] _nums) {
k = _k;
for (int i : _nums) list.add(i);
}
public int add(int val) {
list.add(val);
Collections.sort(list);
return list.get(list.size() - k);
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 优先队列
使用优先队列构建一个容量为 `k` 的小根堆。
将 `nums` 中的前 `k` 项放入优先队列(此时堆顶元素为前 `k` 项的最大值)。
随后逐项加入优先队列:
* 堆内元素个数达到 `k` 个:
* 加入项小于等于堆顶元素:加入项排在第 `k` 大元素的后面。直接忽略
* 加入项大于堆顶元素:将堆顶元素弹出,加入项加入优先队列,调整堆
* 堆内元素个数不足 `k` 个,将加入项加入优先队列
将堆顶元素进行返回(数据保证返回答案时,堆内必然有 `k` 个元素):
代码:
```Java
class KthLargest {
int k;
PriorityQueue<Integer> queue;
public KthLargest(int _k, int[] _nums) {
k = _k;
queue = new PriorityQueue<>(k, (a,b)->Integer.compare(a,b));
int n = _nums.length;
for (int i = 0; i < k && i < n; i++) queue.add(_nums[i]);
for (int i = k; i < n; i++) add(_nums[i]);
}
public int add(int val) {
int t = !queue.isEmpty() ? queue.peek() : Integer.MIN_VALUE;
if (val > t || queue.size() < k) {
if (!queue.isEmpty() && queue.size() >= k) queue.poll();
queue.add(val);
}
return queue.peek();
}
}
```
* 时间复杂度:最坏情况下,`n` 个元素都需要入堆。复杂度为 $O(n\log{k})$
* 空间复杂度:$O(k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.703` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/704. 二分查找（简单）.md | 704. 二分查找 | https://leetcode-cn.com/problems/binary-search/solution/gong-shui-san-xie-yun-yong-er-fen-zhao-f-5jyj/ | 简单 | [
"二分"
] | 给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
示例 1:
```
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
```
示例 2:
```
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
```
提示:
* 你可以假设 nums 中的所有元素是不重复的。
* n 将在 [1, 10000]之间。
* nums 的每个元素都将在 [-9999, 9999]之间。 | ### 二分
一道二分裸题,写二分重点在于学会从「二段性」出发进行分析,想清楚二分的是哪个端点/边界。
而不是局限于用什么模板,大于还是小于,硬记这些对理解二分不会有任何帮助。
事实上,当搞清楚二分的是什么内容之后,何种形式写法都能写出。
代码:
```Java
class Solution {
public int search(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] <= t) l = mid;
else r = mid - 1;
}
return nums[r] == t ? r : -1;
}
}
```
```Java
class Solution {
public int search(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= t) r = mid;
else l = mid + 1;
}
return nums[r] == t ? r : -1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.704` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/705. 设计哈希集合（简单）.md | 705. 设计哈希集合 | https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/ | 简单 | [
"哈希表"
] | 不使用任何内建的哈希表库设计一个哈希集合(HashSet)。
实现 MyHashSet 类:
void add(key) 向哈希集合中插入值 key 。
bool contains(key) 返回哈希集合中是否存在这个值 key 。
void remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值,什么也不做。
示例:
```
输入:
["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"]
[[], [1], [2], [1], [3], [2], [2], [2], [2]]
输出:
[null, null, null, true, false, null, true, null, false]
解释:
MyHashSet myHashSet = new MyHashSet();
myHashSet.add(1); // set = [1]
myHashSet.add(2); // set = [1, 2]
myHashSet.contains(1); // 返回 True
myHashSet.contains(3); // 返回 False ,(未找到)
myHashSet.add(2); // set = [1, 2]
myHashSet.contains(2); // 返回 True
myHashSet.remove(2); // set = [1]
myHashSet.contains(2); // 返回 False ,(已移除)
```
提示:
* 0 <= key <= $10^6$
* 最多调用 $10^4$ 次 add、remove 和 contains 。 | ### 简单数组
由于题目给出了 `0 <= key <= 10^6` 数据范围,同时限定了 key 只能是 int。
我们可以直接使用一个 boolean 数组记录某个 key 是否存在,key 直接对应 boolean 的下标。
代码:
```Java
class MyHashSet {
boolean[] nodes = new boolean[1000009];
public void add(int key) {
nodes[key] = true;
}
public void remove(int key) {
nodes[key] = false;
}
public boolean contains(int key) {
return nodes[key];
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
***
### 链表
我们利用「链表」来构建 Set,这也是工程上最简单的一种实现方式。
代码:
```Java
class MyHashSet {
// 由于使用的是「链表」,这个值可以取得很小
Node[] nodes = new Node[10009];
public void add(int key) {
// 根据 key 获取哈希桶的位置
int idx = getIndex(key);
// 判断链表中是否已经存在
Node loc = nodes[idx], tmp = loc;
if (loc != null) {
Node prev = null;
while (tmp != null) {
if (tmp.key == key) {
return;
}
prev = tmp;
tmp = tmp.next;
}
tmp = prev;
}
Node node = new Node(key);
// 头插法
// node.next = loc;
// nodes[idx] = node;
// 尾插法
if (tmp != null) {
tmp.next = node;
} else {
nodes[idx] = node;
}
}
public void remove(int key) {
int idx = getIndex(key);
Node loc = nodes[idx];
if (loc != null) {
Node prev = null;
while (loc != null) {
if (loc.key == key) {
if (prev != null) {
prev.next = loc.next;
} else {
nodes[idx] = loc.next;
}
return;
}
prev = loc;
loc = loc.next;
}
}
}
public boolean contains(int key) {
int idx = getIndex(key);
Node loc = nodes[idx];
if (loc != null) {
while (loc != null) {
if (loc.key == key) {
return true;
}
loc = loc.next;
}
}
return false;
}
static class Node {
private int key;
private Node next;
private Node(int key) {
this.key = key;
}
}
int getIndex(int key) {
// 因为 nodes 的长度只有 10009,对应的十进制的 10011100011001(总长度为 32 位,其余高位都是 0)
// 为了让 key 对应的 hash 高位也参与运算,这里对 hashCode 进行右移异或
// 使得 hashCode 的高位随机性和低位随机性都能体现在低 16 位中
int hash = Integer.hashCode(key);
hash ^= (hash >>> 16);
return hash % nodes.length;
}
}
```
* 时间复杂度:由于没有扩容的逻辑,最坏情况下复杂度为 $O(n)$,一般情况下复杂度为 $O(1)$
* 空间复杂度:$O(1)$
***
### 分桶数组
事实上我们还可以实现一个类似「bitmap」数据结构。
使用 int 中的每一位代表一个位置。
由于数据范围为 `0 <= key <= 10^6`,我们最多需要的 int 数量不会超过 40000。
因此我们可以建立一个 buckets 数组,数组装载的 int 类型数值。
* 先对 key 进行 `key / 32`,确定当前 key 所在桶的位置(大概位置)
* 再对 key 进行 `key % 32`,确定当前 key 所在桶中的哪一位(精确位置)
根据位运算对「精确位置」进行修改。
代码:
```Java
class MyHashSet {
int[] bs = new int[40000];
public void add(int key) {
int bucketIdx = key / 32;
int bitIdx = key % 32;
setVal(bucketIdx, bitIdx, true);
}
public void remove(int key) {
int bucketIdx = key / 32;
int bitIdx = key % 32;
setVal(bucketIdx, bitIdx, false);
}
public boolean contains(int key) {
int bucketIdx = key / 32;
int bitIdx = key % 32;
return getVal(bucketIdx, bitIdx);
}
void setVal(int bucket, int loc, boolean val) {
if (val) {
int u = bs[bucket] | (1 << loc);
bs[bucket] = u;
} else {
int u = bs[bucket] & ~(1 << loc);
bs[bucket] = u;
}
}
boolean getVal(int bucket, int loc) {
int u = (bs[bucket] >> loc) & 1;
return u == 1;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.705` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/706. 设计哈希映射（简单）.md | 706. 设计哈希映射 | https://leetcode-cn.com/problems/design-hashmap/solution/yi-ti-shuang-jie-jian-dan-shu-zu-lian-bi-yhiw/ | 简单 | [
"哈希表"
] | 不使用任何内建的哈希表库设计一个哈希映射(HashMap)。
实现 MyHashMap 类:
MyHashMap() 用空映射初始化对象
void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中,则更新其对应的值 value 。
int get(int key) 返回特定的 key 所映射的 value ;如果映射中不包含 key 的映射,返回 -1 。
void remove(key) 如果映射中存在 key 的映射,则移除 key 和它所对应的 value 。
示例:
```
输入:
["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]
[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]
输出:
[null, null, null, 1, -1, null, 1, null, -1]
解释:
MyHashMap myHashMap = new MyHashMap();
myHashMap.put(1, 1); // myHashMap 现在为 [[1,1]]
myHashMap.put(2, 2); // myHashMap 现在为 [[1,1], [2,2]]
myHashMap.get(1); // 返回 1 ,myHashMap 现在为 [[1,1], [2,2]]
myHashMap.get(3); // 返回 -1(未找到),myHashMap 现在为 [[1,1], [2,2]]
myHashMap.put(2, 1); // myHashMap 现在为 [[1,1], [2,1]](更新已有的值)
myHashMap.get(2); // 返回 1 ,myHashMap 现在为 [[1,1], [2,1]]
myHashMap.remove(2); // 删除键为 2 的数据,myHashMap 现在为 [[1,1]]
myHashMap.get(2); // 返回 -1(未找到),myHashMap 现在为 [[1,1]]
```
提示:
* 0 <= key, value <= $10^6$
* 最多调用 $10^4$ 次 put、get 和 remove 方法 | ### 简单数组解法
与昨天的 [705. 设计哈希集合](https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/) 不同。
我们不仅仅需要记录一个元素存在与否,还需要记录该元素对应的值是什么。
由于题目限定了数据范围 $0 <= key, value <= 10^6$,和 kv 的数据类型。
我们可以使用 int 类型的数组实现哈希表功能。
```java
class MyHashMap {
int INF = Integer.MAX_VALUE;
int N = 1000009;
int[] map = new int[N];
public MyHashMap() {
Arrays.fill(map, INF);
}
public void put(int key, int value) {
map[key] = value;
}
public int get(int key) {
return map[key] == INF ? -1 : map[key];
}
public void remove(int key) {
map[key] = INF;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
***
### 链表解法
与 [705. 设计哈希集合](https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/) 同理,我们可以利用「链表」来构建 Map,这也是工程上最简单的一种实现方式。
```java
class MyHashMap {
static class Node {
int key, value;
Node next;
Node(int _key, int _value) {
key = _key;
value = _value;
}
}
// 由于使用的是「链表」,这个值可以取得很小
Node[] nodes = new Node[10009];
public void put(int key, int value) {
// 根据 key 获取哈希桶的位置
int idx = getIndex(key);
// 判断链表中是否已经存在
Node loc = nodes[idx], tmp = loc;
if (loc != null) {
Node prev = null;
while (tmp != null) {
if (tmp.key == key) {
tmp.value = value;
return;
}
prev = tmp;
tmp = tmp.next;
}
tmp = prev;
}
Node node = new Node(key, value);
// 头插法
// node.next = loc;
// nodes[idx] = node;
// 尾插法
if (tmp != null) {
tmp.next = node;
} else {
nodes[idx] = node;
}
}
public void remove(int key) {
int idx = getIndex(key);
Node loc = nodes[idx];
if (loc != null) {
Node prev = null;
while (loc != null) {
if (loc.key == key) {
if (prev != null) {
prev.next = loc.next;
} else {
nodes[idx] = loc.next;
}
return;
}
prev = loc;
loc = loc.next;
}
}
}
public int get(int key) {
int idx = getIndex(key);
Node loc = nodes[idx];
if (loc != null) {
while (loc != null) {
if (loc.key == key) {
return loc.value;
}
loc = loc.next;
}
}
return -1;
}
int getIndex(int key) {
// 因为 nodes 的长度只有 10009,对应的十进制的 10011100011001(总长度为 32 位,其余高位都是 0)
// 为了让 key 对应的 hash 高位也参与运算,这里对 hashCode 进行右移异或
// 使得 hashCode 的高位随机性和低位随机性都能体现在低 16 位中
int hash = Integer.hashCode(key);
hash ^= (hash >>> 16);
return hash % nodes.length;
}
}
```
* 时间复杂度:由于没有扩容的逻辑,最坏情况下复杂度为 $O(n)$,一般情况下复杂度为 $O(1)$
* 空间复杂度:$O(1)$
***
### 开放寻址解法
除了使用「链表」来解决哈希冲突以外,还能使用「开放寻址法」来解决。
```java
class MyHashMap {
static class Node {
int key, value;
Node next;
boolean isDeleted;
Node(int _key, int _value) {
key = _key;
value = _value;
}
}
// 冲突时的偏移量
int OFFSET = 1;
Node[] nodes = new Node[10009];
public void put(int key, int value) {
int idx = getIndex(key);
Node node = nodes[idx];
if (node != null) {
node.value = value;
node.isDeleted = false;
} else {
node = new Node(key, value);
nodes[idx] = node;
}
}
public void remove(int key) {
Node node = nodes[getIndex(key)];
if (node != null) node.isDeleted = true;
}
public int get(int key) {
Node node = nodes[getIndex(key)];
if (node == null) return -1;
return node.isDeleted ? -1 : node.value;
}
// 当 map 中没有 key 的时候,getIndex 总是返回一个空位置
// 当 map 中包含 key 的时候,getIndex 总是返回 key 所在的位置
int getIndex(int key) {
int hash = Integer.hashCode(key);
hash ^= (hash >>> 16);
int n = nodes.length;
int idx = hash % n;
while (nodes[idx] != null && nodes[idx].key != key) {
hash += OFFSET;
idx = hash % n;
}
return idx;
}
}
```
* 时间复杂度:一般情况下复杂度为 $O(1)$,极端情况下为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.706` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/707. 设计链表（中等）.md | 707. 设计链表 | https://leetcode.cn/problems/design-linked-list/solution/by-ac_oier-vaib/ | 中等 | [
"链表"
] | 设计链表的实现。您可以选择使用单链表或双链表。
单链表中的节点应该具有两个属性:`val` 和 `next`。`val` 是当前节点的值,`next` 是指向下一个节点的指针/引用。
如果要使用双向链表,则还需要一个属性 `prev` 以指示链表中的上一个节点。假设链表中的所有节点都是 `0-index` 的。
在链表类中实现这些功能:
* `get(index)`:获取链表中第 `index` 个节点的值。如果索引无效,则返回`-1`。
* `addAtHead(val)`:在链表的第一个元素之前添加一个值为 `val` 的节点。插入后,新节点将成为链表的第一个节点。
* `addAtTail(val)`:将值为 `val` 的节点追加到链表的最后一个元素。
* `addAtIndex(index,val)`:在链表中的第 `index` 个节点之前添加值为 `val` 的节点。如果 `index` 等于链表的长度,则该节点将附加到链表的末尾。如果 `index` 大于链表长度,则不会插入节点。如果 `index` 小于 `0`,则在头部插入节点。
* `deleteAtIndex(index)`:如果索引 `index` 有效,则删除链表中的第 `index` 个节点。
示例:
```
MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3
```
提示:
* 所有 `val` 值都在 $[1, 1000]$ 之内。
* 操作次数将在 $[1, 1000]$ 之内。
* 请不要使用内置的 `LinkedList` 库。 | ### 双向链表
一道手写链表裸题(啊嘿,$9$ 月活动的同学表示很棒 🤣
由于需要涉及部分 `index` 相关操作,因此我们可以实现一个「双向链表」,同时使用变量 `sz` 记录下当前链表的总长度,这样在涉及 `index` 操作时,可从较近的一边出发遍历,剩下的则是常规的链表节点操作。
> 一些细节:所有的链表题目我们都可以引入前后哨兵来简化边界处理;同时能写双链表自然能写单链表,因此如果你没有顺利写出双链表的话,在看了题解写完双链表后,再手写一遍单链表作为练习。
Java 代码:
```Java
class MyLinkedList {
class Node {
Node prev, next;
int val;
Node (int _val) {
val = _val;
}
}
Node he = new Node(-1), ta = new Node(-1);
int sz = 0;
public MyLinkedList() {
he.next = ta; ta.prev = he;
}
public int get(int index) {
Node node = getNode(index);
return node == null ? -1 : node.val;
}
public void addAtHead(int val) {
Node node = new Node(val);
node.next = he.next; node.prev = he;
he.next.prev = node; he.next = node;
sz++;
}
public void addAtTail(int val) {
Node node = new Node(val);
node.prev = ta.prev; node.next = ta;
ta.prev.next = node; ta.prev = node;
sz++;
}
public void addAtIndex(int index, int val) {
if (index > sz) return ;
if (index <= 0) {
addAtHead(val);
} else if (index == sz) {
addAtTail(val);
} else {
Node node = new Node(val), cur = getNode(index);
node.next = cur; node.prev = cur.prev;
cur.prev.next = node; cur.prev = node;
sz++;
}
}
public void deleteAtIndex(int index) {
Node cur = getNode(index);
if (cur == null) return ;
cur.next.prev = cur.prev;
cur.prev.next = cur.next;
sz--;
}
Node getNode(int index) {
boolean isLeft = index < sz / 2;
if (!isLeft) index = sz - index - 1;
for (Node cur = isLeft ? he.next : ta.prev; cur != ta && cur != he; cur = isLeft ? cur.next : cur.prev) {
if (index-- == 0) return cur;
}
return null;
}
}
```
TypeScript 代码:
```TypeScript
class TNode {
prev: TNode
next: TNode
val: number
constructor(_val: number) {
this.val = _val
}
}
class MyLinkedList {
he = new TNode(-1)
ta = new TNode(-1)
sz = 0
constructor() {
this.he.next = this.ta; this.ta.prev = this.he
}
get(index: number): number {
const node = this.getNode(index)
return node == null ? -1 : node.val
}
addAtHead(val: number): void {
const node = new TNode(val)
node.next = this.he.next; node.prev = this.he
this.he.next.prev = node; this.he.next = node
this.sz++
}
addAtTail(val: number): void {
const node = new TNode(val)
node.prev = this.ta.prev; node.next = this.ta
this.ta.prev.next = node; this.ta.prev = node
this.sz++
}
addAtIndex(index: number, val: number): void {
if (index > this.sz) return
if (index <= 0) {
this.addAtHead(val)
} else if (index == this.sz) {
this.addAtTail(val)
} else {
const node = new TNode(val), cur = this.getNode(index)
node.next = cur; node.prev = cur.prev
cur.prev.next = node; cur.prev = node
this.sz++
}
}
deleteAtIndex(index: number): void {
const cur = this.getNode(index)
if (cur == null) return
cur.prev.next = cur.next
cur.next.prev = cur.prev
this.sz--
}
getNode(index: number): TNode | null {
const isLeft = index < this.sz / 2
if (!isLeft) index = this.sz - index - 1
for (let cur = isLeft ? this.he.next : this.ta.prev; cur != this.ta && cur != this.he; cur = isLeft ? cur.next : cur.prev) {
if (index-- == 0) return cur
}
return null
}
}
```
Python 代码:
```Python
class Node:
def __init__(self, _val):
self.val = _val
self.prev = None
self.next = None
class MyLinkedList:
def __init__(self):
self.he = Node(-1)
self.ta = Node(-1)
self.he.next = self.ta
self.ta.prev = self.he
self.sz = 0
def get(self, index: int) -> int:
node = self.getNode(index)
return node.val if node else -1
def addAtHead(self, val: int) -> None:
node = Node(val)
node.next = self.he.next
node.prev = self.he
self.he.next.prev = node
self.he.next = node
self.sz += 1
def addAtTail(self, val: int) -> None:
node = Node(val)
node.prev = self.ta.prev
node.next = self.ta
self.ta.prev.next = node
self.ta.prev = node
self.sz += 1
def addAtIndex(self, index: int, val: int) -> None:
if index > self.sz:
return
if index <= 0:
self.addAtHead(val)
elif index == self.sz:
self.addAtTail(val)
else:
node, cur = Node(val), self.getNode(index)
node.next = cur
node.prev = cur.prev
cur.prev.next = node
cur.prev = node
self.sz += 1
def deleteAtIndex(self, index: int) -> None:
node = self.getNode(index)
if node:
node.prev.next = node.next
node.next.prev = node.prev
self.sz -= 1
def getNode(self, index: int) -> Node | None:
isLeft = index < self.sz / 2
if not isLeft:
index = self.sz - index - 1
cur = self.he.next if isLeft else self.ta.prev
while cur != self.he and cur != self.ta:
if index == 0:
return cur
index -= 1
cur = cur.next if isLeft else cur.prev
return None
```
* 时间复杂度:涉及 `index` 的相关操作复杂度为 $O(index)$;其余操作均为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.707` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/709. 转换成小写字母（简单）.md | 709. 转换成小写字母 | https://leetcode-cn.com/problems/to-lower-case/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-czpo/ | 简单 | [
"模拟"
] | 给你一个字符串 `s` ,将该字符串中的大写字母转换成相同的小写字母,返回新的字符串。
示例 1:
```
输入:s = "Hello"
输出:"hello"
```
示例 2:
```
输入:s = "here"
输出:"here"
```
示例 3:
```
输入:s = "LOVELY"
输出:"lovely"
```
提示:
* `1 <= s.length <= 100`
* `s` 由 `ASCII` 字符集中的可打印字符组成 | ### 模拟
根据题意进行模拟。
代码:
```Java
class Solution {
public String toLowerCase(String s) {
return s.toLowerCase();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.709` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/701-710/710. 黑名单中的随机数（困难）.md | 710. 黑名单中的随机数 | https://leetcode.cn/problems/random-pick-with-blacklist/solution/by-ac_oier-2rww/ | 困难 | [
"前缀和",
"二分",
"离散化",
"随机化",
"哈希表"
] | 给定一个整数 `n` 和一个 无重复 黑名单整数数组 `blacklist`。
设计一种算法,从 $[0, n - 1]$ 范围内的任意整数中选取一个 未加入 黑名单 `blacklist` 的整数。任何在上述范围内且不在黑名单 `blacklist` 中的整数都应该有 同等的可能性 被返回。
优化你的算法,使它最小化调用语言 内置 随机函数的次数。
实现 `Solution` 类:
* `Solution(int n, int[] blacklist)` 初始化整数 `n` 和被加入黑名单 `blacklist` 的整数
* `int pick()` 返回一个范围为 $[0, n - 1]$ 且不在黑名单 `blacklist` 中的随机整数
示例 1:
```
输入
["Solution", "pick", "pick", "pick", "pick", "pick", "pick", "pick"]
[[7, [2, 3, 5]], [], [], [], [], [], [], []]
输出
[null, 0, 4, 1, 6, 1, 0, 4]
解释
Solution solution = new Solution(7, [2, 3, 5]);
solution.pick(); // 返回0,任何[0,1,4,6]的整数都可以。注意,对于每一个pick的调用,
// 0、1、4和6的返回概率必须相等(即概率为1/4)。
solution.pick(); // 返回 4
solution.pick(); // 返回 1
solution.pick(); // 返回 6
solution.pick(); // 返回 1
solution.pick(); // 返回 0
solution.pick(); // 返回 4
```
提示:
* $1 <= n <= 10^9$
* $0 <= blacklist.length <= \min(1065, n - 1)$
* $0 <= blacklist[i] < n$
* `blacklist` 中所有值都 不同
* `pick` 最多被调用 $2 \times 10^4$ 次 | ### 前缀和 + 二分
为了方便,我们记 `blacklist` 为 `bs`,将其长度记为 `m`。
问题本质是让我们从 $[0, n - 1]$ 范围内随机一个数,这数不能在 `bs` 里面。
由于 $n$ 的范围是 $1e9$,我们不能在对范围在 $[0, n - 1]$ 且不在 `bs` 中的点集进行离散化,因为离散化后的点集大小仍很大。
同时 $m$ 的范围是 $1e5$,我们也不能使用普通的拒绝采样做法,这样单次 `pick` 被拒绝的次数可能很大。
一个简单且绝对正确的做法是:**我们不对「点」做离散化,而利用 `bs` 数据范围为 $1e5$,来对「线段」做离散化**。
具体的,我们先对 `bs` 进行排序,然后从前往后处理所有的 $bs[i]$,将相邻 $bs[i]$ 之间的能被选择的「线段」以二元组 $(a, b)$ 的形式进行记录(即一般情况下的 $a = bs[i - 1] + 1$,$b = bs[i] - 1$),存入数组 `list` 中(注意特殊处理一下两端的线段)。
当处理完所有的 $bs[i]$ 后,我们得到了所有可被选择线段,同时对于每个线段可直接算得其所包含的整数点数。
我们可以对 `list` 数组做一遍「线段所包含点数」的「前缀和」操作,得到 `sum` 数组,同时得到所有线段所包含的总点数(前缀和数组的最后一位)。
对于 `pick` 操作而言,我们先在 $[1, tot]$ 范围进行随机(其中 $tot$ 代表总点数),假设取得的随机值为 $val$,然后在前缀和数组中进行二分,找到第一个满足「值大于等于 $val$」的位置(含义为找到这个点所在的线段),然后再利用该线段的左右端点的值,取出对应的点。
代码:
```Java
class Solution {
List<int[]> list = new ArrayList<>();
int[] sum = new int[100010];
int sz;
Random random = new Random();
public Solution(int n, int[] bs) {
Arrays.sort(bs);
int m = bs.length;
if (m == 0) {
list.add(new int[]{0, n - 1});
} else {
if (bs[0] != 0) list.add(new int[]{0, bs[0] - 1});
for (int i = 1; i < m; i++) {
if (bs[i - 1] == bs[i] - 1) continue;
list.add(new int[]{bs[i - 1] + 1, bs[i] - 1});
}
if (bs[m - 1] != n - 1) list.add(new int[]{bs[m - 1] + 1, n - 1});
}
sz = list.size();
for (int i = 1; i <= sz; i++) {
int[] info = list.get(i - 1);
sum[i] = sum[i - 1] + info[1] - info[0] + 1;
}
}
public int pick() {
int val = random.nextInt(sum[sz]) + 1;
int l = 1, r = sz;
while (l < r) {
int mid = l + r >> 1;
if (sum[mid] >= val) r = mid;
else l = mid + 1;
}
int[] info = list.get(r - 1);
int a = info[0], b = info[1], end = sum[r];
return b - (end - val);
}
}
```
* 时间复杂度:在初始化操作中:对 `bs` 进行排序复杂度为 $O(m\log{m})$;统计所有线段复杂度为 $O(m)$;对所有线段求前缀和复杂度为 $O(m)$。在 `pick` 操作中:随机后会对所有线段做二分,复杂度为 $O(\log{m})$
* 空间复杂度:$O(m)$
---
### 哈希表
总共有 $n$ 个数,其中 $m$ 个数不可被选,即真实可选个数为 $n - m$ 个。
为了能够在 $[0, n - m)$ 连续段内进行随机,我们可以将 $[0, n - m)$ 内不可被选的数映射到 $[n - m, n - 1]$ 内可选的数上。
具体的,我们可以使用两个 `Set` 结构 `s1` 和 `s2` 分别记录在 $[0, n - m)$ 和 $[n - m, n - 1]$ 范围内的黑名单数字。
在 `pick` 操作时,我们在 $[0, n - m)$ 范围内进行随机,根据随机值 $val$ 是否为黑名单内数字(是否在 `s1` 中)进行分情况讨论:
* 随机值 `val` 不在 `s1` 中,说明 `val` 是真实可选的数值,直接返回;
* 随机值 `val` 在 `s1` 中,说明 `val` 是黑名单内的数值,我们先查询是否已存在 `val` 的映射记录,若已存在直接返回其映射值;否则需要在 $[n - m, n - 1]$ 内找到一个可替代它的数值,我们可以使用一个变量 `idx` 在 $[n- m, n - 1]$ 范围内从前往后扫描,找到第一个未被使用的,同时不在 `s2` 中(不在黑名单内)的数字,假设找到的值为 `x`,将 `x` 进行返回(同时将 `val` 与 `x` 的映射关系,用哈希表进行记录)。
代码:
```Java
class Solution {
int n, m, idx;
Random random = new Random();
Set<Integer> s1 = new HashSet<>(), s2 = new HashSet<>();
Map<Integer, Integer> map = new HashMap<>();
public Solution(int _n, int[] bs) {
n = _n; m = bs.length;
int max = n - m;
for (int x : bs) {
if (x < max) s1.add(x);
else s2.add(x);
}
idx = n - m;
}
public int pick() {
int val = random.nextInt(n - m);
if (!s1.contains(val)) return val;
if (!map.containsKey(val)) {
while (s2.contains(idx)) idx++;
map.put(val, idx++);
}
return map.get(val);
}
}
```
* 时间复杂度:初始化操作复杂度为 $O(m)$,`pick` 操作复杂度为 $O(1)$
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.710` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/71. 简化路径（中等）.md | 71. 简化路径 | https://leetcode-cn.com/problems/simplify-path/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-w7xi/ | 中等 | [
"模拟",
"栈"
] | 给你一个字符串 `path`,表示指向某一文件或目录的 `Unix` 风格 绝对路径 (以 `'/'` 开头),请你将其转化为更加简洁的规范路径。
在 `Unix` 风格的文件系统中,一个点(`.`)表示当前目录本身;此外,两个点 (`..`) 表示将目录切换到上一级(指向父目录);两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠(即,`'//'`)都被视为单个斜杠 `'/'` 。 对于此问题,任何其他格式的点(例如,`'...'`)均被视为文件`/`目录名称。
请注意,返回的 规范路径 必须遵循下述格式:
* 始终以斜杠 `'/'` 开头。
* 两个目录名之间必须只有一个斜杠 `'/'` 。
* 最后一个目录名(如果存在)不能 以 `'/'` 结尾。
* 此外,路径仅包含从根目录到目标文件或目录的路径上的目录(即,不含 '`.'` 或 `'..'`)。
返回简化后得到的 **规范路径**。
示例 1:
```
输入:path = "/home/"
输出:"/home"
解释:注意,最后一个目录名后面没有斜杠。
```
示例 2:
```
输入:path = "/../"
输出:"/"
解释:从根目录向上一级是不可行的,因为根目录是你可以到达的最高级。
```
示例 3:
```
输入:path = "/home//foo/"
输出:"/home/foo"
解释:在规范路径中,多个连续斜杠需要用一个斜杠替换。
```
示例 4:
```
输入:path = "/a/./b/../../c/"
输出:"/c"
```
提示:
* $1 <= path.length <= 3000$
* `path` 由英文字母,数字,`'.'`,`'/'` 或 `'_'` 组成。
* `path` 是一个有效的 `Unix` 风格绝对路径。 | ### 模拟
根据题意,使用栈进行模拟即可。
具体的,从前往后处理 `path`,每次以 `item` 为单位进行处理(有效的文件名),根据 `item` 为何值进行分情况讨论:
* `item` 为有效值 :存入栈中;
* `item` 为 `..` :弹出栈顶元素(若存在);
* `item` 为 `.` :不作处理。
代码:
```Java
class Solution {
public String simplifyPath(String path) {
Deque<String> d = new ArrayDeque<>();
int n = path.length();
for (int i = 1; i < n; ) {
if (path.charAt(i) == '/' && ++i >= 0) continue;
int j = i + 1;
while (j < n && path.charAt(j) != '/') j++;
String item = path.substring(i, j);
if (item.equals("..")) {
if (!d.isEmpty()) d.pollLast();
} else if (!item.equals(".")) {
d.addLast(item);
}
i = j;
}
StringBuilder sb = new StringBuilder();
while (!d.isEmpty()) sb.append("/" + d.pollFirst());
return sb.length() == 0 ? "/" : sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.71` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/73. 矩阵置零（中等）.md | 73. 矩阵置零 | https://leetcode-cn.com/problems/set-matrix-zeroes/solution/xiang-jie-fen-san-bu-de-o1-kong-jian-jie-dbxd/ | 中等 | [
"模拟"
] | 给定一个 $m \times n$ 的矩阵,如果一个元素为 $0$ ,则将其所在行和列的所有元素都设为 $0$ 。
请使用「原地」算法。
进阶:
* 一个直观的解决方案是使用 $O(m \times n)$ 的额外空间,但这并不是一个好的解决方案。
* 一个简单的改进方案是使用 $O(m + n)$ 的额外空间,但这仍然不是最好的解决方案。
* 你能想出一个仅使用常量空间的解决方案吗?
示例 1:
```
输入:matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出:[[1,0,1],[0,0,0],[1,0,1]]
```
示例 2:
```
输入:matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出:[[0,0,0,0],[0,4,5,0],[0,3,1,0]]
```
提示:
* $m == matrix.length$
* $n == matrix[0].length$
* $1 <= m, n <= 200$
* $-2^{31} <= matrix[i][j] <= 2^{31} - 1$ | ### 前言
由于 $O(m \times n)$ 和 $O(m+n)$ 空间的解法都十分简单,无非是「同等大小的矩阵」或「与行列数量相等的标识」来记录置零信息。
这里着重讲解利用原矩阵的 $O(1)$ 空间解法。
---
### O(1) 空间
**1. 使用两个变量(r0 & c0),记录「首行 & 首列」是否该被置零**
**2.「非首行首列」的位置**
* 将置零信息存储到原矩阵
* 根据置零信息,置零「非首行首列」的位置
**3. 使用 r0 & c0 ,置零「首行 & 首列」**
代码:
```Java
class Solution {
public void setZeroes(int[][] mat) {
int m = mat.length, n = mat[0].length;
// 1. 扫描「首行」和「首列」记录「首行」和「首列」是否该被置零
boolean r0 = false, c0 = false;
for (int i = 0; i < m; i++) {
if (mat[i][0] == 0) {
r0 = true;
break;
}
}
for (int j = 0; j < n; j++) {
if (mat[0][j] == 0) {
c0 = true;
break;
}
}
// 2.1 扫描「非首行首列」的位置,如果发现零,将需要置零的信息存储到该行的「最左方」和「最上方」的格子内
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (mat[i][j] == 0) mat[i][0] = mat[0][j] = 0;
}
}
// 2.2 根据刚刚记录在「最左方」和「最上方」格子内的置零信息,进行「非首行首列」置零
for (int j = 1; j < n; j++) {
if (mat[0][j] == 0) {
for (int i = 1; i < m; i++) mat[i][j] = 0;
}
}
for (int i = 1; i < m; i++) {
if (mat[i][0] == 0) Arrays.fill(mat[i], 0);
}
// 3. 根据最开始记录的「首行」和「首列」信息,进行「首行首列」置零
if (r0) for (int i = 0; i < m; i++) mat[i][0] = 0;
if (c0) Arrays.fill(mat[0], 0);
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.73` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/74. 搜索二维矩阵（中等）.md | 74. 搜索二维矩阵 | https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/ | 中等 | [
"二叉搜索树",
"二分"
] | 编写一个高效的算法来判断 m x n 矩阵中,是否存在一个目标值。该矩阵具有如下特性:
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
示例 1:
```
输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出:true
```
示例 2:
```
输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出:false
```
提示:
* m == matrix.length
* n == matrix[i].length
* 1 <= m, n <= 100
* -$10^4$ <= matrix[i][j], target <= $10^4$ | ### 二分解法(一)
由于二维矩阵固定列的「从上到下」或者固定行的「从左到右」都是升序的。
因此我们可以使用两次二分来定位到目标位置:
1. 第一次二分:从第 0 列中的「所有行」开始找,找到合适的行 `row`
2. 第二次二分:从 `row` 中「所有列」开始找,找到合适的列 `col`
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] mat, int t) {
int m = mat.length, n = mat[0].length;
// 第一次二分:定位到所在行(从上往下,找到最后一个满足 mat[x]][0] <= t 的行号)
int l = 0, r = m - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (mat[mid][0] <= t) {
l = mid;
} else {
r = mid - 1;
}
}
int row = r;
if (mat[row][0] == t) return true;
if (mat[row][0] > t) return false;
// 第二次二分:从所在行中定位到列(从左到右,找到最后一个满足 mat[row][x] <= t 的列号)
l = 0; r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (mat[row][mid] <= t) {
l = mid;
} else {
r = mid - 1;
}
}
int col = r;
return mat[row][col] == t;
}
}
```
* 时间复杂度:$O(\log{m} + \log{n})$
* 空间复杂度:$O(1)$
***
### 二分解法(二)
当然,因为将二维矩阵的行尾和行首连接,也具有单调性。
我们可以将「二维矩阵」当做「一维矩阵」来做。
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] mat, int t) {
int m = mat.length, n = mat[0].length;
int l = 0, r = m * n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (mat[mid / n][mid % n] <= t) {
l = mid;
} else {
r = mid - 1;
}
}
return mat[r / n][r % n] == t;
}
}
```
* 时间复杂度:$O(\log{(m * n)})$
* 空间复杂度:$O(1)$
***
### 抽象 BST 解法
我们可以将二维矩阵抽象成「以右上角为根的 BST」:
那么我们可以从根(右上角)开始搜索,如果当前的节点不等于目标值,可以按照树的搜索顺序进行:
1. 当前节点「大于」目标值,搜索当前节点的「左子树」,也就是当前矩阵位置的「左方格子」,即 y--
2. 当前节点「小于」目标值,搜索当前节点的「右子树」,也就是当前矩阵位置的「下方格子」,即 x++
代码:
```Java
class Solution {
int m, n;
public boolean searchMatrix(int[][] mat, int t) {
m = mat.length; n = mat[0].length;
int x = 0, y = n - 1;
while (check(x, y) && mat[x][y] != t) {
if (mat[x][y] > t) {
y--;
} else {
x++;
}
}
return check(x, y) && mat[x][y] == t;
}
boolean check(int x, int y) {
return x >= 0 && x < m && y >= 0 && y < n;
}
}
```
* 时间复杂度:$O(m+n)$
* 空间复杂度:$O(1)$
***
### 拓展
如果你掌握了上述解法的话,你还可以试试这题:
[240. 搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.74` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/75. 颜色分类（中等）.md | 75. 颜色分类 | https://leetcode.cn/problems/sort-colors/solution/by-ac_oier-7lwk/ | 中等 | [
"排序",
"双指针"
] | 给定一个包含红色、白色和蓝色、共 `n` 个元素的数组 `nums`,原地对它们进行排序,使得相同颜色的元素相邻,并按照红色、白色、蓝色顺序排列。
我们使用整数 `0`、 `1` 和 `2` 分别表示红色、白色和蓝色。
必须在不使用库的 `sort` 函数的情况下解决这个问题。
示例 1:
```
输入:nums = [2,0,2,1,1,0]
输出:[0,0,1,1,2,2]
```
示例 2:
```
输入:nums = [2,0,1]
输出:[0,1,2]
```
提示:
* $n = nums.length$
* $1 <= n <= 300$
* `nums[i]` 为 `0`、`1` 或 `2`
进阶:
* 你可以不使用代码库中的排序函数来解决这道题吗?
* 你能想出一个仅使用常数空间的一趟扫描算法吗? | ### 双指针
该题为经典的荷兰国旗问题,由于题目本质是要我们将数分成三段。
因此除了使用一个变量 `idx` 代指处理到哪一个 $nums[i]$ 以外,至少还需要两个变量来代指三段的边界:
* 变量 `l` 为下一个填入 `0` 的位置(因此范围 $[0, l - 1]$ 均为 `0`,初始化 $l = 0$,代表空集)
* 变量 `r` 为下一个填入 `2` 的位置(因此范围 $[r + 1, n - 1]$ 均为 `2`,初始化 $r = n - 1$,代表空集)
由于 $[0, idx - 1]$ 均为处理过的数值(即 `0` 和 `2` 必然都被分到了两端),同时 $l - 1$ 又是 `0` 的右边界,因此 $[l, idx - 1]$ 为 `1` 的区间,而 $[idx, r]$ 为未处理的数值。
上述几个变量的定义是该题唯一需要理清的地方。
不失一般性,根据当前处理到的 $nums[idx]$ 进行分情况讨论:
* $nums[idx] = 0$:此时将其与位置 `l` 进行互换(记住 `l` 为下一个待填入 `0` 的位置,同时 $[l, idx - 1]$ 为 `1` 的区间),本质是将 $nums[idx]$ 的 `0` 和 $nums[l]$ 的 `1` 进行互换,因此互换后将 `l` 和 `idx` 进行右移;
* $nums[idx] = 1$:由于 $[l, idx - 1]$ 本身就是 `1` 的区间,直接将 `idx` 进行右移即可;
* $nums[idx] = 2$:此时将其与位置 `r` 进行互换(`r` 为下一个待填入 `2` 的位置,但 $[idx, r]$ 为未处理区间),也就是我们互换后,只能明确换到位置 $nums[r]$ 的位置为 `2`,可以对 `r` 进行左移,但不确定新 $nums[idx]$ 为何值,因此保持 `idx` 不变再入循环判断。
最后当 $idx > r$(含义为未处理区间为空集),整个分三段过程结束。
Java 代码:
```Java
class Solution {
public void sortColors(int[] nums) {
int n = nums.length;
int l = 0, r = n - 1, idx = 0;
while (idx <= r) {
if (nums[idx] == 0) swap(nums, l++, idx++);
else if (nums[idx] == 1) idx++;
else swap(nums, idx, r--);
}
}
void swap(int[] nums, int i, int j) {
int c = nums[i];
nums[i] = nums[j];
nums[j] = c;
}
}
```
TypeScript 代码:
```TypeScript
function sortColors(nums: number[]): void {
const n = nums.length
let l = 0, r = n - 1, idx = 0
while (idx <= r) {
if (nums[idx] == 0) swap(nums, l++, idx++)
else if (nums[idx] == 1) idx++
else swap(nums, idx, r--)
}
}
function swap(nums: number[], i: number, j: number): void {
const c = nums[i]
nums[i] = nums[j]
nums[j] = c
}
```
Python 代码:
```Python
class Solution:
def sortColors(self, nums: List[int]) -> None:
n = len(nums)
l, r, idx = 0, n - 1, 0
while idx <= r:
if nums[idx] == 0:
nums[l], nums[idx] = nums[idx], nums[l]
l += 1
idx += 1
elif nums[idx] == 1:
idx += 1
else:
nums[r], nums[idx] = nums[idx], nums[r]
r -= 1
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.75` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/76. 最小覆盖子串（困难）.md | 76. 最小覆盖子串 | https://leetcode.cn/problems/minimum-window-substring/solutions/2384313/gong-shui-san-xie-hua-dong-chuang-kou-ji-14q9/ | 困难 | [
"双指针",
"滑动窗口"
] | 给你一个字符串 `s`、一个字符串 `t`。返回 `s` 中涵盖 `t` 所有字符的最小子串。
如果 `s` 中不存在涵盖 `t` 所有字符的子串,则返回空字符串 `""`。
注意:
* 对于 `t` 中重复字符,我们寻找的子字符串中该字符数量必须不少于 `t` 中该字符数量。
* 如果 `s` 中存在这样的子串,我们保证它是唯一的答案。
示例 1:
```
输入:s = "ADOBECODEBANC", t = "ABC"
输出:"BANC"
解释:最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
```
示例 2:
```
输入:s = "a", t = "a"
输出:"a"
解释:整个字符串 s 是最小覆盖子串。
```
示例 3:
```
输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中,
因此没有符合条件的子字符串,返回空字符串。
```
提示:
* `m == s.length`
* `n == t.length`
* $1 <= m, n <= 10^5$
* `s` 和 `t` 由英文字母组成
进阶:你能设计一个在 $O(m+n)$ 时间内解决此问题的算法吗? | ### 滑动窗口
定义两个长度为 $60$(足够存下所有字母种类)的数组 `c1` 和 `c2`,用于存储字符频率。其中 `c1` 用于记录字符串 `t` 中字符的频率,`c2` 用于记录当前滑动窗口内字符的频率。
设定好字母与频率数组下标的映射关系:小写字母 `a-z` 对应下标 `0-25`,大写字母 `A-Z` 对应下标 `26-51`。
使用变量 `tot` 来记录还需要匹配的字符种类数,当 `tot = 0` 代表当前滑动窗口对应的子串能够实现对 `t` 的覆盖,即任意字符满足 $c2[i] \geq c1[i]$。
使用双指针 `j` 和 `i` 表示滑动窗口的左右边界。从前往后遍历字符串 `s`,在每个位置上更新字符频率数组 `c2`。若 `c2` 中字符的频率达到了 `c1` 中的字符频率,则将 `tot` 减 1,表示一个字符已经匹配完成。
每当右边界往后移动一步之后,滑动窗口会增加一个字符。此时我们检查左边界能否右移,同时不会使得 `tot` 变大。即每次右边界右移后,我们检查左边界 $c2[j] > c1[j]$ 是否满足:
* 若满足:说明当前左边界指向字符并非必须,当前子串 $s[j...i]$ 必然不是最短子串。我们让左边界 `j` 进行右移,并重复进行左边界 $c2[j] > c1[j]$ 的检查,直到窗口不能再收缩
* 若不满足:说明当前窗口没有任何一个后缀字符串能够实现对 `t` 的覆盖,我们并不能对窗口实现收缩
每次对窗口移动完成后,我们检查当前 `tot` 是否为 $0$(对字符串 `t` 的覆盖是否完成),若为 $0$ 则尝试用当前窗口对应的字符串 $s[j...i]$ 更新 `ans`。
Java 代码:
```Java
class Solution {
public String minWindow(String s, String t) {
int n = s.length(), tot = 0;
int[] c1 = new int[60], c2 = new int[60];
for (char x : t.toCharArray()) {
if (++c1[getIdx(x)] == 1) tot++;
}
String ans = "";
for (int i = 0, j = 0; i < n; i++) {
int idx1 = getIdx(s.charAt(i));
if (++c2[idx1] == c1[idx1]) tot--;
while (j < i) {
int idx2 = getIdx(s.charAt(j));
if (c2[idx2] > c1[idx2] && --c2[idx2] >= 0) j++;
else break;
}
if (tot == 0 && (ans.length() == 0 || ans.length() > i - j + 1)) ans = s.substring(j, i + 1);
}
return ans;
}
int getIdx(char x) {
return x >= 'A' && x <= 'Z' ? x - 'A' + 26 : x - 'a';
}
}
```
C++ 代码:
```C++
class Solution {
public:
string minWindow(string s, string t) {
int n = s.length(), tot = 0;
vector<int> c1(60), c2(60);
for (char x : t) {
if (++c1[getIdx(x)] == 1) tot++;
}
string ans = "";
for (int i = 0, j = 0; i < n; i++) {
int idx1 = getIdx(s[i]);
if (++c2[idx1] == c1[idx1]) tot--;
while (j < i) {
int idx2 = getIdx(s[j]);
if (c2[idx2] > c1[idx2] && --c2[idx2] >= 0) j++;
else break;
}
if (tot == 0 && (ans.empty() || ans.length() > i - j + 1)) ans = s.substr(j, i - j + 1);
}
return ans;
}
int getIdx(char x) {
return x >= 'A' && x <= 'Z' ? x - 'A' + 26 : x - 'a';
}
};
```
Python 代码:
```Python
class Solution:
def minWindow(self, s: str, t: str) -> str:
def getIdx(x):
return ord(x) - ord('A') + 26 if 'A' <= x <= 'Z' else ord(x) - ord('a')
n, tot = len(s), 0
c1, c2 = [0] * 60, [0] * 60
for x in t:
idx = getIdx(x)
c1[idx] += 1
if c1[idx] == 1:
tot += 1
ans = ""
j = 0
for i in range(n):
idx1 = getIdx(s[i])
c2[idx1] += 1
if c2[idx1] == c1[idx1]:
tot -= 1
while j < i:
idx2 = getIdx(s[j])
if c2[idx2] > c1[idx2]:
j += 1
c2[idx2] -= 1
else:
break
if tot == 0 and (not ans or len(ans) > i - j + 1):
ans = s[j:i + 1]
return ans
```
TypeScript 代码:
```TypeScript
function minWindow(s: string, t: string): string {
let n = s.length, tot = 0;
const c1 = Array(60).fill(0), c2 = Array(60).fill(0);
for (const x of t) {
if (++c1[getIdx(x)] === 1) tot++;
}
let ans = "";
for (let i = 0, j = 0; i < n; i++) {
const idx1 = getIdx(s[i]);
if (++c2[idx1] == c1[idx1]) tot--;
while (j < i) {
const idx2 = getIdx(s[j]);
if (c2[idx2] > c1[idx2] && --c2[idx2] >= 0) j++;
else break;
}
if (tot == 0 && (!ans || ans.length > i - j + 1)) ans = s.substring(j, i + 1);
}
return ans;
}
function getIdx(x: string): number {
return x >= 'A' && x <= 'Z' ? x.charCodeAt(0) - 'A'.charCodeAt(0) + 26 : x.charCodeAt(0) - 'a'.charCodeAt(0);
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(C)$,其中 $C = 26 \times 2$,为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.76` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/71-80/80. 删除有序数组中的重复项 II（中等）.md | 80. 删除有序数组中的重复项 II | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array-ii/solution/gong-shui-san-xie-guan-yu-shan-chu-you-x-glnq/ | 中等 | [
"双指针"
] | 给你一个有序数组 `nums` ,请你「原地」删除重复出现的元素,使每个元素 最多出现两次 ,返回删除后数组的新长度。
不要使用额外的数组空间,你必须「原地」修改输入数组 并在使用 $O(1)$ 额外空间的条件下完成。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
```
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
```
示例 1:
```
输入:nums = [1,1,1,2,2,3]
输出:5, nums = [1,1,2,2,3]
解释:函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。
```
示例 2:
```
输入:nums = [0,0,1,1,1,1,2,3,3]
输出:7, nums = [0,0,1,1,2,3,3]
解释:函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。
```
提示:
* $1 <= nums.length <= 3 \times 10^4$
* $-10^4 <= nums[i] <= 10^4$
* `nums` 已按升序排列 | ### 通用解法
为了让解法更具有一般性,我们将原问题的「保留 2 位」修改为「保留 k 位」。
对于此类问题,我们应该进行如下考虑:
* 由于是保留 `k` 个相同数字,**对于前 `k` 个数字,我们可以直接保留**
* 对于后面的任意数字,能够保留的前提是:**与当前写入的位置前面的第 `k` 个元素进行比较,不相同则保留**
举个🌰,我们令 `k=2`,假设有如下样例 $[1,1,1,1,1,1,2,2,2,2,2,2,3]$
1. 首先我们先让前 2 位直接保留,得到 1,1
2. 对后面的每一位进行继续遍历,能够保留的前提是与当前位置的前面 `k` 个元素不同(答案中的第一个 1),因此我们会跳过剩余的 1,将第一个 2 追加,得到 1,1,2
3. 继续这个过程,这时候是和答案中的第 2 个 1 进行对比,因此可以得到 1,1,2,2
4. 这时候和答案中的第 1 个 2 比较,只有与其不同的元素能追加到答案,因此剩余的 2 被跳过,3 被追加到答案:1,1,2,2,3
代码:
```Java
class Solution {
public int removeDuplicates(int[] nums) {
return process(nums, 2);
}
int process(int[] nums, int k) {
int u = 0;
for (int x : nums) {
if (u < k || nums[u - k] != x) nums[u++] = x;
}
return u;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 其他
**这是一种针对「数据有序,相同元素保留 `k` 位」问题更加本质的解法,该解法是从性质出发提炼的,利用了「数组有序 & 保留逻辑」两大主要性质。**
当你掌握这种通解之后,要解决 [26. 删除有序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/) ,只需要改上述代码一个数字即可(将相同数字保留 2 个修改为保留 1 个)。
这种通解最早我也在 [「双指针」&「通用」解法](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/) 讲过。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.80` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/713. 乘积小于 K 的子数组（中等）.md | 713. 乘积小于 K 的子数组 | https://leetcode-cn.com/problems/subarray-product-less-than-k/solution/by-ac_oier-3w08/ | 中等 | [
"滑动窗口",
"双指针"
] | 给你一个整数数组 `nums` 和一个整数 $k$ ,请你返回子数组内所有元素的乘积严格小于 $k$ 的连续子数组的数目。
示例 1:
```
输入:nums = [10,5,2,6], k = 100
输出:8
解释:8 个乘积小于 100 的子数组分别为:[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
```
示例 2:
```
输入:nums = [1,2,3], k = 0
输出:0
```
提示:
* $1 <= nums.length <= 3 \times 10^4$
* $1 <= nums[i] <= 1000$
* $0 <= k <= 10^6$ | ### 滑动窗口
利用 $1 <= nums[i] <= 1000$,我们可以从前往后处理所有的 $nums[i]$,使用一个变量 $cur$ 记录当前窗口的乘积,使用两个变量 $j$ 和 $i$ 分别代表当前窗口的左右端点。
当 $cur >= k$ 时,我们考虑将左端点 $j$ 右移,同时消除原来左端点元素 $nums[j]$ 对 $cur$ 的贡献,直到 $cur >= k$ 不再满足,这样我们就可以得到每个右端点 $nums[i]$ 的最远左端点 $nums[j]$,从而得知以 $nums[i]$ 为结尾的合法子数组个数为 $i - j + 1$。
Java 代码:
```Java
class Solution {
public int numSubarrayProductLessThanK(int[] nums, int k) {
int n = nums.length, ans = 0;
if (k <= 1) return 0;
for (int i = 0, j = 0, cur = 1; i < n; i++) {
cur *= nums[i];
while (cur >= k) cur /= nums[j++];
ans += i - j + 1;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function numSubarrayProductLessThanK(nums: number[], k: number): number {
let n = nums.length, ans = 0
if (k <= 1) return 0
for (let i = 0, j = 0, cur = 1; i < n; i++) {
cur *= nums[i]
while (cur >= k) cur /= nums[j++]
ans += i - j + 1
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.713` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/715. Range 模块（困难）.md | 715. Range 模块 | https://leetcode.cn/problems/range-module/solution/by-ac_oier-i4sw/ | 困难 | [
"线段树",
"线段树(动态开点)"
] | `Range` 模块是跟踪数字范围的模块。设计一个数据结构来跟踪表示为 半开区间 的范围并查询它们。
半开区间 $[left, right)$ 表示所有 $left <= x < right$ 的实数 `x` 。
实现 `RangeModule` 类:
* `RangeModule()` 初始化数据结构的对象。
* `void addRange(int left, int right)` 添加 半开区间 `[left, right)`,跟踪该区间中的每个实数。添加与当前跟踪的数字部分重叠的区间时,应当添加在区间 `[left, right)` 中尚未跟踪的任何数字到该区间中。
* `boolean queryRange(int left, int right)` 只有在当前正在跟踪区间 `[left, right)` 中的每一个实数时,才返回 `true` ,否则返回 `false` 。
* `void removeRange(int left, int right)` 停止跟踪 半开区间 `[left, right)` 中当前正在跟踪的每个实数。
示例 1:
```
输入
["RangeModule", "addRange", "removeRange", "queryRange", "queryRange", "queryRange"]
[[], [10, 20], [14, 16], [10, 14], [13, 15], [16, 17]]
输出
[null, null, null, true, false, true]
解释
RangeModule rangeModule = new RangeModule();
rangeModule.addRange(10, 20);
rangeModule.removeRange(14, 16);
rangeModule.queryRange(10, 14); 返回 true (区间 [10, 14) 中的每个数都正在被跟踪)
rangeModule.queryRange(13, 15); 返回 false(未跟踪区间 [13, 15) 中像 14, 14.03, 14.17 这样的数字)
rangeModule.queryRange(16, 17); 返回 true (尽管执行了删除操作,区间 [16, 17) 中的数字 16 仍然会被跟踪)
```
提示:
* $1 <= left < right <= 10^9$
* 在单个测试用例中,对 `addRange`、 `queryRange` 和 `removeRange` 的调用总数不超过 $10^4$ 次 | ### 基本分析
线段树(动态开点)写过超多次了。
令 $m$ 为 `addRange`、`queryRange` 和 `removeRange` 的调用总数,$n = 1e9$ 为值域大小。
由于值域过大,我们无法直接使用空间大小固定为 $4 \times n$ 的常规线段树,而要采用「动态开点」的方式,其中动态开点的方式有两种 :「需要进行估点的数组实现」和「无须估点的动态指针」。
设计 `Node` 节点维护什么信息:
* `ls` 和 `rs` 分别指向左右区间子节点(当采用「估点数组」方式时,记录的是左右区间子节点在线段树数组中的下标;在「动态指针」方式时,记录的是左右区间子节点对象);
* `sum` 为记录当前区间有多少个整数被追踪;
* `add` 为懒标记,当 `add = -1` 代表 `removeRange` 懒标记,当 `add = 1` 则代表 `addRange` 懒标记。
---
### 线段树(动态开点)- 数组估点
对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 \times n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。
如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE` 问题。
但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。
动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1 | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。
由于存在「懒标记」,线段树的插入和查询都是 $\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\log{n}$ 的点,因此空间复杂度为 $O(m\log{n})$,而不是 $O(4 \times n)$,而开点数的预估需不能仅仅根据 $\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。
动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 \times n$ 的空间,因此盲猜 $\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 \times m \times \log{n}$,其中 $n = 1e9$ 和 $m = 1e4$ 分别代表值域大小和查询次数。
当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 `128M` 可以开到 $5 \times 10^6$ 以上)。
代码:
```Java
class RangeModule {
class Node {
int ls, rs, sum, add;
}
int N = (int)1e9 + 10, M = 500010, cnt = 1;
Node[] tr = new Node[M];
void update(int u, int lc, int rc, int l, int r, int v) {
int len = rc - lc + 1;
if (l <= lc && rc <= r) {
tr[u].sum = v == 1 ? len : 0;
tr[u].add = v;
return ;
}
pushdown(u, len);
int mid = lc + rc >> 1;
if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);
if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);
pushup(u);
}
int query(int u, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return tr[u].sum;
pushdown(u, rc - lc + 1);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);
if (r > mid) ans += query(tr[u].rs, mid + 1, rc, l, r);
return ans;
}
void pushdown(int u, int len) {
if (tr[u] == null) tr[u] = new Node();
if (tr[u].ls == 0) {
tr[u].ls = ++cnt;
tr[tr[u].ls] = new Node();
}
if (tr[u].rs == 0) {
tr[u].rs = ++cnt;
tr[tr[u].rs] = new Node();
}
if (tr[u].add == 0) return;
if (tr[u].add == -1) {
tr[tr[u].ls].sum = tr[tr[u].rs].sum = 0;
} else {
tr[tr[u].ls].sum = len - len / 2;
tr[tr[u].rs].sum = len / 2;
}
tr[tr[u].ls].add = tr[tr[u].rs].add = tr[u].add;
tr[u].add = 0;
}
void pushup(int u) {
tr[u].sum = tr[tr[u].ls].sum + tr[tr[u].rs].sum;
}
public void addRange(int left, int right) {
update(1, 1, N - 1, left, right - 1, 1);
}
public boolean queryRange(int left, int right) {
return query(1, 1, N - 1, left, right - 1) == right - left;
}
public void removeRange(int left, int right) {
update(1, 1, N - 1, left, right - 1, -1);
}
}
```
* 时间复杂度:`addRange`、`queryRange` 和 `removeRange` 操作复杂度均为 $O(\log{n})$
* 空间复杂度:$O(m\log{n})$
---
### 线段树(动态开点)- 动态指针
利用「动态指针」实现的「动态开点」可以有效避免数组估点问题,更重要的是可以有效避免 `new` 大数组的初始化开销,对于 LC 这种还跟你算所有样例总时长的 OJ 来说,在不考虑 `static` 优化/全局数组优化 的情况下,动态指针的方式要比估点的方式来得好。
代码:
```Java
class RangeModule {
class Node {
Node ls, rs;
int sum, add;
}
int N = (int)1e9 + 10;
Node root = new Node();
void update(Node node, int lc, int rc, int l, int r, int v) {
int len = rc - lc + 1;
if (l <= lc && rc <= r) {
node.sum = v == 1 ? len : 0;
node.add = v;
return ;
}
pushdown(node, len);
int mid = lc + rc >> 1;
if (l <= mid) update(node.ls, lc, mid, l, r, v);
if (r > mid) update(node.rs, mid + 1, rc, l, r, v);
pushup(node);
}
int query(Node node, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return node.sum;
pushdown(node, rc - lc + 1);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = query(node.ls, lc, mid, l, r);
if (r > mid) ans += query(node.rs, mid + 1, rc, l, r);
return ans;
}
void pushdown(Node node, int len) {
if (node.ls == null) node.ls = new Node();
if (node.rs == null) node.rs = new Node();
if (node.add == 0) return ;
int add = node.add;
if (add == -1) {
node.ls.sum = node.rs.sum = 0;
} else {
node.ls.sum = len - len / 2;
node.rs.sum = len / 2;
}
node.ls.add = node.rs.add = add;
node.add = 0;
}
void pushup(Node node) {
node.sum = node.ls.sum + node.rs.sum;
}
public void addRange(int left, int right) {
update(root, 1, N - 1, left, right - 1, 1);
}
public boolean queryRange(int left, int right) {
return query(root, 1, N - 1, left, right - 1) == right - left;
}
public void removeRange(int left, int right) {
update(root, 1, N - 1, left, right - 1, -1);
}
}
```
* 时间复杂度:`addRange`、`queryRange` 和 `removeRange` 操作复杂度均为 $O(\log{n})$
* 空间复杂度:$O(m\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.715` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/717. 1比特与2比特字符（简单）.md | 717. 1比特与2比特字符 | https://leetcode-cn.com/problems/1-bit-and-2-bit-characters/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-igh7/ | 简单 | [
"模拟"
] | 有两种特殊字符:
* 第一种字符可以用一个比特 $0$ 来表示
* 第二种字符可以用两个比特($10$ 或 $11$)来表示、
给定一个以 $0$ 结尾的二进制数组 `bits` ,如果最后一个字符必须是一位字符,则返回 `true` 。
示例 1:
```
输入: bits = [1, 0, 0]
输出: true
解释: 唯一的编码方式是一个两比特字符和一个一比特字符。
所以最后一个字符是一比特字符。
```
示例 2:
```
输入: bits = [1, 1, 1, 0]
输出: false
解释: 唯一的编码方式是两比特字符和两比特字符。
所以最后一个字符不是一比特字符。
```
提示:
* $1 <= bits.length <= 1000$
* $bits[i] == 0$ or $1$ | ### 模拟
根据题意进行模拟即可,使用 $n$ 代指 `bits` 的长度,$idx$ 为当前「比特字」的开头,从前往后扫描每个「比特字」,如果最后一个「比特字」的开头为 $n - 1$ 返回 `True`,否则返回 `False`。
代码:
```Java
class Solution {
public boolean isOneBitCharacter(int[] bits) {
int n = bits.length, idx = 0;
while (idx < n - 1) {
if (bits[idx] == 0) idx++;
else idx += 2;
}
return idx == n - 1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.717` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/719. 找出第 K 小的数对距离（困难）.md | 719. 找出第 K 小的数对距离 | https://leetcode.cn/problems/find-k-th-smallest-pair-distance/solution/by-ac_oier-o4if/ | 困难 | [
"双指针",
"二分"
] | 数对 $(a,b)$ 由整数 `a` 和 `b` 组成,其数对距离定义为 `a` 和 `b` 的绝对差值。
给你一个整数数组 `nums` 和一个整数 $k$ ,数对由 $nums[i]$ 和 $nums[j]$ 组成且满足 $0 <= i < j < nums.length$ 。
返回 所有数对距离中 第 $k$ 小的数对距离。
示例 1:
```
输入:nums = [1,3,1], k = 1
输出:0
解释:数对和对应的距离如下:
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
距离第 1 小的数对是 (1,1) ,距离为 0 。
```
示例 2:
```
输入:nums = [1,1,1], k = 2
输出:0
```
示例 3:
```
输入:nums = [1,6,1], k = 3
输出:5
```
提示:
* $n == nums.length$
* $2 <= n <= 10^4$
* $0 <= nums[i] <= 10^6$
* $1 <= k <= n \times (n - 1) / 2$ | ### 二分 + 双指针
根据题意,由于对距离定义使用的是绝对值,因此从原数组中找数对 $(i, j)$,等价于在排序数组中找数对 $(i, j)$。
同时由于 $k$ 的范围为 $n^2$,因此我们不能使用复杂度为 $O(k\log{n})$ 的「多路归并」做法来做。
利用数据范围 $0 <= nums[i] <= 10^6$,我们知道距离值域范围为 $[0, 10^6]$,假设所能形成的距离序列为 $A = a_1, a_2, ... ,a_m$,此时在以第 $k$ 小的距离值为分割点的数轴上,具有「二段性」,记这第 $k$ 小的距离值为 $a_k$:
* 处于 $a_k$ 右侧的所有位置 $a_i$(包含 $a_k$)**必然满足**「序列 $A$ 中值小于等于 $a_i$ 的数不少于 $k$ 个」;
* 处于 $a_k$ 左侧的所有位置 $a_i$(不包含 $a_k$)**不一定满足**「序列 $A$ 中值小于等于 $a_i$ 的数不少于 $k$ 个」(当且仅当 $a_k$ 在序列 $A$ 中不重复,或 $a_k$ 恰好是连续段距离值中的左端点时,必然不满足)。
因此这本质上是一个满足 `1?` 特性(而不是 `10` 特性)的问题,我们可以使用「二分」来找到 $a_k$ 值。
假设当前我们二分到的值是 $x$,利用我们排序好的 `nums`,我们并不需要真正的构建出序列 $A$,即可统计值小于等于 $x$ 的数量:枚举左端点 $i$,每次找第一个不满足条件的右端点 $j$(由于 $j$ 是第一个不满足条件的值,因此合法右端点范围为 $[i + 1, j - 1]$,共 $j - i - 1$ 个),利用 `nums` 有序,并且所有 $nums[i]$ 均为正数,可知 $j$ 会随着 $i$ 增大而逐步增大,即这部分利用「双指针」可实现 $O(n)$ 复杂度。
代码:
```Java
class Solution {
public int smallestDistancePair(int[] nums, int k) {
Arrays.sort(nums);
int l = 0, r = (int)1e6;
while (l < r) {
int mid = l + r >> 1;
if (check(nums, mid) >= k) r = mid;
else l = mid + 1;
}
return r;
}
int check(int[] nums, int x) {
int n = nums.length, ans = 0;
for (int i = 0, j = 1; i < n; i++) {
while (j < n && nums[j] - nums[i] <= x) j++;
ans += j - i - 1;
}
return ans;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$,二分答案复杂度为 $O(n\log{m})$,其中 $m = 1e6$ 为距离值域。整体复杂度为 $O(n\log{m})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.719` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/711-720/720. 词典中最长的单词（简单）.md | 720. 词典中最长的单词 | https://leetcode-cn.com/problems/longest-word-in-dictionary/solution/by-ac_oier-bmot/ | 简单 | [
"模拟",
"哈希表",
"字典树"
] | 给出一个字符串数组 `words` 组成的一本英语词典。返回 `words` 中最长的一个单词,该单词是由 `words` 词典中其他单词逐步添加一个字母组成。
若其中有多个可行的答案,则返回答案中字典序最小的单词。若无答案,则返回空字符串。
示例 1:
```
输入:words = ["w","wo","wor","worl", "world"]
输出:"world"
解释: 单词"world"可由"w", "wo", "wor", 和 "worl"逐步添加一个字母组成。
```
示例 2:
```
输入:words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
输出:"apple"
解释:"apply" 和 "apple" 都能由词典中的单词组成。但是 "apple" 的字典序小于 "apply"
```
提示:
* $1 <= words.length <= 1000$
* $1 <= words[i].length <= 30$
* 所有输入的字符串 $words[i]$ 都只包含小写字母。 | ### 模拟
数据范围很小,我们可以直接模拟来做。
先将所有的 $words[i]$ 存入 `Set` 集合,方便后续可以近似 $O(1)$ 查询某个子串是否存在 $words$ 中。
遍历 $words$ 数组(题目没有说 $words$ 不重复,因此最好遍历刚刚预处理的 `Set` 集合),判断每个 $words[i]$ 是否为「合法单词」,同时利用当前的最长单词来做剪枝。
不算剪枝效果,该做法计算量不超过 $10^6$,可以过。
代码:
```Java
class Solution {
public String longestWord(String[] words) {
String ans = "";
Set<String> set = new HashSet<>();
for (String s : words) set.add(s);
for (String s : set) {
int n = s.length(), m = ans.length();
if (n < m) continue;
if (n == m && s.compareTo(ans) > 0) continue;
boolean ok = true;
for (int i = 1; i <= n && ok; i++) {
String sub = s.substring(0, i);
if (!set.contains(sub)) ok = false;
}
if (ok) ans = s;
}
return ans;
}
}
```
* 时间复杂度:预处理 `Set` 集合复杂度近似 $O(n)$;判断某个 $words[i]$ 是否合法需要判断所有子串是否均在 $words$ 中,复杂度为 $O(m^2)$,其中 $m$ 为字符串长度,处理 $words[i]$ 的过程还使用到 `compareTo` 操作,其复杂度为 $O(\min(N, M))$,其中 $N$ 和 $M$ 为参与比较的两字符串长度,该操作相比于生成子串可忽略,而对于一个长度为 $m$ 的字符串而言,生成其所有的子串的计算量为首项为 $1$,末项为 $m$,公差为 $1$ 的等差数列求和结果。整体复杂度为 $O(\sum_{i = 0}^{n - 1}words[i].length^2)$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1}words[i].length)$
---
### 字典树
上述解法中「枚举某个 $words[i]$ 的所有子串,并判断子串是否在 $words$ 数组中出现」的操作可使用「字典树」来实现。
**不了解「Trie / 字典树」的同学可以看前置 🧀:[字典树入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)。里面通过图例展示了字典树基本形态,以及提供了「数组实现」和「TrieNode 实现」两种方式,还有「数组大小估算方式」和「Trie 应用面」介绍。**
回到本题,起始先将所有的 $words[i]$ 存入字典树,并记录每个字符的结尾编号。
对于某个 $words[i]$ 而言,其能成为「合法单词」的充要条件为:$words[i]$ 的每个前缀编号都有「以结尾编号」所被记录。
> 一些细节:为了防止每个样例都 `new` 大数组,我们使用 `static` 进行优化,并在跑样例前进行相应的清理工作。
代码:
```Java
class Solution {
static int N = 30010, M = 26;
static int[][] tr = new int[N][M];
static boolean[] isEnd = new boolean[N];
static int idx = 0;
void add(String s) {
int p = 0, n = s.length();
for (int i = 0; i < n; 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 p = 0, n = s.length();
for (int i = 0; i < n; i++) {
int u = s.charAt(i) - 'a';
p = tr[p][u];
if (!isEnd[p]) return false;
}
return true;
}
public String longestWord(String[] words) {
Arrays.fill(isEnd, false);
for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);
idx = 0;
String ans = "";
for (String s : words) add(s);
for (String s : words) {
int n = s.length(), m = ans.length();
if (n < m) continue;
if (n == m && s.compareTo(ans) > 0) continue;
if (query(s)) ans = s;
}
return ans;
}
}
```
* 时间复杂度:将所有 $words[i]$ 存入字典树的复杂度为 $O(\sum_{i = 0}^{n - 1}words[i].length)$;查询每个 $words[i]$ 是否合法的复杂度为 $O(m)$,其中 $m$ 为当前 $words[i]$ 长度。整体复杂度为 $O(\sum_{i = 0}^{n - 1}words[i].length)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.720` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/724. 寻找数组的中心下标（简单）.md | 724. 寻找数组的中心下标 | https://leetcode-cn.com/problems/find-pivot-index/solution/shi-yong-shao-bing-ji-qiao-liang-bian-qi-vkju/ | 简单 | [
"前缀和"
] | 给你一个整数数组 nums,请编写一个能够返回数组 “中心下标” 的方法。
数组 中心下标 是数组的一个下标,其左侧所有元素相加的和等于右侧所有元素相加的和。
如果数组不存在中心下标,返回 -1 。
如果数组有多个中心下标,应该返回最靠近左边的那一个。
注意:中心下标可能出现在数组的两端。
示例 1:
```
输入:nums = [1, 7, 3, 6, 5, 6]
输出:3
解释:
中心下标是 3 。
左侧数之和 (1 + 7 + 3 = 11),
右侧数之和 (5 + 6 = 11) ,二者相等。
```
示例 2:
```
输入:nums = [1, 2, 3]
输出:-1
解释:
数组中不存在满足此条件的中心下标。
```
示例 3:
```
输入:nums = [2, 1, -1]
输出:0
解释:
中心下标是 0 。
下标 0 左侧不存在元素,视作和为 0 ;
右侧数之和为 1 + (-1) = 0 ,二者相等。
```
提示:
* nums 的长度范围为 [0, 10000]。
* 任何一个 nums[i] 将会是一个范围在 [-1000, 1000]的整数。 | ### 基本分析
这是一道前缀和的裸题。
只需要用两个数组,前后处理两遍前缀和,再对两个前缀和数组的相同下标进行判别即可。
为了简化数组越界的判断,我们通常会给前缀和数组多预留一位作为哨兵。
这里由于要求前后前缀和。所以我们直接多开两位。
代码:
```Java
class Solution {
public int pivotIndex(int[] nums) {
int n = nums.length;
int[] s1 = new int[n + 2], s2 = new int[n + 2];
for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] + nums[i - 1];
for (int i = n; i >= 1; i--) s2[i] = s2[i + 1] + nums[i - 1];
for (int i = 1; i <= n; i++) {
if (s1[i] == s2[i]) return i - 1;
}
return -1;
}
}
```
* 时间复杂度:对数组进行线性扫描。复杂度为 $O(n)$
* 空间复杂度:使用了前缀和数组。复杂度为$O(n)$
---
### 空间优化(常数级别的优化)
当然,我们也可以只处理一遍前缀和。
然后在判定一个下标是否为”中心索引“的时候,利用前缀和计算左侧值和右侧值。
但这只是常数级别的优化,并不影响其时空复杂度。
代码:
```Java
class Solution {
public int pivotIndex(int[] nums) {
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];
for (int i = 1; i <= n; i++) {
int left = sum[i - 1], right = sum[n] - sum[i];
if (left == right) return i - 1;
}
return -1;
}
}
```
* 时间复杂度:对数组进行线性扫描。复杂度为 $O(n)$
* 空间复杂度:使用了前缀和数组。复杂度为$O(n)$
---
### 空间优化(优化至常数级别)
甚至可以不使用额外空间。
先求一遍总和 `total`,再使用 `sum` 记录当前遍历位置的左侧总和。
对于中心索引必然有:`sum = total - sum - nums[i]` (左边值 = 右边值)
代码:
```Java
class Solution {
public int pivotIndex(int[] nums) {
int n = nums.length;
int total = 0, sum = 0;
// 我们的 nums 处理不涉及并行操作,使用循环要比 Arrays.stream 快
// total = Arrays.stream(nums).sum();
for (int i = 0; i < n; i++) total += nums[i];
for (int i = 0; i < n; i++) {
if (sum == total - sum - nums[i]) return i;
sum += nums[i];
}
return -1;
}
}
```
* 时间复杂度:对数组进行线性扫描。复杂度为 $O(n)$
* 空间复杂度:$O(1)$
---
### 总结
这是我使用到的前缀和模板(高频):
```Java
class Solution {
public void func(int[] nums) {
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];
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.724` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/725. 分隔链表（中等）.md | 725. 分隔链表 | https://leetcode-cn.com/problems/split-linked-list-in-parts/solution/gong-shui-san-xie-jing-dian-lian-biao-ju-9yj4/ | 中等 | [
"模拟",
"链表"
] | 给你一个头结点为 `head` 的单链表和一个整数 `k` ,请你设计一个算法将链表分隔为 `k` 个连续的部分。
每部分的长度应该尽可能的相等:任意两部分的长度差距不能超过 $1$ 。这可能会导致有些部分为 null 。
这 `k` 个部分应该按照在链表中出现的顺序排列,并且排在前面的部分的长度应该大于或等于排在后面的长度。
返回一个由上述 k 部分组成的数组。
示例 1:
```
输入:head = [1,2,3], k = 5
输出:[[1],[2],[3],[],[]]
解释:
第一个元素 output[0] 为 output[0].val = 1 ,output[0].next = null 。
最后一个元素 output[4] 为 null ,但它作为 ListNode 的字符串表示是 [] 。
```
示例 2:
```
输入:head = [1,2,3,4,5,6,7,8,9,10], k = 3
输出:[[1,2,3,4],[5,6,7],[8,9,10]]
解释:
输入被分成了几个连续的部分,并且每部分的长度相差不超过 1 。前面部分的长度大于等于后面部分的长度。
```
提示:
* 链表中节点的数目在范围 [0, 1000]
* 0 <= Node.val <= 1000
* 1 <= k <= 50 | ### 模拟
根据题意,我们应当近可能将链表平均分为 $k$ 份。
我们可以采取与 [(题解) 68. 文本左右对齐](https://leetcode-cn.com/problems/text-justification/solution/gong-shui-san-xie-zi-fu-chuan-mo-ni-by-a-s3v7/) 类似的思路(在 $68$ 中,填充空格的操作与本题一致:尽可能平均,无法均分时,应当使前面比后面多)。
回到本题,我们可以先对链表进行一次扫描,得到总长度 $cnt$,再结合需要将将链表划分为 $k$ 份,可知每一份的 **最小** 分配单位 $per = \left \lfloor \frac{cnt}{k} \right \rfloor$(当 $cnt < k$ 时,$per$ 为 $0$)。
然后从前往后切割出 $k$ 份链表,由于是在原链表的基础上进行,因此这里的切分只需要在合适的位置将节点的 $next$ 指针置空即可。
**当我们需要构造出 $ans[i]$ 的链表长度时,首先可以先分配 $per$ 的长度,如果 `已处理的链表长度 + 剩余待分配份数 * per < cnt`,说明后面「待分配的份数」如果按照每份链表分配 $per$ 长度的话,会有节点剩余,基于「不能均分时,前面的应当比后面长」原则,此时只需为当前 $ans[i]$ 多分一个单位长度即可。**
代码:
```Java
class Solution {
public ListNode[] splitListToParts(ListNode head, int k) {
// 扫描链表,得到总长度 cnt
int cnt = 0;
ListNode tmp = head;
while (tmp != null && ++cnt > 0) tmp = tmp.next;
// 理论最小分割长度
int per = cnt / k;
// 将链表分割为 k 份(sum 代表已经被处理的链表长度为多少)
ListNode[] ans = new ListNode[k];
for (int i = 0, sum = 1; i < k; i++, sum++) {
ans[i] = head;
tmp = ans[i];
// 每次首先分配 per 的长度
int u = per;
while (u-- > 1 && ++sum > 0) tmp = tmp.next;
// 当「已处理的链表长度 + 剩余待分配份数 * per < cnt」,再分配一个单位长度
int remain = k - i - 1;
if (per != 0 && sum + per * remain < cnt && ++sum > 0) tmp = tmp.next;
head = tmp != null ? tmp.next : null;
if (tmp != null) tmp.next = null;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.725` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/726. 原子的数量（困难）.md | 726. 原子的数量 | https://leetcode-cn.com/problems/number-of-atoms/solution/gong-shui-san-xie-shi-yong-xiao-ji-qiao-l5ak4/ | 困难 | [
"模拟",
"数据结构运用",
"栈",
"哈希表",
"优先队列(堆)"
] | 给定一个化学式 `formula`(作为字符串),返回每种原子的数量。
原子总是以一个大写字母开始,接着跟随0个或任意个小写字母,表示原子的名字。
如果数量大于 1,原子后会跟着数字表示原子的数量。如果数量等于 1 则不会跟数字。例如,`H2O` 和 `H2O2` 是可行的,但 `H1O2` 这个表达是不可行的。
两个化学式连在一起是新的化学式。例如 `H2O2He3Mg4` 也是化学式。
一个括号中的化学式和数字(可选择性添加)也是化学式。例如 `(H2O2)` 和 `(H2O2)3` 是化学式。
给定一个化学式,输出所有原子的数量。格式为:第一个(按字典序)原子的名子,跟着它的数量(如果数量大于 1),然后是第二个原子的名字(按字典序),跟着它的数量(如果数量大于 1),以此类推。
示例 1:
```
输入: formula = "H2O"
输出: "H2O"
解释: 原子的数量是 {'H': 2, 'O': 1}。
```
示例 2:
```
输入: formula = "Mg(OH)2"
输出: "H2MgO2"
解释: 原子的数量是 {'H': 2, 'Mg': 1, 'O': 2}。
```
示例 3:
```
输入: formula = "K4(ON(SO3)2)2"
输出: "K4N2O14S4"
解释: 原子的数量是 {'K': 4, 'N': 2, 'O': 14, 'S': 4}。
```
注意:
* 所有原子的第一个字母为大写,剩余字母都是小写。
* `formula` 的长度在[1, 1000]之间。
* `formula` 只包含字母、数字和圆括号,并且题目中给定的是合法的化学式。 | ### 数据结构 + 模拟
一道综合模拟题。
相比于[(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 的表达式计算问题,本题设计模拟流程的难度要低很多,之所谓定位困难估计是使用到的数据结构较多一些。
为了方便,我们约定以下命名:
* 称一段完整的连续字母为「原子」
* 称一段完整的连续数字为「数值」
* 称 `(` 和`)` 为「符号」
基本实现思路如下:
1. 在处理入参 `s` 的过程中,始终维护着一个哈希表 `map`,`map` 中 **实时维护** 着某个「原子」对应的实际「数值」(即存储格式为 `{H:2,S:1}`);
> 由于相同原子可以出在 `s` 的不同位置中,为了某个「数值」对「原子」的累乘效果被重复应用,我们这里应用一个”小技巧“:为每个「原子」增加一个”编号后缀“。即实际存储时为 `{H_1:2, S_2:1, H_3:1}`。
2. 根据当前处理到的字符分情况讨论:
* 符号:直接入栈;
* 原子:继续往后取,直到取得完整的原子名称,将完整原子名称入栈,同时在 `map` 中计数加 $1$;
* 数值:继续往后取,直到取得完整的数值并解析,然后根据栈顶元素是否为 `)` 符号,决定该数值应用给哪些原子:
* 如果栈顶元素不为 `)`,说明该数值只能应用给栈顶的原子
* 如果栈顶元素是 ),说明当前数值可以应用给「连续一段」的原子中
3. 对 `map` 的原子做 “合并” 操作:`{H_1:2, S_2:1, H_3:1}` => `{H:3, S:1}` ;
4. 使用「优先队列(堆)」实现字典序排序(也可以直接使用 `List`,然后通过 `Collections.sort` 进行排序),并构造答案。
代码:
```Java
class Solution {
class Node {
String s; int v;
Node (String _s, int _v) {
s = _s; v = _v;
}
}
public String countOfAtoms(String s) {
int n = s.length();
char[] cs = s.toCharArray();
Map<String, Integer> map = new HashMap<>();
Deque<String> d = new ArrayDeque<>();
int idx = 0;
for (int i = 0; i < n; ) {
char c = cs[i];
if (c == '(' || c == ')') {
d.addLast(String.valueOf(c));
i++;
} else {
if (Character.isDigit(c)) {
// 获取完整的数字,并解析出对应的数值
int j = i;
while (j < n && Character.isDigit(cs[j])) j++;
String numStr = s.substring(i, j);
i = j;
int cnt = Integer.parseInt(String.valueOf(numStr));
// 如果栈顶元素是 ),说明当前数值可以应用给「连续一段」的原子中
if (!d.isEmpty() && d.peekLast().equals(")")) {
List<String> tmp = new ArrayList<>();
d.pollLast(); // pop )
while (!d.isEmpty() && !d.peekLast().equals("(")) {
String cur = d.pollLast();
map.put(cur, map.getOrDefault(cur, 1) * cnt);
tmp.add(cur);
}
d.pollLast(); // pop (
for (int k = tmp.size() - 1; k >= 0; k--) {
d.addLast(tmp.get(k));
}
// 如果栈顶元素不是 ),说明当前数值只能应用给栈顶的原子
} else {
String cur = d.pollLast();
map.put(cur, map.getOrDefault(cur, 1) * cnt);
d.addLast(cur);
}
} else {
// 获取完整的原子名
int j = i + 1;
while (j < n && Character.isLowerCase(cs[j])) j++;
String cur = s.substring(i, j) + "_" + String.valueOf(idx++);
map.put(cur, map.getOrDefault(cur, 0) + 1);
i = j;
d.addLast(cur);
}
}
}
// 将不同编号的相同原子进行合并
Map<String, Node> mm = new HashMap<>();
for (String key : map.keySet()) {
String atom = key.split("_")[0];
int cnt = map.get(key);
Node node = null;
if (mm.containsKey(atom)) {
node = mm.get(atom);
} else {
node = new Node(atom, 0);
}
node.v += cnt;
mm.put(atom, node);
}
// 使用优先队列(堆)对 Node 进行字典序排序,并构造答案
PriorityQueue<Node> q = new PriorityQueue<Node>((a,b)->a.s.compareTo(b.s));
for (String atom : mm.keySet()) q.add(mm.get(atom));
StringBuilder sb = new StringBuilder();
while (!q.isEmpty()) {
Node poll = q.poll();
sb.append(poll.s);
if (poll.v > 1) sb.append(poll.v);
}
return sb.toString();
}
}
```
* 时间复杂度:最坏情况下,每次处理数值都需要从栈中取出元素进行应用,处理 `s` 的复杂度为 $O(n^2)$;最坏情况下,每个原子独立分布,合并的复杂度为 $O(n)$;将合并后的内容存入优先队列并取出构造答案的复杂度为 $O(n\log{n})$;整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.726` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/728. 自除数（简单）.md | 728. 自除数 | https://leetcode-cn.com/problems/self-dividing-numbers/solution/by-ac_oier-pvb1/ | 简单 | [
"模拟",
"打表",
"哈希表",
"二分"
] | 自除数是指可以被它包含的每一位数整除的数。
* 例如,$128$ 是一个 自除数 ,因为 `128 % 1 == 0`,`128 % 2 == 0`,`128 % 8 == 0`。
自除数不允许包含 $0$ 。
给定两个整数 `left` 和 `right` ,返回一个列表,列表的元素是范围 $[left, right]$ 内所有的 自除数 。
示例 1:
```
输入:left = 1, right = 22
输出:[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
```
示例 2:
```
输入:left = 47, right = 85
输出:[48,55,66,77]
```
提示:
* $1 <= left <= right <= 10^4$ | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public List<Integer> selfDividingNumbers(int left, int right) {
List<Integer> ans = new ArrayList<>();
out:for (int i = left; i <= right; i++) {
int cur = i;
while (cur != 0) {
int t = cur % 10;
if (t == 0 || i % t != 0) continue out;
cur /= 10;
}
ans.add(i);
}
return ans;
}
}
```
-
```Python
class Solution:
def selfDividingNumbers(self, left: int, right: int) -> List[int]:
ans = []
for i in range(left, right + 1):
cur, ok = i, True
while cur and ok:
ok = not ((t := cur % 10) == 0 or i % t != 0)
cur //= 10
if ok:
ans.append(i)
return ans
```
* 时间复杂度:令 $n = right - left + 1$,复杂度为 $O(n * \log{right})$
* 空间复杂度:$O(1)$
---
### 打表 + 二分
利用数据范围只有 $1e4$,我们可以打表预处理出所有的自除数,通过二分找到 $[left, right]$ 范围内的最小自除数,再从前往后找到所有合法的自除数。
代码:
```Java
class Solution {
static List<Integer> list = new ArrayList<>();
static {
out:for (int i = 1; i <= 10000; i++) {
int cur = i;
while (cur != 0) {
int u = cur % 10;
if (u == 0 || i % u != 0) continue out;
cur /= 10;
}
list.add(i);
}
}
public List<Integer> selfDividingNumbers(int left, int right) {
List<Integer> ans = new ArrayList<>();
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r >> 1;
if (list.get(mid) >= left) r = mid;
else l = mid + 1;
}
while (r < list.size() && list.get(r) <= right) ans.add(list.get(r++));
return ans;
}
}
```
* 时间复杂度:令 $m$ 为范围在 $[left, right]$ 之间的自除数的数量,$n = right - left + 1$。复杂度为$O(\log{m} + n)$,对于本题,$m$ 上界为 $339$
* 空间复杂度:$O(m)$
---
### 打表 + 哈希表
在打表预处理了所有范围内的自除数的基础上,我们可以干脆将索引也预处理出来,从而避免二分操作。
其中 $hash[x]$ 的含义为值不超过 $x$ 的最大自除数在 `list` 中的下标。
代码:
```Java
class Solution {
static List<Integer> list = new ArrayList<>();
static int[] hash = new int[10010];
static {
for (int i = 1; i <= 10000; i++) {
int cur = i;
boolean ok = true;
while (cur != 0 && ok) {
int u = cur % 10;
if (u == 0 || i % u != 0) ok = false;
cur /= 10;
}
if (ok) list.add(i);
hash[i] = list.size() - 1;
}
}
public List<Integer> selfDividingNumbers(int left, int right) {
List<Integer> ans = new ArrayList<>();
int idx = list.get(hash[left]) == left ? hash[left] : hash[left] + 1;
while (idx < list.size() && list.get(idx) <= right) ans.add(list.get(idx++));
return ans;
}
}
```
* 时间复杂度:$n = right - left + 1$。复杂度为$O(n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.726` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/729. 我的日程安排表 I（中等）.md | 729. 我的日程安排表 I | https://leetcode.cn/problems/my-calendar-i/solution/by-ac_oier-hnjl/ | 中等 | [
"模拟",
"红黑树",
"线段树(动态开点)",
"线段树",
"分块",
"位运算",
"哈希表"
] | 实现一个 `MyCalendar` 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ,则可以存储这个新的日程安排。
当两个日程安排有一些时间上的交叉时(例如两个日程安排都在同一时间内),就会产生 重复预订 。
日程可以用一对整数 `start` 和 `end` 表示,这里的时间是半开区间,即 $[start, end)$, 实数 $x$ 的范围为, $start <= x < end$ 。
实现 MyCalendar 类:
* `MyCalendar()` 初始化日历对象。
* `boolean book(int start, int end)` 如果可以将日程安排成功添加到日历中而不会导致重复预订,返回 `true`。否则,返回 `false` 并且不要将该日程安排添加到日历中。
示例:
```
输入:
["MyCalendar", "book", "book", "book"]
[[], [10, 20], [15, 25], [20, 30]]
输出:
[null, true, false, true]
解释:
MyCalendar myCalendar = new MyCalendar();
myCalendar.book(10, 20); // return True
myCalendar.book(15, 25); // return False ,这个日程安排不能添加到日历中,因为时间 15 已经被另一个日程安排预订了。
myCalendar.book(20, 30); // return True ,这个日程安排可以添加到日历中,因为第一个日程安排预订的每个时间都小于 20 ,且不包含时间 20 。
```
提示:
* $0 <= start < end <= 10^9$
* 每个测试用例,调用 `book` 方法的次数最多不超过 $1000$ 次。 | ### 模拟
利用 `book` 操作最多调用 $1000$ 次,我们可以使用一个数组存储所有已被预定的日期 $[start, end - 1]$,对于每次 `book` 操作,检查当前传入的 $[start, end)$ 是否会与已有的日期冲突,冲突返回 `False`,否则将 $[start, end- 1]$ 插入数组并返回 `True`。
代码:
```Java
class MyCalendar {
List<int[]> list = new ArrayList<>();
public boolean book(int start, int end) {
end--;
for (int[] info : list) {
int l = info[0], r = info[1];
if (start > r || end < l) continue;
return false;
}
list.add(new int[]{start, end});
return true;
}
}
```
* 时间复杂度:令 $n$ 为 `book` 的最大调用次数,复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$
---
### 线段树(动态开点)
线段树维护的节点信息包括:
* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;
* `add`: 懒标记;
* `val`: 为当前区间的所包含的点的数量。
对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 * n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。
如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE` 问题。
但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。
动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1 | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。
由于存在「懒标记」,线段树的插入和查询都是 $\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\log{n}$ 的点,因此空间复杂度为 $O(m\log{n})$,而不是 $O(4 * n)$,而开点数的预估需不能仅仅根据 $\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。
动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 * n$ 的空间,因此盲猜 $\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 * m * \log{n}$,其中 $n = 1e9$ 和 $m = 1e3$ 分别代表值域大小和查询次数。
当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 $128M$ 可以开到 $5 * 10^6$ 以上)。
代码:
```Java
class MyCalendar {
class Node {
// ls 和 rs 分别代表当前节点的左右子节点在 tr 的下标
// val 代表当前节点有多少数
// add 为懒标记
int ls, rs, add, val;
}
int N = (int)1e9, M = 120010, cnt = 1;
Node[] tr = new Node[M];
void update(int u, int lc, int rc, int l, int r, int v) {
if (l <= lc && rc <= r) {
tr[u].val += (rc - lc + 1) * v;
tr[u].add += v;
return ;
}
lazyCreate(u);
pushdown(u, rc - lc + 1);
int mid = lc + rc >> 1;
if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);
if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);
pushup(u);
}
int query(int u, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return tr[u].val;
lazyCreate(u);
pushdown(u, rc - lc + 1);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);
if (r > mid) ans += query(tr[u].rs, mid + 1, rc, l, r);
return ans;
}
void lazyCreate(int u) {
if (tr[u] == null) tr[u] = new Node();
if (tr[u].ls == 0) {
tr[u].ls = ++cnt;
tr[tr[u].ls] = new Node();
}
if (tr[u].rs == 0) {
tr[u].rs = ++cnt;
tr[tr[u].rs] = new Node();
}
}
void pushdown(int u, int len) {
tr[tr[u].ls].add += tr[u].add; tr[tr[u].rs].add += tr[u].add;
tr[tr[u].ls].val += (len - len / 2) * tr[u].add; tr[tr[u].rs].val += len / 2 * tr[u].add;
tr[u].add = 0;
}
void pushup(int u) {
tr[u].val = tr[tr[u].ls].val + tr[tr[u].rs].val;
}
public boolean book(int start, int end) {
if (query(1, 1, N + 1, start + 1, end) > 0) return false;
update(1, 1, N + 1, start + 1, end, 1);
return true;
}
}
```
* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\log{n})$
* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\log{n})$
---
### 分块 + 位运算(分桶)
另一个留有遗憾的算法是「分块」,朴素的分块做法是使用一个布尔数组 `region` 代表某个块是否有被占用,使用哈希表记录具体某个位置是否被占用,但可惜被奇怪的测评机制卡了。
`TLE` 代码:
```Java
class MyCalendar {
static Boolean T = Boolean.TRUE, F = Boolean.FALSE;
static int n = (int)1e9, len = (int) Math.sqrt(n) + 30;
static boolean[] region = new boolean[len];
static Map<Integer, Boolean> map = new HashMap<>();
int getIdx(int x) {
return x / len;
}
void add(int l, int r) {
if (getIdx(l) == getIdx(r)) {
for (int k = l; k <= r; k++) map.put(k, T);
} else {
int j = l, i = r;
while (getIdx(j) == getIdx(l)) map.put(j++, T);
while (getIdx(i) == getIdx(r)) map.put(i--, T);
for (int k = getIdx(j); k <= getIdx(i); k++) region[k] = true;
}
}
boolean query(int l, int r) {
if (getIdx(l) == getIdx(r)) {
boolean cur = region[getIdx(l)];
for (int k = l; k <= r; k++) {
if (map.getOrDefault(k, F) || cur) return false;
}
return true;
} else {
int j = l, i = r;
while (getIdx(j) == getIdx(l)) {
if (map.getOrDefault(j, F) || region[getIdx(j)]) return false;
j++;
}
while (getIdx(i) == getIdx(r)) {
if (map.getOrDefault(i, F) || region[getIdx(i)]) return false;
i--;
}
for (int k = getIdx(j); k <= getIdx(i); k++) {
if (region[k]) return false;
}
return true;
}
}
public MyCalendar() {
Arrays.fill(region, false);
map.clear();
}
public boolean book(int start, int end) {
if (query(start, end - 1)) {
add(start, end - 1);
return true;
}
return false;
}
}
```
但我们知道分块算法的复杂度并不糟糕,而哈希表可能是被卡常数的关键,因此我们可以使用 `int` 数组来充当哈希表,由于只需要记录「是否被占用」,因此我们可以使用 `int` 的每一位充当格子,通过这种「分桶 + 位运算」,有效降低常数。
`AC` 代码(`2022-07-05` 可过):
```Java
class MyCalendar {
static int n = (int)1e9, len = (int) Math.sqrt(n) + 50, cnt = 32;
static boolean[] region = new boolean[len];
static int[] map = new int[n / cnt];
int getIdx(int x) {
return x / len;
}
boolean get(int x) {
return ((map[x / cnt] >> (x % cnt)) & 1) == 1;
}
void set(int x) {
map[x / cnt] |= (1 << (x % cnt));
}
void add(int l, int r) {
if (getIdx(l) == getIdx(r)) {
for (int k = l; k <= r; k++) set(k);
} else {
int j = l, i = r;
while (getIdx(j) == getIdx(l)) set(j++);
while (getIdx(i) == getIdx(r)) set(i--);
for (int k = getIdx(j); k <= getIdx(i); k++) region[k] = true;
}
}
boolean query(int l, int r) {
if (getIdx(l) == getIdx(r)) {
boolean cur = region[getIdx(l)];
for (int k = l; k <= r; k++) {
if (get(k) || cur) return false;
}
return true;
} else {
int j = l, i = r;
while (getIdx(j) == getIdx(l)) {
if (get(j) || region[getIdx(j)]) return false;
j++;
}
while (getIdx(i) == getIdx(r)) {
if (get(i) || region[getIdx(i)]) return false;
i--;
}
for (int k = getIdx(j); k <= getIdx(i); k++) {
if (region[k]) return false;
}
return true;
}
}
public MyCalendar() {
Arrays.fill(region, false);
Arrays.fill(map, 0);
}
public boolean book(int start, int end) {
if (query(start, end - 1)) {
add(start, end - 1);
return true;
}
return false;
}
}
```
* 时间复杂度:$O(n\sqrt{m})$
* 空间复杂度:$O(\sqrt{m} + \frac{M}{k})$,其中 $M = 1e9$ 为值域大小,$k = 32$ 为单个数字的能够存储的格子数 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.729` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/721-730/730. 统计不同回文子序列（困难）.md | 730. 统计不同回文子序列 | https://leetcode.cn/problems/count-different-palindromic-subsequences/solution/by-ac_oier-lbva/ | 困难 | [
"区间 DP",
"动态规划"
] | 给定一个字符串 `s`,返回 `s` 中不同的非空「回文子序列」个数 。
通过从 `s` 中删除 $0$ 个或多个字符来获得子序列。
如果一个字符序列与它反转后的字符序列一致,那么它是「回文字符序列」。
如果有某个 $i$ , 满足 $a_i$ != $b_i$ ,则两个序列 `a1, a2, ...` 和 `b1, b2, ...` 不同。
注意:
* 结果可能很大,你需要对 $10^9 + 7$ 取模 。
示例 1:
```
输入:s = 'bccb'
输出:6
解释:6 个不同的非空回文子字符序列分别为:'b', 'c', 'bb', 'cc', 'bcb', 'bccb'。
注意:'bcb' 虽然出现两次但仅计数一次。
```
示例 2:
```
输入:s = 'abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba'
输出:104860361
解释:共有 3104860382 个不同的非空回文子序列,104860361 对 109 + 7 取模后的值。
```
提示:
* $1 <= s.length <= 1000$
* `s[i]` 仅包含 `'a'`, `'b'`, `'c'` 或 `'d'` | ### 区间 DP
往长度较少的回文串两端添加字符,可能组成新的长度大的回文串,容易想到「区间 DP」,同时 `s` 仅由 $4$ 类小写字母组成,也是一个切入点。
根据区间 DP 的一般思路,定义 $f[i][j]$ 为考虑字符串 `s` 中的 $[i,j]$ 范围内回文子序列的个数,最终答案为 $f[0][n - 1]$。
**不失一般性考虑 $f[i][j]$ 该如何转移,通过枚举 `abcd` 作为回文方案「边缘字符」来进行统计,即分别统计各类字符作为「边缘字符」时对 $f[i][j]$ 的贡献,此类统计方式天生不存在重复性问题。**
假设当前枚举到的字符为 $k$ :
* 若 $s[i...j]$ 中没有字符 $k$,则字符 $k$ 对 $f[i][j]$ 贡献为 $0$,跳过;
* 若 $s[i...j]$ 中存在字符 $k$,根据字符 $k$ 在范围 $s[i...j]$ 中「最小下标」和「最大下标」进行分情况讨论,假设字符 $k$ 在 $s[i...j]$ 中「最靠左」的位置为 $l$,「最靠右」的位置为 $r$:
* 当 $l = r$ 时,此时字符 $k$ 对 $f[i][j]$ 的贡献为 $1$,即 `k` 本身;
* 当 $l = r - 1$ 时,说明字符 $k$ 中间不存在任何字符,此时字符 $k$ 对 $f[i][j]$ 的贡献为 $2$,包括 `k` 和 `kk` 两种回文方案;
* 其余情况,可根据已算得的「小区间回文方案」进行延伸(两段分别补充位于 $l$ 和 $r$ 的字符 $k$),得到新的大区间方案,此部分对 $f[i][j]$ 的贡献是 $f[l + 1][r - 1]$,另外还有 `k` 和 `kk` 两种回文方案,因此总的对答案的贡献为 $f[l + 1][r - 1] + 2$。
统计 $s[i...j]$ 中各类字符「最靠左」和「最靠右」的位置,可通过调整枚举方向来实现:从大到小枚举 $i$,同时维护 `L[s[i]-'a'] = i`,即可得到「最靠左」的位置;在确定左端点 $i$ 之后,从小到大枚举右端点 $j$,同时维护 `R[s[j]-'a'] = j`,即可得到「最靠右」的位置。
代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int countPalindromicSubsequences(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
int[][] f = new int[n][n];
int[] L = new int[4], R = new int[4];
Arrays.fill(L, -1);
for (int i = n - 1; i >= 0; i--) {
L[cs[i] - 'a'] = i;
Arrays.fill(R, -1);
for (int j = i; j < n; j++) {
R[cs[j] - 'a'] = j;
for (int k = 0; k < 4; k++) {
if (L[k] == -1 || R[k] == -1) continue;
int l = L[k], r = R[k];
if (l == r) f[i][j] = (f[i][j] + 1) % MOD;
else if (l == r - 1) f[i][j] = (f[i][j] + 2) % MOD;
else f[i][j] = (f[i][j] + f[l + 1][r - 1] + 2) % MOD;
}
}
}
return f[0][n - 1];
}
}
```
* 时间复杂度:$O(C \times n^2)$,其中 $C = 4$ 为字符集大小
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.730` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/731. 我的日程安排表 II（中等）.md | 731. 我的日程安排表 II | https://leetcode.cn/problems/my-calendar-ii/solution/by-ac_oier-a1b3/ | 中等 | [
"线段树(动态开点)",
"线段树"
] | 实现一个 `MyCalendar` 类来存放你的日程安排。如果要添加的时间内不会导致三重预订时,则可以存储这个新的日程安排。
`MyCalendar` 有一个 `book(int start, int end)` 方法。它意味着在 `start` 到 `end` 时间内增加一个日程安排,注意,这里的时间是半开区间,即 $[start, end)$, 实数 $x$ 的范围为,$ start <= x < end$。
当三个日程安排有一些时间上的交叉时(例如三个日程安排都在同一时间内),就会产生三重预订。
每次调用 `MyCalendar.book` 方法时,如果可以将日程安排成功添加到日历中而不会导致三重预订,返回 `true`。否则,返回 `false` 并且不要将该日程安排添加到日历中。
请按照以下步骤调用 `MyCalendar` 类: `MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)`
示例:
```
MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(50, 60); // returns true
MyCalendar.book(10, 40); // returns true
MyCalendar.book(5, 15); // returns false
MyCalendar.book(5, 10); // returns true
MyCalendar.book(25, 55); // returns true
解释:
前两个日程安排可以添加至日历中。 第三个日程安排会导致双重预订,但可以添加至日历中。
第四个日程安排活动(5,15)不能添加至日历中,因为它会导致三重预订。
第五个日程安排(5,10)可以添加至日历中,因为它未使用已经双重预订的时间10。
第六个日程安排(25,55)可以添加至日历中,因为时间 [25,40] 将和第三个日程安排双重预订;
时间 [40,50] 将单独预订,时间 [50,55)将和第二个日程安排双重预订。
```
提示:
* 每个测试用例,调用 `MyCalendar.book` 函数最多不超过 $1000$ 次。
* 调用函数 `MyCalendar.book(start, end)` 时, `start` 和 `end` 的取值范围为 $[0, 10^9]$。 | ### 线段树(动态开点)- 估点
和 [729. 我的日程安排表 I](https://leetcode-cn.com/problems/my-calendar-i/solution/by-ac_oier-1znx/) 几乎完全一致,只需要将对「线段树」所维护的节点信息进行调整即可。
线段树维护的节点信息包括:
* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;
* `add`: 懒标记;
* `max`: 为当前区间的最大值。
对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 \times n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。
如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE` 问题。
但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。
动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1 | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。
由于存在「懒标记」,线段树的插入和查询都是 $\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\log{n}$ 的点,因此空间复杂度为 $O(m\log{n})$,而不是 $O(4 \times n)$,而开点数的预估需不能仅仅根据 $\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。
动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 \times n$ 的空间,因此盲猜 $\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 \times m \times \log{n}$,其中 $n = 1e9$ 和 $m = 1e3$ 分别代表值域大小和查询次数。
当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 $128M$ 可以开到 $5 \times 10^6$ 以上)。
Java 代码:
```Java
class MyCalendarTwo {
class Node {
int ls, rs, add, max;
}
int N = (int)1e9, M = 120010, cnt = 1;
Node[] tr = new Node[M];
void update(int u, int lc, int rc, int l, int r, int v) {
if (l <= lc && rc <= r) {
tr[u].add += v;
tr[u].max += v;
return ;
}
lazyCreate(u);
pushdown(u);
int mid = lc + rc >> 1;
if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);
if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);
pushup(u);
}
int query(int u, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return tr[u].max;
lazyCreate(u);
pushdown(u);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = Math.max(ans, query(tr[u].ls, lc, mid, l, r));
if (r > mid) ans = Math.max(ans, query(tr[u].rs, mid + 1, rc, l, r));
return ans;
}
void lazyCreate(int u) {
if (tr[u] == null) tr[u] = new Node();
if (tr[u].ls == 0) {
tr[u].ls = ++cnt;
tr[tr[u].ls] = new Node();
}
if (tr[u].rs == 0) {
tr[u].rs = ++cnt;
tr[tr[u].rs] = new Node();
}
}
void pushup(int u) {
tr[u].max = Math.max(tr[tr[u].ls].max, tr[tr[u].rs].max);
}
void pushdown(int u) {
tr[tr[u].ls].add += tr[u].add; tr[tr[u].rs].add += tr[u].add;
tr[tr[u].ls].max += tr[u].add; tr[tr[u].rs].max += tr[u].add;
tr[u].add = 0;
}
public boolean book(int start, int end) {
if (query(1, 1, N + 1, start + 1, end) >= 2) return false;
update(1, 1, N + 1, start + 1, end, 1);
return true;
}
}
```
TypeScript 代码:
```TypeScript
class TNode {
ls: number = 0; rs: number = 0
max:number = 0; add: number = 0;
}
class MyCalendarTwo {
N = 1e9; M = 120010; cnt = 1
tr: TNode[] = new Array<TNode>(this.M)
query(u: number, lc: number, rc: number, l: number, r: number): number {
if (l <= lc && rc <= r) return this.tr[u].max;
this.pushdown(u)
let mid = lc + rc >> 1, ans = 0
if (l <= mid) ans = Math.max(ans, this.query(this.tr[u].ls, lc, mid, l, r))
if (r > mid) ans = Math.max(ans, this.query(this.tr[u].rs, mid + 1, rc, l, r))
return ans
}
update(u: number, lc: number, rc: number, l: number, r: number, v: number): number {
if (l <= lc && rc <= r) {
this.tr[u].add += v
this.tr[u].max += v
return
}
this.pushdown(u)
let mid = lc + rc >> 1
if (l <= mid) this.update(this.tr[u].ls, lc, mid, l, r, v)
if (r > mid) this.update(this.tr[u].rs, mid + 1, rc, l, r, v)
this.pushdup(u)
}
pushdown(u: number): void {
if (this.tr[u] == null) this.tr[u] = new TNode()
if (this.tr[u].ls == 0) {
this.tr[u].ls = ++this.cnt
this.tr[this.tr[u].ls] = new TNode()
}
if (this.tr[u].rs == 0) {
this.tr[u].rs = ++this.cnt
this.tr[this.tr[u].rs] = new TNode()
}
const add = this.tr[u].add
this.tr[this.tr[u].ls].add += add; this.tr[this.tr[u].rs].add += add
this.tr[this.tr[u].ls].max += add; this.tr[this.tr[u].rs].max += add
this.tr[u].add = 0
}
pushdup(u: number): void {
this.tr[u].max = Math.max(this.tr[this.tr[u].ls].max, this.tr[this.tr[u].rs].max)
}
book(start: number, end: number): boolean {
if (this.query(1, 1, this.N + 1, start + 1, end) >= 2) return false
this.update(1, 1, this.N + 1, start + 1, end, 1)
return true
}
}
```
* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\log{n})$
* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\log{n})$
---
### 线段树(动态开点)- 动态指针
利用「动态指针」实现的「动态开点」可以有效避免数组估点问题,更重要的是可以有效避免 `new` 大数组的初始化开销,对于 LC 这种还跟你算所有样例总时长的 OJ 来说,在不考虑 `static` 优化/全局数组优化 的情况下,动态指针的方式要比估点的方式来得好。
Java 代码:
```Java
class MyCalendarTwo {
class Node {
Node ls, rs;
int max, add;
}
int N = (int)1e9;
Node root = new Node();
void update(Node node, int lc, int rc, int l, int r, int v) {
if (l <= lc && rc <= r) {
node.add += v;
node.max += v;
return ;
}
pushdown(node);
int mid = lc + rc >> 1;
if (l <= mid) update(node.ls, lc, mid, l, r, v);
if (r > mid) update(node.rs, mid + 1, rc, l, r, v);
pushup(node);
}
int query(Node node, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return node.max;
pushdown(node);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = query(node.ls, lc, mid, l, r);
if (r > mid) ans = Math.max(ans, query(node.rs, mid + 1, rc, l, r));
return ans;
}
void pushdown(Node node) {
if (node.ls == null) node.ls = new Node();
if (node.rs == null) node.rs = new Node();
int add = node.add;
node.ls.max += add; node.rs.max += add;
node.ls.add += add; node.rs.add += add;
node.add = 0;
}
void pushup(Node node) {
node.max = Math.max(node.ls.max, node.rs.max);
}
public boolean book(int start, int end) {
if (query(root, 0, N, start, end - 1) >= 2) return false;
update(root, 0, N, start, end - 1, 1);
return true;
}
}
```
TypeScript 代码:
```TypeScript
class TNode {
ls: TNode = null; rs: TNode = null
max: number = 0; add: number = 0
}
class MyCalendarTwo {
root: TNode = new TNode()
update(node: TNode, lc: number, rc: number, l: number, r: number, v: number): void {
if (l <= lc && rc <= r) {
node.add += v
node.max += v
return
}
this.pushdown(node)
let mid = lc + rc >> 1
if (l <= mid) this.update(node.ls, lc, mid, l, r, v)
if (r > mid) this.update(node.rs, mid + 1, rc, l, r, v)
this.pushup(node)
}
query(node: TNode, lc: number, rc: number, l: number, r: number): number {
if (l <= lc && rc <= r) return node.max
let mid = lc + rc >> 1, ans = 0
this.pushdown(node)
if (l <= mid) ans = this.query(node.ls, lc, mid, l, r)
if (r > mid) ans = Math.max(ans, this.query(node.rs, mid + 1, rc, l, r))
return ans
}
pushdown(node: TNode): void {
if (node.ls == null) node.ls = new TNode()
if (node.rs == null) node.rs = new TNode()
const add = node.add
node.ls.add += add; node.rs.add += add
node.ls.max += add; node.rs.max += add
node.add = 0
}
pushup(node: TNode): void {
node.max = Math.max(node.ls.max, node.rs.max)
}
book(start: number, end: number): boolean {
if (this.query(this.root, 0, 1e9, start, end - 1) >= 2) return false
this.update(this.root, 0, 1e9, start, end - 1, 1)
return true
}
}
```
* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\log{n})$
* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.731` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/732. 我的日程安排表 III（困难）.md | 732. 我的日程安排表 III | https://leetcode-cn.com/problems/my-calendar-iii/solution/by-ac_oier-cv31/ | 困难 | [
"线段树(动态开点)",
"分块",
"线段树"
] | 当 $k$ 个日程安排有一些时间上的交叉时(例如 $k$ 个日程安排都在同一时间内),就会产生 $k$ 次预订。
给你一些日程安排 $[start, end)$ ,请你在每个日程安排添加后,返回一个整数 $k$ ,表示所有先前日程安排会产生的最大 $k$ 次预订。
实现一个 `MyCalendarThree` 类来存放你的日程安排,你可以一直添加新的日程安排。
* `MyCalendarThree()` 初始化对象。
* `int book(int start, int end)` 返回一个整数 $k$ ,表示日历中存在的 $k$ 次预订的最大值。
示例:
```
输入:
["MyCalendarThree", "book", "book", "book", "book", "book", "book"]
[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]
输出:
[null, 1, 1, 2, 3, 3, 3]
解释:
MyCalendarThree myCalendarThree = new MyCalendarThree();
myCalendarThree.book(10, 20); // 返回 1 ,第一个日程安排可以预订并且不存在相交,所以最大 k 次预订是 1 次预订。
myCalendarThree.book(50, 60); // 返回 1 ,第二个日程安排可以预订并且不存在相交,所以最大 k 次预订是 1 次预订。
myCalendarThree.book(10, 40); // 返回 2 ,第三个日程安排 [10, 40) 与第一个日程安排相交,所以最大 k 次预订是 2 次预订。
myCalendarThree.book(5, 15); // 返回 3 ,剩下的日程安排的最大 k 次预订是 3 次预订。
myCalendarThree.book(5, 10); // 返回 3
myCalendarThree.book(25, 55); // 返回 3
```
提示:
* $0 <= start < end <= 10^9$
* 每个测试用例,调用 `book` 函数最多不超过 $400$ 次 | ### 线段树(动态开点)
和 [731. 我的日程安排表 II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491636&idx=1&sn=48bfdd56cdcc33ededd6f154ffd41f0a) 几乎完全一致,只需要将对「线段树」所维护的节点信息进行调整即可。
线段树维护的节点信息包括:
* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;
* `add`: 懒标记;
* `max`: 为当前区间的最大值。
对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 \times n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。
如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE` 问题。
但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。
动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1 | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。
由于存在「懒标记」,线段树的插入和查询都是 $\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\log{n}$ 的点,因此空间复杂度为 $O(m\log{n})$,而不是 $O(4 \times n)$,而开点数的预估需不能仅仅根据 $\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。
动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 \times n$ 的空间,因此盲猜 $\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 \times m \times \log{n}$,其中 $n = 1e9$ 和 $m = 1e3$ 分别代表值域大小和查询次数。
当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 `128M` 可以开到 $5 \times 10^6$ 以上)。
代码:
```Java
class MyCalendarThree {
class Node {
int ls, rs, add, max;
}
int N = (int)1e9, M = 4 * 400 * 20, cnt = 1;
Node[] tr = new Node[M];
void update(int u, int lc, int rc, int l, int r, int v) {
if (l <= lc && rc <= r) {
tr[u].add += v;
tr[u].max += v;
return ;
}
lazyCreate(u);
pushdown(u);
int mid = lc + rc >> 1;
if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);
if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);
pushup(u);
}
int query(int u, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return tr[u].max;
lazyCreate(u);
pushdown(u);
int mid = lc + rc >> 1, ans = 0;
if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);
if (r > mid) ans = Math.max(ans, query(tr[u].rs, mid + 1, rc, l, r));
return ans;
}
void lazyCreate(int u) {
if (tr[u] == null) tr[u] = new Node();
if (tr[u].ls == 0) {
tr[u].ls = ++cnt;
tr[tr[u].ls] = new Node();
}
if (tr[u].rs == 0) {
tr[u].rs = ++cnt;
tr[tr[u].rs] = new Node();
}
}
void pushdown(int u) {
tr[tr[u].ls].add += tr[u].add; tr[tr[u].rs].add += tr[u].add;
tr[tr[u].ls].max += tr[u].add; tr[tr[u].rs].max += tr[u].add;
tr[u].add = 0;
}
void pushup(int u) {
tr[u].max = Math.max(tr[tr[u].ls].max, tr[tr[u].rs].max);
}
public int book(int start, int end) {
update(1, 1, N + 1, start + 1, end, 1);
return query(1, 1, N + 1, 1, N + 1);
}
}
```
* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\log{n})$
* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\log{n})$
---
### 带懒标记的分块(TLE)
实际上,还存在另外一种十分值得学习的算法:分块。
但该做法被奇怪的测评机制卡掉,是给每个样例都定了执行用时吗 🤣 ?
旧题解没有这种做法,今天补充的,我们可以大概讲讲「分块」算法是如何解决涉及「区间修改」,也就是带懒标记的问题。
对于本题,我们设定两个块数组 `max` 和 `add`,其中 `max[idx]` 含义为块编号为 `idx` 的连续区间的最大重复值,而 `add[idx]` 代表块编号的懒标记,同时使用「哈希表」记录下某些具体位置的覆盖次数。
然后我们考虑如何指定块大小,设定一个合理的块大小是减少运算量的关键。
通常情况下,我们会设定块大小为 $\sqrt{n}$,从而确保块内最多不超过 $\sqrt{n}$ 个元素,同时块的总个数也不超过 $\sqrt{n}$,即无论我们是块内暴力,还是操作多个块,复杂度均为 $O(\sqrt{n})$。因此对于本题而言,设定块大小为 $\sqrt{1e9}$(经试验,调成 $1200010$ 能够通过较多样例),较为合适。
对于涉及「区间修改」的分块算法,我们需要在每次修改和查询前,先将懒标记下传到区间的每个元素中。
然后考虑如何处理「块内」和「块间」操作:
* 块内操作:
* 块内更新:直接操作 `map` 进行累加,同时使用更新后的 `map` 来维护相应的 `max[idx]`;
* 块内查询:直接查询 `map` 即可;
* 块间操作:
* 块间更新:直接更新懒标记 `add[idx]` 即可,同时由于我们是对整个区间进行累加操作,因此最大值必然也会同步被累加,因此同步更新 `max[idx]`;
* 块间查询:直接查询 `max[idx]` 即可。
代码:
```Java
class MyCalendarThree {
static int N = (int)1e9 + 10, M = 1200010, SZ = N / M + 10;
static int[] max = new int[M], add = new int[M];
static Map<Integer, Integer> map = new HashMap<>();
int minv = -1, maxv = -1;
int getIdx(int x) {
return x / SZ;
}
void add(int l, int r) {
pushdown(l); pushdown(r);
if (getIdx(l) == getIdx(r)) {
for (int k = l; k <= r; k++) {
map.put(k, map.getOrDefault(k, 0) + 1);
max[getIdx(k)] = Math.max(max[getIdx(k)], map.get(k));
}
} else {
int i = l, j = r;
while (getIdx(i) == getIdx(l)) {
map.put(i, map.getOrDefault(i, 0) + 1);
max[getIdx(i)] = Math.max(max[getIdx(i)], map.get(i));
i++;
}
while (getIdx(j) == getIdx(r)) {
map.put(j, map.getOrDefault(j, 0) + 1);
max[getIdx(j)] = Math.max(max[getIdx(j)], map.get(j));
j--;
}
for (int k = getIdx(i); k <= getIdx(j); k++) {
max[k]++; add[k]++;
}
}
}
int query(int l, int r) {
pushdown(l); pushdown(r);
int ans = 0;
if (getIdx(l) == getIdx(r)) {
for (int k = l; k <= r; k++) ans = Math.max(ans, map.getOrDefault(k, 0));
} else {
int i = l, j = r;
while (getIdx(i) == getIdx(l)) ans = Math.max(ans, map.getOrDefault(i++, 0));
while (getIdx(j) == getIdx(r)) ans = Math.max(ans, map.getOrDefault(j--, 0));
for (int k = getIdx(i); k <= getIdx(j); k++) ans = Math.max(ans, max[k]);
}
return ans;
}
void pushdown(int x) {
int idx = getIdx(x);
if (add[idx] == 0) return ;
int i = x, j = x + 1;
while (getIdx(i) == idx) map.put(i, map.getOrDefault(i--, 0) + add[idx]);
while (getIdx(j) == idx) map.put(j, map.getOrDefault(j++, 0) + add[idx]);
add[idx] = 0;
}
public MyCalendarThree() {
Arrays.fill(max, 0);
Arrays.fill(add, 0);
map.clear();
}
public int book(int start, int end) {
add(start + 1, end);
minv = minv == -1 ? start : Math.min(minv, start);
maxv = maxv == -1 ? end + 1 : Math.max(maxv, end + 1);
return query(minv, maxv);
}
}
```
* 时间复杂度:令 $M$ 为块大小,复杂度为 $O(\sqrt{M})$
* 空间复杂度:$O(C \times \sqrt{M})$,其中 $C = 1e3$ 为最大调用次数 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.732` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/735. 行星碰撞（中等）.md | 735. 行星碰撞 | https://leetcode.cn/problems/asteroid-collision/solution/by-ac_oier-p4qh/ | 中等 | [
"栈",
"模拟"
] | 给定一个整数数组 `asteroids`,表示在同一行的行星。
对于数组中的每一个元素,其绝对值表示行星的大小,正负表示行星的移动方向(正表示向右移动,负表示向左移动)。
每一颗行星以相同的速度移动,找出碰撞后剩下的所有行星。
碰撞规则:
1. 两个行星相互碰撞,较小的行星会爆炸。
2. 如果两颗行星大小相同,则两颗行星都会爆炸。
3. 两颗移动方向相同的行星,永远不会发生碰撞。
示例 1:
```
输入:asteroids = [5,10,-5]
输出:[5,10]
解释:10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。
```
示例 2:
```
输入:asteroids = [8,-8]
输出:[]
解释:8 和 -8 碰撞后,两者都发生爆炸。
```
示例 3:
```
输入:asteroids = [10,2,-5]
输出:[10]
解释:2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。
```
提示:
* $2 <= asteroids.length <= 10^4$
* $-1000 <= asteroids[i] <= 1000$
* $asteroids[i] != 0$ | ### 模拟 + 栈
由于碰撞抵消总是从相邻行星之间发生,我们可以使用「栈」来模拟该过程。
从前往后处理所有的 $ats[i]$,使用栈存储当前未被抵消的行星,当栈顶元素方向往右,当前 $ats[i]$ 方向往左时,会发生抵消操作,抵消过程根据规则进行即可。
Java 代码:
```Java
class Solution {
public int[] asteroidCollision(int[] asteroids) {
Deque<Integer> d = new ArrayDeque<>();
for (int t : asteroids) {
boolean ok = true;
while (ok && !d.isEmpty() && d.peekLast() > 0 && t < 0) {
int a = d.peekLast(), b = -t;
if (a <= b) d.pollLast();
if (a >= b) ok = false;
}
if (ok) d.addLast(t);
}
int sz = d.size();
int[] ans = new int[sz];
while (!d.isEmpty()) ans[--sz] = d.pollLast();
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> asteroidCollision(vector<int>& asteroids) {
deque<int> d;
for (int t : asteroids) {
bool ok = true;
while (ok && !d.empty() && d.back() > 0 && t < 0) {
int a = d.back(), b = -t;
if (a <= b) d.pop_back();
if (a >= b) ok = false;
}
if (ok) d.push_back(t);
}
vector<int> ans(d.begin(), d.end());
return ans;
}
};
```
Python 3 代码:
```Python3
class Solution:
def asteroidCollision(self, asteroids: List[int]) -> List[int]:
stk = []
for t in asteroids:
ok = True
while ok and stk and stk[-1] > 0 and t < 0:
a, b = stk[-1], -t
if a <= b:
stk.pop(-1)
if a >= b:
ok = False
if ok:
stk.append(t)
return stk
```
TypeScript 代码:
```TypeScript
function asteroidCollision(asteroids: number[]): number[] {
const stk = new Array<number>()
for (const t of asteroids) {
let ok = true
while (ok && stk.length > 0 && stk[stk.length - 1] > 0 && t < 0) {
const a = stk[stk.length - 1], b = -t
if (a <= b) stk.pop()
if (a >= b) ok = false
}
if (ok) stk.push(t)
}
return stk
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.735` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/736. Lisp 语法解析（困难）.md | 736. Lisp 语法解析 | https://leetcode.cn/problems/parse-lisp-expression/solution/by-ac_oier-i7w1/ | 困难 | [
"DFS",
"模拟",
"哈希表"
] | 给你一个类似 `Lisp` 语句的字符串表达式 `expression`,求出其计算结果。
表达式语法如下所示:
* 表达式可以为整数,`let` 表达式,`add` 表达式,`mult` 表达式,或赋值的变量。表达式的结果总是一个整数。
* 整数可以是正整数、负整数、$0$
* `let` 表达式采用 `"(let v1 e1 v2 e2 ... vn en expr)"` 的形式,其中 `let` 总是以字符串 `"let"`来表示,接下来会跟随一对或多对交替的变量和表达式,也就是说,第一个变量 `v1`被分配为表达式 `e1` 的值,第二个变量 `v2` 被分配为表达式 `e2` 的值,依次类推;最终 `let` 表达式的值为 `expr` 表达式的值。
* `add` 表达式表示为 `"(add e1 e2)"` ,其中 `add` 总是以字符串 `"add"` 来表示,该表达式总是包含两个表达式 `e1`、`e2` ,最终结果是 `e1` 表达式的值与 `e2` 表达式的值之 和 。
* `mult` 表达式表示为 `"(mult e1 e2)"` ,其中 `mult` 总是以字符串 `"mult"` 表示,该表达式总是包含两个表达式 `e1`、e2,最终结果是 `e1` 表达式的值与 `e2` 表达式的值之 积 。
* 在该题目中,变量名以小写字符开始,之后跟随 $0$ 个或多个小写字符或数字。为了方便,`"add"` ,`"let"` ,`"mult"` 会被定义为 `"关键字" ,不会用作变量名。
* 最后,要说一下作用域的概念。计算变量名所对应的表达式时,在计算上下文中,首先检查最内层作用域(按括号计),然后按顺序依次检查外部作用域。测试用例中每一个表达式都是合法的。有关作用域的更多详细信息,请参阅示例。
示例 1:
```
输入:expression = "(let x 2 (mult x (let x 3 y 4 (add x y))))"
输出:14
解释:
计算表达式 (add x y), 在检查变量 x 值时,
在变量的上下文中由最内层作用域依次向外检查。
首先找到 x = 3, 所以此处的 x 值是 3 。
```
示例 2:
```
输入:expression = "(let x 3 x 2 x)"
输出:2
解释:let 语句中的赋值运算按顺序处理即可。
```
示例 3:
```
输入:expression = "(let x 1 y 2 x (add x y) (add x y))"
输出:5
解释:
第一个 (add x y) 计算结果是 3,并且将此值赋给了 x 。
第二个 (add x y) 计算结果是 3 + 2 = 5 。
```
提示:
* $1 <= expression.length <= 2000$
* `exprssion` 中不含前导和尾随空格
* `expressoin` 中的不同部分(`token`)之间用单个空格进行分隔
* 答案和所有中间计算结果都符合 `32-bit` 整数范围 | ### DFS 模拟
今天身体不舒服,不写太详细,题目不难,大家结合代码看吧。
设计函数 `int dfs(int l, int r, Map<String, Integer> map)`,代表计算 $s[l...r]$ 的结果,答案为 `dfs(0,n-1,map)`,其中 $n$ 为字符串的长度。
根据传入的 $[l, r]$ 是否为表达式分情况讨论:
* 若 $s[l] = ($,说明是表达式,此时从 $l$ 开始往后取,取到空格为止(假设位置为 `idx`),从而得到操作 `op`(其中 `op` 为 `let`、`add` 或 `mult` 三者之一),此时 `op` 对应参数为 $[idx + 1, r - 1]$,也就是需要跳过位置 $r$(即跳过 `op` 对应的 `)` 符号);
再根据 `op` 为何种操作进一步处理,我们设计一个「传入左端点找右端点」的函数 `int getRight(int left, int end)`,含义为从 `left` 出发,一直往右找(不超过 `end`),直到取得合法的「子表达式」或「对应的值」。
```Java
// 对于 getRight 函数作用,给大家举个 🌰 理解吧,其实就是从 left 出发,找到合法的「子表达式」或「值」为止
// (let x 2 (mult x (let x 3 y 4 (add x y))))
// a b
// 传入 a 返回 b,代表 [a, b) 表达式为 (mult x (let x 3 y 4 (add x y)))
// (let x 2 (mult x (let x 3 y 4 (add x y))))
// ab
// 传入 a 返回 b,代表 [a, b) 表达式为 x
```
* 否则 $s[l...r]$ 不是表达式,通过判断 $s[l...r]$ 是否有被哈希表记录来得知结果:若在哈希表中有记录,结果为哈希表中的映射值,否则结果为本身所代表的数值。
需要注意,根据「作用域」的定义,我们不能使用全局哈希表,而要在每一层递归时,传入 `clone` 出来的 `map`。
代码:
```Java
class Solution {
char[] cs;
String s;
public int evaluate(String _s) {
s = _s;
cs = s.toCharArray();
return dfs(0, cs.length - 1, new HashMap<>());
}
int dfs(int l, int r, Map<String, Integer> map) {
if (cs[l] == '(') {
int idx = l;
while (cs[idx] != ' ') idx++;
String op = s.substring(l + 1, idx);
r--;
if (op.equals("let")) {
for (int i = idx + 1; i <= r; ) {
int j = getRight(i, r);
String key = s.substring(i, j);
if (j >= r) return dfs(i, j - 1, new HashMap<>(map));
j++; i = j;
j = getRight(i, r);
int value = dfs(i, j - 1, new HashMap<>(map));
map.put(key, value);
i = j + 1;
}
return -1; // never
} else {
int j = getRight(idx + 1, r);
int a = dfs(idx + 1, j - 1, new HashMap<>(map)), b = dfs(j + 1, r, new HashMap<>(map));
return op.equals("add") ? a + b : a * b;
}
} else {
String cur = s.substring(l, r + 1);
if (map.containsKey(cur)) return map.get(cur);
return Integer.parseInt(cur);
}
}
int getRight(int left, int end) {
int right = left, score = 0;
while (right <= end) {
if (cs[right] == '(') {
score++; right++;
} else if (cs[right] == ')') {
score--; right++;
} else if (cs[right] == ' ') {
if (score == 0) break;
right++;
} else {
right++;
}
}
return right;
}
}
```
* 时间复杂度:除对表达式进行递归划分以外,还存在对 `map` 的每层拷贝操作,复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/739. 每日温度（中等）.md | 739. 每日温度 | https://leetcode.cn/problems/daily-temperatures/solution/by-ac_oier-aj5k/ | 中等 | [
"单调栈"
] | 给定一个整数数组 `temperatures`,表示每天的温度,返回一个数组 `answer`,其中 `answer[i]` 是指对于第 `i` 天,下一个更高温度出现在几天后。如果气温在这之后都不会升高,请在该位置用 `0` 来代替。
示例 1:
```
输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]
```
示例 2:
```
输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]
```
示例 3:
```
输入: temperatures = [30,60,90]
输出: [1,1,0]
```
提示:
* $1 <= temperatures.length <= 10^5$
* $30 <= temperatures[i] <= 100$ | ### 单调栈
抽象题意为 : 求解给定序列中每个位置(右边)最近一个比其大的位置,可使用「单调栈」来进行求解。
具体的,我们可以从前往后处理所有的 $temperatures[i]$,使用某类容器装载我们所有的「待更新」的位置(下标),假设当前处理到的是 $temperatures[i]$:
* 若其比容器内的任意位置(下标)对应温度要低,其必然不能更新任何位置(下标),将其也加入容器尾部(此时我们发现,若有一个新的位置(下标)加入容器,其必然是当前所有待更新位置(下标)中的温度最低的,即容器内的温度单调递减);
* 若其价格高于容器内的任一位置(下标)对应温度,其能够更新容器位置(下标)的答案,并且由于我们容器满足单调递减特性,我们必然能够从尾部开始取出待更新位置来进行更新答案,直到处理完成或遇到第一个无法更新位置。
由于我们需要往尾部添加和取出元素,因此容器可使用「栈」。
Java 代码:
```Java
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
int n = temperatures.length;
int[] ans = new int[n];
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && temperatures[d.peekLast()] < temperatures[i]) {
int idx = d.pollLast();
ans[idx] = i - idx;
}
d.addLast(i);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> dailyTemperatures(vector<int>& temperatures) {
int n = temperatures.size();
vector<int> ans(n);
deque<int> d;
for (int i = 0; i < n; i++) {
while (!d.empty() && temperatures[d.back()] < temperatures[i]) {
int idx = d.back();
ans[idx] = i - idx;
d.pop_back();
}
d.push_back(i);
}
return ans;
}
};
```
Python3 代码:
```Python
class Solution:
def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
n, he, ta = len(temperatures), 0, 0
ans, stk = [0] * n, [-1] * n
for i in range(n):
while he < ta and temperatures[stk[ta - 1]] < temperatures[i]:
ta -= 1
idx = stk[ta]
ans[idx] = i - idx
stk[ta] = i
ta += 1
return ans
```
TypeScript 代码:
```TypeScript
function dailyTemperatures(temperatures: number[]): number[] {
const n = temperatures.length
const ans = new Array<number>(n).fill(0)
const stk = new Array<number>(n).fill(-1)
let he = 0, ta = 0
for (let i = 0; i < n; i++) {
while (he < ta && temperatures[stk[ta - 1]] < temperatures[i]) {
const idx = stk[--ta]
ans[idx] = i - idx
}
stk[ta++] = i
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.739` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/731-740/740. 删除并获得点数（中等）.md | 740. 删除并获得点数 | https://leetcode-cn.com/problems/delete-and-earn/solution/gong-shui-san-xie-zhuan-huan-wei-xu-lie-6c9t0/ | 中等 | [
"序列 DP"
] | 给你一个整数数组 nums ,你可以对它进行一些操作。
每次操作中,选择任意一个 nums[i] ,删除它并获得 nums[i] 的点数。之后,你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
示例 1:
```
输入:nums = [3,4,2]
输出:6
解释:
删除 4 获得 4 个点数,因此 3 也被删除。
之后,删除 2 获得 2 个点数。总共获得 6 个点数。
```
示例 2:
```
输入:nums = [2,2,3,3,3,4]
输出:9
解释:
删除 3 获得 3 个点数,接着要删除两个 2 和 4 。
之后,再次删除 3 获得 3 个点数,再次删除 3 获得 3 个点数。
总共获得 9 个点数。
```
提示:
* 1 <= nums.length <= 2 * $10^4$
* 1 <= nums[i] <= $10^4$ | ### 动态规划
根据题意,当我们选择 $nums[i]$ 的时候,比 $nums[i]$ 大/小 一个单位的数都不能被选择。
如果我们将数组排好序,从前往后处理,其实只需要考虑“当前数”与“前一个数”的「大小 & 选择」关系即可,这样处理完,显然每个数的「前一位/后一位」都会被考虑到。
这样我们将问题转化为一个「序列 DP」问题(选择某个数,需要考虑前一个数的「大小/选择」状态)。
**定义 $f[i][0]$ 代表数值为 $i$ 的数字「不选择」的最大价值;$f[i][1]$ 代表数值为 $i$ 的数字「选择」的最大价值。**
为了方便,我们可以先对 $nums$ 中出现的所有数值进行计数,而且由于数据范围只有 $10^4$,我们可以直接使用数组 $cnts[]$ 进行计数:$cnts[x] = i$ 代表数值 $x$ 出现了 $i$ 次。
**然后分别考虑一般性的 $f[i][0]$ 和 $f[i][1]$ 该如何计算:**
* **$f[i][0]$:当数值 $i$ 不被选择,那么前一个数「可选/可不选」,在两者中取 $max$ 即可。转移方程为 $f[i][0] = \max(f[i - 1][0], f[i - 1][1])$**
* **$f[i][1]$:当数值 $i$ 被选,那么前一个数只能「不选」,同时为了总和最大数值 $i$ 要选就全部选完。转移方程为 $f[i][1] = f[i - 1][0] + i * cnts[i]$**
代码:
```Java
class Solution {
int[] cnts = new int[10009];
public int deleteAndEarn(int[] nums) {
int n = nums.length;
int max = 0;
for (int x : nums) {
cnts[x]++;
max = Math.max(max, x);
}
// f[i][0] 代表「不选」数值 i;f[i][1] 代表「选择」数值 i
int[][] f = new int[max + 1][2];
for (int i = 1; i <= max; i++) {
f[i][1] = f[i - 1][0] + i * cnts[i];
f[i][0] = Math.max(f[i - 1][1], f[i - 1][0]);
}
return Math.max(f[max][0], f[max][1]);
}
}
```
* 时间复杂度:遍历 $nums$ 进行计数和取最大值 $max$,复杂度为 $O(n)$;共有 $max * 2$ 个状态需要被转移,每个状态转移的复杂度为 $O(1)$。整体复杂度为 $O(n + max)$。
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.740` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/741. 摘樱桃（困难）.md | 741. 摘樱桃 | https://leetcode.cn/problems/cherry-pickup/solution/by-ac_oier-pz7i/ | 困难 | [
"线性 DP"
] | 一个$N \times N$ 的网格( `grid`) 代表了一块樱桃地,每个格子由以下三种数字的一种来表示:
* $0$ 表示这个格子是空的,所以你可以穿过它。
* $1$ 表示这个格子里装着一个樱桃,你可以摘到樱桃然后穿过它。
* $-1$ 表示这个格子里有荆棘,挡着你的路。
你的任务是在遵守下列规则的情况下,尽可能的摘到最多樱桃:
* 从位置 $(0, 0)$ 出发,最后到达 $(N-1, N-1)$ ,只能向下或向右走,并且只能穿越有效的格子(即只可以穿过值为 $0$ 或者 $1$ 的格子);
* 当到达 $(N-1, N-1)$ 后,你要继续走,直到返回到 $(0, 0)$ ,只能向上或向左走,并且只能穿越有效的格子;
* 当你经过一个格子且这个格子包含一个樱桃时,你将摘到樱桃并且这个格子会变成空的(值变为0);
* 如果在 $(0, 0)$ 和 $(N-1, N-1)$ 之间不存在一条可经过的路径,则没有任何一个樱桃能被摘到。
示例 1:
```
输入: grid =
[[0, 1, -1],
[1, 0, -1],
[1, 1, 1]]
输出: 5
解释:
玩家从(0,0)点出发,经过了向下走,向下走,向右走,向右走,到达了点(2, 2)。
在这趟单程中,总共摘到了4颗樱桃,矩阵变成了[[0,1,-1],[0,0,-1],[0,0,0]]。
接着,这名玩家向左走,向上走,向上走,向左走,返回了起始点,又摘到了1颗樱桃。
在旅程中,总共摘到了5颗樱桃,这是可以摘到的最大值了。
```
说明:
* `grid` 是一个 $N \times N$ 的二维数组,N的取值范围是 $1 <= N <= 50$
* 每一个 `grid[i][j]` 都是集合 `{-1, 0, 1}` 其中的一个数
* 可以保证起点 `grid[0][0]` 和终点 `grid[N-1][N-1]` 的值都不会是 $-1$ | ### 线性 DP
为了方便,我们令 `grid` 为 `g`,同时调整矩阵横纵坐标从 $1$ 开始。
原问题为先从左上角按照「只能往下 + 只能往右」的规则走到右下角,然后再按照「只能往上 + 只能往左」的规则走回左上角,途径的值为 $1$ 的格子得一分(只能得分一次,得分后置零),同时不能经过值为 $-1$ 的格子。
其中第二趟的规则等价于按照第一趟的规则从左上角到右下角再走一遍,再结合每个位置的只能得分一次,可以将原问题等价于:两个点从左上角开始同时走,最终都走到右下角的最大得分。
定义 $f[k][i1][i2]$ 为当前走了 $k$ 步(横纵坐标之和),且第一个点当前在第 $i1$ 行,第二点在第 $i2$ 行时的最大得分,最终答案为 $f[2n][n][n]$,同时有 $f[2][1][1] = g[0][0]$ 的起始状态。
由于两个点是同时走(都走了 $k$ 步),结合「只能往下 + 只能往右」的规则,可直接算得第一个点所在的列为 $j1 = k - i1$,第二点所在的列为 $j2 = k - i2$。
不失一般性考虑 $f[k][i1][i2]$ 该如何转移,两个点均有可能走行或走列,即有 $4$ 种前驱状态:$f[k - 1][i1 - 1][i2]$、$f[k - 1][i1 - 1][i2 - 1]$、$f[k - 1][i1][i2 - 1]$ 和 $f[k - 1][i1][i2]$,在四者中取最大值,同时当前位置 $(i1, j1)$ 和 $(i2, j2)$ 的得分需要被累加,假设两者得分别为 $A$ 和 $B$,若两个位置不重叠的话,可以同时累加,否则只能累加一次。
一些细节:为了防止从值为 $-1$ 的格子进行转移影响正确性,我们需要先将所有 $f[k][i1][i2]$ 初始化为负无穷。
代码:
```Java
class Solution {
static int N = 55, INF = Integer.MIN_VALUE;
static int[][][] f = new int[2 * N][N][N];
public int cherryPickup(int[][] g) {
int n = g.length;
for (int k = 0; k <= 2 * n; k++) {
for (int i1 = 0; i1 <= n; i1++) {
for (int i2 = 0; i2 <= n; i2++) {
f[k][i1][i2] = INF;
}
}
}
f[2][1][1] = g[0][0];
for (int k = 3; k <= 2 * n; k++) {
for (int i1 = 1; i1 <= n; i1++) {
for (int i2 = 1; i2 <= n; i2++) {
int j1 = k - i1, j2 = k - i2;
if (j1 <= 0 || j1 > n || j2 <= 0 || j2 > n) continue;
int A = g[i1 - 1][j1 - 1], B = g[i2 - 1][j2 - 1];
if (A == -1 || B == -1) continue;
int a = f[k - 1][i1 - 1][i2], b = f[k - 1][i1 - 1][i2 - 1], c = f[k - 1][i1][i2 - 1], d = f[k - 1][i1][i2];
int t = Math.max(Math.max(a, b), Math.max(c, d)) + A;
if (i1 != i2) t += B;
f[k][i1][i2] = t;
}
}
}
return f[2 * n][n][n] <= 0 ? 0 : f[2 * n][n][n];
}
}
```
* 时间复杂度:状态数量级为 $n^3$,每个状态转移复杂度为 $O(1)$。整体复杂度为 $O(n^3)$
* 空间复杂度:$O(n^3)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.741` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/743. 网络延迟时间（中等）.md | 743. 网络延迟时间 | https://leetcode-cn.com/problems/network-delay-time/solution/gong-shui-san-xie-yi-ti-wu-jie-wu-chong-oghpz/ | 中等 | [
"最短路",
"图",
"优先队列(堆)"
] | 有 $n$ 个网络节点,标记为 $1$ 到 $n$。
给你一个列表 times,表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi),其中 ui 是源节点,vi 是目标节点, wi 是一个信号从源节点传递到目标节点的时间。
现在,从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号?如果不能使所有节点收到信号,返回 -1 。
示例 1:
```
输入:times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出:2
```
示例 2:
```
输入:times = [[1,2,1]], n = 2, k = 1
输出:1
```
示例 3:
```
输入:times = [[1,2,1]], n = 2, k = 2
输出:-1
```
提示:
* $1 <= k <= n <= 100$
* $1 <= times.length <= 6000$
* $times[i].length == 3$
* $1 <= u_i, v_i <= n$
* $u_i != v_i$
* $0 <= w_i <= 100$
* 所有 $(u_i, v_i)$ 对都 互不相同(即,不含重复边) | ### 基本分析
**为了方便,我们约定 $n$ 为点数,$m$ 为边数。**
根据题意,首先 $n$ 的数据范围只有 $100$,$m$ 的数据范围为 $6000$,使用「邻接表」或「邻接矩阵」来存图都可以。
同时求的是「**从 $k$ 点出发,所有点都被访问到的最短时间**」,将问题转换一下其实就是求「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。
---
### 存图方式
在开始讲解最短路之前,我们先来学习三种「存图」方式。
#### 邻接矩阵
这是一种使用二维矩阵来进行存图的方式。
适用于边数较多的**稠密图**使用,当边数量接近点的数量的平方,即 $m \approx n^2$ 时,可定义为**稠密图**。
```Java
// 邻接矩阵数组:w[a][b] = c 代表从 a 到 b 有权重为 c 的边
int[][] w = new int[N][N];
// 加边操作
void add(int a, int b, int c) {
w[a][b] = c;
}
```
#### 邻接表
这也是一种在图论中十分常见的存图方式,与数组存储单链表的实现一致(头插法)。
这种存图方式又叫**链式前向星存图**。
适用于边数较少的**稀疏图**使用,当边数量接近点的数量,即 $m \approx n$ 时,可定义为**稀疏图**。
```Java
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
int idx;
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx;
w[idx] = c;
idx++;
}
```
首先 `idx` 是用来对边进行编号的,然后对存图用到的几个数组作简单解释:
* `he` 数组:存储是某个节点所对应的边的集合(链表)的头结点;
* `e` 数组:由于访问某一条边指向的节点;
* `ne` 数组:由于是以链表的形式进行存边,该数组就是用于找到下一条边;
* `w` 数组:用于记录某条边的权重为多少。
因此当我们想要遍历所有由 `a` 点发出的边时,可以使用如下方式:
```Java
for (int i = he[a]; i != -1; i = ne[i]) {
int b = e[i], c = w[i]; // 存在由 a 指向 b 的边,权重为 c
}
```
#### 类
这是一种最简单,但是相比上述两种存图方式,使用得较少的存图方式。
只有当我们需要确保某个操作复杂度严格为 $O(m)$ 时,才会考虑使用。
具体的,我们建立一个类来记录有向边信息:
```Java
class Edge {
// 代表从 a 到 b 有一条权重为 c 的边
int a, b, c;
Edge(int _a, int _b, int _c) {
a = _a; b = _b; c = _c;
}
}
```
通常我们会使用 List 存起所有的边对象,并在需要遍历所有边的时候,进行遍历:
```Java
List<Edge> es = new ArrayList<>();
...
for (Edge e : es) {
...
}
```
---
### Floyd(邻接矩阵)
根据「基本分析」,我们可以使用复杂度为 $O(n^3)$ 的「多源汇最短路」算法 Floyd 算法进行求解,同时使用「邻接矩阵」来进行存图。
此时计算量约为 $10^6$,可以过。
跑一遍 Floyd,可以得到「**从任意起点出发,到达任意起点的最短距离**」。然后从所有 $w[k][x]$ 中取 $max$ 即是「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。
代码:
```Java
class Solution {
int N = 110, M = 6010;
// 邻接矩阵数组:w[a][b] = c 代表从 a 到 b 有权重为 c 的边
int[][] w = new int[N][N];
int INF = 0x3f3f3f3f;
int n, k;
public int networkDelayTime(int[][] ts, int _n, int _k) {
n = _n; k = _k;
// 初始化邻接矩阵
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
w[i][j] = w[j][i] = i == j ? 0 : INF;
}
}
// 存图
for (int[] t : ts) {
int u = t[0], v = t[1], c = t[2];
w[u][v] = c;
}
// 最短路
floyd();
// 遍历答案
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = Math.max(ans, w[k][i]);
}
return ans >= INF / 2 ? -1 : ans;
}
void floyd() {
// floyd 基本流程为三层循环:
// 枚举中转点 - 枚举起点 - 枚举终点 - 松弛操作
for (int p = 1; p <= n; p++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
w[i][j] = Math.min(w[i][j], w[i][p] + w[p][j]);
}
}
}
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n^2)$
---
### 朴素 Dijkstra(邻接矩阵)
同理,我们可以使用复杂度为 $O(n^2)$ 的「单源最短路」算法朴素 Dijkstra 算法进行求解,同时使用「邻接矩阵」来进行存图。
根据题意,$k$ 点作为源点,跑一遍 Dijkstra 我们可以得到从源点 $k$ 到其他点 $x$ 的最短距离,再从所有最短路中取 $max$ 即是「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。
朴素 Dijkstra 复杂度为 $O(n^2)$,可以过。
代码:
```Java
class Solution {
int N = 110, M = 6010;
// 邻接矩阵数组:w[a][b] = c 代表从 a 到 b 有权重为 c 的边
int[][] w = new int[N][N];
// dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
int[] dist = new int[N];
// 记录哪些点已经被更新过
boolean[] vis = new boolean[N];
int INF = 0x3f3f3f3f;
int n, k;
public int networkDelayTime(int[][] ts, int _n, int _k) {
n = _n; k = _k;
// 初始化邻接矩阵
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
w[i][j] = w[j][i] = i == j ? 0 : INF;
}
}
// 存图
for (int[] t : ts) {
int u = t[0], v = t[1], c = t[2];
w[u][v] = c;
}
// 最短路
dijkstra();
// 遍历答案
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = Math.max(ans, dist[i]);
}
return ans > INF / 2 ? -1 : ans;
}
void dijkstra() {
// 起始先将所有的点标记为「未更新」和「距离为正无穷」
Arrays.fill(vis, false);
Arrays.fill(dist, INF);
// 只有起点最短距离为 0
dist[k] = 0;
// 迭代 n 次
for (int p = 1; p <= n; p++) {
// 每次找到「最短距离最小」且「未被更新」的点 t
int t = -1;
for (int i = 1; i <= n; i++) {
if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;
}
// 标记点 t 为已更新
vis[t] = true;
// 用点 t 的「最小距离」更新其他点
for (int i = 1; i <= n; i++) {
dist[i] = Math.min(dist[i], dist[t] + w[t][i]);
}
}
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 堆优化 Dijkstra(邻接表)
由于边数据范围不算大,我们还可以使用复杂度为 $O(m\log{n})$ 的堆优化 Dijkstra 算法进行求解。
堆优化 Dijkstra 算法与朴素 Dijkstra 都是「单源最短路」算法。
跑一遍堆优化 Dijkstra 算法求最短路,再从所有最短路中取 $max$ 即是「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。
此时算法复杂度为 $O(m\log{n})$,可以过。
代码:
```Java
class Solution {
int N = 110, M = 6010;
// 邻接表
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
// dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
int[] dist = new int[N];
// 记录哪些点已经被更新过
boolean[] vis = new boolean[N];
int n, k, idx;
int INF = 0x3f3f3f3f;
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx;
w[idx] = c;
idx++;
}
public int networkDelayTime(int[][] ts, int _n, int _k) {
n = _n; k = _k;
// 初始化链表头
Arrays.fill(he, -1);
// 存图
for (int[] t : ts) {
int u = t[0], v = t[1], c = t[2];
add(u, v, c);
}
// 最短路
dijkstra();
// 遍历答案
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = Math.max(ans, dist[i]);
}
return ans > INF / 2 ? -1 : ans;
}
void dijkstra() {
// 起始先将所有的点标记为「未更新」和「距离为正无穷」
Arrays.fill(vis, false);
Arrays.fill(dist, INF);
// 只有起点最短距离为 0
dist[k] = 0;
// 使用「优先队列」存储所有可用于更新的点
// 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);
q.add(new int[]{k, 0});
while (!q.isEmpty()) {
// 每次从「优先队列」中弹出
int[] poll = q.poll();
int id = poll[0], step = poll[1];
// 如果弹出的点被标记「已更新」,则跳过
if (vis[id]) continue;
// 标记该点「已更新」,并使用该点更新其他点的「最短距离」
vis[id] = true;
for (int i = he[id]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] > dist[id] + w[i]) {
dist[j] = dist[id] + w[i];
q.add(new int[]{j, dist[j]});
}
}
}
}
}
```
* 时间复杂度:$O(m\log{n} + n)$
* 空间复杂度:$O(m)$
---
### Bellman Ford(类 & 邻接表)
虽然题目规定了不存在「负权边」,但我们仍然可以使用可以在「负权图中求最短路」的 Bellman Ford 进行求解,该算法也是「单源最短路」算法,复杂度为 $O(n * m)$。
通常为了确保 $O(n * m)$,可以单独建一个类代表边,将所有边存入集合中,在 $n$ 次松弛操作中直接对边集合进行遍历(代码见 $P1$)。
由于本题边的数量级大于点的数量级,因此也能够继续使用「邻接表」的方式进行边的遍历,遍历所有边的复杂度的下界为 $O(n)$,上界可以确保不超过 $O(m)$(代码见 $P2$)。
代码:
```Java
class Solution {
class Edge {
int a, b, c;
Edge(int _a, int _b, int _c) {
a = _a; b = _b; c = _c;
}
}
int N = 110, M = 6010;
// dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
int[] dist = new int[N];
int INF = 0x3f3f3f3f;
int n, m, k;
// 使用类进行存边
List<Edge> es = new ArrayList<>();
public int networkDelayTime(int[][] ts, int _n, int _k) {
n = _n; k = _k;
m = ts.length;
// 存图
for (int[] t : ts) {
int u = t[0], v = t[1], c = t[2];
es.add(new Edge(u, v, c));
}
// 最短路
bf();
// 遍历答案
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = Math.max(ans, dist[i]);
}
return ans > INF / 2 ? -1 : ans;
}
void bf() {
// 起始先将所有的点标记为「距离为正无穷」
Arrays.fill(dist, INF);
// 只有起点最短距离为 0
dist[k] = 0;
// 迭代 n 次
for (int p = 1; p <= n; p++) {
int[] prev = dist.clone();
// 每次都使用上一次迭代的结果,执行松弛操作
for (Edge e : es) {
int a = e.a, b = e.b, c = e.c;
dist[b] = Math.min(dist[b], prev[a] + c);
}
}
}
}
```
```Java
class Solution {
int N = 110, M = 6010;
// 邻接表
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
// dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
int[] dist = new int[N];
int INF = 0x3f3f3f3f;
int n, m, k, idx;
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx;
w[idx] = c;
idx++;
}
public int networkDelayTime(int[][] ts, int _n, int _k) {
n = _n; k = _k;
m = ts.length;
// 初始化链表头
Arrays.fill(he, -1);
// 存图
for (int[] t : ts) {
int u = t[0], v = t[1], c = t[2];
add(u, v, c);
}
// 最短路
bf();
// 遍历答案
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = Math.max(ans, dist[i]);
}
return ans > INF / 2 ? -1 : ans;
}
void bf() {
// 起始先将所有的点标记为「距离为正无穷」
Arrays.fill(dist, INF);
// 只有起点最短距离为 0
dist[k] = 0;
// 迭代 n 次
for (int p = 1; p <= n; p++) {
int[] prev = dist.clone();
// 每次都使用上一次迭代的结果,执行松弛操作
for (int a = 1; a <= n; a++) {
for (int i = he[a]; i != -1; i = ne[i]) {
int b = e[i];
dist[b] = Math.min(dist[b], prev[a] + w[i]);
}
}
}
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(m)$
---
### SPFA(邻接表)
SPFA 是对 Bellman Ford 的优化实现,可以使用队列进行优化,也可以使用栈进行优化。
通常情况下复杂度为 $O(k*m)$,$k$ 一般为 $4$ 到 $5$,最坏情况下仍为 $O(n * m)$,当数据为网格图时,复杂度会从 $O(k*m)$ 退化为 $O(n*m)$。
代码:
```Java
class Solution {
int N = 110, M = 6010;
// 邻接表
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
// dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
int[] dist = new int[N];
// 记录哪一个点「已在队列」中
boolean[] vis = new boolean[N];
int INF = 0x3f3f3f3f;
int n, k, idx;
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx;
w[idx] = c;
idx++;
}
public int networkDelayTime(int[][] ts, int _n, int _k) {
n = _n; k = _k;
// 初始化链表头
Arrays.fill(he, -1);
// 存图
for (int[] t : ts) {
int u = t[0], v = t[1], c = t[2];
add(u, v, c);
}
// 最短路
spfa();
// 遍历答案
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = Math.max(ans, dist[i]);
}
return ans > INF / 2 ? -1 : ans;
}
void spfa() {
// 起始先将所有的点标记为「未入队」和「距离为正无穷」
Arrays.fill(vis, false);
Arrays.fill(dist, INF);
// 只有起点最短距离为 0
dist[k] = 0;
// 使用「双端队列」存储,存储的是点编号
Deque<Integer> d = new ArrayDeque<>();
// 将「源点/起点」进行入队,并标记「已入队」
d.addLast(k);
vis[k] = true;
while (!d.isEmpty()) {
// 每次从「双端队列」中取出,并标记「未入队」
int poll = d.pollFirst();
vis[poll] = false;
// 尝试使用该点,更新其他点的最短距离
// 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」
for (int i = he[poll]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] > dist[poll] + w[i]) {
dist[j] = dist[poll] + w[i];
if (vis[j]) continue;
d.addLast(j);
vis[j] = true;
}
}
}
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.743` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/744. 寻找比目标字母大的最小字母（简单）.md | 744. 寻找比目标字母大的最小字母 | https://leetcode-cn.com/problems/find-smallest-letter-greater-than-target/solution/by-ac_oier-to07/ | 简单 | [
"二分"
] | 给你一个排序后的字符列表 `letters`,列表中只包含小写英文字母。另给出一个目标字母 `target`,请你寻找在这一有序列表里比目标字母大的最小字母。
在比较时,字母是依序循环出现的。举个例子:
如果目标字母 `target = 'z'` 并且字符列表为 `letters = ['a', 'b']`,则答案返回 `'a'`
示例 1:
```
输入: letters = ["c", "f", "j"],target = "a"
输出: "c"
```
示例 2:
```
输入: letters = ["c","f","j"], target = "c"
输出: "f"
```
示例 3:
```
输入: letters = ["c","f","j"], target = "d"
输出: "f"
```
提示:
* $2 <= letters.length <= 10^4$
* $letters[i]$ 是一个小写字母
* $letters$ 按非递减顺序排序
* $letters$ 最少包含两个不同的字母
* $target$ 是一个小写字母 | ### 二分
给定的数组「有序」,找到比 $target$ 大的最小字母,容易想到二分。
唯一需要注意的是,二分结束后需要再次 `check`,如果不满足,则取数组首位元素。
代码:
```Java
class Solution {
public char nextGreatestLetter(char[] letters, char target) {
int n = letters.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (letters[mid] > target) r = mid;
else l = mid + 1;
}
return letters[r] > target ? letters[r] : letters[0];
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.744` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/745. 前缀和后缀搜索（困难）.md | 745. 前缀和后缀搜索 | https://leetcode.cn/problems/prefix-and-suffix-search/solution/by-ac_oier-ayej/ | 困难 | [
"字典树"
] | 设计一个包含一些单词的特殊词典,并能够通过前缀和后缀来检索单词。
实现 `WordFilter` 类:
* `WordFilter(string[] words)` 使用词典中的单词 `words` 初始化对象。
* `f(string pref, string suff)` 返回词典中具有前缀 `prefix` 和后缀 `suff` 的单词的下标。如果存在不止一个满足要求的下标,返回其中 最大的下标 。如果不存在这样的单词,返回 $-1$ 。
示例:
```
输入
["WordFilter", "f"]
[[["apple"]], ["a", "e"]]
输出
[null, 0]
解释
WordFilter wordFilter = new WordFilter(["apple"]);
wordFilter.f("a", "e"); // 返回 0 ,因为下标为 0 的单词:前缀 prefix = "a" 且 后缀 suff = "e" 。
```
提示:
* $1 <= words.length <= 10^4$
* $1 <= words[i].length <= 7$
* $1 <= pref.length, suff.length <= 7$
* `words[i]`、`pref` 和 `suff` 仅由小写英文字母组成
* 最多对函数 `f` 执行 $10^4$ 次调用 | ### 基本分析
为了方便,我们令 `words` 为 `ss`,令 `pref` 和 `suff` 分别为 `a` 和 `b`。
搜索某个前缀(后缀可看做是反方向的前缀)容易想到字典树,但单词长度数据范围只有 $7$,十分具有迷惑性,使用暴力做法最坏情况下会扫描所有的 $ss[i]$,不考虑任何的剪枝操作的话,计算量也才为 $2 \times \ 7 \times 1e4 = 1.4 \times 10^5$,按道理是完全可以过的。
但不要忘记 LC 是一个具有「设定每个样例时长,同时又有总时长」这样奇怪机制的 OJ。
---
### 暴力(TLE or 双百)
于是有了 `Java` 总时间超时,`TypeScripe` 双百的结果(应该是 `TypeScript` 提交不多,同时设限宽松的原因):
Java 代码:
```Java
class WordFilter {
String[] ss;
public WordFilter(String[] words) {
ss = words;
}
public int f(String a, String b) {
int n = a.length(), m = b.length();
for (int k = ss.length - 1; k >= 0; k--) {
String cur = ss[k];
int len = cur.length();
if (len < n || len < m) continue;
boolean ok = true;
for (int i = 0; i < n && ok; i++) {
if (cur.charAt(i) != a.charAt(i)) ok = false;
}
for (int i = 0; i < m && ok; i++) {
if (cur.charAt(len - 1 - i) != b.charAt(m - 1 - i)) ok = false;
}
if (ok) return k;
}
return -1;
}
}
```
TypeScript 代码:
```TypeScript
class WordFilter {
ss: string[]
constructor(words: string[]) {
this.ss = words
}
f(a: string, b: string): number {
const n = a.length, m = b.length
for (let k = this.ss.length - 1; k >= 0; k--) {
const cur = this.ss[k]
const len = cur.length
if (len < n || len < m) continue
let ok = true
for (let i = 0; i < n && ok; i++) {
if (cur[i] != a[i]) ok = false
}
for (let i = m - 1; i >= 0; i--) {
if (cur[len - 1 - i] != b[m - 1 - i]) ok = false
}
if (ok) return k
}
return -1
}
}
```
* 时间复杂度:初始化操作复杂度为 $O(1)$,检索操作复杂度为 $O(\sum_{i = 0}^{n - 1} ss[i].length)$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1} ss[i].length)$
---
### Trie
使用字典树优化检索过程也是容易的,分别使用两棵 `Trie` 树来记录 $ss[i]$ 的前后缀,即正着存到 `tr1` 中,反着存到 `Tr2` 中。
> 还不了解 `Trie` 的同学可以先看前置 🧀:[【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)
前置 🧀 通过图解形式讲解了 `Trie` 的结构与原理,以及提供了两种实现 `Trie` 的方式
同时对于字典树的每个节点,我们使用数组 `idxs` 记录经过该节点的字符串 $ss[i]$ 所在 `ss` 中的下标 $i$,若某个字典树节点的索引数组 `tr.idxs` 为 $[a_1, a_2, ..., a_k]$ 则代表「从根节点到 `tr` 节点所对应的字符串」为 $ss[a_1], ss[a_2], ..., ss[a_k]$ 的前缀。
这样我们可以即可在扫描前后缀 `a` 和 `b` 时,得到对应的候选下标列表 `l1` 和 `l2`,由于我们将 $ss[i]$ 添加到两棵 `tr` 中是按照下标「从小到大」进行,因此我们使用「双指针」算法分别从 `l1` 和 `l2` 结尾往后找到第一个共同元素即是答案(满足条件的最大下标)。
> 使用 `Trie` 优化后,`Java` 从 `TLE` 到 `AC`,`TypeScript` 耗时为原本的 $\frac{1}{7}$ :
Java 代码:
```Java
class WordFilter {
class TrieNode {
TrieNode[] tns = new TrieNode[26];
List<Integer> idxs = new ArrayList<>();
}
void add(TrieNode p, String s, int idx, boolean isTurn) {
int n = s.length();
p.idxs.add(idx);
for (int i = isTurn ? n - 1 : 0; i >= 0 && i < n; i += isTurn ? -1 : 1) {
int u = s.charAt(i) - 'a';
if (p.tns[u] == null) p.tns[u] = new TrieNode();
p = p.tns[u];
p.idxs.add(idx);
}
}
int query(String a, String b) {
int n = a.length(), m = b.length();
TrieNode p = tr1;
for (int i = 0; i < n; i++) {
int u = a.charAt(i) - 'a';
if (p.tns[u] == null) return -1;
p = p.tns[u];
}
List<Integer> l1 = p.idxs;
p = tr2;
for (int i = m - 1; i >= 0; i--) {
int u = b.charAt(i) - 'a';
if (p.tns[u] == null) return -1;
p = p.tns[u];
}
List<Integer> l2 = p.idxs;
n = l1.size(); m = l2.size();
for (int i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {
if (l1.get(i) > l2.get(j)) i--;
else if (l1.get(i) < l2.get(j)) j--;
else return l1.get(i);
}
return -1;
}
TrieNode tr1 = new TrieNode(), tr2 = new TrieNode();
public WordFilter(String[] ss) {
int n = ss.length;
for (int i = 0; i < n; i++) {
add(tr1, ss[i], i, false);
add(tr2, ss[i], i, true);
}
}
public int f(String a, String b) {
return query(a, b);
}
}
```
TypeScript 代码:
```TypeScript
class TrieNode {
tns: TrieNode[] = new Array<TrieNode>()
idxs: number[] = new Array<number>()
}
class WordFilter {
add(p: TrieNode, s: string, idx: number, isTurn: boolean): void {
const n = s.length
p.idxs.push(idx)
for (let i = isTurn ? n - 1 : 0; i >= 0 && i < n; i += isTurn ? -1 : 1) {
const u = s.charCodeAt(i) - 'a'.charCodeAt(0)
if (p.tns[u] == null) p.tns[u] = new TrieNode()
p = p.tns[u]
p.idxs.push(idx)
}
}
query(a: string, b: string): number {
let n = a.length, m = b.length
let p = this.tr1
for (let i = 0; i < n; i++) {
const u = a.charCodeAt(i) - 'a'.charCodeAt(0)
if (p.tns[u] == null) return -1
p = p.tns[u]
}
const l1 = p.idxs
p = this.tr2
for (let i = m - 1; i >= 0; i--) {
const u = b.charCodeAt(i) - 'a'.charCodeAt(0)
if (p.tns[u] == null) return -1
p = p.tns[u]
}
const l2 = p.idxs
n = l1.length; m = l2.length
for (let i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {
if (l1[i] < l2[j]) j--
else if (l1[i] > l2[j]) i--
else return l1[i]
}
return -1
}
tr1: TrieNode = new TrieNode()
tr2: TrieNode = new TrieNode()
constructor(ss: string[]) {
for (let i = 0; i < ss.length; i++) {
this.add(this.tr1, ss[i], i, false)
this.add(this.tr2, ss[i], i, true)
}
}
f(a: string, b: string): number {
return this.query(a, b)
}
}
```
C++ 代码:
```C++
class WordFilter {
public:
struct TrieNode {
TrieNode* tns[26] {nullptr};
vector<int> idxs;
};
void add(TrieNode* p, const string& s, int idx, bool isTurn) {
int n = s.size();
p->idxs.push_back(idx);
for(int i = isTurn ? n - 1 : 0; i >= 0 && i < n; i += isTurn ? -1 : 1) {
int u = s[i] - 'a';
if(p->tns[u] == nullptr) p->tns[u] = new TrieNode();
p = p->tns[u];
p->idxs.push_back(idx);
}
}
int query(const string& a, const string& b) {
int n = a.size(), m = b.size();
auto p = tr1;
for(int i = 0; i < n; i++) {
int u = a[i] - 'a';
if(p->tns[u] == nullptr) return -1;
p = p->tns[u];
}
vector<int>& l1 = p->idxs;
p = tr2;
for(int i = m - 1; i >= 0; i--) {
int u = b[i] - 'a';
if(p->tns[u] == nullptr) return -1;
p = p->tns[u];
}
vector<int>& l2 = p->idxs;
n = l1.size(), m = l2.size();
for(int i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {
if(l1[i] > l2[j]) i--;
else if(l1[i] < l2[j]) j--;
else return l1[i];
}
return -1;
}
TrieNode* tr1 = new TrieNode, *tr2 = new TrieNode;
WordFilter(vector<string>& ss) {
int n = ss.size();
for(int i = 0; i < n; i++) {
add(tr1, ss[i], i, false);
add(tr2, ss[i], i, true);
}
}
int f(string a, string b) {
return query(a, b);
}
};
```
* 时间复杂度:初始化操作复杂度为 $O(\sum_{i = 0}^{n - 1} ss[i].length)$,检索过程复杂度为 $O(a + b + n)$,其中 $a = b = 7$ 为前后缀的最大长度,$n = 1e4$ 为初始化数组长度,代表最多有 $n$ 个候选下标(注意:这里的 $n$ 只是粗略分析,实际上如果候选集长度越大的话,说明两个候选集是重合度是越高的,从后往前找的过程是越快结束的,可以通过方程算出一个双指针的理论最大比较次数 $k$,如果要将 $n$ 卡满成 $1e4$ 的话,需要将两个候选集设计成交替下标,此时 `f` 如果仍是 $1e4$ 次调用的话,必然会面临大量的重复查询,可通过引入 `map` 记录查询次数来进行优化)
* 空间复杂度:$O(\sum_{i = 0}^{n - 1} ss[i].length)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.745` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/747. 至少是其他数字两倍的最大数（简单）.md | 747. 至少是其他数字两倍的最大数 | https://leetcode-cn.com/problems/largest-number-at-least-twice-of-others/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-8179/ | 简单 | [
"模拟"
] | 给你一个整数数组 $nums$ ,其中总是存在 **唯一的** 一个最大整数 。
请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。
如果是,则返回 **最大元素的下标** ,否则返回 $-1$ 。
示例 1:
```
输入:nums = [3,6,1,0]
输出:1
解释:6 是最大的整数,对于数组中的其他整数,6 大于数组中其他元素的两倍。6 的下标是 1 ,所以返回 1 。
```
示例 2:
```
输入:nums = [1,2,3,4]
输出:-1
解释:4 没有超过 3 的两倍大,所以返回 -1 。
```
示例 3:
```
输入:nums = [1]
输出:0
解释:因为不存在其他数字,所以认为现有数字 1 至少是其他数字的两倍。
```
提示:
* $1 <= nums.length <= 50$
* $0 <= nums[i] <= 100$
* $nums$ 中的最大元素是唯一的 | ### 模拟
根据题意进行模拟即可,遍历过程中维护最大值和次大值的下标,最后判断最大值是否至少为次大值两倍。
然后?今天属于圆梦了?(这真的只是他们的日常可爱 🤣
**代码(感谢 [@5cm/s 🌸](/u/megurine/)、[@Benhao](/u/himymben/) 和 [@Qian](/u/qian2/) 几位总提供的其他语言版本 🤣 🤣 ):**
```Java
class Solution {
public int dominantIndex(int[] nums) {
int n = nums.length;
if (n == 1) return 0;
int a = -1, b = 0;
for (int i = 1; i < n; i++) {
if (nums[i] > nums[b]) {
a = b; b = i;
} else if (a == -1 || nums[i] > nums[a]) {
a = i;
}
}
return nums[b] >= nums[a] * 2 ? b : -1;
}
}
```
-
```Python
class Solution(object):
def dominantIndex(self, nums):
n = len(nums)
if n == 1:
return 0
a, b = -1, 0
for i in range(1, n):
if nums[i] > nums[b]:
a, b = b, i
elif a == -1 or nums[i] > nums[a]:
a = i
return b if nums[b] >= nums[a] * 2 else -1
```
-
```Python
class Solution:
def dominantIndex(self, nums: List[int]) -> int:
n = len(nums)
if n == 1:
return 0
a, b = -1, 0
for i in range(1, n):
if nums[i] > nums[b]:
a, b = b, i
elif a == -1 or nums[i] > nums[a]:
a = i
return b if nums[b] >= nums[a] * 2 else -1
```
-
```Go
func dominantIndex(nums []int) int {
n := len(nums)
if n == 1{
return 0
}
a, b := -1, 0
for i := 1; i < n; i++ {
if nums[i] > nums[b] {
a, b = b, i
} else if a == -1 || nums[i] > nums[a] {
a = i
}
}
if nums[b] >= nums[a] * 2{
return b
}
return -1
}
```
-
```Rust
impl Solution {
pub fn dominant_index(nums: Vec<i32>) -> i32 {
let mut mx = 0;
let mut ans = -1 as i32;
for i in 0..nums.len() {
if nums[i] >= mx * 2 {
ans = i as i32;
}
else if nums[i] * 2 > mx {
ans = -1 as i32;
}
if nums[i] > mx {
mx = nums[i];
}
}
ans
}
}
```
-
```C
int dominantIndex(int* nums, int numsSize){
if(numsSize == 1) return 0;
int a = -1, b = 0;
for(int i = 1; i < numsSize; i++){
if (nums[i] > nums[b]) {
a = b; b = i;
} else if (a == -1 || nums[i] > nums[a]) {
a = i;
}
}
return nums[b] >= nums[a] * 2 ? b : -1;
}
```
-
```C#
public class Solution {
public int DominantIndex(int[] nums) {
int n = nums.Length;
if (n == 1) return 0;
int a = -1, b = 0;
for (int i = 1; i < n; i++) {
if (nums[i] > nums[b]) {
a = b; b = i;
} else if (a == -1 || nums[i] > nums[a]) {
a = i;
}
}
return nums[b] >= nums[a] * 2 ? b : -1;
}
}
```
-
```C++
class Solution {
public:
int dominantIndex(vector<int>& nums) {
int mx = 0, ans = -1;
for (int i = 0; i < nums.size(); ++i) {
if (nums[i] >= mx * 2) ans = i;
else if (nums[i] * 2 > mx) ans = -1;
mx = max(nums[i], mx);
}
return ans;
}
};
```
-
```JS
var dominantIndex = function(nums) {
const n = nums.length
if(n == 1) return 0
let a = -1, b = 0
for (let i = 1; i < n; i++){
if (nums[i] > nums[b]) {
a = b; b = i;
} else if (a == -1 || nums[i] > nums[a]) {
a = i;
}
}
return nums[b] >= nums[a] * 2 ? b : -1;
};
```
-
```TS
function dominantIndex(nums: number[]): number {
const n = nums.length
if(n == 1) return 0
let a = -1, b = 0
for (let i = 1; i < n; i++){
if (nums[i] > nums[b]) {
a = b; b = i;
} else if (a == -1 || nums[i] > nums[a]) {
a = i;
}
}
return nums[b] >= nums[a] * 2 ? b : -1;
};
```
-
```PHP
class Solution {
function dominantIndex($nums) {
$n = sizeof($nums);
if ($n == 1) return 0;
$a = -1; $b = 0;
for ($i = 1; $i < $n; $i++) {
if ($nums[$i] > $nums[$b]) {
$a = $b;
$b = $i;
} else if ($a == -1 || $nums[$i] > $nums[$a]) {
$a = $i;
}
}
if($nums[$b] >= $nums[$a] * 2){
return $b;
}
return -1;
}
}
```
-
```Swift
class Solution {
func dominantIndex(_ nums: [Int]) -> Int {
var n = nums.count
if n == 1 {
return 0
}
var (a, b) = (-1, 0)
for i in 1..<nums.count {
if nums[i] > nums[b] {
(a, b) = (b, i)
}
else if a == -1 || nums[i] > nums[a] {
a = i
}
}
return nums[b] >= nums[a] * 2 ? b : -1
}
}
```
-
```Kotlin
class Solution {
fun dominantIndex(nums: IntArray): Int {
var mx = 0
var ans = -1
for (i in nums.indices) {
when {
nums[i] >= mx * 2 -> ans = i
nums[i] * 2 > mx -> ans = -1
}
if (nums[i] > mx) mx = nums[i]
}
return ans
}
}
```
-
```Scala
object Solution {
def dominantIndex(nums: Array[Int]): Int = {
var mx = 0
var ans = -1
for (i <- 0 to (nums.length - 1)) {
if (nums(i) >= mx * 2) ans = i
else if (nums(i) * 2 > mx) ans = -1
if (nums(i) > mx) mx = nums(i)
}
return ans
}
}
```
-
```Ruby
def dominant_index(nums)
n = nums.length
return 0 if n == 1
a = -1
b = 0
nums.each_with_index do |num, i|
next if i == 0
if nums[i] > nums[b]
a = b
b = i
elsif a.eql?(-1) or nums[i] > nums[a]
a = i
end
end
return nums[b] >= nums[a] * 2 ? b : -1
end
```
-
```lisp
(define/contract (dominant-index nums)
(-> (listof exact-integer?) exact-integer?)
(let loop ([nums nums] [i 0] [mx 0] [ans -1])
(cond
[(empty? nums) ans]
[else
(define x (car nums))
(define mxx (max x mx))
(cond
[(>= x (* mx 2)) (loop (cdr nums) (+ i 1) mxx i)]
[(> (* x 2) mx) (loop (cdr nums) (+ i 1) mxx -1)]
[else (loop (cdr nums) (+ i 1) mxx ans)]
)
]
)
)
)
```
-
```Elixir
defmodule Solution do
@spec dominant_index(nums :: [integer]) :: integer
def dominant_index(nums) do
solve(nums, 0, -1, 0)
end
def solve([], mx, ans, cur) do
ans
end
def solve([x | rest], mx, ans, cur) when x >= mx * 2 do
solve(rest, max(x, mx), cur, cur + 1)
end
def solve([x | rest], mx, ans, cur) when x * 2 > mx do
solve(rest, max(x, mx), -1, cur + 1)
end
def solve([x | rest], mx, ans, cur) do
solve(rest, max(x, mx), ans, cur + 1)
end
end
```
-
```Erlang
-spec dominant_index(Nums :: [integer()]) -> integer().
dominant_index(Nums) ->
solve(Nums).
solve(List) ->
solve(List, 0, -1, 0).
solve([], Max, Ans, Cur) ->
Ans;
solve([Head|Rest], Max, Ans, Cur) when Head >= Max * 2 ->
solve(Rest, max(Max, Head), Cur, Cur + 1);
solve([Head|Rest], Max, Ans, Cur) when Head * 2 > Max ->
solve(Rest, max(Max, Head), -1, Cur + 1);
solve([Head|Rest], Max, Ans, Cur) ->
solve(Rest, max(Max, Head), Ans, Cur + 1).
max(A, B) when A > B ->
A;
max(A, B) ->
B.
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 全鱼宴(是全语言 这错别字还挺可爱 🤣
经过三位总 [@5cm/s 🌸](/u/megurine/)、[@Benhao](/u/himymben/) 和 [@Qian](/u/qian2/) 的不懈努力,通过举一反三、连蒙带猜,把所有语言弄出了 🤣
这个过程中也有幸见到,如果一个语言只有一份代码,居然界面是这样的(没有时间和内存的分布图:
我和我的小伙伴纷纷表示这样的 Flag 再也不敢了 🤣 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.747` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/748. 最短补全词（简单）.md | 748. 最短补全词 | https://leetcode-cn.com/problems/shortest-completing-word/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-j-x4ao/ | 简单 | [
"模拟"
] | 给你一个字符串 $licensePlate$ 和一个字符串数组 $words$ ,请你找出并返回 $words$ 中的 最短补全词 。
补全词 是一个包含 $licensePlate$ 中所有的字母的单词。在所有补全词中,最短的那个就是 最短补全词 。
在匹配 $licensePlate$ 中的字母时:
* 忽略 $licensePlate$ 中的 数字和空格 。
* 不区分大小写。
* 如果某个字母在 $licensePlate$ 中出现不止一次,那么该字母在补全词中的出现次数应当一致或者更多。
例如:`licensePlate = "aBc 12c"`,那么它的补全词应当包含字母 `'a'`、`'b'` (忽略大写)和两个 `'c'` 。可能的 补全词 有 `"abccdef"`、`"caaacab"` 以及 `"cbca"`。
请你找出并返回 $words$ 中的 最短补全词 。题目数据保证一定存在一个最短补全词。当有多个单词都符合最短补全词的匹配条件时取 $words$ 中 最靠前的 那个。
示例 1:
```
输入:licensePlate = "1s3 PSt", words = ["step", "steps", "stripe", "stepple"]
输出:"steps"
解释:最短补全词应该包括 "s"、"p"、"s"(忽略大小写) 以及 "t"。
"step" 包含 "t"、"p",但只包含一个 "s",所以它不符合条件。
"steps" 包含 "t"、"p" 和两个 "s"。
"stripe" 缺一个 "s"。
"stepple" 缺一个 "s"。
因此,"steps" 是唯一一个包含所有字母的单词,也是本例的答案。
```
示例 2:
```
输入:licensePlate = "1s3 456", words = ["looks", "pest", "stew", "show"]
输出:"pest"
解释:licensePlate 只包含字母 "s" 。所有的单词都包含字母 "s" ,其中 "pest"、"stew"、和 "show" 三者最短。答案是 "pest" ,因为它是三个单词中在 words 里最靠前的那个。
```
示例 3:
```
输入:licensePlate = "Ah71752", words = ["suggest","letter","of","husband","easy","education","drug","prevent","writer","old"]
输出:"husband"
```
示例 4:
```
输入:licensePlate = "OgEu755", words = ["enough","these","play","wide","wonder","box","arrive","money","tax","thus"]
输出:"enough"
```
示例 5:
```
输入:licensePlate = "iMSlpe4", words = ["claim","consumer","student","camera","public","never","wonder","simple","thought","use"]
输出:"simple"
```
提示:
* $1 <= licensePlate.length <= 7$
* $licensePlate$ 由数字、大小写字母或空格 ' ' 组成
* $1 <= words.length <= 1000$
* $1 <= words[i].length <= 15$
* $words[i]$ 由小写英文字母组成 | ### 模拟
根据题意,先对 $licensePlate$ 进行词频统计(忽略空格和数字),然后遍历 $words$ 进行词频统计,从所有符合要求的 $words[i]$ 找到最短的补全词。
代码:
```Java
class Solution {
public String shortestCompletingWord(String licensePlate, String[] words) {
int[] cnt = getCnt(licensePlate);
String ans = null;
for (String s : words) {
int[] cur = getCnt(s);
boolean ok = true;
for (int i = 0; i < 26 && ok; i++) {
if (cnt[i] > cur[i]) ok = false;
}
if (ok && (ans == null || ans.length() > s.length())) ans = s;
}
return ans;
}
int[] getCnt(String s) {
int[] cnt = new int[26];
for (char c : s.toCharArray()) {
if (Character.isLetter(c)) cnt[Character.toLowerCase(c) - 'a']++;
}
return cnt;
}
}
```
* 时间复杂度:令 $n$ 为字符串 $licensePlate$ 的长度,$m$ 为数组 $words$ 的长度,$L$ 为所有 $words[i]$ 的长度总和,字符集大小为 $C = 26$。整体复杂度为 $O(n + \sum_{i = 0}^{m - 1}{(C + words[i].length)})$
* 空间复杂度:偷懒使用 `toCharArray` 的话,复杂度和时间复杂度一样;仅使用 `charAt` 的话复杂度为 $O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.748` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/741-750/749. 隔离病毒（困难）.md | 749. 隔离病毒 | https://leetcode.cn/problems/contain-virus/solution/by-ac_oier-l9ya/ | 困难 | [
"模拟",
"图论搜索",
"BFS"
] | 病毒扩散得很快,现在你的任务是尽可能地通过安装防火墙来隔离病毒。
假设世界由 $m \times n$ 的二维矩阵 `isInfected` 组成,`isInfected[i][j] == 0` 表示该区域未感染病毒,而 `isInfected[i][j] == 1` 表示该区域已感染病毒。可以在任意 $2$ 个相邻单元之间的共享边界上安装一个防火墙(并且只有一个防火墙)。
每天晚上,病毒会从被感染区域向相邻未感染区域扩散,除非被防火墙隔离。现由于资源有限,每天你只能安装一系列防火墙来隔离其中一个被病毒感染的区域(一个区域或连续的一片区域),且该感染区域对未感染区域的威胁最大且 保证唯一 。
你需要努力使得最后有部分区域不被病毒感染,如果可以成功,那么返回需要使用的防火墙个数; 如果无法实现,则返回在世界被病毒全部感染时已安装的防火墙个数。
示例 1:
```
输入: isInfected = [[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,1],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]
输出: 10
解释:一共有两块被病毒感染的区域。
在第一天,添加 5 墙隔离病毒区域的左侧。病毒传播后的状态是:
第二天,在右侧添加 5 个墙来隔离病毒区域。此时病毒已经被完全控制住了。
```
示例 2:
```
输入: isInfected = [[1,1,1],[1,0,1],[1,1,1]]
输出: 4
解释: 虽然只保存了一个小区域,但却有四面墙。
注意,防火墙只建立在两个不同区域的共享边界上。
```
示例 3:
```
输入: isInfected = [[1,1,1,0,0,0,0,0,0],[1,0,1,0,1,1,1,1,1],[1,1,1,0,0,0,0,0,0]]
输出: 13
解释: 在隔离右边感染区域后,隔离左边病毒区域只需要 2 个防火墙。
```
提示:
* $m == isInfected.length$
* $n == isInfected[i].length$
* $1 <= m, n <= 50$
* `isInfected[i][j]` is either `0` or `1`
* 在整个描述的过程中,总有一个相邻的病毒区域,它将在下一轮 严格地感染更多未受污染的方块 | ### 搜索模拟
根据题意,我们可以按天进行模拟,设计函数 `getCnt` 用于返回当天会被安装的防火墙数量,在 `getCnt` 内部我们会进行如下操作:
* 找出当天「对未感染区域的威胁最大」的区域,并将该区域进行隔离(将 $1$ 设置为 $-1$);
* 对其他区域,进行步长为 $1$ 的感染操作。
考虑如何实现 `getCnt`:我们需要以「连通块」为单位进行处理,因此每次的 `getCnt` 操作,我们先重建一个与矩阵等大的判重数组 `vis`,对于每个 $g[i][j] = 1$ 且未被 $vis[i][j]$ 标记为 `True` 的位置进行搜索,搜索过程使用 `BFS` 实现。
**在 `BFS` 过程中,我们除了统计该连通块所需要的防火墙数量 $b$ 以外,还需要额外记录当前连通块中 $1$ 的点集 `s1`(简称为原集,含义为连通块的格子集合),以及当前连通块相邻的 $0$ 的点集 `s2`(简称为扩充集,含义为将要被感染的格子集合)。**
根据题意,在单次的 `getCnt` 中,我们需要在所有连通块中取出其 `s2` 大小最大(对未感染区域的威胁最大)的连通块进行隔离操作,而其余连通块则进行扩充操作。
因此我们可以使用两个变量 `max` 和 `ans` 分别记录所有 `s2` 中的最大值,以及取得最大 `s2` 所对应连通块所需要的防火墙数量,同时需要使用两个数组 `l1` 和 `l2` 分别记录每个连通块对应的「原集」和「扩充集」,方便我们后续进行「隔离」和「感染」。
Java 代码:
```Java
class Solution {
int[][] g;
int n, m, ans;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
boolean[][] vis;
int search(int _x, int _y, Set<Integer> s1, Set<Integer> s2) {
int ans = 0;
Deque<int[]> d = new ArrayDeque<>();
vis[_x][_y] = true;
d.addLast(new int[]{_x, _y});
s1.add(_x * m + _y);
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int x = info[0], y = info[1];
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1], loc = nx * m + ny;
if (nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny]) continue;
if (g[nx][ny] == 1) {
s1.add(loc);
vis[nx][ny] = true;
d.addLast(new int[]{nx, ny});
} else if (g[nx][ny] == 0) {
s2.add(loc);
ans++;
}
}
}
return ans;
}
int getCnt() {
vis = new boolean[n][m];
int max = 0, ans = 0;
// l1: 每个连通块的点集 s2: 每个连通块的候选感染点集
List<Set<Integer>> l1 = new ArrayList<>(), l2 = new ArrayList<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] == 1 && !vis[i][j]) {
// s1: 当前连通块的点集 s2: 当前连通块的候选感染点集
Set<Integer> s1 = new HashSet<>(), s2 = new HashSet<>();
int b = search(i, j, s1, s2), a = s2.size();
if (a > max) {
max = a; ans = b;
}
l1.add(s1); l2.add(s2);
}
}
}
for (int i = 0; i < l2.size(); i++) {
for (int loc : l2.get(i).size() == max ? l1.get(i) : l2.get(i)) {
int x = loc / m, y = loc % m;
g[x][y] = l2.get(i).size() == max ? -1 : 1;
}
}
return ans;
}
public int containVirus(int[][] _g) {
g = _g;
n = g.length; m = g[0].length;
while (true) {
int cnt = getCnt();
if (cnt == 0) break;
ans += cnt;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
let g: number[][] = null
let n: number = 0, m: number = 0
let vis: boolean[][] = null
const dirs: number[][] = [[1,0],[-1,0],[0,1],[0,-1]]
function search(_x: number, _y: number, s1: Set<number>, s2: Set<number>): number {
let he = 0, ta = 0, ans = 0
let d: Array<number> = new Array<number>()
s1.add(_x * m + _y)
vis[_x][_y] = true
d[ta++] = _x * m + _y
while (he < ta) {
const poll = d[he++]
const x = Math.floor(poll / m), y = poll % m
for (const di of dirs) {
const nx = x + di[0], ny = y + di[1], loc = nx * m + ny
if (nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny]) continue
if (g[nx][ny] == 1) {
s1.add(loc)
vis[nx][ny] = true
d[ta++] = loc
} else if (g[nx][ny] == 0) {
s2.add(loc)
ans++
}
}
}
return ans
}
function getCnt(): number {
vis = new Array<Array<boolean>>(n)
for (let i = 0; i < n; i++) vis[i] = new Array<boolean>(m).fill(false)
let max = 0, ans = 0
let l1: Array<Set<number>> = new Array<Set<number>>(), l2: Array<Set<number>> = new Array<Set<number>>()
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (g[i][j] == 1 && !vis[i][j]) {
let s1 = new Set<number>(), s2 = new Set<number>()
const b = search(i, j, s1, s2), a = s2.size
if (a > max) {
max = a; ans = b
}
l1.push(s1); l2.push(s2)
}
}
}
for (let i = 0; i < l2.length; i++) {
for (let loc of l2[i].size == max ? l1[i] : l2[i]) {
const x = Math.floor(loc / m), y = loc % m
g[x][y] = l2[i].size == max ? -1 : 1
}
}
return ans
}
function containVirus(_g: number[][]): number {
g = _g
n = g.length; m = g[0].length
let ans: number = 0
while (true) {
const cnt = getCnt()
if (cnt == 0) break
ans += cnt
}
return ans
};
```
* 时间复杂度:最多有 $n + m$ 天需要模拟,每天模拟复杂度 $O(n \times m)$,整体复杂度为 $O((n + m) \times nm)$
* 空间复杂度:$O(nm)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.749` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/751-760/752. 打开转盘锁（中等）.md | 752. 打开转盘锁 | https://leetcode-cn.com/problems/open-the-lock/solution/gong-shui-san-xie-yi-ti-shuang-jie-shuan-wyr9/ | 中等 | [
"双向 BFS",
"启发式搜索",
"AStar 算法",
"IDAStar 算法"
] | 你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转:例如把 '9' 变为 '0','0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。
锁的初始数字为 '0000' ,一个代表四个拨轮的数字的字符串。
列表 deadends 包含了一组死亡数字,一旦拨轮的数字和列表里的任何一个元素相同,这个锁将会被永久锁定,无法再被旋转。
字符串 target 代表可以解锁的数字,你需要给出解锁需要的最小旋转次数,如果无论如何不能解锁,返回 -1 。
示例 1:
```
输入:deadends = ["0201","0101","0102","1212","2002"], target = "0202"
输出:6
解释:
可能的移动序列为 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"。
注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 这样的序列是不能解锁的,
因为当拨动到 "0102" 时这个锁就会被锁定。
```
示例 2:
```
输入: deadends = ["8888"], target = "0009"
输出:1
解释:
把最后一位反向旋转一次即可 "0000" -> "0009"。
```
示例 3:
```
输入: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
输出:-1
解释:
无法旋转到目标数字且不被锁定。
```
示例 4:
```
输入: deadends = ["0000"], target = "8888"
输出:-1
```
提示:
* 1 <= deadends.length <= 500
* deadends[i].length == 4
* target.length == 4
* target 不在 deadends 之中
* target 和 deadends[i] 仅由若干位数字组成 | ### 基本分析
首先,我建议你先做 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd),然后再回过头将本题作为「练习题」。
[127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd) 定位困难,而本题定位中等。主要体现在数据范围上,思维难度上 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd) 并不比本题难,大胆做。
回到本题,根据题意,可以确定这是一个「最短路/最小步数」问题。
此类问题,通常我们会使用「BFS」求解,但朴素的 BFS 通常会带来搜索空间爆炸问题。
因此我们可以使用与 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd) 类似的思路进行求解。
---
### 双向 BFS
我们知道,递归树的展开形式是一棵多阶树。
使用朴素 BFS 进行求解时,队列中最多会存在“两层”的搜索节点。
因此搜索空间的上界取决于 **目标节点所在的搜索层次的深度所对应的宽度**。
下图展示了朴素 BFS 可能面临的搜索空间爆炸问题:
**在朴素的 BFS 实现中,空间的瓶颈主要取决于搜索空间中的最大宽度。**
那么有没有办法让我们不使用这么宽的搜索空间,同时又能保证搜索到目标结果呢?
「双向 BFS」 可以很好的解决这个问题:
**同时从两个方向开始搜索,一旦搜索到相同的值,意味着找到了一条联通起点和终点的最短路径。**
对于「有解」、「有一定数据范围」同时「层级节点数量以倍数或者指数级别增长」的情况,「双向 BFS」的搜索空间通常只有「朴素 BFS」的空间消耗的几百分之一,甚至几千分之一。
「双向 BFS」的基本实现思路如下:
1. 创建「两个队列」分别用于两个方向的搜索;
2. 创建「两个哈希表」用于「解决相同节点重复搜索」和「记录转换次数」;
3. 为了尽可能让两个搜索方向“平均”,每次从队列中取值进行扩展时,先判断哪个队列容量较少;
4. 如果在搜索过程中「搜索到对方搜索过的节点」,说明找到了最短路径。
「双向 BFS」基本思路对应的伪代码大致如下:
```Java
d1、d2 为两个方向的队列
m1、m2 为两个方向的哈希表,记录每个节点距离起点的
// 只有两个队列都不空,才有必要继续往下搜索
// 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点
while(!d1.isEmpty() && !d2.isEmpty()) {
if (d1.size() < d2.size()) {
update(d1, m1, m2);
} else {
update(d2, m2, m1);
}
}
// update 为将当前队列 d 中包含的元素取出,进行「一次完整扩展」的逻辑(按层拓展)
void update(Deque d, Map cur, Map other) {}
```
回到本题,我们看看如何使用「双向 BFS」进行求解。
估计不少同学是第一次接触「双向 BFS」,因此这次我写了大量注释。
建议大家带着对「双向 BFS」的基本理解去阅读。
代码:
```Java
class Solution {
String t, s;
Set<String> set = new HashSet<>();
public int openLock(String[] _ds, String _t) {
s = "0000";
t = _t;
if (s.equals(t)) return 0;
for (String d : _ds) set.add(d);
if (set.contains(s)) return -1;
int ans = bfs();
return ans;
}
int bfs() {
// d1 代表从起点 s 开始搜索(正向)
// d2 代表从结尾 t 开始搜索(反向)
Deque<String> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
/*
* m1 和 m2 分别记录两个方向出现的状态是经过多少次转换而来
* e.g.
* m1 = {"1000":1} 代表 "1000" 由 s="0000" 旋转 1 次而来
* m2 = {"9999":3} 代表 "9999" 由 t="9996" 旋转 3 次而来
*/
Map<String, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
d1.addLast(s);
m1.put(s, 0);
d2.addLast(t);
m2.put(t, 0);
/*
* 只有两个队列都不空,才有必要继续往下搜索
* 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点
* e.g.
* 例如,如果 d1 为空了,说明从 s 搜索到底都搜索不到 t,反向搜索也没必要进行了
*/
while (!d1.isEmpty() && !d2.isEmpty()) {
int t = -1;
if (d1.size() <= d2.size()) {
t = update(d1, m1, m2);
} else {
t = update(d2, m2, m1);
}
if (t != -1) return t;
}
return -1;
}
int update(Deque<String> deque, Map<String, Integer> cur, Map<String, Integer> other) {
int m = deque.size();
while (m-- > 0) {
String poll = deque.pollFirst();
char[] pcs = poll.toCharArray();
int step = cur.get(poll);
// 枚举替换哪个字符
for (int i = 0; i < 4; i++) {
// 能「正向转」也能「反向转」,这里直接枚举偏移量 [-1,1] 然后跳过 0
for (int j = -1; j <= 1; j++) {
if (j == 0) continue;
// 求得替换字符串 str
int origin = pcs[i] - '0';
int next = (origin + j) % 10;
if (next == -1) next = 9;
char[] clone = pcs.clone();
clone[i] = (char)(next + '0');
String str = String.valueOf(clone);
if (set.contains(str)) continue;
if (cur.containsKey(str)) continue;
// 如果在「另一方向」找到过,说明找到了最短路,否则加入队列
if (other.containsKey(str)) {
return step + 1 + other.get(str);
} else {
deque.addLast(str);
cur.put(str, step + 1);
}
}
}
}
return -1;
}
}
```
---
### AStar 算法
可以直接根据本题规则来设计 A* 的「启发式函数」。
比如对于两个状态 `a` 和 `b` 可直接计算出「理论最小转换次数」:**不同字符的转换成本之和** 。
**需要注意的是:由于我们衡量某个字符 `str` 的估值是以目标字符串 `target` 为基准,因此我们只能确保 `target` 出队时为「距离最短」,而不能确保中间节点出队时「距离最短」,因此我们不能单纯根据某个节点是否「曾经入队」而决定是否入队,还要结合当前节点的「最小距离」是否被更新而决定是否入队。**
这一点十分关键,在代码层面上体现在 `map.get(str).step > poll.step + 1` 的判断上。
注意:本题用 A* 过了,但通常我们需要先「确保有解」,A* 的启发搜索才会发挥真正价值。而本题,除非 `t` 本身在 `deadends` 中,其余情况我们无法很好提前判断「是否有解」。对于无解的情况 A* 效果不如「双向 BFS」。
代码:
```Java
class Solution {
class Node {
String str;
int val, step;
/**
* str : 对应字符串
* val : 估值(与目标字符串 target 的最小转换成本)
* step: 对应字符串是经过多少步转换而来
*/
Node(String _str, int _val, int _step) {
str = _str;
val = _val;
step = _step;
}
}
int f(String str) {
int ans = 0;
for (int i = 0; i < 4; i++) {
int cur = str.charAt(i) - '0', target = t.charAt(i) - '0';
int a = Math.min(cur, target), b = Math.max(cur, target);
// 在「正向转」和「反向转」之间取 min
int min = Math.min(b - a, a + 10 - b);
ans += min;
}
return ans;
}
String s, t;
Set<String> set = new HashSet<>();
public int openLock(String[] ds, String _t) {
s = "0000";
t = _t;
if (s.equals(t)) return 0;
for (String d : ds) set.add(d);
if (set.contains(s)) return -1;
PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);
Map<String, Node> map = new HashMap<>();
Node root = new Node(s, f(s), 0);
q.add(root);
map.put(s, root);
while (!q.isEmpty()) {
Node poll = q.poll();
char[] pcs = poll.str.toCharArray();
int step = poll.step;
if (poll.str.equals(t)) return step;
for (int i = 0; i < 4; i++) {
for (int j = -1; j <= 1; j++) {
if (j == 0) continue;
int cur = pcs[i] - '0';
int next = (cur + j) % 10;
if (next == -1) next = 9;
char[] clone = pcs.clone();
clone[i] = (char)(next + '0');
String str = String.valueOf(clone);
if (set.contains(str)) continue;
// 如果 str 还没搜索过,或者 str 的「最短距离」被更新,则入队
if (!map.containsKey(str) || map.get(str).step > step + 1) {
Node node = new Node(str, step + 1 + f(str), step + 1);
map.put(str, node);
q.add(node);
}
}
}
}
return -1;
}
}
```
---
### IDA* 算法
同样我们可以使用基于 `DFS` 的启发式 IDA* 算法:
* 仍然使用 `f()` 作为估值函数
* 利用旋转次数有限:总旋转次数不会超过某个阈值 $\max$。
* 利用「迭代加深」的思路找到最短距离
理想情况下,由于存在正向旋转和反向旋转,每一位转轮从任意数字开始到达任意数字,消耗次数不会超过 $5$ 次,因此理想情况下可以设定 $\max = 5 * 4$ 。
但考虑 `deadends` 的存在,我们需要将 $\max$ 定义得更加保守一些:$\max = 10 * 4$ 。
**但这样的阈值设定,加上 IDA\* 算法每次会重复遍历「距离小于与目标节点距离」的所有节点,会有很大的 TLE 风险。**
**因此我们需要使用动态阈值:不再使用固定的阈值,而是利用 `target` 计算出「最大的转移成本」作为我们的「最深数量级」。**
PS. 上述的阈值分析是科学做法。对于本题可以利用数据弱,直接使用 $\max = 5 * 4$ 也可以通过,并且效果不错。
但必须清楚 $\max = 5 * 4$ 可能是一个错误的阈值,本题起点为 `0000`,考虑将所有正向转换的状态都放入 `deadends` 中,`target` 为 `2222`。这时候我们可以只限定 `0000` 先变为 `9999` 再往回变为 `2222` 的通路不在 `deadends` 中。
这时候使用 $\max = 5 * 4$ 就不对,但本题数据弱,可以通过(想提交错误数据拿积分吗?别试了,我已经提交了 🤣
代码:
```Java
class Solution {
String s, t;
String cur;
Set<String> set = new HashSet<>();
Map<String, Integer> map = new HashMap<>();
public int openLock(String[] ds, String _t) {
s = "0000";
t = _t;
if (s.equals(t)) return 0;
for (String d : ds) set.add(d);
if (set.contains(s)) return -1;
int depth = 0, max = getMax();
cur = s;
map.put(cur, 0);
while (depth <= max && !dfs(0, depth)) {
map.clear();
cur = s;
map.put(cur, 0);
depth++;
}
return depth > max ? -1 : depth;
}
int getMax() {
int ans = 0;
for (int i = 0; i < 4; i++) {
int origin = s.charAt(i) - '0', next = t.charAt(i) - '0';
int a = Math.min(origin, next), b = Math.max(origin, next);
int max = Math.max(b - a, a + 10 - b);
ans += max;
}
return ans;
}
int f() {
int ans = 0;
for (int i = 0; i < 4; i++) {
int origin = cur.charAt(i) - '0', next = t.charAt(i) - '0';
int a = Math.min(origin, next), b = Math.max(origin, next);
int min = Math.min(b - a, a + 10 - b);
ans += min;
}
return ans;
}
boolean dfs(int u, int max) {
if (u + f() > max) return false;
if (f() == 0) return true;
String backup = cur;
char[] cs = cur.toCharArray();
for (int i = 0; i < 4; i++) {
for (int j = -1; j <= 1; j++) {
if (j == 0) continue;
int origin = cs[i] - '0';
int next = (origin + j) % 10;
if (next == -1) next = 9;
char[] clone = cs.clone();
clone[i] = (char)(next + '0');
String str = String.valueOf(clone);
if (set.contains(str)) continue;
if (!map.containsKey(str) || map.get(str) > u + 1) {
cur = str;
map.put(str, u + 1);
if (dfs(u + 1, max)) return true;
cur = backup;
}
}
}
return false;
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.752` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/751-760/754. 到达终点数字（中等）.md | 754. 到达终点数字 | https://leetcode.cn/problems/reach-a-number/solution/by-ac_oier-o4ze/ | 中等 | [
"数学"
] | 在一根无限长的数轴上,你站在 `0` 的位置。终点在 `target` 的位置。
你可以做一些数量的移动 numMoves :
* 每次你可以选择向左或向右移动。
* 第 `i` 次移动(从 `i == 1` 开始,到 `i == numMoves`),在选择的方向上走 `i` 步。
给定整数 `target`,返回 到达目标所需的 最小 移动次数(即最小 `numMoves` ) 。
示例 1:
```
输入: target = 2
输出: 3
解释:
第一次移动,从 0 到 1 。
第二次移动,从 1 到 -1 。
第三次移动,从 -1 到 2 。
```
示例 2:
```
输入: target = 3
输出: 2
解释:
第一次移动,从 0 到 1 。
第二次移动,从 1 到 3 。
```
提示:
* $-10^9 <= target <= 10^9$
* $target != 0$ | ### 数学
#### 提示一:数轴上的任意点都以起点($0$ 点)对称,只需要考虑对称点的任意一边
由于题目没有限制我们「不能到达哪些点」以及「出发的起始方向」,因此以起点为中心的左右两边对称。
即:左边所能到达任意一个点,都能通过调整所达路径的方向来将终点调整到右边。
同时由于起点是一个特殊的位置 $0$ 点,因此相应的「正数点」和「负数点」对称,我们仅需考虑一边(例如正数域)即可。
#### 提示二:先往靠近 `target` 的方向移动,到达或越过 `target` 的时候则停止
只考虑 `target` 为正的情况,我们假定起始先往靠近 `target` 的方向移动(即所有步数均为正值),根据是「到达」还是「越过」`target` 位置分情况讨论:
* 若能直接到达 `target`,此时消耗的必然是最小步数,可直接返回;
* 若越过了 `target`,假设此时消耗的步数为 $k$,所走的距离为 $dist = \frac{k \times (k + 1)}{2} > target$,我们可以考虑是否需要增加额外步数来到达 `target`。
#### 提示三:越过 `target` 时,如何不引入额外步数
若不引入额外步数,意味着我们需要将此前某些移动的方向进行翻转,使得调整后的 $dist = target$。
我们假设需要调整的步数总和为 `tot`,则有 $dist - 2 \times tot = target$,变形可得 $tot = \frac{dist - target}{2}$。
若想满足上述性质,需要确保能找到这样的 `tot`,即 `tot` 合法,
不难推导出当 `dist` 和 `target` 差值为「偶数」时(两者奇偶性相同),我们可以找到这样的 `tot`,从而实现不引入额外步数来到达 `target` 位置。
> 由于我们的 $dist$ 是由数列 $[1,2,3,...,k]$ 累加而来,因此必然能够在该数列 $[1,2,3...k]$ 中通过「不重复选择某些数」来凑成任意一个小于等于 $dist$ 的数。
#### 提示四:越过 `target` 时,如何尽量减少引入额外步数
当 `dist` 和 `target` 差值不为「偶数」时,我们只能通过引入额外步数(继续往右走)来使得,两者差值为偶数。
可以证明,最多引入步数不超过 $4$ 步,可使用得两者奇偶性相同,即不超过 $4$ 步可以覆盖到「奇数」和「偶数」两种情况。
根据 $k$ 与 $4$ 的余数关系分情况讨论:
* 余数为 $0$,即 $k = 4X$,由于 $dist = \frac{k(k+1)}{2} = \frac{4X(4X+1)}{2} = 2X(4X+1)$,其中一数为偶数,$dist$ 为偶数;
* 余数为 $1$,即 $k = 4X + 1$,由于 $dist = \frac{k(k+1)}{2} = \frac{(4X+1)(4X+2)}{2} = (4X+1)(2X+1)$,两个奇数相乘为奇数,$dist$ 为奇数;
* 余数为 $2$,即 $k = 4X + 2$,$dist = \frac{k(k+1)}{2} = \frac{(4X+2)(4X+3)}{2} = (2X+1)(4X+3)$,两个奇数相乘为奇数,$dist$ 为奇数;
* 余数为 $3$,即 $k = 4X + 3$,$dist = \frac{k(k+1)}{2} = \frac{(4X+3)(4X+4)}{2} = (4X+3)(2X+2)$,其中一数为偶数,$dist$ 为偶数。
因此在越过 `target` 后,最多引入不超过 $4$ 步可使得 `dist` 和 `target` 奇偶性相同。
#### 提示五:如何不通过「遍历」或「二分」的方式找到一个合适的 `k` 值,再通过不超过 $4$ 步的调整找到答案
我们期望找到一个合适的 `k` 值,使得 $dist = \frac{k \times (k + 1)}{2} < target$,随后通过增加 `k` 值来找到答案。
利用求和公式 $dist = \frac{k \times (k + 1)}{2}$,我们可以设定 $k = \left \lfloor \sqrt{2 \times target}) \right \rfloor$ 为起始值,随后逐步增大 `k` 值,直到满足「`dist` 和 `target` 奇偶性相同」。
Java 代码:
```Java
class Solution {
public int reachNumber(int target) {
if (target < 0) target = -target;
int k = (int) Math.sqrt(2 * target), dist = k * (k + 1) / 2;
while (dist < target || (dist - target) % 2 == 1) {
k++;
dist = k * (k + 1) / 2;
}
return k;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int reachNumber(int target) {
if (target < 0) target = -target;
int k = static_cast<int>(std::sqrt(2 * target));
int dist = k * (k + 1) / 2;
while (dist < target || (dist - target) % 2 == 1) {
k++;
dist = k * (k + 1) / 2;
}
return k;
}
};
```
Python 代码:
```Python
class Solution:
def reachNumber(self, target: int) -> int:
if target < 0:
target = -target
k = int(math.sqrt(2 * target))
dist = k * (k + 1) / 2
while dist < target or (dist - target) % 2 == 1:
k += 1
dist = k * (k + 1) / 2
return k
```
TypeScript 代码:
```TypeScript
function reachNumber(target: number): number {
if (target < 0) target = -target
let k = Math.floor(Math.sqrt(2 * target)), dist = k * (k + 1) / 2
while (dist < target || (dist - target) % 2 == 1) {
k++
dist = k * (k + 1) / 2
}
return k
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.754` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/751-760/757. 设置交集大小至少为2（困难）.md | 757. 设置交集大小至少为2 | https://leetcode.cn/problems/set-intersection-size-at-least-two/solution/by-ac_oier-3xn6/ | 困难 | [
"贪心"
] | 一个整数区间 $[a, b]$ ($a < b$) 代表着从 `a` 到 `b` 的所有连续整数,包括 `a` 和 `b`。
给你一组整数区间 `intervals`,请找到一个最小的集合 `S`,使得 `S` 里的元素与区间 `intervals` 中的每一个整数区间都至少有 $2$ 个元素相交。
输出这个最小集合 `S` 的大小。
示例 1:
```
输入: intervals = [[1, 3], [1, 4], [2, 5], [3, 5]]
输出: 3
解释:
考虑集合 S = {2, 3, 4}. S与intervals中的四个区间都有至少2个相交的元素。
且这是S最小的情况,故我们输出3。
```
示例 2:
```
输入: intervals = [[1, 2], [2, 3], [2, 4], [4, 5]]
输出: 5
解释:
最小的集合S = {1, 2, 3, 4, 5}.
```
注意:
* `intervals` 的长度范围为 $[1, 3000]$。
* `intervals[i]` 长度为 $2$,分别代表左、右边界。
* `intervals[i][j]` 的值是 $[0, 10^8]$ 范围内的整数。 | ### 贪心
不要被样例数据误导了,题目要我们求最小点集的数量,并不规定点集 `S` 是连续段。
为了方便,我们令 `intervals` 为 `ins`。
当只有一个线段时,我们可以在线段内取任意两点作为 `S` 成员,而当只有两个线段时,我们可以两个线段重合情况进行决策:
1. 当两个线段完全不重合时,为满足题意,我们需要从两个线段中各取两个点,此时这四个点都可以任意取;
2. 当两个线段仅有一个点重合,为满足 `S` 最小化的题意,我们可以先取重合点,然后再两个线段中各取一个;
3. 当两个线段有两个及以上的点重合,此时在重合点中任选两个即可。
不难发现,当出现重合的所有情况中,必然可以归纳某个线段的边缘点上。即不存在两个线段存在重合点,仅发生在两线段的中间部分:
因此我们可以从边缘点决策进行入手。
具体的,我们可以按照「右端点从小到大,左端点从大到小」的双关键字排序,然后从前往后处理每个区间,处理过程中不断往 `S` 中添加元素,由于我们已对所有区间排序且从前往后处理,因此我们往 `S` 中增加元素的过程中必然是单调递增,同时在对新的后续区间考虑是否需要往 `S` 中添加元素来满足题意时,也是与 `S` 中的最大/次大值(点集中的边缘元素)做比较,因此我们可以使用两个变量 `a` 和 `b` 分别代指当前集合 `S` 中的次大值和最大值(`a` 和 `b` 初始化为足够小的值 $-1$),而无需将整个 `S` 存下来。
不失一般性的考虑,当我们处理到 $ins[i]$ 时,该如何决策:
1. 若 $ins[i][0] > b$(当前区间的左端点大于当前点集 `S` 的最大值),说明 $ins[i]$ 完全不被 `S` 所覆盖,为满足题意,我们要在 $ins[i]$ 中选两个点,此时直观思路是选择 $ins[i]$ 最靠右的两个点(即 $ins[i][1] - 1$ 和 $ins[i][1]$);
2. 若 $ins[i][0] > a$(即当前区间与点集 `S` 存在一个重合点 `b`,由于次大值 `a` 和 最大值 `b` 不总是相差 $1$,我们不能写成 $ins[i][0] == b$),此时为了满足 $ins[i]$ 至少被 $2$ 个点覆盖,我们需要在 $ins[i]$ 中额外选择一个点,此时直观思路是选择 $ins[i]$ 最靠右的点(即$ins[i][1]$);
3. 其余情况,说明当前区间 $ins[i]$ 与点集 `S` 至少存在两个点 `a` 和 `b`,此时无须额外引入其余点来覆盖 $ins[i]$。
上述情况是对「右端点从小到大」的必要性说明,而「左端点从大到小」目的是为了方便我们处理边界情况而引入的:若在右端点相同的情况下,如果「左端点从小到大」处理的话,会有重复的边缘点被加入 `S`。
> 有同学对重复边缘点加入 `S` 不理解,假设 `S` 当前的次大值和最大值分别为 `j` 和 `k`(其中 $k - j > 1$),如果后面有两个区间分别为 $[k - 1, d]$ 和 $[k + 1, d]$ 时,就会出现问题(其中 `d` 为满足条件的任意右端点)
更具体的:假设当前次大值和最大值分别为 $2$ 和 $4$,后续两个区间分别为 $[3, 8]$ 和 $[5, 8]$,你会发现先处理 $[3, 8]$ 的话,数值 $8$ 会被重复添加
**上述决策存在直观判断,需要证明不存在比该做法取得的点集 `S` 更小的合法解**:
若存在更小的合法集合方案 `A`(最优解),根据我们最前面对两个线段的重合分析知道,由于存在任意选点均能满足覆盖要求的情况,因此最优解 `A` 的具体方案可能并不唯一。
因此首先我们先在不影响 `A` 的集合大小的前提下,**对具体方案 `A` 中的非关键点(即那些被选择,但既不是某个具体区间的边缘点,也不是边缘点的相邻点)进行调整(修改为区间边缘点或边缘点的相邻点)**。
这样我们能够得到一个唯一的最优解具体方案,该方案既能取到最小点集大小,同时与贪心解 `S` 的选点有较大重合度。
此时如果贪心解并不是最优解的话,意味着贪心解中存在某些不必要的点(可去掉,同时不会影响覆盖要求)。
然后我们在回顾下,我们什么情况下会往 `S` 中进行加点,根据上述「不失一般性」的分析:
1. 当 $ins[i][0] > b$ 时,我们会往 `S` 中添加两个点,若这个不必要的点是在这个分支中被添加的话,意味着当前 $ins[i]$ 可以不在此时被覆盖,而在后续其他区间 $ins[j]$ 被覆盖时被同步覆盖(其中 $j > i$),此时必然对应了我们重合分析中的后两种情况,可以将原本在 $ins[j]$ 中被选择的点,调整为 $ins[i]$ 的两个边缘点,结果不会变差(覆盖情况不变,点数不会变多):
即此时原本在最优解 `A` 中不存在,在贪心解 `S` 中存在的「不必要点」会变成「必要点」。
2. 当 $ins[i] > a$ 时,我们会往 `S` 中添加一个点,若这个不必要的点是在这个分支被添加的话,分析方式同理,且情况 $1$ 不会发生,如果 $ins[i]$ 和 $ins[j]$ 只有一个重合点的话,起始 $ins[i][1]$ 不会是不必要点:
**综上,我们可以经过两步的“调整”,将贪心解变为最优解:第一步调整是在最优解的任意具体方案 `A` 中发生,通过将所有非边缘点调整为边缘点,来得到一个唯一的最优解具体方案;然后通过反证法证明,贪心解 `S` 中并不存在所谓的可去掉的「不必要点」,从而证明「贪心解大小必然不会大于最优解的大小」,即 $S > A$ 不成立,$S \leq A$ 恒成立,再结合 `A` 是最优解的前提($A \leq S$),可得 $S = A$。**
Java 代码:
```Java
class Solution {
public int intersectionSizeTwo(int[][] ins) {
Arrays.sort(ins, (a, b)->{
return a[1] != b[1] ? a[1] - b[1] : b[0] - a[0];
});
int a = -1, b = -1, ans = 0;
for (int[] i : ins) {
if (i[0] > b) {
a = i[1] - 1; b = i[1];
ans += 2;
} else if (i[0] > a) {
a = b; b = i[1];
ans++;
}
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function intersectionSizeTwo(ins: number[][]): number {
ins = ins.sort((a, b)=> {
return a[1] != b[1] ? a[1] - b[1] : b[0] - a[0]
});
let a = -1, b = -1, ans = 0
for (const i of ins) {
if (i[0] > b) {
a = i[1] - 1; b = i[1]
ans += 2
} else if (i[0] > a) {
a = b; b = i[1]
ans++
}
}
return ans
};
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.752` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/761. 特殊的二进制序列（困难）.md | 761. 特殊的二进制序列 | https://leetcode.cn/problems/special-binary-string/solution/by-ac_oier-cz6h/ | 困难 | [
"构造"
] | 特殊的二进制序列是具有以下两个性质的二进制序列:
* `0` 的数量与 `1` 的数量相等。
* 二进制序列的每一个前缀码中 `1` 的数量要大于等于 `0` 的数量。
给定一个特殊的二进制序列 `S`,以字符串形式表示。定义一个操作为首先选择 `S` 的两个连续且非空的特殊的子串,然后将它们交换。(两个子串为连续的当且仅当第一个子串的最后一个字符恰好为第二个子串的第一个字符的前一个字符。)
在任意次数的操作之后,交换后的字符串按照字典序排列的最大的结果是什么?
示例 1:
```
输入: S = "11011000"
输出: "11100100"
解释:
将子串 "10" (在S[1]出现) 和 "1100" (在S[3]出现)进行交换。
这是在进行若干次操作后按字典序排列最大的结果。
```
说明:
* `S` 的长度不超过 $50$。
* `S` 保证为一个满足上述定义的特殊 的二进制序列。 | ### 构造
我们可以定义每个字符的得分:字符 `1` 得分为 $1$ 分,字符 `0` 得分为 $-1$ 分。
根据题目对「特殊字符串」的定义可知,给定字符串 `s` 的总得分为 $0$,且任意前缀串不会出现得分为负数的情况。
考虑将 `s` 进行划分为多个足够小特殊字符串 `item`(足够小的含义为每个 `item` 无法再进行划分),每个 `item` 的总得分为 $0$。根据 `s` 定义,必然可恰好划分为多个 `item`。
每次操作可以将相邻特殊字符串进行交换,于是问题转换为将 `s` 进行重排,求其重排后字典序最大的方案。
首先可以证明一个合法 `item` 必然满足 `1...0` 的形式,可通过「反证法」进行进行证明:定义了 `item` 总得分为 $0$,且长度不为 $0$,因此必然有 `1` 有 `0`。**若第一位字符为 `0`,则必然能够从第一位字符作为起点,找到一个得分为负数的子串,这与 `s` 本身的定义冲突(`s` 中不存在得分为负数的前缀串);若最后一位为 `1`,根据 `item` 总得分为 $0$,可知当前 `item` 去掉最后一位后得分为负,也与 `s` 本身定义冲突(`s` 中不存在得分为负数的前缀串)。**
因此可将构造分两步进行:
1. 对于每个 `item` 进行重排,使其调整为字典序最大
2. 对于 `item` 之间的位置进行重排,使其整体字典序最大
由于题目没有规定重排后的性质,为第一步调整和第二步调整的保持相对独立,我们只能对 `item` 中的 `1...0` 中的非边缘部分进行调整(递归处理子串部分)。
假设所有 `item` 均被处理后,考虑如何进行重排能够使得最终方案字典序最大。
若有两个 `item`,分别为 `a` 和 `b`,我们可以根据拼接结果 `ab` 和 `ba` 的字典序大小来决定将谁放在前面。
**这样根据「排序比较逻辑」需要证明在集合上具有[「全序关系」](https://baike.baidu.com/item/%E5%85%A8%E5%BA%8F%E5%85%B3%E7%B3%BB):**
我们使用符号 $@$ 来代指我们的「排序」逻辑:
* 如果 $a$ 必须排在 $b$ 的前面,我们记作 `a@b`;
* 如果 $a$ 必须排在 $b$ 的后面,我们记作 `b@a`;
* 如果 $a$ 既可以排在 $b$ 的前面,也可以排在 $b$ 的后面,我们记作 `a#b`;
**2.1 完全性**
**具有完全性是指从集合 `items` 中任意取出两个元素 $a$ 和 $b$,必然满足 `a@b`、`b@a` 和 `a#b` 三者之一。**
**这点其实不需要额外证明,因为由 $a$ 和 $b$ 拼接的字符串 $ab$ 和 $ba$ 所在「字典序大小关系中」要么完全相等,要么具有明确的字典序大小关系,导致 $a$ 必须排在前面或者后面。**
**2.2 反对称性**
**具有反对称性是指由 `a@b` 和 `b@a` 能够推导出 `a#b`。**
$a@b$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值大。
$b@a$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值小。
**这样,基于「字典序本身满足全序关系」和「数学上的 $a \geqslant b$ 和 $a \leqslant b$ 可推导出 $a = b$」。**
**得证 `a@b` 和 `b@a` 能够推导出 `a#b`。**
**2.3 传递性**
**具有传递性是指由 `a@b` 和 `b@c` 能够推导出 `a@c`。**
**我们可以利用「两个等长的拼接字符串,字典序大小关系与数值大小关系一致」这一性质来证明,因为字符串 $ac$ 和 $ca$ 必然是等长的。**
接下来,让我们从「自定义排序逻辑」出发,换个思路来证明 `a@c`:
**然后我们只需要证明在不同的 $i$ $j$ 关系之间(共三种情况),`a@c` 恒成立即可:**
1. 当 $i == j$ 的时候:
2. 当 $i > j$ 的时候:
3. 当 $i < j$ 的时候:
**综上,我们证明了无论在何种情况下,只要有 `a@b` 和 `b@c` 的话,那么 `a@c` 恒成立。**
**我们之所以能这样证明「传递性」,本质是利用了自定义排序逻辑中「对于确定任意元素 $a$ 和 $b$ 之间的排序关系只依赖于 $a$ 和 $b$ 的第一个不同元素之间的大小关系」这一性质。**
最终,我们证明了该「排序比较逻辑」必然能排序出字典序最大的方案。
Java 代码:
```Java
class Solution {
public String makeLargestSpecial(String s) {
if (s.length() == 0) return s;
List<String> list = new ArrayList<>();
char[] cs = s.toCharArray();
for (int i = 0, j = 0, k = 0; i < cs.length; i++) {
k += cs[i] == '1' ? 1 : -1;
if (k == 0) {
list.add("1" + makeLargestSpecial(s.substring(j + 1, i)) + "0");
j = i + 1;
}
}
Collections.sort(list, (a, b)->(b + a).compareTo(a + b));
StringBuilder sb = new StringBuilder();
for (String str : list) sb.append(str);
return sb.toString();
}
}
```
TypeScript 代码:
```TypeScript
function makeLargestSpecial(s: string): string {
const list = new Array<string>()
for (let i = 0, j = 0, k = 0; i < s.length; i++) {
k += s[i] == '1' ? 1 : -1
if (k == 0) {
list.push('1' + makeLargestSpecial(s.substring(j + 1, i)) + '0')
j = i + 1
}
}
list.sort((a, b)=>(b + a).localeCompare(a + b));
return [...list].join("")
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.761` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/762. 二进制表示中质数个计算置位（简单）.md | 762. 二进制表示中质数个计算置位 | https://leetcode-cn.com/problems/prime-number-of-set-bits-in-binary-representation/solution/by-ac_oier-w50x/ | 简单 | [
"模拟",
"位运算"
] | 给你两个整数 `left` 和 `right`,在闭区间 $[left, right]$ 范围内,统计并返回计算置位位数为质数的整数个数。
计算置位位数就是二进制表示中 $1$ 的个数。
例如, $21$ 的二进制表示 `10101` 有 $3$ 个计算置位。
示例 1:
```
输入:left = 6, right = 10
输出:4
解释:
6 -> 110 (2 个计算置位,2 是质数)
7 -> 111 (3 个计算置位,3 是质数)
9 -> 1001 (2 个计算置位,2 是质数)
10-> 1010 (2 个计算置位,2 是质数)
共计 4 个计算置位为质数的数字。
```
示例 2:
```
输入:left = 10, right = 15
输出:5
解释:
10 -> 1010 (2 个计算置位, 2 是质数)
11 -> 1011 (3 个计算置位, 3 是质数)
12 -> 1100 (2 个计算置位, 2 是质数)
13 -> 1101 (3 个计算置位, 3 是质数)
14 -> 1110 (3 个计算置位, 3 是质数)
15 -> 1111 (4 个计算置位, 4 不是质数)
共计 5 个计算置位为质数的数字。
```
提示:
* $1 <= left <= right <= 10^6$
* $0 <= right - left <= 10^4$ | ### 模拟 + lowbit
利用一个 `int` 的二进制表示不超过 $32$,我们可以先将 $32$ 以内的质数进行打表。
从前往后处理 $[left, right]$ 中的每个数 $x$,利用 `lowbit` 操作统计 $x$ 共有多少位 $1$,记为 $cnt$,若 $cnt$ 为质数,则对答案进行加一操作。
代码:
```Java
class Solution {
static boolean[] hash = new boolean[40];
static {
int[] nums = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
for (int x : nums) hash[x] = true;
}
public int countPrimeSetBits(int left, int right) {
int ans = 0;
for (int i = left; i <= right; i++) {
int x = i, cnt = 0;
while (x != 0 && ++cnt >= 0) x -= (x & -x);
if (hash[cnt]) ans++;
}
return ans;
}
}
```
* 时间复杂度:$O((right - left) * \log{right})$
* 空间复杂度:$O(C)$
---
### 模拟 + 分治
枚举 $[left, right]$ 范围内的数总是不可避免,上述解法的复杂度取决于复杂度为 $O(\log{x})$ 的 `lowbit` 操作。
而比 `lowbit` 更加优秀的统计「二进制 $1$ 的数量」的做法最早在 [(题解) 191. 位1的个数](https://leetcode-cn.com/problems/number-of-1-bits/solution/yi-ti-san-jie-wei-shu-jian-cha-you-yi-to-av1r/) 讲过,采用「分治」思路对二进制进行成组统计,复杂度为 $O(\log{\log{x}})$。
代码:
```Java
class Solution {
static boolean[] hash = new boolean[40];
static {
int[] nums = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
for (int x : nums) hash[x] = true;
}
public int countPrimeSetBits(int left, int right) {
int ans = 0;
for (int i = left; i <= right; i++) {
int x = i;
x = (x & 0x55555555) + ((x >>> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >>> 2) & 0x33333333);
x = (x & 0x0f0f0f0f) + ((x >>> 4) & 0x0f0f0f0f);
x = (x & 0x00ff00ff) + ((x >>> 8) & 0x00ff00ff);
x = (x & 0x0000ffff) + ((x >>> 16) & 0x0000ffff);
if (hash[x]) ans++;
}
return ans;
}
}
```
* 时间复杂度:$O((right - left) * \log{\log{right}})$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.762` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/764. 最大加号标志（中等）.md | 764. 最大加号标志 | https://leetcode.cn/problems/largest-plus-sign/solution/by-ac_oier-q932/ | 中等 | [
"模拟",
"预处理"
] | 在一个 $n \times n$ 的矩阵 `grid` 中,除了在数组 `mines` 中给出的元素为 `0`,其他每个元素都为 `1`。$mines[i] = [x_i, y_i]$ 表示 $grid[x_i][y_i] = 0$。
返回 `grid` 中包含 `1` 的最大的轴对齐加号标志的阶数 。
如果未找到加号标志,则返回 `0` 。
一个 `k` 阶由 `1` 组成的 “轴对称”加号标志 具有中心网格 $grid[r][c] = 1$ ,以及 `4` 个从中心向上、向下、向左、向右延伸,长度为 `k-1`,由 `1` 组成的臂。
注意,只有加号标志的所有网格要求为 `1` ,别的网格可能为 `0` 也可能为 `1` 。
示例 1:
```
输入: n = 5, mines = [[4, 2]]
输出: 2
解释: 在上面的网格中,最大加号标志的阶只能是2。一个标志已在图中标出。
```
示例 2:
```
输入: n = 1, mines = [[0, 0]]
输出: 0
解释: 没有加号标志,返回 0 。
```
提示:
* $1 <= n <= 500$
* $1 <= mines.length <= 5000$
* $0 <= x_i, y_i < n$
* 每一对 $(x_i, y_i)$ 都 不重复 | ### 预处理 + 模拟
假设点 $(x, y)$ 能够取得最大长度 $k$,我们知道 $k$ 取决于以点 $(x, y)$ 为起点,四联通方向中「最短的连续 $1$ 的长度」。
基于此,我们可以建立四个大小为 $n \times n$ 的矩阵(二维数组)`a`、`b`、`c` 和 `d` 分别代表四个方向连续 $1$ 的前缀数:
数据范围为 $500$,预处理前缀数组复杂度为 $O(n^2)$,统计答案复杂度为 $O(n^2)$,时间复杂度没有问题。
再考虑空间,建立四个方向的前缀数组所需空间为 $500 \times 500 \times 4 = 10^6$,即使加上原矩阵 `g` 也不会有 `MLE` 风险,空间复杂度也没有问题。
Java 代码:
```Java
class Solution {
public int orderOfLargestPlusSign(int n, int[][] mines) {
int[][] g = new int[n + 10][n + 10];
for (int i = 1; i <= n; i++) Arrays.fill(g[i], 1);
for (int[] info : mines) g[info[0] + 1][info[1] + 1] = 0;
int[][] a = new int[n + 10][n + 10], b = new int[n + 10][n + 10], c = new int[n + 10][n + 10], d = new int[n + 10][n + 10];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (g[i][j] == 1) {
a[i][j] = a[i - 1][j] + 1;
b[i][j] = b[i][j - 1] + 1;
}
if (g[n + 1 - i][n + 1 - j] == 1) {
c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1;
d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans = Math.max(ans, Math.min(Math.min(a[i][j], b[i][j]), Math.min(c[i][j], d[i][j])));
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {
vector<vector<int>> g(n + 10, vector<int>(n + 10, 1));
for (vector<int>& info : mines) g[info[0] + 1][info[1] + 1] = 0;
vector<vector<int>> a(n + 10, vector<int>(n + 10)), b(n + 10, vector<int>(n + 10)), c(n + 10, vector<int>(n + 10)), d(n + 10, vector<int>(n + 10));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (g[i][j] == 1) {
a[i][j] = a[i - 1][j] + 1;
b[i][j] = b[i][j - 1] + 1;
}
if (g[n + 1 - i][n + 1 - j] == 1) {
c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1;
d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans = max(ans, min(min(a[i][j], b[i][j]), min(c[i][j], d[i][j])));
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def orderOfLargestPlusSign(self, n: int, mines: List[List[int]]) -> int:
g = [[1] * (n + 10) for _ in range(n + 10)]
for x, y in mines:
g[x + 1][y + 1] = 0
a, b, c, d = [[0] * (n + 10) for _ in range(n + 10)], [[0] * (n + 10) for _ in range(n + 10)], [[0] * (n + 10) for _ in range(n + 10)], [[0] * (n + 10) for _ in range(n + 10)]
for i in range(1, n + 1):
for j in range(1, n + 1):
if g[i][j] == 1:
a[i][j] = a[i - 1][j] + 1
b[i][j] = b[i][j - 1] + 1
if g[n + 1 - i][n + 1 - j] == 1:
c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1
d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1
ans = 0
for i in range(1, n + 1):
for j in range(1, n + 1):
ans = max(ans, min(min(a[i][j], b[i][j]), min(c[i][j], d[i][j])))
return ans
```
TypeScript 代码:
```TypeScript
function orderOfLargestPlusSign(n: number, mines: number[][]): number {
function getMat(x: number, y: number, val: number): number[][] {
const ans = new Array<Array<number>>(x)
for (let i = 0; i < x; i++) ans[i] = new Array<number>(y).fill(val)
return ans
}
const g = getMat(n + 10, n + 10, 1)
for (const info of mines) g[info[0] + 1][info[1] + 1] = 0
const a = getMat(n + 10, n + 10, 0), b = getMat(n + 10, n + 10, 0), c = getMat(n + 10, n + 10, 0), d = getMat(n + 10, n + 10, 0)
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= n; j++) {
if (g[i][j] == 1) {
a[i][j] = a[i - 1][j] + 1
b[i][j] = b[i][j - 1] + 1
}
if (g[n + 1 - i][n + 1 - j] == 1) {
c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1
d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1
}
}
}
let ans = 0
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= n; j++) {
ans = Math.max(ans, Math.min(Math.min(a[i][j], b[i][j]), Math.min(c[i][j], d[i][j])))
}
}
return ans
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.764` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/765. 情侣牵手（困难）.md | 765. 情侣牵手 | https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/ | 困难 | [
"并查集",
"贪心"
] | N 对情侣坐在连续排列的 2N 个座位上,想要牵到对方的手。 计算最少交换座位的次数,以便每对情侣可以并肩坐在一起。 一次交换可选择任意两人,让他们站起来交换座位。
人和座位用 0 到 2N-1 的整数表示,情侣们按顺序编号,第一对是 (0, 1),第二对是 (2, 3),以此类推,最后一对是 (2N-2, 2N-1)。
这些情侣的初始座位 row[i] 是由最初始坐在第 i 个座位上的人决定的。
示例 1:
```
输入: row = [0, 2, 1, 3]
输出: 1
解释: 我们只需要交换row[1]和row[2]的位置即可。
```
示例 2:
```
输入: row = [3, 2, 0, 1]
输出: 0
解释: 无需交换座位,所有的情侣都已经可以手牵手了。
```
说明:
* len(row) 是偶数且数值在 [4, 60]范围内。
* 可以保证row 是序列 `0...len(row)-1` 的一个全排列。 | ### 并查集
首先,我们总是以「情侣对」为单位进行设想:
1. 当有两对情侣相互坐错了位置,ta们两对之间形成了一个环。需要进行一次交换,使得每队情侣独立(相互牵手)
2. 如果三对情侣相互坐错了位置,ta们三对之间形成了一个环,需要进行两次交换,使得每队情侣独立(相互牵手)
3. 如果四对情侣相互坐错了位置,ta们四对之间形成了一个环,需要进行三次交换,使得每队情侣独立(相互牵手)
也就是说,如果我们有 `k` 对情侣形成了错误环,需要交换 `k - 1` 次才能让情侣牵手。
**于是问题转化成 `n / 2` 对情侣中,有多少个这样的环。**
可以直接使用「并查集」来做。
由于 0和1配对、2和3配对 ... 因此互为情侣的两个编号除以 2 对应同一个数字,可直接作为它们的「情侣组」编号:
```Java
class Solution {
int[] p = new int[70];
void union(int a, int b) {
p[find(a)] = p[find(b)];
}
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
public int minSwapsCouples(int[] row) {
int n = row.length, m = n / 2;
for (int i = 0; i < m; i++) p[i] = i;
for (int i = 0; i < n; i += 2) union(row[i] / 2, row[i + 1] / 2);
int cnt = 0;
for (int i = 0; i < m; i++) {
if (i == find(i)) cnt++;
}
return m - cnt;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 贪心
还是以「情侣对」为单位进行分析:
由于题目保证有解,我们也可以从前往后(每两格作为一步)处理,对于某一个位置而言,如果下一个位置不是应该出现的情侣的话。
则对下一个位置进行交换。
同时为了方便我们找到某个值的下标,需要先对 `row` 进行预处理(可以使用哈希表或数组)。
```Java
class Solution {
public int minSwapsCouples(int[] row) {
int n = row.length;
int ans = 0;
int[] cache = new int[n];
for (int i = 0; i < n; i++) cache[row[i]] = i;
for (int i = 0; i < n - 1; i += 2) {
int a = row[i], b = a ^ 1;
if (row[i + 1] != b) {
int src = i + 1, tar = cache[b];
cache[row[tar]] = src;
cache[row[src]] = tar;
swap(row, src, tar);
ans++;
}
}
return ans;
}
void swap(int[] nums, int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 证明/分析
我们这样的做法本质是什么?
**其实相当于,当我处理到第 `k` 个位置的时候,前面的 `k - 1` 个位置的情侣已经牵手成功了。我接下来怎么处理,能够使得总花销最低。**
分两种情况讨论:
a. 现在处理第 `k` 个位置,使其牵手成功:
那么我要使得第 `k` 个位置的情侣也牵手成功,那么必然是保留第 `k` 个位置的情侣中其中一位,再进行修改,这样的成本是最小的(因为只需要交换一次)。
而且由于前面的情侣已经牵手成功了,因此交换的情侣必然在 `k` 位置的后面。
然后我们再考虑交换左边或者右边对最终结果的影响。
分两种情况来讨论:
1. 与第 `k` 个位置的匹配的两个情侣不在同一个位置上:这时候无论交换左边还是右边,后面需要调整的「情侣对数量」都是一样。假设处理第 `k` 个位置前需要调整的数量为 `n` 的话,处理完第 `k` 个位置(交换左边或是右边),需要调整的「情侣对数量」都为 `n - 1` 。
2. 与第 `k` 个位置的匹配的两个情侣在同一个位置上:这时候无论交换左边还是右边,后面需要调整的「情侣对数量」都是一样。假设处理第 `k` 个位置前需要调整的数量为 `n` 的话,处理完第 `k` 个位置(交换左边或是右边),需要调整的「情侣对数量」都为 `n - 2` 。
因此对于第 `k` 个位置而言,交换左边还是右边,并不会影响后续需要调整的「情侣对数量」。
b. 现在先不处理第 `k` 个位置,等到后面的情侣处理的时候「顺便」处理第 `k` 位置:
由于我们最终都是要所有位置的情侣牵手,而且每一个数值对应的情侣数值是唯一确定的。
因此我们这个等“后面”的位置处理,其实就是等与第 `k` 个位置互为情侣的位置处理(对应上图的就是我们是在等 【0 x】和【8 y】或者【0 8】这些位置被处理)。
由于被处理都是同一批的联通位置,因此和「a. 现在处理第 `k` 个位置」的分析结果是一样的。
---
不失一般性的,我们可以将这个分析推广到第一个位置,其实就已经是符合「当我处理到第 `k` 个位置的时候,前面的 `k - 1` 个位置的情侣已经牵手成功了」的定义了。
**综上所述,我们只需要确保从前往后处理,并且每次处理都保留第 `k` 个位置的其中一位,无论保留的左边还是右边都能得到最优解。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.765` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/766. 托普利茨矩阵（简单）.md | 766. 托普利茨矩阵 | https://leetcode-cn.com/problems/toeplitz-matrix/solution/cong-ci-pan-du-qu-cheng-ben-fen-xi-liang-f20w/ | 简单 | [
"模拟"
] | 给你一个 m x n 的矩阵 matrix 。如果这个矩阵是托普利茨矩阵,返回 true ;否则,返回 false 。
如果矩阵上每一条由左上到右下的对角线上的元素都相同,那么这个矩阵是 托普利茨矩阵 。
示例 1:
```
输入:matrix = [[1,2,3,4],[5,1,2,3],[9,5,1,2]]
输出:true
解释:
在上述矩阵中, 其对角线为:
"[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]"。
各条对角线上的所有元素均相同, 因此答案是 True 。
```
示例 2:
```
输入:matrix = [[1,2],[2,2]]
输出:false
解释:
对角线 "[1, 2]" 上的元素不同。
```
提示:
* m == matrix.length
* n == matrix[i].length
* 1 <= m, n <= 20
* 0 <= matrix[i][j] <= 99
进阶:
* 如果矩阵存储在磁盘上,并且内存有限,以至于一次最多只能将矩阵的一行加载到内存中,该怎么办?
* 如果矩阵太大,以至于一次只能将不完整的一行加载到内存中,该怎么办? | ### 按「格子」遍历
对于一个合格的「托普利茨矩阵」而言,每个格子总是与其左上角格子相等(如果有的话)。
我们以「格子」为单位进行遍历,每次与左上角的格子进行检查即可。
这样我们每对一个格子进行判断,都要读 `matrix` 上的两个格子的值(即**非边缘格子其实会被读取两次**)。
```Java
class Solution {
public boolean isToeplitzMatrix(int[][] matrix) {
int m = matrix.length, n = matrix[0].length;
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (matrix[i][j] != matrix[i - 1][j - 1]) return false;
}
}
return true;
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(1)$
***
### 按「线」遍历
如果稍微增加一点点难度:限制每个格子只能被读取一次呢?
这时候我们也可以按照「线」为单位进行检查。
当一条完整的斜线值都相等,我们再对下一条斜线做检查。
这样对于每个格子,我们都是**严格只读取一次**(如果整个矩阵是存在磁盘中,且不考虑操作系统的按页读取等机制,那么 IO 成本将下降为原来的一半)。
```Java
class Solution {
public boolean isToeplitzMatrix(int[][] matrix) {
int m = matrix.length, n = matrix[0].length;
int row = m, col = n;
while (col-- > 0) {
for (int i = 0, j = col, val = matrix[i++][j++]; i < m && j < n; i++, j++) {
if (matrix[i][j] != val) return false;
}
}
while (row-- > 0) {
for (int i = row, j = 0, val = matrix[i++][j++]; i < m && j < n; i++, j++) {
if (matrix[i][j] != val) return false;
}
}
return true;
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(1)$
***
### 进阶
1. 如果矩阵存储在磁盘上,并且内存有限,以至于一次最多只能将矩阵的一行加载到内存中,该怎么办?
使用「背包问题」的一维优化思路:假设我们有装载一行数据大小的内存,每次读取新的行时都进行「从右往左」的覆盖,每次覆盖都与前一个位置的进行比较(其实就是和上一行的左上角位置进行比较)。
如图:
如果你对更多「背包问题」相关内容感兴趣,可以看我这篇总结:[深度讲解背包问题](https://leetcode-cn.com/circle/discuss/GWpXCM/)
2. 如果矩阵太大,以至于一次只能将不完整的一行加载到内存中,该怎么办?
亲,这边建议升级内存,啊呸 ...
将问题看做子问题进行解决:调整读取矩阵的方式(按照垂直方向进行读取);或使用额外数据记录当前当前片段的行/列数。
更为合理的解决方案是:存储的时候按照「数组」的形式进行存储(行式存储),然后读取的时候计算偏移量直接读取其「左上角」或者「右下角」的值。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.761` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/768. 最多能完成排序的块 II（困难）.md | 768. 最多能完成排序的块 II | https://leetcode.cn/problems/max-chunks-to-make-sorted-ii/solution/by-ac_oier-z4wt/ | 困难 | [
"贪心"
] | 这个问题和“最多能完成排序的块”相似,但给定数组中的元素可以重复,输入数组最大长度为$2000$,其中的元素最大为 $10^8$。
`arr` 是一个可能包含重复元素的整数数组,我们将这个数组分割成几个“块”,并将这些块分别进行排序。之后再连接起来,使得连接的结果和按升序排序后的原数组相同。
我们最多能将数组分成多少块?
示例 1:
```
输入: arr = [5,4,3,2,1]
输出: 1
解释:
将数组分成2块或者更多块,都无法得到所需的结果。
例如,分成 [5, 4], [3, 2, 1] 的结果是 [4, 5, 1, 2, 3],这不是有序的数组。
```
示例 2:
```
输入: arr = [2,1,3,4,4]
输出: 4
解释:
我们可以把它分成两块,例如 [2, 1], [3, 4, 4]。
然而,分成 [2, 1], [3], [4], [4] 可以得到最多的块数。
```
注意:
* `arr` 的长度在 $[1, 2000]$ 之间。
* `arr[i]` 的大小在 $[0, 10^8]$ 之间。 | ### 贪心 + 构造
一种容易想到的构造方法,是与目标序列(已排升序的数组 `clone`)做区间比较。
由于题目要求尽可能划分出多的区间,我们可以从前往后处理 `arr` 和 `clone` 时统计区间内数的情况,若有 `arr[i...j]` 和 `clone[i...j]` 词频完全相同,可知 `arr[i...j]` 可通过内部排序调整为 `clone[i...j]`,此时我们将范围 $[i...j]$ 划分为一个区间,然后继续往后处理直到整个数组处理完。
容易证明该做法的正确性:可从边界开始进行归纳分析,起始两者均从下标为 $0$ 的位置进行扫描。假设最优解和贪心解的第一个区间的结束位置相同,问题就会归结到子问题上(即双方均从相同的子数组起始位置开始构造),因此无须额外证明;而当起始位置相同,结束位置不同时,假设分别为 $clone[i...j_1]$ 和 $arr[i...j_2]$,则必然有 $j_1 > j_2$(因为如果有 $j_1 < j_2$,那么在 $arr$ 扫描到 $j_1$ 位置时已经满足划分区间的条件,已经会停下来,即与贪心决策逻辑冲突),而当 $j_1 > j_2$ 时,我们可以将最优解中的区间 $clone[i...j_1]$ 进一步划分为 $clone[i...j_2]$ 和 $clone[j_2+1 ... j_1]$ 两段,同时不影响后续的构造过程,使得最终划分的区间数增大,即与最优解本身无法划分冲突。
根据数值之间满足严格全序,可知当 $j_1 > j_2$ 和 $j_1 < j_2$ 均不满足时,必然有 $j_1 = j_2$ 为真。
综上,我们证明了对于相同起点,贪心解与最优解结束位置必然相同,从而证明贪心解区间数与最优解相等。
于是原问题转换为如何快速对两数组(原数组 `arr` 和目标数组 `clone`)进行词频比较,由于数值的范围为 $10^8$,如果使用最裸的词频对比方案的话,需要先进行离散化,最终算法的复杂度为 $O(n\log{n} + n^2)$。而更好的解决方案是使用哈希表进行计数,同时维护当前计数不为 $0$ 的数值数量 `tot`,具体的,当我们处理 $arr[i]$ 时,我们在哈希表中对 $arr[i]$ 进行计数加一,而在处理 $clone[i]$ 时,对 $clone[i]$ 进行计数减一。从而将词频比较的复杂度从 $O(n^2)$ 下降到 $O(n)$。
Java 代码:
```Java
class Solution {
public int maxChunksToSorted(int[] arr) {
int[] clone = arr.clone();
Arrays.sort(clone);
int n = arr.length, ans = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0, tot = 0; i < n; i++) {
int a = arr[i], b = clone[i];
if (map.getOrDefault(a, 0) == -1) tot--;
else if (map.getOrDefault(a, 0) == 0) tot++;
map.put(a, map.getOrDefault(a, 0) + 1);
if (map.getOrDefault(b, 0) == 1) tot--;
else if (map.getOrDefault(b, 0) == 0) tot++;
map.put(b, map.getOrDefault(b, 0) - 1);
if (tot == 0) ans++;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function maxChunksToSorted(arr: number[]): number {
let clone = [...arr].sort((a,b)=>a-b)
let n = arr.length, ans = 0
const map = new Map<number, number>()
for (let i = 0, tot = 0; i < n; i++) {
const a = arr[i], b = clone[i]
if (!map.has(a)) map.set(a, 0)
if (map.get(a) == 0) tot++
else if (map.get(a) == -1) tot--;
map.set(a, map.get(a) + 1)
if (!map.has(b)) map.set(b, 0)
if (map.get(b) == 0) tot++
else if (map.get(b) == 1) tot--
map.set(b, map.get(b) - 1)
if (tot == 0) ans++
}
return ans
};
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.768` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/761-770/769. 最多能完成排序的块（中等）.md | 769. 最多能完成排序的块 | https://leetcode.cn/problems/max-chunks-to-make-sorted/solution/by-ac_oier-4uny/ | 中等 | [
"模拟"
] | 给定一个长度为 `n` 的整数数组 `arr` ,它表示在 $[0, n - 1]$ 范围内的整数的排列。
我们将 `arr` 分割成若干块 (即分区),并对每个块单独排序。
将它们连接起来后,使得连接的结果和按升序排序后的原数组相同。
返回数组能分成的最多块数量。
示例 1:
```
输入: arr = [4,3,2,1,0]
输出: 1
解释:
将数组分成2块或者更多块,都无法得到所需的结果。
例如,分成 [4, 3], [2, 1, 0] 的结果是 [3, 4, 0, 1, 2],这不是有序的数组。
```
示例 2:
```
输入: arr = [1,0,2,3,4]
输出: 4
解释:
我们可以把它分成两块,例如 [1, 0], [2, 3, 4]。
然而,分成 [1, 0], [2], [3], [4] 可以得到最多的块数。
```
提示:
* $n = arr.length$
* $1 <= n <= 10$
* $0 <= arr[i] < n$
* `arr` 中每个元素都不同 | ### 模拟
本题考察的是简单模拟能力,或者说是简单的对「循环不变量」的设计。
我们从前往后处理所有的 $arr[i]$(即 `i` 定义为当前划分块的右边界下标),处理过程中定义变量 `j` 为当前划分块的左边界下标(初始值为 $0$),定义 `min` 为当前划分块中元素最小值(初始值为 $arr[0]$ 或 $n$),定义 `max` 为当前划分块中元素最大值(初始值为 $arr[0]$ 或 $-1$)。
当且仅当 $j = min$ 且 $i = max$ 时,下标范围 $[j, i]$ 排序结果为 $[min, max]$,此时块的个数加一,并重新初始化几个变量,继续循环统计下个块的信息。
Java 代码:
```Java
class Solution {
public int maxChunksToSorted(int[] arr) {
int n = arr.length, ans = 0;
for (int i = 0, j = 0, min = n, max = -1; i < n; i++) {
min = Math.min(min, arr[i]);
max = Math.max(max, arr[i]);
if (j == min && i == max) {
ans++; j = i + 1; min = n; max = -1;
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxChunksToSorted(vector<int>& arr) {
int n = arr.size(), ans = 0;
int j = 0, minv = n, maxv = -1;
for (int i = 0; i < n; i++) {
minv = min(minv, arr[i]);
maxv = max(maxv, arr[i]);
if (j == minv && i == maxv) {
ans++; j = i + 1; minv = n; maxv = -1;
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maxChunksToSorted(self, arr: List[int]) -> int:
n, ans = len(arr), 0
j, minv, maxv = 0, n, -1
for i in range(n):
minv, maxv = min(minv, arr[i]), max(maxv, arr[i])
if j == minv and i == maxv:
ans, j, minv, maxv = ans + 1, i + 1, n, -1
return ans
```
TypeScript 代码:
```TypeScript
function maxChunksToSorted(arr: number[]): number {
let n = arr.length, ans = 0
for (let i = 0, j = 0, min = n, max = -1; i < n; i++) {
min = Math.min(min, arr[i])
max = Math.max(max, arr[i])
if (j == min && i == max) {
ans++; j = i + 1; min = n; max = -1;
}
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.769` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/773. 滑动谜题（困难）.md | 773. 滑动谜题 | https://leetcode-cn.com/problems/sliding-puzzle/solution/gong-shui-san-xie-fa-hui-a-suan-fa-zui-d-3go8/ | 困难 | [
"BFS",
"最小步数",
"AStar 算法",
"启发式搜索"
] | 在一个 `2 x 3` 的板上(`board`)有 $5$ 块砖瓦,用数字 `1~5` 来表示, 以及一块空缺用 $0$ 来表示.
一次移动定义为选择 $0$ 与一个相邻的数字(上下左右)进行交换.
最终当板 `board` 的结果是 $[[1,2,3],[4,5,0]]$ 谜板被解开。
给出一个谜板的初始状态,返回最少可以通过多少次移动解开谜板,如果不能解开谜板,则返回 $-1$ 。
示例 1:
```
输入:board = [[1,2,3],[4,0,5]]
输出:1
解释:交换 0 和 5 ,1 步完成
```
示例 2:
```
输入:board = [[1,2,3],[5,4,0]]
输出:-1
解释:没有办法完成谜板
```
示例 3:
```
输入:board = [[4,1,2],[5,0,3]]
输出:5
解释:
最少完成谜板的最少移动次数是 5 ,
一种移动路径:
尚未移动: [[4,1,2],[5,0,3]]
移动 1 次: [[4,1,2],[0,5,3]]
移动 2 次: [[0,1,2],[4,5,3]]
移动 3 次: [[1,0,2],[4,5,3]]
移动 4 次: [[1,2,0],[4,5,3]]
移动 5 次: [[1,2,3],[4,5,0]]
```
示例 4:
```
输入:board = [[3,2,4],[1,5,0]]
输出:14
```
提示:
* `board` 是一个如上所述的 `2 x 3` 的数组.
* `board[i][j]` 是一个 $[0, 1, 2, 3, 4, 5]$ 的排列. | ### 基本分析
这是八数码问题的简化版:将 $3 * 3$ 变为 $2 * 3$,同时将「输出路径」变为「求最小步数」。
通常此类问题可以使用「BFS」、「AStar 算法」、「康拓展开」进行求解。
由于问题简化到了 $2 * 3$,我们使用前两种解法即可。
---
### BFS
为了方便,将原来的二维矩阵转成字符串(一维矩阵)进行处理。
这样带来的好处直接可以作为哈希 `Key` 使用,也可以很方便进行「二维坐标」与「一维下标」的转换。
由于固定是 $2 * 3$ 的格子,因此任意的合法二维坐标 $(x, y)$ 和对应一维下标 $idx$ 可通过以下转换:
* $idx = x * 3 + y$
* $x = idx / 3,y = idx \% 3$
其余的就是常规的 `BFS` 过程了。
代码:
```Java
class Solution {
class Node {
String str;
int x, y;
Node(String _str, int _x, int _y) {
str = _str; x = _x; y = _y;
}
}
int n = 2, m = 3;
String s, e;
int x, y;
public int slidingPuzzle(int[][] board) {
s = "";
e = "123450";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
s += board[i][j];
if (board[i][j] == 0) {
x = i; y = j;
}
}
}
int ans = bfs();
return ans;
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
int bfs() {
Deque<Node> d = new ArrayDeque<>();
Map<String, Integer> map = new HashMap<>();
Node root = new Node(s, x, y);
d.addLast(root);
map.put(s, 0);
while (!d.isEmpty()) {
Node poll = d.pollFirst();
int step = map.get(poll.str);
if (poll.str.equals(e)) return step;
int dx = poll.x, dy = poll.y;
for (int[] di : dirs) {
int nx = dx + di[0], ny = dy + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
String nStr = update(poll.str, dx, dy, nx, ny);
if (map.containsKey(nStr)) continue;
Node next = new Node(nStr, nx, ny);
d.addLast(next);
map.put(nStr, step + 1);
}
}
return -1;
}
String update(String cur, int i, int j, int p, int q) {
char[] cs = cur.toCharArray();
char tmp = cs[i * m + j];
cs[i * m + j] = cs[p * m + q];
cs[p * m + q] = tmp;
return String.valueOf(cs);
}
}
```
---
### AStar 算法
可以直接根据本题规则来设计 AStar 算法的「启发式函数」。
比如对于两个状态 `a` 和 `b` 可直接计算出「理论最小转换次数」:**所有位置的数值「所在位置」与「目标位置」的曼哈顿距离之和(即横纵坐标绝对值之和)** 。
注意,我们只需要计算「非空格」位置的曼哈顿距离即可,因为空格的位置会由其余数字占掉哪些位置而唯一确定。
**AStar 求最短路的正确性问题:由于我们衡量某个状态 `str` 的估值是以目标字符串 `e=123450` 为基准,因此我们只能确保 `e` 出队时为「距离最短」,而不能确保中间节点出队时「距离最短」,因此我们不能单纯根据某个节点是否「曾经入队」而决定是否入队,还要结合当前节点的「最小距离」是否被更新而决定是否入队。**
这一点十分关键,在代码层面上体现在 `map.get(nStr) > step + 1` 的判断上。
**我们知道,AStar 算法在有解的情况下,才会发挥「启发式搜索」的最大价值,因此如果我们能够提前判断无解的情况,对 AStar 算法来说会是巨大的提升。**
而对于通用的 $N * N$ 数码问题,判定有解的一个充要条件是:**「逆序对」数量为偶数,如果不满足,必然无解,直接返回 $-1$ 即可。**
对该结论的充分性证明和必要性证明完全不在一个难度上,所以建议记住这个结论即可。
代码:
```Java
class Solution {
class Node {
String str;
int x, y;
int val;
Node(String _str, int _x, int _y, int _val) {
str = _str; x = _x; y = _y; val = _val;
}
}
int f(String str) {
int ans = 0;
char[] cs1 = str.toCharArray(), cs2 = e.toCharArray();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// 跳过「空格」,计算其余数值的曼哈顿距离
if (cs1[i * m + j] == '0' || cs2[i * m + j] == '0') continue;
int cur = cs1[i * m + j], next = cs2[i * m + j];
int xd = Math.abs((cur - 1) / 3 - (next - 1) / 3);
int yd = Math.abs((cur - 1) % 3 - (next - 1) % 3);
ans += (xd + yd);
}
}
return ans;
}
int n = 2, m = 3;
String s, e;
int x, y;
public int slidingPuzzle(int[][] board) {
s = "";
e = "123450";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
s += board[i][j];
if (board[i][j] == 0) {
x = i; y = j;
}
}
}
// 提前判断无解情况
if (!check(s)) return -1;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
Node root = new Node(s, x, y, f(s));
PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);
Map<String, Integer> map = new HashMap<>();
q.add(root);
map.put(s, 0);
while (!q.isEmpty()) {
Node poll = q.poll();
int step = map.get(poll.str);
if (poll.str.equals(e)) return step;
int dx = poll.x, dy = poll.y;
for (int[] di : dirs) {
int nx = dx + di[0], ny = dy + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
String nStr = update(poll.str, dx, dy, nx, ny);
if (!map.containsKey(nStr) || map.get(nStr) > step + 1) {
Node next = new Node(nStr, nx, ny, step + 1 + f(nStr));
q.add(next);
map.put(nStr, step + 1);
}
}
}
return 0x3f3f3f3f; // never
}
String update(String cur, int i, int j, int p, int q) {
char[] cs = cur.toCharArray();
char tmp = cs[i * m + j];
cs[i * m + j] = cs[p * m + q];
cs[p * m + q] = tmp;
return String.valueOf(cs);
}
boolean check(String str) {
char[] cs = str.toCharArray();
List<Integer> list = new ArrayList<>();
for (int i = 0; i < n * m; i++) {
if (cs[i] != '0') list.add(cs[i] - '0');
}
int cnt = 0;
for (int i = 0; i < list.size(); i++) {
for (int j = i + 1; j < list.size(); j++) {
if (list.get(i) > list.get(j)) cnt++;
}
}
return cnt % 2 == 0;
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.773` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/775. 全局倒置与局部倒置（中等）.md | 775. 全局倒置与局部倒置 | https://leetcode.cn/problems/global-and-local-inversions/solution/by-ac_oier-jc7a/ | 中等 | [
"树状数组",
"数学"
] | 给你一个长度为 `n` 的整数数组 `nums`,表示由范围 $[0, n - 1]$ 内所有整数组成的一个排列。
全局倒置 的数目等于满足下述条件不同下标对 $(i, j)$ 的数目:
* $0 <= i < j < n$
* $nums[i] > nums[j]$
局部倒置 的数目等于满足下述条件的下标 i 的数目:
* $0 <= i < n - 1$
* $nums[i] > nums[i + 1]$
当数组 `nums` 中 全局倒置 的数量等于 局部倒置 的数量时,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:nums = [1,0,2]
输出:true
解释:有 1 个全局倒置,和 1 个局部倒置。
```
示例 2:
```
输入:nums = [1,2,0]
输出:false
解释:有 2 个全局倒置,和 1 个局部倒置。
```
提示:
* $n = nums.length$
* $1 <= n <= 10^5$
* $0 <= nums[i] < n$
* `nums` 中的所有整数 互不相同
* `nums` 是范围 $[0, n - 1]$ 内所有数字组成的一个排列 | ### 树状数组
根据题意,对于每个 $nums[i]$ 而言:
* 其左边比它大的 $nums[j]$ 的个数,是以 $nums[i]$ 为右端点的“全局倒置”数量,统计所有以 $nums[i]$ 为右端点的“全局倒置”数量即是总的“全局倒置”数量 `a`
* 同时我们可以将每个 $nums[i]$ 与前一个值进行比较,从而统计总的“局部倒置”数量 `b`,其中 $i$ 的取值范围为 $[1, n - 1)$
一个容易想到的做法是利用「树状数组」,虽然该做法没有利用到核心条件「$nums$ 是一个 $[0, n - 1]$ 的排列」,但根据数据范围 $n$ 可知该复杂度为 $O(n\log{n})$ 的做法可过,且依赖的条件更少,适用范围更广。
Java 代码:
```Java
class Solution {
int n;
int[] tr;
int lowbit(int x) {
return x & -x;
}
void add(int x) {
for (int i = x; i <= n; i += lowbit(i)) tr[i]++;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
}
public boolean isIdealPermutation(int[] nums) {
n = nums.length;
tr = new int[n + 10];
add(nums[0] + 1);
int a = 0, b = 0;
for (int i = 1; i < n; i++) {
a += query(n) - query(nums[i] + 1);
b += nums[i] < nums[i - 1] ? 1 : 0;
add(nums[i] + 1);
}
return a == b;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int n;
vector<int> tr;
int lowbit(int x) {
return x & -x;
}
void add(int x) {
for (int i = x; i <= n; i += lowbit(i)) tr[i]++;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
}
bool isIdealPermutation(vector<int>& nums) {
n = nums.size();
tr.resize(n + 10);
add(nums[0] + 1);
long a = 0, b = 0;
for (int i = 1; i < n; i++) {
a += query(n) - query(nums[i] + 1);
b += nums[i] < nums[i - 1] ? 1 : 0;
add(nums[i] + 1);
}
return a == b;
}
};
```
Python 代码:
```Python
class Solution:
def lowbit(self, x):
return x & -x
def add(self, tr, x, n):
i = x
while i <= n:
tr[i] += 1
i += self.lowbit(i)
def query(self, tr, x):
i, ans = x, 0
while i > 0:
ans += tr[i]
i -= self.lowbit(i)
return ans
def isIdealPermutation(self, nums: List[int]) -> bool:
n = len(nums)
tr = [0] * (n + 10)
self.add(tr, nums[0] + 1, n)
a, b = 0, 0
for i in range(1, n):
a += self.query(tr, n) - self.query(tr, nums[i] + 1)
b += nums[i] < nums[i - 1]
self.add(tr, nums[i] + 1, n)
return a == b
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 数学
解法一中并没有利用到核心条件「$nums$ 是一个 $[0, n - 1]$ 的排列」,我们可以从该条件以及两类倒置的定义出发进行分析。
#### 提示一:由“局部倒置”组成的集合为由“全局倒置”组成的集合的子集
任意一个“局部倒置”均满足“全局倒置”的定义,因此要判定两者数量是否相同,可转换为统计是否存在「不满足“局部倒置”定义的“全局倒置”」。
#### 提示二:何为不满足“局部倒置”定义的“全局倒置”
结合题意,若存在坐标 $j$ 和 $i$,满足 $nums[j] > nums[i]$ 且 $j + 1 < i$,那么该倒置满足“全局倒置”定义,且不满足“局部倒置”定义。
若存在这样的逆序对,不满足,则有两类倒置数量不同。
#### 提示三:考虑「如何构造」或「如何避免构造」不满足“全局倒置”定义的“局部倒置”
如果我们能够总结出「如何构造」或「如何避免构造」一个不满足“全局倒置”定义的“局部倒置” 所需的条件,问题可以转换为检查 `nums` 是否满足这样的条件,来得知 `nums` 是否存在不满足“全局倒置”定义的“局部倒置”。
我们可以结合「$nums$ 是一个 $[0, n - 1]$ 的排列」来分析,若需要避免所有 $nums[j] > nums[i]$ 的逆序对均不满足 $j + 1 < i$,只能是所有逆序对均由相邻数值产生。
Java 代码:
```Java
class Solution {
public boolean isIdealPermutation(int[] nums) {
for (int i = 0; i < nums.length; i++) {
if (Math.abs(nums[i] - i) >= 2) return false;
}
return true;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool isIdealPermutation(vector<int>& nums) {
for (int i = 0; i < nums.size(); ++i) {
if (abs(nums[i] - i) >= 2) return false;
}
return true;
}
};
```
Python 代码:
```Python
class Solution:
def isIdealPermutation(self, nums: List[int]) -> bool:
for i in range(len(nums)):
if abs(nums[i] - i) >= 2:
return False
return True
```
TypeScript 代码:
```TypeScript
function isIdealPermutation(nums: number[]): boolean {
for (let i = 0; i < nums.length; i++) {
if (Math.abs(nums[i] - i) >= 2) return false;
}
return true;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.775` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/777. 在LR字符串中交换相邻字符（中等）.md | 777. 在LR字符串中交换相邻字符 | https://leetcode.cn/problems/swap-adjacent-in-lr-string/solutions/1863778/by-ac_oier-ye71/ | 中等 | [
"双指针"
] | 在一个由 `'L'` ,`'R'` 和 `'X'` 三个字符组成的字符串(例如 `"RXXLRXRXL"`)中进行移动操作。
一次移动操作指用一个 `"LX"` 替换一个 `"XL"`,或者用一个 `"XR"` 替换一个 `"RX"`。
现给定起始字符串 `start` 和结束字符串 `end`,请编写代码,当且仅当存在一系列移动操作使得 `start` 可以转换成 `end` 时, 返回 `True`。
示例 :
```
输入: start = "RXXLRXRXL", end = "XRLXXRRLX"
输出: True
解释:
我们可以通过以下几步将start转换成end:
RXXLRXRXL ->
XRXLRXRXL ->
XRLXRXRXL ->
XRLXXRRXL ->
XRLXXRRLX
```
提示:
* $1 <= len(start) = len(end) <= 10000$
* `start` 和 `end` 中的字符串仅限于 `'L'`, `'R'` 和 `'X'` | ### 双指针
根据题意,我们每次移动要么是将 `XL` 变为 `LX`,要么是将 `RX` 变为 `XR`,而该两者操作可分别看做将 `L` 越过多个 `X` 向左移动,将 `R` 越过多个 `X` 向右移动。
因此在 `start` 和 `end` 中序号相同的 `L` 和 `R` 必然满足坐标性质:
1. 序号相同的 `L` : `start` 的下标不小于 `end` 的下标(即 `L` 不能往右移动)
2. 序号相同的 `R` : `start` 的下标不大于 `end` 的下标(即 `R` 不能往左移动)
其中「序号」是指在 `LR` 字符串中出现的相对顺序。
Java 代码:
```Java
class Solution {
public boolean canTransform(String start, String end) {
int n = start.length(), i = 0, j = 0;
while (i < n || j < n) {
while (i < n && start.charAt(i) == 'X') i++;
while (j < n && end.charAt(j) == 'X') j++;
if (i == n || j == n) return i == j;
if (start.charAt(i) != end.charAt(j)) return false;
if (start.charAt(i) == 'L' && i < j) return false;
if (start.charAt(i) == 'R' && i > j) return false;
i++; j++;
}
return i == j;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool canTransform(string start, string end) {
int n = start.size();
int i = 0, j = 0;
while (i < n || j < n) {
while (i < n && start[i] == 'X') i++;
while (j < n && end[j] == 'X') j++;
if (i == n || j == n) return i == j;
if (start[i] != end[j]) return false;
if (start[i] == 'L' && i < j) return false;
if (start[i] == 'R' && i > j) return false;
i++; j++;
}
return i == j;
}
};
```
Python 代码:
```Python
class Solution:
def canTransform(self, start: str, end: str) -> bool:
i, j, n = 0, 0, len(start)
while i < n or j < n:
while i < n and start[i] == 'X': i += 1
while j < n and end[j] == 'X': j += 1
if i == n or j == n: return i == j
if start[i] != end[j]: return False
if start[i] == 'L' and i < j: return False
if start[i] == 'R' and i > j: return False
i, j = i + 1, j + 1
return i == j
```
TypeScript 代码:
```TypeScript
function canTransform(start: string, end: string): boolean {
let n = start.length;
let i = 0, j = 0;
while (i < n || j < n) {
while (i < n && start.charAt(i) === 'X') i++;
while (j < n && end.charAt(j) === 'X') j++;
if (i === n || j === n) return i === j;
if (start.charAt(i) !== end.charAt(j)) return false;
if (start.charAt(i) === 'L' && i < j) return false;
if (start.charAt(i) === 'R' && i > j) return false;
i++; j++;
}
return i === j;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.777` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/778. 水位上升的泳池中游泳（困难）.md | 778. 水位上升的泳池中游泳 | https://leetcode-cn.com/problems/swim-in-rising-water/solution/gong-shui-san-xie-yi-ti-shuang-jie-krusk-7c6o/ | 困难 | [
"最小生成树",
"并查集",
"Kruskal",
"二分",
"BFS"
] | 在一个 `N x N` 的坐标方格 `grid` 中,每一个方格的值 $grid[i][j]$ 表示在位置 $(i,j)$ 的平台高度。
现在开始下雨了。当时间为 $t$ 时,此时雨水导致水池中任意位置的水位为 $t$ 。
你可以从一个平台游向四周相邻的任意一个平台,但是前提是此时水位必须同时淹没这两个平台。
假定你可以瞬间移动无限距离,也就是默认在方格内部游动是不耗时的。
当然,在你游泳的时候你必须待在坐标方格里面。
你从坐标方格的左上平台 $(0, 0)$ 出发,最少耗时多久你才能到达坐标方格的右下平台 $(N-1,N-1)$?
示例 1:
```
输入: [[0,2],[1,3]]
输出: 3
解释:
时间为0时,你位于坐标方格的位置为 (0, 0)。
此时你不能游向任意方向,因为四个相邻方向平台的高度都大于当前时间为 0 时的水位。
等时间到达 3 时,你才可以游向平台 (1, 1). 因为此时的水位是 3,坐标方格中的平台没有比水位 3 更高的,所以你可以游向坐标方格中的任意位置
```
示例2:
```
输入: [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
输出: 16
解释:
0 1 2 3 4
5
12 13 14 15 16
11
10 9 8 7 6
```
提示:
* 2 <= N <= 50.
* grid[i][j] 是 `[0, ..., N*N - 1]` 的排列。 | ### Kruskal
由于在任意点可以往任意方向移动,所以相邻的点(四个方向)之间存在一条无向边。
边的权重 $w$ 是指两点节点中的最大高度。
按照题意,我们需要找的是从左上角点到右下角点的最优路径,其中最优路径是指**途径的边的最大权重值最小**,然后输入最优路径中的最大权重值。
我们可以先遍历所有的点,将所有的边加入集合,存储的格式为数组 $[a, b, w]$ ,代表编号为 $a$ 的点和编号为 $b$ 的点之间的权重为 $w$(按照题意,$w$ 为两者的最大高度)。
对集合进行排序,按照 $w$ 进行从小到达排序。
当我们有了所有排好序的候选边集合之后,我们可以对边从前往后处理,每次加入一条边之后,使用并查集来查询左上角的点和右下角的点是否连通。
当我们的合并了某条边之后,判定左上角和右下角的点联通,那么该边的权重即是答案。
这道题和前天的 [1631. 最小体力消耗路径](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486139&idx=1&sn=37083315de3c6a7e1b675e0363ee7d98&chksm=fd9ca1a4caeb28b220eba888ebc773b460d41123a1042e3b01cfd2001ddfb487ff2a3959f3b9&token=990510480&lang=zh_CN#rd) 几乎是完全一样的思路。
你甚至可以将那题的代码拷贝过来,改一下对于 $w$ 的定义即可。
代码:
```Java
class Solution {
int n;
int[] p;
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];
}
public int swimInWater(int[][] grid) {
n = grid.length;
// 初始化并查集
p = new int[n * n];
for (int i = 0; i < n * n; i++) p[i] = i;
// 预处理出所有的边
// edge 存的是 [a, b, w]:代表从 a 到 b 所需要的时间为 w
// 虽然我们可以往四个方向移动,但是只要对于每个点都添加「向右」和「向下」两条边的话,其实就已经覆盖了所有边了
List<int[]> edges = new ArrayList<>();
for (int i = 0; i < n ;i++) {
for (int j = 0; j < n; j++) {
int idx = getIndex(i, j);
p[idx] = idx;
if (i + 1 < n) {
int a = idx, b = getIndex(i + 1, j);
int w = Math.max(grid[i][j], grid[i + 1][j]);
edges.add(new int[]{a, b, w});
}
if (j + 1 < n) {
int a = idx, b = getIndex(i, j + 1);
int w = Math.max(grid[i][j], grid[i][j + 1]);
edges.add(new int[]{a, b, w});
}
}
}
// 根据权值 w 升序
Collections.sort(edges, (a,b)->a[2]-b[2]);
// 从「小边」开始添加,当某一条边别应用之后,恰好使用得「起点」和「结点」联通
// 那么代表找到了「最短路径」中的「权重最大的边」
int start = getIndex(0, 0), end = getIndex(n - 1, n - 1);
for (int[] edge : edges) {
int a = edge[0], b = edge[1], w = edge[2];
union(a, b);
if (query(start, end)) {
return w;
}
}
return 0;
}
int getIndex(int i, int j) {
return i * n + j;
}
}
```
节点的数量为 $n * n$,无向边的数量严格为 $2 * n * (n - 1)$,数量级上为 $n^2$。
* 时间复杂度:获取所有的边复杂度为 $O(n^2)$,排序复杂度为 $O(n^2\log{n})$,遍历得到最终解复杂度为 $O(n^2)$。整体复杂度为 $O(n^2\log{n})$。
* 空间复杂度:使用了并查集数组。复杂度为 $O(n^2)$。
注意:假定 Collections.sort() 使用 Arrays.sort() 中的双轴快排实现。
---
### 二分 + BFS/DFS
在与本题类型的 [1631. 最小体力消耗路径](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486139&idx=1&sn=37083315de3c6a7e1b675e0363ee7d98&chksm=fd9ca1a4caeb28b220eba888ebc773b460d41123a1042e3b01cfd2001ddfb487ff2a3959f3b9&token=990510480&lang=zh_CN#rd)中,有同学问到是否可以用「二分」。
答案是可以的。
题目给定了 $grid[i][j]$ 的范围是 $[0, n^2 - 1]$,所以答案必然落在此范围。
假设最优解为 $min$ 的话(恰好能到达右下角的时间)。那么小于 $min$ 的时间无法到达右下角,大于 $min$ 的时间能到达右下角。
*因此在以最优解 $min$ 为分割点的数轴上具有两段性,可以通过「二分」来找到分割点 $min$。*
> 注意:「二分」的本质是两段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。其中 [33. 搜索旋转排序数组](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486020&idx=2&sn=9ada4b6e7eccecddbd8faa18f14c4eeb&chksm=fd9ca15bcaeb284d727905c174624e32b39b196e2337a2bfc791b22fcce35eb543b552031530&token=990510480&lang=zh_CN#rd) 是一个很好的说明例子。
接着分析,假设最优解为 $min$,我们在 $[l, r]$ 范围内进行二分,当前二分到的时间为 $mid$ 时:
1. 能到达右下角:必然有 $min \leqslant mid$,让 $r = mid$
2. 不能到达右下角:必然有 $min > mid$,让 $l = mid + 1$
**当确定了「二分」逻辑之后,我们需要考虑如何写 $check$ 函数。**
显然 $check$ 应该是一个判断给定 时间/步数 能否从「起点」到「终点」的函数。
我们只需要按照规则走特定步数,边走边检查是否到达终点即可。
实现 $check$ 既可以使用 DFS 也可以使用 BFS。两者思路类似,这里就只以 BFS 为例。
代码:
```Java
class Solution {
int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};
public int swimInWater(int[][] grid) {
int n = grid.length;
int l = 0, r = n * n;
while (l < r) {
int mid = l + r >> 1;
if (check(grid, mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return r;
}
boolean check(int[][] grid, int time) {
int n = grid.length;
boolean[][] visited = new boolean[n][n];
Deque<int[]> queue = new ArrayDeque<>();
queue.addLast(new int[]{0, 0});
visited[0][0] = true;
while (!queue.isEmpty()) {
int[] pos = queue.pollFirst();
int x = pos[0], y = pos[1];
if (x == n - 1 && y == n - 1) return true;
for (int[] dir : dirs) {
int newX = x + dir[0], newY = y + dir[1];
int[] to = new int[]{newX, newY};
if (inArea(n, newX, newY) && !visited[newX][newY] && canMove(grid, pos, to, time)) {
visited[newX][newY] = true;
queue.addLast(to);
}
}
}
return false;
}
boolean inArea(int n, int x, int y) {
return x >= 0 && x < n && y >= 0 && y < n;
}
boolean canMove(int[][] grid, int[] from, int[] to, int time) {
return time >= Math.max(grid[from[0]][from[1]], grid[to[0]][to[1]]);
}
}
```
* 时间复杂度:在 $[0, n^2]$ 范围内进行二分,复杂度为 $O(\log{n})$;每一次 BFS 最多有 $n^2$ 个节点入队,复杂度为 $O(n^2)$。整体复杂度为 $O({n^2}\log{n})$
* 空间复杂度:使用了 visited 数组。复杂度为 $O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.778` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/779. 第K个语法符号（中等）.md | 779. 第K个语法符号 | https://leetcode.cn/problems/k-th-symbol-in-grammar/solution/by-ac_oier-fp2f/ | 中等 | [
"DFS",
"递归"
] | 我们构建了一个包含 `n` 行( 索引从 `1` 开始 )的表。首先在第一行我们写上一个 `0`。接下来的每一行,将前一行中的 `0` 替换为 `01`,`1` 替换为 `10`。
* 例如,对于 `n = 3`,第 `1` 行是 `0` ,第 `2` 行是 `01`,第 `3` 行是 `0110` 。
给定行数 `n` 和序数 `k`,返回第 `n` 行中第 `k` 个字符。( `k` 从索引 `1` 开始)
示例 1:
```
输入: n = 1, k = 1
输出: 0
解释: 第一行:0
```
示例 2:
```
输入: n = 2, k = 1
输出: 0
解释:
第一行: 0
第二行: 01
```
示例 3:
```
输入: n = 2, k = 2
输出: 1
解释:
第一行: 0
第二行: 01
```
提示:
* $1 <= n <= 30$
* $1 <= k <= 2^{n - 1}$ | ### 递归(倒推验证)
整理一下条件:首行为 `0`,每次用当前行拓展出下一行时,字符数量翻倍(将 `0` 拓展为 `01`,将 `1` 拓展为 `10`),且字符种类仍为 `01`。
要求我们输出第 $n$ 行第 $k$ 列的字符,我们可以通过「倒推验证」的方式来求解:假设第 $n$ 行第 $k$ 为 `1`,若能倒推出首行为 $0$,说明假设成立,返回 `1`,否则返回 `0`。
倒推验证可通过实现递归函数 `int dfs(int r, int c, int cur)` 来做,含义为当第 $r$ 行第 $c$ 列的字符为 $cur$ 时,首行首列字符为何值。同时实现该函数是容易的:
* 若「当前列 $c$ 为偶数且 $cur = 0$」或「当前列 $c$ 为奇数且 $cur = 1$」时,说明当前列所在的组为 `10`,由此可推出其是由上一行的 `1` 拓展而来,结合每次拓展新行字符数量翻倍的条件,可知是由第 $r - 1$ 行的第 $\left \lfloor \frac{c - 1}{2} \right \rfloor + 1$ 列的 `1` 拓展而来,递归处理;
* 否则,同理,必然是上一行(第 $r - 1$ 行)对应位置的 `0` 拓展而来,递归处理。
最终,当倒推到首行时,我们找到了递归出口,直接返回 `cur`。
Java 代码:
```Java
class Solution {
public int kthGrammar(int n, int k) {
return dfs(n, k, 1) == 0 ? 1 : 0;
}
int dfs(int r, int c, int cur) {
if (r == 1) return cur;
if ((c % 2 == 0 && cur == 0) || (c % 2 == 1 && cur == 1)) return dfs(r - 1, (c - 1) / 2 + 1, 1);
else return dfs(r - 1, (c - 1) / 2 + 1, 0);
}
}
```
TypeScript 代码:
```TypeScript
function kthGrammar(n: number, k: number): number {
function dfs(r: number, c: number, cur: number): number {
if (r == 1) return cur
if ((c % 2 == 0 && cur == 0) || (c % 2 == 1 && cur == 1)) return dfs(r - 1, Math.floor((c - 1) / 2) + 1, 1)
else return dfs(r - 1, Math.floor((c - 1) / 2) + 1, 0)
}
return dfs(n, k, 1) == 0 ? 1 : 0
}
```
Python 代码:
```Python
class Solution:
def kthGrammar(self, n: int, k: int) -> int:
def dfs(r, c, cur):
if r == 1:
return cur
if (c % 2 == 0 and cur == 0) or (c % 2 == 1 and cur == 1):
return dfs(r - 1, (c - 1) // 2 + 1, 1)
else:
return dfs(r - 1, (c - 1) // 2 + 1, 0)
return 1 if dfs(n, k, 1) == 0 else 0
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.779` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/771-780/780. 到达终点（困难）.md | 780. 到达终点 | https://leetcode-cn.com/problems/reaching-points/solution/by-ac_oier-hw11/ | 困难 | [
"数学"
] | 给定四个整数 `sx`,`sy`,`tx` 和 `ty`,如果通过一系列的转换可以从起点 $(sx, sy)$ 到达终点 $(tx, ty)$,则返回 `true`,否则返回 `false`。
从点 $(x, y)$ 可以转换到 $(x, x+y)$ 或者 $(x+y, y)$。
示例 1:
```
输入: sx = 1, sy = 1, tx = 3, ty = 5
输出: true
解释:
可以通过以下一系列转换从起点转换到终点:
(1, 1) -> (1, 2)
(1, 2) -> (3, 2)
(3, 2) -> (3, 5)
```
示例 2:
```
输入: sx = 1, sy = 1, tx = 2, ty = 2
输出: false
```
示例 3:
```
输入: sx = 1, sy = 1, tx = 1, ty = 1
输出: true
```
提示:
* $1 <= sx, sy, tx, ty <= 10^9$ | ### 数学
给定的 $(sx, sy)$ 的数据范围为 $[1, 10^9]$(即均为正整数),且每次转换,只能将另外一维的数值累加到当前维,因此对于每一维的数值而言,随着转换次数的进行,呈(非严格)递增趋势,再结合起始值为正整数,可知在转换过程中均不会出现负数。
**由此得知从 $(tx, ty)$ 到 $(sx, sy)$ 的转换过程唯一确定:总是取较大数减去较小数来进行反推(否则会出现负数)。**
但即使反向转换唯一确定,数据范围为 $10^9$,线性模拟仍会超时。
我们考虑将「相同操作的连续段转换动作」进行合并,在某次反向转换中,如果有 $tx < ty$,我们会将 $(tx, ty)$ 转换为 $(tx, ty - tx)$,若相减完仍有 $tx < ty - tx$,该操作会继续进行,得到 $(tx, ty - 2 * tx)$,直到不满足 $tx < ty - k * tx$,其中 $k$ 为转换次数。
即对于一般性的情况而言,$(tx, ty)$ 中的较大数会一直消减到「与较小数的余数」为止。
因此我们可以先使用 $O(\log{max(tx, ty)})$ 的复杂度将其消减到不超过 $(sx, sy)$ 为止。此时如果消减后的结果 $(tx, ty)$ 任一维度小于 $(sx, sy)$,必然不能进行转换,返回 `False`;如果任一维度相等(假定是 $x$ 维度),则检查另一维度($y$ 维度)的差值,能够由当前维度($x$ 维度)拼凑而来。
代码:
```Java
class Solution {
public boolean reachingPoints(int sx, int sy, int tx, int ty) {
while (sx < tx && sy < ty) {
if (tx < ty) ty %= tx;
else tx %= ty;
}
if (tx < sx || ty < sy) return false;
return sx == tx ? (ty - sy) % tx == 0 : (tx - sx) % ty == 0;
}
}
```
* 时间复杂度:$O(\log{\max(tx, ty)})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.780` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/781. 森林中的兔子（中等）.md | 781. 森林中的兔子 | https://leetcode-cn.com/problems/rabbits-in-forest/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-v17p5/ | 中等 | [
"贪心"
] | 森林中,每个兔子都有颜色。其中一些兔子(可能是全部)告诉你还有多少其他的兔子和自己有相同的颜色。我们将这些回答放在 `answers` 数组里。
返回森林中兔子的最少数量。
示例:
```
输入: answers = [1, 1, 2]
输出: 5
解释:
两只回答了 "1" 的兔子可能有相同的颜色,设为红色。
之后回答了 "2" 的兔子不会是红色,否则他们的回答会相互矛盾。
设回答了 "2" 的兔子为蓝色。
此外,森林中还应有另外 2 只蓝色兔子的回答没有包含在数组中。
因此森林中兔子的最少数量是 5: 3 只回答的和 2 只没有回答的。
输入: answers = [10, 10, 10]
输出: 11
输入: answers = []
输出: 0
```
说明:
* `answers` 的长度最大为 $1000$
* `answers[i]` 是在 $[0, 999]$ 范围内的整数。 | ### 基本分析
首先,兔子它不会说谎 (`・ω・ ́),因此我们可以得出以下结论:
* **同一颜色的兔子回答的数值必然是一样的**
* **但回答同样数值的,不一定就是同颜色兔子**
举个🌰,假如有 3 只白兔,每只白兔的回答必然都是 2(对应结论 1);但假如有兔子回答了数值 2,可能只是三只白兔,也可能是三只白兔和三只灰兔同时进行了回答(对应结论 2)。
**答案要我们求最少的兔子数量。**
不妨设有某种颜色的兔子 $m$ 只,它们回答的答案数值为 $cnt$,那么 $m$ 和 $cnt$ 满足什么关系?
显然两者关系为 $m = cnt + 1$。
但如果是在 $answers$ 数组里,回答 $cnt$ 的数量为 $t$ 的话呢?这时候我们需要分情况讨论:
* $t \leqslant cnt + 1$ : 为达到「最少的兔子数量」,我们可以假定这 $t$ 只兔子为同一颜色,这样能够满足题意,同时不会导致「额外」兔子数量增加(颜色数量最少)。
* $t > cnt + 1$ : 我们知道回答 $cnt$ 的兔子应该有 $cnt + 1$ 只。这时候说明有数量相同的不同颜色的兔子进行了回答。为达到「最少的兔子数量」,我们应当将 $t$ 分为若干种颜色,并尽可能让某一种颜色的兔子为 $cnt + 1$ 只,这样能够满足题意,同时不会导致「额外」兔子数量增加(颜色数量最少)。
**换句话说,我们应该让「同一颜色的兔子数量」尽量多,从而实现「总的兔子数量」最少。**
***
### 证明
我们来证明一下,为什么这样的贪心思路是对的:
基于上述分析,我们其实是在处理 $answers$ 数组中每一个 $cnt$ ,使得满足题意的前提下,数值 $cnt$ 带来的影响(总的兔子数量,或者说总的颜色数量)最小。
首先 $answers$ 中的每个数都会导致我们总的兔子数量增加,**因此我们应该「让 $answers$ 的数字尽可能变少」,也就是我们需要去抵消掉 $answers$ 中的一些数字。**
对于 $answers$ 中的某个 $cnt$ 而言(注意是某个 $cnt$,含义为一只兔子的回答),必然代表了有 $cnt + 1$ 只兔子,同时也代表了数值 $cnt$ 最多在 $answers$ 数组中出现 $cnt + 1$ 次(与其颜色相同的兔子都进行了回答)。
这时候我们可以从数组中移走 $cnt + 1$ 个数值 $cnt$(如果有的话)。
**当每次处理 $cnt$ 的时候,我们都执行这样的抵消操作。最后得到的 $answers$ 数值数量必然最少(而固定),抵消完成后的 $answers$ 中的每个 $cnt$ 对答案的影响也固定(增加 $cnt + 1$),从而实现「总的兔子数量」最少。**
**相反,如果不执行这样的操作的话,得到的 $answers$ 数值数量必然会更多,「总的兔子数量」也必然会更多,也必然不会比这样做法更优。**
***
### 模拟解法
按照上述思路,我们可以先对 $answers$ 进行排序,然后根据遍历到某个 $cnt$ 时,将其对答案的影响应用到 $ans$ 中(`ans += cnt + 1`),并将后面的 $cnt$ 个 $cnt$ 进行忽略。
代码:
```Java
class Solution {
public int numRabbits(int[] cs) {
Arrays.sort(cs);
int n = cs.length;
int ans = 0;
for (int i = 0; i < n; i++) {
int cnt = cs[i];
ans += cnt + 1;
// 跳过「数值 cnt」后面的 cnt 个「数值 cnt」
int k = cnt;
while (k-- > 0 && i + 1 < n && cs[i] == cs[i + 1]) i++;
}
return ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(1)$
***
### 统计分配
我们也可以先对所有出现过的数字进行统计,然后再对数值进行(颜色)分配。
代码:
```Java
class Solution {
int N = 1009;
int[] counts = new int[N];
public int numRabbits(int[] cs) {
// counts[x] = cnt 代表在 cs 中数值 x 的数量为 cnt
for (int i : cs) counts[i]++;
int ans = counts[0];
for (int i = 1; i < N; i++) {
int per = i + 1;
int cnt = counts[i];
int k = cnt / per;
if (k * per < cnt) k++;
ans += k * per;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 拓展
保持题目现有的条件不变,假定颜色相同的兔子至少有一只发声,问题改为「问兔子颜色数量可能有多少种」,又该如何求解呢? | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.781` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/782. 变为棋盘（困难）.md | 782. 变为棋盘 | https://leetcode.cn/problems/transform-to-chessboard/solution/by-ac_oier-vf1m/ | 困难 | [
"构造"
] | 一个 `n x n` 的二维网络 `board` 仅由 `0` 和 `1` 组成 。每次移动,你能任意交换两列或是两行的位置。
返回 将这个矩阵变为 “棋盘” 所需的最小移动次数 。如果不存在可行的变换,输出 `-1`。
“棋盘” 是指任意一格的上下左右四个方向的值均与本身不同的矩阵。
示例 1:
```
输入: board = [[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]
输出: 2
解释:一种可行的变换方式如下,从左到右:
第一次移动交换了第一列和第二列。
第二次移动交换了第二行和第三行。
```
示例 2:
```
输入: board = [[0, 1], [1, 0]]
输出: 0
解释: 注意左上角的格值为0时也是合法的棋盘,也是合法的棋盘.
```
示例 3:
```
输入: board = [[1, 0], [1, 0]]
输出: -1
解释: 任意的变换都不能使这个输入变为合法的棋盘。
```
提示:
* $n == board.length$
* $n == board[i].length$
* $2 <= n <= 30$
* `board[i][j]` 将只包含 `0`或 `1` | ### 构造分析
数据范围具有一定的迷惑性,但其并不是一个棋盘搜索问题。
我们需要考虑何种情况下无解,以及有解情况的最小步数。
在给定棋盘大小 $n$ 的前提下,所能构造的合法棋盘只有两种情况:首个格子为 $0$ 或首个格子为 $1$,即问题转化为能否构造出合法棋盘,以及构造哪种合法棋盘所用步数更小。
同时,**交换行和交换列均不会影响行的种类数量和列的种类数量**,因此我们可以得到第一个判断无解的条件:若起始棋盘的行/列种类数不为 $2$,必然无法构造出合法棋盘。
假设起始的行分别为 `r1` 和 `r2`,起始的列分别为 `c1` 和 `c2`。不难发现第二性质:**若能构成合法棋盘,`r1` 和 `r2` 中 $0$ 和 $1$ 的数量必然相等,`c1` 和 `c2` 中的 $0$ 和 $1$ 的数量必然相等**。
同时由于交换行和交换列具有对称性和独立性,我们可以先使用「交换列」来进行分析,交换列不会导致行种类发生变化,但会导致行的数值分布发生变化。
因此第二性质可拓展为:**`r1` 和 `r2` 对称位置为必然不同,`c1` 和 `c2` 对称位置必然不同,即两者异或结果为必然为 $(111...111)_2$,即为 `mask = (1 << n) - 1`,否则必然无解。**
若上述两性质满足,可能有解。
由于 `r1` 和 `r2` 及 `c1` 和 `c2` 对称位置必然不同,因此我们调整好 `r1` 后,`r2` 唯一确定(`c1` 和 `c2` 同理),同时构造其中一种间隔行为 `t` = $(...101)_2$,根据合法棋盘定义可知要么是将首行调整为 $t$,要么是将次行调整为 $t$。
我们设置函数 `int getCnt(int a, int b)` 计算将 `a` 变为 `b` 所需要的最小转换次数,两状态转换所需次数为不同位个数除以 $2$(一次交换可实现消除两个不同位)。
分别计算「将 `r1` 和 `r2` 转换为 `t` 所需步数」和「将 `c1` 和 `c2` 转换为 `t` 所需步数」,两者之和即为答案。
Java 代码:
```Java
class Solution {
int n = 0, INF = 0x3f3f3f3f;
int getCnt(int a, int b) {
return Integer.bitCount(a) != Integer.bitCount(b) ? INF : Integer.bitCount(a ^ b) / 2;
}
public int movesToChessboard(int[][] g) {
n = g.length;
int r1 = -1, r2 = -1, c1 = -1, c2 = -1, mask = (1 << n) - 1;
for (int i = 0; i < n; i++) {
int a = 0, b = 0;
for (int j = 0; j < n; j++) {
if (g[i][j] == 1) a += (1 << j);
if (g[j][i] == 1) b += (1 << j);
}
if (r1 == -1) r1 = a;
else if (r2 == -1 && a != r1) r2 = a;
if (c1 == -1) c1 = b;
else if (c2 == -1 && b != c1) c2 = b;
if (a != r1 && a != r2) return -1;
if (b != c1 && b != c2) return -1;
}
if (Integer.bitCount(r1) + Integer.bitCount(r2) != n) return -1;
if (Integer.bitCount(c1) + Integer.bitCount(c2) != n) return -1;
if ((r1 ^ r2) != mask || (c1 ^ c2) != mask) return -1;
int t = 0;
for (int i = 0; i < n; i += 2) t += (1 << i);
int ans = Math.min(getCnt(r1, t), getCnt(r2, t)) + Math.min(getCnt(c1, t), getCnt(c2, t));
return ans >= INF ? -1 : ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int n = 0, INF = 0x3f3f3f3f;
int getCnt(int a, int b) {
return __builtin_popcount(a) != __builtin_popcount(b) ? INF : (__builtin_popcount(a ^ b) / 2);
}
int movesToChessboard(vector<vector<int>>& g) {
n = g.size();
int r1 = -1, r2 = -1, c1 = -1, c2 = -1, mask = (1 << n) - 1;
for (int i = 0; i < n; i++) {
int a = 0, b = 0;
for (int j = 0; j < n; j++) {
if (g[i][j] == 1) a |= (1 << j);
if (g[j][i] == 1) b |= (1 << j);
}
if (r1 == -1) r1 = a;
else if (r2 == -1 && a != r1) r2 = a;
if (c1 == -1) c1 = b;
else if (c2 == -1 && b != c1) c2 = b;
if (a != r1 && a != r2) return -1;
if (b != c1 && b != c2) return -1;
}
if (__builtin_popcount(r1) + __builtin_popcount(r2) != n) return -1;
if (__builtin_popcount(c1) + __builtin_popcount(c2) != n) return -1;
if ((r1 ^ r2) != mask || (c1 ^ c2) != mask) return -1;
int t = 0;
for (int i = 0; i < n; i += 2) t |= (1 << i);
int ans = min(getCnt(r1, t), getCnt(r2, t)) + min(getCnt(c1, t), getCnt(c2, t));
return (ans >= INF) ? -1 : ans;
}
};
```
TypeScript 代码:
```TypeScript
let n: number = 0, INF = 0x3f3f3f3f
function bitCount(x: number): number {
let ans = 0
while (x != 0 && ++ans >= 0) x -= (x & -x)
return ans
}
function getCnt(a: number, b: number): number {
return bitCount(a) != bitCount(b) ? INF : bitCount(a ^ b) / 2
}
function movesToChessboard(g: number[][]): number {
n = g.length
let r1 = -1, r2 = -1, c1 = -1, c2 = -1, mask = (1 << n) - 1
for (let i = 0; i < n; i++) {
let a = 0, b = 0
for (let j = 0; j < n; j++) {
if (g[i][j] == 1) a += (1 << j)
if (g[j][i] == 1) b += (1 << j)
}
if (r1 == -1) r1 = a
else if (r2 == -1 && a != r1) r2 = a
if (c1 == -1) c1 = b
else if (c2 == -1 && b != c1) c2 = b
if (a != r1 && a != r2) return -1
if (b != c1 && b != c2) return -1
}
if (bitCount(r1) + bitCount(r2) != n) return -1
if (bitCount(c1) + bitCount(c2) != n) return -1
if ((r1 ^ r2) != mask || (c1 ^ c2) != mask) return -1
let t = 0
for (let i = 0; i < n; i += 2) t += (1 << i)
const ans = Math.min(getCnt(r1, t), getCnt(r2, t)) + Math.min(getCnt(c1, t), getCnt(c2, t))
return ans >= INF ? -1 : ans
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.782` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/783. 二叉搜索树节点最小距离（简单）.md | 783. 二叉搜索树节点最小距离 | https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/solution/gong-shui-san-xie-yi-ti-san-jie-shu-de-s-7r17/ | 简单 | [
"树的搜索",
"迭代",
"非迭代",
"中序遍历",
"BFS",
"DFS"
] | 给你一个二叉搜索树的根节点 root ,返回 树中任意两不同节点值之间的最小差值 。
注意:本题与 530:https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同
示例 1:
```
输入:root = [4,2,6,1,3]
输出:1
```
示例 2:
```
输入:root = [1,0,48,null,null,12,49]
输出:1
```
提示:
* 树中节点数目在范围 [2, 100] 内
* 0 <= Node.val <= $10^5$
* 差值是一个正数,其数值等于两值之差的绝对值 | ### 朴素解法(BFS & DFS)
如果不考虑利用二叉搜索树特性的话,一个朴素的做法是将所有节点的 $val$ 存到一个数组中。
对数组进行排序,并获取答案。
将所有节点的 $val$ 存入数组,可以使用 BFS 或者 DFS。
代码:
```java []
class Solution {
public int minDiffInBST(TreeNode root) {
List<Integer> list = new ArrayList<>();
// BFS
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode poll = d.pollFirst();
list.add(poll.val);
if (poll.left != null) d.addLast(poll.left);
if (poll.right != null) d.addLast(poll.right);
}
// DFS
// dfs(root, list);
Collections.sort(list);
int n = list.size();
int ans = Integer.MAX_VALUE;
for (int i = 1; i < n; i++) {
int cur = Math.abs(list.get(i) - list.get(i - 1));
ans = Math.min(ans, cur);
}
return ans;
}
void dfs(TreeNode root, List<Integer> list) {
list.add(root.val);
if (root.left != null) dfs(root.left, list);
if (root.right != null) dfs(root.right, list);
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
***
### 中序遍历(栈模拟 & 递归)
不难发现,在朴素解法中,我们对树进行搜索的目的是为了获取一个「有序序列」,然后从「有序序列」中获取答案。
而二叉搜索树的中序遍历是有序的,因此我们可以直接对「二叉搜索树」进行中序遍历,保存遍历过程中的相邻元素最小值即是答案。
代码:
```java []
class Solution {
int ans = Integer.MAX_VALUE;
TreeNode prev = null;
public int minDiffInBST(TreeNode root) {
// 栈模拟
Deque<TreeNode> d = new ArrayDeque<>();
while (root != null || !d.isEmpty()) {
while (root != null) {
d.addLast(root);
root = root.left;
}
root = d.pollLast();
if (prev != null) {
ans = Math.min(ans, Math.abs(prev.val - root.val));
}
prev = root;
root = root.right;
}
// 递归
// dfs(root);
return ans;
}
void dfs(TreeNode root) {
if (root == null) return;
dfs(root.left);
if (prev != null) {
ans = Math.min(ans, Math.abs(prev.val - root.val));
}
prev = root;
dfs(root.right);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.783` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/784. 字母大小写全排列（中等）.md | 784. 字母大小写全排列 | https://leetcode.cn/problems/letter-case-permutation/solution/by-ac_oier-x7f0/ | 中等 | [
"DFS",
"爆搜",
"二进制枚举"
] | 给定一个字符串 `s` ,通过将字符串 `s` 中的每个字母转变大小写,我们可以获得一个新的字符串。
返回 所有可能得到的字符串集合 。以 任意顺序 返回输出。
示例 1:
```
输入:s = "a1b2"
输出:["a1b2", "a1B2", "A1b2", "A1B2"]
```
示例 2:
```
输入: s = "3z4"
输出: ["3z4","3Z4"]
```
提示:
* $1 <= s.length <= 12$
* `s` 由小写英文字母、大写英文字母和数字组成 | ### DFS
数据范围为 $12$,同时要我们求所有具体方案,容易想到使用 `DFS` 进行「爆搜」。
我们可以从前往后考虑每个 $s[i]$,根据 $s[i]$ 是否为字母进行分情况讨论:
* 若 $s[i]$ 不是字母,直接保留
* 若 $s[i]$ 是字母,则有「保留原字母」或「进行大小写转换」两种决策
设计 `DFS` 函数为 `void dfs(int idx, int n, String cur)`:其中 $n$ 固定为具体方案的长度(即原字符串长度),而 `idx` 和 `cur` 分别为当前处理到哪一个 $s[idx]$,而 `cur` 则是当前具体方案。
根据上述分析可知,当 $s[idx]$ 不为字母,将其直接追加到 `cur` 上,并决策下一个位置 $idx + 1$;而当 $s[idx]$ 为字母时,我们可以选择将 $s[idx]$ 追加到 `cur` 上(保留原字母)或是将 $s[idx]$ 进行翻转后再追加到 `cur` 上(进行大小写转换)。
最后当我们满足 `idx = n` 时,说明已经对原字符串的每一位置决策完成,将当前具体方案 `cur` 加入答案。
> 一些细节:我们可以通过与 `32` 异或来进行大小写转换
Java 代码:
```Java
class Solution {
char[] cs;
List<String> ans = new ArrayList<>();
public List<String> letterCasePermutation(String s) {
cs = s.toCharArray();
dfs(0, s.length(), new char[s.length()]);
return ans;
}
void dfs(int idx, int n, char[] cur) {
if (idx == n) {
ans.add(String.valueOf(cur));
return ;
}
cur[idx] = cs[idx];
dfs(idx + 1, n, cur);
if (Character.isLetter(cs[idx])) {
cur[idx] = (char) (cs[idx] ^ 32);
dfs(idx + 1, n, cur);
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<string> ans;
string s;
void dfs(int idx, int n, string cur) {
if (idx == n) {
ans.push_back(cur);
return;
}
cur.push_back(s[idx]);
dfs(idx + 1, n, cur);
if (isalpha(s[idx])) {
cur[idx] = s[idx] ^ 32;
dfs(idx + 1, n, cur);
}
}
vector<string> letterCasePermutation(string s) {
this->s = s;
dfs(0, s.length(), "");
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def letterCasePermutation(self, s: str) -> List[str]:
ans = []
def dfs(idx, n, cur):
if idx == n:
ans.append(cur)
return
dfs(idx + 1, n, cur + s[idx])
if 'a' <= s[idx] <= 'z' or 'A' <= s[idx] <= 'Z':
dfs(idx + 1, n, cur + s[idx].swapcase())
dfs(0, len(s), '')
return ans
```
TypeScript 代码:
```TypeScript
function letterCasePermutation(s: string): string[] {
const ans = new Array<string>()
function dfs(idx: number, n: number, cur: string): void {
if (idx == n) {
ans.push(cur)
return
}
dfs(idx + 1, n, cur + s[idx])
if ((s[idx] >= 'a' && s[idx] <= 'z') || (s[idx] >= 'A' && s[idx] <= 'Z')) {
dfs(idx + 1, n, cur + String.fromCharCode(s.charCodeAt(idx) ^ 32))
}
}
dfs(0, s.length, "")
return ans
}
```
* 时间复杂度:最坏情况下原串 `s` 的每一位均为字母(均有保留和转换两种决策),此时具体方案数量共 $2^n$ 种;同时每一种具体方案我们都需要用与原串长度相同的复杂度来进行构造。复杂度为 $O(n \times 2^n)$
* 空间复杂度:$O(n \times 2^n)$
---
### 二进制枚举
根据解法一可知,具体方案的个数与字符串 `s1` 存在的字母个数相关,当 `s1` 存在 `m` 个字母时,由于每个字母存在两种决策,总的方案数个数为 $2^m$ 个。
因此可以使用「二进制枚举」的方式来做:使用变量 `s` 代表字符串 `s1` 的字母翻转状态,`s` 的取值范围为 `[0, 1 << m)`。若 `s` 的第 $j$ 位为 `0` 代表在 `s1` 中第 $j$ 个字母不进行翻转,而当为 `1` 时则代表翻转。
每一个状态 `s` 对应了一个具体方案,通过枚举所有翻转状态 `s`,可构造出所有具体方案。
Java 代码:
```Java
class Solution {
public List<String> letterCasePermutation(String str) {
List<String> ans = new ArrayList<String>();
int n = str.length(), m = 0;
for (int i = 0; i < n; i++) m += Character.isLetter(str.charAt(i)) ? 1 : 0;
for (int s = 0; s < (1 << m); s++) {
char[] cs = str.toCharArray();
for (int i = 0, j = 0; i < n; i++) {
if (!Character.isLetter(cs[i])) continue;
cs[i] = ((s >> j) & 1) == 1 ? (char) (cs[i] ^ 32) : cs[i];
j++;
}
ans.add(String.valueOf(cs));
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<string> letterCasePermutation(string str) {
vector<string> ans;
int n = str.length(), m = 0;
for (int i = 0; i < n; i++) m += isalpha(str[i]) ? 1 : 0;
for (int s = 0; s < (1 << m); s++) {
string cs = str;
for (int i = 0, j = 0; i < n; i++) {
if (!isalpha(cs[i])) continue;
cs[i] = ((s >> j) & 1) ? (cs[i] ^ 32) : cs[i];
j++;
}
ans.push_back(cs);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def letterCasePermutation(self, s1: str) -> List[str]:
def isLetter(ch):
return 'a' <= ch <= 'z' or 'A' <= ch <= 'Z'
ans = []
n, m = len(s1), len([ch for ch in s1 if isLetter(ch)])
for s in range(1 << m):
cur = ''
j = 0
for i in range(n):
if not isLetter(s1[i]) or not ((s >> j) & 1):
cur += s1[i]
else:
cur += s1[i].swapcase()
if isLetter(s1[i]):
j += 1
ans.append(cur)
return ans
```
TypeScript 代码:
```TypeScript
function letterCasePermutation(str: string): string[] {
function isLetter(ch: string): boolean {
return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
}
const ans = new Array<string>()
let n = str.length, m = 0
for (let i = 0; i < n; i++) m += isLetter(str[i]) ? 1 : 0
for (let s = 0; s < (1 << m); s++) {
let cur = ''
for (let i = 0, j = 0; i < n; i++) {
if (!isLetter(str[i]) || ((s >> j) & 1) == 0) cur += str[i]
else cur += String.fromCharCode(str.charCodeAt(i) ^ 32)
if (isLetter(str[i])) j++
}
ans.push(cur)
}
return ans
}
```
* 时间复杂度:最坏情况下原串 `s` 的每一位均为字母(均有保留和转换两种决策),此时具体方案数量共 $2^n$ 种;同时每一种具体方案我们都需要用与原串长度相同的复杂度来进行构造。复杂度为 $O(n \times 2^n)$
* 空间复杂度:$O(n \times 2^n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.784` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/786. 第 K 个最小的素数分数（中等）.md | 786. 第 K 个最小的素数分数 | https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-8ymk/ | 中等 | [
"优先队列(堆)",
"多路归并",
"二分",
"双指针"
] | 给你一个按递增顺序排序的数组 `arr` 和一个整数 `k` 。
数组 `arr` 由 $1$ 和若干 **素数** 组成,且其中所有整数互不相同。
对于每对满足 $0 < i < j < arr.length$ 的 $i$ 和 $j$ ,可以得到分数 $arr[i] / arr[j]$ 。
那么第 $k$ 个最小的分数是多少呢? 以长度为 $2$ 的整数数组返回你的答案, 这里 $answer[0] == arr[i]$ 且 $answer[1] == arr[j]$ 。
示例 1:
```
输入:arr = [1,2,3,5], k = 3
输出:[2,5]
解释:已构造好的分数,排序后如下所示:
1/5, 1/3, 2/5, 1/2, 3/5, 2/3
很明显第三个最小的分数是 2/5
```
示例 2:
```
输入:arr = [1,7], k = 1
输出:[1,7]
```
提示:
* $2 <= arr.length <= 1000$
* $1 <= arr[i] <= 3 \times 10^4$
* $arr[0] = 1$
* $arr[i]$ 是一个 素数 ,$i > 0$
* $arr$ 中的所有数字 互不相同 ,且按**严格递增**排序
* $1 <= k <= arr.length \times (arr.length - 1) / 2$ | ### 优先队列(堆)
数据范围只有 $10^3$,直接扫描所有点对的计算量不超过 $10^6$。
因此我们可以使用「扫描点对」+「优先队列(堆)」的做法,使用二元组 $(arr[i], arr[j])$ 进行存储,构建大小为 $k$ 的大根堆。
根据「堆内元素多少」和「当前计算值与堆顶元素的大小关系」决定入堆行为:
* 若堆内元素不足 $k$ 个,直接将当前二元组进行入堆;
* 若堆内元素已达 $k$ 个,根据「当前计算值 $\frac{arr[i]}{arr[j]}$ 与堆顶元素 $\frac{peek[0]}{peek[1]}$ 的大小关系」进行分情况讨论:
* 如果当前计算值比堆顶元素大,那么当前元素不可能是第 $k$ 小的值,直接丢弃;
* 如果当前计算值比堆顶元素小,那么堆顶元素不可能是第 $k$ 小的值,使用当前计算值置换掉堆顶元素。
代码:
```Java
class Solution {
public int[] kthSmallestPrimeFraction(int[] arr, int k) {
int n = arr.length;
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->Double.compare(b[0]*1.0/b[1],a[0]*1.0/a[1]));
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
double t = arr[i] * 1.0 / arr[j];
if (q.size() < k || q.peek()[0] * 1.0 / q.peek()[1] > t) {
if (q.size() == k) q.poll();
q.add(new int[]{arr[i], arr[j]});
}
}
}
return q.poll();
}
}
```
* 时间复杂度:扫描所有的点对复杂度为 $O(n^2)$;将二元组入堆和出堆的复杂度为 $O(\log{k})$。整体复杂度为 $O(n^2\log{k})$
* 空间复杂度:$O(k)$
---
### 多路归并
在解法一中,我们没有利用「数组内元素严格单调递增」的特性。
由于题目规定所有的点对 $(i, j)$ 必须满足 $i < j$,即给定 $arr[j]$ 后,其所能构建的分数个数为 $j$ 个,而这 $j$ 个分数值满足严格单调递增:$\frac{arr[0]}{arr[j]} < \frac{arr[1]}{arr[j]} < \frac{arr[2]}{arr[j]} < ... < \frac{arr[j - 1]}{arr[j]}$。
问题等价于我们从 $n - 1$ 个(下标 $0$ 作为分母的话,不存在任何分数)有序序列中找到第 $k$ 小的数值。这 $n - 1$ 个序列分别为:
* $[\frac{arr[0]}{arr[1]}]$
* $[\frac{arr[0]}{arr[2]}, \frac{arr[1]}{arr[2]}]$
* $[\frac{arr[0]}{arr[3]}, \frac{arr[1]}{arr[3]}, \frac{arr[2]}{arr[3]}]$
...
* $[\frac{arr[0]}{arr[j]}, \frac{arr[1]}{arr[j]}, \frac{arr[2]}{arr[j]}, ... , \frac{arr[j - 1]}{arr[j]}]$
问题彻底切换为「多路归并」问题,我们使用「优先队列(堆)」来维护多个有序序列的当前头部的最小值即可。
代码:
```Java
class Solution {
public int[] kthSmallestPrimeFraction(int[] arr, int k) {
int n = arr.length;
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{
double i1 = arr[a[0]] * 1.0 / arr[a[1]], i2 = arr[b[0]] * 1.0 / arr[b[1]];
return Double.compare(i1, i2);
});
for (int i = 1; i < n; i++) q.add(new int[]{0, i});
while (k-- > 1) {
int[] poll = q.poll();
int i = poll[0], j = poll[1];
if (i + 1 < j) q.add(new int[]{i + 1, j});
}
int[] poll = q.poll();
return new int[]{arr[poll[0]], arr[poll[1]]};
}
}
```
* 时间复杂度:起始将 $n - 1$ 个序列的头部元素放入堆中,复杂度为 $O(n\log{n})$;然后重复 $k$ 次操作得到第 $k$ 小的值,复杂度为 $O(k\log{n})$。整体复杂度为 $O(\max(n, k) \times \log{n})$
* 空间复杂度:$O(n)$
---
### 二分 + 双指针
进一步,利用 $arr$ 递增,且每个点对 $(i, j)$ 满足 $i < j$,我们可以确定 $(i, j)$ 对应的分数 $\frac{arr[i]}{arr[j]}$ 必然落在 $[0, 1]$ 范围内。
假设最终答案 $\frac{arr[i]}{arr[j]}$ 为 $x$,那么以 $x$ 为分割点的数轴(该数轴上的点为 $arr$ 所能构造的分数值)上具有「二段性」:
* 小于等于 $x$ 的值满足:其左边分数值个数小于 $k$ 个;
* 大于 $x$ 的值不满足:其左边分数值个数小于 $k$ 个(即至少有 $k$ 个)。
而当确定 $arr[j]$ 时,利用 $arr$ 有序,我们可以通过「双指针」快速得知,满足 $\frac{arr[i]}{arr[j]} <= x$ 的分子位置在哪(找到最近一个满足 $\frac{arr[i]}{arr[j]} > x$ 的位置)。
另外,我们可以在每次 `check` 的同时,记录下相应的 $arr[i]$ 和 $arr[j]$。
代码:
```Java
class Solution {
double eps = 1e-8;
int[] arr;
int n, a, b;
public int[] kthSmallestPrimeFraction(int[] _arr, int k) {
arr = _arr;
n = arr.length;
double l = 0, r = 1;
while (r - l > eps) {
double mid = (l + r) / 2;
if (check(mid) >= k) r = mid;
else l = mid;
}
return new int[]{a, b};
}
int check(double x){
int ans = 0;
for (int i = 0, j = 1; j < n; j++) {
while (arr[i + 1] * 1.0 / arr[j] <= x) i++;
if (arr[i] * 1.0 / arr[j] <= x) ans += i + 1;
if (Math.abs(arr[i] * 1.0 / arr[j] - x) < eps) {
a = arr[i]; b = arr[j];
}
}
return ans;
}
}
```
* 时间复杂度:二分次数取决于精度,精度为 $C = 10^8$,二分复杂度为 $O(\log{C});$`check` 的复杂度为 $O(n)$。整体复杂度为 $O(n\log{C})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.786` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/787. K 站中转内最便宜的航班（中等）.md | 787. K 站中转内最便宜的航班 | https://leetcode-cn.com/problems/cheapest-flights-within-k-stops/solution/gong-shui-san-xie-xiang-jie-bellman-ford-dc94/ | 中等 | [
"最短路",
"Bellman Ford"
] | 有 `n` 个城市通过一些航班连接。给你一个数组 `flights`,其中 $flights[i] = [from_i, to_i, price_i]$ ,表示该航班都从城市 $from_i$ 开始,以价格 $price_i$ 抵达 $to_i$。
现在给定所有的城市和航班,以及出发城市 `src` 和目的地 `dst`,你的任务是找到出一条最多经过 `k` 站中转的路线,使得从 `src` 到 `dst` 的 价格最便宜 ,并返回该价格。 如果不存在这样的路线,则输出 `-1`。
示例 1:
```
输入:
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
输出: 200
解释:
城市航班图如下
从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200,如图中红色所示。
```
示例 2:
```
输入:
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 0
输出: 500
解释:
城市航班图如下
从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500,如图中蓝色所示。
```
提示:
* 1 <= n <= 100
* 0 <= flights.length <= (n * (n - 1) / 2)
* flights[i].length == 3
* 0 <= fromi, toi < n
* fromi != toi
* 1 <= pricei <= $10^4$
* 航班没有重复,且不存在自环
* 0 <= src, dst, k < n
* src != dst | ### 基本分析
从题面看就能知道,这是一类「有限制」的最短路问题。
「限制最多经过不超过 $k$ 个点」等价于「限制最多不超过 $k + 1$ 条边」,而解决「有边数限制的最短路问题」是 SPFA 所不能取代 Bellman Ford 算法的经典应用之一(SPFA 能做,但不能直接做)。
**Bellman Ford/SPFA 都是基于动态规划,其原始的状态定义为 $f[i][k]$ 代表从起点到 $i$ 点,且经过最多 $k$ 条边的最短路径。这样的状态定义引导我们能够使用 Bellman Ford 来解决有边数限制的最短路问题。**
**同样多源汇最短路算法 Floyd 也是基于动态规划,其原始的三维状态定义为 $f[i][j][k]$ 代表从点 $i$ 到点 $j$,且经过的所有点编号不会超过 $k$(即可使用点编号范围为 $[1, k]$)的最短路径。这样的状态定义引导我们能够使用 Floyd 求最小环或者求“重心点”(即删除该点后,最短路值会变大)。**
如果你对几类最短算法不熟悉,可以看 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=754098973&lang=zh_CN#rd),里面涵盖所有的「最短路算法」和「存图方式」。
---
### Bellman Ford + 邻接矩阵
回到本题,「限制最多经过不超过 $k$ 个点」等价于「限制最多不超过 $k + 1$ 条边」,因此可以使用 Bellman Ford 来求解。
点的数量只有 $100$,可以直接使用「邻接矩阵」的方式进行存图。
> 需要注意的是,在遍历所有的“点对/边”进行松弛操作前,需要先对 $dist$ 进行备份,否则会出现「本次松弛操作所使用到的边,也是在同一次迭代所更新的」,从而不满足边数限制的要求。
举个 🌰,例如本次松弛操作使用了从 $a$ 到 $b$ 的当前最短距离来更新 $dist[b]$,直接使用 $dist[a]$ 的话,不能确保 $dist[a]$ 不是在同一次迭代中所更新,如果 $dist[a]$ 是同一次迭代所更新的话,那么使用的边数将会大于 $k$ 条。
因此在每次迭代开始前,我们都应该对 $dist$ 进行备份,在迭代时使用备份来进行松弛操作。
代码:
```Java
class Solution {
int N = 110, INF = 0x3f3f3f3f;
int[][] g = new int[N][N];
int[] dist = new int[N];
int n, m, s, t, k;
public int findCheapestPrice(int _n, int[][] flights, int _src, int _dst, int _k) {
n = _n; s = _src; t = _dst; k = _k + 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
g[i][j] = i == j ? 0 : INF;
}
}
for (int[] f : flights) {
g[f[0]][f[1]] = f[2];
}
int ans = bf();
return ans > INF / 2 ? -1 : ans;
}
int bf() {
Arrays.fill(dist, INF);
dist[s] = 0;
for (int limit = 0; limit < k; limit++) {
int[] clone = dist.clone();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[j] = Math.min(dist[j], clone[i] + g[i][j]);
}
}
}
return dist[t];
}
}
```
* 时间复杂度:$O(k * n^2)$
* 空间复杂度:$O(n^2)$
---
### Bellman Ford + 类
我们知道 Bellman Ford 需要遍历所有的边,而使用「邻接矩阵」的存图方式让我们不得不遍历所有的点对,复杂度为 $O(n^2)$。
而边的数量 $m$ 的数据范围为 $0 <= flights.length <= (n * (n - 1) / 2)$,因此我们可以使用「类」的方式进行存图,从而确保在遍历所有边的时候,复杂度严格为 $O(m)$,而不是 $O(n^2)$。
代码:
```Java
class Solution {
class Edge {
int x, y, w;
Edge(int _x, int _y, int _w) {
x = _x; y = _y; w = _w;
}
}
int N = 110, INF = 0x3f3f3f3f;
int[] dist = new int[N];
List<Edge> list = new ArrayList<>();
int n, m, s, t, k;
public int findCheapestPrice(int _n, int[][] flights, int _src, int _dst, int _k) {
n = _n; s = _src; t = _dst; k = _k + 1;
for (int[] f : flights) {
list.add(new Edge(f[0], f[1], f[2]));
}
m = list.size();
int ans = bf();
return ans > INF / 2 ? -1 : ans;
}
int bf() {
Arrays.fill(dist, INF);
dist[s] = 0;
for (int i = 0; i < k; i++) {
int[] clone = dist.clone();
for (Edge e : list) {
int x = e.x, y = e.y, w = e.w;
dist[y] = Math.min(dist[y], clone[x] + w);
}
}
return dist[t];
}
}
```
* 时间复杂度:共进行 $k + 1$ 次迭代,每次迭代备份数组复杂度为 $O(n)$,然后遍历所有的边进行松弛操作,复杂度为 $O(m)$。整体复杂度为 $O(k * (n + m))$
* 空间复杂度:$O(n + m)$
---
### Bellman Ford
更进一步,由于 Bellman Ford 核心操作需要遍历所有的边,因此也可以直接使用 $flights$ 数组作为存图信息,而无须额外存图。
代码:
```Java
class Solution {
int N = 110, INF = 0x3f3f3f3f;
int[] dist = new int[N];
public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
Arrays.fill(dist, INF);
dist[src] = 0;
for (int limit = 0; limit < k + 1; limit++) {
int[] clone = dist.clone();
for (int[] f : flights) {
int x = f[0], y = f[1], w = f[2];
dist[y] = Math.min(dist[y], clone[x] + w);
}
}
return dist[dst] > INF / 2 ? -1 : dist[dst];
}
}
```
* 时间复杂度:共进行 $k + 1$ 次迭代,每次迭代备份数组复杂度为 $O(n)$,然后遍历所有的边进行松弛操作,复杂度为 $O(m)$。整体复杂度为 $O(k * (n + m))$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.787` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/788. 旋转数字（中等）.md | 788. 旋转数字 | https://leetcode.cn/problems/rotated-digits/solution/by-ac_oier-9qpw/ | 中等 | [
"模拟"
] | 我们称一个数 `X` 为好数, 如果它的每位数字逐个地被旋转 `180` 度后,我们仍可以得到一个有效的,且和 `X` 不同的数。要求每位数字都要被旋转。
如果一个数的每位数字被旋转以后仍然还是一个数字, 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己;2 和 5 可以互相旋转成对方(在这种情况下,它们以不同的方向旋转,换句话说,2 和 5 互为镜像);6 和 9 同理,除了这些以外其他的数字旋转以后都不再是有效的数字。
现在我们有一个正整数 `N`, 计算从 `1` 到 `N` 中有多少个数 X 是好数?
示例:
```
输入: 10
输出: 4
解释:
在[1, 10]中有四个好数: 2, 5, 6, 9。
注意 1 和 10 不是好数, 因为他们在旋转之后不变。
```
提示:
* `N` 的取值范围是 $[1, 10000]$。 | ### 模拟
利用 $n$ 的范围为 $1e4$,我们可以直接检查 $[1, n]$ 的每个数。
由于每一个位数都需要翻转,因此如果当前枚举到的数值 `x` 中包含非有效翻转数字(非 `0125689`)则必然不是好数;而在每一位均为有效数字的前提下,若当前枚举到的数值 `x` 中包含翻转后能够发生数值上变化的数值(`2569`),则为好数。
Java 代码:
```Java
class Solution {
public int rotatedDigits(int n) {
int ans = 0;
out:for (int i = 1; i <= n; i++) {
boolean ok = false;
int x = i;
while (x != 0) {
int t = x % 10;
x /= 10;
if (t == 2 || t == 5 || t == 6 || t == 9) ok = true;
else if (t != 0 && t != 1 && t != 8) continue out;
}
if (ok) ans++;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function rotatedDigits(n: number): number {
let ans = 0
out:for (let i = 1; i <= n; i++) {
let ok = false
let x = i
while (x != 0) {
const t = x % 10
x = Math.floor(x / 10)
if (t == 2 || t == 5 || t == 6 || t == 9) ok = true
else if (t != 0 && t != 1 && t != 8) continue out
}
if (ok) ans++
}
return ans
};
```
Python3 代码:
```Python3
class Solution:
def rotatedDigits(self, n: int) -> int:
ans = 0
for i in range(1, n + 1):
ok, x = False, i
while x != 0:
t = x % 10
x = x // 10
if t == 2 or t == 5 or t == 6 or t == 9:
ok = True
elif t != 0 and t != 1 and t != 8:
ok = False
break
ans = ans + 1 if ok else ans
return ans
```
* 时间复杂度:共有 $n$ 个数需要枚举,检查一个数需要遍历其每个数字,复杂度为 $O(\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.788` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/789. 逃脱阻碍者（中等）.md | 789. 逃脱阻碍者 | https://leetcode-cn.com/problems/escape-the-ghosts/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-w69gr/ | 中等 | [
"数学"
] | 你在进行一个简化版的吃豆人游戏。你从 [0, 0] 点开始出发,你的目的地是 target = [xtarget, ytarget] 。地图上有一些阻碍者,以数组 ghosts 给出,第 i 个阻碍者从 ghosts[i] = [xi, yi] 出发。所有输入均为 整数坐标 。
每一回合,你和阻碍者们可以同时向东,西,南,北四个方向移动,每次可以移动到距离原位置 1 个单位 的新位置。当然,也可以选择 不动 。所有动作 同时 发生。
如果你可以在任何阻碍者抓住你 之前 到达目的地(阻碍者可以采取任意行动方式),则被视为逃脱成功。如果你和阻碍者同时到达了一个位置(包括目的地)都不算是逃脱成功。
只有在你有可能成功逃脱时,输出 true ;否则,输出 false 。
示例 1:
```
输入:ghosts = [[1,0],[0,3]], target = [0,1]
输出:true
解释:你可以直接一步到达目的地 (0,1) ,在 (1, 0) 或者 (0, 3) 位置的阻碍者都不可能抓住你。
```
示例 2:
```
输入:ghosts = [[1,0]], target = [2,0]
输出:false
解释:你需要走到位于 (2, 0) 的目的地,但是在 (1, 0) 的阻碍者位于你和目的地之间。
```
示例 3:
```
输入:ghosts = [[2,0]], target = [1,0]
输出:false
解释:阻碍者可以和你同时达到目的地。
```
示例 4:
```
输入:ghosts = [[5,0],[-10,-2],[0,-5],[-2,-2],[-7,1]], target = [7,7]
输出:false
```
示例 5:
```
输入:ghosts = [[-1,0],[0,1],[-1,0],[0,1],[-1,0]], target = [0,0]
输出:true
```
提示:
* 1 <= ghosts.length <= 100
* ghosts[i].length == 2
* -$10^4$ <= xi, yi <= $10^4$
* 同一位置可能有 多个阻碍者 。
* target.length == 2
* -$10^4$ <= xtarget, ytarget <= $10^4$ | ### 数学
从数据范围 $-10^4 <= x_{target}, y_{target} <= 10^4$ 且每次只能移动一个单位(或不移动)就注定了不能使用朴素的 `BFS` 进行求解。
朴素的 `BFS` 是指每次在玩家移动一步前,先将阻碍者可以一步到达的位置“置灰”(即设为永不可达),然后判断玩家是否能够到达 $target$。
朴素 `BFS` 本质是模拟,由于棋盘足够大,步长只有 $1$,因此该做法显然会 TLE。
是否有比模拟更快的做法呢?
**根据「树的直径」类似的证明,我们可以证明出「如果一个阻碍者能够抓到玩家,必然不会比玩家更晚到达终点」。**
为了方便,我们设玩家起点、阻碍者起点、终点分别为 $s$、$e$ 和 $t$,计算两点距离的函数为 $dist(x, y)$。
假设玩家从 $s$ 到 $t$ 的路径中会经过点 $k$,**当且仅当 $dist(e, k) <= dist(s, k)$,即「阻碍者起点与点 $k$ 的距离」小于等于「玩家起点与点 $k$ 的距离」时,阻碍者可以在点 $k$ 抓到玩家。**
由于「玩家到终点」以及「阻碍者到终点」的路径存在公共部分 $dist(k, t)$,可推导出:
$$
dist(e, k) + dist(k, t) <= dist(s, k) + dist(k, t)
$$
即得证 **如果一个阻碍者能够抓到玩家,那么该阻碍者必然不会比玩家更晚到达终点。**
由于步长为 $1$,且移动规则为上下左右四联通方向,因此 $dist(x, y)$ 的实现为计算两点的曼哈顿距离。
代码:
```Java
class Solution {
int dist(int x1, int y1, int x2, int y2) {
return Math.abs(x1 - x2) + Math.abs(y1 - y2);
}
public boolean escapeGhosts(int[][] gs, int[] t) {
int cur = dist(0, 0, t[0], t[1]);
for (int[] g : gs) {
if (dist(g[0], g[1], t[0], t[1]) <= cur) return false;
}
return true;
}
}
```
* 时间复杂度:令 $gs$ 长度为 $n$,计算曼哈顿距离复杂度为 $O(1)$,整体复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.789` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/781-790/790. 多米诺和托米诺平铺（中等）.md | 790. 多米诺和托米诺平铺 | https://leetcode.cn/problems/domino-and-tromino-tiling/solution/gong-shui-san-xie-by-ac_oier-kuv4/ | 中等 | [
"状态机 DP",
"动态规划"
] | 有两种形状的瓷砖:一种是 `2 x 1` 的多米诺形,另一种是形如 `"L"` 的托米诺形,两种形状都可以旋转。
给定整数 `n` ,返回可以平铺 `2 x n` 的面板的方法的数量,返回对 $10^9 + 7$ 取模 的值。
平铺指的是每个正方形都必须有瓷砖覆盖。
两个平铺不同,当且仅当面板上有四个方向上的相邻单元中的两个,使得恰好有一个平铺有一个瓷砖占据两个正方形。
示例 1:
```
输入: n = 3
输出: 5
解释: 五种不同的方法如上所示。
```
示例 2:
```
输入: n = 1
输出: 1
```
提示:
* $1 <= n <= 1000$ | ### 状态机 DP
定义 $f[i][j]$ 为无须考虑前 $i - 1$ 列(含义为前 $i - 1$ 列已铺满),当前第 $i$ 列状态为 $j$ 时的方案数。
其中 $j$ 取值范围为 $[0, 4)$ 分别对应了当前列的填充情况:
为了方便,我们人为规定列数从 $1$ 开始。
由于骨牌只能在 $2 \times n$ 的棋盘内填充(不能延伸出棋盘两端),因此我们有显而易见的初始化状态:
$$
f[1][0] = f[1][1] = 1
$$
分别对应「第一列不放置任何骨牌」和「第一列竖着放一块 $1 \times 2$ 骨牌」合法方案。
而 $f[1][2]$ 和 $f[1][3]$ 由于没法在棋盘左侧以外的位置放置骨牌,不存在合法方案,其值均为 $0$。
同时可知 $f[n][1]$ 为我们最终答案,含义为所有列都恰好铺完,不溢出棋盘右侧位置。
不失一般性考虑 $f[i][j]$ 该如何计算,其实就是一个简单的状态机转移分情况讨论:
* $f[i][0]$ : 需要前 $i - 1$ 列铺满,同时第 $i$ 列没有被铺,只能由 $f[i - 1][1]$ 转移而来,即有 $f[i][0] = f[i - 1][1]$
> 这里需要尤其注意:虽然我们能够在上一步留空第 $i - 1$ 列,然后在 $i - 1$ 列竖放一块 $1 \times 2$ 的骨牌(如下图)
> 但我们不能从 $f[i - 1][0]$ 转移到 $f[i][0]$,因为此时放置的骨牌,仅对第 $i - 1$ 列产生影响,不会对第 $i$ 列产生影响,该决策所产生的方案数,已在 $f[i - 1][X]$ 时被统计
* $f[i][1]$ : 可由 $f[i - 1][j]$ 转移而来(见下图),其中 $j \in [0, 4)$,即有 $f[i][1] = \sum_{j = 0}^{3} f[i - 1][j]$
* $f[i][2]$ : 可由 $f[i - 1][0]$ 和 $f[i - 1][3]$ 转移而来
* $f[i][3]$ : 可由 $f[i - 1][0]$ 和 $f[i - 1][2]$ 转移而来
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int numTilings(int n) {
int[][] f = new int[n + 10][4];
f[1][0] = f[1][1] = 1;
for (int i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1];
int cur = 0;
for (int j = 0; j < 4; j++) cur = (cur + f[i - 1][j]) % MOD;
f[i][1] = cur;
f[i][2] = (f[i - 1][0] + f[i - 1][3]) % MOD;
f[i][3] = (f[i - 1][0] + f[i - 1][2]) % MOD;
}
return f[n][1];
}
}
```
C++ 代码:
```C++
class Solution {
const int MOD = 1e9 + 7;
public:
int numTilings(int n){
vector<vector<int>> f(n + 10, vector<int>(4));
f[1][0] = f[1][1] = 1;
for (int i = 2; i <= n; ++i){
f[i][0] = f[i - 1][1];
int cur = 0;
for (int j = 0; j < 4; ++j) cur = (cur + f[i - 1][j]) % MOD;
f[i][1] = cur;
f[i][2] = (f[i - 1][0] + f[i - 1][3]) % MOD;
f[i][3] = (f[i - 1][0] + f[i - 1][2]) % MOD;
}
return f[n][1];
}
};
```
Python3 代码:
```Python
class Solution:
def numTilings(self, n: int) -> int:
f = [[0] * 4 for _ in range(n + 10)]
f[1][0] = f[1][1] = 1
for i in range(2, n + 1):
f[i][0] = f[i - 1][1]
f[i][1] = sum([f[i - 1][j] for j in range(4)])
f[i][2] = f[i - 1][0] + f[i - 1][3]
f[i][3] = f[i - 1][0] + f[i - 1][2]
return f[n][1] % 1000000007
```
TypeScript 代码:
```TypeScript
function numTilings(n: number): number {
const MOD = 1e9+7
const f = new Array<Array<number>>()
for (let i = 0; i <= n; i++) f[i] = new Array<number>(4).fill(0)
f[1][0] = f[1][1] = 1
for (let i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1]
let cur = 0
for (let j = 0; j < 4; j++) cur = (cur + f[i - 1][j]) % MOD
f[i][1] = cur
f[i][2] = (f[i - 1][0] + f[i - 1][3]) % MOD
f[i][3] = (f[i - 1][0] + f[i - 1][2]) % MOD
}
return f[n][1]
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 滚动数组优化
利用 $f[i][X]$ 仅依赖于 $f[i - 1][X]$,我们可以采用「滚动数组」方式将其空间优化至 $O(1)$。
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int numTilings(int n) {
int[][] f = new int[2][4];
f[1][0] = f[1][1] = 1;
for (int i = 2; i <= n; i++) {
int a = i & 1, b = (i - 1) & 1;
f[a][0] = f[b][1];
int cur = 0;
for (int j = 0; j < 4; j++) cur = (cur + f[b][j]) % MOD;
f[a][1] = cur;
f[a][2] = (f[b][0] + f[b][3]) % MOD;
f[a][3] = (f[b][0] + f[b][2]) % MOD;
}
return f[n & 1][1];
}
}
```
C++ 代码:
```C++
class Solution {
const int MOD = 1e9 + 7;
public:
int numTilings(int n){
vector<vector<int>> f(2, vector<int>(4));
f[1][0] = f[1][1] = 1;
for (int i = 2; i <= n; ++i){
int a = i & 1, b = (i - 1) & 1;
f[a][0] = f[b][1];
int cur = 0;
for (int j = 0; j < 4; ++j) cur = (cur + f[b][j]) % MOD;
f[a][1] = cur;
f[a][2] = (f[b][0] + f[b][3]) % MOD;
f[a][3] = (f[b][0] + f[b][2]) % MOD;
}
return f[n & 1][1];
}
};
```
Python3 代码:
```Python
class Solution:
def numTilings(self, n: int) -> int:
f = [[0] * 4 for _ in range(2)]
f[1][0] = f[1][1] = 1
for i in range(2, n + 1):
a, b = i & 1, (i - 1) & 1
f[a][0] = f[b][1]
f[a][1] = sum([f[b][j] for j in range(4)])
f[a][2] = f[b][0] + f[b][3]
f[a][3] = f[b][0] + f[b][2]
return f[n & 1][1] % 1000000007
```
TypeScript 代码:
```TypeScript
function numTilings(n: number): number {
const MOD = 1e9+7
const f = new Array<Array<number>>()
for (let i = 0; i <= 1; i++) f[i] = new Array<number>(4).fill(0)
f[1][0] = f[1][1] = 1
for (let i = 2; i <= n; i++) {
const a = i & 1, b = (i - 1) & 1
f[a][0] = f[b][1]
let cur = 0
for (let j = 0; j < 4; j++) cur = (cur + f[b][j]) % MOD
f[a][1] = cur
f[a][2] = (f[b][0] + f[b][3]) % MOD
f[a][3] = (f[b][0] + f[b][2]) % MOD
}
return f[n & 1][1]
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.790` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/791. 自定义字符串排序（中等）.md | 791. 自定义字符串排序 | https://leetcode.cn/problems/custom-sort-string/solution/by-ac_oier-ali0/ | 中等 | [
"构造",
"模拟"
] | 给定两个字符串 `order` 和 `s` 。
`order` 的所有单词都是唯一的,并且以前按照一些自定义的顺序排序。
对 `s` 的字符进行置换,使其与排序的 `order` 相匹配。
更具体地说,如果在 `order` 中的字符 `x` 出现字符 `y` 之前,那么在排列后的字符串中, `x` 也应该出现在 `y` 之前。
返回满足这个性质的 `s` 的任意排列 。
示例 1:
```
输入: order = "cba", s = "abcd"
输出: "cbad"
解释:
“a”、“b”、“c”是按顺序出现的,所以“a”、“b”、“c”的顺序应该是“c”、“b”、“a”。
因为“d”不是按顺序出现的,所以它可以在返回的字符串中的任何位置。“dcba”、“cdba”、“cbda”也是有效的输出。
```
示例 2:
```
输入: order = "cbafg", s = "abcd"
输出: "cbad"
```
提示:
* $1 <= order.length <= 26$
* $1 <= s.length <= 200$
* `order` 和 `s` 由小写英文字母组成
* `order` 中的所有字符都 不同 | ### 构造
根据题意进行模拟即可:起始先使用大小为 $C = 26$ 的数组 `cnts` 对 `s` 的所有字符进行词频统计,随后根据 `order` 的优先级进行构造。
若字符 `x` 在 `order` 中排于 `y` 前面,则先往答案追加 `cnts[x]` 个字符 `x`,再往答案追加 `cnts[y]` 个字符 `y`,并更新对应词频,最后将仅出现在 `s` 中的字符追加到答案尾部。
Java 代码:
```Java
class Solution {
public String customSortString(String order, String s) {
int[] cnts = new int[26];
for (char c : s.toCharArray()) cnts[c - 'a']++;
StringBuilder sb = new StringBuilder();
for (char c : order.toCharArray()) {
while (cnts[c - 'a']-- > 0) sb.append(c);
}
for (int i = 0; i < 26; i++) {
while (cnts[i]-- > 0) sb.append((char)(i + 'a'));
}
return sb.toString();
}
}
```
C++ 代码:
```C++
class Solution {
public:
string customSortString(string order, string s) {
vector<int> cnts(26, 0);
for (char c : s) cnts[c - 'a']++;
string result = "";
for (char c : order) {
while (cnts[c - 'a']-- > 0) result += c;
}
for (int i = 0; i < 26; i++) {
while (cnts[i]-- > 0) result += (char)(i + 'a');
}
return result;
}
};
```
Python 代码:
```Python
class Solution:
def customSortString(self, order: str, s: str) -> str:
cnts = [0] * 26
for c in s:
cnts[ord(c) - ord('a')] += 1
ans = ''
for c in order:
num = ord(c) - ord('a')
if cnts[num] > 0:
ans += c * cnts[num]
cnts[num] = 0
for i in range(26):
if cnts[i] > 0:
ans += chr(i + ord('a')) * cnts[i]
return ans
```
TypeScript 代码:
```TypeScript
function customSortString(order: string, s: string): string {
const cnts = new Array<number>(26).fill(0)
for (const c of s) cnts[c.charCodeAt(0) - 'a'.charCodeAt(0)]++
let ans = ''
for (const c of order) {
while (cnts[c.charCodeAt(0) - 'a'.charCodeAt(0)]-- > 0) ans += c
}
for (let i = 0; i < 26; i++) {
while (cnts[i]-- > 0) ans += String.fromCharCode(i + 'a'.charCodeAt(0));
}
return ans
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.791` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/792. 匹配子序列的单词数（中等）.md | 792. 匹配子序列的单词数 | https://leetcode.cn/problems/number-of-matching-subsequences/solution/by-ac_oier-u1ox/ | 中等 | [
"二分",
"哈希表"
] | 给定字符串 `s` 和字符串数组 `words`, 返回 `words[i]` 中是 `s` 的子序列的单词个数 。
字符串的子序列是从原始字符串中生成的新字符串,可以从中删去一些字符(可以是`""`),而不改变其余字符的相对顺序。
例如, `“ace”` 是 `“abcde”` 的子序列。
示例 1:
```
输入: s = "abcde", words = ["a","bb","acd","ace"]
输出: 3
解释: 有三个是 s 的子序列的单词: "a", "acd", "ace"。
```
示例 2:
```
输入: s = "dsahjpjauf", words = ["ahjpjau","ja","ahbwzgqnuk","tnmlanowax"]
输出: 2
```
提示:
* $1 <= s.length <= 5 \times 10^4$
* $1 <= words.length <= 5000$
* $1 <= words[i].length <= 50$
* `words[i]` 和 `s` 都只由小写字母组成。 | ### 预处理 + 哈希表 + 二分
朴素判定某个字符串是为另一字符串的子序列的复杂度为 $O(n + m)$,对于本题共有 $5000$ 个字符串需要判定,每个字符串最多长为 $50$,因此整体计算量为 $(5 \times 10^4 + 50) \times 5000 \approx 2.5 \times 10^8$,会超时。
不可避免的是,我们要对每个 $words[i]$ 进行检查,因此优化的思路可放在如何优化单个 $words[i]$ 的判定操作。
朴素的判定过程需要使用双指针扫描两个字符串,其中对于原串的扫描,会有大量的字符会被跳过(无效匹配),即只有两指针对应的字符相同时,匹配串指针才会后移。
我们考虑如何优化这部分无效匹配。
对于任意一个 $w = words[i]$ 而言,假设我们当前匹配到 $w[j]$ 位置,此时我们已经明确下一个待匹配的字符为 $w[j + 1]$,因此我们可以直接在 `s` 中字符为 $w[j + 1]$ 的位置中找候选。
具体的,我们可以使用哈希表 `map` 对 `s` 进行预处理:以字符 $c = s[i]$ 为哈希表的 `key`,对应的下标 $i$ 集合为 `value`,由于我们从前往后处理 `s` 进行预处理,因此对于所有的 `value` 均满足递增性质。
> 举个 🌰 : 对于 `s = abcabc` 而言,预处理的哈希表为 `{a=[0,3], b=[1,4], c=[2,5]}`
最后考虑如何判定某个 $w = words[i]$ 是否满足要求:待匹配字符串 `w` 长度为 `m`,我们从前往后对 `w` 进行判定,假设当前判待匹配位置为 $w[i]$,我们使用变量 `idx` 代表能够满足匹配 $w[0:i]$ 的最小下标(贪心思路)。
对于匹配的 $w[i]$ 字符,可以等价为在 `map[w[i]]` 中找到第一个大于 `idx` 的下标,含义在原串 `s` 中找到字符为 `w[i]` 且下标大于 `idx` 的最小值,由于我们所有的 `map[X]` 均满足单调递增,该过程可使用「二分」进行。
Java 代码:
```Java
class Solution {
public int numMatchingSubseq(String s, String[] words) {
int n = s.length(), ans = 0;
Map<Character, List<Integer>> map = new HashMap<>();
for (int i = 0; i < n; i++) {
List<Integer> list = map.getOrDefault(s.charAt(i), new ArrayList<>());
list.add(i);
map.put(s.charAt(i), list);
}
for (String w : words) {
boolean ok = true;
int m = w.length(), idx = -1;
for (int i = 0; i < m && ok; i++) {
List<Integer> list = map.getOrDefault(w.charAt(i), new ArrayList<>());
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r >> 1;
if (list.get(mid) > idx) r = mid;
else l = mid + 1;
}
if (r < 0 || list.get(r) <= idx) ok = false;
else idx = list.get(r);
}
if (ok) ans++;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function numMatchingSubseq(s: string, words: string[]): number {
let n = s.length, ans = 0
const map = new Map<String, Array<number>>()
for (let i = 0; i < n; i++) {
if (!map.has(s[i])) map.set(s[i], new Array<number>())
map.get(s[i]).push(i)
}
for (const w of words) {
let ok = true
let m = w.length, idx = -1
for (let i = 0; i < m && ok; i++) {
if (!map.has(w[i])) {
ok = false
} else {
const list = map.get(w[i])
let l = 0, r = list.length - 1
while (l < r) {
const mid = l + r >> 1
if (list[mid] > idx) r = mid
else l = mid + 1
}
if (r < 0 || list[r] <= idx) ok = false
else idx = list[r]
}
}
if (ok) ans++
}
return ans
}
```
Python3 代码:
```Python
class Solution:
def numMatchingSubseq(self, s: str, words: List[str]) -> int:
dmap = defaultdict(list)
for i, c in enumerate(s):
dmap[c].append(i)
ans = 0
for w in words:
ok = True
idx = -1
for i in range(len(w)):
idxs = dmap[w[i]]
l, r = 0, len(idxs) - 1
while l < r :
mid = l + r >> 1
if dmap[w[i]][mid] > idx:
r = mid
else:
l = mid + 1
if r < 0 or dmap[w[i]][r] <= idx:
ok = False
break
else:
idx = dmap[w[i]][r]
ans += 1 if ok else 0
return ans
```
* 时间复杂度:令 `n` 为 `s` 长度,`m` 为 `words` 长度,`l = 50` 为 $words[i]$ 长度的最大值。构造 `map` 的复杂度为 $O(n)$;统计符合要求的 $words[i]$ 的数量复杂度为 $O(m \times l \times \log{n})$。整体复杂度为 $O(n + m \times l \times \log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.792` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/793. 阶乘函数后 K 个零（困难）.md | 793. 阶乘函数后 K 个零 | https://leetcode.cn/problems/preimage-size-of-factorial-zeroes-function/solution/by-ac_oier-pk9g/ | 困难 | [
"数学",
"二分",
"容斥原理"
] | `f(x)` 是 `x!` 末尾是 `0` 的数量。回想一下 `x! = 1 * 2 * 3 * ... * x`,且 `0! = 1`。
例如, `f(3) = 0`,因为 `3! = 6` 的末尾没有 `0` ;而 `f(11) = 2`,因为 `11!= 39916800` 末端有 `2` 个 `0` 。
给定 `k`,找出返回能满足 `f(x) = k` 的非负整数 `x` 的数量。
示例 1:
```
输入:k = 0
输出:5
解释:0!, 1!, 2!, 3!, 和 4! 均符合 k = 0 的条件。
```
示例 2:
```
输入:k = 5
输出:0
解释:没有匹配到这样的 x!,符合 k = 5 的条件。
```
示例 3:
```
输入: k = 3
输出: 5
```
提示:
* $0 <= k <= 10^9$ | ### 数学 + 二分
对于一个 $n! = 1 \times 2 \times ... \times (n - 1) \times n$ 而言,其最终结果尾部包含 $0$ 的数量取决于其被累乘 $10$ 的次数,而 $10$ 可通过质因数 $2$ 和 $5$ 相乘而来,因此假设对 $n!$ 进行阶乘分解,最终分解出 $2^p$ 和 $5^q$ 的话,那么最终结果尾部包含 $0$ 的个数为 $q$ 个(可证明 $p >= q$ 始终满足)。
因此原问题转化为:在非负整数中,有多少个数进行阶乘分解后,所含质因数 $5$ 的个数恰好为 $k$ 个。
同时我们可知:随着 $n$ 的增大,其所能分解出来的 $5$ 的个数必然是递增的。
基于此,我们可以通过「二分 + 容斥原理」来得出分解 $5$ 个数恰好为 $k$ 的连续段长度。假设我们存在函数 `f(k)` 可得到非负整数中分解 $5$ 个数为小于等于 `k` 的个数,那么最终 `f(k) - f(k - 1)` 即是答案。
在单调函数上求解小于等于 `k` 分割点,可通过「二分」来做。剩下的问题是,如何求得给定 `x` 时,其阶乘分解所包含 $5$ 个个数,这可以通过 $O(\log{x})$ 的筛法来做。
最后还要确定二分的值域,由于我们是求阶乘分解中 $5$ 的个数,因此值域的上界为 $5k$,利用 $k$ 的范围为 $1e9$,直接取成 $1e10$ 即可。
Java 代码:
```Java
class Solution {
public int preimageSizeFZF(int k) {
if (k <= 1) return 5;
return f(k) - f(k - 1);
}
int f(int x) {
long l = 0, r = (long) 1e10;
while (l < r) {
long mid = l + r + 1 >> 1;
if (getCnt(mid) <= x) l = mid;
else r = mid - 1;
}
return (int)r;
}
long getCnt(long x) {
long ans = 0;
while (x != 0) {
ans += x / 5; x /= 5;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function preimageSizeFZF(k: number): number {
if (k <= 1) return 5
return f(k) - f(k - 1)
};
function f(x: number): number {
let l = 0n, r = BigInt("10000000000")
while (l < r) {
const mid = l + r + 1n >> 1n
if (getCnt(mid) <= x) l = mid
else r = mid - 1n
}
return Number(r)
}
function getCnt(x: bigint): bigint {
let ans = 0n
while (x != 0n) {
ans += BigInt(Math.floor(Number(x / 5n))); x = BigInt(Math.floor(Number(x / 5n)))
}
return ans
}
```
* 时间复杂度:$O(\log^2{k})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.793` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/794. 有效的井字游戏（中等）.md | 794. 有效的井字游戏 | https://leetcode-cn.com/problems/valid-tic-tac-toe-state/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-pikn/ | 中等 | [
"模拟"
] | 给你一个字符串数组 `board` 表示井字游戏的棋盘。当且仅当在井字游戏过程中,棋盘有可能达到 `board` 所显示的状态时,才返回 `true` 。
井字游戏的棋盘是一个 `3 x 3` 数组,由字符 `' '`,`'X'` 和 `'O'` 组成。字符 `' '` 代表一个空位。
以下是井字游戏的规则:
* 玩家轮流将字符放入空位(`' '`)中。
* 玩家 $1$ 总是放字符 `'X'` ,而玩家 $2$ 总是放字符 `'O'` 。
* 'X' 和 'O' 只允许放置在空位中,不允许对已放有字符的位置进行填充。
* 当有 $3$ 个相同(且非空)的字符填充任何行、列或对角线时,游戏结束。
* 当所有位置非空时,也算为游戏结束。
* 如果游戏结束,玩家不允许再放置字符。
示例 1:
```
输入:board = ["O "," "," "]
输出:false
解释:玩家 1 总是放字符 "X" 。
```
示例 2:
```
输入:board = ["XOX"," X "," "]
输出:false
解释:玩家应该轮流放字符。
```
示例 3:
```
输入:board = ["XXX"," ","OOO"]
输出:false
```
示例 4:
```
输入:board = ["XOX","O O","XOX"]
输出:true
```
提示:
* `board.length == 3`
* `board[i].length == 3`
* `board[i][j]` 为 `'X'`、`'O'` 或 `' '` | ### 分情况讨论
给定的棋盘大小固定,对于无效情况进行分情况讨论即可:
1. 由于 `X` 先手,`O` 后手,两者轮流下子。因此 `O` 的数量不会超过 `X`,且两者数量差不会超过 $1$,否则为无效局面;
2. 若局面是 `X` 获胜,导致该局面的最后一个子必然是 `X`,此时必然有 `X` 数量大于 `O`(`X` 为先手),否则为无效局面;
3. 若局面是 `O` 获胜,导致该局面的最后一个子必然是 `O`,此时必然有 `X` 数量等于 `O`(`X` 为先手),否则为无效局面;
4. 局面中不可能出现两者同时赢(其中一方赢后,游戏结束)。
代码:
```Java
class Solution {
public boolean validTicTacToe(String[] board) {
char[][] cs = new char[3][3];
int x = 0, o = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
char c = board[i].charAt(j);
if (c == 'X') x++;
else if (c == 'O') o++;
cs[i][j] = c;
}
}
boolean a = check(cs, 'X'), b = check(cs, 'O');
if (o > x || x - o > 1) return false;
if (a && x <= o) return false;
if (b && o != x) return false;
if (a && b) return false;
return true;
}
boolean check(char[][] cs, char c) {
for (int i = 0; i < 3; i++) {
if (cs[i][0] == c && cs[i][1] == c && cs[i][2] == c) return true;
if (cs[0][i] == c && cs[1][i] == c && cs[2][i] == c) return true;
}
boolean a = true, b = true;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == j) a &= cs[i][j] == c;
if (i + j == 2) b &= cs[i][j] == c;
}
}
return a || b;
}
}
```
* 时间复杂度:棋盘大小固定,遍历棋盘次数为常数。复杂度为 $O(C)$
* 空间复杂度:使用了 $char$ 二维数组对 $board$ 进行转存,复杂度为 $O(C)$;全程使用 `charAt` 的话复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.794` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/795. 区间子数组个数（中等）.md | 795. 区间子数组个数 | https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum/solution/by-ac_oier-gmpt/ | 中等 | [
"模拟",
"单调栈"
] | 给你一个整数数组 `nums` 和两个整数:`left` 及 `right` 。
找出 `nums` 中连续、非空且其中最大元素在范围 $[left, right]$ 内的子数组,并返回满足条件的子数组的个数。
生成的测试用例保证结果符合 `32-bit` 整数范围。
示例 1:
```
输入:nums = [2,1,4,3], left = 2, right = 3
输出:3
解释:满足条件的三个子数组:[2], [2, 1], [3]
```
示例 2:
```
输入:nums = [2,9,2,5,6], left = 2, right = 8
输出:7
```
提示:
* $1 <= nums.length <= 10^5$
* $0 <= nums[i] <= 10^9$
* $0 <= left <= right <= 10^9$ | ### 单调栈
为了方便,我们令 $[left, right]$ 为 $[a, b]$。
一个容易想到的思路是使用「单调栈」。
**统计所有最大值范围在 $[a, b]$ 之间的子数组个数,可等价为统计每一个范围落在 $[a, b]$ 之间的 $nums[i]$ 作为最大值时子数组的个数。**
由此可以进一步将问题转换为:求解每个 $nums[i]$ 作为子数组最大值时,最远的合法左右端点的位置。也就是求解每一个 $nums[i]$ 左右最近一个比其“大”的位置,这可以使用「单调栈」来进行求解。
> 对于单调栈不了解的同学,可以看前置 🧀 : [【RMQ 专题】关于 RMQ 的若干解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493262&idx=1&sn=2d8e192a5767b49b9a13a6192ab3b833)
**统计所有 $nums[i]$ 对答案的贡献即是最终答案,但我们忽略了「当 `nums` 存在重复元素,且该元素作为子数组最大值时,最远左右端点的边界越过重复元素时,导致重复统计子数组」的问题。**
我们不失一般性的举个 🌰 来理解(下图):
为了消除这种重复统计,我们可以将「最远左右边界」的一端,从「严格小于」调整为「小于等于」,从而实现半开半闭的效果。
Java 代码:
```Java
class Solution {
public int numSubarrayBoundedMax(int[] nums, int a, int b) {
int n = nums.length, ans = 0;
int[] l = new int[n + 10], r = new int[n + 10];
Arrays.fill(l, -1); Arrays.fill(r, n);
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && nums[d.peekLast()] < nums[i]) r[d.pollLast()] = i;
d.addLast(i);
}
d.clear();
for (int i = n - 1; i >= 0; i--) {
while (!d.isEmpty() && nums[d.peekLast()] <= nums[i]) l[d.pollLast()] = i;
d.addLast(i);
}
for (int i = 0; i < n; i++) {
if (nums[i] < a || nums[i] > b) continue;
ans += (i - l[i]) * (r[i] - i);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int numSubarrayBoundedMax(vector<int>& nums, int a, int b) {
int n = nums.size(), ans = 0;
vector<int> l(n + 10, -1), r(n + 10, n);
deque<int> d;
for (int i = 0; i < n; i++) {
while (!d.empty() && nums[d.back()] < nums[i]) {
r[d.back()] = i;
d.pop_back();
}
d.push_back(i);
}
d.clear();
for (int i = n - 1; i >= 0; i--) {
while (!d.empty() && nums[d.back()] <= nums[i]) {
l[d.back()] = i;
d.pop_back();
}
d.push_back(i);
}
for (int i = 0; i < n; i++) {
if (nums[i] < a || nums[i] > b) continue;
ans += (i - l[i]) * (r[i] - i);
}
return ans;
}
};
```
Python3 代码:
```Python
class Solution:
def numSubarrayBoundedMax(self, nums: List[int], a: int, b: int) -> int:
n, ans = len(nums), 0
l, r = [-1] * n, [n] * n
stk = []
for i in range(n):
while stk and nums[stk[-1]] < nums[i]:
r[stk.pop()] = i
stk.append(i)
stk = []
for i in range(n - 1, -1, -1):
while stk and nums[stk[-1]] <= nums[i]:
l[stk.pop()] = i
stk.append(i)
for i in range(n):
if a <= nums[i] <= b:
ans += (i - l[i]) * (r[i] - i)
return ans
```
TypeScript 代码:
```TypeScript
function numSubarrayBoundedMax(nums: number[], a: number, b: number): number {
let n = nums.length, ans = 0
const l = new Array<number>(n).fill(-1), r = new Array<number>(n).fill(n)
let stk = new Array<number>()
for (let i = 0; i < n; i++) {
while (stk.length > 0 && nums[stk[stk.length - 1]] < nums[i]) r[stk.pop()] = i
stk.push(i)
}
stk = new Array<number>()
for (let i = n - 1; i >= 0; i--) {
while (stk.length > 0 && nums[stk[stk.length - 1]] <= nums[i]) l[stk.pop()] = i
stk.push(i)
}
for (let i = 0; i < n; i++) {
if (nums[i] < a || nums[i] > b) continue
ans += (i - l[i]) * (r[i] - i)
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 模拟
除了统计「每个 $nums[i]$ 作为子数组最大值时,所能贡献的子数组个数」以外,我们还可以统计「每个 $nums[i]$ 作为子数组右端点时,所能贡献的子数组个数」。
具体的,我们从前往后处理每个 $nums[i]$,并统计其作为子数组右端点时,所能贡献的子数组个数。同时使用变量 `j` 和 `k` 分别记录最近一次满足「$nums[i]$ 范围落在 $[a, b]$ 之间」以及「$nums[i]$ 数值大于 $b$」的下标位置。
遍历过程中根据 $nums[i]$ 与规定范围 $[a, b]$ 之间的关系进行分情况讨论:
* $nums[i]$ 大于 $b$,$nums[i]$ 作为右端点,必不可能贡献合法子数组。更新 `k`;
* $nums[i]$ 小于 $a$,此时 $nums[i]$ 想作为右端点的话,子数组必须有其他满足「范围落在 $[a, b]$ 之间」的其他数,而最近一个满足要求的位置为 $j$,若有 $j > k$,说明范围在 $(k, j]$ 均能作为子数组的左端点,累加方案数 $j - k$;若有 $j < k$,说明我们无法找到任何一个左端点,使得形成的子数组满足要求(要么最值不在 $[a, b]$ 范围内,要么有 $[a, b]$ 范围内的数,但最大值又大于 `b` 值);
* $nums[i]$ 落在范围 $[a, b]$,此时 $nums[i]$ 想作为右端点的话,只需要找到左边第一个数值大于 $b$ 的数值即可(即变量 `k`),累加方案数 $i - k$。更新 `j`。
Java 代码:
```Java
class Solution {
public int numSubarrayBoundedMax(int[] nums, int a, int b) {
int n = nums.length, ans = 0;
for (int i = 0, j = -1, k = -1; i < n; i++) {
if (nums[i] > b) {
k = i;
} else {
if (nums[i] < a) {
if (j > k) ans += j - k;
} else {
ans += i - k;
j = i;
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int numSubarrayBoundedMax(vector<int>& nums, int a, int b) {
int n = nums.size(), ans = 0;
for (int i = 0, j = -1, k = -1; i < n; i++) {
if (nums[i] > b) {
k = i;
} else {
if (nums[i] < a) {
if (j > k) ans += j - k;
} else {
ans += i - k;
j = i;
}
}
}
return ans;
}
};
```
Python3 代码:
```Python
class Solution:
def numSubarrayBoundedMax(self, nums: List[int], a: int, b: int) -> int:
n, ans = len(nums), 0
j, k = -1, -1
for i in range(n):
if nums[i] > b:
k = i
else:
if nums[i] < a:
ans += j - k if j > k else 0
else:
ans += i - k
j = i
return ans
```
TypeScript 代码:
```TypeScript
function numSubarrayBoundedMax(nums: number[], a: number, b: number): number {
let n = nums.length, ans = 0
for (let i = 0, j = -1, k = -1; i < n; i++) {
if (nums[i] > b) {
k = i
} else {
if (nums[i] < a) {
if (j > k) ans += j - k
} else {
ans += i - k
j = i
}
}
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.795` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/796. 旋转字符串（简单）.md | 796. 旋转字符串 | https://leetcode-cn.com/problems/rotate-string/solution/by-ac_oier-bnkx/ | 简单 | [
"模拟"
] | 给定两个字符串,`s` 和 `goal`。如果在若干次旋转操作之后,`s` 能变成 `goal`,那么返回 `true`。
`s` 的旋转操作就是将 `s` 最左边的字符移动到最右边。
* 例如, 若 `s = 'abcde'`,在旋转一次之后结果就是`'bcdea'` 。
示例 1:
```
输入: s = "abcde", goal = "cdeab"
输出: true
```
示例 2:
```
输入: s = "abcde", goal = "abced"
输出: false
```
提示:
* $1 <= s.length, goal.length <= 100$
* `s` 和 `goal` 由小写英文字母组成 | ### 模拟
由于每次旋转操作都是将最左侧字符移动到最右侧,因此如果 `goal` 可由 `s` 经过多步旋转而来,那么 `goal` 必然会出现在 `s + s` 中,即满足 `(s + s).contains(goal)`,同时为了 `s` 本身过长导致的结果成立,我们需要先确保两字符串长度相等。
代码:
```Java
class Solution {
public boolean rotateString(String s, String goal) {
return s.length() == goal.length() && (s + s).contains(goal);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 关于 `contains` 操作的复杂度说明
看到不少同学对 `contains` 的复杂度写成 $O(n)$ 有疑问。
在 Java 中,`contains` 实际最终是通过 `indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)` 来拿到子串在原串的下标,通过判断下标是否为 $-1$ 来得知子串是否在原串出现过。
我们知道一个较为普通的子串匹配算法的复杂度通为 $O(n*k)$,其中 $n$ 和 $k$ 分别是原串和子串的长度,而一些复杂度上较为优秀的算法可以做到 $O(n + k)$,例如 [KMP](https://leetcode-cn.com/problems/implement-strstr/solution/shua-chuan-lc-shuang-bai-po-su-jie-fa-km-tb86/)。
从复杂度上来看 KMP 似乎要更好,但实际上对于 `indexOf` 这一高频操作而言,KMP 的预处理逻辑和空间开销都是不可接受的。
因此在 OpenJDK 中的 `indexOf` 源码中,你看不到诸如 KMP 这一类「最坏情况下仍为线性复杂度」的算法实现。
但是 `contains` 的复杂度真的就是 $O(n * k)$ 吗?
其实并不是,这取决于 JVM 是否有针对 `indexOf` 的优化,在最为流行 HotSpot VM 中,就有对 `indexOf` 的优化。
使用以下两行命令执行 `Main.java`,会得到不同的用时。
```Java
// Main.java
import java.util.*;
class Main {
static String ss = "1900216589537958049456207450268985232242852754963049829410964867980510717200606495004259179775210762723370289106970649635773837906542900276476226929871813370344374628795427969854262816333971458418647697497933767559786473164055741512717436542961770628985635269208255141092673831132865";
static String pp = "830411595466023844647269831101019568881117264597716557501027220546437084223034983361631430958163646150071031688420479928498493050624766427709034028819288384316713084883575266906600102801186671777455503932259958027055697399984336592981698127456301551509241";
static int cnt = (int) 1e8;
static public void main(String[] args) {
long start = System.currentTimeMillis();
while (cnt-- > 0) ss.contains(pp);
System.out.println(System.currentTimeMillis() - start);
}
}
```
环境说明:
```Shell
➜ java -version
java version "1.8.0_131"
Java(TM) SE Runtime Environment (build 1.8.0_131-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.131-b11, mixed mode)
```
先执行 `javac Main.java` 进行编译后:
1. 使用原始的 `indexOf` 实现进行匹配(执行多次,平均耗时为基准值 $X$):
```
java -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_indexOf Main
```
2. 使用 HotSpot VM 优化的 `indexOf` 进行匹配(执行多次,平均耗时为基准值 $X$ 的 $[0.55, 0.65]$ 之间):
```
java Main
```
因此实际运行的 `contains` 操作的复杂度为多少并不好确定,但可以确定是要优于 $O(n * k)$ 的。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.796` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/797. 所有可能的路径（中等）.md | 797. 所有可能的路径 | https://leetcode-cn.com/problems/all-paths-from-source-to-target/solution/gong-shui-san-xie-yun-yong-dfs-bao-sou-s-xlz9/ | 中等 | [
"回溯算法",
"DFS"
] | 给你一个有 n 个节点的 有向无环图(DAG),请你找出所有从节点 0 到节点 n-1 的路径并输出(不要求按特定顺序)
二维数组的第 i 个数组中的单元都表示有向图中 i 号节点所能到达的下一些节点,空就是没有下一个结点了。
译者注:有向图是有方向的,即规定了 a→b 你就不能从 b→a 。
示例 1:
```
输入:graph = [[1,2],[3],[3],[]]
输出:[[0,1,3],[0,2,3]]
解释:有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3
```
示例 2:
```
输入:graph = [[4,3,1],[3,2,4],[3],[4],[]]
输出:[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
```
示例 3:
```
输入:graph = [[1],[]]
输出:[[0,1]]
```
示例 4:
```
输入:graph = [[1,2,3],[2],[3],[]]
输出:[[0,1,2,3],[0,2,3],[0,3]]
```
示例 5:
```
输入:graph = [[1,3],[2],[3],[]]
输出:[[0,1,2,3],[0,3]]
```
提示:
* n == graph.length
* 2 <= n <= 15
* 0 <= graph[i][j] < n
* graph[i][j] != i(即,不存在自环)
* graph[i] 中的所有元素 互不相同
* 保证输入为 有向无环图(DAG) | ### DFS
$n$ 只有 $15$,且要求输出所有方案,因此最直观的解决方案是使用 `DFS` 进行爆搜。
起始将 $0$ 进行加入当前答案,当 $n - 1$ 被添加到当前答案时,说明找到了一条从 $0$ 到 $n - 1$ 的路径,将当前答案加入结果集。
当我们决策到第 $x$ 位(非零)时,该位置所能放入的数值由第 $x - 1$ 位已经填入的数所决定,同时由于给定的 $graph$ 为有向无环图(拓扑图),因此按照第 $x - 1$ 位置的值去决策第 $x$ 位的内容,必然不会决策到已经在当前答案的数值,否则会与 $graph$ 为有向无环图(拓扑图)的先决条件冲突。
换句话说,与一般的爆搜不同的是,我们不再需要 $vis$ 数组来记录某个点是否已经在当前答案中。
代码:
```Java
class Solution {
int[][] g;
int n;
List<List<Integer>> ans = new ArrayList<>();
List<Integer> cur = new ArrayList<>();
public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
g = graph;
n = g.length;
cur.add(0);
dfs(0);
return ans;
}
void dfs(int u) {
if (u == n - 1) {
ans.add(new ArrayList<>(cur));
return ;
}
for (int next : g[u]) {
cur.add(next);
dfs(next);
cur.remove(cur.size() - 1);
}
}
}
```
* 时间复杂度:共有 $n$ 个节点,每个节点有选和不选两种决策,总的方案数最多为 $2^n$,对于每个方案最坏情况需要 $O(n)$ 的复杂度进行拷贝并添加到结果集。整体复杂度为 $O(n * 2^n)$
* 空间复杂度:最多有 $2^n$ 种方案,每个方案最多有 $n$ 个元素。整体复杂度为 $O(n * 2^n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.797` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/798. 得分最高的最小轮调（困难）.md | 798. 得分最高的最小轮调 | https://leetcode-cn.com/problems/smallest-rotation-with-highest-score/solution/gong-shui-san-xie-shang-xia-jie-fen-xi-c-p6kh/ | 困难 | [
"区间求和问题",
"差分"
] | 给你一个数组 $nums$,我们可以将它按一个非负整数 $k$ 进行轮调,这样可以使数组变为 $[nums[k], nums[k + 1], ... nums[nums.length - 1], nums[0], nums[1], ..., nums[k-1]]$ 的形式。此后,任何值小于或等于其索引的项都可以记作一分。
例如,数组为 $nums = [2,4,1,3,0]$,我们按 $k = 2$ 进行轮调后,它将变成 $[1,3,0,2,4]$。这将记为 $3$ 分,因为 $1 > 0$ [不计分]、$3 > 1$ [不计分]、$0 <= 2$ [计 $1$ 分]、$2 <= 3$ [计 $1$ 分],$4 <= 4$ [计 $1$ 分]。
在所有可能的轮调中,返回我们所能得到的最高分数对应的轮调下标 $k$ 。如果有多个答案,返回满足条件的最小的下标 $k$ 。
示例 1:
```
输入:nums = [2,3,1,4,0]
输出:3
解释:
下面列出了每个 k 的得分:
k = 0, nums = [2,3,1,4,0], score 2
k = 1, nums = [3,1,4,0,2], score 3
k = 2, nums = [1,4,0,2,3], score 3
k = 3, nums = [4,0,2,3,1], score 4
k = 4, nums = [0,2,3,1,4], score 3
所以我们应当选择 k = 3,得分最高。
```
示例 2:
```
输入:nums = [1,3,0,2,4]
输出:0
解释:
nums 无论怎么变化总是有 3 分。
所以我们将选择最小的 k,即 0。
```
提示:
* $1 <= nums.length <= 10^5$
* $0 <= nums[i] < nums.length$ | ### 上下界分析 + 差分应用
为了方便,令 $n$ 为 $nums$ 长度(中文的数据范围是错的,数组长度应该是 $10^5$,不是 $20000$)。
对于给定的 $nums$ 而言,有效的轮调范围为 $[0, n - 1]$,即对于任意 $nums[i]$ 而言,可取的下标共有 $n$ 种。
假定当前下标为 $i$,轮调次数为 $k$,那么轮调后下标为 $i - k$,当新下标为负数时,相当于 $nums[i]$ 出现在比原数组更“靠后”的位置,此时下标等价于 $(i - k + n) \mod n$。
考虑什么情况下 $nums[i]$ 能够得分?
首先新下标的取值范围为 $[0, n - 1]$,即有 $0 \leqslant i - k \leqslant n - 1$ 。由此可分析出 $k$ 的取值范围为:
$$
0 \leqslant i - k \Leftrightarrow k \leqslant i
$$
$$
i - k \leqslant n - 1 \Leftrightarrow i - (n - 1) \leqslant k
$$
即由新下标取值范围可知 $k$ 的上下界分别为 $i$ 和 $i - (n - 1)$。
同时为了满足得分定义,还有 $nums[i] \leqslant i - k$,进行变形可得:
$$
nums[i] \leqslant i - k \Leftrightarrow k \leqslant i - nums[i]
$$
此时我们有两个关于 $k$ 的上界 $k \leqslant i$ 和 $k \leqslant i - nums[i]$,由于 $nums[i]$ 取值范围为 $[0, n)$,则有 $i - nums[i] \leqslant i$,由于必须同时满足「合法移动(有效下标)」和「能够得分」,我们仅考虑范围更小(更严格)由 $nums[i] \leqslant i - k$ 推导而来的上界 $k \leqslant i - nums[i]$ 即可。
综上,$nums[i]$ 能够得分的 $k$ 的取值范围为 $[i - (n - 1), i - nums[i]]$。
最后考虑 $[i - (n - 1), i - nums[i]]$(均进行加 $n$ 模 $n$ 转为正数)什么情况下为合法的连续段:
* 当 $i - (n - 1) \leqslant i - nums[i]$ 时,$[i - (n - 1), i - nums[i]]$ 为合法连续段;
* 当 $i - (n - 1) > i - nums[i]$ 时,根据负数下标等价于 $(i - k + n) \mod n$,此时 $[i - (n - 1), i - nums[i]]$ 等价于 $[0, i - nums[i]]$ 和 $[i - (n - 1), n - 1]$ 两段。
至此,我们分析出原数组的每个 $nums[i]$ 能够得分的 $k$ 的取值范围,假定取值范围为 $[l, r]$,我们可以对 $[l, r]$ 进行 $+1$ 标记,代表范围为 $k$ 能够得 $1$ 分,当处理完所有的 $nums[i]$ 后,找到标记次数最多的位置 $k$ 即是答案。
标记操作可使用「差分」实现(不了解差分的同学,可以先看前置🧀:[差分入门模板题](https%3A//mp.weixin.qq.com/s?__biz%3DMzU4NDE3MTEyMA%3D%3D%26mid%3D2247490329%26idx%3D1%26sn%3D6d448a53cd722bbd990fda82bd262857%26chksm%3Dfd9cb006caeb3910758522054564348b7eb4bde333889300bd5d249950be12a5b990b5d2c059%26token%3D168273153%26lang%3Dzh_CN%23rd),里面讲解了差分的两个核心操作「区间修改」&「单点查询」),而找标记次数最多的位置可对差分数组求前缀和再进行遍历即可。
代码:
```Java
class Solution {
static int N = 100010;
static int[] c = new int[N];
void add(int l, int r) {
c[l] += 1; c[r + 1] -= 1;
}
public int bestRotation(int[] nums) {
Arrays.fill(c, 0);
int n = nums.length;
for (int i = 0; i < n; i++) {
int a = (i - (n - 1) + n) % n, b = (i - nums[i] + n) % n;
if (a <= b) {
add(a, b);
} else {
add(0, b);
add(a, n - 1);
}
}
for (int i = 1; i <= n; i++) c[i] += c[i - 1];
int ans = 0, k = c[0];
for (int i = 1; i <= n; i++) {
if (c[i] > k) {
k = c[i]; ans = i;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.798` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/791-800/799. 香槟塔（中等）.md | 799. 香槟塔 | https://leetcode.cn/problems/champagne-tower/solution/by-ac_oier-c8jn/ | 中等 | [
"动态规划",
"线性 DP"
] | 我们把玻璃杯摆成金字塔的形状,其中 第一层 有 `1` 个玻璃杯, 第二层 有 `2` 个,依次类推到第 `100` 层,每个玻璃杯 (`250ml`) 将盛有香槟。
从顶层的第一个玻璃杯开始倾倒一些香槟,当顶层的杯子满了,任何溢出的香槟都会立刻等流量的流向左右两侧的玻璃杯。当左右两边的杯子也满了,就会等流量的流向它们左右两边的杯子,依次类推。(当最底层的玻璃杯满了,香槟会流到地板上)
例如,在倾倒一杯香槟后,最顶层的玻璃杯满了。倾倒了两杯香槟后,第二层的两个玻璃杯各自盛放一半的香槟。在倒三杯香槟后,第二层的香槟满了 - 此时总共有三个满的玻璃杯。在倒第四杯后,第三层中间的玻璃杯盛放了一半的香槟,他两边的玻璃杯各自盛放了四分之一的香槟,如下图所示。
现在当倾倒了非负整数杯香槟后,返回第 i 行 j 个玻璃杯所盛放的香槟占玻璃杯容积的比例( i 和 j 都从0开始)。
示例 1:
```
输入: poured(倾倒香槟总杯数) = 1, query_glass(杯子的位置数) = 1, query_row(行数) = 1
输出: 0.00000
解释: 我们在顶层(下标是(0,0))倒了一杯香槟后,没有溢出,因此所有在顶层以下的玻璃杯都是空的。
```
示例 2:
```
输入: poured(倾倒香槟总杯数) = 2, query_glass(杯子的位置数) = 1, query_row(行数) = 1
输出: 0.50000
解释: 我们在顶层(下标是(0,0)倒了两杯香槟后,有一杯量的香槟将从顶层溢出,位于(1,0)的玻璃杯和(1,1)的玻璃杯平分了这一杯香槟,所以每个玻璃杯有一半的香槟。
```
示例 3:
```
输入: poured = 100000009, query_row = 33, query_glass = 17
输出: 1.00000
```
提示:
* $0 <= poured <= 10^9$
* $0 <= query_glass <= query_row < 100$ | ### 线性 DP
为了方便,我们令 `poured` 为 `k`,`query_row` 和 `query_glass` 分别为 $n$ 和 $m$。
定义 $f[i][j]$ 为第 $i$ 行第 $j$ 列杯子所经过的水的流量(而不是最终剩余的水量)。
起始我们有 $f[0][0] = k$,最终答案为 $\min(f[n][m], 1)$。
不失一般性考虑 $f[i][j]$ 能够更新哪些状态:显然当 $f[i][j]$ 不足 $1$ 的时候,不会有水从杯子里溢出,即 $f[i][j]$ 将不能更新其他状态;当 $f[i][j]$ 大于 $1$ 时,将会有 $f[i][j] - 1$ 的水会等量留到下一行的杯子里,所流向的杯子分别是「第 $i + 1$ 行第 $j$ 列的杯子」和「第 $i + 1$ 行第 $j + 1$ 列的杯子」,增加流量均为 $\frac{f[i][j] - 1}{2}$,即有 $f[i + 1][j] += \frac{f[i][j] - 1}{2}$ 和 $f[i + 1][j + 1] += \frac{f[i][j] - 1}{2}$。
Java 代码:
```Java
class Solution {
public double champagneTower(int k, int n, int m) {
double[][] f = new double[n + 10][n + 10];
f[0][0] = k;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (f[i][j] <= 1) continue;
f[i + 1][j] += (f[i][j] - 1) / 2;
f[i + 1][j + 1] += (f[i][j] - 1) / 2;
}
}
return Math.min(f[n][m], 1);
}
}
```
C++ 代码:
```C++
class Solution {
public:
double champagneTower(int k, int n, int m) {
vector<vector<double>> f(n + 10, vector<double>(n + 10, 0.0));
f[0][0] = k;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= i; ++j) {
if (f[i][j] <= 1) continue;
f[i + 1][j] += (f[i][j] - 1.0) / 2.0;
f[i + 1][j + 1] += (f[i][j] - 1.0) / 2.0;
}
}
return min(f[n][m], 1.0);
}
};
```
Python3 代码:
```Python
class Solution:
def champagneTower(self, k: int, n: int, m: int) -> float:
f = [[0] * (n + 10) for _ in range(n + 10)]
f[0][0] = k
for i in range(n + 1):
for j in range(i + 1):
if f[i][j] <= 1:
continue
f[i + 1][j] += (f[i][j] - 1) / 2
f[i + 1][j + 1] += (f[i][j] - 1) / 2
return min(f[n][m], 1)
```
TypeScript 代码:
```TypeScript
function champagneTower(k: number, n: number, m: number): number {
const f = new Array<Array<number>>()
for (let i = 0; i < n + 10; i++) f.push(new Array<number>(n + 10).fill(0))
f[0][0] = k
for (let i = 0; i <= n; i++) {
for (let j = 0; j <= i; j++) {
if (f[i][j] <= 1) continue
f[i + 1][j] += (f[i][j] - 1) / 2
f[i + 1][j + 1] += (f[i][j] - 1) / 2
}
}
return Math.min(f[n][m], 1)
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.799` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/801. 使序列递增的最小交换次数（困难）.md | 801. 使序列递增的最小交换次数 | https://leetcode.cn/problems/minimum-swaps-to-make-sequences-increasing/solution/by-ac_oier-fjhp/ | 困难 | [
"状态机 DP",
"动态规划"
] | 我们有两个长度相等且不为空的整型数组 `nums1` 和 `nums2`。
在一次操作中,我们可以交换 $nums1[i]$ 和 $nums2[i]$ 的元素。
例如,如果 $nums1 = [1,2,3,8]$ ,$nums2 =[5,6,7,4]$ ,你可以交换 $i = 3$ 处的元素,得到 $nums1 =[1,2,3,4]$ 和 $nums2 =[5,6,7,8]$ 。
返回 使 `nums1` 和 `nums2` 严格递增 所需操作的最小次数 。
数组 `arr` 严格递增 且 $arr[0] < arr[1] < arr[2] < ... < arr[arr.length - 1]$ 。
注意:
用例保证可以实现操作。
示例 1:
```
输入: nums1 = [1,3,5,4], nums2 = [1,2,3,7]
输出: 1
解释:
交换 A[3] 和 B[3] 后,两个数组如下:
A = [1, 3, 5, 7] , B = [1, 2, 3, 4]
两个数组均为严格递增的。
```
示例 2:
```
输入: nums1 = [0,3,5,8,9], nums2 = [2,1,4,6,9]
输出: 1
```
提示:
* $2 <= nums1.length <= 10^5$
* $nums2.length = nums1.length$
* $0 <= nums1[i], nums2[i] <= 2 \times 10^5$ | ### 基本分析
这是一道很裸的状态机 DP 运用题。
由于每次交换只会发生在两数组的相同位置上,使得问题变得简单:**仅需考虑交换当前位置后,当前元素与前后元素大小关系变化即可**。
又因为我们会从前往后处理每个位置,因此只需要考虑当前位置与前一位置的大小关系即可。
---
### 状态机 DP
定义 $f[i][j]$ 为考虑下标范围为 $[0, i]$ 的元素,且位置 $i$ 的交换状态为 $j$ 时(其中 $j = 0$ 为不交换,$j = 1$ 为交换)两数组满足严格递增的最小交换次数。
最终答案为 $\min(f[n - 1][0], f[n - 1][1])$,同时我们有显而易见的初始化条件 $f[0][0] = 0$ 和 $f[0][1] = 1$,其余未知状态初始化为正无穷。
不失一般性考虑 $f[i][j]$ 该如何转移:
* 若 $nums1[i] > nums1[i - 1]$ 且 $nums2[i] > nums2[i - 1]$(即顺序位满足要求),此时要么当前位置 $i$ 和前一位置 $i - 1$ 都不交换,要么同时发生交换,此时有(分别对应两个位置「都不交换」和「都交换」):
$$
\begin{cases}
f[i][0] = f[i - 1][0] \\
f[i][1] = f[i - 1][1] + 1
\end{cases}
$$
* 若 $nums1[i] > nums2[i - 1]$ 且 $nums2[i] > nums1[i - 1]$(即交叉位满足要求),此时当前位置 $i$ 和前一位置 $i - 1$ 只能有其一发生交换,此时有(分别对应「前一位置交换」和「当前位置交换」):
$$
\begin{cases}
f[i][0] = \min(f[i][0], f[i - 1][1]); \\
f[i][1] = \min(f[i][1], f[i - 1][0] + 1)
\end{cases}
$$
Java 代码:
```Java
class Solution {
public int minSwap(int[] nums1, int[] nums2) {
int n = nums1.length;
int[][] f = new int[n][2];
for (int i = 1; i < n; i++) f[i][0] = f[i][1] = n + 10;
f[0][1] = 1;
for (int i = 1; i < n; i++) {
if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
f[i][0] = f[i - 1][0];
f[i][1] = f[i - 1][1] + 1;
}
if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
f[i][0] = Math.min(f[i][0], f[i - 1][1]);
f[i][1] = Math.min(f[i][1], f[i - 1][0] + 1);
}
}
return Math.min(f[n - 1][0], f[n - 1][1]);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minSwap(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size();
vector<vector<int>> f(n, vector<int>(2, n + 10));
f[0][0] = 0; f[0][1] = 1;
for (int i = 1; i < n; ++i) {
if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
f[i][0] = f[i - 1][0];
f[i][1] = f[i - 1][1] + 1;
}
if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
f[i][0] = min(f[i][0], f[i - 1][1]);
f[i][1] = min(f[i][1], f[i - 1][0] + 1);
}
}
return min(f[n - 1][0], f[n - 1][1]);
}
};
```
Python 代码:
```Python
class Solution:
def minSwap(self, nums1: List[int], nums2: List[int]) -> int:
n = len(nums1)
f = [[0, 0] for _ in range(n)]
for i in range(1, n):
f[i][0] = f[i][1] = n + 10
f[0][1] = 1
for i in range(1, n):
if nums1[i] > nums1[i - 1] and nums2[i] > nums2[i - 1]:
f[i][0], f[i][1] = f[i - 1][0], f[i - 1][1] + 1
if nums1[i] > nums2[i - 1] and nums2[i] > nums1[i - 1]:
f[i][0], f[i][1] = min(f[i][0], f[i - 1][1]), min(f[i][1], f[i - 1][0] + 1)
return min(f[n - 1][0], f[n - 1][1])
```
TypeScript 代码:
```TypeScript
function minSwap(nums1: number[], nums2: number[]): number {
const n = nums1.length
const f = new Array<Array<number>>(n)
f[0] = [0, 1]
for (let i = 1; i < n; i++) f[i] = [n + 10, n + 10]
for (let i = 1; i < n; i++) {
if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
f[i][0] = f[i - 1][0]
f[i][1] = f[i - 1][1] + 1
}
if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
f[i][0] = Math.min(f[i][0], f[i - 1][1])
f[i][1] = Math.min(f[i][1], f[i - 1][0] + 1)
}
}
return Math.min(f[n - 1][0], f[n - 1][1])
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 滚动数组
利用 $f[i][X]$ 仅依赖于 $f[i - 1][X]$,我们可以采用「滚动数组」的方式,通过机械性操作将空间优化到 $O(1)$。
Java 代码:
```Java
class Solution {
public int minSwap(int[] nums1, int[] nums2) {
int n = nums1.length;
int[][] f = new int[2][2];
f[0][1] = 1;
for (int i = 1; i < n; i++) {
int a = n + 10, b = n + 10;
int prev = (i - 1) & 1, cur = i & 1; // 避免重复的 & 操作
if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
a = f[prev][0];
b = f[prev][1] + 1;
}
if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
a = Math.min(a, f[prev][1]);
b = Math.min(b, f[prev][0] + 1);
}
f[cur][0] = a; f[cur][1] = b;
}
return Math.min(f[(n - 1) & 1][0], f[(n - 1) & 1][1]);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minSwap(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size();
vector<vector<int>> f(2, vector<int>(2, 0));
f[0][1] = 1;
for (int i = 1; i < n; ++i) {
int a = n + 10, b = n + 10;
int prev = (i - 1) & 1, cur = i & 1;
if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
a = f[prev][0];
b = f[prev][1] + 1;
}
if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
a = min(a, f[prev][1]);
b = min(b, f[prev][0] + 1);
}
f[cur][0] = a;
f[cur][1] = b;
}
return min(f[(n - 1) & 1][0], f[(n - 1) & 1][1]);
}
};
```
Python 代码:
```Python
class Solution:
def minSwap(self, nums1: List[int], nums2: List[int]) -> int:
n = len(nums1)
f = [[0, 1], [0, 0]]
for i in range(1, n):
a, b = n + 10, n + 10
prev, cur = (i - 1) & 1, i & 1
if nums1[i] > nums1[i - 1] and nums2[i] > nums2[i - 1]:
a, b = f[prev][0], f[prev][1] + 1
if nums1[i] > nums2[i - 1] and nums2[i] > nums1[i - 1]:
a, b = min(a, f[prev][1]), min(b, f[prev][0] + 1)
f[cur][0], f[cur][1] = a, b
return min(f[(n - 1) & 1][0], f[(n - 1) & 1][1])
```
TypeScript 代码:
```TypeScript
function minSwap(nums1: number[], nums2: number[]): number {
const n = nums1.length
const f = new Array<Array<number>>(2)
f[0] = [0, 1], f[1] = [0, 0]
for (let i = 1; i < n; i++) {
let a = n + 10, b = n + 10
const prev = (i - 1) & 1, cur = i & 1
if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
a = f[prev][0]
b = f[prev][1] + 1
}
if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
a = Math.min(a, f[prev][1])
b = Math.min(b, f[prev][0] + 1)
}
f[cur][0] = a; f[cur][1] = b
}
return Math.min(f[(n - 1) & 1][0], f[(n - 1) & 1][1])
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.801` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/802. 找到最终的安全状态（中等）.md | 802. 找到最终的安全状态 | https://leetcode-cn.com/problems/find-eventual-safe-states/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-isy6u/ | 中等 | [
"图",
"拓扑排序"
] | 在有向图中,以某个节点为起始节点,从该点出发,每一步沿着图中的一条有向边行走。如果到达的节点是终点(即它没有连出的有向边),则停止。
对于一个起始节点,如果从该节点出发,无论每一步选择沿哪条有向边行走,最后必然在有限步内到达终点,则将该起始节点称作是 安全 的。
返回一个由图中所有安全的起始节点组成的数组作为答案。答案数组中的元素应当按 升序 排列。
该有向图有 n 个节点,按 0 到 n - 1 编号,其中 n 是 graph 的节点数。图以下述形式给出:graph[i] 是编号 j 节点的一个列表,满足 (i, j) 是图的一条有向边。
示例 1:
```
输入:graph = [[1,2],[2,3],[5],[0],[5],[],[]]
输出:[2,4,5,6]
解释:示意图如上。
```
示例 2:
```
输入:graph = [[1,2,3,4],[1,2],[3,4],[0,4],[]]
输出:[4]
```
提示:
* n == graph.length
* 1 <= n <= $10^4$
* 0 <= graph[i].length <= n
* graph[i] 按严格递增顺序排列。
* 图中可能包含自环。
* 图中边的数目在范围 [1, 4 * $10^4$] 内。 | ### 基本分析 & 拓扑排序
为了方便,我们令点数为 $n$,边数为 $m$。
**在图论中,一个有向无环图必然存在至少一个拓扑序与之对应,反之亦然。**
如果对拓扑排序不熟悉的小伙伴,可以看看 [拓扑排序](https://baike.baidu.com/item/%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F)。
**简单来说,就是将图中的所有节点展开成一维序列,对于序列中任意的节点 $(u, v)$,如果在序列中 $u$ 在 $v$ 的前面,则说明在图中存在从 $u$ 出发达到 $v$ 的通路,即 $u$ 排在 $v$ 的前面。反之亦然。**
同时,我们需要知晓「入度」和「出度」的概念:
* 入度:有多少条边直接指向该节点;
* 出度:由该节点指出边的有多少条。
因此,对于有向图的拓扑排序,我们可以使用如下思路输出拓扑序(`BFS` 方式):
1. 起始时,将所有入度为 $0$ 的节点进行入队(入度为 $0$,说明没有边指向这些节点,将它们放到拓扑排序的首部,不会违反拓扑序定义);
2. **从队列中进行节点出队操作,出队序列就是对应我们输出的拓扑序**。
对于当前弹出的节点 $x$,遍历 $x$ 的所有出度,即遍历所有由 $x$ 直接指向的节点 $y$,对 $y$ 做入度减一操作(因为 $x$ 节点已经从队列中弹出,被添加到拓扑序中,等价于从 $x$ 节点从有向图中被移除,相应的由 $x$ 发出的边也应当被删除,带来的影响是与 $x$ 相连的节点 $y$ 的入度减一);
3. 对 $y$ 进行入度减一之后,检查 $y$ 的入度是否为 $0$,如果为 $0$ 则将 $y$ 入队(当 $y$ 的入度为 $0$,说明有向图中在 $y$ 前面的所有的节点均被添加到拓扑序中,此时 $y$ 可以作为拓扑序的某个片段的首部被添加,而不是违反拓扑序的定义);
3. 循环流程 $2$、$3$ 直到队列为空。
---
### 证明
上述 `BFS` 方法能够求得「某个有向无环图的拓扑序」的前提是:**我们必然能够找到(至少)一个「入度为 $0$ 的点」,在起始时将其入队。**
这可以使用反证法进行证明:假设有向无环图的拓扑序不存在入度为 $0$ 的点。
**那么从图中的任意节点 $x$ 进行出发,沿着边进行反向检索,由于不存在入度为 $0$ 的节点,因此每个点都能够找到上一个节点。**
**当我们找到一条长度为 $n + 1$ 的反向路径时,由于我们图中只有 $n$ 个节点,因此必然有至少一个节点在该路径中重复出现,即该反向路径中存在环,与我们「有向无环图」的起始条件冲突。**
得证「有向无环图的拓扑序」必然存在(至少)一个「入度为 $0$ 的点」。
即按照上述的 `BFS` 方法,我们能够按照流程迭代下去,直到将有向无环图的所有节点从队列中弹出。
反之,如果一个图不是「有向无环图」的话,我们是无法将所有节点入队的,因此能够通过入队节点数量是否为 $n$ 来判断是否为有向无环图。
---
### 反向图 + 拓扑排序
回到本题,根据题目对「安全节点」的定义,我们知道如果一个节点无法进入「环」的话则是安全的,否则是不安全的。
另外我们发现,**如果想要判断某个节点数 $x$ 是否安全,起始时将 $x$ 进行入队,并跑一遍拓扑排序是不足够的。**
因为我们无法事先确保 $x$ 满足入度为 $0$ 的要求,所以当我们处理到与 $x$ 相连的节点 $y$ 时,可能会存在 $y$ 节点入度无法减到 $0$ 的情况,即我们无法输出真实拓扑序中,从 $x$ 节点开始到结尾的完整部分。
但是根据我们「证明」部分的启发,我们可以将所有边进行反向,这时候「入度」和「出度」翻转了。
对于那些反向图中「入度」为 $0$ 的点集 $x$,其实就是原图中「出度」为 $0$ 的节点,它们「出度」为 $0$,根本没指向任何节点,必然无法进入环,是安全的;同时由它们在反向图中指向的节点(在原图中**只指向**它们的节点),必然也是无法进入环的,对应到反向图中,就是那些减去 $x$ 对应的入度之后,入度为 $0$ 的节点。
因此整个过程就是将图进行反向,再跑一遍拓扑排序,如果某个节点出现在拓扑序列,说明其进入过队列,说明其入度为 $0$,其是安全的,其余节点则是在环内非安全节点。
> 另外,这里的存图方式还是使用前几天一直使用的「链式前向星」,关于几个数组的定义以及其他的存图方式,如果还是有不熟悉的小伙伴可以在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=1711035050&lang=zh_CN#rd) 查阅,本次不再赘述。
代码:
```Java
class Solution {
int N = (int)1e4+10, M = 4 * N;
int idx;
int[] he = new int[N], e = new int[M], ne = new int[M];
int[] cnts = new int[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public List<Integer> eventualSafeNodes(int[][] g) {
int n = g.length;
// 存反向图,并统计入度
Arrays.fill(he, -1);
for (int i = 0; i < n; i++) {
for (int j : g[i]) {
add(j, i);
cnts[i]++;
}
}
// BFS 求反向图拓扑排序
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (cnts[i] == 0) d.addLast(i);
}
while (!d.isEmpty()) {
int poll = d.pollFirst();
for (int i = he[poll]; i != -1; i = ne[i]) {
int j = e[i];
if (--cnts[j] == 0) d.addLast(j);
}
}
// 遍历答案:如果某个节点出现在拓扑序列,说明其进入过队列,说明其入度为 0
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (cnts[i] == 0) ans.add(i);
}
return ans;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.802` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/804. 唯一摩尔斯密码词（简单）.md | 804. 唯一摩尔斯密码词 | https://leetcode-cn.com/problems/unique-morse-code-words/solution/by-ac_oier-a9hv/ | 简单 | [
"模拟"
] | 国际摩尔斯密码定义一种标准编码方式,将每个字母对应于一个由一系列点和短线组成的字符串, 比如:
* `'a'` 对应 `".-"` ,
* `'b'` 对应 `"-..."` ,
* `'c'` 对应 `"-.-."`,以此类推。
为了方便,所有 $26$ 个英文字母的摩尔斯密码表如下:
```
[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
```
给你一个字符串数组 `words`,每个单词可以写成每个字母对应摩尔斯密码的组合。
例如,`"cab"` 可以写成 `"-.-..--..."` ,(即 `"-.-."` + `".-"` + `"-..."` 字符串的结合)。我们将这样一个连接过程称作单词翻译。
对 `words` 中所有单词进行单词翻译,返回不同单词翻译的数量。
示例 1:
```
输入: words = ["gin", "zen", "gig", "msg"]
输出: 2
解释:
各单词翻译如下:
"gin" -> "--...-."
"zen" -> "--...-."
"gig" -> "--...--."
"msg" -> "--...--."
共有 2 种不同翻译, "--...-." 和 "--...--.".
```
示例 2:
```
输入:words = ["a"]
输出:1
```
提示:
* $1 <= words.length <= 100$
* $1 <= words[i].length <= 12$
* $words[i]$ 由小写英文字母组成 | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
String[] ss = new String[]{".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
public int uniqueMorseRepresentations(String[] words) {
Set<String> set = new HashSet<>();
for (String s : words) {
StringBuilder sb = new StringBuilder();
for (char c : s.toCharArray()) sb.append(ss[c - 'a']);
set.add(sb.toString());
}
return set.size();
}
}
```
* 时间复杂度:$O(\sum_{i = 0}^{words.length - 1}words[i].length())$
* 空间复杂度:$O(\sum_{i = 0}^{words.length - 1}words[i].length())$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.804` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/805. 数组的均值分割（困难）.md | 805. 数组的均值分割 | https://leetcode.cn/problems/split-array-with-same-average/solution/gong-shui-san-xie-by-ac_oier-flsd/ | 困难 | [
"折半搜索",
"二进制枚举",
"哈希表"
] | 给定你一个整数数组 `nums`。
我们要将 `nums` 数组中的每个元素移动到 `A` 数组 或者 `B` 数组中,使得 `A` 数组和 `B` 数组不为空,并且 `average(A) == average(B)` 。
如果可以完成则返回 `true`, 否则返回 `false`。
注意:对于数组 `arr`, `average(arr)` 是 `arr` 的所有元素除以 `arr` 长度的和。
示例 1:
```
输入: nums = [1,2,3,4,5,6,7,8]
输出: true
解释: 我们可以将数组分割为 [1,4,5,8] 和 [2,3,6,7], 他们的平均值都是4.5。
```
示例 2:
```
输入: nums = [3,1]
输出: false
```
提示:
* $1 <= nums.length <= 30$
* $0 <= nums[i] <= 10^4$ | ### 折半搜索 + 二进制枚举 + 哈希表 + 数学
##### 提示一:将长度为 $n$,总和为 $sum$ 的原数组划分为两组,使得两数组平均数相同,可推导出该平均数 $avg = \frac{sum}{n}$
若两数组平均数相同,则由两数组组成的新数组(对应原数组 `nums`)平均数不变,而原数组的平均数可直接算得。
##### 提示二:原数组长度为 $30$,直接通过「二进制枚举」的方式来做,计算量为 $2^{30}$,该做法无须额外空间,但会 `TLE`。
所谓的直接使用「二进制枚举」来做,是指用二进制表示中的 `0` 和 `1` 分别代表在划分数组两边。
如果直接对原数组进行「二进制枚举」,由于每个 $nums[i]$ 都有两种决策(归属于数组 `A` 或 `B`),共有 $2^{30}$ 个状态需要计算。同时每个状态 `state` 而言,需要 $O(n)$ 的时间复杂度来判定,但整个过程只需要有限个变量。
因此直接使用「二进制枚举」是一个无须额外空间 `TLE` 做法。
##### 提示三:空间换时间
我们不可避免需要使用「枚举」的思路,也不可避免对每个 $nums[i]$ 有两种决策。**但我们可以考虑缩减每次搜索的长度,将搜索分多次进行。**
具体的,我们可以先对 `nums` 的前半部分进行搜索,并将搜索记录以「二元组 $(tot, cnt)$ 的形式」进行缓存(`map` 套 `set`),其中 `tot` 为划分元素总和,`cnt` 为划分元素个数;随后再对 `nums` 的后半部分进行搜索,假设当前搜索到结果为 $(tot', cnt')$,假设我们能够通过“某种方式”算得另外一半的结果为何值,并能在缓存结果中查得该结果,则说明存在合法划分方案,返回 `true`。
通过「折半 + 缓存结果」的做法,将「累乘」的计算过程优化成「累加」计算过程。
##### 提示四:何为“某种方式”
假设我们已经缓存了前半部分的所有搜索结果,并且在搜索后半部分数组时,当前搜索结果为 $(tot', cnt')$,应该在缓存结果中搜索何值来确定是否存在合法划分方案。
假设存在合法方案,且在缓存结果应当被搜索的结果为 $(x, y)$。我们有 $\frac{tot' + x}{cnt' + y} = avg = \frac{sum}{n}$。
因此我们可以直接枚举系数 $k$ 来进行判定,其中 $k$ 的取值范围为 $[\max(1, cnt'), n - 1]$,结合上式算得 $t = k \times \frac{sum}{n}$,若在缓存结果中存在 $(t - tot', k - cnt')$,说明存在合法方案。
Java 代码:
```Java
class Solution {
public boolean splitArraySameAverage(int[] nums) {
int n = nums.length, m = n / 2, sum = 0;
for (int x : nums) sum += x;
Map<Integer, Set<Integer>> map = new HashMap<>();
for (int s = 0; s < (1 << m); s++) {
int tot = 0, cnt = 0;
for (int i = 0; i < m; i++) {
if (((s >> i) & 1) == 1) {
tot += nums[i]; cnt++;
}
}
Set<Integer> set = map.getOrDefault(tot, new HashSet<>());
set.add(cnt);
map.put(tot, set);
}
for (int s = 0; s < (1 << (n - m)); s++) {
int tot = 0, cnt = 0;
for (int i = 0; i < (n - m); i++) {
if (((s >> i) & 1) == 1) {
tot += nums[i + m]; cnt++;
}
}
for (int k = Math.max(1, cnt); k < n; k++) {
if (k * sum % n != 0) continue;
int t = k * sum / n;
if (!map.containsKey(t - tot)) continue;
if (!map.get(t - tot).contains(k - cnt)) continue;
return true;
}
}
return false;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool splitArraySameAverage(vector<int>& nums) {
int n = nums.size(), m = n / 2, sum = 0;
for (int x : nums) sum += x;
map<int, unordered_set<int>> hashMap;
for (int s = 0; s < (1 << m); s++) {
int tot = 0, cnt = 0;
for (int i = 0; i < m; i++) {
if ((s >> i) & 1) {
tot += nums[i]; cnt++;
}
}
hashMap[tot].insert(cnt);
}
for (int s = 0; s < (1 << (n - m)); s++) {
int tot = 0, cnt = 0;
for (int i = 0; i < (n - m); i++) {
if ((s >> i) & 1) {
tot += nums[i + m]; cnt++;
}
}
for (int k = max(1, cnt); k < n; k++) {
if (k * sum % n != 0) continue;
int t = k * sum / n;
if (hashMap.count(t - tot) == 0) continue;
if (!hashMap[t - tot].count(k - cnt)) continue;
return true;
}
}
return false;
}
};
```
Python 代码:
```Python
from collections import defaultdict
class Solution:
def splitArraySameAverage(self, nums: List[int]) -> bool:
n, m = len(nums), len(nums) // 2
sum_nums = sum(nums)
hash_map = defaultdict(set)
for s in range(1 << m):
tot = cnt = 0
for i in range(m):
if ((s >> i) & 1):
tot += nums[i]
cnt += 1
hash_map[tot].add(cnt)
for s in range(1 << (n - m)):
tot = cnt = 0
for i in range(n - m):
if ((s >> i) & 1):
tot += nums[i + m]
cnt += 1
for k in range(max(1, cnt), n):
if (k * sum_nums) % n != 0: continue
t = (k * sum_nums) // n
if (t - tot) not in hash_map: continue
if (k - cnt) not in hash_map[t - tot]: continue
return True
return False
```
TypeScript 代码:
```TypeScript
function splitArraySameAverage(nums: number[]): boolean {
let n = nums.length, m = Math.floor(n / 2), sum = 0;
for (let x of nums) sum += x;
let map = new Map();
for (let s = 0; s < (1 << m); s++) {
let tot = 0, cnt = 0;
for (let i = 0; i < m; i++) {
if (((s >> i) & 1) == 1) {
tot += nums[i]; cnt++;
}
}
let set = map.get(tot) || new Set();
set.add(cnt);
map.set(tot, set);
}
for (let s = 0; s < (1 << (n - m)); s++) {
let tot = 0, cnt = 0;
for (let i = 0; i < (n - m); i++) {
if (((s >> i) & 1) == 1) {
tot += nums[i + m]; cnt++;
}
}
for (let k = Math.max(1, cnt); k < n; k++) {
if (k * sum % n != 0) continue;
let t = Math.floor(k * sum / n);
if (!map.has(t - tot)) continue;
if (!map.get(t - tot).has(k - cnt)) continue;
return true;
}
}
return false;
};
```
* 时间复杂度:对原数组前半部分搜索复杂度为 $O(2^{\frac{n}{2}})$;对原数组后半部分搜索复杂度为 $O(2^{\frac{n}{2}})$,搜索同时检索前半部分的结果需要枚举系数 `k`,复杂度为 $O(n)$。整体复杂度为 $O(n \times 2^{\frac{n}{2}})$
* 空间复杂度:$O(2^{\frac{n}{2}})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.805` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/806. 写字符串需要的行数（简单）.md | 806. 写字符串需要的行数 | https://leetcode-cn.com/problems/number-of-lines-to-write-string/solution/by-ac_oier-5hg2/ | 简单 | [
"模拟"
] | 我们要把给定的字符串 `S` 从左到右写到每一行上,每一行的最大宽度为 $100$ 个单位,如果我们在写某个字母的时候会使这行超过了 $100$ 个单位,那么我们应该把这个字母写到下一行。
我们给定了一个数组 `widths`,这个数组 $widths[0]$ 代表 `'a'` 需要的单位, $widths[1]$ 代表 `'b'` 需要的单位,..., $widths[25]$ 代表 `'z'` 需要的单位。
现在回答两个问题:至少多少行能放下 `S`,以及最后一行使用的宽度是多少个单位?
将你的答案作为长度为 $2$ 的整数列表返回。
示例 1:
```
输入:
widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
S = "abcdefghijklmnopqrstuvwxyz"
输出: [3, 60]
解释:
所有的字符拥有相同的占用单位10。所以书写所有的26个字母,
我们需要2个整行和占用60个单位的一行。
```
示例 2:
```
输入:
widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
S = "bbbcccdddaaa"
输出: [2, 4]
解释:
除去字母'a'所有的字符都是相同的单位10,并且字符串 "bbbcccdddaa" 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.
最后一个字母 'a' 将会被写到第二行,因为第一行只剩下2个单位了。
所以,这个答案是2行,第二行有4个单位宽度。
```
注:
* 字符串 `S` 的长度在 $[1, 1000]$ 的范围。
* `S` 只包含小写字母。
* `widths` 是长度为 $26$ 的数组。
* $widths[i]$ 值的范围在 $[2, 10]$。 | ### 模拟
根据题意进行模拟即可。
使用变量 `a` 代指当前有多少行是满的,使用变量 `b` 代指当前填充光标所在的位置。
代码:
```Java
class Solution {
public int[] numberOfLines(int[] widths, String s) {
int a = 0, b = 0;
for (char c : s.toCharArray()) {
int t = widths[c - 'a'];
if (b + t > 100 && ++a >= 0) b = t;
else b += t;
}
if (b != 0) a++;
return new int[]{a, b};
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:不使用 `toCharArray` 为 $O(1)$,否则为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.804` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/807. 保持城市天际线（中等）.md | 807. 保持城市天际线 | https://leetcode-cn.com/problems/max-increase-to-keep-city-skyline/solution/gong-shui-san-xie-jian-dan-tan-xin-yun-y-2f47/ | 中等 | [
"贪心"
] | 在二维数组 $grid$ 中,$grid[i][j]$ 代表位于某处的建筑物的高度。 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度。 高度 $0$ 也被认为是建筑物。
最后,从新数组的所有四个方向(即顶部,底部,左侧和右侧)观看的“天际线”必须与原始数组的天际线相同。 城市的天际线是从远处观看时,由所有建筑物形成的矩形的外部轮廓。 请看下面的例子。
建筑物高度可以增加的最大总和是多少?
例子:
```
输入: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
输出: 35
解释:
The grid is:
[ [3, 0, 8, 4],
[2, 4, 5, 7],
[9, 2, 6, 3],
[0, 3, 1, 0] ]
从数组竖直方向(即顶部,底部)看“天际线”是:[9, 4, 8, 7]
从水平水平方向(即左侧,右侧)看“天际线”是:[8, 7, 9, 3]
在不影响天际线的情况下对建筑物进行增高后,新数组如下:
gridNew = [ [8, 4, 8, 7],
[7, 4, 7, 7],
[9, 4, 8, 7],
[3, 3, 3, 3] ]
```
说明:
* $1 < grid.length = grid[0].length <= 50。$
* $ grid[i][j]$ 的高度范围是:$[0, 100]$。
* 一座建筑物占据一个$grid[i][j]$:换言之,它们是 $1 x 1 x grid[i][j]$ 的长方体。 | ### 贪心
根据题意,我们需要确保在调整建筑物高度后,从「水平」和「竖直」两个方向所看到的「行」和「列」的最大高度不变。
因此我们可以先通过 $O(n * m)$ 的复杂度预处理出 `grid` 中每行的最大值(使用 $r$ 数组存储),以及每列的最大值(使用 $c$ 数组存储)。
然后在统计答案时,通过判断当前位置 $g[i][j]$ 与 $\min(r[i], c[j])$ 的大小关系来决定当前位置能够增高多少。
可以证明,当每个位置都取得最大的增大高度(局部最优)时,可使得总的增加高度最大(全局最优)。
代码:
```Java
class Solution {
public int maxIncreaseKeepingSkyline(int[][] grid) {
int n = grid.length, m = grid[0].length;
int[] r = new int[n], c = new int[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
r[i] = Math.max(r[i], grid[i][j]);
c[j] = Math.max(c[j], grid[i][j]);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans += Math.min(r[i], c[j]) - grid[i][j];
}
}
return ans;
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.807` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/808. 分汤（中等）.md | 808. 分汤 | https://leetcode.cn/problems/soup-servings/solution/by-ac_oier-3n1h/ | 中等 | [
"数学",
"动态规划",
"线性 DP"
] | 有 `A` 和 `B` 两种类型 的汤,一开始每种类型的汤有 `n` 毫升。
有四种分配操作:
1. 提供 `100ml` 的 汤A 和 `0ml` 的 汤B 。
2. 提供 `75ml` 的 汤A 和 `25ml` 的 汤B 。
3. 提供 `50ml` 的 汤A 和 `50ml` 的 汤B 。
4. 提供 `25ml` 的 汤A 和 `75ml` 的 汤B 。
当我们把汤分配给某人之后,汤就没有了。
每个回合,我们将从四种概率同为 `0.25` 的操作中进行分配选择。
如果汤的剩余量不足以完成某次操作,我们将尽可能分配。
当两种类型的汤都分配完时,停止操作。
注意 不存在先分配 `100 ml` 汤B 的操作。
需要返回的值:汤A 先分配完的概率 + 汤A和汤B 同时分配完的概率 / 2。
返回值在正确答案 $10^{-5}$ 的范围内将被认为是正确的。
示例 1:
```
输入: n = 50
输出: 0.62500
解释:如果我们选择前两个操作,A 首先将变为空。
对于第三个操作,A 和 B 会同时变为空。
对于第四个操作,B 首先将变为空。
所以 A 变为空的总概率加上 A 和 B 同时变为空的概率的一半是 0.25 *(1 + 1 + 0.5 + 0)= 0.625。
```
示例 2:
```
输入: n = 100
输出: 0.71875
```
提示:
* $0 <= n <= 10^9$ | ### 数学 + 动态规划
四种分配方式都是 $25$ 的倍数,因此我们可以将 $n$ 进行除以 $25$ 上取整的缩放操作,并将四类操作等价成:
1. 提供 `4ml` 的 汤A 和 `0ml` 的 汤B 。
2. 提供 `3ml` 的 汤A 和 `1ml` 的 汤B 。
3. 提供 `2ml` 的 汤A 和 `2ml` 的 汤B 。
4. 提供 `1ml` 的 汤A 和 `3ml` 的 汤B 。
定义 $f[i][j]$ 为 汤A 剩余 $i$ 毫升,汤B 剩余 $j$ 毫升时的最终概率($概率 = 汤A先分配完的概率 + 汤A和汤B同时分配完的概率 \times 0.5$)。
最终答案为 $f[n][n]$ 为最终答案,考虑任意项存在为 $0$ 情况时的边界情况:
* 若 $i = 0$ 且 $j = 0$,结果为 $0 + \frac{1}{2} = \frac{1}{2}$,即有 $f[0][0] = 0.5$
* 若 $i = 0$ 且 $j > 0$,结果为 $1 + 0 = 1$,即有 $f[0][X] = 1$,其中 $X > 1$
* 若 $i > 0$ 且 $j = 0$,结果为 $0 + 0 = 0$,即有 $f[X][0] = 0$,其中 $X > 1$
其余一般情况为 $i$ 和 $j$ 均不为 $0$,由于四类操作均为等概率,结合题意和状态定义可知:
$$
f[i][j] = \frac{1}{4} \times (f[i - 4][j] + f[i - 3][j - 1] + f[i - 2][j - 2] + f[i - 1][j - 3])
$$
由于 $n = 1e9$,即使进行了除 $25$ 的缩放操作,过多的状态数仍会导致 `TLE`。
此时需要利用「返回值在正确答案 $10^{-5}$ 的范围内将被认为是正确的」来做优化(一下子不太好想到):由于四类操作均是等概率,单个回合期望消耗汤 A 的量为 $2.5$,消耗汤 B 的量为 $1.5$。
因此当 $n$ 足够大,操作回合足够多,汤 A 将有较大的概率结束分配,即当 $n$ 足够大,概率值会趋向于 $1$。
我们考虑多大的 $n$ 能够配合精度误差 $10^{-5}$ 来减少计算量:一个可行的操作是利用上述的 DP 思路 + 二分的方式找到符合精度要求的验算值(不超过 $200$)。
Java 代码:
```Java
class Solution {
public double soupServings(int n) {
n = Math.min(200, (int) Math.ceil(n / 25.0));
double[][] f = new double[n + 10][n + 10];
f[0][0] = 0.5;
for (int j = 1; j <= n; j++) f[0][j] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
double a = f[Math.max(i - 4, 0)][j], b = f[Math.max(i - 3, 0)][Math.max(j - 1, 0)];
double c = f[Math.max(i - 2, 0)][Math.max(j - 2, 0)], d = f[Math.max(i - 1, 0)][Math.max(j - 3, 0)];
f[i][j] = 0.25 * (a + b + c + d);
}
}
return f[n][n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
double soupServings(int n) {
n = min(200, (int)ceil(n / 25.0));
vector<vector<double>> f(n + 10, vector<double>(n + 10, 0));
f[0][0] = 0.5;
for (int j = 1; j <= n; ++j) f[0][j] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
double a = f[max(i - 4, 0)][j], b = f[max(i - 3, 0)][max(j - 1, 0)];
double c = f[max(i - 2, 0)][max(j - 2, 0)], d = f[max(i - 1, 0)][max(j - 3, 0)];
f[i][j] = 0.25 * (a + b + c + d);
}
}
return f[n][n];
}
};
```
Python 代码:
```Python
class Solution:
def soupServings(self, n: int) -> float:
n = min(200, math.ceil(n / 25))
f = [[0] * (n + 10) for _ in range(n + 10)]
f[0][0] = 0.5
for j in range(1, n + 10):
f[0][j] = 1
for i in range(1, n + 1):
for j in range(1, n + 1):
a, b = f[max(i - 4, 0)][j], f[max(i - 3, 0)][max(j - 1, 0)]
c, d = f[max(i - 2, 0)][max(j - 2, 0)], f[max(i - 1, 0)][max(j - 3, 0)]
f[i][j] = 0.25 * (a + b + c + d)
return f[n][n]
```
TypeScript 代码:
```TypeScript
function soupServings(n: number): number {
n = Math.min(200, Math.ceil(n / 25.0));
const f: number[][] = Array(n + 10).fill(0).map(() => Array(n + 10).fill(0));
f[0][0] = 0.5;
for (let j = 1; j <= n; j++) f[0][j] = 1;
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= n; j++) {
let a = f[Math.max(i - 4, 0)][j], b = f[Math.max(i - 3, 0)][Math.max(j - 1, 0)];
let c = f[Math.max(i - 2, 0)][Math.max(j - 2, 0)], d = f[Math.max(i - 1, 0)][Math.max(j - 3, 0)];
f[i][j] = 0.25 * (a + b + c + d);
}
}
return f[n][n];
};
```
* 时间复杂度:$O(m^2)$,其中 $m = 200$ 为验算值
* 空间复杂度:$O(m^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.808` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/809. 情感丰富的文字（中等）.md | 809. 情感丰富的文字 | https://leetcode.cn/problems/expressive-words/solution/by-ac_oier-tb57/ | 中等 | [
"双指针",
"模拟"
] | 有时候人们会用重复写一些字母来表示额外的感受,比如 `"hello" -> "heeellooo", "hi" -> "hiii"`。我们将相邻字母都相同的一串字符定义为相同字母组,例如:`"h", "eee", "ll", "ooo"`。
对于一个给定的字符串 `S` ,如果另一个单词能够通过将一些字母组扩张从而使其和 `S` 相同,我们将这个单词定义为可扩张的(`stretchy`)。
扩张操作定义如下:选择一个字母组(包含字母 `c` ),然后往其中添加相同的字母 `c` 使其长度达到 `3` 或以上。
例如,以 `"hello"` 为例:
我们可以对字母组 `"o"` 扩张得到 `"hellooo"`,但是无法以同样的方法得到 `"helloo"` 因为字母组 `"oo"` 长度小于 `3`。此外,我们可以进行另一种扩张 `"ll" -> "lllll"` 以获得 `"helllllooo"`。
如果 `S = "helllllooo"`,那么查询词 `"hello"` 是可扩张的,因为可以对它执行这两种扩张操作使得 `query = "hello" -> "hellooo" -> "helllllooo" = S`。
输入一组查询单词,输出其中可扩张的单词数量。
示例:
```
输入:
S = "heeellooo"
words = ["hello", "hi", "helo"]
输出:1
解释:
我们能通过扩张 "hello" 的 "e" 和 "o" 来得到 "heeellooo"。
我们不能通过扩张 "helo" 来得到 "heeellooo" 因为 "ll" 的长度小于 3 。
```
提示:
* $0 <= len(S) <= 100$
* $0 <= len(words) <= 100$
* $0 <= len(words[i]) <= 100$
* `S` 和所有在 `words` 中的单词都只由小写字母组成。 | ### 双指针
该题最难的部分就是理解 “扩张” 操作:假设有两个字符相同的连续段 `a` 和 `b`,如何判断 `a` 是否能由 `b` 扩张而来。
忘记掉题目所说的规则,我们重新定义 “扩张” 操作:
* 当 `a` 和 `b` 长度相同,定义为可扩张;
* 当 `a` 和 `b` 长度不同,根据「`a` 和 `b` 长度对比」以及「`a` 的长度大小」分情况讨论:
* 当 `b` 长度大于 `a`,不可扩张;
* 当 `a` 长度大于 `b`,**我们不一定要拿整一段的 `b` 进行扩张,可以拿 `b` 中的一个字符进行扩张。** 因此只需要满足扩张后的长度(`a` 的长度)大于等于 $3$ 即可定义为可扩张。
搞明白何为 “扩张” 后,剩余的则是简单的「双指针 + 模拟」做法。
Java 代码:
```Java
class Solution {
public int expressiveWords(String s, String[] words) {
int n = s.length(), ans = 0;
out:for (String word : words) {
int m = word.length(), i = 0, j = 0;
while (i < n && j < m) {
if (s.charAt(i) != word.charAt(j)) continue out;
int a = i, b = j;
while (a < n && s.charAt(a) == s.charAt(i)) a++;
while (b < m && word.charAt(b) == word.charAt(j)) b++;
a -= i; b -= j;
if (a != b && (b > a || a < 3)) continue out;
i += a; j += b;
}
if (i == n && j == m) ans++;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int expressiveWords(string s, vector<string>& words) {
int n = s.size(), ans = 0;
for (const string &word : words) {
int m = word.size(), i = 0, j = 0;
while (i < n && j < m) {
if (s[i] != word[j]) break;
int a = i, b = j;
while (a < n && s[a] == s[i]) a++;
while (b < m && word[b] == word[j]) b++;
a -= i; b -= j;
if (a != b && (b > a || a < 3)) break;
i += a; j += b;
if (i == n && j == m) ans++;
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def expressiveWords(self, s: str, words: List[str]) -> int:
n, ans = len(s), 0
for word in words:
m, i, j = len(word), 0, 0
ok = True
while ok and i < n and j < m:
if s[i] != word[j]:
ok = False
a, b = i, j
while a < n and s[a] == s[i]:
a += 1
while b < m and word[b] == word[j]:
b += 1
a, b = a - i, b - j
if a != b and (b > a or a < 3):
ok = False
i, j = i + a, j + b
if ok and i == n and j == m:
ans += 1
return ans
```
TypeScript 代码:
```TypeScript
function expressiveWords(s: string, words: string[]): number {
let n = s.length, ans = 0
out:for (const word of words) {
let m = word.length, i = 0, j = 0
while (i < n && j < m) {
if (s[i] != word[j]) continue out
let a = i, b = j
while (a < n && s[a] == s[i]) a++
while (b < m && word[b] == word[j]) b++
a -= i; b -= j;
if (a != b && (b > a || a < 3)) continue out
i += a; j += b;
}
if (i == n && j == m) ans++;
}
return ans
}
```
* 时间复杂度:$O(n \times m + \sum_{i = 0}^{m - 1}words[i].length)$,其中 `n` 为字符串 `s` 的长度,`m` 为数组 `words` 的长度
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.809` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/801-810/810. 黑板异或游戏（困难）.md | 810. 黑板异或游戏 | https://leetcode-cn.com/problems/chalkboard-xor-game/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ges7k/ | 困难 | [
"博弈论",
"数学",
"异或"
] | 黑板上写着一个非负整数数组 `nums[i]` 。
`Alice` 和 `Bob` 轮流从黑板上擦掉一个数字,`Alice` 先手。如果擦除一个数字后,剩余的所有数字按位异或运算得出的结果等于 `0` 的话,当前玩家游戏失败。 (另外,如果只剩一个数字,按位异或运算得到它本身;如果无数字剩余,按位异或运算结果为 `0`。)
换种说法就是,轮到某个玩家时,如果当前黑板上所有数字按位异或运算结果等于 `0`,这个玩家获胜。
假设两个玩家每步都使用最优解,当且仅当 `Alice` 获胜时返回 `true`。
示例:
```
输入: nums = [1, 1, 2]
输出: false
解释:
Alice 有两个选择: 擦掉数字 1 或 2。
如果擦掉 1, 数组变成 [1, 2]。剩余数字按位异或得到 1 XOR 2 = 3。那么 Bob 可以擦掉任意数字,因为 Alice 会成为擦掉最后一个数字的人,她总是会输。
如果 Alice 擦掉 2,那么数组变成[1, 1]。剩余数字按位异或得到 1 XOR 1 = 0。Alice 仍然会输掉游戏。
```
提示:
* $1 <= N <= 1000$
* $0 <= nums[i] <= 2^{16}$ | ### 基本分析
这是一道「博弈论」题。
如果没接触过博弈论,其实很难想到,特别是数据范围为 $10^3$,很具有迷惑性。
如果接触过博弈论,对于这种「判断先手后手的必胜必败」的题目,博弈论方向是一个优先考虑的方向。
根据题意,如果某位玩家在操作前所有数值异或和为 $0$,那么该玩家胜利。要我们判断给定序列时,先手是处于「必胜态」还是「必败态」,如果处于「必胜态」返回 `True`,否则返回 `False`。
对于博弈论的题目,通常有两类的思考方式:
1. 经验分析:见过类似的题目,猜一个性质,然后去证明该性质是否可推广。
2. 状态分析:根据题目给定的规则是判断「胜利」还是「失败」来决定优先分析「必胜态」还是「必败态」时具有何种性质,然后证明性质是否可推广。
---
### 博弈论
**对于本题,给定的是判断「胜利」的规则(在给定序列的情况下,如果所有数值异或和为 $0$ 可立即判断胜利,其他情况无法立即判断胜负),那么我们应该优先判断何为「先手必胜态」,如果不好分析,才考虑分析后手的「必败态」。**
接下来是分情况讨论:
#### 1. 如果给定的序列异或和为 $0$,游戏开始时,先手直接获胜:
由此推导出性质一:**给定序列 `nums` 的异或和为 $0$,先手处于「必胜态」,返回 `True`。**
#### 2. 如果给定序列异或和不为 $0$,我们需要分析,先手获胜的话,序列会满足何种性质:
显然如果要先手获胜,则需要满足「**先手去掉一个数,剩余数值异或和必然不为 $0$;同时后手去掉一个数后,剩余数值异或和必然为 $0$**」。
换句话说,我们需要分析**什么情况下「经过一次后手操作」后,序列会以上述情况 $1$ 的状态,回到先手的局面**。
也就是反过来分析想要出现「后手必败态」,序列会有何种性质。
假设后手操作前的异或和为 $Sum$($Sum \neq 0$),「后手必败态」意味着去掉任意数字后异或和为 $0$。
同时根据「相同数值异或结果为 $0$」的特性,我们知道去掉某个数值,等价于在原有异或和的基础上异或上这个值。
则有:
$$
Sum' = Sum ⊕ nums[i] = 0
$$
由于是「后手必败态」,因此 $i$ 取任意一位,都满足上述式子。
则有:
$$
Sum ⊕ nums[0] = ... = Sum ⊕ nums[k] = ... = Sum ⊕ nums[n - 1] = 0
$$
同时根据「任意数值与 $0$ 异或数值不变」的特性,我们将每一项进行异或:
$$
(Sum ⊕ nums[0]) ⊕ ... ⊕ (Sum ⊕ nums[k]) ⊕ ... ⊕ (Sum ⊕ nums[n - 1]) = 0
$$
根据交换律进行变换:
$$
(Sum ⊕ Sum ⊕ ... ⊕ Sum) ⊕ (nums[0] ⊕ ... ⊕ nums[k] ⊕ ... ⊕ nums[n - 1]) = 0
$$
再结合 $Sum$ 为原序列的异或和可得:
$$
(Sum ⊕ Sum ⊕ ... ⊕ Sum) ⊕ Sum = 0 , Sum \neq 0
$$
至此,我们分析出当处于「后手必败态」时,去掉任意一个数值会满足上述式子。
根据「相同数值偶数次异或结果为 $0$」的特性,可推导出「后手必败态」会导致交回到先手的序列个数为偶数,由此推导后手操作前序列个数为奇数,后手操作前一个回合为偶数。
到这一步,我们推导出想要出现「后手必败态」,先手操作前的序列个数应当为偶数。
那么根据先手操作前序列个数为偶数(且异或和不为 $0$),是否能够推导出必然出现「后手必败态」呢?
**显然是可以的,因为如果不出现「后手必败态」,会与我们前面分析过程矛盾。**
假设先手操作前异或和为 $Xor$(序列数量为偶数,同时 $Xor \neq 0$),如果最终不出现「后手必败态」的话,也就是先手会输掉的话,那么意味着有 $Xor ⊕ nums[i] = 0$,其中 $i$ 为序列的任意位置。利用此性质,像上述分析那样,将每一项进行展开异或,会得到奇数个 $Xor$ 异或结果为 $0$,这与开始的 $Xor \neq 0$ 矛盾。
由此推导出性质二:**只需要保证先手操作前序列个数为偶数时就会出现「后手必败态」,从而确保先手必胜。**
**综上,如果序列 `nums` 本身异或和为 $0$,天然符合「先手必胜态」的条件,答案返回 `True` ;如果序列 `nums` 异或和不为 $0$,但序列长度为偶数,那么最终会出现「后手必败态」,推导出先手必胜,答案返回 `True`。**
代码:
```Java
class Solution {
public boolean xorGame(int[] nums) {
int sum = 0;
for (int i : nums) sum ^= i;
return sum == 0 || nums.length % 2 == 0;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 总结
事实上,在做题的时候,我也是采取「先假定奇偶性,再证明」的做法,因为这样比较快。
但「假定奇偶性」这一步是比较具有跳跃性的,这有点像我前面说到的「经验分析解法」,而本题解证明没有做任何的前置假定,单纯从「先手必胜态」和「后手必败态」进行推导,最终推导出「先手序列偶数必胜」的性质 ,更符合前面说到的「状态分析解法」。
两种做法殊途同归,在某些博弈论问题上,「经验分析解法」可以通过「归纳」&「反证」很好分析出来,但这要求选手本身具有一定的博弈论基础;而「状态分析解法」则对选手的题量要求低些,逻辑推理能力高些。
两种方法并无优劣之分,都是科学严谨的做法。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.810` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/81. 搜索旋转排序数组 II（中等）.md | 81. 搜索旋转排序数组 II | https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/ | 中等 | [
"二分"
] | 已知存在一个按非降序排列的整数数组 nums ,数组中的值不必互不相同。
在传递给函数之前,nums 在预先未知的某个下标 k(0 <= k < nums.length)上进行了 旋转 ,使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]](下标 从 0 开始 计数)。例如, [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。
给你 旋转后 的数组 nums 和一个整数 target ,请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ,则返回 true ,否则返回 false 。
示例 1:
```
输入:nums = [2,5,6,0,0,1,2], target = 0
输出:true
```
示例 2:
```
输入:nums = [2,5,6,0,0,1,2], target = 3
输出:false
```
提示:
* 1 <= nums.length <= 5000
* -$10^4$ <= nums[i] <= $10^4$
* 题目数据保证 nums 在预先未知的某个下标上进行了旋转
* -$10^4$ <= target <= $10^4$ | ### 二分
根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。
但和 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode-solut/) 不同的是,本题元素并不唯一。
**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**
**因为「二分」的本质是二段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。**
如果你有看过我 [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/) 这篇题解,你应该很容易就理解上句话的意思。如果没有也没关系,我们可以先解决本题,在理解后你再去做 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode-solut/),我认为这两题都是一样的,不存在先后关系。
举个🌰,我们使用数据 [0,1,2,2,2,3,4,5] 来理解为什么不同的旋转点会导致「二段性丢失」:
代码:
```java []
class Solution {
public boolean search(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
// 恢复二段性
while (l < r && nums[0] == nums[r]) r--;
// 第一次二分,找旋转点
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] >= nums[0]) {
l = mid;
} else {
r = mid - 1;
}
}
int idx = n;
if (nums[r] >= nums[0] && r + 1 < n) idx = r + 1;
// 第二次二分,找目标值
int ans = find(nums, 0, idx - 1, t);
if (ans != -1) return true;
ans = find(nums, idx, n - 1, t);
return ans != -1;
}
int find(int[] nums, int l, int r, int t) {
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= t) {
r = mid;
} else {
l = mid + 1;
}
}
return nums[r] == t ? r : -1;
}
}
```
* 时间复杂度:恢复二段性处理中,最坏的情况下(考虑整个数组都是同一个数)复杂度是 $O(n)$,而之后的找旋转点和目标值都是「二分」,复杂度为 $O(log{n})$。整体复杂度为 $O(n)$ 的。
* 空间复杂度:$O(1)$。
***
### 进阶
如果真正理解「二分」的话,本题和 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode-solut/) 区别不大。
建议大家在完成两题的基础上试试 [面试题 10.03. 搜索旋转数组](https://leetcode-cn.com/problems/search-rotate-array-lcci/) 。
***
### 其他「二分」相关题解
* 二分模板
[29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)
* 二分本质 & 恢复二段性处理
[33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)
[81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)
[153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)
[154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)
* 二分 check 函数如何确定
[34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)
* 二分答案的题目
[1482. 制作 m 束花所需的最少天数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/) : [利用「二段性」找分割点,以及优化 check 函数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/)
[1011. 在 D 天内送达包裹的能力](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/) : [利用「二段性」找分割点,以及如何确定「二分范围」](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.81` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/82. 删除排序链表中的重复元素 II（中等）.md | 82. 删除排序链表中的重复元素 II | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/solution/tong-yong-shan-chu-zhong-fu-jie-dian-lia-od9g/ | 中等 | [
"链表"
] | 存在一个按升序排列的链表,给你这个链表的头节点 `head`,请你删除链表中所有存在数字重复情况的节点,只保留原始链表中没有重复出现的数字。
返回同样按升序排列的结果链表。
示例 1:
```
输入:head = [1,2,3,3,4,4,5]
输出:[1,2,5]
```
示例 2:
```
输入:head = [1,1,1,2,3]
输出:[2,3]
```
提示:
* 链表中节点数目在范围 $[0, 300]$ 内
* $-100 <= Node.val <= 100$
* 题目数据保证链表已经按升序排列 | ### 基本思路
几乎所有的链表题目,都具有相似的解题思路。
1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面
2. 使用 `tail` 代表当前有效链表的结尾
3. 通过原输入的 `head` 指针进行链表扫描
我们会确保「进入外层循环时 `head` 不会与上一节点相同」,因此插入时机:
1. `head` 已经没有下一个节点,`head` 可以被插入
2. `head` 有一下个节点,但是值与 `head` 不相同,`head` 可以被插入
Java 代码:
```Java
class Solution {
public ListNode deleteDuplicates(ListNode head) {
ListNode dummy = new ListNode();
ListNode tail = dummy;
while (head != null) {
// 进入循环时,确保了 head 不会与上一节点相同
if (head.next == null || head.val != head.next.val) {
tail.next = head;
tail = head;
}
// 如果 head 与下一节点相同,跳过相同节点
while (head.next != null && head.val == head.next.val) head = head.next;
head = head.next;
}
tail.next = null;
return dummy.next;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode* dummy = new ListNode();
ListNode* tail = dummy;
while (head != nullptr) {
// 进入循环时,确保了 head 不会与上一节点相同
if (head->next == nullptr || head->val != head->next->val) {
tail->next = head;
tail = head;
}
// 如果 head 与下一节点相同,跳过相同节点
while (head->next != nullptr && head->val == head->next->val) head = head->next;
head = head->next;
}
tail->next = nullptr;
return dummy->next;
}
};
```
Python 代码:
```Python
class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode()
tail = dummy
while head:
# 进入循环时,确保了 head 不会与上一节点相同
if not head.next or head.val != head.next.val:
tail.next = head
tail = head
# 如果 head 与下一节点相同,跳过相同节点
while head.next and head.val == head.next.val: head = head.next
head = head.next
tail.next = None
return dummy.next
```
TypeScript 代码:
```TypeScript
function deleteDuplicates(head: ListNode | null): ListNode | null {
const dummy: ListNode = new ListNode();
let tail: ListNode | null = dummy;
while (head) {
// 进入循环时,确保了 head 不会与上一节点相同
if (!head.next || head.val !== head.next.val) {
tail.next = head;
tail = head;
}
// 如果 head 与下一节点相同,跳过相同节点
while (head.next && head.val === head.next.val) head = head.next;
head = head.next;
}
tail.next = null;
return dummy.next;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 拓展
如果问题变为「相同节点保留一个」,该如何实现?
还是类似的解题思路。
1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面
2. 使用 `tail` 代表当前有效链表的结尾
3. 通过原输入的 `head` 指针进行链表扫描
Java 代码:
```Java
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if (head == null) return head;
ListNode dummy = new ListNode(-109);
ListNode tail = dummy;
while (head != null) {
// 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if (tail.val != head.val) {
tail.next = head;
tail = tail.next;
}
head = head.next;
}
tail.next = null;
return dummy.next;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if (!head) return head;
ListNode* dummy = new ListNode(-109);
ListNode* tail = dummy;
while (head) {
// 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if (tail->val != head->val) {
tail->next = head;
tail = tail->next;
}
head = head->next;
}
tail->next = nullptr;
return dummy->next;
}
};
```
Python 代码:
```Python
class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
if not head: return head
dummy = ListNode(-109)
tail = dummy
while head:
# 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if tail.val != head.val:
tail.next = head
tail = tail.next
head = head.next
tail.next = None
return dummy.next
```
TypeScript 代码:
```TypeScript
function deleteDuplicates(head: ListNode | null): ListNode | null {
if (!head) return head;
const dummy: ListNode = new ListNode(-109);
let tail: ListNode | null = dummy;
while (head) {
// 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if (tail.val !== head.val) {
tail.next = head;
tail = tail.next;
}
head = head.next;
}
tail.next = null;
return dummy.next;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.82` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/83. 删除排序链表中的重复元素（简单）.md | 83. 删除排序链表中的重复元素 | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/solution/tong-yong-shan-chu-zhong-fu-jie-dian-lia-101c/ | 简单 | [
"链表"
] | 存在一个按升序排列的链表,给你这个链表的头节点 `head`,请你删除所有重复的元素,使每个元素只出现一次 。
返回同样按升序排列的结果链表。
示例 1:
```
输入:head = [1,1,2]
输出:[1,2]
```
示例 2:
```
输入:head = [1,1,2,3,3]
输出:[1,2,3]
```
提示:
* 链表中节点数目在范围 $[0, 300]$ 内
* $-100 <= Node.val <= 100$
* 题目数据保证链表已经按升序排列 | ### 基本思路
几乎所有的链表题目,都具有相似的解题思路。
1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面
2. 使用 `tail` 代表当前有效链表的结尾
3. 通过原输入的 `head` 指针进行链表扫描
Java 代码:
```Java
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if (head == null) return head;
ListNode dummy = new ListNode(-109);
ListNode tail = dummy;
while (head != null) {
// 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if (tail.val != head.val) {
tail.next = head;
tail = tail.next;
}
head = head.next;
}
tail.next = null;
return dummy.next;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if (!head) return head;
ListNode* dummy = new ListNode(-109);
ListNode* tail = dummy;
while (head) {
// 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if (tail->val != head->val) {
tail->next = head;
tail = tail->next;
}
head = head->next;
}
tail->next = nullptr;
return dummy->next;
}
};
```
Python 代码:
```Python
class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
if not head: return head
dummy = ListNode(-109)
tail = dummy
while head:
# 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if tail.val != head.val:
tail.next = head
tail = tail.next
head = head.next
tail.next = None
return dummy.next
```
TypeScript 代码:
```TypeScript
function deleteDuplicates(head: ListNode | null): ListNode | null {
if (!head) return head;
const dummy: ListNode = new ListNode(-109);
let tail: ListNode | null = dummy;
while (head) {
// 值不相等才追加,确保了相同的节点只有第一个会被添加到答案
if (tail.val !== head.val) {
tail.next = head;
tail = tail.next;
}
head = head.next;
}
tail.next = null;
return dummy.next;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 拓展
如果问题变为「重复元素全部删除」,该如何实现?
还是类似的解题思路。
1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面
2. 使用 `tail` 代表当前有效链表的结尾
3. 通过原输入的 `head` 指针进行链表扫描
我们会确保「进入外层循环时 `head` 不会与上一节点相同」,因此插入时机:
1. `head` 已经没有下一个节点,`head` 可以被插入
2. `head` 有一下个节点,但是值与 `head` 不相同,`head` 可以被插入
Java 代码:
```Java
class Solution {
public ListNode deleteDuplicates(ListNode head) {
ListNode dummy = new ListNode();
ListNode tail = dummy;
while (head != null) {
// 进入循环时,确保了 head 不会与上一节点相同
if (head.next == null || head.val != head.next.val) {
tail.next = head;
tail = head;
}
// 如果 head 与下一节点相同,跳过相同节点
while (head.next != null && head.val == head.next.val) head = head.next;
head = head.next;
}
tail.next = null;
return dummy.next;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode* dummy = new ListNode();
ListNode* tail = dummy;
while (head != nullptr) {
// 进入循环时,确保了 head 不会与上一节点相同
if (head->next == nullptr || head->val != head->next->val) {
tail->next = head;
tail = head;
}
// 如果 head 与下一节点相同,跳过相同节点
while (head->next != nullptr && head->val == head->next->val) head = head->next;
head = head->next;
}
tail->next = nullptr;
return dummy->next;
}
};
```
Python 代码:
```Python
class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode()
tail = dummy
while head:
# 进入循环时,确保了 head 不会与上一节点相同
if not head.next or head.val != head.next.val:
tail.next = head
tail = head
# 如果 head 与下一节点相同,跳过相同节点
while head.next and head.val == head.next.val: head = head.next
head = head.next
tail.next = None
return dummy.next
```
TypeScript 代码:
```TypeScript
function deleteDuplicates(head: ListNode | null): ListNode | null {
const dummy: ListNode = new ListNode();
let tail: ListNode | null = dummy;
while (head) {
// 进入循环时,确保了 head 不会与上一节点相同
if (!head.next || head.val !== head.next.val) {
tail.next = head;
tail = head;
}
// 如果 head 与下一节点相同,跳过相同节点
while (head.next && head.val === head.next.val) head = head.next;
head = head.next;
}
tail.next = null;
return dummy.next;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.83` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/84. 柱状图中最大的矩形（困难）.md | 84. 柱状图中最大的矩形 | https://leetcode.cn/problems/largest-rectangle-in-histogram/solution/by-ac_oier-i470/ | 困难 | [
"单调栈"
] | 给定 `n` 个非负整数,用来表示柱状图中各个柱子的高度。每个柱子彼此相邻,且宽度为 `1` 。
求在该柱状图中,能够勾勒出来的矩形的最大面积。
示例 1:
```
输入:heights = [2,1,5,6,2,3]
输出:10
解释:最大的矩形为图中红色区域,面积为 10
```
示例 2:
```
输入: heights = [2,4]
输出: 4
```
提示:
* $1 <= heights.length <=10^5$
* $0 <= heights[i] <= 10^4$ | ### 单调栈 + 枚举高度
为了方便,我们令 `heights` 为 `hs`。
最终矩形的高度必然取自某个 $hs[i]$,因此我们可以枚举最终矩形的高度来做。
问题转换为当使用某个 $hs[i]$ 作为矩形高度时,该矩形所能取得的最大宽度为多少。
假设我们能够预处理出 `l` 和 `r` 数组,其中 $l[i]$ 代表位置 $i$ 左边最近一个比其小的位置(初始值为 $-1$),$r[i]$ 代表位置 $i$ 右边最近一个比其小的位置(初始值为 $n$),那么 $r[i] - l[i] - 1$ 则是以 $hs[i]$ 作为矩形高度时所能取得的最大宽度。
预处理 `l` 和 `r` 则是经典的「求最近一个比当前值大的位置」单调栈问题。
Java 代码:
```Java
class Solution {
public int largestRectangleArea(int[] hs) {
int n = hs.length;
int[] l = new int[n], r = new int[n];
Arrays.fill(l, -1); Arrays.fill(r, n);
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && hs[d.peekLast()] > hs[i]) r[d.pollLast()] = i;
d.addLast(i);
}
d.clear();
for (int i = n - 1; i >= 0; i--) {
while (!d.isEmpty() && hs[d.peekLast()] > hs[i]) l[d.pollLast()] = i;
d.addLast(i);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int t = hs[i], a = l[i], b = r[i];
ans = Math.max(ans, (b - a - 1) * t);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function largestRectangleArea(hs: number[]): number {
const n = hs.length
const l = new Array<number>(n).fill(-1), r = new Array<number>(n).fill(n)
const stk = new Array<number>(n).fill(-1)
let he = 0, ta = 0
for (let i = 0; i < n; i++) {
while (he < ta && hs[stk[ta - 1]] > hs[i]) r[stk[--ta]] = i
stk[ta++] = i
}
he = ta = 0
for (let i = n - 1; i >= 0; i--) {
while (he < ta && hs[stk[ta - 1]] > hs[i]) l[stk[--ta]] = i
stk[ta++] = i
}
let ans = 0
for (let i = 0; i < n; i++) {
const t = hs[i], a = l[i], b = r[i]
ans = Math.max(ans, (b - a - 1) * t)
}
return ans
};
```
Python 代码:
```Python
class Solution:
def largestRectangleArea(self, hs: List[int]) -> int:
n, he, ta = len(hs), 0, 0
stk = [0] * n
l, r = [-1] * n, [n] * n
for i in range(n):
while he < ta and hs[stk[ta - 1]] > hs[i]:
ta -= 1
r[stk[ta]] = i
stk[ta] = i
ta += 1
he = ta = 0
for i in range(n - 1, -1, -1):
while he < ta and hs[stk[ta - 1]] > hs[i]:
ta -= 1
l[stk[ta]] = i
stk[ta] = i
ta += 1
ans = 0
for i in range(n):
ans = max(ans, (r[i] - l[i] - 1) * hs[i])
return ans
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.84` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/85. 最大矩形（困难）.md | 85. 最大矩形 | https://leetcode.cn/problems/maximal-rectangle/solution/by-ac_oier-k02i/ | 困难 | [
"单调栈",
"前缀和"
] | 给定一个仅包含 `0` 和 `1` 、大小为 `rows x cols` 的二维二进制矩阵,找出只包含 `1` 的最大矩形,并返回其面积。
示例 1:
```
输入:matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
输出:6
解释:最大矩形如上图所示。
```
示例 2:
```
输入:matrix = []
输出:0
```
示例 3:
```
输入:matrix = [["0"]]
输出:0
```
示例 4:
```
输入:matrix = [["1"]]
输出:1
```
示例 5:
```
输入:matrix = [["0","0"]]
输出:0
```
提示:
* $rows = matrix.length$
* $cols = matrix[0].length$
* $1 <= row, cols <= 200$
* `matrix[i][j]` 为 `'0'` 或 `'1'` | ### 前缀和 + 单调栈
为了方便,我们令 `matrix` 为 `mat`,记矩阵的行高为 $n$,矩阵的列宽为 $m$。
定义坐标系 : 左上角坐标为 $(1, 1)$,右下角坐标为 $(n, m)$。
我们将 `mat` 的每一行作为基准,以基准线为起点,往上连续 $1$ 的个数为高度。
以题目样例进行说明:
1. 红框部分代表「以第一行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时只有第一行,可得:$[1, 0, 1, 0, 0]$
2. 黄框部分代表「以第二行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时有第一行和第二行,可得:$[2, 0, 2, 1, 1]$
3. 蓝框部分代表「以第三行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时有三行,可得:$[3, 1, 3, 2, 2]$
...
**将原矩阵进行这样的转换好处是 : 对于原矩中面积最大的矩形,其下边缘必然对应了某一条基准线,从而将问题转换为[(题解)84. 柱状图中最大的矩形](https://leetcode.cn/problems/largest-rectangle-in-histogram/solution/by-ac_oier-i470/) 。**
预处理基准线数据可以通过前缀和思想来做,构建一个二维数组 `sum`(为了方便,我们令二维数组下标从 $1$ 开始)并从上往下地构造:
$$
sum[i][j] = \begin{cases}
0 & mat[i][j] = 0 \\
sum[i - 1][j] + 1 & mat[i][j] = 1 \\
\end{cases}
$$
当有了 `sum` 之后,则是和 [(题解)84. 柱状图中最大的矩形](https://leetcode.cn/problems/largest-rectangle-in-histogram/solution/by-ac_oier-i470/) 一样的做法 : 枚举高度 + 单调栈。
Java 代码:
```Java
class Solution {
public int maximalRectangle(char[][] mat) {
int n = mat.length, m = mat[0].length, ans = 0;
int[][] sum = new int[n + 10][m + 10];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum[i][j] = mat[i - 1][j - 1] == '0' ? 0 : sum[i - 1][j] + 1;
}
}
int[] l = new int[m + 10], r = new int[m + 10];
for (int i = 1; i <= n; i++) {
int[] cur = sum[i];
Arrays.fill(l, 0); Arrays.fill(r, m + 1);
Deque<Integer> d = new ArrayDeque<>();
for (int j = 1; j <= m; j++) {
while (!d.isEmpty() && cur[d.peekLast()] > cur[j]) r[d.pollLast()] = j;
d.addLast(j);
}
d.clear();
for (int j = m; j >= 1; j--) {
while (!d.isEmpty() && cur[d.peekLast()] > cur[j]) l[d.pollLast()] = j;
d.addLast(j);
}
for (int j = 1; j <= m; j++) ans = Math.max(ans, cur[j] * (r[j] - l[j] - 1));
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function maximalRectangle(mat: string[][]): number {
const n = mat.length, m = mat[0].length
const sum = new Array<Array<number>>(n + 10)
sum[0] = new Array<number>(m + 10).fill(0)
for (let i = 1; i <= n; i++) {
sum[i] = new Array<number>(m + 10).fill(0)
for (let j = 1; j <= m; j++) {
sum[i][j] = mat[i - 1][j - 1] == '0' ? 0 : sum[i - 1][j] + 1
}
}
let ans = 0
const l = new Array<number>(m + 10), r = new Array<number>(m + 10)
const stk = new Array<number>(m + 10).fill(0)
let he = 0, ta = 0
for (let i = 1; i <= n; i++) {
const cur = sum[i]
l.fill(0); r.fill(m + 1)
he = ta = 0
for (let j = 1; j <= m; j++) {
while (he < ta && cur[stk[ta - 1]] > cur[j]) r[stk[--ta]] = j
stk[ta++] = j
}
he = ta = 0
for (let j = m; j >= 1; j--) {
while (he < ta && cur[stk[ta - 1]] > cur[j]) l[stk[--ta]] = j
stk[ta++] = j
}
for (let j = 1; j <= m; j++) ans = Math.max(ans, cur[j] * (r[j] - l[j] - 1))
}
return ans
}
```
Python 代码:
```Python
class Solution:
def maximalRectangle(self, mat: List[List[str]]) -> int:
n, m, ans = len(mat), len(mat[0]), 0
psum = [[0] * (m + 10) for _ in range(n + 10)]
for i in range(1, n + 1):
for j in range(1, m + 1):
psum[i][j] = 0 if mat[i - 1][j - 1] == '0' else psum[i - 1][j] + 1
stk = [0] * (m + 10)
he, ta = 0, 0
for i in range(1, n + 1):
cur = psum[i]
l, r = [0] * (m + 10), [m + 1] * (m + 10)
he = ta = 0
for j in range(1, m + 1):
while he < ta and cur[stk[ta - 1]] > cur[j]:
ta -= 1
r[stk[ta]] = j
stk[ta] = j
ta += 1
he = ta = 0
for j in range(m, 0, -1):
while he < ta and cur[stk[ta - 1]] > cur[j]:
ta -= 1
l[stk[ta]] = j
stk[ta] = j
ta += 1
for j in range(1, m + 1):
ans = max(ans, cur[j] * (r[j] - l[j] - 1))
return ans
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.85` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/87. 扰乱字符串（困难）.md | 87. 扰乱字符串 | https://leetcode-cn.com/problems/scramble-string/solution/gong-shui-san-xie-yi-ti-san-jie-di-gui-j-hybk/ | 困难 | [
"DFS",
"记忆化搜索",
"区间 DP"
] | 使用下面描述的算法可以扰乱字符串 s 得到字符串 t :
1. 如果字符串的长度为 1 ,算法停止
2. 如果字符串的长度 > 1 ,执行下述步骤:
* 在一个随机下标处将字符串分割成两个非空的子字符串。即,如果已知字符串 s ,则可以将其分成两个子字符串 x 和 y ,且满足 s = x + y 。
* 随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即,在执行这一步骤之后,s 可能是 s = x + y 或者 s = y + x 。
* 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。
给你两个 长度相等 的字符串 s1 和 s2,判断 s2 是否是 s1 的扰乱字符串。如果是,返回 true ;否则,返回 false 。
示例 1:
```
输入:s1 = "great", s2 = "rgeat"
输出:true
解释:s1 上可能发生的一种情形是:
"great" --> "gr/eat" // 在一个随机下标处分割得到两个子字符串
"gr/eat" --> "gr/eat" // 随机决定:「保持这两个子字符串的顺序不变」
"gr/eat" --> "g/r / e/at" // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割
"g/r / e/at" --> "r/g / e/at" // 随机决定:第一组「交换两个子字符串」,第二组「保持这两个子字符串的顺序不变」
"r/g / e/at" --> "r/g / e/ a/t" // 继续递归执行此算法,将 "at" 分割得到 "a/t"
"r/g / e/ a/t" --> "r/g / e/ a/t" // 随机决定:「保持这两个子字符串的顺序不变」
算法终止,结果字符串和 s2 相同,都是 "rgeat"
这是一种能够扰乱 s1 得到 s2 的情形,可以认为 s2 是 s1 的扰乱字符串,返回 true
```
示例 2:
```
输入:s1 = "abcde", s2 = "caebd"
输出:false
```
示例 3:
```
输入:s1 = "a", s2 = "a"
输出:true
```
提示:
s1.length == s2.length
1 <= s1.length <= 30
s1 和 s2 由小写英文字母组成 | ### 朴素解法(TLE)
一个朴素的做法根据「扰乱字符串」的生成规则进行判断。
由于题目说了整个生成「扰乱字符串」的过程是通过「递归」来进行。
我们要实现 $isScramble$ 函数的作用是判断 $s1$ 是否可以生成出 $s2$。
这样判断的过程,同样我们可以使用「递归」来做:
假设 $s1$ 的长度为 $n$, 的第一次分割的分割点为 $i$,那么 $s1$ 会被分成 $[0, i)$ 和 $[i, n)$ 两部分。
同时由于生成「扰乱字符串」时,可以选交换也可以选不交换。因此我们的 $s2$ 会有两种可能性:
**因为对于某个确定的分割点,$s1$ 固定分为两部分,分别为 $[0,i)$ & $[i, n)$。**
**而 $s2$ 可能会有两种分割方式,分别 $[0,i)$ & $[i,n)$ 和 $[0, n-i)$ & $[n-i,n)$。**
**我们只需要递归调用 $isScramble$ 检查 $s1$ 的 $[0,i)$ & $[i, n)$ 部分能否与 「$s2$ 的 $[0,i)$ & $[i,n)$」 或者 「$s2$ 的 $[0, n-i)$ & $[n-i,n)$」 匹配即可。**
**同时,我们将「$s1$ 和 $s2$ 相等」和「$s1$ 和 $s2$ 词频不同」作为「递归」出口。**
**理解这套做法十分重要,后续的解法都是基于此解法演变过来。**
代码:
```java []
class Solution {
public boolean isScramble(String s1, String s2) {
if (s1.equals(s2)) return true;
if (!check(s1, s2)) return false;
int n = s1.length();
for (int i = 1; i < n; i++) {
// s1 的 [0,i) 和 [i,n)
String a = s1.substring(0, i), b = s1.substring(i);
// s2 的 [0,i) 和 [i,n)
String c = s2.substring(0, i), d = s2.substring(i);
if (isScramble(a, c) && isScramble(b, d)) return true;
// s2 的 [0,n-i) 和 [n-i,n)
String e = s2.substring(0, n - i), f = s2.substring(n - i);
if (isScramble(a, f) && isScramble(b, e)) return true;
}
return false;
}
// 检查 s1 和 s2 词频是否相同
boolean check(String s1, String s2) {
if (s1.length() != s2.length()) return false;
int n = s1.length();
int[] cnt1 = new int[26], cnt2 = new int[26];
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
for (int i = 0; i < n; i++) {
cnt1[cs1[i] - 'a']++;
cnt2[cs2[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (cnt1[i] != cnt2[i]) return false;
}
return true;
}
}
```
* 时间复杂度:$O(5^n)$
* 空间复杂度:忽略递归与生成子串带来的空间开销,复杂度为 $O(1)$
---
### 记忆化搜索
朴素解法卡在了 $286 / 288$ 个样例。
我们考虑在朴素解法的基础上,增加「记忆化搜索」功能。
我们可以重新设计我们的「爆搜」逻辑:假设 $s1$ 从 $i$ 位置开始,$s2$ 从 $j$ 位置开始,后面的长度为 $len$ 的字符串是否能形成「扰乱字符串」(互为翻转)。
那么在单次处理中,我们可分割的点的范围为 $[1, len)$,然后和「递归」一下,将 $s1$ 分割出来的部分尝试去和 $s2$ 的对应位置匹配。
同样的,我们将「入参对应的子串相等」和「入参对应的子串词频不同」作为「递归」出口。
代码:
```java []
class Solution {
String s1; String s2;
int n;
int[][][] cache;
int N = -1, Y = 1, EMPTY = 0;
public boolean isScramble(String _s1, String _s2) {
s1 = _s1; s2 = _s2;
if (s1.equals(s2)) return true;
if (s1.length() != s2.length()) return false;
n = s1.length();
// cache 的默认值是 EMPTY
cache = new int[n][n][n + 1];
return dfs(0, 0, n);
}
boolean dfs(int i, int j, int len) {
if (cache[i][j][len] != EMPTY) return cache[i][j][len] == Y;
String a = s1.substring(i, i + len), b = s2.substring(j, j + len);
if (a.equals(b)) {
cache[i][j][len] = Y;
return true;
}
if (!check(a, b)) {
cache[i][j][len] = N;
return false;
}
for (int k = 1; k < len; k++) {
// 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [0,i) & [i,n)」
if (dfs(i, j, k) && dfs(i + k, j + k, len - k)) {
cache[i][j][len] = Y;
return true;
}
// 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [n-i,n) & [0,n-i)」
if (dfs(i, j + len - k, k) && dfs(i + k, j, len - k)) {
cache[i][j][len] = Y;
return true;
}
}
cache[i][j][len] = N;
return false;
}
// 检查 s1 和 s2 词频是否相同
boolean check(String s1, String s2) {
if (s1.length() != s2.length()) return false;
int n = s1.length();
int[] cnt1 = new int[26], cnt2 = new int[26];
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
for (int i = 0; i < n; i++) {
cnt1[cs1[i] - 'a']++;
cnt2[cs2[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (cnt1[i] != cnt2[i]) return false;
}
return true;
}
}
```
* 时间复杂度:$O(n^4)$
* 空间复杂度:$O(n^3)$
---
### 动态规划(区间 DP)
其实有了上述「记忆化搜索」方案之后,我们就已经可以直接忽略原问题,将其改成「动态规划」了。
**根据「dfs 方法的几个可变入参」作为「状态定义的几个维度」,根据「dfs 方法的返回值」作为「具体的状态值」。**
**我们可以得到状态定义 $f[i][j][len]$:**
**$f[i][j][len]$ 代表 $s1$ 从 $i$ 开始,$s2$ 从 $j$ 开始,后面长度为 $len$ 的字符是否能形成「扰乱字符串」(互为翻转)。**
状态转移方程其实就是翻译我们「记忆化搜索」中的 dfs 主要逻辑部分:
```java
// 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [0,i) & [i,n)」
if (dfs(i, j, k) && dfs(i + k, j + k, len - k)) {
cache[i][j][len] = Y;
return true;
}
// 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [n-i,n) & [0,n-i)」
if (dfs(i, j + len - k, k) && dfs(i + k, j, len - k)) {
cache[i][j][len] = Y;
return true;
}
```
**从状态定义上,我们就不难发现这是一个「区间 DP」问题,区间长度大的状态值可以由区间长度小的状态值递推而来。**
**而且由于本身我们在「记忆化搜索」里面就是从小到大枚举 $len$,因此这里也需要先将 $len$ 这层循环提前,确保我们转移 $f[i][j][len]$ 时所需要的状态都已经被计算好。**
代码:
```java []
class Solution {
public boolean isScramble(String s1, String s2) {
if (s1.equals(s2)) return true;
if (s1.length() != s2.length()) return false;
int n = s1.length();
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();
boolean[][][] f = new boolean[n][n][n + 1];
// 先处理长度为 1 的情况
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
f[i][j][1] = cs1[i] == cs2[j];
}
}
// 再处理其余长度情况
for (int len = 2; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
for (int j = 0; j <= n - len; j++) {
for (int k = 1; k < len; k++) {
boolean a = f[i][j][k] && f[i + k][j + k][len - k];
boolean b = f[i][j + len - k][k] && f[i + k][j][len - k];
if (a || b) {
f[i][j][len] = true;
}
}
}
}
}
return f[0][0][n];
}
}
```
* 时间复杂度:$O(n^4)$
* 空间复杂度:$O(n^3)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.87` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/88. 合并两个有序数组（简单）.md | 88. 合并两个有序数组 | https://leetcode-cn.com/problems/merge-sorted-array/solution/gong-shui-san-xie-yi-ti-san-jie-shuang-z-47gj/ | 简单 | [
"双指针",
"排序"
] | 给你两个有序整数数组 `nums1` 和 `nums2`,请你将 `nums2` 合并到 `nums1` 中,使 `nums1` 成为一个有序数组。
初始化 `nums1` 和 `nums2` 的元素数量分别为 `m` 和 `n` 。
你可以假设 `nums1` 的空间大小等于 `m + n`,这样它就有足够的空间保存来自 `nums2` 的元素。
示例 1:
```
输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出:[1,2,2,3,5,6]
```
示例 2:
```
输入:nums1 = [1], m = 1, nums2 = [], n = 0
输出:[1]
```
提示:
* $nums1.length = m + n$
* $nums2.length == n$
* $0 <= m, n <= 200$
* $1 <= m + n <= 200$
* $-10^9 <= nums1[i], nums2[i] <= 10^9$ | ### 模拟
最简单的做法,我们可以将 $nums2$ 的内容先搬到 $nums1$ 去,再对 $nums1$ 进行排序。
Java 代码:
```Java
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
System.arraycopy(nums2, 0, nums1, m, n);
Arrays.sort(nums1);
}
}
```
C++ 代码:
```C++
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
copy(nums2.begin(), nums2.end(), nums1.begin() + m);
sort(nums1.begin(), nums1.end());
}
};
```
Python 代码:
```Python
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
nums1[m:m+n] = nums2
nums1.sort()
```
TypeScript 代码:
```TypeScript
function merge(nums1: number[], m: number, nums2: number[], n: number): void {
nums1.splice(m, n, ...nums2);
nums1.sort((a, b) => a - b);
};
```
* 时间复杂度:$O((m + n)\log{(m + n)})$
* 空间复杂度:$O(1)$
**PS. Java 中的 sort 排序是一个综合排序。包含插入/双轴快排/归并/timsort,这里假定 `Arrays.sort` 使用的是「双轴快排」,并忽略递归带来的空间开销。**
---
### 双指针 - 额外空间
上述方法,粗暴地将两个数组结合,再对结果进行排序,没有很好利用俩数组本身有序的特性。
一个容易想到的,可以避免对结果排序的做法是:创建一个和 $nums1$ 等长的数组 $arr$,使用双指针将 $num1$ 和 $nums2$ 的数据迁移到 $arr$,最后再将 $arr$ 复制到 $nums1$ 中。
Java 代码:
```Java
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int total = m + n, idx = 0;
int[] arr = new int[total];
for (int i = 0, j = 0; i < m || j < n;) {
if (i < m && j < n) {
arr[idx++] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];
} else if (i < m) {
arr[idx++] = nums1[i++];
} else if (j < n) {
arr[idx++] = nums2[j++];
}
}
System.arraycopy(arr, 0, nums1, 0, total);
}
}
```
C++ 代码:
```C++
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int total = m + n, idx = 0;
vector<int> arr(total);
for (int i = 0, j = 0; i < m || j < n;) {
if (i < m && j < n) {
arr[idx++] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];
} else if (i < m) {
arr[idx++] = nums1[i++];
} else if (j < n) {
arr[idx++] = nums2[j++];
}
}
copy(arr.begin(), arr.end(), nums1.begin());
}
};
```
Python 代码:
```Python
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
total, idx = m + n, 0
arr = [0] * total
i, j = 0, 0
while i < m or j < n:
if i < m and j < n:
if nums1[i] < nums2[j]:
arr[idx] = nums1[i]
i += 1
else:
arr[idx] = nums2[j]
j += 1
idx += 1
elif i < m:
arr[idx] = nums1[i]
idx += 1
i += 1
elif j < n:
arr[idx] = nums2[j]
idx += 1
j += 1
for i in range(total):
nums1[i] = arr[i]
```
TypeScript 代码:
```TypeScript
function merge(nums1: number[], m: number, nums2: number[], n: number): void {
let total = m + n, idx = 0;
const arr = new Array(total);
for (let i = 0, j = 0; i < m || j < n;) {
if (i < m && j < n) {
arr[idx++] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];
} else if (i < m) {
arr[idx++] = nums1[i++];
} else if (j < n) {
arr[idx++] = nums2[j++];
}
}
for (let i = 0; i < total; i++) nums1[i] = arr[i];
};
```
* 时间复杂度:$O(m + n)$
* 空间复杂度:$O(m + n)$
---
### 双指针 - 原地合并
上述两类做法都不是最优:
* 要么使用到了“排序”操作,时间复杂度带 $\log$,不是最优
* 要么使用到了“额外辅助数组”空间,空间复杂度不为 $O(1)$,也不是最优
那么是否有“不排序”且“不消耗额外空间”的原地做法呢?
答案是有的。
**使用两个指针 `i` 和 `j` 分别指向 `nums1` 和 `nums2` 的结尾位置,从后往前地原地构造出答案。**
所谓的原地构造是指:直接将 $nums1[i]$ 和 $nums2[j]$ 之间的较大值,放到合并后该在 `nums1` 出现的位置。
这也是为什么我们要「从后往前」而不是「从前往后」的原因。
使用 `idx` 代表当构造到答案的下标值,起始有 `idx = m + n - 1`(答案是一个长度为 $m + n$ 的数组,因此下标是 $m + n - 1$),根据指针 `i` 和 `j` 所达位置,以及 $nums1[i]$ 和 $nums2[j]$ 大小关系,分情况讨论:
* 若 `i` 和 `j` 任一到达边界,说明其中一个数组已用完,用另一数组的剩余元素进行填充即可
* 若 `i` 和 `j` 均未到达边界,进一步比较 $nums1[i]$ 和 $nums2[j]$ 的大小关系:
* 若 $nums1[i] > nums2[j]$,说明在合并答案中 $nums1[i]$ 出现 $nums2[j]$ 后面,将 $nums1[i]$ 填入到 $nums1[idx]$ 中,让 `idx` 和 `i` 同时前移
* 否则,将 $nums2[j]$ 填入到 $nums1[idx]$ 中,让 `idx` 和 `j` 同时前移
直到 `i` 和 `j` 均到达边界,此时合并答案已全部填充到 `nums1` 中。
Java 代码:
```Java
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int i = m - 1, j = n - 1, idx = m + n - 1;
while (i >= 0 || j >= 0) {
if (i >= 0 && j >= 0) {
nums1[idx--] = nums1[i] >= nums2[j] ? nums1[i--] : nums2[j--];
} else if (i >= 0) {
nums1[idx--] = nums1[i--];
} else {
nums1[idx--] = nums2[j--];
}
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int i = m - 1, j = n - 1, idx = m + n - 1;
while (i >= 0 || j >= 0) {
if (i >= 0 && j >= 0) {
nums1[idx--] = nums1[i] >= nums2[j] ? nums1[i--] : nums2[j--];
} else if (i >= 0) {
nums1[idx--] = nums1[i--];
} else {
nums1[idx--] = nums2[j--];
}
}
}
};
```
Python 代码:
```Python
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
i, j, idx = m - 1, n - 1, m + n - 1
while i >= 0 or j >= 0:
if i >= 0 and j >= 0:
if nums1[i] > nums2[j]:
nums1[idx] = nums1[i]
i -= 1
else:
nums1[idx] = nums2[j]
j -= 1
idx -= 1
elif i >= 0:
nums1[idx] = nums1[i]
idx, i = idx - 1, i - 1
else:
nums1[idx] = nums2[j]
idx, j = idx - 1, j - 1
```
TypeScript 代码:
```TypeScript
function merge(nums1: number[], m: number, nums2: number[], n: number): void {
let i = m - 1, j = n - 1, idx = m + n - 1;
while (i >= 0 || j >= 0) {
if (i >= 0 && j >= 0) {
nums1[idx--] = nums1[i] >= nums2[j] ? nums1[i--] : nums2[j--];
} else if (i >= 0) {
nums1[idx--] = nums1[i--];
} else {
nums1[idx--] = nums2[j--];
}
}
};
```
* 时间复杂度:$O(m + n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.88` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/89. 格雷编码（中等）.md | 89. 格雷编码 | https://leetcode-cn.com/problems/gray-code/solution/gong-shui-san-xie-dui-cheng-xing-gou-zao-9ap1/ | 中等 | [
"模拟"
] | $n$ 位格雷码序列 是一个由 $2^n$ 个整数组成的序列,其中:
* 每个整数都在范围 $[0, 2^n - 1]$ 内(含 $0$ 和 $2^n - 1$)
* 第一个整数是 0
* 一个整数在序列中出现 不超过一次
* 每对 相邻 整数的二进制表示 恰好一位不同 ,且
* 第一个 和 最后一个 整数的二进制表示 恰好一位不同
给你一个整数 `n` ,返回任一有效的 `n` 位格雷码序列 。
示例 1:
```
输入:n = 2
输出:[0,1,3,2]
解释:
[0,1,3,2] 的二进制表示是 [00,01,11,10] 。
- 00 和 01 有一位不同
- 01 和 11 有一位不同
- 11 和 10 有一位不同
- 10 和 00 有一位不同
[0,2,3,1] 也是一个有效的格雷码序列,其二进制表示是 [00,10,11,01] 。
- 00 和 10 有一位不同
- 10 和 11 有一位不同
- 11 和 01 有一位不同
- 01 和 00 有一位不同
```
示例 2:
```
输入:n = 1
输出:[0,1]
```
提示:
* `1 <= n <= 16` | ### 对称性构造
根据格雷码的定义,我们需要构造一个合法序列,序列之间每两个数的二进制表示中只有一位不同,同时序列第一位和最后一位对应的二进制也只有一位不同。
我们知道 $k + 1$ 位的格雷码序列是 $k$ 位格雷码序列长度的两倍,利用合法 $k$ 位格雷码序列,我们可以「对称性」地构造出 $k + 1$ 位格雷码。
具体的,假定 $k$ 位格雷码序列长度为 $n$,我们将这 $k$ 位的格雷序列进行翻转,并追加到原有序列的尾部,得到长度为 $2 * n$ 的序列,此时新序列的前后两部分均为合法的格雷码。
考虑如何进行解决衔接点的合法性:我们可以对于序列的后半(翻转而来)的部分中的每个数进行「尾部」追加 $1$ 的操作,确保链接点的两个数只有有一位二进制位不同,同时并不影响前后两半部分的合法性。
而且由于后半部分本身是由前半部分翻转而来,序列中的第一个数和最后一个数原本为同一个值,经过追加 $1$ 的操作之后,首尾两个数的二进制表示只有一位不同,整个序列的合法性得以保证。
代码:
```Java
class Solution {
public List<Integer> grayCode(int n) {
List<Integer> ans = new ArrayList<>();
ans.add(0);
while (n-- > 0) {
int m = ans.size();
for (int i = m - 1; i >= 0; i--) {
ans.set(i, ans.get(i) << 1);
ans.add(ans.get(i) + 1);
}
}
return ans;
}
}
```
* 时间复杂度:$O(2^n)$
* 空间复杂度:$O(2^n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.89` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/81-90/90. 子集 II（中等）.md | 90. 子集 II | https://leetcode-cn.com/problems/subsets-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hui-s-g77q/ | 中等 | [
"位运算",
"回溯算法",
"状态压缩",
"DFS"
] | 给你一个整数数组 `nums`,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。
解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
示例 1:
```
输入:nums = [1,2,2]
输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]
```
示例 2:
```
输入:nums = [0]
输出:[[],[0]]
```
提示:
* $1 <= nums.length <= 10$
* $-10 <= nums[i] <= 10$ | ### 回溯解法(Set)
由于是求所有的方案,而且数据范围只有 $10$,可以直接用爆搜来做。
同时由于答案中不能包含相同的方案,因此我们可以先对原数组进行排序,从而确保所有爆搜出来的方案,都具有单调性,然后配合 `Set` 进行去重。
代码:
```Java
class Solution {
public List<List<Integer>> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
Set<List<Integer>> ans = new HashSet<>();
List<Integer> cur = new ArrayList<>();
dfs(nums, 0, cur, ans);
return new ArrayList<>(ans);
}
/**
* @param nums 原输入数组
* @param u 当前决策到原输入数组中的哪一位
* @param cur 当前方案
* @param ans 最终结果集
*/
void dfs(int[] nums, int u, List<Integer> cur, Set<List<Integer>> ans) {
// 所有位置都决策完成,将当前方案放入结果集
if (nums.length == u) {
ans.add(new ArrayList<>(cur));
return;
}
// 选择当前位置的元素,往下决策
cur.add(nums[u]);
dfs(nums, u + 1, cur, ans);
// 不选当前位置的元素(回溯),往下决策
cur.remove(cur.size() - 1);
dfs(nums, u + 1, cur, ans);
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,爆搜复杂度为 $(2^n)$,每个方案通过深拷贝存入答案,复杂度为 $O(n)$。整体复杂度为 $(n \times 2^n)$
* 空间复杂度:总共有 $2^n$ 个方案,每个方案最多占用 $O(n)$ 空间,整体复杂度为 $(n \times 2^n)$
---
### 回溯解法
我们知道使用 `Set` 虽然是 $O(1)$ 操作,但是只是均摊 $O(1)$。
因此我们来考虑不使用 `Set` 的做法。
我们使用 `Set` 的目的是为了去重,那什么时候会导致的重复呢?
**其实就是相同的元素,不同的决策方案对应同样的结果。**
举个🌰,[1,1,1] 的数据,只选择第一个和只选择第三个(不同的决策方案),结果是一样的。
**因此如果我们希望去重的话,不能单纯的利用「某个下标是否被选择」来进行决策,而是要找到某个数值的连续一段,根据该数值的选择次数类进行决策。**
还是那个🌰,[1,1,1] 的数据,我们可以需要找到数值为 1 的连续一段,然后决策选择 0 次、选择 1 次、选择 2 次 ... 从而确保不会出现重复
**也就是说,将决策方案从「某个下标是否被选择」修改为「相同的数值被选择的个数」。这样肯定不会出现重复,因为 [1,1,1] 不会因为只选择第一个和只选择第三个产生两个 [1] 的方案,只会因为 1 被选择一次,产生一个 [1] 的方案。**
代码:
```Java
class Solution {
public List<List<Integer>> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
List<List<Integer>> ans = new ArrayList<>();
List<Integer> cur = new ArrayList<>();
dfs(nums, 0, cur, ans);
return ans;
}
/**
* @param nums 原输入数组
* @param u 当前决策到原输入数组中的哪一位
* @param cur 当前方案
* @param ans 最终结果集
*/
void dfs(int[] nums, int u, List<Integer> cur, List<List<Integer>> ans) {
// 所有位置都决策完成,将当前方案放入结果集
int n = nums.length;
if (n == u) {
ans.add(new ArrayList<>(cur));
return;
}
// 记录当前位置是什么数值(令数值为 t),并找出数值为 t 的连续一段
int t = nums[u];
int last = u;
while (last < n && nums[last] == nums[u]) last++;
// 不选当前位置的元素,直接跳到 last 往下决策
dfs(nums, last, cur, ans);
// 决策选择不同个数的 t 的情况:选择 1 个、2 个、3 个 ... k 个
for (int i = u; i < last; i++) {
cur.add(nums[i]);
dfs(nums, last, cur, ans);
}
// 回溯对数值 t 的选择
for (int i = u; i < last; i++) {
cur.remove(cur.size() - 1);
}
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,爆搜复杂度为 $(2^n)$,每个方案通过深拷贝存入答案,复杂度为 $O(n)$。整体复杂度为 $(n \times 2^n)$
* 空间复杂度:总共有 $2^n$ 个方案,每个方案最多占用 $O(n)$ 空间,整体复杂度为 $(n \times 2^n)$
---
### 状态压缩(Set)
由于长度只有 10,我们可以使用一个 `int` 的后 $10$ 位来代表每位数组成员是否被选择。
同样,我们也需要先对原数组进行排序,再配合 `Set` 来进行去重。
代码:
```Java
class Solution {
public List<List<Integer>> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
Set<List<Integer>> ans = new HashSet<>();
List<Integer> cur = new ArrayList<>();
// 枚举 i 代表,枚举所有的选择方案状态
// 例如 [1,2],我们有 []、[1]、[2]、[1,2] 几种方案,分别对应了 00、10、01、11 几种状态
for (int i = 0; i < (1 << n); i++) {
cur.clear();
// 对当前状态进行诸位检查,如果当前状态为 1 代表被选择,加入当前方案中
for (int j = 0; j < n; j++) {
int t = (i >> j) & 1;
if (t == 1) cur.add(nums[j]);
}
// 将当前方案中加入结果集
ans.add(new ArrayList<>(cur));
}
return new ArrayList<>(ans);
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,爆搜复杂度为 $(2^n)$,每个方案通过深拷贝存入答案,复杂度为 $O(n)$。整体复杂度为 $(n \times 2^n)$
* 空间复杂度:总共有 $2^n$ 个方案,每个方案最多占用 $O(n)$ 空间,整体复杂度为 $(n \times 2^n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.90` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
Subsets and Splits