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/811-820/811. 子域名访问计数（中等）.md | 811. 子域名访问计数 | https://leetcode.cn/problems/subdomain-visit-count/solution/by-ac_oier-aex6/ | 中等 | [
"模拟",
"哈希表"
] | 网站域名 `"discuss.leetcode.com"` 由多个子域名组成。顶级域名为 `"com"` ,二级域名为 `"leetcode.com"` ,最低一级为 `"discuss.leetcode.com"` 。
当访问域名 `"discuss.leetcode.com"` 时,同时也会隐式访问其父域名 `"leetcode.com"` 以及 `"com"` 。
计数配对域名 是遵循 `"rep d1.d2.d3"` 或 `"rep d1.d2"` 格式的一个域名表示,其中 `rep` 表示访问域名的次数,`d1.d2.d3` 为域名本身。
例如,`"9001 discuss.leetcode.com"` 就是一个 计数配对域名 ,表示 `discuss.leetcode.com` 被访问了 `9001` 次。
给你一个 计数配对域名 组成的数组 `cpdomains` ,解析得到输入中每个子域名对应的 计数配对域名 ,并以数组形式返回。可以按 任意顺序 返回答案。
示例 1:
```
输入:cpdomains = ["9001 discuss.leetcode.com"]
输出:["9001 leetcode.com","9001 discuss.leetcode.com","9001 com"]
解释:例子中仅包含一个网站域名:"discuss.leetcode.com"。
按照前文描述,子域名 "leetcode.com" 和 "com" 都会被访问,所以它们都被访问了 9001 次。
```
示例 2:
```
输入:cpdomains = ["900 google.mail.com", "50 yahoo.com", "1 intel.mail.com", "5 wiki.org"]
输出:["901 mail.com","50 yahoo.com","900 google.mail.com","5 wiki.org","5 org","1 intel.mail.com","951 com"]
解释:按照前文描述,会访问 "google.mail.com" 900 次,"yahoo.com" 50 次,"intel.mail.com" 1 次,"wiki.org" 5 次。
而对于父域名,会访问 "mail.com" 900 + 1 = 901 次,"com" 900 + 50 + 1 = 951 次,和 "org" 5 次。
```
提示:
* $1 <= cpdomain.length <= 100$
* $1 <= cpdomain[i].length <= 100$
* `cpdomain[i]` 会遵循 `"repi d1i.d2i.d3i"` 或 `"repi d1i.d2i"` 格式
* `repi` 是范围 $[1, 10^4]$ 内的一个整数
* $d1_i$、$d2_i$ 和 $d3_i$ 由小写英文字母组成 | ### 哈希表
为了方便,我们令 `cpdomains` 为 `ss`。
根据题意进行模拟:使用哈希表记录每个域名的总访问次数,从前往后处理所有的 $ss[i]$。在处理某个 $ss[i]$ 时(记长度为 $n$,使用指针 `idx` 代指扫描到的游标位置),先通过指针扫描找到访问数字部分 `cnt = ss[i][0:idx]`,然后「从后往前」处理 $ss[i]$ 的 $[idx + 1, n - 1]$ 部分,按照域名层级「从小到大」的顺序进行截取,并累加访问次数 `cnt` 到当前域名。
最后根据哈希表构造答案。
Java 代码:
```Java
class Solution {
public List<String> subdomainVisits(String[] ss) {
Map<String, Integer> map = new HashMap<>();
for (String s : ss) {
int n = s.length(), idx = 0;
while (idx < n && s.charAt(idx) != ' ') idx++;
int cnt = Integer.parseInt(s.substring(0, idx));
int start = idx + 1; idx = n - 1;
while (idx >= start) {
while (idx >= start && s.charAt(idx) != '.') idx--;
String cur = s.substring(idx + 1);
map.put(cur, map.getOrDefault(cur, 0) + cnt);
idx--;
}
}
List<String> ans = new ArrayList<>();
for (String key : map.keySet()) ans.add(map.get(key) + " " + key);
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function subdomainVisits(ss: string[]): string[] {
const map = new Map<string, number>()
for (const s of ss) {
let n = s.length, idx = 0
while (idx < n && s[idx] != ' ') idx++
const cnt = Number(s.substring(0, idx))
const start = idx + 1; idx = n - 1
while (idx >= start) {
while (idx >= start && s[idx] != '.') idx--
const cur = s.substring(idx + 1)
if (!map.has(cur)) map.set(cur, 0)
map.set(cur, map.get(cur) + cnt)
idx--
}
}
const ans = new Array<string>()
for (const key of map.keys()) ans.push(map.get(key) + " " + key)
return ans
};
```
Python 代码:
```Python
class Solution:
def subdomainVisits(self, ss: List[str]) -> List[str]:
mapping = defaultdict(int)
for s in ss:
n, idx = len(s), 0
while idx < n and s[idx] != ' ':
idx += 1
cnt = int(s[:idx])
start, idx = idx + 1, n - 1
while idx >= start:
while idx >= start and s[idx] != '.':
idx -= 1
mapping[s[idx + 1:]] += cnt
idx -= 1
return [f'{v} {k}' for k, v in mapping.items()]
```
* 时间复杂度:$O(\sum_{i = 0}^{n - 1}len(ss[i]))$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1}len(ss[i]))$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.811` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/812. 最大三角形面积（简单）.md | 812. 最大三角形面积 | https://leetcode.cn/problems/largest-triangle-area/solution/by-ac_oier-htv8/ | 简单 | [
"模拟"
] | 给定包含多个点的集合,从其中取三个点组成三角形,返回能组成的最大三角形的面积。
示例:
```
输入: points = [[0,0],[0,1],[1,0],[0,2],[2,0]]
输出: 2
解释:
这五个点如下图所示。组成的橙色三角形是最大的,面积为2。
```
注意:
* $3 <= points.length <= 50.$
* 不存在重复的点。
* $-50 <= points[i][j] <= 50$
* 结果误差值在 $10^{-6}$ 以内都认为是正确答案。 | ### 模拟
根据题意模拟即可:枚举三角形三个顶点并计算面积。
代码:
```Java
class Solution {
public double largestTriangleArea(int[][] ps) {
int n = ps.length;
double ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
int cur = cross(ps[j][0] - ps[i][0], ps[j][1] - ps[i][1], ps[k][0] - ps[i][0], ps[k][1] - ps[i][1]);
ans = Math.max(ans, Math.abs(cur / 2.0));
}
}
}
return ans;
}
int cross(int a, int b, int c, int d) {
return a * d - c * b;
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.812` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/813. 最大平均值和的分组（中等）.md | 813. 最大平均值和的分组 | https://leetcode.cn/problems/largest-sum-of-averages/solution/by-ac_oier-yfnt/ | 中等 | [
"序列 DP",
"前缀和",
"动态规划",
"数学"
] | 给定数组 `nums` 和一个整数 `m` 。
我们将给定的数组 `nums` 分成最多 `m` 个相邻的非空子数组,分数由每个子数组内的平均值的总和构成。
注意我们必须使用 `nums` 数组中的每一个数进行分组,并且分数不一定需要是整数。
返回我们所能得到的最大分数是多少。
答案误差在 $10^{-6}$ 内被视为是正确的。
示例 1:
```
输入: nums = [9,1,2,3,9], m = 3
输出: 20.00000
解释:
nums 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) / 3 + 9 = 20.
我们也可以把 nums 分成[9, 1], [2], [3, 9].
这样的分组得到的分数为 5 + 2 + 6 = 13, 但不是最大值.
```
示例 2:
```
输入: nums = [1,2,3,4,5,6,7], m = 4
输出: 20.50000
```
提示:
* $1 <= nums.length <= 100$
* $1 <= nums[i] <= 10^4$ | ### 前缀和 + 序列 DP
题意可整理为一句话:将 $n$ 个元素划分为「最多」$m$ 个连续段,最大化连续段的平均值之和。
为了方便,我们令所有数组下标从 $1$ 开始。
定义 $f[i][j]$ 为考虑将前 $i$ 个元素划分成 $j$ 份的最大平均和,答案为 $f[n][k]$,其中 $1 \leq k \leq m$。
不失一般性考虑 $f[i][j]$ 该如何计算,由于划分出来的子数组不能是空集,因此我们可以根据 $j$ 的大小分情况讨论:
* 当 $j = 1$,此时有 $f[i][j] = \frac{\sum_{idx = 1}^{i} nums[idx - 1]}{i}$
* 当 $j > 1$,此时枚举最后一个子数组的起点 $k$,其中 $2 \leq k \leq i$,此时有平均值之和为 $f[k - 1][j - 1] + \frac{\sum_{idx = k}^{i} nums[idx]}{i - k + 1}$,最终 $f[i][j]$ 为枚举所有 $k$ 值的最大值
其中求解连续段之和可以用「前缀和」进行优化。同时,想要简化代码,还可以利用一个简单的数学结论:划分份数越多,平均值之和越大,因此想要取得最大值必然是恰好划分成 $m$ 份。
Java 代码:
```Java
class Solution {
public double largestSumOfAverages(int[] nums, int m) {
int n = nums.length;
double[] sum = new double[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
double[][] f = new double[n + 10][m + 10];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= Math.min(i, m); j++) {
if (j == 1) {
f[i][1] = sum[i] / i;
} else {
for (int k = 2; k <= i; k++) {
f[i][j] = Math.max(f[i][j], f[k - 1][j - 1] + (sum[i] - sum[k - 1]) / (i - k + 1));
}
}
}
}
return f[n][m];
}
}
```
C++ 代码:
```C++
class Solution {
public:
double largestSumOfAverages(vector<int>& nums, int m) {
int n = nums.size();
vector<double> sum(n + 10, 0);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
vector<vector<double>> f(n + 10, vector<double>(m + 10, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= min(i, m); j++) {
if (j == 1) {
f[i][j] = sum[i] / i;
} else {
for (int k = 2; k <= i; k++) {
f[i][j] = max(f[i][j], f[k - 1][j - 1] + (sum[i] - sum[k - 1]) / (i - k + 1));
}
}
}
}
return f[n][m];
}
};
```
Python 代码:
```Python
class Solution:
def largestSumOfAverages(self, nums: List[int], m: int) -> float:
n = len(nums)
psum = [0] * (n + 10)
for i in range(1, n + 1):
psum[i] = psum[i - 1] + nums[i - 1]
f = [[0] * (m + 10) for _ in range(n + 10)]
for i in range(1, n + 1):
for j in range(1, min(i, m) + 1):
if j == 1:
f[i][j] = psum[i] / i
else:
for k in range(2, i + 1):
f[i][j] = max(f[i][j], f[k - 1][j - 1] + (psum[i] - psum[k - 1]) / (i - k + 1))
return f[n][m]
```
TypeScript 代码:
```TypeScript
function largestSumOfAverages(nums: number[], m: number): number {
const n = nums.length
const sum = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1]
const f = new Array<Array<number>>()
for (let i = 0; i < n + 10; i++) f[i] = new Array<number>(m + 10).fill(0)
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= Math.min(i, m); j++) {
if (j == 1) {
f[i][j] = sum[i] / i
} else {
for (let k = 2; k <= i; k++) {
f[i][j] = Math.max(f[i][j], f[k - 1][j - 1] + (sum[i] - sum[k - 1]) / (i - k + 1))
}
}
}
}
return f[n][m]
}
```
* 时间复杂度:$O(n^2 \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.813` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/814. 二叉树剪枝（中等）.md | 814. 二叉树剪枝 | https://leetcode.cn/problems/binary-tree-pruning/solution/by-ac_oier-7me9/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给你二叉树的根结点 `root`,此外树的每个结点的值要么是 $0$ ,要么是 $1$ 。
返回移除了所有不包含 $1$ 的子树的原二叉树。
节点 `node` 的子树为 `node` 本身加上所有 `node` 的后代。
示例 1:
```
输入:root = [1,null,0,0,1]
输出:[1,null,0,null,1]
解释:
只有红色节点满足条件“所有不包含 1 的子树”。 右图为返回的答案。
```
示例 2:
```
输入:root = [1,0,1,0,0,0,1]
输出:[1,null,1,null,1]
```
示例 3:
```
输入:root = [1,1,0,1,1,0,1,0]
输出:[1,1,0,1,1,null,1]
```
提示:
* 树中节点的数目在范围 $[1, 200]$ 内
* `Node.val` 为 $0$ 或 $1$ | ### 递归
根据题意,我们将原函数 `pruneTree` 作为递归函数,递归函数的含义为「将入参 `root` 中的所有不包含 $1$ 的子树移除,并返回新树头结点」。
不失一般性的考虑任意节点作为入参该如何处理:我们可以递归处理左右子树,并将新左右子树重新赋值给 `root`。由于当前节点 `root` 的左右子树可能为空树,因此我们要增加递归函数入参为空的边界处理。
当递归操作完成后,若左右节点任一值不为空(说明当前节点 `root` 不为叶子节点),我们可以直接返回 `root`,否则根据 `root` 的值是否为 $0$ 来决定返回空树还是 `root` 本身。
Java 代码:
```Java
class Solution {
public TreeNode pruneTree(TreeNode root) {
if (root == null) return null;
root.left = pruneTree(root.left);
root.right = pruneTree(root.right);
if (root.left != null || root.right != null) return root;
return root.val == 0 ? null : root;
}
}
```
TypeScript 代码:
```TypeScript
function pruneTree(root: TreeNode | null): TreeNode | null {
if (root == null) return null
root.left = pruneTree(root.left)
root.right = pruneTree(root.right)
if (root.left != null || root.right != null) return root
return root.val == 0 ? null : root
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.814` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/815. 公交路线（困难）.md | 815. 公交路线 | https://leetcode-cn.com/problems/bus-routes/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-1roh/ | 困难 | [
"图论 BFS",
"双向 BFS",
"图论搜索"
] | 给你一个数组 `routes` ,表示一系列公交线路,其中每个 `routes[i]` 表示一条公交线路,第 `i` 辆公交车将会在上面循环行驶。
* 例如,路线 `routes[0] = [1, 5, 7]` 表示第 0 辆公交车会一直按序列 `1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ...` 这样的车站路线行驶。
现在从 `source` 车站出发(初始时不在公交车上),要前往 `target` 车站。 期间仅可乘坐公交车。
求出 最少乘坐的公交车数量 。如果不可能到达终点车站,返回 `-1` 。
示例 1:
```
输入:routes = [[1,2,7],[3,6,7]], source = 1, target = 6
输出:2
解释:最优策略是先乘坐第一辆公交车到达车站 7 , 然后换乘第二辆公交车到车站 6 。
```
示例 2:
```
输入:routes = [[7,12],[4,5,15],[6],[15,19],[9,12,13]], source = 15, target = 12
输出:-1
```
提示:
* 1 <= routes.length <= 500.
* 1 <= routes[i].length <= $10^5$
* routes[i] 中的所有值 互不相同
* sum(routes[i].length) <= $10^5$
* 0 <= routes[i][j] < $10^6$
* 0 <= source, target < $10^6$ | ### 基本分析
为了方便,我们令每个公交站为一个「车站」,由一个「车站」可以进入一条或多条「路线」。
问题为从「起点车站」到「终点车站」,所进入的最少路线为多少。
抽象每个「路线」为一个点,当不同「路线」之间存在「公共车站」则为其增加一条边权为 $1$ 的无向边。
---
### 单向 BFS
由于是在边权为 $1$ 的图上求最短路,我们直接使用 `BFS` 即可。
起始时将「起点车站」所能进入的「路线」进行入队,每次从队列中取出「路线」时,查看该路线是否包含「终点车站」:
* 包含「终点车站」:返回进入该线路所花费的距离
* 不包含「终点车站」:遍历该路线所包含的车站,将由这些车站所能进入的路线,进行入队
一些细节:由于是求最短路,同一路线重复入队是没有意义的,因此将新路线入队前需要先判断是否曾经入队。
代码:
```Java
class Solution {
int s, t;
int[][] rs;
public int numBusesToDestination(int[][] _rs, int _s, int _t) {
rs = _rs; s = _s; t = _t;
if (s == t) return 0;
int ans = bfs();
return ans;
}
int bfs() {
// 记录某个车站可以进入的路线
Map<Integer, Set<Integer>> map = new HashMap<>();
// 队列存的是经过的路线
Deque<Integer> d = new ArrayDeque<>();
// 哈希表记录的进入该路线所使用的距离
Map<Integer, Integer> m = new HashMap<>();
int n = rs.length;
for (int i = 0; i < n; i++) {
for (int station : rs[i]) {
// 将从起点可以进入的路线加入队列
if (station == s) {
d.addLast(i);
m.put(i, 1);
}
Set<Integer> set = map.getOrDefault(station, new HashSet<>());
set.add(i);
map.put(station, set);
}
}
while (!d.isEmpty()) {
// 取出当前所在的路线,与进入该路线所花费的距离
int poll = d.pollFirst();
int step = m.get(poll);
// 遍历该路线所包含的车站
for (int station : rs[poll]) {
// 如果包含终点,返回进入该路线花费的距离即可
if (station == t) return step;
// 将由该线路的车站发起的路线,加入队列
Set<Integer> lines = map.get(station);
if (lines == null) continue;
for (int nr : lines) {
if (!m.containsKey(nr)) {
m.put(nr, step + 1);
d.add(nr);
}
}
}
}
return -1;
}
}
```
* 时间复杂度:令路线的数量为 $n$,车站的数量为 $m$。建图的时间复杂度为 $O(\sum_{i=0}^{n-1} len(rs[i]))$;`BFS` 部分每个路线只会入队一次,最坏情况下每个路线都包含所有车站,复杂度为 $O(n * m)$。整体复杂度为 $O(n * m + \sum_{i=0}^{n-1} len(rs[i]))$。
* 空间复杂度:$O(n * m)$
---
### 双向 BFS(并查集预处理无解情况)
另外一个做法是使用双向 `BFS`。
首先建图方式不变,将「起点」和「终点」所能进入的路线分别放入两个方向的队列,如果「遇到公共的路线」或者「当前路线包含了目标位置」,说明找到了最短路径。
另外我们知道,双向 `BFS` 在无解的情况下不如单向 `BFS`。因此我们可以先使用「并查集」进行预处理,判断「起点」和「终点」是否连通,如果不联通,直接返回 $-1$,有解才调用双向 `BFS`。
由于使用「并查集」预处理的复杂度与建图是近似的,增加这样的预处理并不会越过我们时空复杂度的上限,因此这样的预处理是有益的。一定程度上可以最大化双向 `BFS` 减少搜索空间的效益。
代码:
```Java
class Solution {
static int N = (int)1e6+10;
static int[] p = new int[N];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void union(int a, int b) {
p[find(a)] = p[find(b)];
}
boolean query(int a, int b) {
return find(a) == find(b);
}
int s, t;
int[][] rs;
public int numBusesToDestination(int[][] _rs, int _s, int _t) {
rs = _rs; s = _s; t = _t;
if (s == t) return 0;
for (int i = 0; i < N; i++) p[i] = i;
for (int[] r : rs) {
for (int loc : r) {
union(loc, r[0]);
}
}
if (!query(s, t)) return -1;
int ans = bfs();
return ans;
}
// 记录某个车站可以进入的路线
Map<Integer, Set<Integer>> map = new HashMap<>();
int bfs() {
Deque<Integer> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
Map<Integer, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
int n = rs.length;
for (int i = 0; i < n; i++) {
for (int station : rs[i]) {
// 将从起点可以进入的路线加入正向队列
if (station == s) {
d1.addLast(i);
m1.put(i, 1);
}
// 将从终点可以进入的路线加入反向队列
if (station == t) {
d2.addLast(i);
m2.put(i, 1);
}
Set<Integer> set = map.getOrDefault(station, new HashSet<>());
set.add(i);
map.put(station, set);
}
}
// 如果「起点所发起的路线」和「终点所发起的路线」有交集,直接返回 1
Set<Integer> s1 = map.get(s), s2 = map.get(t);
Set<Integer> tot = new HashSet<>();
tot.addAll(s1);
tot.retainAll(s2);
if (!tot.isEmpty()) return 1;
// 双向 BFS
while (!d1.isEmpty() && !d2.isEmpty()) {
int res = -1;
if (d1.size() <= d2.size()) {
res = update(d1, m1, m2);
} else {
res = update(d2, m2, m1);
}
if (res != -1) return res;
}
return 0x3f3f3f3f; // never
}
int update(Deque<Integer> d, Map<Integer, Integer> cur, Map<Integer, Integer> other) {
int m = d.size();
while (m-- > 0) {
// 取出当前所在的路线,与进入该路线所花费的距离
int poll = d.pollFirst();
int step = cur.get(poll);
// 遍历该路线所包含的车站
for (int station : rs[poll]) {
// 遍历将由该线路的车站发起的路线
Set<Integer> lines = map.get(station);
if (lines == null) continue;
for (int nr : lines) {
if (cur.containsKey(nr)) continue;
if (other.containsKey(nr)) return step + other.get(nr);
cur.put(nr, step + 1);
d.add(nr);
}
}
}
return -1;
}
}
```
* 时间复杂度:令路线的数量为 $n$,车站的个数为 $m$。并查集和建图的时间复杂度为 $O(\sum_{i=0}^{n-1} len(rs[i]))$;`BFS` 求最短路径的复杂度为 $O(n * m)$。整体复杂度为 $O(n * m + \sum_{i=0}^{n-1} len(rs[i]))$。
* 空间复杂度:$O(n * m + \sum_{i=0}^{n-1} len(rs[i]))$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.815` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/816. 模糊坐标（中等）.md | 816. 模糊坐标 | https://leetcode.cn/problems/ambiguous-coordinates/solution/by-ac_oier-sbxl/ | 中等 | [
"枚举",
"模拟"
] | 我们有一些二维坐标,如 `"(1, 3)"` 或 `"(2, 0.5)"`,然后我们移除所有逗号,小数点和空格,得到一个字符串 `S`。返回所有可能的原始字符串到一个列表中。
原始的坐标表示法不会存在多余的零,所以不会出现类似于 `"00", "0.0", "0.00", "1.0", "001", "00.01"` 或一些其他更小的数来表示坐标。
此外,一个小数点前至少存在一个数,所以也不会出现 `“.1”` 形式的数字。
最后返回的列表可以是任意顺序的。而且注意返回的两个数字中间(逗号之后)都有一个空格。
示例 1:
```
输入: "(123)"
输出: ["(1, 23)", "(12, 3)", "(1.2, 3)", "(1, 2.3)"]
```
示例 2:
```
输入: "(00011)"
输出: ["(0.001, 1)", "(0, 0.011)"]
解释:
0.0, 00, 0001 或 00.01 是不被允许的。
```
示例 3:
```
输入: "(0123)"
输出: ["(0, 123)", "(0, 12.3)", "(0, 1.23)", "(0.1, 23)", "(0.1, 2.3)", "(0.12, 3)"]
```
示例 4:
```
输入: "(100)"
输出: [(10, 0)]
解释:
1.0 是不被允许的。
```
提示:
* $4 <= S.length <= 12$
* `S[0] = "(", S[S.length - 1] = ")"`, 且字符串 `S` 中的其他元素都是数字。 | ### 枚举
我们先将原字符串 `s` 中的左右括号去掉,重新定义 `s` 为原字符串 $s[1...(n - 2)]$,重新定义后的 `s` 长度为 `n`。
随后枚举逗号的位置 `idx`,枚举范围为 $[0, n - 1)$,含义为在 $s[idx]$ 后面追加逗号。
此时左边部分字符串为 $s[0, idx]$,右边部分字符串为 $s[idx + 1, n - 1]$。
实现一个搜索函数 `List<String> search(int start, int end)`,该函数返回使用字符串 $s[start...end]$ 构造的具体数值集合。
假设左边字符串 $s[0, idx]$ 搜索结果为 `A`,右边字符串 $s[idx + 1, n - 1]$ 搜索结果为 `B`,根据「乘法原理」,可知所有实际方案为 `(x, y)` 其中 $x \in A$,$y \in B$。
考虑如何实现 `search` 函数(假设入参函数 `start` 和 `end` 对应的子串为 `sub`):枚举字符串追加小数点的位置 `idx`,枚举范围为 $[start, end - 1)$,含义为在 $sub[idx]$ 后面追加小数点。小数点前面的部分不能包含前导零,小数点后面的部分不能包含后导零。注意记得把不添加小数点的合法方案也存入搜索集合。
Java 代码:
```Java
class Solution {
String s;
public List<String> ambiguousCoordinates(String _s) {
s = _s.substring(1, _s.length() - 1);
int n = s.length();
List<String> ans = new ArrayList<>();
for (int i = 0; i < n - 1; i++) { // 枚举逗号:在 i 的后面追加逗号
List<String> a = search(0, i), b = search(i + 1, n - 1);
for (String x : a) {
for (String y : b) {
ans.add("(" + x + ", " + y + ")");
}
}
}
return ans;
}
List<String> search(int start, int end) {
List<String> ans = new ArrayList<>();
if (start == end || s.charAt(start) != '0') ans.add(s.substring(start, end + 1));
for (int i = start; i < end; i++) { // 枚举小数点:在 i 后面追加小数点
String a = s.substring(start, i + 1), b = s.substring(i + 1, end + 1);
if (a.length() > 1 && a.charAt(0) == '0') continue;
if (b.charAt(b.length() - 1) == '0') continue;
ans.add(a + "." + b);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
string s;
vector<string> ambiguousCoordinates(string _s) {
s = _s.substr(1, _s.size() - 2);
int n = s.size();
vector<string> ans;
for (int i = 0; i < n - 1; i++) {
vector<string> a = search(0, i), b = search(i + 1, n - 1);
for (auto &x : a) {
for (auto &y : b) {
ans.push_back("(" + x + ", " + y + ")");
}
}
}
return ans;
}
vector<string> search(int start, int end) {
vector<string> ans;
if (start == end || s[start] != '0') ans.push_back(s.substr(start, end - start + 1));
for (int i = start; i < end; i++) {
string a = s.substr(start, i - start + 1), b = s.substr(i + 1, end - i);
if (a.size() > 1 && a[0] == '0') continue;
if (b.back() == '0') continue;
ans.push_back(a + "." + b);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def ambiguousCoordinates(self, _s: str) -> List[str]:
def search(s, start, end):
ans = []
if start == end or s[start] != '0':
ans.append(s[start:end+1])
for i in range(start, end):
a, b = s[start:i+1], s[i+1:end+1]
if len(a) > 1 and a[0] == '0':
continue
if b[-1] == '0':
continue
ans.append(f'{a}.{b}')
return ans
s = _s[1:len(_s)-1]
n = len(s)
ans = []
for i in range(n - 1):
a, b = search(s, 0, i), search(s, i + 1, n - 1)
for x in a:
for y in b:
ans.append(f'({x}, {y})')
return ans
```
TypeScript 代码:
```TypeScript
function ambiguousCoordinates(_s: string): string[] {
function search(s: string, start: number, end: number): string[] {
const ans = new Array<string>()
if (start == end || s[start] != '0') ans.push(s.substring(start, end + 1))
for (let i = start; i < end; i++) {
const a = s.substring(start, i + 1), b = s.substring(i + 1, end + 1)
if (a.length > 1 && a[0] == '0') continue
if (b[b.length - 1] == '0') continue
ans.push(a + '.' + b)
}
return ans
}
const s = _s.substring(1, _s.length - 1)
const n = s.length
const ans = new Array<string>()
for (let i = 0; i < n - 1; i++) {
const a = search(s, 0, i), b = search(s, i + 1, n - 1)
for (const x of a) {
for (const y of b) {
ans.push('(' + x + ', ' + y + ')')
}
}
}
return ans
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n^3)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.816` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/817. 链表组件（中等）.md | 817. 链表组件 | https://leetcode.cn/problems/linked-list-components/solution/by-ac_oier-3gl5/ | 中等 | [
"链表",
"模拟",
"哈希表"
] | 给定链表头结点 `head`,该链表上的每个结点都有一个 唯一的整型值 。同时给定列表 `nums`,该列表是上述链表中整型值的一个子集。
返回列表 `nums` 中组件的个数,这里对组件的定义为:链表中一段最长连续结点的值(该值必须在列表 `nums` 中)构成的集合。
示例 1:
```
输入: head = [0,1,2,3], nums = [0,1,3]
输出: 2
解释: 链表中,0 和 1 是相连接的,且 nums 中不包含 2,所以 [0, 1] 是 nums 的一个组件,同理 [3] 也是一个组件,故返回 2。
```
示例 2:
```
输入: head = [0,1,2,3,4], nums = [0,3,1,4]
输出: 2
解释: 链表中,0 和 1 是相连接的,3 和 4 是相连接的,所以 [0, 1] 和 [3, 4] 是两个组件,故返回 2。
```
提示:
* 链表中节点数为 `n`
* $1 <= n <= 10^4$
* $0 <= Node.val < n$
* `Node.val` 中所有值 不同
* $1 <= nums.length <= n$
* $0 <= nums[i] < n$
* `nums` 中所有值 不同 | ### 模拟
根据题意进行模拟即可 : 为了方便判断某个 $node.val$ 是否存在于 `nums` 中,我们先使用 `Set` 结构对所有的 $nums[i]$ 进行转存,随后每次检查连续段(组件)的个数。
Java 代码:
```Java
class Solution {
public int numComponents(ListNode head, int[] nums) {
int ans = 0;
Set<Integer> set = new HashSet<>();
for (int x : nums) set.add(x);
while (head != null) {
if (set.contains(head.val)) {
while (head != null && set.contains(head.val)) head = head.next;
ans++;
} else {
head = head.next;
}
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function numComponents(head: ListNode | null, nums: number[]): number {
let ans = 0
const set = new Set<number>()
for (const x of nums) set.add(x)
while (head != null) {
if (set.has(head.val)) {
while (head != null && set.has(head.val)) head = head.next
ans++
} else {
head = head.next
}
}
return ans
}
```
Python 代码:
```Python
class Solution:
def numComponents(self, head: Optional[ListNode], nums: List[int]) -> int:
ans = 0
nset = set([x for x in nums])
while head:
if head.val in nset:
while head and head.val in nset:
head = head.next
ans += 1
else:
head = head.next
return ans
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.817` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/811-820/819. 最常见的单词（简单）.md | 819. 最常见的单词 | https://leetcode-cn.com/problems/most-common-word/solution/by-ac_oier-6aqd/ | 简单 | [
"模拟",
"哈希表"
] | 给定一个段落 (`paragraph`) 和一个禁用单词列表 (`banned`)。返回出现次数最多,同时不在禁用列表中的单词。
题目保证至少有一个词不在禁用列表中,而且答案唯一。
禁用列表中的单词用小写字母表示,不含标点符号。段落中的单词不区分大小写。答案都是小写字母。
示例:
```
输入:
paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
banned = ["hit"]
输出: "ball"
解释:
"hit" 出现了3次,但它是一个禁用的单词。
"ball" 出现了2次 (同时没有其他单词出现2次),所以它是段落里出现次数最多的,且不在禁用列表中的单词。
注意,所有这些单词在段落里不区分大小写,标点符号需要忽略(即使是紧挨着单词也忽略, 比如 "ball,"),
"hit"不是最终的答案,虽然它出现次数更多,但它在禁用单词列表中。
```
提示:
* $1 <= `段落长度` <= 1000$
* $0 <= `禁用单词个数` <= 100$
* $1 <= `禁用单词长度` <= 10$
* 答案是唯一的, 且都是小写字母 (即使在 `paragraph` 里是大写的,即使是一些特定的名词,答案都是小写的。)
* `paragraph` 只包含字母、空格和下列标点符号`!?',;.`
* 不存在没有连字符或者带有连字符的单词。
* 单词里只包含字母,不会出现省略号或者其他标点符号。 | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public String mostCommonWord(String s, String[] banned) {
Set<String> set = new HashSet<>();
for (String b : banned) set.add(b);
char[] cs = s.toCharArray();
int n = cs.length;
String ans = null;
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < n; ) {
if (!Character.isLetter(cs[i]) && ++i >= 0) continue;
int j = i;
while (j < n && Character.isLetter(cs[j])) j++;
String sub = s.substring(i, j).toLowerCase();
i = j + 1;
if (set.contains(sub)) continue;
map.put(sub, map.getOrDefault(sub, 0) + 1);
if (ans == null || map.get(sub) > map.get(ans)) ans = sub;
}
return ans;
}
}
```
* 时间复杂度:$O(n + m)$,$n$ 和 $m$ 分别代表 `s` 的字符总长度和 `banned` 的字符总长度(哈希函数的计算与长度成正比)
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.819` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/821. 字符的最短距离（简单）.md | 821. 字符的最短距离 | https://leetcode-cn.com/problems/shortest-distance-to-a-character/solution/by-ac_oier-5bjs/ | 简单 | [
"模拟",
"BFS"
] | 给你一个字符串 `s` 和一个字符 `c` ,且 `c` 是 `s` 中出现过的字符。
返回一个整数数组 `answer`,其中 $answer.length == s.length$ 且 $answer[i]$ 是 `s` 中从下标 $i$ 到离它 最近 的字符 `c` 的 距离 。
两个下标 $i$ 和 $j$ 之间的 距离 为 `abs(i - j)` ,其中 `abs` 是绝对值函数。
示例 1:
```
输入:s = "loveleetcode", c = "e"
输出:[3,2,1,0,1,0,0,1,2,2,1,0]
解释:字符 'e' 出现在下标 3、5、6 和 11 处(下标从 0 开始计数)。
距下标 0 最近的 'e' 出现在下标 3 ,所以距离为 abs(0 - 3) = 3 。
距下标 1 最近的 'e' 出现在下标 3 ,所以距离为 abs(1 - 3) = 2 。
对于下标 4 ,出现在下标 3 和下标 5 处的 'e' 都离它最近,但距离是一样的 abs(4 - 3) == abs(4 - 5) = 1 。
距下标 8 最近的 'e' 出现在下标 6 ,所以距离为 abs(8 - 6) = 2 。
```
示例 2:
```
输入:s = "aaab", c = "b"
输出:[3,2,1,0]
```
提示:
* $1 <= s.length <= 10^4$
* $s[i]$ 和 `c` 均为小写英文字母
* 题目数据保证 `c` 在 `s` 中至少出现一次 | ### 遍历
根据题意进行模拟即可:两次遍历,第一次找到每个 $i$ 左边最近的 `c`,第二次找到每个 $i$ 右边最近的 `c`。
代码:
```Java
class Solution {
public int[] shortestToChar(String s, char c) {
int n = s.length();
int[] ans = new int[n];
Arrays.fill(ans, n + 1);
for (int i = 0, j = -1; i < n; i++) {
if (s.charAt(i) == c) j = i;
if (j != -1) ans[i] = i - j;
}
for (int i = n - 1, j = -1; i >= 0; i--) {
if (s.charAt(i) == c) j = i;
if (j != -1) ans[i] = Math.min(ans[i], j - i);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### BFS
起始令所有的 $ans[i] = -1$,然后将所有的 `c` 字符的下标入队,并更新 $ans[i] = 0$,然后跑一遍 `BFS` 逻辑,通过 $ans[i]$ 是否为 $-1$ 来判断是否重复入队。
代码:
```Java
class Solution {
public int[] shortestToChar(String s, char c) {
int n = s.length();
int[] ans = new int[n];
Arrays.fill(ans, -1);
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == c) {
d.addLast(i);
ans[i] = 0;
}
}
int[] dirs = new int[]{-1, 1};
while (!d.isEmpty()) {
int t = d.pollFirst();
for (int di : dirs) {
int ne = t + di;
if (ne >= 0 && ne < n && ans[ne] == -1) {
ans[ne] = ans[t] + 1;
d.addLast(ne);
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.821` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/824. 山羊拉丁文（简单）.md | 824. 山羊拉丁文 | https://leetcode-cn.com/problems/goat-latin/solution/by-ac_oier-t7hj/ | 简单 | [
"模拟"
] | 给你一个由若干单词组成的句子 `sentence`,单词间由空格分隔。每个单词仅由大写和小写英文字母组成。
请你将句子转换为 “山羊拉丁文(`Goat Latin`)”(一种类似于 猪拉丁文 - Pig Latin 的虚构语言)。山羊拉丁文的规则如下:
* 如果单词以元音开头(`'a'`, `'e'`, `'i'`, `'o'`, `'u'`),在单词后添加`"ma"`。
* 例如,单词 `"apple"` 变为 `"applema"` 。
* 如果单词以辅音字母开头(即,非元音字母),移除第一个字符并将它放到末尾,之后再添加`"ma"`。
* 例如,单词 `"goat"` 变为 `"oatgma"` 。
* 根据单词在句子中的索引,在单词最后添加与索引相同数量的字母`'a'`,索引从 $1$ 开始。
* 例如,在第一个单词后添加 `"a"`,在第二个单词后添加 `"aa"`,以此类推。
返回将 `sentence` 转换为山羊拉丁文后的句子。
示例 1:
```
输入:sentence = "I speak Goat Latin"
输出:"Imaa peaksmaaa oatGmaaaa atinLmaaaaa"
```
示例 2:
```
输入:sentence = "The quick brown fox jumped over the lazy dog"
输出:"heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"
```
提示:
* $1 <= sentence.length <= 150$
* `sentence` 由英文字母和空格组成
* `sentence` 不含前导或尾随空格
* `sentence` 中的所有单词由单个空格分隔 | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public String toGoatLatin(String s) {
int n = s.length();
String last = "a";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ) {
int j = i;
while (j < n && s.charAt(j) != ' ') j++;
if ("aeiouAEIOU".indexOf(s.charAt(i)) >= 0) {
sb.append(s.substring(i, j)).append("ma");
} else {
sb.append(s.substring(i + 1, j)).append(s.charAt(i)).append("ma");
}
sb.append(last);
last += "a";
i = j + 1;
if (i < n) sb.append(" ");
}
return sb.toString();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.824` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/825. 适龄的朋友（中等）.md | 825. 适龄的朋友 | https://leetcode-cn.com/problems/friends-of-appropriate-ages/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-maa8/ | 中等 | [
"排序",
"双指针",
"桶排序",
"前缀和"
] | 在社交媒体网站上有 $n$ 个用户。给你一个整数数组 `ages` ,其中 $ages[i]$ 是第 $i$ 个用户的年龄。
如果下述任意一个条件为真,那么用户 $x$ 将不会向用户 $y$(`x != y`)发送好友请求:
* $age[y] <= 0.5 * age[x] + 7$
* $age[y] > age[x]$
* $age[y] > 100$ 且 $age[x] < 100$
否则,$x$ 将会向 $y$ 发送一条好友请求。
注意,如果 $x$ 向 $y$ 发送一条好友请求,$y$ 不必也向 $x$ 发送一条好友请求。另外,用户不会向自己发送好友请求。
返回在该社交媒体网站上产生的好友请求总数。
示例 1:
```
输入:ages = [16,16]
输出:2
解释:2 人互发好友请求。
```
示例 2:
```
输入:ages = [16,17,18]
输出:2
解释:产生的好友请求为 17 -> 16 ,18 -> 17 。
```
示例 3:
```
输入:ages = [20,30,100,110,120]
输出:3
解释:产生的好友请求为 110 -> 100 ,120 -> 110 ,120 -> 100 。
```
提示:
* $n == ages.length$
* $1 <= n <= 2 * 10^4$
* $1 <= ages[i] <= 120$ | ### 排序 + 双指针
从三个不发送好友请求的条件来看,以 $y$ 的角度来说,可总结为:**年龄比我小的不考虑(同龄的可以),年龄比我大可以考虑,但是不能超过一定范围则不考虑。**
即对于一个确定的 $y$ 而言,会发送好友请求的 $x$ 范围为连续段:
**随着 $y$ 的逐渐增大,对应的 $x$ 连续段的左右边界均逐渐增大(数轴上均往右移动)。**
因此,我们可以先对 $ages$ 进行排序,枚举每个 $y = ages[k]$,同时使用 $i$ 和 $j$ 维护左右区间,$[i, j)$ 代表在 $ages$ 上会往 $y = ages[k]$ 发送请求的 $x$ 连续段,统计每个 $y = ages[k]$ 的 $x$ 有多少个即是答案,同时需要注意在 $[i, j)$ 范围内是包含 $y = ages[k]$ 自身,统计区间长度时需要进行 $-1$ 操作。
代码:
```Java
class Solution {
public int numFriendRequests(int[] ages) {
Arrays.sort(ages);
int n = ages.length, ans = 0;
for (int k = 0, i = 0, j = 0; k < n; k++) {
while (i < k && !check(ages[i], ages[k])) i++;
if (j < k) j = k;
while (j < n && check(ages[j], ages[k])) j++;
if (j > i) ans += j - i - 1;
}
return ans;
}
boolean check(int x, int y) {
if (y <= 0.5 * x + 7) return false;
if (y > x) return false;
if (y > 100 && x < 100) return false;
return true;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 桶排序 + 前缀和
在解法一中,复杂度的上界在于「双轴快排」,利用本题数据范围 `1 <= ages[i] <= 120`,值域较小,我们可以通过「桶排序」的方式进行排序优化。
假设对 $ages$ 进行桶排后得到的数组为 $nums$,其中 $cnt = nums[i]$ 的含义为在 $ages$ 中年龄为 $i$ 的人有 $cnt$ 个。
同时,我们发现在解法一中,我们枚举 $y = ages[k]$,并使用 $i$ 和 $j$ 两个指针寻找连续的 $x$ 段的过程,$x$ 会始终停留于值与 $y = ages[k]$ 相等的最小下标处,而对于桶排数组而言,当前位置就是最小合法 $x$ 值(与 $y$ 相等),因此我们只需要找到最大合法 $x$ 值的位置即可(对应解法一的 $j$ 位置)。
同样,最大 $x$ 的位置在桶排数组中也是随着 $y$ 的增大(右移)逐渐增大(右移)。
剩下的问题在于,如何统计桶排数组中连续段下标的和为多少(有多少个合法 $x$ 值),这可以直接在桶排数组应用前缀和即可。
代码:
```Java
class Solution {
int N = 130;
public int numFriendRequests(int[] ages) {
int[] nums = new int[N];
for (int i : ages) nums[i]++;
for (int i = 1; i < N; i++) nums[i] += nums[i - 1];
int ans = 0;
for (int y = 1, x = 1; y < N; y++) {
int a = nums[y] - nums[y - 1]; // 有 a 个 y
if (a == 0) continue;
if (x < y) x = y;
while (x < N && check(x, y)) x++;
int b = nums[x - 1] - nums[y - 1] - 1; // [y, x) 为合法的 x 范围,对于每个 y 而言,有 b 个 x
if (b > 0) ans += b * a;
}
return ans;
}
boolean check(int x, int y) {
if (y <= 0.5 * x + 7) return false;
if (y > x) return false;
if (y > 100 && x < 100) return false;
return true;
}
}
```
* 时间复杂度:令 $C$ 为年龄值域大小,对于本题 $C$ 固定为 $130$。复杂度为 $O(\max(n, C))$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.825` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/827. 最大人工岛（困难）.md | 827. 最大人工岛 | https://leetcode.cn/problems/making-a-large-island/solution/by-ac_oier-1kmp/ | 困难 | [
"并查集",
"枚举"
] | 给你一个大小为 `n x n` 二进制矩阵 `grid` 。最多 只能将一格 `0` 变成 `1` 。
返回执行此操作后,`grid` 中最大的岛屿面积是多少?
岛屿 由一组上、下、左、右四个方向相连的 `1` 形成。
示例 1:
```
输入: grid = [[1, 0], [0, 1]]
输出: 3
解释: 将一格0变成1,最终连通两个小岛得到面积为 3 的岛屿。
```
示例 2:
```
输入: grid = [[1, 1], [1, 0]]
输出: 4
解释: 将一格0变成1,岛屿的面积扩大为 4。
```
示例 3:
```
输入: grid = [[1, 1], [1, 1]]
输出: 4
解释: 没有0可以让我们变成1,面积依然为 4。
```
提示:
* $n = grid.length$
* $n == grid[i].length$
* $1 <= n <= 500$
* `grid[i][j]` 为 `0` 或 `1` | ### 并查集 + 枚举
为了方便,我们令 `grid` 为 `g`。
根据题意,容易想到通过「并查集」来维护所有连通块大小,再通过「枚举」来找最优翻转点。
具体的,我们可以先使用「并查集」维护所有 $g[i][j] = 1$ 的块连通性,并在维护连通性的过程中,使用 `sz[idx]` 记录下每个连通块的大小(注意:只有连通块根编号,`sz[idx]` 才有意义,即只有 `sz[find(x)]` 才有意义)。
随后我们再次遍历 `g`,根据原始的 $g[i][j]$ 的值进行分别处理:
* 若 $g[i][j] = 1$,该位置不会作为翻转点,但真实最大面积未必是由翻转后所导致的(可能取自原有的连通块),因此我们需要将 $sz[root]$ 参与比较,其中 `root` 为 $(i, j)$ 所属的连通块根节点编号;
* 若 $g[i][j] = 0$,该位置可作为翻转点,我们可以统计其四联通位置对应的连通块大小总和 `tot`(注意若四联通方向有相同连通块,只统计一次),那么 $tot + 1$ 即是翻转该位置所得到的新连通块大小。
最后对所有连通块大小取最大值即是答案。
> 一些细节:为了方便,我们令点 $(i, j)$ 的编号从 $1$ 开始;
同时由于我们本身就要用 `sz` 数组,因此我们可以随手把并查集的「按秩合并」也加上。体现在 `union` 操作时,我们总是将小的连通块合并到大的连通块上,从而确保我们并查集单次操作即使在最坏情况下复杂度仍为 $O(\alpha(n))$(可看作常数)。需要注意只有同时应用「路径压缩」和「按秩合并」,并查集操作复杂度才为 $O(\alpha(n))$。
Java 代码:
```Java
class Solution {
static int N = 510;
static int[] p = new int[N * N], sz = new int[N * N];
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void union(int a, int b) {
int ra = find(a), rb = find(b);
if (ra == rb) return ;
if (sz[ra] > sz[rb]) {
union(b, a);
} else {
sz[rb] += sz[ra]; p[ra] = p[rb];
}
}
public int largestIsland(int[][] g) {
int n = g.length;
for (int i = 1; i <= n * n; i++) {
p[i] = i; sz[i] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 0) continue;
for (int[] di : dirs) {
int x = i + di[0], y = j + di[1];
if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;
union(i * n + j + 1, x * n + y + 1);
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 1) {
ans = Math.max(ans, sz[find(i * n + j + 1)]);
} else {
int tot = 1;
Set<Integer> set = new HashSet<>();
for (int[] di : dirs) {
int x = i + di[0],y = j + di[1];
if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;
int root = find(x * n + y + 1);
if (set.contains(root)) continue;
tot += sz[root];
set.add(root);
}
ans = Math.max(ans, tot);
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int p[510 * 510], sz[510 * 510];
vector<vector<int>> dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void unionX(int a, int b) {
int ra = find(a), rb = find(b);
if (ra == rb) return;
if (sz[ra] > sz[rb]) {
unionX(b, a);
} else {
sz[rb] += sz[ra];
p[ra] = p[rb];
}
}
int largestIsland(vector<vector<int>>& g) {
int n = g.size();
for (int i = 1; i <= n * n; i++) {
p[i] = i; sz[i] = 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 0) continue;
for (const auto& di : dirs) {
int x = i + di[0], y = j + di[1];
if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;
unionX(i * n + j + 1, x * n + y + 1);
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 1) {
ans = max(ans, sz[find(i * n + j + 1)]);
} else {
int tot = 1;
unordered_set<int> set;
for (const auto& di : dirs) {
int x = i + di[0], y = j + di[1];
if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;
int root = find(x * n + y + 1);
if (set.find(root) != set.end()) continue;
tot += sz[root];
set.insert(root);
}
ans = max(ans, tot);
}
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def find(self, p, x):
if p[x] != x:
p[x] = self.find(p, p[x])
return p[x]
def union(self, p, sz, a, b):
ra, rb = self.find(p, a), self.find(p, b)
if ra == rb:
return
if sz[ra] > sz[rb]:
ra, rb = rb, ra
sz[rb] += sz[ra]
p[ra] = p[rb]
def largestIsland(self, g: List[List[int]]) -> int:
n, ans = len(g), 0
p, sz = [i for i in range(n * n + 10)], [1 for _ in range(n * n + 10)]
dirs = [[1,0],[-1,0],[0,1],[0,-1]]
for i in range(n):
for j in range(n):
if g[i][j] == 0:
continue
for di in dirs:
x, y = i + di[0], j + di[1]
if x < 0 or x >= n or y < 0 or y >= n or g[x][y] == 0:
continue
self.union(p, sz, i * n + j + 1, x * n + y + 1)
for i in range(n):
for j in range(n):
if g[i][j] == 1:
ans = max(ans, sz[self.find(p, i * n + j + 1)])
else:
tot = 1
vis = set()
for di in dirs:
x, y = i + di[0], j + di[1]
if x < 0 or x >= n or y < 0 or y >= n or g[x][y] == 0:
continue
root = self.find(p, x * n + y + 1)
if root in vis:
continue
tot += sz[root]
vis.add(root)
ans = max(ans, tot)
return ans
```
TypeScript 代码:
```TypeScript
const N = 510
const p = new Array<number>(N * N).fill(-1), sz = new Array<number>(N * N).fill(1)
const dirs = [[1,0], [-1,0], [0,1], [0,-1]]
function find(x: number): number {
if (p[x] != x) p[x] = find(p[x])
return p[x]
}
function union(a: number, b: number): void {
const ra = find(a), rb = find(b)
if (ra == rb) return
if (sz[ra] > sz[rb]) {
union(rb, ra)
} else {
sz[rb] += sz[ra]; p[ra] = p[rb]
}
}
function largestIsland(g: number[][]): number {
const n = g.length
for (let i = 1; i <= n * n; i++) {
p[i] = i; sz[i] = 1
}
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (g[i][j] == 0) continue
for (const di of dirs) {
const x = i + di[0], y = j + di[1]
if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue
union(i * n + j + 1, x * n + y + 1)
}
}
}
let ans = 0
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (g[i][j] == 1) {
ans = Math.max(ans, sz[find(i * n + j + 1)])
} else {
let tot = 1
const set = new Set()
for (let di of dirs) {
const x = i + di[0], y = j + di[1]
if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue
const root = find(x * n + y + 1)
if (set.has(root)) continue
tot += sz[root]
set.add(root)
}
ans = Math.max(ans, tot)
}
}
}
return ans
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.827` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/828. 统计子串中的唯一字符（困难）.md | 828. 统计子串中的唯一字符 | https://leetcode.cn/problems/count-unique-characters-of-all-substrings-of-a-given-string/solution/by-ac_oier-922k/ | 困难 | [
"模拟",
"数学",
"线性 DP"
] | 我们定义了一个函数 `countUniqueChars(s)` 来统计字符串 `s` 中的唯一字符,并返回唯一字符的个数。
例如:`s = "LEETCODE"` ,则其中 `"L"`, `"T"`,`"C"`,`"O"`,`"D"` 都是唯一字符,因为它们只出现一次,所以 `countUniqueChars(s) = 5`。
本题将会给你一个字符串 `s` ,我们需要返回 `countUniqueChars(t)` 的总和,其中 `t` 是 `s` 的子字符串。
输入用例保证返回值为 `32` 位整数。
注意,某些子字符串可能是重复的,但你统计时也必须算上这些重复的子字符串(也就是说,你必须统计 `s` 的所有子字符串中的唯一字符)。
示例 1:
```
输入: s = "ABC"
输出: 10
解释: 所有可能的子串为:"A","B","C","AB","BC" 和 "ABC"。
其中,每一个子串都由独特字符构成。
所以其长度总和为:1 + 1 + 1 + 2 + 2 + 3 = 10
```
示例 2:
```
输入: s = "ABA"
输出: 8
解释: 除了 countUniqueChars("ABA") = 1 之外,其余与示例 1 相同。
```
示例 3:
```
输入:s = "LEETCODE"
输出:92
```
提示:
* $1 <= s.length <= 10^5$
* `s` 只包含大写英文字符 | ### 模拟 + 乘法原理
这道题和 [907. 子数组的最小值之和](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493485&idx=1&sn=c6d6ac25c171e2617c5a95173aa58825) 如出一辙,只不过无须考虑运用「单调栈」。
原问题为求所有子数组的唯一字符数量和,其可等价为求每个 $s[i]$ 对答案的贡献,即每个 $s[i]$ 可作为多少个子数组的唯一元素。
假定我们能预处理出两数组 `l` 和 `r` 分别代表 $s[i]$ 作为子数组唯一字符时,其所能到达的最远两端:
* `l[i] = a` 代表下标 $a$ 为 $s[i]$ 能够作为子数组唯一字符时的最远左边界,即为 $s[i]$ 左边第一个与 $s[i]$ 值相同的位置(若不存在,则为 $a = -1$)
* `r[i] = b` 代表跳表 $b$ 为 $s[i]$ 能够作为子数组唯一字符时的最远右边界,即为 $s[i]$ 右边第一个与 $s[i]$ 值相同的位置(若不存在,则为 $b = n$)
子数组左端点个数为 $(i - a)$ 个,右端点个数为 $(b - i)$ 个,根据乘法原理可知,子数组个数为两者乘积。
预处理 `l` 和 `r` 只需要使用遍历计数即可。
Java 代码:
```Java
class Solution {
public int uniqueLetterString(String s) {
char[] cs = s.toCharArray();
int n = cs.length, ans = 0;
int[] l = new int[n], r = new int[n];
int[] idx = new int[26];
Arrays.fill(idx, -1);
for (int i = 0; i < n; i++) {
int u = cs[i] - 'A';
l[i] = idx[u];
idx[u] = i;
}
Arrays.fill(idx, n);
for (int i = n - 1; i >= 0; i--) {
int u = cs[i] - 'A';
r[i] = idx[u];
idx[u] = i;
}
for (int i = 0; i < n; i++) ans += (i - l[i]) * (r[i] - i);
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int uniqueLetterString(string s) {
int n = s.size(), ans = 0;
vector<int> l(n, -1), r(n, n);
vector<int> idx(26, -1);
for (int i = 0; i < n; i++) {
int u = s[i] - 'A';
l[i] = idx[u];
idx[u] = i;
}
fill(idx.begin(), idx.end(), n);
for (int i = n - 1; i >= 0; i--) {
int u = s[i] - 'A';
r[i] = idx[u];
idx[u] = i;
}
for (int i = 0; i < n; i++) ans += (i - l[i]) * (r[i] - i);
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def uniqueLetterString(self, s: str) -> int:
n = len(s)
l, r = [-1] * n, [n] * n
idx = [-1] * 26
for i in range(n):
u = ord(s[i]) - ord('A')
l[i] = idx[u]
idx[u] = i
idx = [n] * 26
for i in range(n - 1, -1, -1):
u = ord(s[i]) - ord('A')
r[i] = idx[u]
idx[u] = i
return sum((i - l[i]) * (r[i] - i) for i in range(n))
```
Typescript 代码:
```Typescript
function uniqueLetterString(s: string): number {
let n = s.length, ans = 0
const l = new Array<number>(n), r = new Array<number>(n)
const idx = new Array<number>(26).fill(-1)
for (let i = 0; i < n; i++) {
const u = s.charCodeAt(i) - 65
l[i] = idx[u]
idx[u] = i
}
idx.fill(n)
for (let i = n - 1; i >= 0; i--) {
const u = s.charCodeAt(i) - 65
r[i] = idx[u]
idx[u] = i
}
for (let i = 0; i < n; i++) ans += (i - l[i]) * (r[i] - i)
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 线性 DP
另外一个实现思路是利用「动态规划」思想。
定义 $f[i]$ 为考虑以 $s[i]$ 为结尾的所有子串中的唯一字符个数。
不失一般性考虑 $f[i]$ 该如何转移:以 $s[i]$ 为结尾的子串包括在所有以 $s[i - 1]$ 为结尾的子串结尾添加一个字符而来,以及 $s[i]$ 字符本身组成的新子串。
首先我们令 $f[i] = f[i - 1]$,同时使用 $b[x]$ 记录字符 $x$ 前一次出现的下标,使用 $a[x]$ 记录字符 $x$ 在上上次出现的下标,然后假设当前处理的字符为 $c = s[i]$,考虑 $s[i]$ 对 $f[i]$ 的影响(注意 $s[i]$ 始终为子串右端点):
* 在子串左端点下标范围在 $[b[c] + 1, i]$ 的子串中,$s[i]$ 必然只出现一次(满足唯一字符要求),即可增加 $i - b[c]$ 个唯一字符 $s[i]$;
* 在子串左端点下标范围在 $[a[c] + 1, b[c]]$ 的子串中,原本位于 $b[c]$ 的字符在新子串中出现次数变为 $2$ 次(不再满足唯一字符要求),即需减少 $b[c] - a[c]$ 个唯一字符 $s[i]$。
综上,我们有状态转移方程:$f[i] = f[i - 1] + (i - b[s[i]]) - (b[s[i]] - a[s[i]])$
实现上,由于 $f[i]$ 只依赖于 $f[i - 1]$,因此我们无须真的创建动规数组,而只需要使用单个变量 `cur` 来记录当前处理到的 $f[i]$ 即可,累积所有的 $f[i]$ 即是答案。
Java 代码:
```Java
class Solution {
public int uniqueLetterString(String s) {
int n = s.length(), ans = 0, cur = 0;
int[] a = new int[26], b = new int[26];
Arrays.fill(a, -1); Arrays.fill(b, -1);
for (int i = 0; i < n; i++) {
int u = s.charAt(i) - 'A';
cur += i - b[u] - (b[u] - a[u]);
ans += cur;
a[u] = b[u]; b[u] = i;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int uniqueLetterString(string s) {
int n = s.length(), ans = 0, cur = 0;
vector<int> a(26, -1), b(26, -1);
for (int i = 0; i < n; ++i) {
int u = s[i] - 'A';
cur += i - b[u] - (b[u] - a[u]);
ans += cur;
a[u] = b[u]; b[u] = i;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def uniqueLetterString(self, s: str) -> int:
n, ans, cur = len(s), 0, 0
a, b = [-1] * 26, [-1] * 26
for i in range(n):
u = ord(s[i]) - ord('A')
cur += i - b[u] - (b[u] - a[u])
ans += cur
a[u], b[u] = b[u], i
return ans
```
TypeScript 代码:
```TypeScript
function uniqueLetterString(s: string): number {
let n = s.length, ans = 0, cur = 0
const a = new Array<number>(26).fill(-1), b = new Array<number>(26).fill(-1)
for (let i = 0; i < n; i++) {
const u = s.charCodeAt(i) - 65
cur += i - b[u] - (b[u] - a[u])
ans += cur
a[u] = b[u]; b[u] = i
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.828` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/821-830/829. 连续整数求和（困难）.md | 829. 连续整数求和 | https://leetcode.cn/problems/consecutive-numbers-sum/solution/by-ac_oier-220q/ | 困难 | [
"数论",
"数学"
] | 给定一个正整数 $n$,返回连续正整数满足所有数字之和为 $n$ 的组数 。
示例 1:
```
输入: n = 5
输出: 2
解释: 5 = 2 + 3,共有两组连续整数([5],[2,3])求和后为 5。
```
示例 2:
```
输入: n = 9
输出: 3
解释: 9 = 4 + 5 = 2 + 3 + 4
```
示例 3:
```
输入: n = 15
输出: 4
解释: 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5
```
提示:
* $1 <= n <= 10^9$ | ### 数论
假设我们存在某个连续段之和为 $n$,假定该连续段首项为 $a$,长度为 $k$,根据「等差数列求和」可知:
$$
\frac{(a + a + k - 1) \times k}{2} = n
$$
简单变形可得:
$$
(2a + k - 1) \times k = 2n \Leftrightarrow 2a = \frac{2n}{k} - k + 1
$$
根据首项 $a$ 和 $k$ 均为正整数,可得:
$$
2a = \frac{2n}{k} - k + 1 \geq 2
$$
进一步可得:
$$
\frac{2n}{k} \geq k + 1 \Leftrightarrow \frac{2n}{k} > k
$$
综上,根据 $(2a + k - 1) \times k = 2n$ 和 $\frac{2n}{k} > k$ 可知,$k$ 必然是 $2n$ 的约数,并且为「较小」的约数。
因此我们可以在 $[1, \sqrt{2n})$ 范围内枚举 $k$,如果 $k$ 为 $2n$ 约数,并且结合 $(2a + k - 1) \times k = 2n$ 可验证 $a$ 合法,说明找到了一组合法的 $(a, k)$,对答案进行累加。
Java 代码:
```Java
class Solution {
public int consecutiveNumbersSum(int n) {
int ans = 0; n *= 2;
for (int k = 1; k * k < n; k++) {
if (n % k != 0) continue;
if ((n / k - (k - 1)) % 2 == 0) ans++;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int consecutiveNumbersSum(int n) {
int ans = 0; n *= 2;
for (int k = 1; k * k < n; k++) {
if (n % k != 0) continue;
if ((n / k - (k - 1)) % 2 == 0) ans++;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def consecutiveNumbersSum(self, n: int) -> int:
ans, n = 0, n * 2
for k in range(1, int(n ** 0.5) + 1):
ans += n % k == 0 and (n // k - (k - 1)) % 2 == 0
return ans
```
TypeScript 代码:
```TypeScript
function consecutiveNumbersSum(n: number): number {
let ans = 0; n *= 2;
for (let k = 1; k * k < n; k++) {
if (n % k != 0) continue;
if ((n / k - (k - 1)) % 2 == 0) ans++;
}
return ans;
};
```
* 时间复杂度:$O(\sqrt{2n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.829` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/831-840/832. 翻转图像（简单）.md | 832. 翻转图像 | https://leetcode-cn.com/problems/flipping-an-image/solution/shuang-zhi-zhen-yi-bian-chu-li-huan-you-ik0v1/ | 简单 | [
"双指针"
] | 给定一个二进制矩阵 A,我们想先水平翻转图像,然后反转图像并返回结果。
水平翻转图片就是将图片的每一行都进行翻转,即逆序。例如,水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。
反转图片的意思是图片中的 0 全部被 1 替换, 1 全部被 0 替换。例如,反转 [0, 1, 1] 的结果是 [1, 0, 0]。
示例 1:
```
输入:[[1,1,0],[1,0,1],[0,0,0]]
输出:[[1,0,0],[0,1,0],[1,1,1]]
解释:首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]];
然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]
```
示例 2:
```
输入:[[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
输出:[[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
解释:首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]];
然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
```
提示:
* 1 <= A.length = A[0].length <= 20
* 0 <= A[i][j] <= 1 | ### 双指针代码
对于每行而言,我们都需要对其进行「翻转」和「反转」。
这两步可以到放到一遍循环里做:
* 翻转部分:使用双指针进行数字交换
* 反转部分:将数字存储进目标位置前,使用「异或」对 0 1 进行翻转
当前有一些「小细节」需要注意:
1. 题目要求我们对参数图像进行翻转,并返回新图像。因此我们不能对输入直接进行修改,而要先进行拷贝再处理
2. 由于我们将「翻转」和「反转」合成了一步,因此对于「奇数」图像,需要对中间一列进行特殊处理:仅「反转」
对于 Java 的基本类型拷贝,有三种方式进行拷贝:
1. System.arraycopy() : 底层的数组拷贝接口,具体实现与操作系统相关,调用的是系统本地方法。需要自己创建好目标数组进行传入,可指定拷贝长度,实现局部拷贝。
2. Arrays.copyOf() : 基于 `System.arraycopy()` 封装的接口,省去了自己目标数组这一步。但无法实现局部拷贝。
3. clone() : Object 的方法。会调用每个数组成员的 clone() 方法进行拷贝。因此对于一维数组而言,可以直接使用 clone() 得到「深拷贝数组」,而对于多维数组而言,得到的是「浅拷贝数组」。
```java []
class Solution {
public int[][] flipAndInvertImage(int[][] a) {
int n = a.length;
int[][] ans = new int[n][n];
for (int i = 0; i < n; i++) {
// ans[i] = a[i].clone();
// ans[i] = Arrays.copyOf(a[i], n);
System.arraycopy(a[i], 0, ans[i], 0, n);
int l = 0, r = n - 1;
while (l < r) {
int c = ans[i][r];
ans[i][r--] = ans[i][l] ^ 1;
ans[i][l++] = c ^ 1;
}
if (n % 2 != 0) ans[i][r] ^= 1;
}
return ans;
}
}
```
```java []
class Solution {
public int[][] flipAndInvertImage(int[][] a) {
int n = a.length;
int[][] ans = new int[n][n];
// 遍历每一行进行处理
for (int i = 0; i < n; i++) {
// 对每一行进行拷贝(共三种方式)
// ans[i] = a[i].clone();
// ans[i] = Arrays.copyOf(a[i], n);
System.arraycopy(a[i], 0, ans[i], 0, n);
// 使用「双指针」对其进行数组交换,实现「翻转」
// 并通过「异或」进行 0 1 翻转,实现「反转」
int l = 0, r = n - 1;
while (l < r) {
int c = ans[i][r];
ans[i][r--] = ans[i][l] ^ 1;
ans[i][l++] = c ^ 1;
}
// 由于「奇数」矩形的中间一列不会进入上述双指针逻辑
// 需要对其进行单独「反转」
if (n % 2 != 0) ans[i][r] ^= 1;
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:使用了同等大小的空间存储答案。复杂度为 $O(n^2)$
***
### 补充
Q: 那么 Arrays.copyOfRange() 与 System.arraycopy() 作用是否等同呢?
A: 不等同。
Arrays.copyOf() 和 Arrays.copyOfRange() 都会内部创建目标数组。前者是直接创建一个和源数组等长的数组,而后者则是根据传参 to 和 from 计算出目标数组长度进行创建。
它们得到的数组都是完整包含了要拷贝内容的,都无法实现目标数组的局部拷贝功能。
例如我要拿到一个长度为 10 的数组,前面 5 个位置的内容来源于「源数组」的拷贝,后面 5 个位置我希望预留给我后面自己做操作,它们都无法满足,只有 System.arraycopy() 可以。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.832` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/831-840/834. 树中距离之和（困难）.md | 834. 树中距离之和 | https://leetcode.cn/problems/sum-of-distances-in-tree/solutions/2449965/gong-shui-san-xie-shu-xing-dp-chang-gui-1v7ud/ | 困难 | [
"树形 DP",
"DFS",
"动态规划",
"树"
] | 给定一个无向、连通的树。
树中有 `n` 个标记为 `0...n-1` 的节点以及 `n-1` 条边 。
给定整数 `n` 和数组 `edges`, $edges[i] = [a_{i}, b_{i}]$表示树中的节点 $a_{i}$ 和 $b_{i}$ 之间有一条边。
返回长度为 `n` 的数组 `answer`,其中 `answer[i]` 是树中第 `i` 个节点与所有其他节点之间的距离之和。
示例 1:
```
输入: n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
输出: [8,12,6,10,10,10]
解释: 树如图所示。
我们可以计算出 dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5)
也就是 1 + 1 + 2 + 2 + 2 = 8。 因此,answer[0] = 8,以此类推。
```
示例 2:
```
输入: n = 1, edges = []
输出: [0]
```
示例 3:
```
输入: n = 2, edges = [[1,0]]
输出: [1,1]
```
提示:
* $1 <= n <= 3 \times 10^4$
* $edges.length = n - 1$
* $edges[i].length = 2$
* $0 <= a_{i}, b_{i} < n$
* $a_{i} != b_{i}$
* 给定的输入保证为有效的树 | ### 树形 DP
**对于树形 DP,可以随便以某个节点为根,把整棵树“拎起来”进行分析,通常还会以“方向”作为切入点进行思考。**
不妨以编号为 `0` 的节点作为根节点进行分析:假设当前处理到的节点为 `u`,当前节点 `u` 的父节点为 `fa`,同时 `u` 有若干子节点 `j`。
对于任意节点 `u` 而言,其树中距离之和可根据「方向/位置」分为两大类(对应示例图的左右两部分):
* 所有从节点 `u` “往下”延伸所达的节点距离之和,即所有经过 `u -> j` 边所能访问到的节点距离之和
* 所有从节点 `u` “往上”延伸所达的节点距离之和,即经过 `u -> fa` 边所能访问到的节点距离之和
假设我们能够用 $f[u]$ 和 $g[u]$ 预处理出每个节点“往下”和“往上”的距离之和,那么就有 $ans[u] = f[u] + g[u]$。
不失一般性分别考虑 $f[u]$ 和 $g[u]$ 该如何计算。
为了方便,起始先用「链式前向星」对 `edges` 进行转存,同时在递归计算 $f[u]$ 时,将父节点 `fa` 也进行传递,从而避免遍历节点 `u` 的出边时,重新走回 `fa` 。
##### $f[u]$ 的推导
对于叶子节点(没有“往下”出边的节点),我们有 $f[u] = 0$ 的天然条件,计算好的叶子节点值可用于更新其父节点,因此**求解 $f[u]$ 是一个「从下往上」的递推过程**。
假设当前处理到的节点是 `u`,往下节点有 $j_{1}$、$j_{2}$ 和 $j_{3}$ ,且所有 $f[j]$ 均已计算完成。
由于 $f[u]$ 是由所有存在“往下”出边的节点 `j` 贡献而来。而单个子节点 `j` 来说,其对 $f[u]$ 的贡献应当是:**在所有原有节点到节点 `j` 的距离路径中,额外增加一条当前出边(`u -> j`),再加上 `1`(代表节点 `u` 到节点 `j` 的距离)**。
原路径距离之和恰好是 $f[j]$,额外需要增加的出边数量为原来参与计算 $f[j]$ 的点的数量(即挂载在节点 `j` 下的数量),因此我们还需要一个 `c` 数组,来记录某个节点下的子节点数量。
最终的 $f[u]$ 为所有符合条件的节点的 `j` 的 $f[j] + c[j] + 1$ 的总和。
##### $g[u]$ 的推导
对于树形 DP 题目,“往下”的计算往往是容易的,而“往上”的计算则是稍稍麻烦。
假设当前我们处理到节点为 `u`,将要遍历的节点为 `j`,考虑如何使用已经计算好的 $f[X]$ 来求解 $g[j]$。
这里为什么是求解 $g[j]$,而不是 $g[u]$ 呢?
因为我们求解的方向是“往上”的部分,必然是用父节点的计算结果,来推导子节点的结果,即**求解 $g[u]$ 是一个「从上往下」的过程**。
对于树形 DP ,通常需要对“往上”进一步拆分:「往上再往上」和「往上再往下」:
* 往上再往上:是指经过了 `j -> u` 后,还必然经过 `u -> fa` 这条边时,所能到达的节点距离之和:
这部分对 $g[j]$ 的贡献为:在所有原有节点到节点 `u` 的距离路径中,额外增加一条当前出边(`u -> j`),增加当前出边的数量与节点数量相同,点数量为 $n - 1 - c[u]$,含义为 总节点数量 减去 `u` 节点以及子节点数量。
即此部分对 $g[j]$ 的贡献为 $g[u] + n - 1 - c[u]$。
* 往上再往下:是指经过了 `j -> u` 后,还经过「除 `u -> j` 以外」的其他“往下”边时,所能到达的节点距离之和:
这部分的计算需要先在 $f[u]$ 中剔除 $f[j]$ 的贡献,然后再加上额外边(`u -> j`)的累加数量,同样也是节点数量。
从 $f[u]$ 中剔除 $f[j]$ 后为 $f[u] - f[j] - c[j]$,而点的数量为 $c[u] - 1 - c[j]$,含义为在以节点 `u` 为根的子树中剔除调用以节点 `j` 为根节点的部分。
即此部分对 $g[j]$ 的贡献为 $f[u] - f[j] - c[j] + c[u] - 1 - c[j]$。
Java 代码:
```Java
class Solution {
int N = 30010, M = 60010, idx = 0, n;
int[] he = new int[N], e = new int[M], ne = new int[M];
int[] f = new int[N], c = new int[N], g = new int[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int[] sumOfDistancesInTree(int _n, int[][] es) {
n = _n;
Arrays.fill(he, -1);
for (int[] e : es) {
int a = e[0], b = e[1];
add(a, b); add(b, a);
}
dfs1(0, -1);
dfs2(0, -1);
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = f[i] + g[i];
return ans;
}
int[] dfs1(int u, int fa) {
int tot = 0, cnt = 0;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
int[] next = dfs1(j, u);
tot += next[0] + next[1] + 1; cnt += next[1] + 1;
}
f[u] = tot; c[u] = cnt;
return new int[]{tot, cnt};
}
void dfs2(int u, int fa) {
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
g[j] += g[u] + n - 1 - c[u]; // 往上再往上
g[j] += f[u] - f[j] - c[j] + c[u] - 1 - c[j]; // 往上再往下
dfs2(j, u);
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
int N = 30010, M = 60010, idx = 0, n;
int he[30010], e[60010], ne[60010];
int f[30010], c[30010], g[30010];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
vector<int> sumOfDistancesInTree(int _n, vector<vector<int>>& es) {
n = _n;
memset(he, -1, sizeof(he));
for (auto& e : es) {
int a = e[0], b = e[1];
add(a, b);
add(b, a);
}
dfs1(0, -1);
dfs2(0, -1);
vector<int> ans(n);
for (int i = 0; i < n; i++) ans[i] = f[i] + g[i];
return ans;
}
vector<int> dfs1(int u, int fa) {
int tot = 0, cnt = 0;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
vector<int> next = dfs1(j, u);
tot += next[0] + next[1] + 1;
cnt += next[1] + 1;
}
f[u] = tot; c[u] = cnt;
return {tot, cnt};
}
void dfs2(int u, int fa) {
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
g[j] += g[u] + n - 1 - c[u];
g[j] += f[u] - f[j] - c[j] + c[u] - 1 - c[j];
dfs2(j, u);
}
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.834` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/831-840/838. 推多米诺（中等）.md | 838. 推多米诺 | https://leetcode-cn.com/problems/push-dominoes/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-y-z52w/ | 中等 | [
"BFS",
"双指针"
] | `n` 张多米诺骨牌排成一行,将每张多米诺骨牌垂直竖立。在开始时,同时把一些多米诺骨牌向左或向右推。
每过一秒,倒向左边的多米诺骨牌会推动其左侧相邻的多米诺骨牌。同样地,倒向右边的多米诺骨牌也会推动竖立在其右侧的相邻多米诺骨牌。
如果一张垂直竖立的多米诺骨牌的两侧同时有多米诺骨牌倒下时,由于受力平衡, 该骨牌仍然保持不变。
就这个问题而言,我们会认为一张正在倒下的多米诺骨牌不会对其它正在倒下或已经倒下的多米诺骨牌施加额外的力。
给你一个字符串 `dominoes` 表示这一行多米诺骨牌的初始状态,其中:
* `dominoes[i] = 'L'`,表示第 `i` 张多米诺骨牌被推向左侧,
* `dominoes[i] = 'R'`,表示第 `i` 张多米诺骨牌被推向右侧,
* `dominoes[i] = '.'`,表示没有推动第 `i` 张多米诺骨牌。
返回表示最终状态的字符串。
示例 1:
```
输入:dominoes = "RR.L"
输出:"RR.L"
解释:第一张多米诺骨牌没有给第二张施加额外的力。
```
示例 2:
```
输入:dominoes = ".L.R...LR..L.."
输出:"LL.RR.LLRRLL.."
```
提示:
* $n == dominoes.length$
* $1 <= n <= 10^5$
* $dominoes[i]$ 为 `'L`、`'R'` 或 `'.'` | ### BFS
推倒骨牌是一个行为传递的过程,可以使用 `BFS` 来进行模拟。
起始将所有不为 `.` 的骨牌以 $(loc, time, dire)$ 三元组的形式进行入队,三元组所代表的含义为「**位置为 $loc$ 的骨牌在 $time$ 时刻受到一个方向为 $dire$ 的力**」,然后进行常规的 `BFS` 即可。
在受力(入队)时,我们尝试修改骨牌的状态,同时为了解决「一个骨牌同时受到左右推力时,维持站立状态不变」的问题,我们需要在尝试修改骨牌状态后,额外记录下该骨牌的状态修改时间,如果在同一时间内,一块骨牌受力两次(只能是来自左右两个方向的力),需要将该骨牌恢复成竖立状态。
代码:
```Java
class Solution {
public String pushDominoes(String dominoes) {
char[] cs = dominoes.toCharArray();
int n = cs.length;
int[] g = new int[n];
Deque<int[]> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (cs[i] == '.') continue;
int dire = cs[i] == 'L' ? -1 : 1;
d.add(new int[]{i, 1, dire});
g[i] = 1;
}
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int loc = info[0], time = info[1], dire = info[2];
int ne = loc + dire;
if (cs[loc] == '.' || (ne < 0 || ne >= n)) continue;
if (g[ne] == 0) { // 首次受力
d.addLast(new int[]{ne, time + 1, dire});
g[ne] = time + 1;
cs[ne] = dire == -1 ? 'L' : 'R';
} else if (g[ne] == time + 1) { // 多次受力
cs[ne] = '.';
}
}
return String.valueOf(cs);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 预处理 + 双指针
我们知道,**如果一块原本竖立的骨牌最终倒下,必然是「受到来自左侧向右的力」或者「受到来自右侧向左的力」**。
基于此,我们可以**创建两个二维数组 `l` 和 `r` 分别存储每个位置 $i$ 的左侧和右侧的受力情况,每个的 $l[i]$ 和 $r[i]$ 分别存储「左侧」和「右侧」的最近受力点下标,以及该力的方向**。
然后枚举所有 $dominoes[i]$ 为 `.` 的位置,获取其左侧的最近受力点 `loc1` 和受力方向 `dire1`,以及其右侧的最近受力点 `loc2` 和受力方向 `dire2`,并进行分情况讨论即可。
根据左右侧受力情况修改骨牌状态可通过「双指针」实现。
> 一些细节:为了避免每个样例都 `new` 大数组,可以使用 `static` 优化 `l` 和 `r` 的创建。
代码:
```Java
class Solution {
static int N = 100010;
static int[][] l = new int[N][2], r = new int[N][2];
public String pushDominoes(String dominoes) {
char[] cs = dominoes.toCharArray();
int n = cs.length;
for (int i = 0, j = -1; i < n; i++) {
if (cs[i] != '.') j = i;
l[i] = new int[]{j, j != -1 ? cs[j] : '.'};
}
for (int i = n - 1, j = -1; i >= 0; i--) {
if (cs[i] != '.') j = i;
r[i] = new int[]{j, j != -1 ? cs[j] : '.'};
}
for (int i = 0; i < n; ) {
if (cs[i] != '.' && ++i >= 0) continue;
int j = i;
while (j < n && cs[j] == '.') j++;
j--;
int[] a = l[i], b = r[j];
int loc1 = a[0], dire1 = a[1], loc2 = b[0], dire2 = b[1];
if (loc1 == -1 && loc2 == -1) { // 两侧无力
} else if (loc1 == -1) { // 只有右侧有力,且力的方向向左
if (dire2 == 'L') update(cs, i, j, 'L', 'L');
} else if (loc2 == -1) { // 只有左侧有力,且力的方向向右
if (dire1 == 'R') update(cs, i, j, 'R', 'R');
} else { // 两侧有力,且两力方向「不同时」反向
if (!(dire1 == 'L' && dire2 == 'R')) update(cs, i, j, (char)dire1, (char)dire2);
}
i = j + 1;
}
return String.valueOf(cs);
}
void update(char[] cs, int l, int r, char c1, char c2) {
for (int p = l, q = r; p <= q; p++, q--) {
if (p == q && c1 != c2) continue;
cs[p] = c1; cs[q] = c2;
}
}
}
```
* 时间复杂度:预处理 `l` 和 `r` 的复杂度为 $O(n)$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.838` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/841-850/846. 一手顺子（中等）.md | 846. 一手顺子 | https://leetcode-cn.com/problems/hand-of-straights/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-4hxw/ | 中等 | [
"模拟",
"优先队列(堆)",
"哈希表"
] | Alice 手中有一把牌,她想要重新排列这些牌,分成若干组,使每一组的牌数都是 groupSize ,并且由 groupSize 张连续的牌组成。
给你一个整数数组 `hand` 其中 `hand[i]` 是写在第 `i` 张牌,和一个整数 `groupSize`。
如果她可能重新排列这些牌,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
输出:true
解释:Alice 手中的牌可以被重新排列为 [1,2,3],[2,3,4],[6,7,8]。
```
示例 2:
```
输入:hand = [1,2,3,4,5], groupSize = 4
输出:false
解释:Alice 手中的牌无法被重新排列成几个大小为 4 的组。
```
提示:
* $1 <= hand.length <= 10^4$
* $0 <= hand[i] <= 10^9$
* $1 <= groupSize <= hand.length$ | ### 模拟 + 哈希表 + 优先队列(堆)
为了方便,我们令 $m = groupSize$。
题目要求我们将 $hand$ 分为若干份大小为 $m$ 的顺子。
**在给定 $hand$ 的情况下,划分方式唯一确定,因此本质上这是一个「模拟」的过程。**
具体的,我们可以使用「哈希表」对 $hand$ 中的数值进行「出现次数」统计,并用于后续 **实时** 维护剩余元素的出现次数。
然后使用优先队列维护(小根堆)所有的 $hand[i]$。每次从优先队列(堆)中取出堆顶元素 $t$ 来 **尝试作为**「顺子」的发起点/首个元素(当然 $t$ 能够作为发起点的前提是 $t$ 仍是剩余元素,即实时维护的出现次数不为 $0$ ),然后用 $t$ 作为发起点/首个元素构造顺子,即对 $[t, t + 1, ... , t + m - 1]$ 元素的出现次数进行 $-1$ 操作。
若构造过程中没有出现「剩余元素出现次数」不足以 $-1$ 的话,说明整个构造过程没有冲突,返回 `True`,否则返回 `False`。
代码:
```Java
class Solution {
public boolean isNStraightHand(int[] hand, int m) {
Map<Integer, Integer> map = new HashMap<>();
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);
for (int i : hand) {
map.put(i, map.getOrDefault(i, 0) + 1);
q.add(i);
}
while (!q.isEmpty()) {
int t = q.poll();
if (map.get(t) == 0) continue;
for (int i = 0; i < m; i++) {
int cnt = map.getOrDefault(t + i, 0);
if (cnt == 0) return false;
map.put(t + i, cnt - 1);
}
}
return true;
}
}
```
* 时间复杂度:令 $n$ 为数组 `hand` 长度,使用哈希表进行次数统计的复杂度为 $O(n)$;将所有元素从堆中存入和取出的复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.846` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/841-850/847. 访问所有节点的最短路径（困难）.md | 847. 访问所有节点的最短路径 | https://leetcode-cn.com/problems/shortest-path-visiting-all-nodes/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-z-6p2k/ | 困难 | [
"图",
"图论 BFS",
"动态规划",
"状态压缩",
"AStar 算法",
"启发式搜索"
] | 存在一个由 $n$ 个节点组成的无向连通图,图中的节点按从 $0$ 到 $n - 1$ 编号。
给你一个数组 `graph` 表示这个图。其中,$graph[i]$ 是一个列表,由所有与节点 $i$ 直接相连的节点组成。
返回能够访问所有节点的最短路径的长度。你可以在任一节点开始和停止,也可以多次重访节点,并且可以重用边。
示例 1:
```
输入:graph = [[1,2,3],[0],[0],[0]]
输出:4
解释:一种可能的路径为 [1,0,2,0,3]
```
示例 2:
```
输入:graph = [[1],[0,2,4],[1,3,4],[2],[1,2]]
输出:4
解释:一种可能的路径为 [0,1,4,2,3]
```
提示:
* $n == graph.length$
* $1 <= n <= 12$
* $0 <= graph[i].length < n$
* `graph[i]` 不包含 $i$
* 如果 `graph[a]` 包含 `b` ,那么 `graph[b]` 也包含 `a`
* 输入的图总是连通图 | ### 基本分析
为了方便,令点的数量为 $n$,边的数量为 $m$。
这是一个等权无向图,题目要我们求从「**一个点都没访问过**」到「**所有点都被访问**」的最短路径。
同时 $n$ 只有 $12$,容易想到使用「状态压缩」来代表「当前点的访问状态」:**使用二进制表示长度为 $32$ 的 `int` 的低 $12$ 来代指点是否被访问过。**
我们可以通过一个具体的样例,来感受下「状态压缩」是什么意思:
例如 $(000...0101)_2$ 代表编号为 $0$ 和编号为 $2$ 的节点已经被访问过,而编号为 $1$ 的节点尚未被访问。
然后再来看看使用「状态压缩」的话,一些基本的操作该如何进行:
假设变量 $state$ 存放了「当前点的访问状态」,当我们需要检查编号为 $x$ 的点是否被访问过时,可以使用位运算 `a = (state >> x) & 1`,来获取 $state$ 中第 $x$ 位的二进制表示,如果 `a` 为 $1$ 代表编号为 $x$ 的节点已被访问,如果为 $0$ 则未被访问。
同理,当我们需要将标记编号为 $x$ 的节点已经被访问的话,可以使用位运算 `state | (1 << x)` 来实现标记。
---
### 状态压缩 + BFS
因为是等权图,求从某个状态到另一状态的最短路,容易想到 `BFS`。
同时我们需要知道下一步能往哪些点进行移动,因此除了记录当前的点访问状态 $state$ 以外,还需要记录最后一步是在哪个点 $u$,因此我们需要使用二元组进行记录 $(state, u)$,同时使用 $dist$ 来记录到达 $(state, u)$ 使用的步长是多少。
> 一些细节:由于点的数量较少,使用「邻接表」或者「邻接矩阵」来存图都可以。对于本题,由于已经给出了 $graph$ 数组,因此可以直接充当「邻接表」来使用,而无须做额外的存图操作。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
public int shortestPathLength(int[][] graph) {
int n = graph.length;
int mask = 1 << n;
// 初始化所有的 (state, u) 距离为正无穷
int[][] dist = new int[mask][n];
for (int i = 0; i < mask; i++) Arrays.fill(dist[i], INF);
// 因为可以从任意起点出发,先将起始的起点状态入队,并设起点距离为 0
Deque<int[]> d = new ArrayDeque<>(); // state, u
for (int i = 0; i < n; i++) {
dist[1 << i][i] = 0;
d.addLast(new int[]{1 << i, i});
}
// BFS 过程,如果从点 u 能够到达点 i,则更新距离并进行入队
while (!d.isEmpty()) {
int[] poll = d.pollFirst();
int state = poll[0], u = poll[1], step = dist[state][u];
if (state == mask - 1) return step;
for (int i : graph[u]) {
if (dist[state | (1 << i)][i] == INF) {
dist[state | (1 << i)][i] = step + 1;
d.addLast(new int[]{state | (1 << i), i});
}
}
}
return -1; // never
}
}
```
* 时间复杂度:点(状态)数量为 $n \times 2^n$,边的数量为 $n^2 \times 2^n$,`BFS` 复杂度上界为点数加边数,整体复杂度为 $O(n^2 \times 2^n)$
* 空间复杂度:$O(n \times 2^n)$
---
### Floyd + 状压 DP
其实在上述方法中,我们已经使用了与 DP 状态定义分析很像的思路了。甚至我们的元祖设计 $(state, u)$ 也很像状态定义的两个维度。
**那么为什么我们不使用 $f[state][u]$ 为从「没有点被访问过」到「访问过的点状态为 $state$」,并最后一步落在点 $u$ 的状态定义,然后跑一遍 DP 来做呢?**
**是因为如果从「常规的 DP 转移思路」出发,状态之间不存在拓扑序(有环),这就导致了我们在计算某个 $f[state][u]$ 时,它所依赖的状态并不确保已经被计算/更新完成,所以我们无法使用常规的 DP 手段来求解。**
> 这里说的常规 DP 手段是指:枚举所有与 $u$ 相连的节点 $v$,用 $f[state'][v]$ 来更新 $f[state][u]$ 的转移方式。
常规的 DP 转移方式状态间不存在拓扑序,我们需要换一个思路进行转移。
对于某个 $state$ 而言,我们可以枚举其最后一个点 $i$ 是哪一个,充当其达到 $state$ 的最后一步,然后再枚举下一个点 $j$ 是哪一个,充当移动的下一步(当然前提是满足 $state$ 的第 $i$ 位为 $1$,而第 $j$ 位为 $0$)。
求解任意两点最短路径,可以使用 Floyd 算法,复杂度为 $O(n^3)$。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
public int shortestPathLength(int[][] graph) {
int n = graph.length;
int mask = 1 << n;
// Floyd 求两点的最短路径
int[][] dist = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = INF;
}
}
for (int i = 0; i < n; i++) {
for (int j : graph[i]) dist[i][j] = 1;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
// DP 过程,如果从 i 能够到 j 的话,使用 i 到 j 的最短距离(步长)来转移
int[][] f = new int[mask][n];
// 起始时,让所有状态的最短距离(步长)为正无穷
for (int i = 0; i < mask; i++) Arrays.fill(f[i], INF);
// 由于可以将任意点作为起点出发,可以将这些起点的最短距离(步长)设置为 0
for (int i = 0; i < n; i++) f[1 << i][i] = 0;
// 枚举所有的 state
for (int state = 0; state < mask; state++) {
// 枚举 state 中已经被访问过的点
for (int i = 0; i < n; i++) {
if (((state >> i) & 1) == 0) continue;
// 枚举 state 中尚未被访问过的点
for (int j = 0; j < n; j++) {
if (((state >> j) & 1) == 1) continue;
f[state | (1 << j)][j] = Math.min(f[state | (1 << j)][j], f[state][i] + dist[i][j]);
}
}
}
int ans = INF;
for (int i = 0; i < n; i++) ans = Math.min(ans, f[mask - 1][i]);
return ans;
}
}
```
* 时间复杂度:Floyd 复杂度为 $O(n^3)$;DP 共有 $n \times 2^n$ 个状态需要被转移,每次转移复杂度为 $O(n)$,总的复杂度为 $O(n^2 \times 2^n)$。整体复杂度为 $O(\max(n^3, n^2 \times 2^n))$
* 空间复杂度:$O(n \times 2^n)$
---
### AStar 算法
显然,从 $state$ 到 $state'$ 的「理论最小修改成本」为两者二进制表示中不同位数的个数。
同时,当且仅当在 $state$ 中 $1$ 的位置与 $state'$ 中 $0$ 存在边,才有可能取到这个「理论最小修改成本」。
因此直接使用当前状态 $state$ 与最终目标状态 `1 << n` 两者二进制表示中不同位数的个数作为启发预估值是合适的。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
int n;
int f(int state) {
int ans = 0;
for (int i = 0; i < n; i++) {
if (((state >> i) & 1) == 0) ans++;
}
return ans;
}
public int shortestPathLength(int[][] g) {
n = g.length;
int mask = 1 << n;
int[][] dist = new int[mask][n];
for (int i = 0; i < mask; i++) {
for (int j = 0; j < n; j++) {
dist[i][j] = INF;
}
}
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[2]-b[2]); // state, u, val
for (int i = 0; i < n; i++) {
dist[1 << i][i] = 0;
q.add(new int[]{1<< i, i, f(i << 1)});
}
while (!q.isEmpty()) {
int[] poll = q.poll();
int state = poll[0], u = poll[1], step = dist[state][u];
if (state == mask - 1) return step;
for (int i : g[u]) {
int nState = state | (1 << i);
if (dist[nState][i] > step + 1) {
dist[nState][i] = step + 1;
q.add(new int[]{nState, i, step + 1 + f(nState)});
}
}
}
return -1; // never
}
}
```
* 时间复杂度:启发式搜索不讨论时空复杂度
* 空间复杂度:启发式搜索不讨论时空复杂度 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.847` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/841-850/850. 矩形面积 II（困难）.md | 850. 矩形面积 II | https://leetcode.cn/problems/rectangle-area-ii/solution/gong-shui-san-xie-by-ac_oier-9r36/ | 困难 | [
"扫描线"
] | 我们给出了一个(轴对齐的)二维矩形列表 `rectangles`。 对于 $rectangle[i] = [x_1, y_1, x_2, y_2]$,其中$(x_1, y_1)$ 是矩形 `i` 左下角的坐标,$ (x_{i1}, y_{i1})$ 是该矩形 左下角 的坐标,$ (x_{i2}, y_{i2})$ 是该矩形 右上角 的坐标。
计算平面中所有 `rectangles` 所覆盖的 总面积 。任何被两个或多个矩形覆盖的区域应只计算 一次 。
返回 总面积 。因为答案可能太大,返回 $10^9 + 7$ 的 模 。
示例 1:
```
输入:rectangles = [[0,0,2,2],[1,0,2,3],[1,0,3,1]]
输出:6
解释:如图所示,三个矩形覆盖了总面积为6的区域。
从(1,1)到(2,2),绿色矩形和红色矩形重叠。
从(1,0)到(2,3),三个矩形都重叠。
```
示例 2:
```
输入:rectangles = [[0,0,1000000000,1000000000]]
输出:49
解释:答案是 1018 对 (109 + 7) 取模的结果, 即 49 。
```
提示:
* $1 <= rectangles.length <= 200$
* $rectanges[i].length = 4$
* $0 <= x_{i1}, y_{i1}, x_{i2}, y_{i2} <= 10^9$
* 矩形叠加覆盖后的总面积不会超越 $2^{63} - 1$ ,这意味着可以用一个 `64` 位有符号整数来保存面积结果。 | ### 扫描线
这是一道「扫描线」模板题。
将所有给定的矩形的左右边对应的 `x` 端点提取出来并排序,每个端点可看作是一条竖直的线段(红色),问题转换为求解「由多条竖直线段分割开」的多个矩形的面积总和(黄色):
相邻线段之间的宽度为单个矩形的「宽度」(通过 `x` 差值直接算得),问题转换为求该区间内高度的并集(即矩形的高度)。
由于数据范围只有 $200$,我们可以对给定的所有矩形进行遍历,统计所有对该矩形有贡献的 `y` 值线段(即有哪些 `rs[i]` 落在该矩形中),再对线段进行求交集(总长度),即可计算出该矩形的「高度」,从而计算出来该矩形的面积。
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int rectangleArea(int[][] rs) {
List<Integer> list = new ArrayList<>();
for (int[] info : rs) {
list.add(info[0]); list.add(info[2]);
}
Collections.sort(list);
long ans = 0;
for (int i = 1; i < list.size(); i++) {
int a = list.get(i - 1), b = list.get(i), len = b - a;
if (len == 0) continue;
List<int[]> lines = new ArrayList<>();
for (int[] info : rs) {
if (info[0] <= a && b <= info[2]) lines.add(new int[]{info[1], info[3]});
}
Collections.sort(lines, (l1, l2)->{
return l1[0] != l2[0] ? l1[0] - l2[0] : l1[1] - l2[1];
});
long tot = 0, l = -1, r = -1;
for (int[] cur : lines) {
if (cur[0] > r) {
tot += r - l;
l = cur[0]; r = cur[1];
} else if (cur[1] > r) {
r = cur[1];
}
}
tot += r - l;
ans += tot * len;
ans %= MOD;
}
return (int) ans;
}
}
```
TypeScript 代码:
```TypeScript
const MOD = BigInt(1e9+7)
function rectangleArea(rs: number[][]): number {
const list = new Array<number>()
for (let info of rs) {
list.push(info[0]); list.push(info[2]);
}
list.sort((a,b)=>a-b)
let ans = 0n
for (let i = 1; i < list.length; i++) {
const a = list[i - 1], b = list[i], len = b - a
if (len == 0) continue
const lines = new Array<number[]>()
for (let info of rs) {
if (info[0] <= a && b <= info[2]) lines.push([info[1], info[3]])
}
lines.sort((l1,l2)=>{
return l1[0] != l2[0] ? l1[0] - l2[0] : l1[1] - l2[1]
})
let tot = 0n, l = -1, r = -1
for (let cur of lines) {
if (cur[0] > r) {
tot += BigInt(r - l)
l = cur[0]; r = cur[1]
} else if (cur[1] > r) {
r = cur[1]
}
}
tot += BigInt(r - l)
ans += tot * BigInt(len)
ans %= MOD
}
return Number(ans)
};
```
Python 代码:
```Python
class Solution:
def rectangleArea(self, rs: List[List[int]]) -> int:
ps = []
for info in rs:
ps.append(info[0])
ps.append(info[2])
ps.sort()
ans = 0
for i in range(1, len(ps)):
a, b = ps[i - 1], ps[i]
width = b - a
if width == 0:
continue
lines = [(info[1], info[3]) for info in rs if info[0] <= a and b <= info[2]]
lines.sort()
height, l, r = 0, -1, -1
for cur in lines:
if cur[0] > r:
height += r - l
l, r = cur
elif cur[1] > r:
r = cur[1]
height += r - l
ans += height * width
return ans % 1000000007
```
Go 代码:
```Go
const MOD = int64(1e9 + 7)
func rectangleArea(rectangles [][]int) int {
list := []int{}
for _, info := range rectangles {
list = append(list, info[0])
list = append(list, info[2])
}
sort.Ints(list)
ans := int64(0)
for i := 1; i < len(list); i++ {
a, b, length := list[i - 1], list[i], list[i] - list[i - 1]
if length == 0 {
continue
}
lines := [][]int{}
for _, info := range rectangles {
if info[0] <= a && b <= info[2] {
lines = append(lines, []int{info[1], info[3]})
}
}
sort.Slice(lines, func(i,j int) bool {
if lines[i][0] != lines[j][0] {
return lines[i][0] - lines[j][0] < 0
}
return lines[i][1] - lines[j][1] < 0
})
total, l, r := int64(0), -1, -1
for _, cur := range lines {
if cur[0] > r {
total += int64(r - l)
l, r = cur[0], cur[1]
} else if cur[1] > r {
r = cur[1]
}
}
total += int64(r - l)
ans += total * int64(length)
ans %= MOD
}
return int(ans)
}
```
* 时间复杂度:预处理所有扫描线的复杂度为 $O(n\log{n})$;处理所有相邻的扫描线,并计算相邻扫描线形成的矩形面积复杂度为 $O(n\log{n})$ 。整体复杂度为 $O(n^2\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.850` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/851. 喧闹和富有（中等）.md | 851. 喧闹和富有 | https://leetcode-cn.com/problems/loud-and-rich/solution/gong-shui-san-xie-tuo-bu-pai-xu-yun-yong-ylih/ | 中等 | [
"拓扑排序"
] | 有一组 `n` 个人作为实验对象,从 `0` 到 `n - 1` 编号,其中每个人都有不同数目的钱,以及不同程度的安静值(`quietness`)。为了方便起见,我们将编号为 `x` 的人简称为 `"person x"`。
给你一个数组 `richer` ,其中 `richer[i] = [ai, bi]` 表示 $person$ $a_i$ 比 $person$ $b_i$ 更有钱。另给你一个整数数组 `quiet`,其中 `quiet[i]` 是 $person_i$ 的安静值。
`richer` 中所给出的数据 逻辑自恰(也就是说,在 $person_x$ 比 $person_y$ 更有钱的同时,不会出现 $person_y$ 比 $person_x$ 更有钱的情况 )。
现在,返回一个整数数组 `answer` 作为答案,其中 `answer[x] = y` 的前提是,在所有拥有的钱肯定不少于 `person x` 的人中,`person y` 是最安静的人(也就是安静值 `quiet[y]` 最小的人)。
示例 1:
```
输入:richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]
输出:[5,5,2,5,4,5,6,7]
解释:
answer[0] = 5,
person 5 比 person 3 有更多的钱,person 3 比 person 1 有更多的钱,person 1 比 person 0 有更多的钱。
唯一较为安静(有较低的安静值 quiet[x])的人是 person 7,
但是目前还不清楚他是否比 person 0 更有钱。
answer[7] = 7,
在所有拥有的钱肯定不少于 person 7 的人中(这可能包括 person 3,4,5,6 以及 7),
最安静(有较低安静值 quiet[x])的人是 person 7。
其他的答案也可以用类似的推理来解释。
```
示例 2:
```
输入:richer = [], quiet = [0]
输出:[0]
```
提示:
* $n == quiet.length$
* $1 <= n <= 500$
* $0 <= quiet[i] < n$
* $quiet$ 的所有值 互不相同
* $0 <= richer.length <= n * (n - 1) / 2$
* $0 <= ai, bi < n$
* $ai != bi$
* `richer` 中的所有数对 互不相同
* 对 `richer` 的观察在逻辑上是一致的 | ### 拓扑排序
根据题意,我们可以使用 `richer` 进行建图(邻接矩阵/邻接表),对于每组 $richer[i] = (a_i, b_i)$ 而言,添加一条从 $a$ 到 $b$ 的有向边(有钱指向没钱)。
其中题目中的「`richer` 逻辑自恰」是指在该图中不存在环,即为 DAG。
因此我们可以在建图过程中,同时统计每个节点的入度数,然后在图中跑一遍拓扑排序来求得答案 $ans$。
**对「图论 拓扑排序」不了解的同学,可以先看前置 🧀:[拓扑排序入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489706&idx=1&sn=771cd807f39d1ca545640c0ef7e5baec&chksm=fd9cb3b5caeb3aa333809633f09e3967c8f62d10feec5a463c7e30d4781e1fecb50e7f46e4af&token=126965152&lang=zh_CN#rd),里面详细说明了「拓扑排序的基本流程」&「反向图 + 拓扑排序做法的正确性证明」。**
起始时,每个 $ans[i] = i$,然后将统计入度为 $0$ 的节点进行入队,每次出队时,将该节点删掉,对该 DAG 带来影响是「该节点的邻点的入度减一」,若更新入度后数值为 $0$,则将该邻点进行入队操作。
同时,利用跑拓扑排序过程中的 $t -> u$ 关系,尝试使用 $ans[t]$ 更新 $ans[u]$(由于存在 $t$ 指向 $u$ 的边,说明 $t$ 比 $u$ 有钱,此时检查两者的安静值,若满足 $quiet[ans[t]] < quiet[ans[u]]$,则用 $ans[t]$ 更新 $ans[u]$)。
> 本题为稠密图(点数为 $n$,边数为 $m$,当 $m$ 与 $n^2$ 为同一数据级,定义以为稠密图),可直接使用「邻接矩阵」进行存图。
关于何种图选择什么存图方式,在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=126965152&lang=zh_CN#rd) 详细讲过,本次不再赘述。
代码($P1$ 为邻接矩阵,$P2$ 为邻接表):
```Java
class Solution {
public int[] loudAndRich(int[][] richer, int[] quiet) {
int n = quiet.length;
int[][] w = new int[n][n];
int[] in = new int[n];
for (int[] r : richer) {
int a = r[0], b = r[1];
w[a][b] = 1; in[b]++;
}
Deque<Integer> d = new ArrayDeque<>();
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
ans[i] = i;
if (in[i] == 0) d.addLast(i);
}
while (!d.isEmpty()) {
int t = d.pollFirst();
for (int u = 0; u < n; u++) {
if (w[t][u] == 1) {
if (quiet[ans[t]] < quiet[ans[u]]) ans[u] = ans[t];
if (--in[u] == 0) d.addLast(u);
}
}
}
return ans;
}
}
```
```Java
class Solution {
int N = 510, M = N * N + 10;
int[] he = new int[N], e = new int[M], ne = new int[M];
int idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx;
idx++;
}
public int[] loudAndRich(int[][] richer, int[] quiet) {
int n = quiet.length;
int[] in = new int[n];
Arrays.fill(he, -1);
for (int[] r : richer) {
int a = r[0], b = r[1];
add(a, b); in[b]++;
}
Deque<Integer> d = new ArrayDeque<>();
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
ans[i] = i;
if (in[i] == 0) d.addLast(i);
}
while (!d.isEmpty()) {
int t = d.pollFirst();
for (int i = he[t]; i != -1; i = ne[i]) {
int u = e[i];
if (quiet[ans[t]] < quiet[ans[u]]) ans[u] = ans[t];
if (--in[u] == 0) d.addLast(u);
}
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为 `person` 数量(点数),$m$ 为 `richer` 长度(边数)。的建图的复杂度为 $O(m)$;拓扑排序复杂度为 $O(m + n)$。整体复杂度为 $O(m + n)$
* 空间复杂度:$O(m + n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.851` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/852. 山脉数组的峰顶索引（简单）.md | 852. 山脉数组的峰顶索引 | https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/solution/gong-shui-san-xie-er-fen-san-fen-cha-zhi-5gfv/ | 简单 | [
"二分",
"三分"
] | 符合下列属性的数组 `arr` 称为 山脉数组 :
* `arr.length >= 3`
* 存在 `i(0 < i < arr.length - 1)` 使得:
* `arr[0] < arr[1] < ... arr[i-1] < arr[i]`
* `arr[i] > arr[i+1] > ... > arr[arr.length - 1]`
给你由整数组成的山脉数组 `arr` ,返回任何满足 `arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1]` 的下标 `i` 。
示例 1:
```
输入:arr = [0,1,0]
输出:1
```
示例 2:
```
输入:arr = [0,2,1,0]
输出:1
```
示例 3:
```
输入:arr = [0,10,5,2]
输出:1
```
示例 4:
```
输入:arr = [3,4,5,1]
输出:2
```
示例 5:
```
输入:arr = [24,69,100,99,79,78,67,36,26,19]
输出:2
```
提示:
* $3 <= arr.length <= 10^4$
* $0 <= arr[i] <= 10^6$
* 题目数据保证 `arr` 是一个山脉数组
进阶:很容易想到时间复杂度 $O(n)$ 的解决方案,你可以设计一个 $O(\log{n})$ 的解决方案吗? | ### 二分
往常我们使用「二分」进行查值,需要确保序列本身满足「二段性」:当选定一个端点(基准值)后,结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。
但本题求的是峰顶索引值,如果我们选定数组头部或者尾部元素,其实无法根据大小关系“直接”将数组分成两段。
但可以利用题目发现如下性质:**由于 `arr` 数值各不相同,因此峰顶元素左侧必然满足严格单调递增,峰顶元素右侧必然不满足。**
因此 **以峰顶元素为分割点的 `arr` 数组,根据与 前一元素/后一元素 的大小关系,具有二段性:**
* 峰顶元素左侧满足 $arr[i-1] < arr[i]$ 性质,右侧不满足
* 峰顶元素右侧满足 $arr[i] > arr[i+1]$ 性质,左侧不满足
因此我们可以选择任意条件,写出若干「二分」版本。
代码:
```Java
class Solution {
// 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 1, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (arr[mid - 1] < arr[mid]) l = mid;
else r = mid - 1;
}
return r;
}
}
```
```Java
class Solution {
// 根据 arr[i] > arr[i+1] 在 [0,n-2] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素值
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 0, r = n - 2;
while (l < r) {
int mid = l + r >> 1;
if (arr[mid] > arr[mid + 1]) r = mid;
else l = mid + 1;
}
return r;
}
}
```
```Java
class Solution {
// 根据 arr[i-1] > arr[i] 在 [1,n-1] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素的前一个值
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 1, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (arr[mid - 1] > arr[mid]) r = mid;
else l = mid + 1;
}
return r - 1;
}
}
```
```Java
class Solution {
// 根据 arr[i] < arr[i+1] 在 [0,n-2] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素的下一个值
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 0, r = n - 2;
while (l < r) {
int mid = l + r + 1 >> 1;
if (arr[mid] < arr[mid + 1]) l = mid;
else r = mid - 1;
}
return r + 1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 三分
事实上,我们还可以利用「三分」来解决这个问题。
顾名思义,**「三分」就是使用两个端点将区间分成三份,然后通过每次否决三分之一的区间来逼近目标值。**
具体的,由于峰顶元素为全局最大值,因此我们可以每次将当前区间分为 $[l, m1]$、$[m1, m2]$ 和 $[m2, r]$ 三段,如果满足 $arr[m1] > arr[m2]$,说明峰顶元素不可能存在与 $[m2, r]$ 中,让 $r = m2 - 1$ 即可。另外一个区间分析同理。
代码:
```Java
class Solution {
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 0, r = n - 1;
while (l < r) {
int m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
if (arr[m1] > arr[m2]) r = m2 - 1;
else l = m1 + 1;
}
return r;
}
}
```
* 时间复杂度:$O(\log_3{n})$
* 空间复杂度:$O(1)$
---
### 二分 & 三分 & k 分 ?
必须说明一点,「二分」和「三分」在渐进复杂度上都是一样的,都可以通过换底公式转化为可忽略的常数,因此两者的复杂度都是 $O(\log{n})$。
而选择「二分」还是「三分」取决于要解决的是什么问题:
* 二分通常用来解决单调函数的找 $target$ 问题,但进一步深入我们发现只需要满足「二段性」就能使用「二分」来找分割点;
* 三分则是解决单峰函数极值问题。
**因此一般我们将「通过比较两个端点,每次否决 1/3 区间 来解决单峰最值问题」的做法称为「三分」;而不是简单根据单次循环内将区间分为多少份来判定是否为「三分」。**
随手写了一段反例代码:
```Java
class Solution {
public int peakIndexInMountainArray(int[] arr) {
int left = 0, right = arr.length - 1;
while(left < right) {
int m1 = left + (right - left) / 3;
int m2 = right - (right - left + 2) / 3;
if (arr[m1] > arr[m1 + 1]) {
right = m1;
} else if (arr[m2] < arr[m2 + 1]) {
left = m2 + 1;
} else {
left = m1; right = m2;
}
}
return left;
}
}
```
这并不是「三分」做法,最多称为「变形二分」。本质还是利用「二段性」来做分割的,只不过同时 check 了两个端点而已。
如果这算「三分」的话,那么我能在一次循环里面划分 $k - 1$ 个端点来实现 $k$ 分?
**显然这是没有意义的,因为按照这种思路写出来的所谓的「四分」、「五分」、「k 分」是需要增加同等数量的分支判断的。这时候单次 `while` 决策就不能算作 $O(1)$ 了,而是需要在 $O(k)$ 的复杂度内决定在哪个分支,就跟上述代码有三个分支进行判断一样。** 因此,这种写法只能算作是「变形二分」。
**综上,只有「二分」和「三分」的概念,不存在所谓的 $k$ 分。** 同时题解中的「三分」部分提供的做法就是标准的「三分」做法。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.852` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/854. 相似度为 K 的字符串（困难）.md | 854. 相似度为 K 的字符串 | https://leetcode.cn/problems/k-similar-strings/solution/by-ac_oier-w8nf/ | 困难 | [
"启发式搜索",
"AStar 算法"
] | 对于某些非负整数 `k` ,如果交换 $s_1$ 中两个字母的位置恰好 `k` 次,能够使结果字符串等于 $s_2$ ,则认为字符串 $s_1$ 和 $s_2$ 的 相似度为 `k` 。
给你两个字母异位词 $s_1$ 和 $s_2$ ,返回 $s_1$ 和 $s_2$ 的相似度 `k` 的最小值。
示例 1:
```
输入:s1 = "ab", s2 = "ba"
输出:1
```
示例 2:
```
输入:s1 = "abc", s2 = "bca"
输出:2
```
提示:
* $1 <= s1.length <= 20$
* $s2.length = s1.length$
* `s1` 和 `s2` 只包含集合 `{'a', 'b', 'c', 'd', 'e', 'f'}` 中的小写字母
* `s2` 是 `s1` 的一个字母异位词 | ### AStar 算法
由于题目确保了 `s1` 和 `s2` 互为字母异位词(必然有解),因此最好的求解方式是使用 AStar 算法。
可直接根据本题规则来设计 AStar 的启发式函数: 对于两个状态 `a` 和 `b` 直接计算出「理论最小转换次数」: **不同字符串的转换成本之和,由于每一次交换最多可减少两个不同的字符,我们可计算 `a` 与 `b` 的不同字符数量 $ans$,对应的理论最小转换次数为 $\left \lfloor \frac{ans + 1}{2} \right \rfloor$。**
需要注意的是:**由于我们衡量某个字符 `str` 的估值是以目标字符串 `target` 为基准,因此我们只能确保 `target` 出队时为「距离最短」,而不能确保中间节点出队时「距离最短」,因此我们不能单纯根据某个节点是否「曾经入队」而决定是否入队,还要结合当前节点的「最小距离」是否被更新而决定是否入队。**
> 一些细节:在使用当前状态(字符串)`poll` 拓展新状态(字符串)`nstr` 时,只拓展能够减少不同字符数量的方案,从而收窄搜索空间。
Java 代码:
```Java
class Solution {
int n;
String t;
int f(String s) {
int ans = 0;
for (int i = 0; i < n; i++) ans += s.charAt(i) != t.charAt(i) ? 1 : 0;
return ans + 1 >> 1;
}
public int kSimilarity(String s1, String s2) {
if (s1.equals(s2)) return 0;
t = s2;
n = s1.length();
Map<String, Integer> map = new HashMap<>();
PriorityQueue<String> pq = new PriorityQueue<>((a,b)->{
int v1 = f(a), v2 = f(b), d1 = map.get(a), d2 = map.get(b);
return (v1 + d1) - (v2 + d2);
});
map.put(s1, 0);
pq.add(s1);
while (!pq.isEmpty()) {
String poll = pq.poll();
int step = map.get(poll);
char[] cs = poll.toCharArray();
int idx = 0;
while (idx < n && cs[idx] == t.charAt(idx)) idx++;
for (int i = idx + 1; i < n; i++) {
if (cs[i] != t.charAt(idx) || cs[i] == t.charAt(i)) continue;
swap(cs, idx, i);
String nstr = String.valueOf(cs);
swap(cs, idx, i);
if (map.containsKey(nstr) && map.get(nstr) <= step + 1) continue;
if (nstr.equals(t)) return step + 1;
map.put(nstr, step + 1);
pq.add(nstr);
}
}
return -1; // never
}
void swap(char[] cs, int i, int j) {
char c = cs[i];
cs[i] = cs[j];
cs[j] = c;
}
}
```
* 时间复杂度:启发式搜索不分析时空复杂度
* 空间复杂度:启发式搜索不分析时空复杂度 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.854` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/856. 括号的分数（中等）.md | 856. 括号的分数 | https://leetcode.cn/problems/score-of-parentheses/solution/by-ac_oier-0mhz/ | 中等 | [
"栈"
] | 给定一个平衡括号字符串 `S`,按下述规则计算该字符串的分数:
* `()` 得 `1` 分。
* `AB` 得 `A + B` 分,其中 `A` 和 `B` 是平衡括号字符串。
* `(A)` 得 `2 * A` 分,其中 `A` 是平衡括号字符串。
示例 1:
```
输入: "()"
输出: 1
```
示例 2:
```
输入: "(())"
输出: 2
```
示例 3:
```
输入: "()()"
输出: 2
```
示例 4:
```
输入: "(()(()))"
输出: 6
```
提示:
* `S` 是平衡括号字符串,且只含有 `(` 和 `)` 。
* $2 <= S.length <= 50$ | ### 栈
初始化将答案 `0` 放入栈中,从前往后处理整个 `s`,当遇到 `(` 则存入一个占位数值 `0`,遇到 `)` 取出栈顶元素 `cur`,根据栈顶元素数值值分情况讨论:
* 栈顶元素 $cur = 0$,即当前的 `)` 的前一元素即是 `(` ,根据 `()` 得一分的规则可知,我们本次操作得到的分值为 $1$;
* 栈顶元素 $cur \neq 0$,即当前 `)` 与其匹配的 `(` 中间相隔了其他字符,根据 `(A)` 的得分规则,此时可知得分为 $cur \times 2$;
将两者结合可统一为 $\max(cur \times 2, 1)$。
由于我们每次遇到 `)` 时,都将最近一次操作计算出来。而再前面无论是 `)` 还是 `(` 我们都可以归结到 `X()` 的相邻项累加规则,将其新得分累加到栈顶元素上,其中 `(` 仍采用累加规则,则利用我们将 `(` 定义为 $0$ 的设定。
Java 代码:
```Java
class Solution {
public int scoreOfParentheses(String s) {
Deque<Integer> d = new ArrayDeque<>();
d.addLast(0);
for (char c : s.toCharArray()) {
if (c == '(') d.addLast(0);
else {
int cur = d.pollLast();
d.addLast(d.pollLast() + Math.max(cur * 2 , 1));
}
}
return d.peekLast();
}
}
```
TypeScript 代码:
```TypeScript
function scoreOfParentheses(s: string): number {
const stk = new Array<number>()
stk.push(0)
for (const c of s) {
if (c == '(') stk.push(0)
else {
const cur = stk.pop()
stk.push(stk.pop() + Math.max(cur * 2, 1))
}
}
return stk.pop()
}
```
Python 代码:
```Python
class Solution:
def scoreOfParentheses(self, s: str) -> int:
stk = [0]
for c in s:
if c == '(':
stk.append(0)
else:
cur = stk.pop()
stk.append(stk.pop() + max(cur * 2, 1))
return stk[-1]
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.856` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/857. 雇佣 K 名工人的最低成本（困难）.md | 857. 雇佣 K 名工人的最低成本 | https://leetcode.cn/problems/minimum-cost-to-hire-k-workers/solution/by-ac_oier-u42f/ | 困难 | [
"枚举",
"优先队列(堆)"
] | 有 `n` 名工人。 给定两个数组 `quality` 和 `wage` ,其中,`quality[i]` 表示第 `i` 名工人的工作质量,其最低期望工资为 `wage[i]` 。
现在我们想雇佣 `k` 名工人组成一个工资组。在雇佣 一组 `k` 名工人时,我们必须按照下述规则向他们支付工资:
* 对工资组中的每名工人,应当按其工作质量与同组其他工人的工作质量的比例来支付工资。
* 工资组中的每名工人至少应当得到他们的最低期望工资。
给定整数 `k`,返回 组成满足上述条件的付费群体所需的最小金额 。在实际答案的 $10^{-5}$ 以内的答案将被接受。。
示例 1:
```
输入: quality = [10,20,5], wage = [70,50,30], k = 2
输出: 105.00000
解释: 我们向 0 号工人支付 70,向 2 号工人支付 35。
```
示例 2:
```
输入: quality = [3,1,10,10,1], wage = [4,8,2,2,7], k = 3
输出: 30.66667
解释: 我们向 0 号工人支付 4,向 2 号和 3 号分别支付 13.33333。
```
提示:
* $n = quality.length = wage.length$
* $1 <= k <= n <= 10^4$
* $1 <= quality[i], wage[i] <= 10^4$ | ### 枚举 + 优先队列(堆)
为了方便,我们令 `quality` 为 `qs`,`wage` 为 `ws`。
从 $n$ 个工人中选 $k$ 个,使这 $k$ 个工人实际工资与其 $qs[i]$ 成比例,且实际工资不低于 $ws[i]$。
根据条件一,假设实际工资与能力值比值为 $t$,则所选工人的实际工资为 $qs[i] \times t$,再结合条件二可知 $qs[i] \times t >= ws[i]$,变形可得 $t >= \frac{ws[i]}{qs[i]}$。
那么在选定若干工人的情况下,为使得总支出最小,我们可以取 $t$ 为所有被选工人中的最大 $\frac{ws[i]}{qs[i]}$ 即可。
**因此最终的 $t$ 值必然是取自某个工人的实际比值 $\frac{ws[i]}{qs[i]}$,这引导我们可以通过「枚举」哪个工人的实际比值为实际 $t$ 值来做。**
假设我们已经预处理出所有工人的 $\frac{ws[i]}{qs[i]}$ 比值信息,并「从小到大」进行枚举(该过程可看做是以比值信息作为维度来枚举每个工人):假设当前处理到的比值为最终使用到的 $t$,我们能够选的工人必然是在该工人的左边(根据上述分析可知,被选的工人满足 $\frac{ws[i]}{qs[i]} <= t$ 条件)。
因此,我们可以使用二维数组 `ds` 记录下每个工人的 $\frac{ws[i]}{qs[i]}$ 比值信息:$ds[i][0] = \frac{ws[i]}{qs[i]}$,$ds[i][1] = i$。并对其进行排升序,枚举每个工人的实际比值,同时动态维护枚举过程中的最小 $k$ 个 $qs[i]$(使用「大根堆」处理),并使用单变量 `tot` 记录当前堆中的 $qs[i]$ 总和,$tot \times \frac{ws[i]}{qs[i]}$ 即是以当前比值作为实际 $t$ 值时的总成本,在所有总成本中取最小值即是答案。
Java 代码:
```Java
class Solution {
public double mincostToHireWorkers(int[] qs, int[] ws, int k) {
int n = qs.length;
double[][] ds = new double[n][2];
for (int i = 0; i < n; i++) {
ds[i][0] = ws[i] * 1.0 / qs[i]; ds[i][1] = i * 1.0;
}
Arrays.sort(ds, (a,b)->Double.compare(a[0], b[0]));
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
double ans = 1e18;
for (int i = 0, tot = 0; i < n; i++) {
int cur = qs[(int)ds[i][1]];
tot += cur; q.add(cur);
if (q.size() > k) tot -= q.poll();
if (q.size() == k) ans = Math.min(ans, tot * ds[i][0]);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function mincostToHireWorkers(qs: number[], ws: number[], k: number): number {
const n = qs.length
const ds: number[][] = new Array<Array<number>>()
for (let i = 0; i < n; i++) ds.push([ws[i] / qs[i], i])
ds.sort((a,b)=>a[0]-b[0])
const q = new MaxPriorityQueue()
let ans = 1e18
for (let i = 0, tot = 0; i < n; i++) {
const cur = qs[ds[i][1]]
tot += cur
q.enqueue(cur)
if (q.size() > k) tot -= q.dequeue().element
if (q.size() == k) ans = Math.min(ans, tot * ds[i][0])
}
return ans
};
```
* 时间复杂度:构造系数并排序复杂度为 $O(n\log{n})$;枚举并计算答案复杂度为 $O(n\log{k})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.857` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/851-860/859. 亲密字符串（简单）.md | 859. 亲密字符串 | https://leetcode-cn.com/problems/buddy-strings/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-q056/ | 简单 | [
"模拟"
] | 给你两个字符串 `s` 和 `goal` ,只要我们可以通过交换 `s` 中的两个字母得到与 `goal` 相等的结果,就返回 `true` ;否则返回 `false` 。
交换字母的定义是:取两个下标 `i` 和 `j` (下标从 $0$ 开始)且满足 `i != j` ,接着交换 `s[i]` 和 `s[j]` 处的字符。
* 例如,在 `"abcd"` 中交换下标 `0` 和下标 `2` 的元素可以生成 `"cbad"` 。
示例 1:
```
输入:s = "ab", goal = "ba"
输出:true
解释:你可以交换 s[0] = 'a' 和 s[1] = 'b' 生成 "ba",此时 s 和 goal 相等。
```
示例 2:
```
输入:s = "ab", goal = "ab"
输出:false
解释:你只能交换 s[0] = 'a' 和 s[1] = 'b' 生成 "ba",此时 s 和 goal 不相等。
```
示例 3:
```
输入:s = "aa", goal = "aa"
输出:true
解释:你可以交换 s[0] = 'a' 和 s[1] = 'a' 生成 "aa",此时 s 和 goal 相等。
```
示例 4:
```
输入:s = "aaaaaaabc", goal = "aaaaaaacb"
输出:true
```
提示:
* $1 <= s.length, goal.length <= 2 * 10^4$
* `s` 和 `goal` 由小写英文字母组成 | ### 模拟
根据题意进行模拟即可,搞清楚什么情况下两者为「亲密字符」:
1. 当 $s$ 与 $goal$ 长度 或 词频不同,必然不为亲密字符;
2. 当「$s$ 与 $goal$ 不同的字符数量为 $2$(能够相互交换)」或「$s$ 与 $goal$ 不同的字符数量为 $0$,但同时 $s$ 中有出现数量超过 $2$ 的字符(能够相互交换)」时,两者必然为亲密字符。
代码:
```Java
class Solution {
public boolean buddyStrings(String s, String goal) {
int n = s.length(), m = goal.length();
if (n != m) return false;
int[] cnt1 = new int[26], cnt2 = new int[26];
int sum = 0;
for (int i = 0; i < n; i++) {
int a = s.charAt(i) - 'a', b = goal.charAt(i) - 'a';
cnt1[a]++; cnt2[b]++;
if (a != b) sum++;
}
boolean ok = false;
for (int i = 0; i < 26; i++) {
if (cnt1[i] != cnt2[i]) return false;
if (cnt1[i] > 1) ok = true;
}
return sum == 2 || (sum == 0 && ok);
}
}
```
* 时间复杂度:令 $n$ 为两字符串之间的最大长度,$C$ 为字符集大小,$C$ 固定为 $26$,复杂度为 $O(n + C)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.859` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/862. 和至少为 K 的最短子数组（困难）.md | 862. 和至少为 K 的最短子数组 | https://leetcode.cn/problems/shortest-subarray-with-sum-at-least-k/solution/by-ac_oier-es0s/ | 困难 | [
"前缀和",
"离散化",
"二分",
"树状数组"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,找出 `nums` 中和至少为 `k` 的 最短非空子数组 ,并返回该子数组的长度。如果不存在这样的子数组,返回 `-1` 。
子数组是数组中连续 的一部分。
示例 1:
```
输入:nums = [1], k = 1
输出:1
```
示例 2:
```
输入:nums = [1,2], k = 4
输出:-1
```
示例 3:
```
输入:nums = [2,-1,2], k = 3
输出:3
```
提示:
* $1 <= nums.length <= 10^5$
* $-10^5 <= nums[i] <= 10^5$
* $1 <= k <= 10^9$ | ### 前缀和 + 离散化 + 权值树状数组
由于求解的对象是子数组,容易联想到求连续段之和,容易联想到「前缀和」,假设我们预处理出的前缀和数组为 $sum$(为了方便,我们令前缀和数组坐标从 $1$ 开始)。
即每个 $nums[i]$ 而言,本质上是找满足「$sum[i] - sum[j] \geqslant k$」条件的最大下标 $j$,其中 $j$ 的取值范围为 $[0, i - 1]$,从而知道以 $i$ 作为右端点时,满足条件的最短子数组长度为 $i - j$。
先考虑存在负数域的问题,由于我们需要使用 $sum[X]$,以及对应的 $sum[X] + k$,同时 $k$ 的取值为 $1e9$(过大),我们可以通过「离散化」手段将其映射到 $2$ 倍的数组长度,即大小为 $2 \times 10^5$ 的正数域。
随后来考虑如何求解「满足条件的最大下标」问题,可以通过「权值树状数组」来做:对于每个 $sum[i]$ 而言,我们利用「权值树状数组」来维护满足大于等于 $sum[i] + k$ 的最大下标。起始我们先初始化树状数组为 $-1$,遍历过程中,查询是否存在满足条件的下标(若不为 `-1` 则更新 `ans`),并更新权值树状数组对应的最大下标即可。
Java 代码:
```Java
class Solution {
static int N = 200010;
static int[] tr = new int[N], sum = new int[N];
int n, m, ans;
int lowbit(int x) {
return x & -x;
}
void update(int val, int loc) {
for (int i = val; i < m; i += lowbit(i)) tr[i] = Math.max(tr[i], loc);
}
int query(int x) {
int ans = -1;
for (int i = x; i > 0; i -= lowbit(i)) ans = Math.max(ans, tr[i]);
return ans;
}
int getIdx(List<Long> list, long x) {
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r >> 1;
if (list.get(mid) >= x) r = mid;
else l = mid + 1;
}
return r + 1;
}
public int shortestSubarray(int[] nums, int k) {
n = nums.length; m = 2 * n + 10; ans = n + 10;
Arrays.fill(tr, -1);
long[] temp = new long[m];
List<Long> list = new ArrayList<>();
list.add(0L);
for (int i = 1; i <= 2 * n + 1; i++) {
if (i <= n) temp[i] = temp[i - 1] + nums[i - 1];
else temp[i] = temp[i - (n + 1)] + k;
list.add(temp[i]);
}
Collections.sort(list);
for (int i = 0; i <= 2 * n + 1; i++) sum[i] = getIdx(list, temp[i]);
update(sum[n + 1], 0);
for (int i = 1; i <= n; i++) {
int j = query(sum[i]);
if (j != -1) ans = Math.min(ans, i - j);
update(sum[n + 1 + i], i);
}
return ans == n + 10 ? -1 : ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
static const int N = 200010;
vector<int> tr, sum;
int n, m, ans;
int lowbit(int x) {
return x & -x;
}
void update(int val, int loc) {
for (int i = val; i < m; i += lowbit(i)) tr[i] = max(tr[i], loc);
}
int query(int x) {
int ans = -1;
for (int i = x; i > 0; i -= lowbit(i)) ans = max(ans, tr[i]);
return ans;
}
int shortestSubarray(vector<int>& nums, int k) {
n = nums.size(); m = 2 * n + 10; ans = n + 10;
tr.resize(m, -1); sum.resize(m + 10, 0);
vector<long long> temp(m);
vector<long long> list;
for (int i = 1; i <= 2 * n + 1; i++) {
if (i <= n) temp[i] = temp[i - 1] + nums[i - 1];
else temp[i] = temp[i - (n + 1)] + k;
list.push_back(temp[i]);
}
sort(list.begin(), list.end());
for (int i = 0; i <= 2 * n + 1; i++) {
sum[i] = lower_bound(list.begin(), list.end(), temp[i]) - list.begin() + 1;
}
update(sum[n + 1], 0);
for (int i = 1; i <= n; i++) {
int j = query(sum[i]);
if (j != -1) ans = min(ans, i - j);
update(sum[n + 1 + i], i);
}
return ans == n + 10 ? -1 : ans;
}
};
```
* 时间复杂度:预处理前缀和的的复杂度为 $O(n)$,排序并进行离散化的复杂度为 $O(n\log{n})$;构造答案的复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.862` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/863. 二叉树中所有距离为 K 的结点（中等）.md | 863. 二叉树中所有距离为 K 的结点 | https://leetcode-cn.com/problems/all-nodes-distance-k-in-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-x6hak/ | 中等 | [
"图论 BFS",
"图论 DFS",
"二叉树"
] | 给定一个二叉树(具有根结点 root), 一个目标结点 target ,和一个整数值 K 。
返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。
示例 1:
```
输入:root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, K = 2
输出:[7,4,1]
解释:
所求结点为与目标结点(值为 5)距离为 2 的结点,
值分别为 7,4,以及 1
```
注意,输入的 "root" 和 "target" 实际上是树上的结点。
上面的输入仅仅是对这些对象进行了序列化描述。
提示:
* 给定的树是非空的。
* 树上的每个结点都具有唯一的值 0 <= node.val <= 500 。
* 目标结点 target 是树上的结点。
* 0 <= K <= 1000. | ### 基本分析
显然,如果题目是以图的形式给出的话,我们可以很容易通过「`BFS` / 迭代加深」找到距离为 $k$ 的节点集。
而树是一类特殊的图,我们可以通过将二叉树转换为图的形式,再进行「`BFS` / 迭代加深」。
由于二叉树每个点最多有 $2$ 个子节点,点和边的数量接近,属于稀疏图,因此我们可以使用「邻接表」的形式进行存储。
建图方式为:对于二叉树中相互连通的节点(`root` 与 `root.left`、`root` 和 `root.right`),建立一条无向边。
建图需要遍历整棵树,使用 `DFS` 或者 `BFS` 均可。
由于所有边的权重均为 $1$,我们可以使用 「`BFS` / 迭代加深」 找到从目标节点 `target` 出发,与目标节点距离为 $k$ 的节点,然后将其添加到答案中。
>一些细节:利用每个节点具有唯一的值,我们可以直接使用节点值进行建图和搜索。
---
### 建图 + `BFS`
由「基本分析」,可写出「建图 + `BFS`」的实现。
代码:
```Java
class Solution {
int N = 1010, M = N * 2;
int[] he = new int[N], e = new int[M], ne = new int[M];
int idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
boolean[] vis = new boolean[N];
public List<Integer> distanceK(TreeNode root, TreeNode t, int k) {
List<Integer> ans = new ArrayList<>();
Arrays.fill(he, -1);
dfs(root);
Deque<Integer> d = new ArrayDeque<>();
d.addLast(t.val);
vis[t.val] = true;
while (!d.isEmpty() && k >= 0) {
int size = d.size();
while (size-- > 0) {
int poll = d.pollFirst();
if (k == 0) {
ans.add(poll);
continue;
}
for (int i = he[poll]; i != -1 ; i = ne[i]) {
int j = e[i];
if (!vis[j]) {
d.addLast(j);
vis[j] = true;
}
}
}
k--;
}
return ans;
}
void dfs(TreeNode root) {
if (root == null) return;
if (root.left != null) {
add(root.val, root.left.val);
add(root.left.val, root.val);
dfs(root.left);
}
if (root.right != null) {
add(root.val, root.right.val);
add(root.right.val, root.val);
dfs(root.right);
}
}
}
```
* 时间复杂度:通过 `DFS` 进行建图的复杂度为 $O(n)$;通过 `BFS` 找到距离 $target$ 为 $k$ 的节点,复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 建图 + 迭代加深
由「基本分析」,可写出「建图 + 迭代加深」的实现。
迭代加深的形式,我们只需要结合题意,搜索深度为 $k$ 的这一层即可。
代码:
```Java
class Solution {
int N = 1010, M = N * 2;
int[] he = new int[N], e = new int[M], ne = new int[M];
int idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
boolean[] vis = new boolean[N];
public List<Integer> distanceK(TreeNode root, TreeNode t, int k) {
List<Integer> ans = new ArrayList<>();
Arrays.fill(he, -1);
dfs(root);
vis[t.val] = true;
find(t.val, k, 0, ans);
return ans;
}
void find(int root, int max, int cur, List<Integer> ans) {
if (cur == max) {
ans.add(root);
return ;
}
for (int i = he[root]; i != -1; i = ne[i]) {
int j = e[i];
if (!vis[j]) {
vis[j] = true;
find(j, max, cur + 1, ans);
}
}
}
void dfs(TreeNode root) {
if (root == null) return;
if (root.left != null) {
add(root.val, root.left.val);
add(root.left.val, root.val);
dfs(root.left);
}
if (root.right != null) {
add(root.val, root.right.val);
add(root.right.val, root.val);
dfs(root.right);
}
}
}
```
* 时间复杂度:通过 `DFS` 进行建图的复杂度为 $O(n)$;通过迭代加深找到距离 $target$ 为 $k$ 的节点,复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.863` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/864. 获取所有钥匙的最短路径（困难）.md | 864. 获取所有钥匙的最短路径 | https://leetcode.cn/problems/shortest-path-to-get-all-keys/solution/by-ac_oier-5gxc/ | 困难 | [
"BFS",
"状态压缩"
] | 给定一个二维网格 `g`,其中:
* `'.'` 代表一个空房间
* `'#'` 代表一堵墙
* `'@'` 是起点
* 小写字母代表钥匙
* 大写字母代表锁
我们从起点开始出发,一次移动是指向四个基本方向之一行走一个单位空间。
我们不能在网格外面行走,也无法穿过一堵墙。
如果途经一个钥匙,我们就把它捡起来,除非我们手里有对应的钥匙,否则无法通过锁。
假设 `k` 为 钥匙/锁 的个数,且满足 $1 <= k <= 6$,字母表中的前 `k` 个字母在网格中都有自己对应的一个小写和一个大写字母。
换言之,每个锁有唯一对应的钥匙,每个钥匙也有唯一对应的锁。另外,代表钥匙和锁的字母互为大小写并按字母顺序排列。
返回获取所有钥匙所需要的移动的最少次数。
如果无法获取所有钥匙,返回 `-1` 。
示例 1:
```
输入:g = ["@.a.#","###.#","b.A.B"]
输出:8
解释:目标是获得所有钥匙,而不是打开所有锁。
```
示例 2:
```
输入:g = ["@..aA","..B#.","....b"]
输出:6
```
示例 3:
```
输入: g = ["@Aa"]
输出: -1
```
提示:
* $m = g.length$
* $n = g[i].length$
* $1 <= m, n <= 30$
* `g[i][j]` 只含有 `'.'`,`'#'`, `'@'`, `'a'-'f'` 以及 `'A'-'F'`
* 钥匙的数目范围是 $[1, 6]$
* 每个钥匙都对应一个不同的字母
* 每个钥匙正好打开一个对应的锁 | ### BFS + 状态压缩
**一道常规的 `BFS` 运用题,只不过需要在 `BFS` 过程中记录收集到的钥匙状态。**
利用「钥匙数量不超过 $6$,并按字母顺序排列」,我们可以使用一个 `int` 类型二进制数 `state` 来代指当前收集到钥匙情况:
* 若 `state` 的二进制中的第 $k$ 位为 `1`,代表当前种类编号为 $k$ 的钥匙 **已被收集**,后续移动若遇到对应的锁则 **能通过**
* 若 `state` 的二进制中的第 $k$ 位为 `0`,代表当前种类编号为 $k$ 的钥匙 **未被收集**,后续移动若遇到对应的锁则 **无法通过**
其中「钥匙种类编号」则按照小写字母先后顺序,从 $0$ 开始进行划分对应:即字符为 `a` 的钥匙编号为 `0`,字符为 `b` 的钥匙编号为 `1`,字符为 `c` 的钥匙编号为 `2` ...
当使用了这样的「状态压缩」技巧后,我们可以很方便通过「位运算」进行 **钥匙检测** 和 **更新钥匙收集状态**:
* 钥匙检测:`(state >> k) & 1`,若返回 `1` 说明第 $k$ 位为 `1`,当前持有种类编号为 `k` 的钥匙
* 更新钥匙收集状态:`state |= 1 << k`,将 `state` 的第 $k$ 位设置为 `1`,代表当前新收集到种类编号为 `k` 的钥匙
搞明白如何记录当前收集到的钥匙状态后,剩下的则是常规 `BFS` 过程:
1. 起始遍历一次棋盘,找到起点位置,并将其进行入队,队列维护的是 $(x, y, state)$ 三元组状态(其中 $(x, y)$ 代表当前所在的棋盘位置,$state$ 代表当前的钥匙收集情况)
同时统计整个棋盘所包含的钥匙数量 `cnt`,并使用 数组/哈希表 记录到达每个状态所需要消耗的最小步数 `step`
2. 进行四联通方向的 `BFS`,转移过程中需要注意「遇到锁时,必须有对应钥匙才能通过」&「遇到钥匙时,需要更新对应的 `state` 再进行入队」
3. 当 `BFS` 过程中遇到 `state = (1 << cnt) - 1` 时,代表所有钥匙均被收集完成,可结束搜索
Java 代码:
```Java
class Solution {
static int N = 35, K = 10, INF = 0x3f3f3f3f;
static int[][][] dist = new int[N][N][1 << K];
static int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
public int shortestPathAllKeys(String[] g) {
int n = g.length, m = g[0].length(), cnt = 0;
Deque<int[]> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
Arrays.fill(dist[i][j], INF);
char c = g[i].charAt(j);
if (c == '@') {
d.addLast(new int[]{i, j, 0});
dist[i][j][0] = 0;
} else if (c >= 'a' && c <= 'z') cnt++;
}
}
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int x = info[0], y = info[1], cur = info[2], step = dist[x][y][cur];
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
char c = g[nx].charAt(ny);
if (c == '#') continue;
if ((c >= 'A' && c <= 'Z') && (cur >> (c - 'A') & 1) == 0) continue;
int ncur = cur;
if (c >= 'a' && c <= 'z') ncur |= 1 << (c - 'a');
if (ncur == (1 << cnt) - 1) return step + 1;
if (step + 1 >= dist[nx][ny][ncur]) continue;
dist[nx][ny][ncur] = step + 1;
d.addLast(new int[]{nx, ny, ncur});
}
}
return -1;
}
}
```
C++ 代码:
```C++
class Solution {
int N = 35, K = 10, INF = 0x3f3f3f3f;
vector<vector<vector<int>>> dist = vector<vector<vector<int>>>(N, vector<vector<int>>(N, vector<int>(1<<K, INF)));
vector<vector<int>> dirs = {{1,0}, {-1,0}, {0,1}, {0,-1}};
public:
int shortestPathAllKeys(vector<string>& g) {
int n = g.size(), m = g[0].size(), cnt = 0;
queue<vector<int>> d;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fill(dist[i][j].begin(), dist[i][j].end(), INF);
char c = g[i][j];
if (c == '@') {
d.push({i, j, 0});
dist[i][j][0] = 0;
} else if (c >= 'a' && c <= 'z') cnt++;
}
}
while (!d.empty()) {
vector<int> info = d.front();
d.pop();
int x = info[0], y = info[1], cur = info[2], step = dist[x][y][cur];
for (vector<int> di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
char c = g[nx][ny];
if (c == '#') continue;
if ((c >= 'A' && c <= 'Z') && (cur >> (c - 'A') & 1) == 0) continue;
int ncur = cur;
if (c >= 'a' && c <= 'z') ncur |= 1 << (c - 'a');
if (ncur == (1 << cnt) - 1) return step + 1;
if (step + 1 >= dist[nx][ny][ncur]) continue;
dist[nx][ny][ncur] = step + 1;
d.push({nx, ny, ncur});
}
}
return -1;
}
};
```
Python3 代码:
```Python
class Solution:
def shortestPathAllKeys(self, g: List[str]) -> int:
dirs = [[0,1], [0,-1], [1,0], [-1,0]]
n, m, cnt = len(g), len(g[0]), 0
dist = defaultdict(lambda : 0x3f3f3f3f)
for i in range(n):
for j in range(m):
c = g[i][j]
if c == '@':
d = deque([(i, j, 0)])
dist[(i, j, 0)] = 0
elif 'a' <= c <= 'z':
cnt += 1
while d:
x, y, cur = d.popleft()
step = dist[(x, y, cur)]
for di in dirs:
nx, ny = x + di[0], y + di[1]
if nx < 0 or nx >= n or ny < 0 or ny >= m:
continue
c = g[nx][ny]
if c == '#':
continue
if 'A' <= c <= 'Z' and (cur >> (ord(c) - ord('A')) & 1) == 0:
continue
ncur = cur
if 'a' <= c <= 'z':
ncur |= (1 << (ord(c) - ord('a')))
if ncur == (1 << cnt) - 1:
return step + 1
if step + 1 >= dist[(nx, ny, ncur)]:
continue
dist[(nx, ny, ncur)] = step + 1
d.append((nx, ny, ncur))
return -1
```
TypeScript 代码:
```TypeScript
function shortestPathAllKeys(g: string[]): number {
const dirs = [[1,0],[-1,0],[0,1],[0,-1]]
let n = g.length, m = g[0].length, cnt = 0
const dist = new Array<Array<Array<number>>>()
for (let i = 0; i < n; i++) {
dist[i] = new Array<Array<number>>(m)
for (let j = 0; j < m; j++) {
dist[i][j] = new Array<number>(1 << 10).fill(0x3f3f3f3f)
}
}
const d = []
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (g[i][j] == '@') {
d.push([i, j, 0]); dist[i][j][0] = 0
} else if (g[i][j] >= 'a' && g[i][j] <= 'z') cnt++
}
}
while (d.length > 0) {
const info = d.shift()
const x = info[0], y = info[1], cur = info[2], step = dist[x][y][cur]
for (const di of dirs) {
const nx = x + di[0], ny = y + di[1]
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue
const c = g[nx][ny]
if (c == '#') continue
if ('A' <= c && c <= 'Z' && ((cur >> (c.charCodeAt(0) - 'A'.charCodeAt(0)) & 1) == 0)) continue
let ncur = cur
if ('a' <= c && c <= 'z') ncur |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0))
if (ncur == (1 << cnt) - 1) return step + 1
if (step + 1 >= dist[nx][ny][ncur]) continue
d.push([nx, ny, ncur])
dist[nx][ny][ncur] = step + 1
}
}
return -1
}
```
* 时间复杂度:$O(n \times m \times 2^k)$
* 空间复杂度:$O(n \times m \times 2^k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.864` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/867. 转置矩阵（简单）.md | 867. 转置矩阵 | https://leetcode-cn.com/problems/transpose-matrix/solution/yi-you-wei-jin-huo-xu-ni-neng-kan-kan-zh-m53m/ | 简单 | [
"模拟"
] | 给你一个二维整数数组 matrix, 返回 matrix 的 转置矩阵 。
矩阵的 转置 是指将矩阵的主对角线翻转,交换矩阵的行索引与列索引。
示例 1:
```
输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出:[[1,4,7],[2,5,8],[3,6,9]]
```
示例 2:
```
输入:matrix = [[1,2,3],[4,5,6]]
输出:[[1,4],[2,5],[3,6]]
```
提示:
* m == matrix.length
* n == matrix[i].length
* 1 <= m, n <= 1000
* 1 <= m * n <= $10^5$
* -$10^9$ <= matrix[i][j] <= $10^9$ | ### 模拟
对角线翻转,只需要从头模拟一遍即可。
```java
class Solution {
public int[][] transpose(int[][] matrix) {
int n = matrix.length, m = matrix[0].length;
int[][] ans = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
ans[i][j] = matrix[j][i];
}
}
return ans;
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:使用同等空间保存答案。复杂度为 $O(n * m)$
***
### 矩阵类题目
题目过于简单,让人怀疑 LeetCode 团队是不是还在放假。
我在 LeetCode 上挑了几道难度适中,与矩阵变换相关的题目,如果大家感觉今天的「每日一题」不够尽兴的话,可以试着做一下:
[566. 重塑矩阵(简单)](https://leetcode-cn.com/problems/reshape-the-matrix/)
[54. 螺旋矩阵(中等)](https://leetcode-cn.com/problems/spiral-matrix/)
[59. 螺旋矩阵 II(中等)](https://leetcode-cn.com/problems/spiral-matrix-ii/)
***
#### 关于复杂度的说明
无论是时间还是空间都是用作描述算法运行所需要的资源消耗
我是将「算法本身占用的内存」和「输入数据」以外的内存作为“额外”内存,所以是 $O(n * m)$
官方的我看了一下,如果说明了忽略输出数据的内存占用的话,说成 $O(1)$ 也是可以的
就像我们使用递归求解问题的时候,栈帧本身也会带来内存消耗。因此进行复杂度分析的时候,出于严谨应该是要说明忽略递归带来的空间消耗 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.867` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/868. 二进制间距（简单）.md | 868. 二进制间距 | https://leetcode-cn.com/problems/binary-gap/solution/by-ac_oier-2sui/ | 简单 | [
"模拟"
] | 给定一个正整数 $n$,找到并返回 $n$ 的二进制表示中两个 相邻 $1$ 之间的 最长距离 。如果不存在两个相邻的 $1$,返回 $0$ 。
如果只有 $0$ 将两个 $1$ 分隔开(可能不存在 $0$ ),则认为这两个 $1$ 彼此 相邻 。两个 $1$ 之间的距离是它们的二进制表示中位置的绝对差。例如,`"1001"` 中的两个 $1$ 的距离为 $3$ 。
示例 1:
```
输入:n = 22
输出:2
解释:22 的二进制是 "10110" 。
在 22 的二进制表示中,有三个 1,组成两对相邻的 1 。
第一对相邻的 1 中,两个 1 之间的距离为 2 。
第二对相邻的 1 中,两个 1 之间的距离为 1 。
答案取两个距离之中最大的,也就是 2 。
```
示例 2:
```
输入:n = 8
输出:0
解释:8 的二进制是 "1000" 。
在 8 的二进制表示中没有相邻的两个 1,所以返回 0 。
```
示例 3:
```
输入:n = 5
输出:2
解释:5 的二进制是 "101" 。
```
提示:
* $1 <= n <= 10^9$ | ### 模拟
根据题意进行模拟即可,遍历 $n$ 的二进制中的每一位 $i$,同时记录上一位 $1$ 的位置 $j$,即可得到所有相邻 $1$ 的间距,所有间距取 $\max$ 即是答案。
代码:
```Java
class Solution {
public int binaryGap(int n) {
int ans = 0;
for (int i = 31, j = -1; i >= 0; i--) {
if (((n >> i) & 1) == 1) {
if (j != -1) ans = Math.max(ans, j - i);
j = i;
}
}
return ans;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.868` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/869. 重新排序得到 2 的幂（中等）.md | 869. 重新排序得到 2 的幂 | https://leetcode-cn.com/problems/reordered-power-of-2/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-c-3s1e/ | 中等 | [
"DFS",
"哈希表"
] | 给定正整数 `N` ,我们按任何顺序(包括原始顺序)将数字重新排序,注意其前导数字不能为零。
如果我们可以通过上述方式得到 $2$ 的幂,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:1
输出:true
```
示例 2:
```
输入:10
输出:false
```
示例 3:
```
输入:16
输出:true
```
示例 4:
```
输入:24
输出:false
```
示例 5:
```
输入:46
输出:true
```
提示:
$1 <= N <= 10^9$ | ### 打表 + DFS
一个朴素的做法是对 $n$ 进行重排,然后检查重排后的数值是否属于 $2$ 的幂。
由于 $2$ 的幂数固定,我们可以先通过「打表」将范围落在 $[1, 1e9]$ 以内的 $2$ 的幂预处理出来,这样我们可以在 $O(1)$ 的复杂度内判断某个数是否为 $2$ 的幂。
重排的过程则是 `DFS` 实现。
代码:
```Java
class Solution {
static Set<Integer> set = new HashSet<>();
static {
for (int i = 1; i < (int)1e9+10; i *= 2) set.add(i);
}
int m;
int[] cnts = new int[10];
public boolean reorderedPowerOf2(int n) {
while (n != 0) {
cnts[n % 10]++;
n /= 10;
m++;
}
return dfs(0, 0);
}
boolean dfs(int u, int cur) {
if (u == m) return set.contains(cur);
for (int i = 0; i < 10; i++) {
if (cnts[i] != 0) {
cnts[i]--;
if ((i != 0 || cur != 0) && dfs(u + 1, cur * 10 + i)) return true;
cnts[i]++;
}
}
return false;
}
}
```
* 时间复杂度:打表预处理所有 $2$ 的幂放到本地运行为 $O(1)$,放到 $OJ$ 运行则是 $O(C)$,$C$ 为常数,约为 $30$。处理处 $cnts$ 数组的复杂度为 $O(\log{n})$;重排的复杂度为 $O((\log{n})!)$,判断是否为 $2$ 的幂的复杂度为 $O(1)$。整体复杂度为 $O((\log{n})!)$。
* 空间复杂度:$O(C)$,其中 $C$ 为常数,约为 $40$。
---
### 打表 + 词频统计
解法一,我们发现复杂度上界取决于对 $n$ 的重排,同时数据范围内的 $2$ 的幂数量很少。
因此有效降低复杂度(避免重排)的做法是,直接枚举所有的 $2$ 的幂 $x$,检查 $x$ 的词频是否与 $n$ 相同。
代码:
```Java
class Solution {
static Set<Integer> set = new HashSet<>();
static {
for (int i = 1; i < (int)1e9+10; i *= 2) set.add(i);
}
public boolean reorderedPowerOf2(int n) {
int[] cnts = new int[10];
while (n != 0) {
cnts[n % 10]++;
n /= 10;
}
int[] cur = new int[10];
out:for (int x : set) {
Arrays.fill(cur, 0);
while (x != 0) {
cur[x % 10]++;
x /= 10;
}
for (int i = 0; i < 10; i++) {
if (cur[i] != cnts[i]) continue out;
}
return true;
}
return false;
}
}
```
* 时间复杂度:打表预处理所有 $2$ 的幂放到本地运行为 $O(1)$,放到 $OJ$ 运行则是 $O(C)$,$C$ 为常数,约为 $30$。检查所有 $2$ 的幂的词频是否与 $n$ 词频相同复杂度为 $O(C * \log{n})$。整体复杂度为 $O(C * \log{n})$。
* 空间复杂度:$O(C)$,其中 $C$ 为常数,约为 $40$。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.869` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/861-870/870. 优势洗牌（中等）.md | 870. 优势洗牌 | https://leetcode.cn/problems/advantage-shuffle/solution/by-ac_oier-i01s/ | 中等 | [
"红黑树",
"哈希表",
"排序",
"双指针",
"贪心"
] | 给定两个大小相等的数组 `nums1` 和 `nums2`,`nums1` 相对于 `nums` 的优势可以用满足 `nums1[i] > nums2[i]` 的索引 `i` 的数目来描述。
返回 `nums1` 的任意排列,使其相对于 `nums2` 的优势最大化。
示例 1:
```
输入:nums1 = [2,7,11,15], nums2 = [1,10,4,11]
输出:[2,11,7,15]
```
示例 2:
```
输入:nums1 = [12,24,8,32], nums2 = [13,25,32,11]
输出:[24,32,8,12]
```
提示:
* $1 <= nums1.length <= 10^5$
* $nums2.length = nums1.length$
* $0 <= nums1[i], nums2[i] <= 10^9$ | ### 数据结构
显然,对于任意一个 $t = nums2[i]$ 而言,我们应当在候选集合中选择**比其大的最小数**,若不存在这样的数字,则选择候选集合中的**最小值**。
同时,由于 $nums1$ 相同数会存在多个,我们还要对某个具体数字的可用次数进行记录。
也就是我们总共涉及两类操作:
1. 实时维护一个候选集合,该集合支持高效查询比某个数大的数值操作;
2. 对候选集合中每个数值的可使用次数进行记录,当使用到了候选集合中的某个数后,要对其进行计数减一操作,若计数为 $0$,则将该数值从候选集合中移除。
计数操作容易想到哈希表,而实时维护候选集合并高效查询可以使用基于红黑树的 `TreeSet` 数据结构。
Java 代码:
```Java
class Solution {
public int[] advantageCount(int[] nums1, int[] nums2) {
int n = nums1.length;
TreeSet<Integer> tset = new TreeSet<>();
Map<Integer, Integer> map = new HashMap<>();
for (int x : nums1) {
map.put(x, map.getOrDefault(x, 0) + 1);
if (map.get(x) == 1) tset.add(x);
}
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
Integer cur = tset.ceiling(nums2[i] + 1);
if (cur == null) cur = tset.ceiling(-1);
ans[i] = cur;
map.put(cur, map.get(cur) - 1);
if (map.get(cur) == 0) tset.remove(cur);
}
return ans;
}
}
```
Python 代码:
```Python
from sortedcontainers import SortedList
class Solution:
def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]:
n = len(nums1)
cnts, tset = defaultdict(int), SortedList()
for i in range(n):
cnts[nums1[i]] += 1
if cnts[nums1[i]] == 1:
tset.add(nums1[i])
ans = [0] * n
for i in range(n):
t = nums2[i]
if (idx := tset.bisect_left(t + 1)) == len(tset):
idx = tset.bisect_left(-1)
ans[i] = tset[idx]
cnts[ans[i]] -= 1
if cnts[ans[i]] == 0:
tset.remove(ans[i])
return ans
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 排序 + 双指针
在解法一中,我们是从每个 $nums2[i]$ 出发考虑,使用哪个 $nums1[i]$ 去匹配最为合适。
实际上,我们也能从 $nums1[i]$ 出发,考虑将其与哪个 $nums2[i]$ 进行匹配。
为了让每个决策回合具有独立性,我们需要对两数组进行排序,同时为了在构造答案时,能够对应回 `nums2` 的原下标,排序前我们需要使用「哈希表」记录每个 $nums2[i]$ 的下标为何值。
使用变量 `l1` 代表当前决策将 $nums1[l1]$ 分配到哪个 `nums2` 的位置,使用 `l2` 和 `r2` 代表当前 `nums2` 中还有 $[l2, r2]$ 位置还待填充。
可以证明我们在从前往后给每个 $nums1[l1]$ 分配具体位置时,分配的位置只会在 `l2` 和 `r2` 两者之间产生。
Java 代码:
```Java
class Solution {
public int[] advantageCount(int[] nums1, int[] nums2) {
int n = nums1.length;
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < n; i++) {
List<Integer> list = map.getOrDefault(nums2[i], new ArrayList<>());
list.add(i);
map.put(nums2[i], list);
}
Arrays.sort(nums1); Arrays.sort(nums2);
int[] ans = new int[n];
for (int l1 = 0, l2 = 0, r2 = n - 1; l1 < n; l1++) {
int t = nums1[l1] > nums2[l2] ? l2 : r2;
List<Integer> list = map.get(nums2[t]);
int idx = list.remove(list.size() - 1);
ans[idx] = nums1[l1];
if (t == l2) l2++;
else r2--;
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]:
n = len(nums1)
mapping = defaultdict(list)
for i in range(n):
mapping[nums2[i]].append(i)
nums1.sort()
nums2.sort()
ans = [0] * n
l2, r2 = 0, n - 1
for l1 in range(n):
t = l2 if nums1[l1] > nums2[l2] else r2
ans[mapping[nums2[t]].pop()] = nums1[l1]
if t == l2:
l2 += 1
else:
r2 -= 1
return ans
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 加餐
**加餐一道同类型题目 : [难度 2.5/5,敲醒沉睡心灵的数据结构运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493710&idx=1&sn=2d6d4ee9f4b1ff1ea766ddf7ea57bf55) 🎉🎉** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.870` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/871. 最低加油次数（困难）.md | 871. 最低加油次数 | https://leetcode.cn/problems/minimum-number-of-refueling-stops/solution/by-ac_oier-q2mk/ | 困难 | [
"贪心",
"优先队列(堆)",
"模拟"
] | 汽车从起点出发驶向目的地,该目的地位于出发位置东面 `target` 英里处。
沿途有加油站,每个 `station[i]` 代表一个加油站,它位于出发位置东面 `station[i][0]` 英里处,并且有 `station[i][1]` 升汽油。
假设汽车油箱的容量是无限的,其中最初有 `startFuel` 升燃料。它每行驶 $1$ 英里就会用掉 $1$ 升汽油。
当汽车到达加油站时,它可能停下来加油,将所有汽油从加油站转移到汽车中。
为了到达目的地,汽车所必要的最低加油次数是多少?如果无法到达目的地,则返回 $-1$ 。
注意:如果汽车到达加油站时剩余燃料为 $0$,它仍然可以在那里加油。如果汽车到达目的地时剩余燃料为 $0$,仍然认为它已经到达目的地。
示例 1:
```
输入:target = 1, startFuel = 1, stations = []
输出:0
解释:我们可以在不加油的情况下到达目的地。
```
示例 2:
```
输入:target = 100, startFuel = 1, stations = [[10,100]]
输出:-1
解释:我们无法抵达目的地,甚至无法到达第一个加油站。
```
示例 3:
```
输入:target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]
输出:2
解释:
我们出发时有 10 升燃料。
我们开车来到距起点 10 英里处的加油站,消耗 10 升燃料。将汽油从 0 升加到 60 升。
然后,我们从 10 英里处的加油站开到 60 英里处的加油站(消耗 50 升燃料),
并将汽油从 10 升加到 50 升。然后我们开车抵达目的地。
我们沿途在1两个加油站停靠,所以返回 2 。
```
提示:
* $1 <= target, startFuel, stations[i][1] <= 10^9$
* $0 <= stations.length <= 500$
* $1 <= position_{i} < position_{i+1} < target$
* $1 <= fuel_{i} < 10^9$ | ### 贪心 + 优先队列(堆)
我们可以模拟行进过程,使用 `n` 代表加油站总个数,`idx` 代表经过的加油站下标,使用 `remain` 代表当前有多少油(起始有 `remain = startFuel`),`loc` 代表走了多远,`ans` 代表答案(至少需要的加油次数)。
只要 `loc < target`,代表还没到达(经过)目标位置,我们可以继续模拟行进过程。
每次将 `remain` 累加到 `loc` 中,含义为使用完剩余的油量,可以去到的最远距离,同时将所在位置 `stations[idx][0] <= loc` 的加油站数量加入优先队列(大根堆,根据油量排倒序)中。
再次检查是否满足 `loc < target`(下次循环),此时由于清空了剩余油量 `remain`,我们尝试从优先队列(大根堆)中取出过往油量最大的加油站并进行加油(同时对加油次数 `ans` 进行加一操作)。
使用新的剩余油量 `remain` 重复上述过程,直到满足 `loc >= target` 或无油可加。
容易证明该做法的正确性:同样是消耗一次加油次数,始终选择油量最大的加油站进行加油,可以确保不存在更优的结果。
Java 代码:
```Java
class Solution {
public int minRefuelStops(int target, int startFuel, int[][] stations) {
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
int n = stations.length, idx = 0;
int remain = startFuel, loc = 0, ans = 0;
while (loc < target) {
if (remain == 0) {
if (!q.isEmpty() && ++ans >= 0) remain += q.poll();
else return -1;
}
loc += remain; remain = 0;
while (idx < n && stations[idx][0] <= loc) q.add(stations[idx++][1]);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minRefuelStops(int target, int startFuel, vector<vector<int>>& stations) {
priority_queue<int> q;
int n = stations.size(), idx = 0;
int remain = startFuel, loc = 0, ans = 0;
while (loc < target) {
if (remain == 0) {
if (!q.empty() && ++ans >= 0) {
remain += q.top();
q.pop();
} else {
return -1;
}
}
loc += remain; remain = 0;
while (idx < n && stations[idx][0] <= loc) q.push(stations[idx++][1]);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def minRefuelStops(self, target: int, startFuel: int, stations: List[List[int]]) -> int:
q = []
n, idx = len(stations), 0
remain, loc, ans = startFuel, 0, 0
while loc < target:
if remain == 0:
if q:
ans += 1
remain += -heappop(q)
else:
return -1
loc, remain = loc + remain, 0
while idx < n and stations[idx][0] <= loc:
heappush(q, -stations[idx][1])
idx += 1
return ans
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.871` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/872. 叶子相似的树（简单）.md | 872. 叶子相似的树 | https://leetcode-cn.com/problems/leaf-similar-trees/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-udfc/ | 简单 | [
"树的搜索",
"非递归",
"递归",
"DFS"
] | 请考虑一棵二叉树上所有的叶子,这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。
举个例子,如上图所示,给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。
如果有两棵二叉树的叶值序列是相同,那么我们就认为它们是 叶相似 的。
如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的,则返回 true;否则返回 false 。
示例 1:
```
输入:
root1 = [3,5,1,6,2,9,8,null,null,7,4],
root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
输出:true
```
示例 2:
```
输入:root1 = [1], root2 = [1]
输出:true
```
示例 3:
```
输入:root1 = [1], root2 = [2]
输出:false
```
示例 4:
```
输入:root1 = [1,2], root2 = [2,2]
输出:true
```
示例 5:
```
输入:root1 = [1,2,3], root2 = [1,3,2]
输出:false
```
提示:
* 给定的两棵树可能会有 1 到 200 个结点。
* 给定的两棵树上的值介于 0 到 200 之间。 | ### 递归
递归写法十分简单,属于树的遍历中最简单的实现方式。
代码:
```Java
class Solution {
public boolean leafSimilar(TreeNode t1, TreeNode t2) {
List<Integer> l1 = new ArrayList<>(), l2 = new ArrayList<>();
dfs(t1, l1);
dfs(t2, l2);
if (l1.size() == l2.size()) {
for (int i = 0; i < l1.size(); i++) {
if (!l1.get(i).equals(l2.get(i))) return false;
}
return true;
}
return false;
}
void dfs(TreeNode root, List<Integer> list) {
if (root == null) return;
if (root.left == null && root.right == null) {
list.add(root.val);
return;
}
dfs(root.left, list);
dfs(root.right, list);
}
}
```
* 时间复杂度:`n` 和 `m` 分别代表两棵树的节点数量。复杂度为 $O(n + m)$
* 空间复杂度:`n` 和 `m` 分别代表两棵树的节点数量,当两棵树都只有一层的情况,所有的节点值都会被存储在 $list$ 中。复杂度为 $O(n + m)$
---
### 迭代
迭代其实就是使用「栈」来模拟递归过程,也属于树的遍历中的常见实现形式。
一般简单的面试中如果问到树的遍历,面试官都不会对「递归」解法感到满意,因此掌握「迭代/非递归」写法同样重要。
代码:
```Java
class Solution {
public boolean leafSimilar(TreeNode t1, TreeNode t2) {
List<Integer> l1 = new ArrayList<>(), l2 = new ArrayList<>();
process(t1, l1);
process(t2, l2);
if (l1.size() == l2.size()) {
for (int i = 0; i < l1.size(); i++) {
if (!l1.get(i).equals(l2.get(i))) return false;
}
return true;
}
return false;
}
void process(TreeNode root, List<Integer> list) {
Deque<TreeNode> d = new ArrayDeque<>();
while (root != null || !d.isEmpty()) {
while (root != null) {
d.addLast(root);
root = root.left;
}
root = d.pollLast();
if (root.left == null && root.right == null) list.add(root.val);
root = root.right;
}
}
}
```
* 时间复杂度:`n` 和 `m` 分别代表两棵树的节点数量。复杂度为 $O(n + m)$
* 空间复杂度:`n` 和 `m` 分别代表两棵树的节点数量,当两棵树都只有一层的情况,所有的节点值都会被存储在 $list$ 中。复杂度为 $O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.872` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/873. 最长的斐波那契子序列的长度（中等）.md | 873. 最长的斐波那契子序列的长度 | https://leetcode.cn/problems/length-of-longest-fibonacci-subsequence/solution/by-ac_oier-beo2/ | 中等 | [
"序列 DP",
"哈希表",
"动态规划"
] | 如果序列 $X_1, X_2, ..., X_n$ 满足下列条件,就说它是 斐波那契式 的:
* `n >= 3`
* 对于所有 `i + 2 <= n`,都有 $X_i + X_{i+1} = X_{i+2}$
给定一个严格递增的正整数数组形成序列 `arr`,找到 `arr` 中最长的斐波那契式的子序列的长度。如果一个不存在,返回 $0$ 。
(回想一下,子序列是从原序列 `arr` 中派生出来的,它从 `arr` 中删掉任意数量的元素(也可以不删),而不改变其余元素的顺序。例如, `[3, 5, 8]` 是 `[3, 4, 5, 6, 7, 8]` 的一个子序列)
示例 1:
```
输入: arr = [1,2,3,4,5,6,7,8]
输出: 5
解释: 最长的斐波那契式子序列为 [1,2,3,5,8] 。
```
示例 2:
```
输入: arr = [1,3,7,11,12,14,18]
输出: 3
解释: 最长的斐波那契式子序列有 [1,11,12]、[3,11,14] 以及 [7,11,18] 。
```
提示:
* $3 <= arr.length <= 1000$
* $1 <= arr[i] < arr[i + 1] <= 10^9$ | ### 序列 DP
定义 $f[i][j]$ 为使用 $arr[i]$ 为斐波那契数列的最后一位,使用 $arr[j]$ 为倒数第二位(即 $arr[i]$ 的前一位)时的最长数列长度。
不失一般性考虑 $f[i][j]$ 该如何计算,首先根据斐波那契数列的定义,我们可以直接算得 $arr[j]$ 前一位的值为 $arr[i] - arr[j]$,而快速得知 $arr[i] - arr[j]$ 值的坐标 $t$,可以利用 `arr` 的严格单调递增性质,使用「哈希表」对坐标进行转存,若坐标 $t$ 存在,并且符合 $t < j$,说明此时至少凑成了长度为 $3$ 的斐波那契数列,同时结合状态定义,可以使用 $f[j][t]$ 来更新 $f[i][j]$,即有状态转移方程:
$$
f[i][j] = \max(3, f[j][t] + 1)
$$
同时,当我们「从小到大」枚举 $i$,并且「从大到小」枚举 $j$ 时,我们可以进行如下的剪枝操作:
* 可行性剪枝:当出现 $arr[i] - arr[j] >= arr[j]$,说明即使存在值为 $arr[i] - arr[j]$ 的下标 $t$,根据 `arr` 单调递增性质,也不满足 $t < j < i$ 的要求,且继续枚举更小的 $j$,仍然有 $arr[i] - arr[j] >= arr[j]$,仍不合法,直接 `break` 掉当前枚举 $j$ 的搜索分支;
* 最优性剪枝:假设当前最大长度为 `ans`,只有当 $j + 2 > ans$,我们才有必要往下搜索,$j + 2$ 的含义为以 $arr[j]$ 为斐波那契数列倒数第二个数时的理论最大长度。
代码:
```Java
class Solution {
public int lenLongestFibSubseq(int[] arr) {
int n = arr.length, ans = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) map.put(arr[i], i);
int[][] f = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = i - 1; j >= 0 && j + 2 > ans; j--) {
if (arr[i] - arr[j] >= arr[j]) break;
int t = map.getOrDefault(arr[i] - arr[j], -1);
if (t == -1) continue;
f[i][j] = Math.max(3, f[j][t] + 1);
ans = Math.max(ans, f[i][j]);
}
}
return ans;
}
}
```
* 时间复杂度:存入哈希表复杂度为 $O(n)$;`DP` 过程复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.873` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/875. 爱吃香蕉的珂珂（中等）.md | 875. 爱吃香蕉的珂珂 | https://leetcode.cn/problems/koko-eating-bananas/solution/by-ac_oier-4z7i/ | 中等 | [
"二分"
] | 珂珂喜欢吃香蕉。这里有 `n` 堆香蕉,第 `i` 堆中有 `piles[i]` 根香蕉。警卫已经离开了,将在 `h` 小时后回来。
珂珂可以决定她吃香蕉的速度 `k` (单位:根/小时)。每个小时,她将会选择一堆香蕉,从中吃掉 `k` 根。如果这堆香蕉少于 `k` 根,她将吃掉这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉。
珂珂喜欢慢慢吃,但仍然想在警卫回来前吃掉所有的香蕉。
返回她可以在 `h` 小时内吃掉所有香蕉的最小速度 `k`(`k` 为整数)。
示例 1:
```
输入:piles = [3,6,7,11], h = 8
输出:4
```
示例 2:
```
输入:piles = [30,11,23,4,20], h = 5
输出:30
```
示例 3:
```
输入:piles = [30,11,23,4,20], h = 6
输出:23
```
提示:
* $1 <= piles.length <= 10^4$
* $piles.length <= h <= 10^9$
* $1 <= piles[i] <= 10^9$ | ### 二分
由于存在「吃完这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉」的条件,因此不会存在多堆香蕉共用一个小时的情况,即每堆香蕉都是相互独立,同时可以明确每堆香蕉的耗时为 $\left \lceil \frac{piles[i]}{k} \right \rceil$(其中 $k$ 为速度)。
因此我们可以二分 $k$ 值,在以 $k$ 为分割点的数组上具有「二段性」:
* 小于 $k$ 的值,总耗时 $ans$ 必然不满足 $ans \leq h$
* 大于等于 $k$ 的值,总耗时 $ans$ 必然满足 $ans \leq h$
然后我们需要确定二分的范围,每堆香蕉至少消耗一个小时,因此大于 $\max(piles[i])$ 的速度值 $k$ 是没有意义的(与 $k = \max(piles[i])$ 等价),因此我们可以先对 `piles` 进行一次遍历,找最大值,再二分;也可以直接利用数据范围 $1 <= piles[i] <= 10^9$ 确定一个粗略边界进行二分。
最后的 `check` 函数,只需要计算当前速率 $k$ 所对应的总耗时 $ans$,再与 $h$ 做比较即可。
代码:
```Java
class Solution {
public int minEatingSpeed(int[] piles, int h) {
int l = 0, r = (int)1e9;
while (l < r) {
int mid = l + r >> 1;
if (check(piles, mid, h)) r = mid;
else l = mid + 1;
}
return r;
}
boolean check(int[] p, int k, int h) {
int ans = 0;
for (int x : p) ans += Math.ceil(x * 1.0 / k);
return ans <= h;
}
}
```
* 时间复杂度:令 $n$ 数组长度,$m = 1e9$ 为最大的 $piles[i]$,复杂度为 $O(n\log{m})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.875` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/877. 石子游戏（中等）.md | 877. 石子游戏 | https://leetcode-cn.com/problems/stone-game/solution/gong-shui-san-xie-jing-dian-qu-jian-dp-j-wn31/ | 中等 | [
"区间 DP",
"博弈论"
] | 亚历克斯和李用几堆石子在做游戏。偶数堆石子排成一行,每堆都有正整数颗石子 piles[i] 。
游戏以谁手中的石子最多来决出胜负。石子的总数是奇数,所以没有平局。
亚历克斯和李轮流进行,亚历克斯先开始。 每回合,玩家从行的开始或结束处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止,此时手中石子最多的玩家获胜。
假设亚历克斯和李都发挥出最佳水平,当亚历克斯赢得比赛时返回 true ,当李赢得比赛时返回 false 。
示例:
```
输入:[5,3,4,5]
输出:true
解释:
亚历克斯先开始,只能拿前 5 颗或后 5 颗石子 。
假设他取了前 5 颗,这一行就变成了 [3,4,5] 。
如果李拿走前 3 颗,那么剩下的是 [4,5],亚历克斯拿走后 5 颗赢得 10 分。
如果李拿走后 5 颗,那么剩下的是 [3,4],亚历克斯拿走后 4 颗赢得 9 分。
这表明,取前 5 颗石子对亚历克斯来说是一个胜利的举动,所以我们返回 true 。
```
提示:
* 2 <= piles.length <= 500
* piles.length 是偶数。
* 1 <= piles[i] <= 500
* sum(piles) 是奇数。 | ### 动态规划
**定义 $f[l][r]$ 为考虑区间 $[l,r]$,在双方都做最好选择的情况下,先手与后手的最大得分差值为多少。**
那么 $f[1][n]$ 为考虑所有石子,先手与后手的得分差值:
* $f[1][n] > 0$,则先手必胜,返回 `True`
* $f[1][n] < 0$,则先手必败,返回 `False`
不失一般性的考虑 $f[l][r]$ 如何转移。根据题意,只能从两端取石子(令 $piles$ 下标从 $1$ 开始),共两种情况:
* 从左端取石子,价值为 $piles[l - 1]$;取完石子后,原来的后手变为先手,从 $[l + 1, r]$ 区间做最优决策,所得价值为 $f[l + 1][r]$。**因此本次先手从左端点取石子的话,双方差值为**:
$$
piles[l - 1] - f[l + 1][r]
$$
* 从右端取石子,价值为 $piles[r - 1]$;取完石子后,原来的后手变为先手,从 $[l, r - 1]$ 区间做最优决策,所得价值为 $f[l][r - 1]$。**因此本次先手从右端点取石子的话,双方差值为**:
$$
piles[r - 1] - f[l][r - 1]
$$
双方都想赢,都会做最优决策(即使自己与对方分差最大)。因此 $f[l][r]$ 为上述两种情况中的最大值。
根据状态转移方程,我们发现大区间的状态值依赖于小区间的状态值,典型的区间 DP 问题。
按照从小到大「枚举区间长度」和「区间左端点」的常规做法进行求解即可。
代码:
```Java
class Solution {
public boolean stoneGame(int[] ps) {
int n = ps.length;
int[][] f = new int[n + 2][n + 2];
for (int len = 1; len <= n; len++) { // 枚举区间长度
for (int l = 1; l + len - 1 <= n; l++) { // 枚举左端点
int r = l + len - 1; // 计算右端点
int a = ps[l - 1] - f[l + 1][r];
int b = ps[r - 1] - f[l][r - 1];
f[l][r] = Math.max(a, b);
}
}
return f[1][n] > 0;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 博弈论
事实上,这还是一道很经典的博弈论问题,也是最简单的一类博弈论问题。
为了方便,我们称「石子序列」为石子在原排序中的编号,下标从 $1$ 开始。
由于石子的堆数为偶数,且只能从两端取石子。**因此先手后手所能选择的石子序列,完全取决于先手每一次决定。**
由于石子的堆数为偶数,对于先手而言:**每一次的决策局面,都能「自由地」选择奇数还是偶数的序列,从而限制后手下一次「只能」奇数还是偶数石子。**
具体的,对于本题,**由于石子堆数为偶数,因此先手的最开始局面必然是 $[奇数, 偶数]$,即必然是「奇偶性不同的局面」;当先手决策完之后,交到给后手的要么是 $[奇数,奇数]$ 或者 $[偶数,偶数]$,即必然是「奇偶性相同的局面」;后手决策完后,又恢复「奇偶性不同的局面」交回到先手** ...
不难归纳推理,这个边界是可以应用到每一个回合。
**因此先手只需要在进行第一次操作前计算原序列中「奇数总和」和「偶数总和」哪个大,然后每一次决策都「限制」对方只能选择「最优奇偶性序列」的对立面即可。**
同时又由于所有石子总和为奇数,堆数为偶数,即没有平局,所以先手必胜。
代码:
```Java
class Solution {
public boolean stoneGame(int[] piles) {
return true;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.877` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/878. 第 N 个神奇数字（困难）.md | 878. 第 N 个神奇数字 | https://leetcode.cn/problems/nth-magical-number/solution/by-ac_oier-ln3b/ | 困难 | [
"数学",
"容斥原理",
"二分",
"gcd",
"lcm"
] | 一个正整数如果能被 `a` 或 `b` 整除,那么它是神奇的。
给定三个整数 `n` , `a` , `b` ,返回第 `n` 个神奇的数字。因为答案可能很大,所以返回答案 对 $10^9 + 7$ 取模 后的值。
示例 1:
```
输入:n = 1, a = 2, b = 3
输出:2
```
示例 2:
```
输入:n = 4, a = 2, b = 3
输出:6
```
提示:
* $1 <= n <= 10^9$
* $2 <= a, b <= 4 \times 10^4$ | ### 数学
#### 提示一 : 从题面分析常见做法,从常见做法复杂度出发考虑其他做法
若不看数据范围,只看题面,容易想到的做法是「多路归并」:起始使用两个指针指向 `[a, 2a, 3a, ... ]` 和 `[b, 2b, 3b, ...]` 的开头,不断比较两指针所指向的数值大小,从而决定将谁后移,并不断更新顺位计数。
该做法常见,但其复杂度为 $O(n)$,对于本题 $n = 1e9$ 来说并不可行。
确定线性复杂度的做法不可行后,我们考虑是否存在对数复杂度的做法。
#### 提示二 : 如何考虑常见的对数复杂度做法,如何定义二段性
题目要我们求第 $n$ 个符合要求的数,假设我们想要通过「二分」来找该数值,那么我们需要分析其是否存在「二段性」。
假设在所有「能够被 `a` 或 `b` 整除的数」形成的数轴上,我们要找的分割点是 `k`,我们期望通过「二分」来找到 `k` 值,那么需要定义某种性质,使得 `k` 左边的数均满足该性质,`k` 右边的数均不满足该性质。
不难想到可根据题意来设定该性质:小于 `k` 的任意数字 `x` 满足在 $[0, x]$ 范围数的个数不足 `k` 个,而大于等于 `k` 的任意数字 `x` 则不满足该性质。
#### 提示三 : 如何实现高效的 `check` 函数
当确定使用「二分」来做时,剩下问题转化为:**如何快速得知某个 $[0, n]$ 中满足要求的数的个数。**
容易联想到「容斥原理」:**能被 `a` 或 `b` 整除的数的个数 = 能够被 `a` 整除的数的个数 + 能够被 `b` 整除的数的个数 - 既能被 `a` 又能被 `b` 整除的数的个数**。
$$
\left \lfloor \frac{n}{a} \right \rfloor + \left \lfloor \frac{n}{b} \right \rfloor - \left \lfloor \frac{n}{c} \right \rfloor
$$
其中 `c` 为 `a` 和 `b` 的最小公倍数。
求解最小公倍数 `lcm` 需要实现最大公约数 `gcd`,两者模板分别为:
```Java []
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
```
#### 提示四 : 如何确定值域
一个合格的值域只需要确定答案在值域范围即可,因此我们可以直接定值域大小为 $1e18$。
或是根据 `a` 和 `b` 的取值来大致确定:假设两者中的较大值为 $m$,此时第 $n$ 个符合要求的数最大不会超过 $n \times m$,因此也可以设定值域大小为 $[0, 40000n]$。
Java 代码:
```Java
class Solution {
int n, a, b, c;
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
public int nthMagicalNumber(int _n, int _a, int _b) {
n = _n; a = _a; b = _b; c = a * b / gcd(a, b);
long l = 0, r = (long)1e18;
while (l < r) {
long mid = l + r >> 1;
if (check(mid) >= n) r = mid;
else l = mid + 1;
}
return (int)(r % 1000000007);
}
long check(long x) {
return x / a + x / b - x / c;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int n, a, b, c;
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
long check(long x) {
return x / a + x / b - x / c;
}
int nthMagicalNumber(int _n, int _a, int _b) {
n = _n; a = _a; b = _b; c = a * b / gcd(a, b);
long l = 0, r = 1e18;
while (l < r) {
long mid = l + r >> 1;
if (check(mid) >= n) r = mid;
else l = mid + 1;
}
return (int)(r % 1000000007);
}
};
```
Python3 代码:
```Python
class Solution:
def nthMagicalNumber(self, n: int, a: int, b: int) -> int:
def gcd(a, b):
return a if b == 0 else gcd(b, a % b)
def check(x):
return x // a + x // b - x // c
c = a * b // gcd(a, b)
l, r = 0, 1e18
while l < r:
mid = (l + r) // 2
if check(mid) >= n:
r = mid
else:
l = mid + 1
return int(r % 1000000007)
```
TypeScript 代码:
```TypeScript
function nthMagicalNumber(n: number, a: number, b: number): number {
function gcd(a: number, b: number): number {
return b == 0 ? a : gcd(b, a % b)
}
function check(x: number): number {
return Math.floor(x / a) + Math.floor(x / b) - Math.floor(x / c)
}
const c = Math.floor(a * b / gcd(a, b))
let l = 0, r = 1e18
while (l < r) {
const mid = Math.floor((l + r) / 2)
if (check(mid) >= n) r = mid
else l = mid + 1
}
return r % 1000000007
}
```
* 时间复杂度:$O(\log{N})$,其中 $N = 1e18$ 为值域大小
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.878` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/871-880/879. 盈利计划（困难）.md | 879. 盈利计划 | https://leetcode-cn.com/problems/profitable-schemes/solution/gong-shui-san-xie-te-shu-duo-wei-fei-yon-7su9/ | 困难 | [
"动态规划",
"容斥原理",
"数学",
"背包问题",
"多维背包"
] | 集团里有 `n` 名员工,他们可以完成各种各样的工作创造利润。
第 `i` 种工作会产生 `profit[i]` 的利润,它要求 `group[i]` 名成员共同参与。如果成员参与了其中一项工作,就不能参与另一项工作。
工作的任何至少产生 `minProfit` 利润的子集称为 盈利计划 。并且工作的成员总数最多为 `n` 。
有多少种计划可以选择?因为答案很大,所以 返回结果模 $10^9 + 7 $ 的值。
示例 1:
```
输入:n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出:2
解释:至少产生 3 的利润,该集团可以完成工作 0 和工作 1 ,或仅完成工作 1 。
总的来说,有两种计划。
```
示例 2:
```
输入:n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出:7
解释:至少产生 5 的利润,只要完成其中一种工作就行,所以该集团可以完成任何工作。
有 7 种可能的计划:(0),(1),(2),(0,1),(0,2),(1,2),以及 (0,1,2) 。
```
提示:
* 1 <= n <= 100
* 0 <= minProfit <= 100
* 1 <= group.length <= 100
* 1 <= group[i] <= 100
* profit.length == group.length
* 0 <= profit[i] <= 100 | ### 动态规划
这是一类特殊的多维费用背包问题。
将每个任务看作一个「物品」,完成任务所需要的人数看作「成本」,完成任务得到的利润看作「价值」。
其特殊在于存在一维容量维度需要满足「不低于」,而不是常规的「不超过」。这需要我们对于某些状态作等价变换。
**定义 $f[i][j][k]$ 为考虑前 $i$ 件物品,使用人数不超过 $j$,所得利润至少为 $k$ 的方案数。**
对于每件物品(令下标从 $1$ 开始),我们有「选」和「不选」两种决策:
* 不选:显然有:
$$
f[i - 1][j][k]
$$
* 选:首先需要满足人数达到要求( $j >= group[i - 1]$ ),还需要考虑「至少利润」负值问题:
如果直接令「利润维度」为 $k - profit[i - 1]$ 可能会出现负值,那么负值是否为合法状态呢?这需要结合「状态定义」来看,由于是「利润至少为 $k$」,因此属于「合法状态」,需要参与转移。
**由于我们没有设计动规数组存储「利润至少为负权」状态,我们需要根据「状态定义」做一个等价替换,将这个「状态」映射到 $f[i][j][0]$。这主要是利用所有的任务利润都为“非负数”,所以不可能出现利润为负的情况,这时候「利润至少为某个负数 $k$」的方案数其实是完全等价于「利润至少为 $0$」的方案数。**
$$
f[i - 1][j - group[i - 1]][\max(k - profit[i - 1], 0)]
$$
最终 $f[i][j][k]$ 为上述两种情况之和.
然后考虑「如何构造有效起始值」问题,还是结合我们的「状态定义」来考虑:
当不存在任何物品(任务)时,所得利用利润必然为 $0$(满足至少为 $0$),同时对人数限制没有要求。
因此可以让所有 $f[0][x][0] = 1$。
代码(一维空间优化代码见 P2):
```Java
class Solution {
int mod = (int)1e9+7;
public int profitableSchemes(int n, int min, int[] gs, int[] ps) {
int m = gs.length;
long[][][] f = new long[m + 1][n + 1][min + 1];
for (int i = 0; i <= n; i++) f[0][i][0] = 1;
for (int i = 1; i <= m; i++) {
int a = gs[i - 1], b = ps[i - 1];
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= min; k++) {
f[i][j][k] = f[i - 1][j][k];
if (j >= a) {
int u = Math.max(k - b, 0);
f[i][j][k] += f[i - 1][j - a][u];
f[i][j][k] %= mod;
}
}
}
}
return (int)f[m][n][min];
}
}
```
```Java
class Solution {
int mod = (int)1e9+7;
public int profitableSchemes(int n, int min, int[] gs, int[] ps) {
int m = gs.length;
int[][] f = new int[n + 1][min + 1];
for (int i = 0; i <= n; i++) f[i][0] = 1;
for (int i = 1; i <= m; i++) {
int a = gs[i - 1], b = ps[i - 1];
for (int j = n; j >= a; j--) {
for (int k = min; k >= 0; k--) {
int u = Math.max(k - b, 0);
f[j][k] += f[j - a][u];
if (f[j][k] >= mod) f[j][k] -= mod;
}
}
}
return f[n][min];
}
}
```
* 时间复杂度:$O(m * n * min)$
* 空间复杂度:$O(m * n * min)$
---
### 动态规划(作差法)
这个方案足足调了快一个小时 🤣
先是爆 `long`,然后转用高精度后被卡内存,最终改为滚动数组后~~勉强过了~~(不是,稳稳的过了,之前调得久是我把 `N` 多打了一位,写成 1005 了,`N` 不打错的话,不滚动也是能过的 😭😭😭 )
基本思路是先不考虑最小利润 `minProfit`,求得所有只受「人数限制」的方案数 `a`,然后求得考虑「人数限制」同时,利润低于 `minProfit`(不超过 `minProfit - 1`)的所有方案数 `b`。
由 `a` - `b` 即是答案。
代码:
```Java
import java.math.BigInteger;
class Solution {
static int N = 105;
static BigInteger[][] f = new BigInteger[2][N];
static BigInteger[][][] g = new BigInteger[2][N][N];
static BigInteger mod = new BigInteger("1000000007");
public int profitableSchemes(int n, int min, int[] gs, int[] ps) {
int m = gs.length;
for (int j = 0; j <= n; j++) {
f[0][j] = new BigInteger("1");
f[1][j] = new BigInteger("0");
}
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= min; k++) {
g[0][j][k] = new BigInteger("1");
g[1][j][k] = new BigInteger("0");
}
}
for (int i = 1; i <= m; i++) {
int a = gs[i - 1], b = ps[i - 1];
int x = i & 1, y = (i - 1) & 1;
for (int j = 0; j <= n; j++) {
f[x][j] = f[y][j];
if (j >= a) {
f[x][j] = f[x][j].add(f[y][j - a]);
}
}
}
if (min == 0) return (f[m&1][n]).mod(mod).intValue();
for (int i = 1; i <= m; i++) {
int a = gs[i - 1], b = ps[i - 1];
int x = i & 1, y = (i - 1) & 1;
for (int j = 0; j <= n; j++) {
for (int k = 0; k < min; k++) {
g[x][j][k] = g[y][j][k];
if (j - a >= 0 && k - b >= 0) {
g[x][j][k] = g[x][j][k].add(g[y][j - a][k - b]);
}
}
}
}
return f[m&1][n].subtract(g[m&1][n][min - 1]).mod(mod).intValue();
}
}
```
* 时间复杂度:第一遍 `DP` 复杂度为 $O(m * n)$;第二遍 `DP` 复杂度为 $O(m * n * min)$。整体复杂度为 $O(m * n * min)$
* 空间复杂度:$O(m * n * min)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.879` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/881. 救生艇（中等）.md | 881. 救生艇 | https://leetcode-cn.com/problems/boats-to-save-people/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-hosg8/ | 中等 | [
"贪心",
"双指针"
] | 第 `i` 个人的体重为 `people[i]`,每艘船可以承载的最大重量为 `limit`。
每艘船最多可同时载两人,但条件是这些人的重量之和最多为 `limit`。
返回载到每一个人所需的最小船数。(保证每个人都能被船载)。
示例 1:
```
输入:people = [1,2], limit = 3
输出:1
解释:1 艘船载 (1, 2)
```
示例 2:
```
输入:people = [3,2,2,1], limit = 3
输出:3
解释:3 艘船分别载 (1, 2), (2) 和 (3)
```
示例 3:
```
输入:people = [3,5,3,4], limit = 5
输出:4
解释:4 艘船分别载 (3), (3), (4), (5)
```
提示:
* 1 <= people.length <= 50000
* 1 <= people[i] <= limit <= 30000 | ### 贪心
一个直观的想法是:由于一个船要么载两人要么载一人,在人数给定的情况下,为了让使用的总船数最小,要当尽可能让更多船载两人,即尽可能多的构造出数量之和不超过 $limit$ 的二元组。
先对 $people$ 进行排序,然后使用两个指针 `l` 和 `r` 分别从首尾开始进行匹配:
* 如果 $people[l] + people[r] <= limit$,说明两者可以同船,此时船的数量加一,两个指针分别往中间靠拢;
* 如果 $people[l] + people[r] > limit$,说明不能成组,由于题目确保人的重量不会超过 $limit$,此时让 $people[r]$ 独立成船,船的数量加一,`r` 指针左移。
**我们猜想这样「最重匹配最轻、次重匹配次轻」的做法能使双人船的重量之和尽可能平均,从而使双人船的数量最大化。**
接下来,我们使用「归纳法」证明猜想的正确性。
假设最优成船组合中二元组的数量为 $c1$,我们贪心做法的二元组数量为 $c2$。
最终答案 = 符合条件的二元组的数量 + 剩余人数数量,而在符合条件的二元组数量固定的情况下,剩余人数也固定。因此我们只需要证明 $c1 = c2$ 即可。
通常使用「归纳法」进行证明,都会先从边界入手。
当我们处理最重的人 $people[r]$(此时 $r$ 为原始右边界 $n - 1$)时:
* 假设其与 $people[l]$(此时 $l$ 为原始左边界 $0$)之和超过 $limit$,说明 $people[r]$ 与数组任一成员组合都会超过 $limit$,即无论在最优组合还是贪心组合中,$people[r]$ 都会独立成船;
* 假设 $people[r] + people[l] <= limit$,说明数组中存在至少一个成员能够与 $people[l]$ 成船:
* 假设在最优组合中 $people[l]$ 独立成船,此时如果将贪心组合 $(people[l], people[r])$ 中的 $people[l]$ 拆分出来独立成船,贪心二元组数量 $c2$ 必然不会变大(可能还会变差),即将「贪心解」调整成「最优解」结果不会变好;
* 假设在最优组合中,$people[l]$ 不是独立成船,又因此当前 $r$ 处于原始右边界,因此与 $people[l]$ 成组的成员 $people[x]$ 必然满足 $people[x] <= people[r]$。
此时我们将 $people[x]$ 和 $people[r]$ 位置进行交换(将贪心组合调整成最优组合),此时带来的影响包括:
* 与 $people[l]$ 成组的对象从 $people[r]$ 变为 $people[x]$,但因为 $people[x] <= people[r]$,即有 $people[l] + people[x] <= people[l] + people[r] <= limit$,仍为合法二元组,消耗船的数量为 $1$;
* 原本位置 $x$ 的值从 $people[x]$ 变大为 $people[r]$,如果调整后的值能组成二元组,那么原本更小的值也能组成二元组,结果没有变化;如果调整后不能成为组成二元组,那么结果可能会因此变差。
综上,将 $people[x]$ 和 $people[r]$ 位置进行交换(将贪心组合调整成最优组合),贪心二元组数量 $c2$ 不会变大,即将「贪心解」调整成「最优解」结果不会变好。
**对于边界情况,我们证明了从「贪心解」调整为「最优解」不会使得结果更好,因此可以保留当前的贪心决策,然后将问题规模缩减为 $n - 1$ 或者 $n - 2$,同时数列仍然满足升序特性,即归纳分析所依赖的结构没有发生改变,可以将上述的推理分析推广到每一个决策的回合(新边界)中。**
**至此,我们证明了将「贪心解」调整为「最优解」结果不会变好,即贪心解是最优解之一。**
代码:
```Java
class Solution {
public int numRescueBoats(int[] people, int limit) {
Arrays.sort(people);
int n = people.length;
int l = 0, r = n - 1;
int ans = 0;
while (l <= r) {
if (people[l] + people[r] <= limit) l++;
r--;
ans++;
}
return ans;
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;双指针统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.881` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/882. 细分图中的可到达节点（困难）.md | 882. 细分图中的可到达节点 | https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph/solution/by-ac_oier-yrhg/ | 困难 | [
"最短路",
"单源最短路",
"Dijkstra",
"SPFA"
] | 给你一个无向图(原始图),图中有 `n` 个节点,编号从 `0` 到 `n - 1` 。你决定将图中的每条边 细分 为一条节点链,每条边之间的新节点数各不相同。
图用由边组成的二维数组 `edges` 表示,其中 $edges[i] = [u_{i}, v_{i}, cnt_{i}]$ 表示原始图中节点 $u_{i}$ 和 $v_{i}$ 之间存在一条边,$cnt_{i}$ 是将边 细分 后的新节点总数。注意,$cnt_{i} = 0$ 表示边不可细分。
要 细分边 $[u_{i}, v_{i}]$ ,需要将其替换为 $(cnt_{i} + 1)$ 条新边,和 $cnt_{i}$ 个新节点。新节点为 $x_1, x_2, ..., x_{cnt_{i}}$ ,新边为 $[u_{i}, x_{1}], [x_{1}, x_{2}], [x_{2}, x_{3}], ..., [x_{cnt_{i}}+1, x_{cnt_{i}}], [x_{cnt_{i}}, v_{i}]$ 。
现在得到一个 新的细分图 ,请你计算从节点 `0` 出发,可以到达多少个节点?如果节点间距离是 `maxMoves` 或更少,则视为 可以到达 。
给你原始图和 `maxMoves` ,返回 新的细分图中从节点 `0` 出发 可到达的节点数 。
示例 1:
```
输入:edges = [[0,1,10],[0,2,1],[1,2,2]], maxMoves = 6, n = 3
输出:13
解释:边的细分情况如上图所示。
可以到达的节点已经用黄色标注出来。
```
示例 2:
```
输入:edges = [[0,1,4],[1,2,6],[0,2,8],[1,3,1]], maxMoves = 10, n = 4
输出:23
```
示例 3:
```
输入:edges = [[1,2,4],[1,4,5],[1,3,1],[2,3,4],[3,4,5]], maxMoves = 17, n = 5
输出:1
解释:节点 0 与图的其余部分没有连通,所以只有节点 0 可以到达。
```
提示:
* $0 <= edges.length <= \min(n * (n - 1) / 2, 10^4)$
* $edges[i].length = 3$
* $0 <= u_{i} < v_{i} < n$
* 图中 不存在平行边
* $0 <= cnt_{i} <= 10^4$
* $0 <= maxMoves <= 10^9$
* $1 <= n <= 3000$ | ### 朴素 Dijkstra
为了方便,我们将原始图边的数量记为 `m`,因此对于原始图而言,点的数量 $3000$,边的数量为 $10000$。
题目要我们求新图上,从 `0` 点出发可到达的点的数量,我们将原图上存在的点称为「原点」,细分边上增加的点称为「细分点」,两类点中可达点的数量即是答案。
在分别考虑如何统计两类点之前,我们需要重新定义一下边的权重:**若原点 `u` 和原点 `v` 的边上存在 `c` 个细分点,我们将原点 `u` 和原点 `v` 之间的边看作是一条权重为 `c + 1` 的无向边(结合题意,`c` 个点存在 `c + 1` 个分段/距离)**。
重新定义边的权重后,因为该图是「稠密图」,我们可以使用「朴素 Dijkstra」来求解最短路,得到 $dist$ 数组,其中 $dist[x] = t$ 含义为从原点 `0` 点出发,到达原点 `x` 的最短距离为 `t`。
> **不了解最短路的同学可以看前置 🧀 : [涵盖所有的「存图方式」与「最短路算法(详尽注释)」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d)**
随后考虑如何统计答案(可达点的数量),根据统计点的类型分情况讨论:
1. 对于原点:若有 $dist[x] \leq max$ 的话,说明原点 `x` 可达,累加到答案中;
2. 对于细分点:由于所有的细分点都在原图边上,因此我们可以统计所有原图边上有多少细分点可达。
对于任意一条边 $e(u, v)$ 而言,该边上可达点数量包含「经过原点 `u` 可达」以及「经过原点 `v` 可达」的并集,其中原点 `0` 到达原点 `u` 以及原点 `v` 的距离,我们是已知的。因此经过原点 `u` 可达的数量为 $\max(0, max - dist[u])$,经过原点 `v` 可达的数量为 $\max(0, max - dist[v])$,两者之和与该边上细分点的总数取 `min` 即是这条边可达点的数量。
代码:
```Java
class Solution {
static int N = 3010, INF = 0x3f3f3f3f;
static int[][] g = new int[N][N];
static int[] dist = new int[N];
static boolean[] vis = new boolean[N];
public int reachableNodes(int[][] edges, int max, int n) {
// 建图
for (int i = 0; i < n; i++) Arrays.fill(g[i], INF);
for (int[] info : edges) {
int a = info[0], b = info[1], c = info[2] + 1;
g[a][b] = g[b][a] = c;
}
// 朴素 Dijkstra
Arrays.fill(dist, INF);
Arrays.fill(vis, false);
dist[0] = 0;
for (int i = 0; i < n; i++) {
int t = -1;
for (int j = 0; j < n; j++) {
if (!vis[j] && (t == -1 || dist[j] < dist[t])) t = j;
}
vis[t] = true;
for (int j = 0; j < n; j++) dist[j] = Math.min(dist[j], dist[t] + g[t][j]);
}
// 统计答案
int ans = 0;
for (int i = 0; i < n; i++) {
if (dist[i] <= max) ans++;
}
for (int[] info : edges) {
int a = info[0], b = info[1], c = info[2];
int c1 = Math.max(0, max - dist[a]), c2 = Math.max(0, max - dist[b]);
ans += Math.min(c, c1 + c2);
}
return ans;
}
}
```
* 时间复杂度:建图复杂度为 $O(m)$;使用朴素 Dijkstra 求最短路复杂度为 $O(n^2)$;统计答案复杂度为 $O(n + m)$。整体复杂度为 $O(m + n^2)$
* 空间复杂度:$O(n^2)$
---
### SPFA
从数据范围来看,无论是朴素 Dijkstra 还是堆优化版的 Dijkstra 都可以过,复杂度分别为 $O(n^2)$ 和 $O(m\log{n})$。
那 Bellman Ford 类的单源最短路就无法通过了吗?
理论上,无论是 Bellman Ford 还是 SPFA 复杂度均为 $O(n \times m)$,均无法通过本题。但实际上 SPFA 由于使用队列对松弛顺序进行了调整,因此在应对「非菊花图」时均表现良好,复杂度可视为 $O(k \times m)$,近似 $O(m)$。
代码:
```Java
class Solution {
static int N = 3010, M = 20010, INF = 0x3f3f3f3f, idx = 0;
static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
static int[] dist = new int[N];
static boolean[] vis = new boolean[N];
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
public int reachableNodes(int[][] edges, int max, int n) {
// 建图
Arrays.fill(he, -1);
idx = 0;
for (int[] info : edges) {
int a = info[0], b = info[1], c = info[2] + 1;
add(a, b, c); add(b, a, c);
}
// SPFA
Arrays.fill(dist, INF);
Arrays.fill(vis, false);
Deque<Integer> d = new ArrayDeque<>();
d.addLast(0);
dist[0] = 0;
vis[0] = true;
while (!d.isEmpty()) {
int t = d.pollFirst();
vis[t] = false;
for (int i = he[t]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] > dist[t] + w[i]) {
dist[j] = dist[t] + w[i];
if (vis[j]) continue;
d.addLast(j);
vis[j] = true;
}
}
}
// 统计答案
int ans = 0;
for (int i = 0; i < n; i++) {
if (dist[i] <= max) ans++;
}
for (int[] info : edges) {
int a = info[0], b = info[1], c = info[2];
int c1 = Math.max(0, max - dist[a]), c2 = Math.max(0, max - dist[b]);
ans += Math.min(c, c1 + c2);
}
return ans;
}
}
```
* 时间复杂度:建图复杂度为 $O(m)$;使用 SPFA 求最短路复杂度为 $O(n \times m)$;统计答案复杂度为 $O(n + m)$。整体复杂度为 $O(n \times m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.882` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/883. 三维形体投影面积（简单）.md | 883. 三维形体投影面积 | https://leetcode-cn.com/problems/projection-area-of-3d-shapes/solution/by-ac_oier-r6hj/ | 简单 | [
"模拟"
] | 在 $n * n$ 的网格 `grid` 中,我们放置了一些与 `x`,`y`,`z` 三轴对齐的 $1 * 1 * 1$ 立方体。
每个值 $v = grid[i][j]$ 表示 $v$ 个正方体叠放在单元格 $(i, j)$ 上。
现在,我们查看这些立方体在 `xy`、`yz` 和 `zx` 平面上的投影。
投影 就像影子,将 三维 形体映射到一个 二维 平面上。从顶部、前面和侧面看立方体时,我们会看到“影子”。
返回 所有三个投影的总面积 。
示例 1:
```
输入:[[1,2],[3,4]]
输出:17
解释:这里有该形体在三个轴对齐平面上的三个投影(“阴影部分”)。
```
示例 2:
```
输入:grid = [[2]]
输出:5
```
示例 3:
```
输入:[[1,0],[0,2]]
输出:8
```
提示:
* $n == grid.length == grid[i].length$
* $1 <= n <= 50$
* $0 <= grid[i][j] <= 50$ | ### 模拟
根据题意进行模拟即可,使用三个变量分别统计三视图的阴影面积:
* `ans1`:统计俯视图的面积,共有 $n * n$ 个位置需要被统计,当任意格子 $g[i][j] > 0$,阴影面积加一;
* `ans2`:统计左视图的面积,共有 $n$ 行需要被统计,每一行对 `ans2` 的贡献为该行的最大高度;
* `ans3`:统计主视图的面积,共有 $n$ 列需要被统计,每一列对 `ans3` 的贡献为该列的最大高度。
代码:
```Java
class Solution {
public int projectionArea(int[][] g) {
int ans1 = 0, ans2 = 0, ans3 = 0;
int n = g.length;
for (int i = 0; i < n; i++) {
int a = 0, b = 0;
for (int j = 0; j < n; j++) {
if (g[i][j] > 0) ans1++;
a = Math.max(a, g[i][j]);
b = Math.max(b, g[j][i]);
}
ans2 += a; ans3 += b;
}
return ans1 + ans2 + ans3;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.883` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/884. 两句话中的不常见单词（简单）.md | 884. 两句话中的不常见单词 | https://leetcode-cn.com/problems/uncommon-words-from-two-sentences/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-wwam/ | 简单 | [
"模拟",
"哈希表"
] | 句子 是一串由空格分隔的单词。每个 单词 仅由小写字母组成。
如果某个单词在其中一个句子中恰好出现一次,在另一个句子中却 没有出现 ,那么这个单词就是 不常见的 。
给你两个 句子 `s1` 和 `s2` ,返回所有 不常用单词 的列表。返回列表中单词可以按 任意顺序 组织。
示例 1:
```
输入:s1 = "this apple is sweet", s2 = "this apple is sour"
输出:["sweet","sour"]
```
示例 2:
```
输入:s1 = "apple apple", s2 = "banana"
输出:["banana"]
```
提示:
* $1 <= s1.length, s2.length <= 200$
* `s1` 和 `s2` 由小写英文字母和空格组成
* `s1` 和 `s2` 都不含前导或尾随空格
* `s1` 和 `s2` 中的所有单词间均由单个空格分隔 | ### 数据结构 + 模拟
根据题意进行模拟即可,先使用「哈希表」对两字符串进行「词频统计」,然后分别从两边的「哈希表」出发,统计符合题意的字符串数量。
或是利用某个单词在一边出现一次,另外一边不曾出现,等价于「某个单词总共只出现一次」。
代码:
```Java
class Solution {
public String[] uncommonFromSentences(String s1, String s2) {
Map<String, Integer> map = new HashMap<>();
String str = s1 + " " + s2;
String[] ss = str.split(" ");
for (String s : ss) map.put(s, map.getOrDefault(s, 0) + 1);
List<String> list = new ArrayList<>();
for (String s : map.keySet()) if (map.get(s) == 1) list.add(s);
return list.toArray(new String[list.size()]);
}
}
```
* 时间复杂度:令 `n` 和 `m` 分别为两字符串长度,复杂度为 $O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.884` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/886. 可能的二分法（中等）.md | 886. 可能的二分法 | https://leetcode.cn/problems/possible-bipartition/solution/by-ac_oier-6j0n/ | 中等 | [
"二分图",
"染色法",
"并查集",
"DFS"
] | 给定一组 `n` 人(编号为 `1, 2, ..., n`), 我们想把每个人分进任意大小的两组。
每个人都可能不喜欢其他人,那么他们不应该属于同一组。
给定整数 `n` 和数组 `dislikes` ,其中 $dislikes[i] = [a_i, b_i]$ ,表示不允许将编号为 $a_i$ 和 $b_i$ 的人归入同一组。
当可以用这种方法将所有人分进两组时,返回 `true`;否则返回 `false`。
示例 1:
```
输入:n = 4, dislikes = [[1,2],[1,3],[2,4]]
输出:true
解释:group1 [1,4], group2 [2,3]
```
示例 2:
```
输入:n = 3, dislikes = [[1,2],[1,3],[2,3]]
输出:false
```
示例 3:
```
输入:n = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]
输出:false
```
提示:
* $1 <= n <= 2000$
* $0 <= dislikes.length <= 10^4$
* $dislikes[i].length = 2$
* $1 <= dislikes[i][j] <= n$
* $a_i < b_i$
* `dislikes` 中每一组都 不同 | ### 染色法
无论是从题目描述和对点边的描述,这都是一道「染色法判定二分图」的模板题。
为了方便,我们令 `dislikes` 为 `ds`,将其长度记为 $m$。
题目要求我们将 $n$ 个点划分到两个集合中,同时我们将每个 $ds[i]$ 看做无向边的话,可知集合内部无边,即所有的边必然横跨两个集合之间。
使用 $ds[i]$ 进行建图,并将两个将要划分出的两个集合分别记为 `A` 和 `B`,我们可以采用「染色」的方式,尝试将所有点进行划分。
构建一个与点数相等的数组 `color`,我们人为规定划分到集合 `A` 的点满足 $color[i] = 1$,划分到集合 `B` 的点满足 $color[i] = 2$,起始有 $color[i] = 0$,代表该点尚未被划分。
随后我们可以实现 `DFS` 函数为 `boolean dfs(int u, int cur)` 含义为尝试将点 `u` 上 `cur` 色。根据定义可知,我们除了需要 `color[u] = cur` 以外,还需要遍历点 `u` 的所有出边(处理其邻点,将其划分到另一集合上),若在处理过程中发生冲突,则返回 `false`,若能顺利染色则返回 `true`。
由于我们固定了颜色编号为 `1` 和 `2`,因此 `cur` 的对立色可统一为 `3 - cur`。
最终,我们根据能否给所有点染色成功来决定答案。
Java 代码:
```Java
class Solution {
int N = 2010, M = 2 * 10010;
int[] he = new int[N], e = new int[M], ne = new int[M], color = new int[N];
int idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
boolean dfs(int u, int cur) {
color[u] = cur;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (color[j] == cur) return false;
if (color[j] == 0 && !dfs(j, 3 - cur)) return false;
}
return true;
}
public boolean possibleBipartition(int n, int[][] ds) {
Arrays.fill(he, -1);
for (int[] info : ds) {
int a = info[0], b = info[1];
add(a, b); add(b, a);
}
for (int i = 1; i <= n; i++) {
if (color[i] != 0) continue;
if (!dfs(i, 1)) return false;
}
return true;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int he[2010], e[2 * 10010], ne[2 * 10010], color[2010], idx = 0;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
bool dfs(int u, int cur) {
color[u] = cur;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (color[j] == cur) return false;
if (color[j] == 0 && !dfs(j, 3 - cur)) return false;
}
return true;
}
bool possibleBipartition(int n, vector<vector<int>>& ds) {
fill(he, he + n + 10, -1);
for (const auto& info : ds) {
int a = info[0], b = info[1];
add(a, b); add(b, a);
}
for (int i = 1; i <= n; i++) {
if (color[i] != 0) continue;
if (!dfs(i, 1)) return false;
}
return true;
}
};
```
Python 代码:
```Python
class Solution:
def possibleBipartition(self, n: int, ds: List[List[int]]) -> bool:
N, M = 2010, 20010
he, e, ne, color = [-1] * N, [0] * M, [0] * M, [0] * N
idx = 0
def add(a, b):
nonlocal idx
e[idx], ne[idx], he[a] = b, he[a], idx
idx += 1
def dfs(u, cur):
color[u] = cur
i = he[u]
while i != -1:
j = e[i]
if color[j] == cur:
return False
if color[j] == 0 and not dfs(j, 3 - cur):
return False
i = ne[i]
return True
for info in ds:
a, b = info[0], info[1]
add(a, b)
add(b, a)
for i in range(1, n + 1):
if color[i] != 0:
continue
if not dfs(i, 1):
return False
return True
```
TypeScript 代码:
```TypeScript
function possibleBipartition(n: number, ds: number[][]): boolean {
const N = 2010, M = 2 * 10010
const he = new Array<number>(N).fill(-1), e = new Array<number>(M).fill(0), ne = new Array<number>(M).fill(0), color = new Array<number>(N).fill(0)
let idx = 0
function add(a: number, b: number): void {
e[idx] = b
ne[idx] = he[a]
he[a] = idx++
}
function dfs(u: number, cur: number): boolean {
color[u] = cur
for (let i = he[u]; i != -1; i = ne[i]) {
const j = e[i];
if (color[j] == cur) return false
if (color[j] == 0 && !dfs(j, 3 - cur)) return false
}
return true
}
for (const info of ds) {
const a = info[0], b = info[1]
add(a, b); add(b, a)
}
for (let i = 1; i <= n; i++) {
if (color[i] != 0) continue
if (!dfs(i, 1)) return false
}
return true
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$
---
### 反向点 + 并查集
我们知道对于 $ds[i] = (a, b)$ 而言,点 `a` 和点 `b` 必然位于不同的集合中,同时由于只有两个候选集合,因此这样的关系具有推断性:即对于 $(a, b)$ 和 $(b, c)$ 可知 `a` 和 `c` 位于同一集合。
因此,我们可以对于每个点 `x` 而言,建议一个反向点 `x + n`:若点 `x` 位于集合 `A` 则其反向点 `x + n` 位于集合 `B`,反之同理。
基于此,我们可以使用「并查集」维护所有点的连通性:边维护变检查每个 $ds[i]$ 的联通关系,若 $ds[i] = (a, b)$ 联通,必然是其反向点联通所导致,必然是此前的其他 $ds[j]$ 导致的关系冲突,必然不能顺利划分成两个集合,返回 `false`,否则返回 `true`。
Java 代码:
```Java
class Solution {
int[] p = new int[4010];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void union(int a, int b) {
p[find(a)] = p[find(b)];
}
boolean query(int a, int b) {
return find(a) == find(b);
}
public boolean possibleBipartition(int n, int[][] ds) {
for (int i = 1; i <= 2 * n; i++) p[i] = i;
for (int[] info : ds) {
int a = info[0], b = info[1];
if (query(a, b)) return false;
union(a, b + n); union(b, a + n);
}
return true;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> p;
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void unionp(int a, int b) {
p[find(a)] = p[find(b)];
}
bool query(int a, int b) {
return find(a) == find(b);
}
bool possibleBipartition(int n, vector<vector<int>>& ds) {
p.resize(2 * n + 1);
for (int i = 1; i <= 2 * n; ++i) p[i] = i;
for (const auto& info : ds) {
int a = info[0], b = info[1];
if (query(a, b)) return false;
unionp(a, b + n);
unionp(b, a + n);
}
return true;
}
};
```
Python 代码:
```Python
class Solution:
def possibleBipartition(self, n: int, ds: List[List[int]]) -> bool:
p = [i for i in range(0, 2 * n + 10)]
def find(x):
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(a, b):
p[find(a)] = p[find(b)]
def query(a, b):
return find(a) == find(b)
for info in ds:
a, b = info[0], info[1]
if query(a, b):
return False
else:
union(a, b + n)
union(b, a + n)
return True
```
TypeScript 代码:
```TypeScript
function possibleBipartition(n: number, ds: number[][]): boolean {
const p = new Array<number>(4010).fill(0)
function find(x: number): number {
if (p[x] != x) p[x] = find(p[x])
return p[x]
}
function union(a: number, b: number): void {
p[find(a)] = p[find(b)]
}
function query(a: number, b: number): boolean {
return find(a) == find(b)
}
for (let i = 1; i <= 2 * n; i++) p[i] = i
for (const info of ds) {
const a = info[0], b = info[1]
if (query(a, b)) return false
union(a, b + n); union(b, a + n)
}
return true
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.886` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/888. 公平的糖果棒交换（简单）.md | 888. 公平的糖果棒交换 | https://leetcode-cn.com/problems/fair-candy-swap/solution/xiang-jie-po-su-jie-fa-cha-zhao-you-hua-9nd9y/ | 简单 | [
"哈希表"
] | 爱丽丝和鲍勃有不同大小的糖果棒:A[i] 是爱丽丝拥有的第 i 根糖果棒的大小,B[j] 是鲍勃拥有的第 j 根糖果棒的大小。
因为他们是朋友,所以他们想交换一根糖果棒,这样交换后,他们都有相同的糖果总量。(一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。)
返回一个整数数组 ans,其中 ans[0] 是爱丽丝必须交换的糖果棒的大小,ans[1] 是 Bob 必须交换的糖果棒的大小。
如果有多个答案,你可以返回其中任何一个。
保证答案存在。
示例 1:
```
输入:A = [1,1], B = [2,2]
输出:[1,2]
```
示例 2:
```
输入:A = [1,2], B = [2,3]
输出:[1,2]
```
示例 3:
```
输入:A = [2], B = [1,3]
输出:[2,3]
```
示例 4:
```
输入:A = [1,2,5], B = [2,4]
输出:[5,4]
```
提示:
* 1 <= A.length <= 10000
* 1 <= B.length <= 10000
* 1 <= A[i] <= 100000
* 1 <= B[i] <= 100000
* 保证爱丽丝与鲍勃的糖果总量不同。
* 答案肯定存在。 | ### 朴素解法
最终目的是让两个数组总和相等。
我们可以先分别求得两个数组总和为 $aSum$ 和 $bSum$。
即有数组总和 $total = aSum + bSum$。
同时得数组目标总和 $target = total / 2$。
当前两个数组与目标总和的差值分别为 $target - aSum$ 和 $target - bSum$。
我们记 $diff = target - aSum$。
对于某个 $a[i]$ 而言,如果 $a[i]$ 能构成答案,那么 `b` 数组中必然存在大小为 $a[i] + diff$ 的值,使得两者交换后,数组总和均为 $target$。
因此我们只需要遍历数组 `a`,查找哪一个 $a[i]$ 使得 $a[i] + diff$ 存在于数组 `b` 即可。
代码:
```Java
class Solution {
public int[] fairCandySwap(int[] a, int[] b) {
int aSum = 0, bSum = 0;
for (int i : a) aSum += i;
for (int i : b) bSum += i;
int total = aSum + bSum, target = total / 2;
int diff = target - aSum;
int[] ans = new int[2];
for (int i : a) {
if (find(b, i + diff)) {
ans[0] = i;
ans[1] = i + diff;
}
}
return ans;
}
boolean find(int[] nums, int target) {
for (int i : nums) {
if (i == target) return true;
}
return false;
}
}
```
* 时间复杂度: 计算总和复杂度为 $O(n)$,找到最终解复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(1)$
---
### 查找优化
上述解法之所以无法做到线性,是因为我们每次都要对数组 `b` 进行扫描,确定 $a[i] + diff$ 是否存在。
我们知道 map/set/数组 都可以实现 $O(1)$ 查找,由于这里明确给出了两个数组中出现的数的范围,因此可以使用数组进行计数。
同时可以优化一下变量的使用,使用一个变量 $diff$ 来计算最终的差异值。
这种优化,是典型的空间换时间做法。
代码:
```Java
class Solution {
public int[] fairCandySwap(int[] a, int[] b) {
// 先求得 a 的总和
int diff = 0;
for (int i : a) diff += i;
// 使用 cnt 统计 b 中的数的出现次数,同时计算 a 总和与 b 总和的差值
int[] cnt = new int[100009];
for (int i : b) {
diff -= i;
cnt[i]++;
}
// 计算出 a 中具体的替换差值是多少
diff /= -2;
int[] ans = new int[2];
for (int i : a) {
int target = i + diff;
// 如果目标替换量在合法范围,并且存在于 b 数组中。说明找到解了
if (target >= 1 && target <= 100000 && cnt[target] > 0) {
ans[0] = i;
ans[1] = target;
break;
}
}
return ans;
}
}
```
* 时间复杂度:计算总和复杂度为 $O(n)$,找到最终解复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:使用 `cnt` 数组进行计数。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.888` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/881-890/890. 查找和替换模式（中等）.md | 890. 查找和替换模式 | https://leetcode.cn/problems/find-and-replace-pattern/solution/by-ac_oier-s4cw/ | 中等 | [
"哈希表",
"模拟"
] | 你有一个单词列表 `words` 和一个模式 `pattern`,你想知道 `words` 中的哪些单词与模式匹配。
如果存在字母的排列 `p` ,使得将模式中的每个字母 `x` 替换为 `p(x)` 之后,我们就得到了所需的单词,那么单词与模式是匹配的。
(回想一下,字母的排列是从字母到字母的双射:每个字母映射到另一个字母,没有两个字母映射到同一个字母。)
返回 `words` 中与给定模式匹配的单词列表。
你可以按任何顺序返回答案。
示例:
```
输入:words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
输出:["mee","aqq"]
解释:
"mee" 与模式匹配,因为存在排列 {a -> m, b -> e, ...}。
"ccc" 与模式不匹配,因为 {a -> c, b -> c, ...} 不是排列。
因为 a 和 b 映射到同一个字母。
```
提示:
* $1 <= words.length <= 50$
* $1 <= pattern.length = words[i].length <= 20$ | ### 哈希表 模拟
根据题意进行模拟即可,使用 `map` 记录具体的映射关系,使用 `vis` 记录哪些字符已被映射,利用字符集大小只有 $26$,我们可以使用数组充当哈希表。
代码:
```Java
class Solution {
public List<String> findAndReplacePattern(String[] ws, String pe) {
List<String> ans = new ArrayList<>();
int[] map = new int[26], vis = new int[26];
for (String s : ws) {
Arrays.fill(map, -1);
Arrays.fill(vis, 0);
boolean ok = true;
for (int i = 0; i < pe.length() && ok; i++) {
int c1 = s.charAt(i) - 'a', c2 = pe.charAt(i) - 'a';
if (map[c1] == -1 && vis[c2] == 0) {
map[c1] = c2; vis[c2] = 1;
} else if (map[c1] != c2) ok = false;
}
if (ok) ans.add(s);
}
return ans;
}
}
```
* 时间复杂度:$O(\sum_{i = 0}^{n}len(ws[i]) + n \times C)$,其中 $C = 26$ 代表字符集大小
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.890` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/891. 子序列宽度之和（困难）.md | 891. 子序列宽度之和 | https://leetcode.cn/problems/sum-of-subsequence-widths/solution/by-ac_oier-6tyk/ | 困难 | [
"数学"
] | 一个序列的 宽度 定义为该序列中最大元素和最小元素的差值。
给你一个整数数组 `nums`,返回 `nums` 的所有非空 子序列 的 宽度之和 。由于答案可能非常大,请返回对 $10^9 + 7$ 取余 后的结果。
子序列 定义为从一个数组里删除一些(或者不删除)元素,但不改变剩下元素的顺序得到的数组。例如,`[3,6,2,7]` 就是数组 `[0,3,1,6,2,2,7]` 的一个子序列。
示例 1:
```
输入:nums = [2,1,3]
输出:6
解释:子序列为 [1], [2], [3], [2,1], [2,3], [1,3], [2,1,3] 。
相应的宽度是 0, 0, 0, 1, 1, 2, 2 。
宽度之和是 6 。
```
示例 2:
```
输入:nums = [2]
输出:0
```
提示:
* $1 <= nums.length <= 10^5$
* $1 <= nums[i] <= 10^5$ | ### 数学
#### 提示一:每个子序列对答案的贡献
对于某个子序列而言,若其最大值为 $a$,最小值为 $b$,则该子序列对答案的贡献为 $(a - b)$。
我们有若干个子序列,即有若干个 $(a - b)$,答案为所有 $(a - b)$ 之和,我们称一个 $(a - b)$ 为 `item`。
#### 提示二:每个 $nums[i]$ 参与了多少个 `item` 的组成,在最终展开式中又是如何
对于每个 $(a - b)$ 而言,`a` 和 `b` 均必然是具体的 $nums[i]$。
同时易知若 $nums[i]$ 作为了 $k$ 个子序列的最小值,那么在最终表达式展开中,必然有 $k$ 个 $-nums[i]$;同理若 $nums[i]$ 作为了 $k$ 个子序列的最大值,那么在最终表达式展开中,必然有 $k$ 个 $nums[i]$。
#### 提示三:统计每个 $nums[i]$ 作为最值时,有多少个子序列
先不考虑 $nums[i]$ 的重复问题。
若 $nums[i]$ 作为子序列最小值时,首先 $nums[i]$ 必选,小于 $nums[i]$ 的必不选,而大于 $nums[i]$ 的可选可不选,组合个数取决于大于 $nums[i]$ 的数的个数,假设有 $k$ 个,那么根据组合数原理,共有 $2^k$ 个组合,即共有 $2^k$ 个子序列。此时 $nums[i]$ 对答案的贡献为 $2^k \times (-nums[i])$。
同理,$nums[i]$ 作为子序列最大值时,子序列个数取决于小于 $nums[i]$ 的数的个数,假设有 $k$ 个,此时 $nums[i]$ 对答案的贡献为 $2^k \times nums[i]$。
#### 提示四:如何快速得知比 $nums[i]$ 大/小 的数的个数
排序。
#### 提示五:$nums[i]$ 的重复问题
无论是将 $nums[i]$ 视作最大值还是最小值,我们的组合数均取决于某一侧的数的个数,因此不会答案正确性产生影响。
#### 提示六:$2^k$ 操作的重复计算问题
将 $nums[i]$ 视作最值,我们都需要统计两边数所产生的组合数个数,因此即使对于单个用例都会面临重复计算某个 $2^k$ 的问题(对称性)。
同时对于跨样例而言,我们仍会重复计算某些 $2^k$(尤其是较小的 $k$ 值),为避免重复计算,我们可以通过打表预处理的方式算得所有可能要用到 $2^k$ 结果,在使用的时候直接通过查表取得。
Java 代码:
```Java
class Solution {
static int N = 100010, MOD = (int)1e9+7;
static long[] p = new long[N];
static {
p[0] = 1;
for (int i = 1; i < N; i++) p[i] = p[i - 1] * 2 % MOD;
}
public int sumSubseqWidths(int[] nums) {
int n = nums.length;
long ans = 0;
Arrays.sort(nums);
for (int i = 0; i < n; i++) {
ans += (p[i] * nums[i]) % MOD;
ans %= MOD;
ans -= (p[n - i - 1] * nums[i]) % MOD;
ans %= MOD;
}
return (int) ans;
}
}
```
TypeScript 代码:
```TypeScript
function sumSubseqWidths(nums: number[]): number {
let n = nums.length, mod = 1000000007, ans = 0
const p = new Array<number>(n + 10).fill(1)
for (let i = 1; i <= n; i++) p[i] = p[i - 1] * 2 % mod
nums.sort((a,b)=>a-b)
for (let i = 0; i < n; i++) {
ans += p[i] * nums[i] % mod
ans %= mod
ans -= p[n - i - 1] * nums[i] % mod
ans %= mod
}
return ans
}
```
Python3 代码:
```Python3
class Solution:
def sumSubseqWidths(self, nums: List[int]) -> int:
n, mod, ans = len(nums), 1000000007, 0
p = [1] * (n + 10)
for i in range(1, n + 1):
p[i] = p[i - 1] * 2 % mod
nums.sort()
for i in range(n):
ans = ans + p[i] * nums[i] % mod
ans = ans - p[n - i - 1] * nums[i] % mod
return ans % mod
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.891` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/895. 最大频率栈（困难）.md | 895. 最大频率栈 | https://leetcode.cn/problems/maximum-frequency-stack/solution/by-ac_oier-tquk/ | 困难 | [
"哈希表",
"模拟"
] | 设计一个类似堆栈的数据结构,将元素推入堆栈,并从堆栈中弹出出现频率最高的元素。
实现 `FreqStack` 类:
* `FreqStack()` 构造一个空的堆栈。
* `void push(int val)` 将一个整数 `val` 压入栈顶。
* `int pop()` 删除并返回堆栈中出现频率最高的元素。
如果出现频率最高的元素不只一个,则移除并返回最接近栈顶的元素。
示例 1:
```
输入:
["FreqStack","push","push","push","push","push","push","pop","pop","pop","pop"],
[[],[5],[7],[5],[7],[4],[5],[],[],[],[]]
输出:[null,null,null,null,null,null,null,5,7,5,4]
解释:
FreqStack = new FreqStack();
freqStack.push (5);//堆栈为 [5]
freqStack.push (7);//堆栈是 [5,7]
freqStack.push (5);//堆栈是 [5,7,5]
freqStack.push (7);//堆栈是 [5,7,5,7]
freqStack.push (4);//堆栈是 [5,7,5,7,4]
freqStack.push (5);//堆栈是 [5,7,5,7,4,5]
freqStack.pop ();//返回 5 ,因为 5 出现频率最高。堆栈变成 [5,7,5,7,4]。
freqStack.pop ();//返回 7 ,因为 5 和 7 出现频率最高,但7最接近顶部。堆栈变成 [5,7,5,4]。
freqStack.pop ();//返回 5 ,因为 5 出现频率最高。堆栈变成 [5,7,4]。
freqStack.pop ();//返回 4 ,因为 4, 5 和 7 出现频率最高,但 4 是最接近顶部的。堆栈变成 [5,7]。
```
提示:
* $0 <= val <= 10^9$
* `push` 和 `pop` 的操作数不大于 $2 \times 10^4$
* 输入保证在调用 `pop` 之前堆栈中至少有一个元素 | ### 哈希表
这是一道很纯的哈希表题儿。
首先,我们容易想到建立 **第一个哈希表 `cnts` 用于记录某个数值的出现次数,`cnts[val] = c` 含义为数值 `val` 当前在栈中的出现次数为 `c`。我们称该哈希表为「计数哈希表」**。
再结合每次 `pop` 需要返回「频率最大的元素,若有多个则返回最考虑栈顶的一个」的要求,我们还可以 **建立第二个哈希 `map`,该哈希表以「出现次数 `c`」为键,以「出现次数均为 `c` 的元素序列」为值,`map[c] = A = [...]` 含义为出现次数为 `c` 的序列为 `A`,并且序列 `A` 中的结尾元素为出现次数为 `c` 的所有元素中最靠近栈顶的元素。我们称该哈希表为「分桶哈希表」**。
最后再额外使用一个变量 `max` 记录当前最大出现频数,不难发现,`max` 必然是以步长 $\pm 1$ 进行变化(当出现次数为 `max` 的元素被 `pop` 掉了一个后,必然剩下 `max - 1` 个),因此当我们在某次 `pop` 操作后发现出现次数为 `max` 的集合为空时,对 `max` 进行自减操作即可。
将题目给的样例作为 🌰 ,大家可以看看 `cnts`、`map` 和 `max` 三者如何变化,以及 `pop` 的更新逻辑:
Java 代码:
```Java
class FreqStack {
Map<Integer, List<Integer>> map = new HashMap<>();
Map<Integer, Integer> cnts = new HashMap<>();
int max;
public void push(int val) {
cnts.put(val, cnts.getOrDefault(val, 0) + 1);
int c = cnts.get(val);
List<Integer> list = map.getOrDefault(c, new ArrayList<>());
list.add(val);
map.put(c, list);
max = Math.max(max, c);
}
public int pop() {
List<Integer> list = map.get(max);
int ans = list.remove(list.size() - 1);
cnts.put(ans, cnts.get(ans) - 1);
if (list.size() == 0) max--;
return ans;
}
}
```
C++ 代码:
```C++
class FreqStack {
public:
unordered_map<int, int> freq;
unordered_map<int, vector<int>> m;
int maxv = 0;
void push(int val) {
maxv = max(maxv, ++freq[val]);
m[freq[val]].push_back(val);
}
int pop() {
int x = m[maxv].back();
m[maxv].pop_back();
if (m[freq[x]--].empty()) maxv--;
return x;
}
};
```
Python 代码:
```Python
class FreqStack:
def __init__(self):
self.cnts = defaultdict(int)
self.map = defaultdict(list)
self.mv = 0
def push(self, val: int) -> None:
self.cnts[val] += 1
c = self.cnts[val]
self.map[c].append(val)
self.mv = max(self.mv, c)
def pop(self) -> int:
ans = self.map[self.mv].pop()
self.cnts[ans] -= 1
self.mv -= 0 if self.map[self.mv] else 1
return ans
```
TypeScript 代码:
```TypeScript
class FreqStack {
map: Map<number, Array<number>> = new Map<number, Array<number>>()
cnst: Map<number, number> = new Map<number, number>()
max: number = 0
push(val: number): void {
if (!this.cnst.has(val)) this.cnst.set(val, 0)
this.cnst.set(val, this.cnst.get(val) + 1)
const c = this.cnst.get(val)
if (!this.map.has(c)) this.map.set(c, new Array<number>())
this.map.get(c).push(val)
this.max = Math.max(this.max, c)
}
pop(): number {
const ans = this.map.get(this.max).pop()
if (this.map.get(this.max).length == 0) this.max--
this.cnst.set(ans, this.cnst.get(ans) - 1)
return ans
}
}
```
* 时间复杂度:所有操作均为 $O(1)$
* 空间复杂度:所有入栈的节点最多会被存储两次,一次在计数哈希表中,一次在分桶哈希表中,复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.895` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/896. 单调数列（简单）.md | 896. 单调数列 | https://leetcode-cn.com/problems/monotonic-array/solution/wei-shi-yao-yi-ci-bian-li-yao-bi-liang-c-uglp/ | 简单 | [
"数组",
"模拟"
] | 如果数组是单调递增或单调递减的,那么它是单调的。
如果对于所有 i <= j,A[i] <= A[j],那么数组 A 是单调递增的。 如果对于所有 i <= j,A[i]> = A[j],那么数组 A 是单调递减的。
当给定的数组 A 是单调数组时返回 true,否则返回 false。
示例 1:
```
输入:[1,2,2,3]
输出:true
```
示例 2:
```
输入:[6,5,4,4]
输出:true
```
示例 3:
```
输入:[1,3,2]
输出:false
```
示例 4:
```
输入:[1,2,4,5]
输出:true
```
示例 5:
```
输入:[1,1,1]
输出:true
```
提示:
* 1 <= A.length <= 50000
* -100000 <= A[i] <= 100000 | ### 朴素解法(所谓的两次遍历)
两次遍历,分别检查是否为单调递增和单调递减。
```java []
class Solution {
public boolean isMonotonic(int[] a) {
return check(a, true) || check(a, false);
}
boolean check(int[] a, boolean flag) {
for (int i = 0; i < a.length - 1; i++) {
if (flag) {
if (a[i] > a[i + 1]) return false;
} else {
if (a[i] < a[i + 1]) return false;
}
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
***
### 朴素解法(所谓的一次遍历)
一次遍历。
同时为了防止扫完整个数组,增加一个提前 return 的逻辑:
```java
class Solution {
public boolean isMonotonic(int[] a) {
boolean up = true, down = true;
for (int i = 0; i < a.length - 1; i++) {
if (a[i] > a[i + 1]) up = false;
if (a[i] < a[i + 1]) down = false;
if (!up && !down) return false;
}
return up || down;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
***
### 总结
事实上,上述两种解法其实并**不应该区分为「一次遍历」与「两次遍历」**。
**我们应该用「对数组的访问次数」来定义遍历多少次,而不是「利用 for 循环的个数」来定义。上述无论那种方法,对数组访问次数都是一样的。**
而在不对解法二进行剪枝的情况下,要比解法一慢。主要是因为解法一明确了是「递增」还是「递减」之后,在循环内部做了剪枝。
当我们对解法二进行同样的内部剪枝之后,其实和解法一应该是类似的。
前三次提交是保留 `if (!up && !down) return false;` 的提交 (1 ms)
后三次提交是不保留 `if (!up && !down) return false;` 的提交记录 (2 ms)
简单题,大家就看个乐呵 ~
***
### 有趣的实验
评论区有位同学提出了一个很有意思的问题:如果数据量很大,大到内存都无法一次完全读入,那么一个循环里两次重复读应该比两次循环要快得多了吧?
我理解 ta 的意思是,每次读取值都算一次 IO 成本的话,一个循环里两次重复读的的成本应该是要**小于**比两次循环的成本吧?
因此有了以下的测试代码:
```java
class Solution {
// 统计「二次循环」的访问次数
int cnt;
public boolean isMonotonic(int[] a) {
cnt = 0;
// 这里不直接写成「短路与」进行返回,确保两个循环都会被执行
boolean t = check(a, true), u = check(a, false);
System.out.println(cnt);
return t || u;
}
boolean check(int[] a, boolean flag) {
for (int i = 0; i < a.length - 1; i++) {
if (flag) {
if (getVal(a, i) > getVal(a, i + 1)) return false;
} else {
if (getVal(a, i) < getVal(a, i + 1)) return false;
}
}
return true;
}
int getVal(int[] a, int idx) {
cnt++;
return a[idx];
}
}
```
对于样例数据的输出:8 8 6 8 8
```java
class Solution {
// 统计「一次循环」的访问次数
int cnt;
public boolean isMonotonic(int[] a) {
cnt = 0;
boolean up = true, down = true;
for (int i = 0; i < a.length - 1; i++) {
if (getVal(a, i) > getVal(a, i + 1)) up = false;
if (getVal(a, i) < getVal(a, i + 1)) down = false;
if (!up && !down) break;
}
System.out.println(cnt);
return up || down;
}
int getVal(int[] a, int idx) {
cnt++;
return a[idx];
}
}
```
对于样例数据的输出:12 12 8 12 8
**结论:二次循环的剪枝效果应该是要比一次循环要更好点(更加直接)。如果还有人坚持「所谓的一次循环」要优于「所谓的二次循环」,实验代码就是最好的证明。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.896` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/897. 递增顺序搜索树（简单）.md | 897. 递增顺序搜索树 | https://leetcode-cn.com/problems/increasing-order-search-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-yc8l/ | 简单 | [
"树的遍历",
"递归",
"非递归"
] | 给你一棵二叉搜索树,请你 按中序遍历 将其重新排列为一棵递增顺序搜索树,使树中最左边的节点成为树的根节点,并且每个节点没有左子节点,只有一个右子节点。
示例 1:
```
输入:root = [5,3,6,2,4,null,8,1,null,null,null,7,9]
输出:[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
```
示例 2:
```
输入:root = [5,1,7]
输出:[1,null,5,null,7]
```
提示:
* 树中节点数的取值范围是 [1, 100]
* 0 <= Node.val <= 1000 | ### 基本思路
由于给定的树是一棵「二叉搜索树」,因此只要对其进行「中序遍历」即可得到有序列表,再根据有序列表构建答案即可。
而二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。
---
### 递归
递归写法十分简单,属于树的遍历中最简单的实现方式。
代码:
```Java
class Solution {
List<TreeNode> list = new ArrayList<>();
public TreeNode increasingBST(TreeNode root) {
dfs(root);
TreeNode dummy = new TreeNode(-1);
TreeNode cur = dummy;
for (TreeNode node : list) {
cur.right = node;
node.left = null;
cur = node;
}
return dummy.right;
}
void dfs(TreeNode root) {
if (root == null) return ;
dfs(root.left);
list.add(root);
dfs(root.right);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 迭代
迭代其实就是使用「栈」来模拟递归过程,也属于树的遍历中的常见实现形式。
一般简单的面试中如果问到树的遍历,面试官都不会对「递归」解法感到满意,因此掌握「迭代/非递归」写法同样重要。
代码:
```Java
class Solution {
List<TreeNode> list = new ArrayList<>();
public TreeNode increasingBST(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
while (root != null || !d.isEmpty()) {
while (root != null) {
d.add(root);
root = root.left;
}
root = d.pollLast();
list.add(root);
root = root.right;
}
TreeNode dummy = new TreeNode(-1);
TreeNode cur = dummy;
for (TreeNode node : list) {
cur.right = node;
node.left = null;
cur = node;
}
return dummy.right;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.897` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/891-900/899. 有序队列（困难）.md | 899. 有序队列 | https://leetcode.cn/problems/orderly-queue/solution/by-ac_oier-443m/ | 困难 | [
"构造",
"最小表示法"
] | 给定一个字符串 `s` 和一个整数 `k` 。你可以从 `s` 的前 `k` 个字母中选择一个,并把它加到字符串的末尾。
返回 在应用上述步骤的任意数量的移动后,字典上最小的字符串 。
示例 1:
```
输入:s = "cba", k = 1
输出:"acb"
解释:
在第一步中,我们将第一个字符(“c”)移动到最后,获得字符串 “bac”。
在第二步中,我们将第一个字符(“b”)移动到最后,获得最终结果 “acb”。
```
示例 2:
```
输入:s = "baaca", k = 3
输出:"aaabc"
解释:
在第一步中,我们将第一个字符(“b”)移动到最后,获得字符串 “aacab”。
在第二步中,我们将第三个字符(“c”)移动到最后,获得最终结果 “aaabc”。
```
提示:
* $1 <= k <= S.length <= 1000$
* `s` 只由小写字母组成。 | ### 最小表示法
当 $k > 1$ 时,我们能够构造出任意的字符串方案,因此当 $k > 1$ 时,我们可以直接通过对字符串排序来得到答案,复杂度为 $O(n\log{n})$。
当 $k = 1$ 时,我们共有 $n$ 种候选方案(将字符串 `s` 看作一个首尾相接的循环字符串,共有 $n$ 个起点可枚举),枚举过程中需要与当前最优的方案进行比较,比较复杂度为 $O(n)$,因此整体复杂度为 $O(n^2)$。
上述的做法已经可以通过本题,可以看出瓶颈在于对 $k = 1$ 的处理。
而实际上,对于给定字符串 `s`,求其循环同构的所有方案中字典序最小的方案,可以使用「最小表示法」来做,复杂度为 $O(n)$。
最小表示法将「方案比较」与「构造更优方案」进行结合:假设我们当前有两字符串 `a` 和 `b` 需要进行比较,其均为原串 `s` 的循环同构具体方案。假设 `a` 和 `b` 分别对应了原串下标为 `i` 和 `j` 的具体方案,且假设两字符串前 $k$ 个字符均相同。
当两字符串第一个不同的字符大小关系为 $cs[i + k] > cs[j + k]$ 时,可以发现在下标范围 $idx \in [i, i + k]$ 作为起点的新方案 `a'` 必然不会是最优方案,即必然存在下标范围 $idx - i + j$ 作为起点的新方案 `b'` 比其更优,因此我们可以直接从 $i + k + 1$ 位置构造新的更优方案,并与 `b` 再次比较。而 $cs[i + k] < cs[j + k]$ 的分析同理。
> 更为直白的表述为:分别从 `i` 和 `j` 作为起点的字符串 `a` 和 `b`,其前 $k$ 个字符相同,而当 $cs[i + k] > cs[j + k]$ 时,我们可以明确「以 $i + p$ 为起点的字符串」必不可能比「以 $j + p$ 为起点的字符串」更优,其中 $p \in [0, k]$。
Java 代码:
```Java
class Solution {
public String orderlyQueue(String s, int _k) {
char[] cs = s.toCharArray();
if (_k == 1) {
int i = 0, j = 1, k = 0, n = cs.length;
while (i < n && j < n && k < n) {
char a = cs[(i + k) % n], b = cs[(j + k) % n];
if (a == b) k++;
else {
if (a > b) i += k + 1;
else j += k + 1;
if (i == j) i++;
k = 0;
}
}
i = Math.min(i, j);
return s.substring(i) + s.substring(0, i);
} else {
Arrays.sort(cs);
return String.valueOf(cs);
}
}
}
```
TypeScript 代码:
```TypeScript
function orderlyQueue(s: string, _k: number): string {
if (_k == 1) {
let i = 0, j = 1, k = 0, n = s.length
while (i < n && j < n && k < n) {
const a = s[(i + k) % n], b = s[(j + k) % n]
if (a == b) k++;
else {
if (a > b) i += k + 1
else j += k + 1
if (i == j) i++
k = 0
}
}
i = Math.min(i, j)
return s.substring(i) + s.substring(0, i)
} else {
return [...s].sort().join('');
}
};
```
* 时间复杂度:当 $k = 1$ 时,复杂度为 $O(n)$;当 $k > 1$ 时,复杂度为 $O(n\log{n})$
* 空间复杂度:当 $k > 1$ 时,需要使用额外的排序空间 $O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.899` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/901. 股票价格跨度（中等）.md | 901. 股票价格跨度 | https://leetcode.cn/problems/online-stock-span/solution/by-ac_oier-m8g7/ | 中等 | [
"分块",
"单调栈"
] | 编写一个 `StockSpanner` 类,它收集某些股票的每日报价,并返回该股票当日价格的跨度。
今天股票价格的跨度被定义为股票价格小于或等于今天价格的最大连续日数(从今天开始往回数,包括今天)。
例如,如果未来 `7` 天股票的价格是 `[100, 80, 60, 70, 60, 75, 85]`,那么股票跨度将是 `[1, 1, 1, 2, 1, 4, 6]`。
示例:
```
输入:["StockSpanner","next","next","next","next","next","next","next"], [[],[100],[80],[60],[70],[60],[75],[85]]
输出:[null,1,1,1,2,1,4,6]
解释:
首先,初始化 S = StockSpanner(),然后:
S.next(100) 被调用并返回 1,
S.next(80) 被调用并返回 1,
S.next(60) 被调用并返回 1,
S.next(70) 被调用并返回 2,
S.next(60) 被调用并返回 1,
S.next(75) 被调用并返回 4,
S.next(85) 被调用并返回 6。
注意 (例如) S.next(75) 返回 4,因为截至今天的最后 4 个价格
(包括今天的价格 75) 小于或等于今天的价格。
```
提示:
* 调用 `StockSpanner.next(int price)` 时,将有 $1 <= price <= 10^5$。
* 每个测试用例最多可以调用 `10000` 次 `StockSpanner.next`。
* 在所有测试用例中,最多调用 `150000` 次 `StockSpanner.next`。
* 此问题的总时间限制减少了 `50%`。 | ### 分块
又名优雅的暴力。
这是一道在线问题,在调用 `next` 往数据流存入元素的同时,返回连续段不大于当前元素的数的个数。
一个朴素的想法是:使用数组 `nums` 将所有 `price` 进行存储,每次返回时往前找到第一个不满足要求的位置,并返回连续段的长度。
但对于 $10^4$ 的调用次数来看,该做法的复杂度为 $O(n^2)$,计算量为 $10^8$,不满足 `OJ` 要求。
实际上我们可以利用「分块」思路对其进行优化,将与连续段的比较转换为与最值的比较。
具体的,我们仍然使用 `nums` 对所有的 `price` 进行存储,同时使用 `region` 数组来存储每个连续段的最大值,其中 $region[loc] = x$ 含义为块编号为 `loc` 的最大值为 `x`,其中块编号 `loc` 块对应了数据编号 `idx` 的范围 $[(loc - 1) \times len + 1, loc \times len]$。
对于 `next` 操作而言,除了直接更新数据数组 `nums[++idx] = price` 以外,我们还需要更新 `idx` 所在块的最值 `region[loc]`,然后从当前块 `loc` 开始往前扫描其余块,使用 `left` 和 `right` 代指当前处理到的块的左右端点,若当前块满足 `region[loc] <= price`,说明块内所有元素均满足要求,直接将当前块 `loc` 所包含元素个数累加到答案中,直到遇到不满足的块或达到块数组边界,若存在遇到不满足要求的块,再使用 `right` 和 `left` 统计块内满足要求 `nums[i] <= price` 的个数。
对于块个数和大小的设定,是运用分块降低复杂度的关键,数的个数为 $10^4$,我们可以设定块大小为 $\sqrt{n} = 100$,这样也限定了块的个数为 $\sqrt{n} = 100$ 个。这样对于单次操作而言,我们最多遍历进行 $\sqrt{n}$ 次的块间操作,同时最多进行一次块内操作,整体复杂度为 $O(\sqrt{n})$,单次 `next` 操作计算量为 $2 \times 10^2$ 以内,单样例计算量为 $2 \times 10^6$,可以过。
为了方便,我们令块编号 `loc` 和数据编号 `idx` 均从 $1$ 开始;同时为了防止每个样例都 `new` 大数组,我们采用 `static` 优化,并在 `StockSpanner` 的初始化中做重置工作。
Java 代码:
```Java
class StockSpanner {
static int N = 10010, len = 100, idx = 0;
static int[] nums = new int[N], region = new int[N / len + 10];
public StockSpanner() {
for (int i = 0; i <= getIdx(idx); i++) region[i] = 0;
idx = 0;
}
int getIdx(int x) {
return (x - 1) / len + 1;
}
int query(int price) {
int ans = 0, loc = getIdx(idx), left = (loc - 1) * len + 1, right = idx;
while (loc >= 1 && region[loc] <= price) {
ans += right - left + 1;
loc--; right = left - 1; left = (loc - 1) * len + 1;
}
for (int i = right; loc >= 1 && i >= left && nums[i] <= price; i--) ans++;
return ans;
}
public int next(int price) {
nums[++idx] = price;
int loc = getIdx(idx);
region[loc] = Math.max(region[loc], price);
return query(price);
}
}
```
TypeScript 代码:
```TypeScript
class StockSpanner {
N: number = 10010; sz: number = 100; idx: number = 0
nums: number[] = new Array<number>(this.N).fill(0);
region = new Array<number>(Math.floor(this.N / this.sz) + 10).fill(0)
getIdx(x: number): number {
return Math.floor((x - 1) / this.sz) + 1
}
query(price: number): number {
let ans = 0, loc = this.getIdx(this.idx), left = (loc - 1) * this.sz + 1, right = this.idx
while (loc >= 1 && this.region[loc] <= price) {
ans += right - left + 1
loc--; right = left - 1; left = (loc - 1) * this.sz + 1
}
for (let i = right; loc >= 1 && i >= left && this.nums[i] <= price; i--) ans++
return ans
}
next(price: number): number {
this.nums[++this.idx] = price
const loc = this.getIdx(this.idx)
this.region[loc] = Math.max(this.region[loc], price)
return this.query(price)
}
}
```
Python3 代码:
```Python
class StockSpanner:
def __init__(self):
self.N, self.sz, self.idx = 10010, 110, 0
self.nums, self.region = [0] * self.N, [0] * (self.N // self.sz + 10)
def next(self, price: int) -> int:
def getIdx(x):
return (x - 1) // self.sz + 1
def query(price):
ans, loc = 0, getIdx(self.idx)
left, right = (loc - 1) * self.sz + 1, self.idx
while loc >= 1 and self.region[loc] <= price:
ans += right - left + 1
loc -= 1
right, left = left - 1, (loc - 1) * self.sz + 1
while loc >= 1 and right >= left and self.nums[right] <= price:
right, ans = right - 1, ans + 1
return ans
self.idx += 1
loc = getIdx(self.idx)
self.nums[self.idx] = price
self.region[loc] = max(self.region[loc], price)
return query(price)
```
* 时间复杂度:由于使用了 `static` 优化,`StockSpanner` 初始化时,需要对上一次使用的块进行重置,复杂度为 $O(\sqrt{n})$;由于块大小和数量均为 $\sqrt{n}$,`next` 操作复杂度为 $O(\sqrt{n})$
* 空间复杂度:$O(n)$
---
### 单调栈
另外一个容易想到的想法是使用「单调栈」,栈内以二元组 $(idx, price)$ 形式维护比当前元素 `price` 大的元素。
每次执行 `next` 操作时,从栈顶开始处理,将所有满足「不大于 `price`」的元素进行出栈,从而找到当前元素 `price` 左边最近一个比其大的位置。
Java 代码:
```Java
class StockSpanner {
Deque<int[]> d = new ArrayDeque<>();
int cur = 0;
public int next(int price) {
while (!d.isEmpty() && d.peekLast()[1] <= price) d.pollLast();
int prev = d.isEmpty() ? -1 : d.peekLast()[0], ans = cur - prev;
d.addLast(new int[]{cur++, price});
return ans;
}
}
```
TypeScript 代码:
```TypeScript
class StockSpanner {
stk = new Array<Array<number>>(10010).fill([0, 0])
he = 0; ta = 0; cur = 0
next(price: number): number {
while (this.he < this.ta && this.stk[this.ta - 1][1] <= price) this.ta--
const prev = this.he >= this.ta ? -1 : this.stk[this.ta - 1][0], ans = this.cur - prev
this.stk[this.ta++] = [this.cur++, price]
return ans
}
}
```
Python3 代码:
```Python
class StockSpanner:
def __init__(self):
self.stk = []
self.cur = 0
def next(self, price: int) -> int:
while self.stk and self.stk[-1][1] <= price:
self.stk.pop()
prev = -1 if not self.stk else self.stk[-1][0]
ans = self.cur - prev
self.stk.append([self.cur, price])
self.cur += 1
return ans
```
* 时间复杂度:`next` 操作的均摊复杂度为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.901` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/902. 最大为 N 的数字组合（困难）.md | 902. 最大为 N 的数字组合 | https://leetcode-cn.com/problems/numbers-at-most-n-given-digit-set/solution/by-ac_oier-8k27/ | 困难 | [
"动态规划",
"二分",
"数位 DP"
] | 给定一个按 非递减顺序 排列的数字数组 `digits`。你可以用任意次数 $digits[i]$ 来写的数字。例如,如果 $digits = [1,3,5]$,我们可以写数字,如 `'13'`, `'551'`, 和 `'1351315'`。
返回 **可以生成的小于或等于给定整数** $n$ 的正整数的个数 。
示例 1:
```
输入:digits = ["1","3","5","7"], n = 100
输出:20
解释:
可写出的 20 个数字是:
1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.
```
示例 2:
```
输入:digits = ["1","4","9"], n = 1000000000
输出:29523
解释:
我们可以写 3 个一位数字,9 个两位数字,27 个三位数字,
81 个四位数字,243 个五位数字,729 个六位数字,
2187 个七位数字,6561 个八位数字和 19683 个九位数字。
总共,可以使用D中的数字写出 29523 个整数。
```
示例 3:
```
输入:digits = ["7"], n = 8
输出:1
```
提示:
* $1 <= digits.length <= 9$
* $digits[i].length == 1$
* $digits[i]$ 是从 `'1'` 到 `'9'` 的数
* `digits` 中的所有值都 不同
* `digits` 按 非递减顺序 排列
* $1 <= n <= 10^9$ | ### 数位 DP + 二分
这是一道「数位 DP」的经典运用题。
由于题目给定的 `digits` 不包含 $0$,因此相当于只需要回答使用 `digits` 的数值能够覆盖 $[1, x]$ 范围内的多少个数字。
起始先将字符串数组 `digits` 转为数字数组 `nums`,假定 `nums` 的长度为 $m$,然后考虑如何求得 $[1, x]$ 范围内合法数字的个数。
假定我们存在函数 `int dp(int x)` 函数,能够返回区间 $[1, x]$ 内合法数的个数,那么配合「容斥原理」我们便能够回答任意区间合法数的查询:
$$
ans_{(l, r)} = dp(r) - dp(l - 1)
$$
对于本题,查询区间的左端点固定为 $1$,同时 $dp(0) = 0$,因此答案为 $dp(x)$。
然后考虑如何实现 `int dp(int x)` 函数,我们将组成 $[1, x]$ 的合法数分成三类:
* 位数和 $x$ 相同,且最高位比 $x$ 最高位要小的,这部分统计为 `res1`;
* 位数和 $x$ 相同,且最高位与 $x$ 最高位相同的,这部分统计为 `res2`;
* 位数比 $x$ 少,这部分统计为 `res3`。
其中 `res1` 和 `res3` 求解相对简单,重点落在如何求解 `res2` 上。
**对 $x$ 进行「从高到低」的处理(假定 $x$ 数位为 $n$),对于第 $k$ 位而言($k$ 不为最高位),假设在 $x$ 中第 $k$ 位为 $cur$,那么为了满足「大小限制」关系,我们只能在 $[1, cur - 1]$ 范围内取数,同时为了满足「数字只能取自 `nums`」的限制,因此我们可以利用 `nums` 本身有序,对其进行二分,找到满足 `nums[mid] <= cur` 的最大下标 $r$,根据 $nums[r]$ 与 $cur$ 的关系进行分情况讨论:**
* $nums[r] = cur$: 此时位置 $k$ 共有 $r$ 种选择,而后面的每个位置由于 $nums[i]$ 可以使用多次,每个位置都有 $m$ 种选择,共有 $n - p$ 个位置,因此该分支往后共有 $r * m^{n - p}$ 种合法方案。且由于 $nums[r] = cur$,往后还有分支可决策(需要统计),因此需要继续处理;
* $nums[r] < cur$:此时算上 $nums[r]$,位置 $k$ 共有 $r + 1$ 种选择,而后面的每个位置由于 $nums[i]$ 可以使用多次,每个位置都有 $m$ 种选择,共有 $n - p$ 个位置,因此该分支共有 $(r + 1) * m^{n - p}$ 种合法方案,由于 $nums[r] < cur$,往后的方案数(均满足小于关系)已经在这次被统计完成,累加后进行 `break`;
* $nums[r] > cur$:该分支往后不再满足「大小限制」要求,合法方案数为 $0$,直接 `break`。
其他细节:实际上,我们可以将 `res1` 和 `res2` 两种情况进行合并处理。
代码:
```Java
class Solution {
int[] nums;
int dp(int x) {
List<Integer> list = new ArrayList<>();
while (x != 0) {
list.add(x % 10);
x /= 10;
}
int n = list.size(), m = nums.length, ans = 0;
// 位数和 x 相同
for (int i = n - 1, p = 1; i >= 0; i--, p++) {
int cur = list.get(i);
int l = 0, r = m - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] <= cur) l = mid;
else r = mid - 1;
}
if (nums[r] > cur) {
break;
} else if (nums[r] == cur) {
ans += r * (int) Math.pow(m, (n - p));
if (i == 0) ans++;
} else if (nums[r] < cur) {
ans += (r + 1) * (int) Math.pow(m, (n - p));
break;
}
}
// 位数比 x 少的
for (int i = 1, last = 1; i < n; i++) {
int cur = last * m;
ans += cur; last = cur;
}
return ans;
}
public int atMostNGivenDigitSet(String[] digits, int max) {
int n = digits.length;
nums = new int[n];
for (int i = 0; i < n; i++) nums[i] = Integer.parseInt(digits[i]);
return dp(max);
}
}
```
* 时间复杂度:由于 `digits` 最多存在 $9$ 个元素,因此二分的复杂度可以忽略,整体复杂度为 $O(\log{n})$
* 空间复杂度:$O(C)$
---
### 总结
数位 DP 的难度取决于「限制条件」的多少,而 LC 上仅有的几道数位 DP 题目限制条件都很少,且不需要引入额外的数据结构来记录状态,因此都属于数位 DP 的入门难度(LC 难度均为 Hard)。
几乎所有的数位 DP 问题都可以归纳到上述的解法 :「将问题抽象为求解一个 $[0, x]$ / $[1, x]$ 范围方案数的方法」->「对方案数统计根据 位数 来分情况讨论:数位相等的情况 + 数位不等情况」->「统计数位相等的方案数时,需要按位处理,并根据限制条件做逻辑;统计数位不等的方案数时,通常要做一些预处理,然后配合乘法原理直接算得」。
在还没卷到数位 DP 烂大街的现在,掌握此类求解方式单一,普遍定位为「困难」的数位 DP 类型,还是极具性价比的。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.902` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/904. 水果成篮（中等）.md | 904. 水果成篮 | https://leetcode.cn/problems/fruit-into-baskets/solution/by-ac_oier-skgk/ | 中等 | [
"双指针",
"模拟",
"滑动窗口"
] | 你正在探访一家农场,农场从左到右种植了一排果树。
这些树用一个整数数组 `fruits` 表示,其中 `fruits[i]` 是第 `i` 棵树上的水果种类。
你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:
* 你只有两个篮子,并且每个篮子只能装单一类型 的水果。每个篮子能够装的水果总量没有限制。
* 你可以选择任意一棵树开始采摘,你必须从每棵树(包括开始采摘的树)上恰好摘一个水果。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。
* 一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。
给你一个整数数组 `fruits`,返回你可以收集的水果的最大数目。
示例 1:
```
输入:fruits = [1,2,1]
输出:3
解释:可以采摘全部 3 棵树。
```
示例 2:
```
输入:fruits = [0,1,2,2]
输出:3
解释:可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘,则只能采摘 [0,1] 这两棵树。
```
示例 3:
```
输入:fruits = [1,2,3,2,2]
输出:4
解释:可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘,则只能采摘 [1,2] 这两棵树。
```
示例 4:
```
输入:fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出:5
解释:可以采摘 [1,2,1,1,2] 这五棵树。
```
提示:
* $1 <= fruits.length <= 10^5$
* $0 <= fruits[i] < fruits.length$ | ### 滑动窗口
本题至少一半的难度在于理解题意。
坏消息是,像此类描述不够清晰的算法题,并不在少数。
好消息是,此类题目,通常都有对应的解决方案。就是如果读一遍题面,不能理解题意的时候,切勿来回阅读题面,而是从示例数据进行入手进行理解。
通过对先看「示例」再阅读「题面」的理解方式,整理出基本题意:从任意位置开始,**同时使用**两个篮子采集,一旦选择后不能修改篮子所装的水果种类,当所有树处理完或遇到第一棵种类不同的树则停止。
核心求解思路为滑动窗口:使用 `j` 和 `i` 分别代表滑动窗口的两端,窗口种类不超过 $2$ 种为合法。
Java 代码:
```Java
class Solution {
public int totalFruit(int[] fruits) {
int n = fruits.length, ans = 0;
int[] cnts = new int[n + 10];
for (int i = 0, j = 0, tot = 0; i < n; i++) {
if (++cnts[fruits[i]] == 1) tot++;
while (tot > 2) {
if (--cnts[fruits[j++]] == 0) tot--;
}
ans = Math.max(ans, i - j + 1);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int totalFruit(vector<int>& fruits) {
int n = fruits.size(), ans = 0;
unordered_map<int, int> cnts;
for (int i = 0, j = 0, tot = 0; i < n; i++) {
if (++cnts[fruits[i]] == 1) tot++;
while (tot > 2) {
if (--cnts[fruits[j++]] == 0) tot--;
}
ans = max(ans, i - j + 1);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def totalFruit(self, fruits: List[int]) -> int:
n, ans = len(fruits), 0
j, tot = 0, 0
cnts = defaultdict(int)
for i in range(n):
cnts[fruits[i]] += 1
if cnts[fruits[i]] == 1:
tot += 1
while tot > 2:
cnts[fruits[j]] -= 1
if cnts[fruits[j]] == 0:
tot -= 1
j += 1
ans = max(ans, i - j + 1)
return ans
```
TypeScript 代码:
```TypeScript
function totalFruit(fruits: number[]): number {
let n = fruits.length, ans = 0
const cnts = new Array<number>(n + 10).fill(0)
for (let i = 0, j = 0, tot = 0; i < n; i++) {
if (++cnts[fruits[i]] == 1) tot++
while (tot > 2) {
if (--cnts[fruits[j++]] == 0) tot--
}
ans = Math.max(ans, i - j + 1)
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.904` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/905. 按奇偶排序数组（简单）.md | 905. 按奇偶排序数组 | https://leetcode-cn.com/problems/sort-array-by-parity/solution/by-ac_oier-nuz7/ | 简单 | [
"模拟",
"双指针"
] | 给你一个整数数组 `nums`,将 `nums` 中的的所有偶数元素移动到数组的前面,后跟所有奇数元素。
返回满足此条件的 任一数组 作为答案。
示例 1:
```
输入:nums = [3,1,2,4]
输出:[2,4,3,1]
解释:[4,2,3,1]、[2,4,1,3] 和 [4,2,1,3] 也会被视作正确答案。
```
示例 2:
```
输入:nums = [0]
输出:[0]
```
提示:
* $1 <= nums.length <= 5000$
* $0 <= nums[i] <= 5000$ | ### 模拟
根据题意进行模拟即可:使用指针 $i$ 和 $j$ 分别代表未处理区间的左右端点,当 $nums[i]$ 不为偶数时,将 $i$ 和 $j$ 两个位置互换,原有位置 $j$ 必然是奇数(已处理好),让 $j$ 自减左移,但原有位置 $i$ 交换后不确保是偶数,需要再次检查。
代码:
```Java
class Solution {
public int[] sortArrayByParity(int[] nums) {
int n = nums.length;
for (int i = 0, j = n - 1; i < j; i++) {
if (nums[i] % 2 == 1) {
int c = nums[j];
nums[j--] = nums[i];
nums[i--] = c;
}
}
return nums;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.905` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/907. 子数组的最小值之和（中等）.md | 907. 子数组的最小值之和 | https://leetcode.cn/problems/sum-of-subarray-minimums/solution/by-ac_oier-w2ya/ | 中等 | [
"数学",
"单调栈"
] | 给定一个整数数组 `arr`,找到 `min(b)` 的总和,其中 `b` 的范围为 `arr` 的每个(连续)子数组。
由于答案可能很大,因此 返回答案模 $10^9 + 7$ 。
示例 1:
```
输入:arr = [3,1,2,4]
输出:17
解释:
子数组为 [3],[1],[2],[4],[3,1],[1,2],[2,4],[3,1,2],[1,2,4],[3,1,2,4]。
最小值为 3,1,2,4,1,1,2,1,1,1,和为 17。
```
示例 2:
```
输入:arr = [11,81,94,43,3]
输出:444
```
提示:
* $1 <= arr.length <= 3 \times 10^4$
* $1 <= arr[i] <= 3 \times 10^4$ | ### 单调栈 + 数学
原问题为求所有子数组的最小值之和。
统计所有子数组需要枚举左右端点,复杂度为 $O(n^2)$,对于每个子数组,我们还需要通过线性扫描的方式找到其最小值,复杂度为 $O(n)$,因此朴素解法的整体复杂度为 $O(n^3)$,题目给定数据范围为 $3 \times 10^4$,会 `TLE`。
由于我们是从子数组中取最小值来进行累加,即参与答案构成的每个数必然某个具体的 $arr[i]$。
**因此我们可以将原问题转化为「考虑统计每个 $arr[i]$ 对答案的贡献」。**
对于某一个 $arr[i]$ 而言,我们考虑其能够作为哪些子数组的最小值。
我们可以想象以 $arr[i]$ 为中心,分别往两端进行拓展,只要新拓展的边界不会改变「$arr[i]$ 为当前子数组的最小值」的性质即可。
换句话说,我们需要找到 $arr[i]$ 作为最小值的最远左右边界,即找到 $arr[i]$ 左右最近一个比其小的位置 `l` 和 `r`。
**在给定序列中,找到任意 $A[i]$ 最近一个比其大/小的位置,可使用「单调栈」进行求解。**
到这里,我们会自然想到,通过单调栈的方式,分别预处理除 `l` 和 `r` 数组:
* `l[i] = loc` 含义为下标 `i` 左边最近一个比 `arr[i]` 小的位置是 `loc`(若在 $arr[i]$ 左侧不存在比其小的数,则 `loc = -1`)
* `r[i] = loc` 含义为下标 `i` 右边最近一个比 `arr[i]` 小的位置是 `loc`(若在 $arr[i]$ 左侧不存在比其小的数,则 `loc = n`)
当我们预处理两数组后,通过简单「乘法原理」即可统计以 $arr[i]$ 为最小值时,子数组的个数:
* 包含 $arr[i]$ 的子数组左端点个数为 $a = i - l[i]$ 个
* 包含 $arr[i]$ 的子数组右端点个数为 $b = r[i] - i$ 个
子数组的个数 $\times$ 子数组最小值 $arr[i]$,即是当前 $arr[i]$ 对答案的贡献:$a \times b \times arr[i]$。
**统计所有 $arr[i]$ 对答案的贡献即是最终答案,但我们忽略了「当 `arr` 存在重复元素,且该元素作为子数组最小值时,最远左右端点的边界越过重复元素时,导致重复统计子数组」的问题。**
我们不失一般性的举个 🌰 来理解(下图):
为了消除这种重复统计,我们可以将「最远左右边界」的一端,从「严格小于」调整为「小于等于」,从而实现半开半闭的效果。
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int sumSubarrayMins(int[] arr) {
int n = arr.length, ans = 0;
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() && arr[d.peekLast()] >= arr[i]) r[d.pollLast()] = i;
d.addLast(i);
}
d.clear();
for (int i = n - 1; i >= 0; i--) {
while (!d.isEmpty() && arr[d.peekLast()] > arr[i]) l[d.pollLast()] = i;
d.addLast(i);
}
for (int i = 0; i < n; i++) {
int a = i - l[i], b = r[i] - i;
ans += a * 1L * b % MOD * arr[i] % MOD;
ans %= MOD;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int MOD = 1e9 + 7;
int sumSubarrayMins(vector<int>& arr) {
int n = arr.size(), ans = 0;
vector<int> l(n, -1), r(n, n);
stack<int> d;
for (int i = 0; i < n; i++) {
while (!d.empty() && arr[d.top()] >= arr[i]) {
r[d.top()] = i;
d.pop();
}
d.push(i);
}
while (!d.empty()) d.pop();
for (int i = n - 1; i >= 0; i--) {
while (!d.empty() && arr[d.top()] > arr[i]) {
l[d.top()] = i;
d.pop();
}
d.push(i);
}
for (int i = 0; i < n; i++) {
long long a = i - l[i], b = r[i] - i;
ans = (ans + a * b % MOD * arr[i] % MOD) % MOD;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def sumSubarrayMins(self, arr: List[int]) -> int:
n, ans = len(arr), 0
l, r = [-1] * n, [n] * n
stk = []
for i in range(n):
while stk and arr[stk[-1]] >= arr[i]:
r[stk.pop()] = i
stk.append(i)
stk = []
for i in range(n - 1, -1, -1):
while stk and arr[stk[-1]] > arr[i]:
l[stk.pop()] = i
stk.append(i)
for i in range(n):
a, b = i - l[i], r[i] - i
ans += a * b * arr[i]
return ans % (10 ** 9 + 7)
```
TypeScript 代码:
```TypeScript
const MOD = 1000000007
function sumSubarrayMins(arr: number[]): number {
let n = arr.length, ans = 0
const l = new Array<number>(n).fill(-1), r = new Array<number>(n).fill(n)
const stk = new Array<number>(n).fill(0)
let he = 0, ta = 0
for (let i = 0; i < n; i++) {
while (he < ta && arr[stk[ta - 1]] >= arr[i]) r[stk[--ta]] = i
stk[ta++] = i
}
he = ta = 0
for (let i = n - 1; i >= 0; i--) {
while (he < ta && arr[stk[ta - 1]] > arr[i]) l[stk[--ta]] = i
stk[ta++] = i
}
for (let i = 0; i < n; i++) {
const a = i - l[i], b = r[i] - i
ans += a * b % MOD * arr[i] % MOD
ans %= MOD
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 优化
实际上,当我们从栈中弹出某个 $arr[cur]$ 时,其右边界必然是导致其弹出的 `arr[r]`(当前所遍历到的元素),而 $arr[cur]$ 若存在左边界,必然是位于 $cur$ 栈中的前一位置,即 $arr[cur]$ 弹出后的新栈顶元素(若不存在物理左边界,则左边界为 $-1$)。
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int sumSubarrayMins(int[] arr) {
int n = arr.length, ans = 0;
Deque<Integer> d = new ArrayDeque<>();
for (int r = 0; r <= n; r++) {
int t = r < n ? arr[r] : 0;
while (!d.isEmpty() && arr[d.peekLast()] >= t) {
int cur = d.pollLast();
int l = d.isEmpty() ? -1 : d.peekLast();
int a = cur - l, b = r - cur;
ans += a * 1L * b % MOD * arr[cur] % MOD;
ans %= MOD;
}
d.addLast(r);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int MOD = 1e9 + 7;
int sumSubarrayMins(vector<int>& arr) {
int n = arr.size(), ans = 0;
deque<int> d;
for (int r = 0; r <= n; r++) {
int t = (r < n) ? arr[r] : 0;
while (!d.empty() && arr[d.back()] >= t) {
int cur = d.back();
d.pop_back();
int l = d.empty() ? -1 : d.back();
long long a = cur - l, b = r - cur;
ans = (ans + a * b % MOD * arr[cur] % MOD) % MOD;
}
d.push_back(r);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def sumSubarrayMins(self, arr: List[int]) -> int:
n, ans = len(arr), 0
stk = []
for r in range(n + 1):
t = arr[r] if r < n else 0
while stk and arr[stk[-1]] >= t:
cur = stk.pop()
l = stk[-1] if stk else -1
a, b = cur - l, r - cur
ans += a * b * arr[cur]
stk.append(r)
return ans % (10 ** 9 + 7)
```
TypeScript 代码:
```TypeScript
const MOD = 1000000007
function sumSubarrayMins(arr: number[]): number {
let n = arr.length, ans = 0
const stk = new Array<number>(n).fill(0)
let he = 0, ta = 0
for (let r = 0; r <= n; r++) {
const t = r < n ? arr[r] : 0
while (he < ta && arr[stk[ta - 1]] >= t) {
const cur = stk[--ta]
const l = he < ta ? stk[ta - 1] : -1
const a = cur - l, b = r - cur
ans += a * b % MOD * arr[cur] % MOD
ans %= MOD
}
stk[ta++] = r
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.907` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/908. 最小差值 I（简单）.md | 908. 最小差值 I | https://leetcode.cn/problems/smallest-range-i/solution/by-ac_oier-7fh0/ | 简单 | [
"模拟",
"脑筋急转弯"
] | 给你一个整数数组 `nums`,和一个整数 `k` 。
在一个操作中,您可以选择 $0 <= i < nums.length$ 的任何索引 `i` 。将 $nums[i]$ 改为 $nums[i] + x$ ,其中 $x$ 是一个范围为 $[-k, k]$ 的整数。对于每个索引 `i` ,最多 只能 应用 一次 此操作。
`nums` 的 分数 是 `nums` 中最大和最小元素的差值。
在对 `nums` 中的每个索引最多应用一次上述操作后,返回 `nums` 的最低 分数 。
示例 1:
```
输入:nums = [1], k = 0
输出:0
解释:分数是 max(nums) - min(nums) = 1 - 1 = 0。
```
示例 2:
```
输入:nums = [0,10], k = 2
输出:6
解释:将 nums 改为 [2,8]。分数是 max(nums) - min(nums) = 8 - 2 = 6。
```
示例 3:
```
输入:nums = [1,3,6], k = 3
输出:0
解释:将 nums 改为 [4,4,4]。分数是 max(nums) - min(nums) = 4 - 4 = 0。
```
提示:
* $1 <= nums.length <= 10^4$
* $0 <= nums[i] <= 10^4$
* $0 <= k <= 10^4$ | ### 脑筋急转弯
根据题意,对于任意一个数 $nums[i]$ 而言,其所能变化的范围为 $[nums[i] - k, nums[i] + k]$,我们需要最小化变化后的差值。而当 $k$ 足够大时,我们必然能够将所有数变为同一个值,此时答案为 $0$,而更一般的情况,我们能够缩减的数值距离为 $2 * k$,因此如果原来的最大差值为 $d = \max - \min$,若 $d <= 2 * k$ 时,答案为 $0$,否则答案为 $d - 2 * k$。
代码:
```Java
class Solution {
public int smallestRangeI(int[] nums, int k) {
int max = nums[0], min = nums[0];
for (int i : nums) {
max = Math.max(max, i);
min = Math.min(min, i);
}
return Math.max(0, max - min - 2 * k);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.908` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/901-910/909. 蛇梯棋（中等）.md | 909. 蛇梯棋 | https://leetcode-cn.com/problems/snakes-and-ladders/solution/gong-shui-san-xie-bfs-mo-ni-by-ac_oier-woh6/ | 中等 | [
"图论 BFS"
] | 给你一个大小为 `n x n` 的整数矩阵 `board` ,方格按从 $1$ 到 $n^2$ 编号,编号遵循 转行交替方式 ,从左下角开始 (即,从 `board[n - 1][0]` 开始)每一行交替方向。
玩家从棋盘上的方格 $1$ (总是在最后一行、第一列)开始出发。
每一回合,玩家需要从当前方格 $curr$ 开始出发,按下述要求前进:
* 选定目标方格 `next`,目标方格的编号符合范围 $[curr + 1, min(curr + 6, n^2)]$。
* 该选择模拟了掷 六面体骰子 的情景,无论棋盘大小如何,玩家最多只能有 $6$ 个目的地。
* 传送玩家:如果目标方格 `next` 处存在蛇或梯子,那么玩家会传送到蛇或梯子的目的地。否则,玩家传送到目标方格 `next`。
* 当玩家到达编号 $n^2$ 的方格时,游戏结束。
`r` 行 `c` 列的棋盘,按前述方法编号,棋盘格中可能存在 “蛇” 或 “梯子”;
如果 `board[r][c] != -1`,那个蛇或梯子的目的地将会是 `board[r][c]`。
编号为 $1$ 和 $n^2$ 的方格上没有蛇或梯子。
注意,玩家在每回合的前进过程中最多只能爬过蛇或梯子一次:就算目的地是另一条蛇或梯子的起点,玩家也 不能 继续移动。
* 举个例子,假设棋盘是 $[[-1,4],[-1,3]]$ ,第一次移动,玩家的目标方格是 $2$ 。那么这个玩家将会顺着梯子到达方格 $3$ ,但 不能 顺着方格 $3$ 上的梯子前往方格 $4$ 。
返回达到编号为 $n^2$ 的方格所需的最少移动次数,如果不可能,则返回 $-1$。
示例 1:
```
输入:board =
[
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,35,-1,-1,13,-1],
[-1,-1,-1,-1,-1,-1],
[-1,15,-1,-1,-1,-1]
]
输出:4
解释:
首先,从方格 1 [第 5 行,第 0 列] 开始。
先决定移动到方格 2 ,并必须爬过梯子移动到到方格 15 。
然后决定移动到方格 17 [第 3 行,第 4 列],必须爬过蛇到方格 13 。
接着决定移动到方格 14 ,且必须通过梯子移动到方格 35 。
最后决定移动到方格 36 , 游戏结束。
可以证明需要至少 4 次移动才能到达最后一个方格,所以答案是 4 。
```
提示:
* $n == board.length == board[i].length$
* $2 <= n <= 20$
* $grid[i][j]$ 的值是 $-1$ 或在范围 $[1, n^2]$ 内
* 编号为 $1$ 和 $n^2$ 的方格上没有蛇或梯子 | ### BFS
最多有 $20 * 20$ 个格子,直接使用常规的单向 `BFS` 进行求解即可。
为了方便我们可以按照题目给定的意思,将二维的矩阵「扁平化」为一维的矩阵,然后再按照规则进行 `BFS`。
代码:
```Java
class Solution {
int n;
int[] nums;
public int snakesAndLadders(int[][] board) {
n = board.length;
if (board[0][0] != -1) return -1;
nums = new int[n * n + 1];
boolean isRight = true;
for (int i = n - 1, idx = 1; i >= 0; i--) {
for (int j = (isRight ? 0 : n - 1); isRight ? j < n : j >= 0; j += isRight ? 1 : -1) {
nums[idx++] = board[i][j];
}
isRight = !isRight;
}
int ans = bfs();
return ans;
}
int bfs() {
Deque<Integer> d = new ArrayDeque<>();
Map<Integer, Integer> m = new HashMap<>();
d.addLast(1);
m.put(1, 0);
while (!d.isEmpty()) {
int poll = d.pollFirst();
int step = m.get(poll);
if (poll == n * n) return step;
for (int i = 1; i <= 6; i++) {
int np = poll + i;
if (np <= 0 || np > n * n) continue;
if (nums[np] != -1) np = nums[np];
if (m.containsKey(np)) continue;
m.put(np, step + 1);
d.addLast(np);
}
}
return -1;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.909` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/91. 解码方法（中等）.md | 91. 解码方法 | https://leetcode-cn.com/problems/decode-ways/solution/gong-shui-san-xie-gen-ju-shu-ju-fan-wei-ug3dd/ | 中等 | [
"线性 DP"
] | 一条包含字母 A-Z 的消息通过以下映射进行了 编码 :
```
'A' -> 1
'B' -> 2
...
'Z' -> 26
```
要 解码 已编码的消息,所有数字必须基于上述映射的方法,反向映射回字母(可能有多种方法)。例如,"11106" 可以映射为:
* "AAJF" ,将消息分组为 (1 1 10 6)
* "KJF" ,将消息分组为 (11 10 6)
注意,消息不能分组为 (1 11 06) ,因为 "06" 不能映射为 "F" ,这是由于 "6" 和 "06" 在映射中并不等价。
给你一个只含数字的 非空 字符串 s ,请计算并返回 解码 方法的 总数 。
题目数据保证答案肯定是一个 32 位 的整数。
示例 1:
```
输入:s = "12"
输出:2
解释:它可以解码为 "AB"(1 2)或者 "L"(12)。
```
示例 2:
```
输入:s = "226"
输出:3
解释:它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
```
示例 3:
```
输入:s = "0"
输出:0
解释:没有字符映射到以 0 开头的数字。
含有 0 的有效映射是 'J' -> "10" 和 'T'-> "20" 。
由于没有字符,因此没有有效的方法对此进行解码,因为所有数字都需要映射。
```
示例 4:
```
输入:s = "06"
输出:0
解释:"06" 不能映射到 "F" ,因为字符串含有前导 0("6" 和 "06" 在映射中并不等价)。
```
提示:
* 1 <= s.length <= 100
* s 只包含数字,并且可能包含前导零。 | ### 基本分析
我们称一个解码内容为一个 `item`。
为根据题意,每个 `item` 可以由一个数字组成,也可以由两个数字组成。
数据范围为 100,很具有迷惑性,可能会有不少同学会想使用 DFS 进行爆搜。
我们可以大致分析一下这样的做法是否可行:不失一般性的考虑字符串 `s` 中的任意位置 `i`,位置 `i` 既可以作为一个独立 `item`,也可以与上一位置组成新 `item`,那么相当于每个位置都有两种分割选择(先不考虑分割结果的合法性问题),这样做法的复杂度是 $O(2^n)$ 的,当 `n` 范围是 100 时,远超我们计算机单秒运算量($10^7$)。即使我们将「判断分割结果是否合法」的操作放到爆搜过程中做剪枝,也与我们的单秒最大运算量相差很远。
递归的方法不可行,我们需要考虑递推的解法。
---
### 动态规划
**这其实是一道字符串类的动态规划题,不难发现对于字符串 `s` 的某个位置 `i` 而言,我们只关心「位置 `i` 自己能否形成独立 `item` 」和「位置 `i` 能够与上一位置(`i-1`)能否形成 `item`」,而不关心 `i-1` 之前的位置。**
有了以上分析,我们可以从前往后处理字符串 `s`,使用一个数组记录以字符串 `s` 的每一位作为结尾的解码方案数。即定义 $f[i]$ 为考虑前 $i$ 个字符的解码方案数。
对于字符串 `s` 的任意位置 `i` 而言,其存在三种情况:
* 只能由位置 `i` 的单独作为一个 `item`,设为 `a`,转移的前提是 `a` 的数值范围为 $[1,9]$,转移逻辑为 $f[i] = f[i - 1]$。
* 只能由位置 `i` 的与前一位置(`i-1`)共同作为一个 `item`,设为 `b`,转移的前提是 `b` 的数值范围为 $[10,26]$,转移逻辑为 $f[i] = f[i - 2]$。
* 位置 `i` 既能作为独立 `item` 也能与上一位置形成 `item`,转移逻辑为 $f[i] = f[i - 1] + f[i - 2]$。
因此,我们有如下转移方程:
$$
\begin{cases}
f[i] = f[i - 1], 1 \leqslant a \leq 9 \\
f[i] = f[i - 2], 10 \leqslant b \leqslant 26 \\
f[i] = f[i - 1] + f[i - 2], 1 \leqslant a \leq 9, 10 \leqslant b \leqslant 26 \\
\end{cases}
$$
其他细节:由于题目存在前导零,而前导零属于无效 `item`。可以进行特判,但个人习惯往字符串头部追加空格作为哨兵,追加空格既可以避免讨论前导零,也能使下标从 1 开始,简化 `f[i-1]` 等负数下标的判断。
代码:
```Java
class Solution {
public int numDecodings(String s) {
int n = s.length();
s = " " + s;
char[] cs = s.toCharArray();
int[] f = new int[n + 1];
f[0] = 1;
for (int i = 1; i <= n; i++) {
// a : 代表「当前位置」单独形成 item
// b : 代表「当前位置」与「前一位置」共同形成 item
int a = cs[i] - '0', b = (cs[i - 1] - '0') * 10 + (cs[i] - '0');
// 如果 a 属于有效值,那么 f[i] 可以由 f[i - 1] 转移过来
if (1 <= a && a <= 9) f[i] = f[i - 1];
// 如果 b 属于有效值,那么 f[i] 可以由 f[i - 2] 或者 f[i - 1] & f[i - 2] 转移过来
if (10 <= b && b <= 26) f[i] += f[i - 2];
}
return f[n];
}
}
```
* 时间复杂度:共有 `n` 个状态需要被转移。复杂度为 $O(n)$。
* 空间复杂度:$O(n)$。
---
### 空间优化
不难发现,我们转移 `f[i]` 时只依赖 `f[i-1]` 和 `f[i-2]` 两个状态。
因此我们可以采用与「滚动数组」类似的思路,只创建长度为 3 的数组,通过取余的方式来复用不再需要的下标。
代码:
```Java
class Solution {
public int numDecodings(String s) {
int n = s.length();
s = " " + s;
char[] cs = s.toCharArray();
int[] f = new int[3];
f[0] = 1;
for (int i = 1; i <= n; i++) {
f[i % 3] = 0;
int a = cs[i] - '0', b = (cs[i - 1] - '0') * 10 + (cs[i] - '0');
if (1 <= a && a <= 9) f[i % 3] = f[(i - 1) % 3];
if (10 <= b && b <= 26) f[i % 3] += f[(i - 2) % 3];
}
return f[n % 3];
}
}
```
* 时间复杂度:共有 `n` 个状态需要被转移。复杂度为 $O(n)$。
* 空间复杂度:$O(1)$。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.91` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/92. 反转链表 II（中等）.md | 92. 反转链表 II | https://leetcode-cn.com/problems/reverse-linked-list-ii/solution/yi-ge-neng-ying-yong-suo-you-lian-biao-t-vjx6/ | 中等 | [
"链表"
] | 给你单链表的头指针 head 和两个整数 left 和 right ,其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点,返回 反转后的链表 。
示例 1:
```
输入:head = [1,2,3,4,5], left = 2, right = 4
输出:[1,4,3,2,5]
```
示例 2:
```
输入:head = [5], left = 1, right = 1
输出:[5]
```
提示:
* 链表中节点数目为 n
* 1 <= n <= 500
* -500 <= Node.val <= 500
* 1 <= left <= right <= n | ### 朴素解法
为了减少边界判断,我们可以建立一个虚拟头结点 dummy,使其指向 head,最终返回 dummy.next。
这种「哨兵」技巧能应用在所有的「链表」题目。
黄色部分的节点代表需要「翻转」的部分:
之后就是常规的模拟,步骤我写在示意图里啦 ~
代码:
```java []
class Solution {
public ListNode reverseBetween(ListNode head, int l, int r) {
ListNode dummy = new ListNode(0);
dummy.next = head;
r -= l;
ListNode hh = dummy;
while (l-- > 1) hh = hh.next;
ListNode a = hh.next, b = a.next;
while (r-- > 0) {
ListNode tmp = b.next;
b.next = a;
a = b;
b = tmp;
}
hh.next.next = b;
hh.next = a;
return dummy.next;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.92` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/93. 复原 IP 地址（中等）.md | 93. 复原 IP 地址 | https://leetcode.cn/problems/restore-ip-addresses/solutions/2519711/gong-shui-san-xie-hui-su-suan-fa-yun-yon-khnj/ | 中等 | [
"回溯算法",
"DFS"
] | 有效 `IP` 地址 正好由四个整数(每个整数位于 `0` 到 `255` 之间组成,且不能含有前导 `0`),整数之间用 `'.'` 分隔。
例如:`"0.1.2.201"` 和 `"192.168.1.1"` 是 有效 `IP` 地址,但是 `"0.011.255.245"`、`"192.168.1.312"` 和 `"[email protected]"` 是 无效 `IP` 地址。
给定一个只包含数字的字符串 `s` ,用以表示一个 `IP` 地址,返回所有可能的有效 `IP` 地址,这些地址可以通过在 `s` 中插入 `'.'` 来形成。你 不能 重新排序或删除 `s` 中的任何数字。你可以按 任何 顺序返回答案。
示例 1:
```
输入:s = "25525511135"
输出:["255.255.11.135","255.255.111.35"]
```
示例 2:
```
输入:s = "0000"
输出:["0.0.0.0"]
```
示例 3:
```
输入:s = "101023"
输出:["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
```
提示:
* $1 <= s.length <= 20$
* `s` 仅由数字组成 | ### 回溯算法
和 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8) 一样,同样是一道求所有方案的题目,只能是没有太多优化的「爆搜」做法。
设计递归函数 `void dfs(int idx, int n, List<Integer> cur)`,其中 `idx` 代表当前处理字符串 `s` 的哪个位置,`n` 代表字符串 `s` 总长度,而 `cur` 的则是代表子串 $s[0 ... (idx - 1)]$ 部分的具体划分方案。
用题目样例 `s = "25525511135"` 作为 🌰,`n` 固定为 `11`。
当 `idx = 3` 时,`cur` 为 $s[0...2] = 255$,`cur` 部分的划分方案可能是 `[2,5,5]`、`[2,55]`、`[25,5]`、`[255]` 之一。
在 `cur` 的基础上,我们继续爆搜剩余部分,即递归执行 `dfs(idx, n, cur)`,算法会将剩余部分的划分方案添加到 `cur` 上,我们只需要确保每次追加到 `cur` 的数值符合要求即可(没有前导零 且 范围在 $[0, 255]$ 中)。
在单次回溯过程中,我们可以将 `idx` 作为当前划分数字的左端点,通过枚举的形式找到右端点 `j`,并将当前数字 $s[idx ... (j - 1)]$ 加到 `cur` 中(若合法),回溯到底后再添加到 `cur` 的元素进行移除。
当 `idx = n` 代表整个 `s` 已经处理完成,若此时 `cur` 恰好有 $4$ 个元素,说明我们找到了一组合法方案,将其拼接成字符串追加到答案数组中。
同时也是由于划分过程中 `cur` 最多只有 $4$ 个元素,我们可以用此做简单剪枝。
Java 代码:
```Java
class Solution {
List<String> ans = new ArrayList<>();
char[] cs;
public List<String> restoreIpAddresses(String s) {
cs = s.toCharArray();
dfs(0, cs.length, new ArrayList<>());
return ans;
}
void dfs(int idx, int n, List<Integer> cur) {
if (cur.size() > 4) return ;
if (idx == n) {
if (cur.size() == 4) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 4; i++) sb.append(cur.get(i)).append(".");
ans.add(sb.substring(0, sb.length() - 1));
}
} else {
for (int i = idx; i < n; i++) {
int t = 0;
for (int j = idx; j <= i; j++) t = t * 10 + (cs[j] - '0');
if (cs[idx] == '0' && i != idx) break;
if (t > 255) break;
cur.add(t);
dfs(i + 1, n, cur);
cur.remove(cur.size() - 1);
}
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<string> ans;
string s;
void dfs(int idx, int n, vector<int>& cur) {
if (cur.size() > 4) return ;
if (idx == n) {
if (cur.size() == 4) {
string sb;
for (int i = 0; i < 4; i++) sb += to_string(cur[i]) + ".";
ans.push_back(sb.substr(0, sb.length() - 1));
}
} else {
for (int i = idx; i < n; i++) {
int t = 0;
for (int j = idx; j <= i; j++) t = t * 10 + (s[j] - '0');
if (s[idx] == '0' && i != idx) break;
if (t > 255) break;
cur.push_back(t);
dfs(i + 1, n, cur);
cur.pop_back();
}
}
}
vector<string> restoreIpAddresses(string _s) {
s = _s;
vector<int> cur;
dfs(0, s.length(), cur);
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def restoreIpAddresses(self, s: str) -> List[str]:
ans = []
def dfs(idx, n, cur):
if len(cur) > 4:
return
if idx == n:
if len(cur) == 4:
ans.append('.'.join(cur))
else:
for i in range(idx, n):
t = 0
for j in range(idx, i + 1):
t = t * 10 + (ord(s[j]) - ord('0'))
if s[idx] == '0' and i != idx:
break
if t > 255:
break
cur.append(str(t))
dfs(i + 1, n, cur)
cur.pop()
dfs(0, len(s), [])
return ans
```
TypeScript 代码:
```TypeScript
function restoreIpAddresses(s: string): string[] {
const ans = new Array<string>()
function dfs(idx: number, n: number, cur: Array<number>): void {
if (cur.length > 4) return
if (idx == n) {
if (cur.length == 4) {
let str = ''
for (let i = 0; i < 4; i++) str += cur[i] + "."
ans.push(str.substring(0, str.length - 1))
}
} else {
for (let i = idx; i < n; i++) {
let t = 0
for (let j = idx; j <= i; j++) t = t * 10 + (s.charCodeAt(j) - '0'.charCodeAt(0))
if (s[idx] == '0' && i != idx) break
if (t > 255) break
cur.push(t)
dfs(i + 1, n, cur)
cur.pop()
}
}
}
dfs(0, s.length, new Array<number>())
return ans
}
```
* 时间复杂度:爆搜不讨论时空复杂度
* 空间复杂度:爆搜不讨论时空复杂度 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.93` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/95. 不同的二叉搜索树 II（中等）.md | 95. 不同的二叉搜索树 II | https://leetcode.cn/problems/unique-binary-search-trees-ii/solutions/2438263/gong-shui-san-xie-chang-gui-er-cha-shu-b-h4sw/ | 中等 | [
"树",
"二叉搜索树",
"BST",
"DFS",
"递归",
"爆搜"
] | 给你一个整数 `n`,请你生成并返回所有由 `n` 个节点组成且节点值从 `1` 到 `n` 互不相同的不同 二叉搜索树 。
可以按 任意顺序 返回答案。
示例 1:
```
输入:n = 3
输出:[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
```
示例 2:
```
输入:n = 1
输出:[[1]]
```
提示:
* $1 <= n <= 8$ | ### 回溯算法
题目要我们求所有所能构造的二叉搜索树的具体方案,而给定 $n$ 个节点所能构成的二叉搜索树的个数为 [卡特兰数](https://baike.baidu.com/item/%E5%8D%A1%E7%89%B9%E5%85%B0%E6%95%B0)。
其他方案数同为卡特兰数的还包括:凸多边形三角划分、`n` 对括号正确匹配数目 ...
回到本题,根据二叉搜索搜索的特性,若某个子树的根节点为 `root`,那么 `root` 的左子树任意节点值均比 `root.val` 要小,`root` 的右子树任意节点值均比 `root.val` 要大。
因此,假设我们使用 $[l, r]$ 连续段来构造二叉搜索树,并且选择了节点 `t` 作为二叉搜索树的根节点时:
* 那么使用 $[l, t - 1]$ 构造出来的二叉搜索树均可作为根节点 $t$ 的左子树
* 使用 $[t + 1, r]$ 构造出来的二叉搜索树均可作为根节点 $t$ 的右子树
也就是说,我们可以设计递归函数 `List<TreeNode> dfs(int l, int r)`,含义为使用连续段 $[l, r]$ 进行二叉搜索树构造,并返回相应集合。
最终答案为 `dfs(1,n)`,起始我们可以枚举 $[1, n]$ 范围内的的每个数 `t` 作为根节点,并递归 `dfs(l,t-1)` 和 `dfs(t+1,r)` 获取左右子树的集合 `left` 和 `right`。
结合「乘法原理」,枚举任意左子树和任意右子树,即可得到 `t` 作为根节点的二叉搜索树方案集,枚举所有 `t` 后即可得到所有二叉搜索树的总集。
> 注意:当我们运用乘法原理,来构造以 `t` 为根节点的二叉搜索树时,其 `left` 或 `right` 某一边可能为空集,但此时我们仍要将非空的一边子树进行挂载。
为了确保两层新循环的逻辑会被执行,对于空集我们不能使用 `null` 来代指,而要使用 `[null]` 来代指。
Java 代码:
```Java
class Solution {
public List<TreeNode> generateTrees(int n) {
return dfs(1, n);
}
List<TreeNode> dfs(int l, int r) {
if (l > r) return new ArrayList<>(){{add(null);}};
List<TreeNode> ans = new ArrayList<>();
for (int i = l; i <= r; i++) {
for (TreeNode x : dfs(l, i - 1)) {
for (TreeNode y : dfs(i + 1, r)) {
TreeNode root = new TreeNode(i);
root.left = x; root.right = y;
ans.add(root);
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<TreeNode*> generateTrees(int n) {
return dfs(1, n);
}
vector<TreeNode*> dfs(int l, int r) {
if (l > r) return vector<TreeNode*>{NULL};
vector<TreeNode*> ans;
for (int i = l; i <= r; i++) {
for (TreeNode* x : dfs(l, i - 1)) {
for (TreeNode* y : dfs(i + 1, r)) {
// 创建当前节点并添加到结果列表中
TreeNode* root = new TreeNode(i);
root->left = x;
root->right = y;
ans.push_back(root);
}
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def generateTrees(self, n: int) -> List[Optional[TreeNode]]:
def dfs(l, r):
if l > r:
return [None]
ans = []
for i in range(l, r + 1):
for x in dfs(l, i - 1):
for y in dfs(i + 1, r):
root = TreeNode(i)
root.left, root.right = x, y
ans.append(root)
return ans
return dfs(1, n)
```
TypeScript 代码:
```TypeScript
function generateTrees(n: number): Array<TreeNode | null> {
function dfs(l: number, r: number): Array<TreeNode | null> {
if (l > r) return [null]
const ans = new Array<TreeNode>()
for (let i = l; i <= r; i++) {
for (const x of dfs(l, i - 1)) {
for (const y of dfs(i + 1, r)) {
const root = new TreeNode(i)
root.left = x; root.right = y
ans.push(root)
}
}
}
return ans
}
return dfs(1, n)
}
```
* 时间复杂度:卡特兰数
* 空间复杂度:卡特兰数 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.95` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/96. 不同的二叉搜索树（中等）.md | 96. 不同的二叉搜索树 | https://leetcode.cn/problems/unique-binary-search-trees/solutions/2438266/gong-shui-san-xie-cong-qu-jian-dp-dao-qi-fz5z/ | 中等 | [
"树",
"二叉搜索树",
"动态规划",
"区间 DP",
"数学",
"卡特兰数"
] | 给你一个整数 `n` ,求恰由 `n` 个节点组成且节点值从 `1` 到 `n` 互不相同的 二叉搜索树 有多少种?
返回满足题意的二叉搜索树的种数。
示例 1:
```
输入:n = 3
输出:5
```
示例 2:
```
输入:n = 1
输出:1
```
提示:
* $1 <= n <= 19$ | ### 区间 DP
沿用 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 的基本思路,只不过本题不是求具体方案,而是求个数。
除了能用 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 提到的「卡特兰数」直接求解 $n$ 个节点的以外,本题还能通过常规「区间 DP」的方式进行求解。
> 求数量使用 DP,求所有具体方案使用爆搜,是极其常见的一题多问搭配。
**定义 $f[l][r]$ 为使用数值范围在 $[l, r]$ 之间的节点,所能构建的 `BST` 个数**。
不失一般性考虑 $f[l][r]$ 该如何求解,仍用 $[l, r]$ 中的根节点 `i` 为何值,作为切入点进行思考。
根据「`BST` 定义」及「乘法原理」可知:$[l, i - 1]$ 相关节点构成的 `BST` 子树只能在 `i` 的左边,而 $[i + 1, r]$ 相关节点构成的 `BST` 子树只能在 `i` 的右边。所有的左右子树相互独立,因此以 `i` 为根节点的 `BST` 数量为 $f[l][i - 1] \times f[i + 1][r]$,而 `i` 共有 $r - l + 1$ 个取值($i \in [l, r]$)。
即有:
$$
f[l][r] = \sum_{i = l}^{r} (f[l][i - 1] \times f[i + 1][r])
$$
不难发现,求解区间 $[l, r]$ 的 `BST` 数量 $f[l][r]$ 依赖于比其小的区间 $[l, i - 1]$ 和 $[i + 1, r]$,这引导我们使用「区间 DP」的方式进行递推。
> 不了解区间 DP 的同学,可看 [前置 🧀](https://mp.weixin.qq.com/s/RuIKpDEuxkhhKiTeVRMXng)
一些细节:由于我们 `i` 的取值可能会取到区间中的最值 `l` 和 `r`,为了能够该情况下,$f[l][i - 1]$ 和 $f[i + 1][r]$ 能够顺利参与转移,起始我们需要先对所有满足 $i >= j$ 的 $f[i][j]$ 初始化为 `1`。
Java 代码:
```Java
class Solution {
public int numTrees(int n) {
int[][] f = new int[n + 10][n + 10];
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
if (i >= j) f[i][j] = 1;
}
}
for (int len = 2; len <= n; len++) {
for (int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
for (int i = l; i <= r; i++) {
f[l][r] += f[l][i - 1] * f[i + 1][r];
}
}
}
return f[1][n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int numTrees(int n) {
vector<vector<int>> f(n + 2, vector<int>(n + 2, 0));
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
if (i >= j) f[i][j] = 1;
}
}
for (int len = 2; len <= n; len++) {
for (int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
for (int i = l; i <= r; i++) {
f[l][r] += f[l][i - 1] * f[i + 1][r];
}
}
}
return f[1][n];
}
};
```
Python 代码:
```Python
class Solution(object):
def numTrees(self, n):
f = [[0] * (n + 2) for _ in range(n + 2)]
for i in range(n + 2):
for j in range(n + 2):
if i >= j:
f[i][j] = 1
for length in range(2, n + 1):
for l in range(1, n - length + 2):
r = l + length - 1
for i in range(l, r + 1):
f[l][r] += f[l][i - 1] * f[i + 1][r]
return f[1][n]
```
TypeScript 代码:
```TypeScript
function numTrees(n: number): number {
const f = new Array(n + 2).fill(0).map(() => new Array(n + 2).fill(0));
for (let i = 0; i <= n + 1; i++) {
for (let j = 0; j <= n + 1; j++) {
if (i >= j) f[i][j] = 1;
}
}
for (let len = 2; len <= n; len++) {
for (let l = 1; l + len - 1 <= n; l++) {
const r = l + len - 1;
for (let i = l; i <= r; i++) {
f[l][r] += f[l][i - 1] * f[i + 1][r];
}
}
}
return f[1][n];
};
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n^2)$
---
### 区间 DP(优化)
求解完使用 $[1, n]$ 共 $n$ 个连续数所能构成的 `BST` 个数后,再来思考一个问题:使用 $[L, R]$ 共 $n = R - L + 1$ 个连续数,所能构成的 `BST` 个数又是多少。
答案是一样的。
**由 $n$ 个连续数构成的 `BST` 个数仅与数值个数有关系,与数值大小本身并无关系**。
由于可知,我们上述的「区间 DP」必然进行了大量重复计算,例如 $f[1][3]$ 和 $f[2][4]$ 同为大小为 $3$ 的区间,却被计算了两次。
调整我们的状态定义:**定义 $f[k]$ 为考虑连续数个数为 $k$ 时,所能构成的 `BST` 的个数**。
不失一般性考虑 $f[i]$ 如何计算,仍用 $[1, i]$ 中哪个数值作为根节点进行考虑。假设使用数值 $j$ 作为根节点,则有 $f[j - 1] \times f[i - j]$ 个 `BST` 可贡献到 $f[i]$,而 $j$ 共有 $i$ 个取值($j \in [1, i]$)。
即有:
$$
f[i] = \sum_{j = 1}^{i}(f[j - 1] \times f[i - j])
$$
同时有初始化 $f[0] = 1$,含义为没有任何连续数时,只有“空树”一种合法方案。
Java 代码:
```Java
class Solution {
public int numTrees(int n) {
int[] f = new int[n + 10];
f[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
f[i] += f[j - 1] * f[i - j];
}
}
return f[n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int numTrees(int n) {
vector<int> f(n + 10, 0);
f[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
f[i] += f[j - 1] * f[i - j];
}
}
return f[n];
}
};
```
Python 代码:
```Python
class Solution:
def numTrees(self, n: int) -> int:
f = [0] * (n + 10)
f[0] = 1
for i in range(1, n + 1):
for j in range(1, i + 1):
f[i] += f[j - 1] * f[i - j]
return f[n]
```
TypeScript 代码:
```TypeScript
function numTrees(n: number): number {
const f = new Array(n + 10).fill(0);
f[0] = 1;
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= i; j++) {
f[i] += f[j - 1] * f[i - j];
}
}
return f[n];
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
---
### 数学 - 卡特兰数
在「区间 DP(优化)」中的递推过程,正是“卡特兰数”的 $O(n^2)$ 递推过程。通过对常规「区间 DP」的优化,我们得证 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 中「给定 $n$ 个节点所能构成的 `BST` 的个数为卡特兰数」这一结论。
对于精确求卡特兰数,存在时间复杂度为 $O(n)$ 的通项公式做法,公式为 $C_{n+1} = \frac{C_n \cdot (4n + 2)}{n + 2}$。
Java 代码:
```Java
class Solution {
public int numTrees(int n) {
if (n <= 1) return 1;
long ans = 1;
for (int i = 0; i < n; i++) ans = ans * (4 * i + 2) / (i + 2);
return (int)ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int numTrees(int n) {
if (n <= 1) return 1;
long long ans = 1;
for (int i = 0; i < n; i++) ans = ans * (4 * i + 2) / (i + 2);
return (int)ans;
}
};
```
Python 代码:
```Python
class Solution:
def numTrees(self, n: int) -> int:
if n <= 1:
return 1
ans = 1
for i in range(n):
ans = ans * (4 * i + 2) // (i + 2)
return ans
```
TypeScript 代码:
```TypeScript
function numTrees(n: number): number {
if (n <= 1) return 1;
let ans = 1;
for (let i = 0; i < n; i++) ans = ans * (4 * i + 2) / (i + 2);
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.96` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/97. 交错字符串（中等）.md | 97. 交错字符串 | https://leetcode.cn/problems/interleaving-string/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-51da/ | 中等 | [
"线性 DP",
"记忆化搜索"
] | 给定三个字符串 `s1`、`s2`、`s3`,请你帮忙验证 `s3` 是否是由 `s1` 和 `s2` 交错 组成的。
两个字符串 `s` 和 `t` **交错** 的定义与过程如下,其中每个字符串都会被分割成若干 **非空** 子字符串:
* `s = s1 + s2 + ... + sn`
* `t = t1 + t2 + ... + tm`
* `|n - m| <= 1`
交错是 `s1 + t1 + s2 + t2 + s3 + t3 + ...` 或者 `t1 + s1 + t2 + s2 + t3 + s3 + ...`
注意:`a + b` 意味着字符串 `a` 和 `b` 连接。
示例 1:
```
输入:s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
输出:true
```
示例 2:
```
输入:s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
输出:false
```
示例 3:
```
输入:s1 = "", s2 = "", s3 = ""
输出:true
```
提示:
* $0 <= s1.length, s2.length <= 100$
* $0 <= s3.length <= 200$
* `s1`、`s2`、和 `s3` 都由小写英文字母组成
进阶:您能否仅使用 $O(s2.length)$ 额外的内存空间来解决它? | ### 记忆化搜索
数据范围相比于「暴搜」而言有点大,但将「暴搜」解法作为前置思考,总能为我们带来灵感。
将 `s1`、`s2` 和 `s3` 的长度分别记为 $n$、$m$ 和 $l$。
一个显然的情况是若 $n + m$ 不为 $l$,必然不能用 `s1` 和 `s2` 来凑成 `s3`,返回 `false`。
定义暴搜函数为 `boolean dfs(int i, int j)`,代表当前处理到 `s1` 的第 $i$ 个字符,`s2` 的第 $j$ 个字符,能否凑成 `s3` 的前 $i + j$ 个字符。
最终答案为 `dfs(0, 0)`。
根据 $s1[i]$、$s2[j]$ 和 $s3[i + j]$ 的关系分情况讨论:
* $s1[i] = s3[i + j]$,可使用 $s1[i]$ 充当 $s3[i + j]$ ,暴搜 $s1[i]$ 已被使用的情况,决策下一位 `dfs(i + 1, j)`
* $s2[j] = s3[i + j]$,可使用 $s2[j]$ 充当 $s3[i + j]$ ,暴搜 $s2[j]$ 已被使用的情况,决策下一位`dfs(i, j + 1)`
当 $i + j = l$ 时,代表我们成功用 `s1` 和 `s2` 凑成了 `s3`,返回 `true`;而若在任一回合出现 $s1[i] \neq s3[i + j]$ 且 $s2[j] \neq s3[i + j]$,说明构造无法进行,返回 `false`。
`TLE` Java 代码:
```Java
class Solution {
char[] cs1, cs2, cs3;
int n, m, l;
public boolean isInterleave(String s1, String s2, String s3) {
cs1 = s1.toCharArray(); cs2 = s2.toCharArray(); cs3 = s3.toCharArray();
n = s1.length(); m = s2.length(); l = s3.length();
if (n + m != l) return false;
return dfs(0, 0);
}
boolean dfs(int i, int j) {
if (i + j == l) return true;
boolean ans = false;
if (i < n && cs1[i] == cs3[i + j]) ans |= dfs(i + 1, j);
if (j < m && cs2[j] == cs3[i + j]) ans |= dfs(i, j + 1);
return ans;
}
}
```
可分析上述 `TLE` 做法的时间复杂度上界为交错序列个数。
长度分别为 $n$ 和 $m$ 形成的交错序列数量为 $C(n+m, n) = \frac{(n+m)!}{n! \times m!}$ : 从 $n + m$ 个位置中选 $n$ 个位置按顺序放置 `s1`,剩下的 $m$ 个位置唯一确定的放置 `s2`。
实际上,不同交错序列之间有着相同的前缀(例如 `s1 = aac` 和 `s2 = bbd`,具体交错方案中的 `aabbcd` 和 `aabbdc` 之间有着相同的前缀 `aabb__`),可通过「记忆化搜索」来进行减少这些重复的构造。
直接根据 `dfs` 函数的入参构建缓存器 `cache`,起始 `cache[i][j] = 0`;若 `cache[i][j] = 1` 代表 `true`;`cache[i][j] = -1` 代表 `false`。
如此简单的改动,即可将朴素的 `DFS` 改成记忆化搜索。
Java 代码:
```Java
class Solution {
char[] cs1, cs2, cs3;
int n, m, l;
int[][] cache;
public boolean isInterleave(String s1, String s2, String s3) {
cs1 = s1.toCharArray(); cs2 = s2.toCharArray(); cs3 = s3.toCharArray();
n = s1.length(); m = s2.length(); l = s3.length();
if (n + m != l) return false;
cache = new int[n + 10][m + 10];
return dfs(0, 0);
}
boolean dfs(int i, int j) {
if (cache[i][j] != 0) return cache[i][j] == 1;
if (i + j == l) return true;
boolean ans = false;
if (i < n && cs1[i] == cs3[i + j]) ans |= dfs(i + 1, j);
if (j < m && cs2[j] == cs3[i + j]) ans |= dfs(i, j + 1);
cache[i][j] = ans ? 1 : -1;
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool isInterleave(string s1, string s2, string s3) {
int n = s1.length(), m = s2.length(), l = s3.length();
if (n + m != l) return false;
vector<vector<int>> cache(n + 10, vector<int>(m + 10, 0));
function<bool(int, int)> dfs = [&](int i, int j) {
if (cache[i][j] != 0) return cache[i][j] == 1;
if (i + j == l) return true;
bool ans = false;
if (i < n && s1[i] == s3[i + j]) ans |= dfs(i + 1, j);
if (j < m && s2[j] == s3[i + j]) ans |= dfs(i, j + 1);
cache[i][j] = ans ? 1 : -1;
return ans;
};
return dfs(0, 0);
}
};
```
Python 代码:
```Python
class Solution:
def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
n, m, l = len(s1), len(s2), len(s3)
if n + m != l:
return False
@lru_cache
def dfs(i, j):
if i + j == l:
return True
ans = False
if i < n and s1[i] == s3[i + j]:
ans |= dfs(i + 1, j)
if j < m and s2[j] == s3[i + j]:
ans |= dfs(i, j + 1)
return ans
return dfs(0, 0)
```
TypeScript 代码:
```TypeScript
function isInterleave(s1: string, s2: string, s3: string): boolean {
const n = s1.length, m = s2.length, l = s3.length;
if (n + m !== l) return false;
const cache = new Array(n + 10).fill(0).map(() => new Array(m + 10).fill(0));
const dfs = (i: number, j: number): boolean => {
if (cache[i][j] !== 0) return cache[i][j] === 1;
if (i + j === l) return true;
let ans = false;
if (i < n && s1[i] === s3[i + j]) ans ||= dfs(i + 1, j);
if (j < m && s2[j] === s3[i + j]) ans ||= dfs(i, j + 1);
cache[i][j] = ans ? 1 : -1;
return ans;
};
return dfs(0, 0);
};
```
* 时间复杂度:共有 $n \times m$ 个状态,复杂度为 $O(n \times m)$
* 空间复杂度:$O(n \times m)$
---
### 线性 DP
直接将「记忆化搜索」中的缓存器修改为我们的动态规划状态定义。
**定义 $f[i][j]$ 为使用 `s1` 的前 $i$ 个字符,使用 `s2` 的前 $j$ 个字符,能否凑出 `s3` 的前 $i + j$ 个字符**。
为了方便,我们令所有字符串的下标均从 $1$ 开始。
不失一般性,考虑 $f[i][j]$ 如何转移,根据 $s1[i]$、$s2[j]$ 和 $s3[i+j]$ 是否相等进行分析,即**根据当前 `s3` 的最后一个字符 $s3[i + j]$ 由 $s1[i]$ 和 $s2[j]$ 谁来提供进行讨论**:
* $s1[i] = s3[i + j]$:说明当前 `s3` 的最后一个字符 $s3[i + j]$ 可由 $s1[i]$ 提供,而 `s3` 此前的 $i + j - 1$ 个字符,可由 `s1` 的前 $i - 1$ 字符和 `s2` 的前 $j$ 个字符共同提供。此时若 $f[i - 1][j]$ 为真,则有 $f[i][j]$ 为真。
* $s2[j] = s3[i+j]$:说明当前 `s3` 的最后一个字符串 $s3[i+j]$ 可由 $s2[j]$ 提供,而 `s3` 此前的 $i + j - 1$ 个字符,可由 `s1` 的前 $i$ 字符和 `s2` 的前 $j - 1$ 个字符共同提供。此时若 $f[i][j - 1]$ 为真,则有 $f[i][j]$ 为真。
综上,只有上述条件任一成立,$f[i][j]$ 即为真。
一些细节:为了在转移过程中减少边界处理,我们先预处理出 $f[0][X]$ 和 $f[X][0]$ 的状态值(即 `s1`、`s2` 和 `s3` 之间的公共前缀)。
Java 代码:
```Java
class Solution {
public boolean isInterleave(String s1, String s2, String s3) {
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray(), cs3 = s3.toCharArray();
int n = s1.length(), m = s2.length(), l = s3.length();
if (n + m != l) return false;
boolean[][] f = new boolean[n + 10][m + 10];
f[0][0] = true;
for (int i = 1; i <= n && f[i - 1][0]; i++) f[i][0] = cs1[i - 1] == cs3[i - 1];
for (int i = 1; i <= m && f[0][i - 1]; i++) f[0][i] = cs2[i - 1] == cs3[i - 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (cs1[i - 1] == cs3[i + j - 1]) f[i][j] |= f[i - 1][j];
if (cs2[j - 1] == cs3[i + j - 1]) f[i][j] |= f[i][j - 1];
}
}
return f[n][m];
}
}
```
Python 代码:
```Python
class Solution:
def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
n, m, l = len(s1), len(s2), len(s3)
if n + m != l:
return False
f = [[False] * (m + 10) for _ in range(n + 10)]
f[0][0] = True
for i in range(1, n + 1):
f[i][0] = f[i - 1][0] and s1[i - 1] == s3[i - 1]
for i in range(1, m + 1):
f[0][i] = f[0][i - 1] and s2[i - 1] == s3[i - 1]
for i in range(1, n + 1):
for j in range(1, m + 1):
if s1[i - 1] == s3[i + j - 1]:
f[i][j] |= f[i - 1][j]
if s2[j - 1] == s3[i + j - 1]:
f[i][j] |= f[i][j - 1]
return f[n][m]
```
C++ 代码:
```C++
class Solution {
public:
bool isInterleave(string s1, string s2, string s3) {
int n = s1.length(), m = s2.length(), l = s3.length();
if (n + m != l) return false;
vector<vector<bool>> f(n + 10, vector<bool>(m + 10, false));
f[0][0] = true;
for (int i = 1; i <= n && f[i - 1][0]; i++) f[i][0] = (s1[i - 1] == s3[i - 1]);
for (int i = 1; i <= m && f[0][i - 1]; i++) f[0][i] = (s2[i - 1] == s3[i - 1]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s1[i - 1] == s3[i + j - 1]) f[i][j] = f[i][j] | f[i - 1][j];
if (s2[j - 1] == s3[i + j - 1]) f[i][j] = f[i][j] | f[i][j - 1];
}
}
return f[n][m];
}
};
```
TypeScript 代码:
```TypeScript
function isInterleave(s1: string, s2: string, s3: string): boolean {
const n = s1.length, m = s2.length, l = s3.length;
if (n + m !== l) return false;
const f = new Array(n + 10).fill(false).map(() => new Array(m + 10).fill(false));
f[0][0] = true;
for (let i = 1; i <= n && f[i - 1][0]; i++) f[i][0] = s1[i - 1] === s3[i - 1];
for (let i = 1; i <= m && f[0][i - 1]; i++) f[0][i] = s2[i - 1] === s3[i - 1];
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
if (s1[i - 1] === s3[i + j - 1]) f[i][j] ||= f[i - 1][j];
if (s2[j - 1] === s3[i + j - 1]) f[i][j] ||= f[i][j - 1];
}
}
return f[n][m];
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$
---
### 进阶
根据状态转移方程可知 $f[i][j]$ 仅依赖于 $f[i - 1][j]$ 和 $f[i][j - 1]$,因此可通过「滚动数组」的方式进行优化。
状态定义不变,将动规数组开成 $f[2][m + 10]$ 大小(另外一维的 `+10` 操作仅为个人习惯)。
随后,当我们需要更新 `f[i][X]` 时,需要写成 `f[i & 1][X]`;需要访问 `f[i - 1][X]` 时,则写成 `f[(i - 1) & 1][X]` 即可。
最后,同样是为了转移过程中减少边界处理,我们需要使用两个变量 `a` 和 `b` 记住 `s1` 和 `s2` 与 `s3` 的公共前缀,并特判掉 `s1` 或 `s2` 为空的情况。
Java 代码:
```Java
class Solution {
public boolean isInterleave(String s1, String s2, String s3) {
char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray(), cs3 = s3.toCharArray();
int n = s1.length(), m = s2.length(), l = s3.length();
if (n + m != l) return false;
int a = 0, b = 0;
while (a < n && cs1[a] == cs3[a]) a++;
while (b < m && cs2[b] == cs3[b]) b++;
if (m == 0) return n <= a;
if (n == 0) return m <= b;
boolean[][] f = new boolean[2][m + 10];
f[0][0] = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
boolean cur = false;
if (cs1[i - 1] == cs3[i + j - 1]) {
if (i == 1) cur |= j <= b;
else cur |= f[(i - 1) & 1][j];
}
if (cs2[j - 1] == cs3[i + j - 1]) {
if (j == 1) cur |= i <= a;
else cur |= f[i & 1][j - 1];
}
f[i & 1][j] = cur;
}
}
return f[n & 1][m];
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool isInterleave(string s1, string s2, string s3) {
int n = s1.length(), m = s2.length(), l = s3.length();
if (n + m != l) return false;
int a = 0, b = 0;
while (a < n && s1[a] == s3[a]) a++;
while (b < m && s2[b] == s3[b]) b++;
if (n == 0) return m <= b;
if (m == 0) return n <= a;
vector<vector<bool>> f(2, vector<bool>(m + 1, false));
f[0][0] = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
bool cur = false;
if (s1[i - 1] == s3[i + j - 1]) {
if (i == 1) cur |= j <= b;
else cur |= f[(i - 1) & 1][j];
}
if (s2[j - 1] == s3[i + j - 1]) {
if (j == 1) cur |= i <= a;
else cur |= f[i & 1][j - 1];
}
f[i & 1][j] = cur;
}
}
return f[n & 1][m];
}
};
```
Python 代码:
```Python
class Solution:
def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
n, m, l = len(s1), len(s2), len(s3)
if n + m != l:
return False
a, b = 0, 0
while a < n and s1[a] == s3[a]:
a += 1
while b < m and s2[b] == s3[b]:
b += 1
if m == 0:
return n <= a
if n == 0:
return m <= b
f = [[False for _ in range(m + 1)] for _ in range(2)]
f[0][0] = True
for i in range(1, n+1):
for j in range(1, m+1):
cur = False
if s1[i - 1] == s3[i + j - 1]:
if i == 1:
cur |= j <= b
else:
cur |= f[(i - 1) & 1][j]
if s2[j - 1] == s3[i + j - 1]:
if j == 1:
cur |= i <= a
else:
cur |= f[i & 1][j - 1]
f[i & 1][j] = cur
return f[n & 1][m]
```
TypeScript 代码:
```TypeScript
function isInterleave(s1: string, s2: string, s3: string): boolean {
const n = s1.length, m = s2.length, l = s3.length;
if (n + m !== l) return false;
let a = 0, b = 0;
while (a < n && s1[a] === s3[a]) a++;
while (b < m && s2[b] === s3[b]) b++;
if (m == 0) return n <= a;
if (n == 0) return m <= b;
const f = new Array(2).fill(null).map(() => new Array(m + 1).fill(false));
f[0][0] = true;
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= m; j++) {
let cur = false;
if (s1[i - 1] === s3[i + j - 1]) {
if (i === 1) cur ||= j <= b;
else cur ||= f[(i - 1) & 1][j];
}
if (s2[j - 1] === s3[i + j - 1]) {
if (j === 1) cur ||= i <= a;
else cur ||= f[i & 1][j - 1];
}
f[i & 1][j] = cur;
}
}
return f[n & 1][m];
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.97` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/91-100/99. 恢复二叉搜索树（中等）.md | 99. 恢复二叉搜索树 | https://leetcode.cn/problems/recover-binary-search-tree/solutions/2431878/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-4po4/ | 中等 | [
"二叉树",
"树的搜索",
"递归",
"迭代",
"中序遍历",
"Morris 遍历"
] | 给你二叉搜索树的根节点 `root`,该树中的 恰好 两个节点的值被错误地交换。
请在不改变其结构的情况下,恢复这棵树 。
示例 1:
```
输入:root = [1,3,null,null,2]
输出:[3,1,null,null,2]
解释:3 不能是 1 的左孩子,因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。
```
示例 2:
```
输入:root = [3,1,4,null,null,2]
输出:[2,1,4,null,null,3]
解释:2 不能在 3 的右子树中,因为 2 < 3 。交换 2 和 3 使二叉搜索树有效。
```
提示:
* 树上节点的数目在范围 $[2, 1000]$ 内
* $-2^{31} <= Node.val <= 2^{31} - 1$
进阶:使用 $O(n)$ 空间复杂度的解法很容易实现。你能想出一个只使用 $O(1)$ 空间的解决方案吗? | ### 基本分析
首先,别想复杂了。
所谓的恢复二叉树(两节点互换),只需要将两节点的 `val` 进行互换即可,而不需要对节点本身进行互换。
---
### 中序遍历 - 递归 & 迭代
二叉搜索树,其中序遍历是有序的。
要找到哪两个节点被互换,可通过比对中序遍历序列来实现。
但将整个中序遍历序列保存下来,再检测序列有序性的做法,复杂度是 $O(n)$ 的(不要说题目要求的 $O(1)$,连 $O(h)$ 都达不到)。
所以第一步,**这个「递归 & 迭代」的次优解,我们先考虑如何做到 $O(h)$ 的空间复杂度,即在中序遍历过程中找到互换节点**。
其实也很简单,除了使用 `a` 和 `b` 来记录互换节点,额外使用变量 `last` 来记录当前遍历过程中的前一节点即可:
若存在前一节点 `last` 存在,而且满足前一节点值大于当前节点(`last.val > root.val`),违反“有序性”,根据是否为首次出现该情况分情况讨论:
* 若是首次满足条件,即 `a == null`,此时上一节点 `last` 必然是两个互换节点之一,而当前 `root` 只能说是待定,因为有可能是 `last` 和 `root` 实现互换,也有可能是 `last` 和后续的某个节点实现互换。
此时有 `a = last, b = root`
* 若是非首次满足条件,即 `a != null`,此时当前节点 `root` 必然是两个互换节点中的另外一个。
此时有 `b = root`
综上:如果整个中序遍历的序列中“逆序对”为一对,那么互换节点为该“逆序对”的两个成员;若“逆序对”数量为两对,则互换节点为「第一对“逆序对”的首个节点」和「第二对“逆序对”的第二个节点」。
Java 代码(递归):
```Java
class Solution {
TreeNode a = null, b = null, last = null;
public void recoverTree(TreeNode root) {
dfs(root);
int val = a.val;
a.val = b.val;
b.val = val;
}
void dfs(TreeNode root) {
if (root == null) return ;
dfs(root.left);
if (last != null && last.val > root.val) {
if (a == null) {
a = last; b = root;
} else {
b = root;
}
}
last = root;
dfs(root.right);
}
}
```
Java 代码(迭代):
```Java
class Solution {
public void recoverTree(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
TreeNode a = null, b = null, last = null;
while (root != null || !d.isEmpty()) {
while (root != null) {
d.addLast(root);
root = root.left;
}
root = d.pollLast();
if (last != null && last.val > root.val) {
if (a == null) {
a = last; b = root;
} else {
b = root;
}
}
last = root;
root = root.right;
}
int val = a.val;
a.val = b.val;
b.val = val;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(h)$,其中 $h$ 为树高
---
### 中序遍历 - Morris 遍历
Morris 遍历也就是经常说到的“神级遍历”,其本质是通过做大常数来降低空间复杂度。
还是以二叉树的中序遍历为例,无论是递归或是迭代,为了在遍历完左节点(也可以是左子树)时,仍能回到父节点,我们需要使用数据结构栈,只不过在递归做法中是用函数调用充当栈,而在迭代做法则是显式栈。
**这使得空间复杂度为 $O(h)$,而 Morris 遍历的核心则是利用“路径底部节点”中的空闲指针进行线索。**
举个 🌰,对于一棵最简单的二叉树:
在中序遍历过程中,如果选择递归或迭代方式,并且不使用栈的情况,当遍历完左子节点(或左子树的最后一个节点)后,将会面临无法返回根节点的问题。
在 Morris 遍历中,从根节点开始,尚未真正遍历左子节点之前,就会先建立「左子节点(或左子树的最后一个节点)」与「当前根节点」之间的链接,从而避免使用栈。
具体的,Morris 遍历的中序遍历遵循如下流程(喜欢的话可以背过):
1. 令根节点为当前节点
2. 只要当前节点不为空(`while (root != null) `),重复执行如下流程:
* 若当前节点的左子节点为空(`root.left = null`),将当前节点更新为其右子节点(`root = root.right`)
* 若当前节点的左子节点不为空,利用临时变量 `t` 存储,找到当前节点的前驱节点(左子树中最后一个节点):
* 若前驱节点的右子节点为空(`t.right = null`),将前驱节点的右子节点链接到当前节点(`t.right = root`),并将当前节点更新为左子节点(`root = root.left`)
* 若前驱节点的右子节点不为空,说明已链接到当前节点,此时将前驱节点的右子节点置空(删除链接 `t.right = null`),遍历当前节点,并将当前节点更新为右子节点(`root = root.right`)
Java 代码:
```Java
class Solution {
public void recoverTree(TreeNode root) {
TreeNode a = null, b = null, last = null;
while (root != null) {
if (root.left == null) {
if (last != null && last.val > root.val) {
if (a == null) {
a = last; b = root;
} else {
b = root;
}
}
last = root;
root = root.right;
} else {
TreeNode t = root.left;
while (t.right != null && t.right != root) t = t.right;
if (t.right == null) { // 若前驱节点右子树为空, 说明是真正遍历左子树前, 建立与当前根节点的链接, 然后开始真正遍历左子树
t.right = root;
root = root.left;
} else { // 若已存在链接, 说明是第二次访问根节点, 左子树(前驱节点)已遍历完, 此时应该解开链接, 遍历当前节点以及右子树
t.right = null;
if (last != null && last.val > root.val) {
if (a == null) {
a = last; b = root;
} else {
b = root;
}
}
last = root;
root = root.right;
}
}
}
int val = a.val;
a.val = b.val;
b.val = val;
}
}
```
C++ 代码:
```C++
class Solution {
public:
void recoverTree(TreeNode* root) {
TreeNode *a = nullptr, *b = nullptr, *last = nullptr;
while (root != nullptr) {
if (root->left == nullptr) {
if (last != nullptr && last->val > root->val) {
if (a == nullptr) {
a = last; b = root;
} else {
b = root;
}
}
last = root;
root = root->right;
} else {
TreeNode *t = root->left;
while (t->right != nullptr && t->right != root) t = t->right;
if (t->right == nullptr) {
t->right = root;
root = root->left;
} else {
t->right = nullptr;
if (last != nullptr && last->val > root->val) {
if (a == nullptr) {
a = last, b = root;
} else {
b = root;
}
}
last = root;
root = root->right;
}
}
}
swap(a->val, b->val);
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.99` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/911. 在线选举（中等）.md | 911. 在线选举 | https://leetcode-cn.com/problems/online-election/solution/gong-shui-san-xie-er-fen-yun-yong-ti-by-5y3hi/ | 中等 | [
"二分"
] | 给你两个整数数组 $persons$ 和 $times$ 。
在选举中,第 $i$ 张票是在时刻为 $times[i]$ 时投给候选人 $persons[i]$ 的。
对于发生在时刻 $t$ 的每个查询,需要找出在 t 时刻在选举中领先的候选人的编号。
在 $t$ 时刻投出的选票也将被计入我们的查询之中。在平局的情况下,最近获得投票的候选人将会获胜。
实现 TopVotedCandidate 类:
* `TopVotedCandidate(int[] persons, int[] times)` 使用 $persons$ 和 $times$ 数组初始化对象。
* `int q(int t)` 根据前面描述的规则,返回在时刻 $t$ 在选举中领先的候选人的编号。
示例:
```
输入:
["TopVotedCandidate", "q", "q", "q", "q", "q", "q"]
[[[0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]], [3], [12], [25], [15], [24], [8]]
输出:
[null, 0, 1, 1, 0, 0, 1]
解释:
TopVotedCandidate topVotedCandidate = new TopVotedCandidate([0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]);
topVotedCandidate.q(3); // 返回 0 ,在时刻 3 ,票数分布为 [0] ,编号为 0 的候选人领先。
topVotedCandidate.q(12); // 返回 1 ,在时刻 12 ,票数分布为 [0,1,1] ,编号为 1 的候选人领先。
topVotedCandidate.q(25); // 返回 1 ,在时刻 25 ,票数分布为 [0,1,1,0,0,1] ,编号为 1 的候选人领先。(在平局的情况下,1 是最近获得投票的候选人)。
topVotedCandidate.q(15); // 返回 0
topVotedCandidate.q(24); // 返回 0
topVotedCandidate.q(8); // 返回 1
```
提示:
* $1 <= persons.length <= 5000$
* $times.length == persons.length$
* $0 <= persons[i] < persons.length$
* $0 <= times[i] <= 10^9$
* $times$ 是一个严格递增的有序数组
* $times[0] <= t <= 10^9$
* 每个测试用例最多调用 $10^4$ 次 `q` | ### 二分
根据题意,我们会在 $times[i]$ 时刻为 $persons[i]$ 候选人增加一票。
**利用 $times$ 数组严格递增,我们可以在处理 $times$ 时(模拟加票过程),使用一个变量 $val$ 来维护当前得票的最大数量,使用 $list$ 来记录不同时刻点的候选人交替情况。**
起始时 $val = 0$,当出现票数大于等于 $val$ 时,我们往 $list$ 追加二元组记录 $list[idx] = (times[i], persons[i])$,并更新 $val$。
**每个 $list[idx]$ 代表了当前候选人 $list[idx][1]$ 的首次当选时刻为 $list[idx][0]$。**
举个 🌰,若 $i = list[idx][0], j = list[idx + 1][0]$,则意味着在时间段 $[i, j)$ 内当选的候选人为 $list[idx][1]$。
在查询时,我们只需要通过「二分」找到 $list$ 中满足 $list[i][0] <= t$ 的分割点 $r$(最大下标),取 $list[r][1]$ 即是答案。
代码:
```Java
class TopVotedCandidate {
List<int[]> list = new ArrayList<>();
public TopVotedCandidate(int[] persons, int[] times) {
int val = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < times.length; i++) {
map.put(persons[i], map.getOrDefault(persons[i], 0) + 1);
if (map.get(persons[i]) >= val) {
val = map.get(persons[i]);
list.add(new int[]{times[i], persons[i]});
}
}
}
public int q(int t) {
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid)[0] <= t) l = mid;
else r = mid - 1;
}
return list.get(r)[0] <= t ? list.get(r)[1] : 0;
}
}
```
* 时间复杂度:令 $n$ 为数组长度,$m$ 为查询次数(调用 `q` 的次数)。预处理出 $list$ 的复杂度为 $O(n)$;最坏情况下,每个 $time[i]$ 时刻都会交替产生新的候选人编号,即最坏情况下 $list$ 的数组长度为 $n$,总的查询复杂度为 $O(m * \log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.911` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/913. 猫和老鼠（困难）.md | 913. 猫和老鼠 | https://leetcode-cn.com/problems/cat-and-mouse/solution/gong-shui-san-xie-dong-tai-gui-hua-yun-y-0bx1/ | 困难 | [
"动态规划",
"记忆化搜索"
] | 两位玩家分别扮演猫和老鼠,在一张**无向**图上进行游戏,两人轮流行动。
图的形式是:`graph[a]` 是一个列表,由满足 `ab` 是图中的一条边的所有节点 `b` 组成。
老鼠从节点 `1` 开始,第一个出发;猫从节点 `2` 开始,第二个出发。在节点 `0` 处有一个洞。
在每个玩家的行动中,他们 必须 沿着图中与所在当前位置连通的一条边移动。
例如,如果老鼠在节点 `1` ,那么它必须移动到 `graph[1]` 中的任一节点。
此外,猫无法移动到洞中(节点 `0`)。
然后,游戏在出现以下三种情形之一时结束:
如果猫和老鼠出现在同一个节点,猫获胜。
如果老鼠到达洞中,老鼠获胜。
如果某一位置重复出现(即,玩家的位置和移动顺序都与上一次行动相同),游戏平局。
给你一张图 `graph`,并假设两位玩家都都以最佳状态参与游戏:
* 如果老鼠获胜,则返回 `1`;
* 如果猫获胜,则返回 `2`;
* 如果平局,则返回 `0` 。
示例 1:
```
输入:graph = [[2,5],[3],[0,4,5],[1,4,5],[2,3],[0,2,3]]
输出:0
```
示例 2:
```
输入:graph = [[1,3],[0],[3],[0,2]]
输出:1
```
提示:
* 3 <= graph.length <= 50
* 1 <= graph[i].length < graph.length
* 0 <= graph[i][j] < graph.length
* graph[i][j] != i
* graph[i] 互不相同
* 猫和老鼠在游戏中总是移动 | ### 动态规划
数据范围只有 $50$,使得本题的难度大大降低。
**定义 $f[k][i][j]$ 为当前进行了 $k$ 步,老鼠所在位置为 $i$,猫所在的位置为 $j$ 时,最终的获胜情况($0$ 为平局,$1$ 和 $2$ 分别代表老鼠和猫获胜),起始我们让所有的 $f[k][i][j] = -1$(为无效值),最终答案为 $f[0][1][2]$。**
不失一般性的考虑 $f[i][j][k]$ 该如何转移,根据题意,将当前所在位置 $i$ 和 $j$ 结合「游戏结束,判定游戏」的规则来分情况讨论:
* 若 $i = 0$,说明老鼠位于洞中,老鼠获胜,此时有 $f[k][i][j] = 1$;
* 若 $i = j$,说明两者为与同一位置,猫获胜,此时有 $f[k][i][j] = 2$;
* 考虑如何定义平局,即 $f[k][i][j] = 0$ 的情况?
我们最多有 $n$ 个位置,因此 $(i, j)$ 位置对组合数最多为 $n^2$ 种,然后 $k$ 其实代表的是老鼠先手还是猫先手,共有 $2$ 种可能,因此状态数量数据有明确上界为 $2 * n^2$。
所以我们可以设定 $k$ 的上界为 $2 * n^2$(抽屉原理,走超过 $2 * n^2$ 步,必然会有相同的局面出现过至少两次),但是这样的计算量为 $2 * 50^2 * 50 * 50 = 1.25 * 10^7$,有 `TLE` 风险,转移过程增加剪枝,可以过。
而更小的 $k$ 值需要证明:在最优策略中,相同局面(状态)成环的最大长度的最小值为 $k$。
题目规定轮流移动,且只能按照 $graph$ 中存在的边进行移动。
1. 如果当前 $k$ 为偶数(该回合老鼠移动),此时所能转移所有点为 $f[k + 1][ne][j]$,其中 $ne$ 为 $i$ 所能到达的点。由于采用的是最优移动策略,因此 $f[k][i][j]$ 会优先往 $f[k + 1][ne][j] = 1$ 的点移动(自身获胜),否则往 $f[k + 1][ne][j] = 0$ 的点移动(平局),再否则才是往 $f[k + 1][ne][j] = 2$ 的点移动(对方获胜);
2. 同理,如果当前 $k$ 为奇数(该回合猫移动),此时所能转移所有点为 $f[k + 1][i][ne]$,其中 $ne$ 为 $j$ 所能到达的点。由于采用的是最优移动策略,因此 $f[k][i][j]$ 会优先往 $f[k + 1][i][ne] = 2$ 的点移动(自身获胜),否则往 $f[k + 1][i][ne] = 0$ 的点移动(平局),再否则才是往 $f[k + 1][i][ne] = 1$ 的点移动(对方获胜)。
使用该转移优先级进行递推即可,为了方便我们使用「记忆化搜索」的方式来实现动态规划。
注意,该优先级转移其实存在「贪心」决策,但证明这样的决策会使得「最坏情况最好」是相对容易的,而证明存在更小的 $k$ 值才是本题难点。
> 一些细节:由于本身就要对动规数组进行无效值的初始化,为避免每个样例都 `new` 大数组,我们使用 `static` 来修饰大数组,可以有效减少一点时间(不使用 `static` 的话,`N` 只能取到 $51$)。
代码:
```Java
class Solution {
static int N = 55;
static int[][][] f = new int[2 * N * N][N][N];
int[][] g;
int n;
public int catMouseGame(int[][] graph) {
g = graph;
n = g.length;
for (int k = 0; k < 2 * n * n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
f[k][i][j] = -1;
}
}
}
return dfs(0, 1, 2);
}
// 0:draw / 1:mouse / 2:cat
int dfs(int k, int a, int b) {
int ans = f[k][a][b];
if (a == 0) ans = 1;
else if (a == b) ans = 2;
else if (k >= 2 * n * n) ans = 0;
else if (ans == -1) {
if (k % 2 == 0) { // mouse
boolean win = false, draw = false;
for (int ne : g[a]) {
int t = dfs(k + 1, ne, b);
if (t == 1) win = true;
else if (t == 0) draw = true;
if (win) break;
}
if (win) ans = 1;
else if (draw) ans = 0;
else ans = 2;
} else { // cat
boolean win = false, draw = false;
for (int ne : g[b]) {
if (ne == 0) continue;
int t = dfs(k + 1, a, ne);
if (t == 2) win = true;
else if (t == 0) draw = true;
if (win) break;
}
if (win) ans = 2;
else if (draw) ans = 0;
else ans = 1;
}
}
f[k][a][b] = ans;
return ans;
}
}
```
* 时间复杂度:状态的数量级为 $n^4$,可以确保每个状态只会被计算一次。复杂度为 $O(n^4)$
* 空间复杂度:$O(n^4)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.913` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/915. 分割数组（中等）.md | 915. 分割数组 | https://leetcode.cn/problems/partition-array-into-disjoint-intervals/solution/by-ac_oier-yyen/ | 中等 | [
"模拟"
] | 给定一个数组 `nums`,将其划分为两个连续子数组 `left` 和 `right`,使得:
* `left` 中的每个元素都小于或等于 `right` 中的每个元素。
* `left` 和 `right` 都是非空的。
* `left` 的长度要尽可能小。
在完成这样的分组后返回 `left` 的长度。
用例可以保证存在这样的划分方法。
示例 1:
```
输入:nums = [5,0,3,8,6]
输出:3
解释:left = [5,0,3],right = [8,6]
```
示例 2:
```
输入:nums = [1,1,1,0,6,12]
输出:4
解释:left = [1,1,1,0],right = [6,12]
```
提示:
* $2 <= nums.length <= 10^5$
* $0 <= nums[i] <= 10^6$
* 可以保证至少有一种方法能够按题目所描述的那样对 `nums` 进行划分。 | ### 模拟
根据题意,我们知道本质是求分割点,使得分割点的「左边的子数组的最大值」小于等于「右边的子数组的最小值」。
我们可以先通过一次遍历(从后往前)统计出所有后缀的最小值 `min`,其中 `min[i] = x` 含义为下标范围在 $[i, n - 1]$ 的 $nums[i]$ 的最小值为 `x`,然后再通过第二次遍历(从前往后)统计每个前缀的最大值(使用单变量进行维护),找到第一个符合条件的分割点即是答案。
Java 代码:
```Java
class Solution {
public int partitionDisjoint(int[] nums) {
int n = nums.length;
int[] min = new int[n + 10];
min[n - 1] = nums[n - 1];
for (int i = n - 2; i >= 0; i--) min[i] = Math.min(min[i + 1], nums[i]);
for (int i = 0, max = 0; i < n - 1; i++) {
max = Math.max(max, nums[i]);
if (max <= min[i + 1]) return i + 1;
}
return -1; // never
}
}
```
C++ 代码:
```C++
class Solution {
public:
int partitionDisjoint(vector<int>& nums) {
int n = nums.size();
vector<int> arr(n + 10);
arr[n - 1] = nums[n - 1];
for (int i = n - 2; i >= 0; i--) arr[i] = min(arr[i + 1], nums[i]);
int maxv = 0;
for (int i = 0; i < n - 1; i++) {
maxv = max(maxv, nums[i]);
if (maxv <= arr[i + 1]) return i + 1;
}
return -1; // never
}
};
```
Python 代码:
```Python
class Solution:
def partitionDisjoint(self, nums: List[int]) -> int:
n = len(nums)
minv = [0] * (n + 10)
minv[n - 1] = nums[n - 1]
for i in range(n - 2, -1, -1):
minv[i] = min(minv[i + 1], nums[i])
maxv = 0
for i in range(n - 1):
maxv = max(maxv, nums[i])
if maxv <= minv[i + 1]:
return i + 1
return -1
```
TypeScript 代码:
```TypeScript
function partitionDisjoint(nums: number[]): number {
const n = nums.length
const min = new Array<number>(n + 10).fill(nums[n - 1])
for (let i = n - 2; i >= 0; i--) min[i] = Math.min(min[i + 1], nums[i])
for (let i = 0, max = 0; i < n; i++) {
max = Math.max(max, nums[i])
if (max <= min[i + 1]) return i + 1
}
return -1
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.915` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/917. 仅仅反转字母（简单）.md | 917. 仅仅反转字母 | https://leetcode-cn.com/problems/reverse-only-letters/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-xrpt/ | 简单 | [
"双指针"
] | 给你一个字符串 `s` ,根据下述规则反转字符串:
* 所有非英文字母保留在原有位置。
* 所有英文字母(小写或大写)位置反转。
返回反转后的 `s` 。
示例 1:
```
输入:s = "ab-cd"
输出:"dc-ba"
```
示例 2:
```
输入:s = "a-bC-dEf-ghIj"
输出:"j-Ih-gfE-dCba"
```
示例 3:
```
输入:s = "Test1ng-Leet=code-Q!"
输出:"Qedo1ct-eeLg=ntse-T!"
```
提示
* $1 <= s.length <= 100$
* `s` 仅由 `ASCII` 值在范围 $[33, 122]$ 的字符组成
* `s` 不含 `'\"'` 或 `'\\'` | ### 双指针
根据题意进行模拟即可,每次都使用 `i` 和 `j` 分别指向左端和右端可以被交换的字母,若当前指针指向的不是字母,则分别往中间移动,直到找到下一个可交换的字母位置,每次交换结束,两指针均往中间移动一位。
代码:
```Java
class Solution {
public String reverseOnlyLetters(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
for (int i = 0, j = n - 1; i < j; ) {
while (i < j && !Character.isLetter(cs[i])) i++;
while (i < j && !Character.isLetter(cs[j])) j--;
if (i < j) {
char c = cs[i];
cs[i++] = cs[j];
cs[j--] = c;
}
}
return String.valueOf(cs);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:调用 `toCharArray` 和构造新字符串均需要与字符串长度等同的空间。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.917` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/911-920/919. 完全二叉树插入器（中等）.md | 919. 完全二叉树插入器 | https://leetcode.cn/problems/complete-binary-tree-inserter/solution/by-ac_oier-t9dh/ | 中等 | [
"模拟",
"BFS",
"树的遍历"
] | 完全二叉树 是每一层(除最后一层外)都是完全填充(即,节点数达到最大)的,并且所有的节点都尽可能地集中在左侧。
设计一种算法,将一个新节点插入到一个完整的二叉树中,并在插入后保持其完整。
实现 `CBTInserter` 类:
* `CBTInserter(TreeNode root)` 使用头节点为 `root` 的给定树初始化该数据结构;
* `CBTInserter.insert(int v)` 向树中插入一个值为 `Node.val == val` 的新节点 `TreeNode`。使树保持完全二叉树的状态,并返回插入节点 `TreeNode` 的父节点的值
* `CBTInserter.get_root()` 将返回树的头节点。
示例 1:
```
输入
["CBTInserter", "insert", "insert", "get_root"]
[[[1, 2]], [3], [4], []]
输出
[null, 1, 2, [1, 2, 3, 4]]
解释
CBTInserter cBTInserter = new CBTInserter([1, 2]);
cBTInserter.insert(3); // 返回 1
cBTInserter.insert(4); // 返回 2
cBTInserter.get_root(); // 返回 [1, 2, 3, 4]
```
提示:
* 树中节点数量范围为 $[1, 1000]$
* $0 <= Node.val <= 5000$
* `root` 是完全二叉树
* $0 <= val <= 5000 $
* 每个测试用例最多调用 `insert` 和 `get_root` 操作 $10^4$ 次 | ### BFS
起始使用数组对构造函数传入的 `root` 进行 `BFS` 层序遍历(由于仍要保留层序遍历顺序,因此使用下标指针 `cur` 来模拟出队位置)。
对于 `insert` 操作而言,我们要在数组(层序遍历顺序)中找到首个「存在左右空子节点」的父节点 `fa`,由于找到 `fa` 节点的过程数组下标单调递增,因此可以使用全局变量 `idx` 不断往后搜索,每次将新节点 `node` 添加到当前树后,需要将 `node` 添加到数组尾部。
`get_root` 操作则始终返回数组首位元素即可。
Java 代码:
```Java
class CBTInserter {
List<TreeNode> list = new ArrayList<>();
int idx = 0;
public CBTInserter(TreeNode root) {
list.add(root);
int cur = 0;
while (cur < list.size()) {
TreeNode node = list.get(cur);
if (node.left != null) list.add(node.left);
if (node.right != null) list.add(node.right);
cur++;
}
}
public int insert(int val) {
TreeNode node = new TreeNode(val);
while (list.get(idx).left != null && list.get(idx).right != null) idx++;
TreeNode fa = list.get(idx);
if (fa.left == null) fa.left = node;
else if (fa.right == null) fa.right = node;
list.add(node);
return fa.val;
}
public TreeNode get_root() {
return list.get(0);
}
}
```
TypeScript 代码:
```TypeScript
class CBTInserter {
list: TreeNode[] = new Array<TreeNode>()
idx: number = 0
constructor(root: TreeNode | null) {
this.list.push(root)
let cur = 0
while (cur < this.list.length) {
const node = this.list[cur]
if (node.left != null) this.list.push(node.left)
if (node.right != null) this.list.push(node.right)
cur++
}
}
insert(val: number): number {
const node = new TreeNode(val)
while (this.list[this.idx].left != null && this.list[this.idx].right != null) this.idx++
const fa = this.list[this.idx]
if (fa.left == null) fa.left = node
else if (fa.right == null) fa.right = node
this.list.push(node)
return fa.val
}
get_root(): TreeNode | null {
return this.list[0]
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.919` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/921. 使括号有效的最少添加（中等）.md | 921. 使括号有效的最少添加 | https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid/solution/by-ac_oier-9tn1/ | 中等 | [
"模拟"
] | 只有满足下面几点之一,括号字符串才是有效的:
* 它是一个空字符串,或者
* 它可以被写成 `AB` (`A` 与 `B` 连接), 其中 `A` 和 `B` 都是有效字符串,或者
* 它可以被写作 (`A`),其中 `A` 是有效字符串。
给定一个括号字符串 `s` ,移动 `N` 次,你就可以在字符串的任何位置插入一个括号。
* 例如,如果 `s = "()))"` ,你可以插入一个开始括号为 `"(()))"` 或结束括号为 `"())))"` 。
返回 为使结果字符串 `s` 有效而必须添加的最少括号数。
示例 1:
```
输入:s = "())"
输出:1
```
示例 2:
```
输入:s = "((("
输出:3
```
提示:
* $1 <= s.length <= 1000$
* `s` 只包含 `'('` 和 `')'` 字符 | ### 模拟
一个介绍过很多次的做法 : 将「有效括号问题」转化为「分值有效性」的数学判定。
使用 `score` 代指处理过程中的得分,将 `(` 记为 `+1`,将 `)` 记为 `-1`。
一个有效的括号应当在整个过程中不出现负数,因此一旦 `score` 出现负数,我们需要马上增加 `(` 来确保合法性;当整个 `s` 处理完后,还需要添加 `socre` 等同的 `)` 来确保合法性。
Java 代码:
```Java
class Solution {
public int minAddToMakeValid(String s) {
int score = 0, ans = 0;
for (char c : s.toCharArray()) {
score += c == '(' ? 1 : -1;
if (score < 0) {
score = 0; ans++;
}
}
return ans + score;
}
}
```
TypeScript 代码:
```TypeScript
function minAddToMakeValid(s: string): number {
let scroe = 0, ans = 0
for (const c of s) {
scroe += c == '(' ? 1 : -1
if (scroe < 0) {
scroe = 0; ans++
}
}
return ans + scroe
};
```
Python 代码:
```Python
class Solution:
def minAddToMakeValid(self, s: str) -> int:
score, ans = 0, 0
for c in s:
score += 1 if c == '(' else -1
if score < 0:
score = 0
ans += 1
return ans + score
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用 `charAt` 代替 `toCharArray` 操作,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.921` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/926. 将字符串翻转到单调递增（中等）.md | 926. 将字符串翻转到单调递增 | https://leetcode.cn/problems/flip-string-to-monotone-increasing/solution/by-ac_oier-h0we/ | 中等 | [
"LIS",
"序列 DP",
"贪心",
"二分",
"动态规划",
"前缀和",
"枚举",
"容斥原理"
] | 如果一个二进制字符串,是以一些 $0$(可能没有 $0$)后面跟着一些 $1$(也可能没有 $1$)的形式组成的,那么该字符串是 单调递增 的。
给你一个二进制字符串 `s`,你可以将任何 $0$ 翻转为 $1$ 或者将 $1$ 翻转为 $0$ 。
返回使 `s` 单调递增的最小翻转次数。
示例 1:
```
输入:s = "00110"
输出:1
解释:翻转最后一位得到 00111.
```
示例 2:
```
输入:s = "010110"
输出:2
解释:翻转得到 011111,或者是 000111。
```
示例 3:
```
输入:s = "00011000"
输出:2
解释:翻转得到 00000000。
```
提示:
* $1 <= s.length <= 10^5$
* `s[i]` 为 `'0'` 或 `'1'` | ### LIS 问题贪心解
根据题意,不难想到将原题进行等价转换:**令 `s` 长度为 $n$,原问题等价于在 `s` 中找到最长不下降子序列,设其长度为 $ans$,那么对应的 $n - ans$ 即是答案。**
由于数据范围为 $1e5$,因此我们需要使用 `LIS` 问题的贪心求解方式:**使用 `g` 数组记录每个长度的最小结尾元素,即 `g[len] = x` 含义为长度为 $len$ 的最长不下降子序列的结尾元素为 $x$,然后在从前往后处理每个 $t = s[i]$ 时,由于是求解「最长不下降子序列」,等价于找「满足大于 $t$ 的最小下标」,这可以运用「二分」进行求解。**
> 不了解 `LIS` 问题或者不清楚 `LIS` 问题贪心解法的同学可以看前置 🧀 : **[LCS 问题与 LIS 问题的相互关系,以及 LIS 问题的最优解证明](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892)**,里面详细讲解了 `LIS` 贪心解的正确性证明,以及 `LCS` 和 `LIS` 在特定条件下存在的内在联系。
代码:
```Java
class Solution {
public int minFlipsMonoIncr(String s) {
char[] cs = s.toCharArray();
int n = cs.length, ans = 0;
int[] g = new int[n + 10];
Arrays.fill(g, n + 10);
for (int i = 0; i < n; i++) {
int t = s.charAt(i) - '0';
int l = 1, r = i + 1;
while (l < r) {
int mid = l + r >> 1;
if (g[mid] > t) r = mid;
else l = mid + 1;
}
g[r] = t;
ans = Math.max(ans, r);
}
return n - ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 前缀和 + 枚举
更进一步,利用 `s` 只存在 $0$ 和 $1$ 两种数值,我们知道最后的目标序列形如 `000...000`、`000...111` 或 `111...111` 的形式。
因此我们可以枚举目标序列的 $0$ 和 $1$ 分割点位置 $idx$(分割点是 $0$ 是 $1$ 都可以,不消耗改变次数)。
于是问题转换为:分割点 $idx$ 左边有多少个 $1$(目标序列中分割点左边均为 $0$,因此 $1$ 的个数为左边的改变次数),分割点 $idx$ 的右边有多少个 $0$(目标序列中分割点右边均为 $1$,因此 $0$ 的个数为右边的改变次数),两者之和即是分割点为 $idx$ 时的总变化次数,所有 $idx$ 的总变化次数最小值即是答案。
而求解某个点左边或者右边有多少 $1$ 和 $0$ 可通过「前缀和」进行优化。
代码:
```Java
class Solution {
public int minFlipsMonoIncr(String s) {
char[] cs = s.toCharArray();
int n = cs.length, ans = n;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (cs[i - 1] - '0');
for (int i = 1; i <= n; i++) {
int l = sum[i - 1], r = (n - i) - (sum[n] - sum[i]);
ans = Math.min(ans, l + r);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.926` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/927. 三等分（困难）.md | 927. 三等分 | https://leetcode.cn/problems/three-equal-parts/solution/by-ac_oier-9i2s/ | 困难 | [
"模拟"
] | 给定一个由 `0` 和 `1` 组成的数组 `arr`,将数组分成 `3` 个非空的部分 ,使得所有这些部分表示相同的二进制值。
如果可以做到,请返回任何 `[i, j]`,其中 `i+1 < j`,这样一来:
* `arr[0], arr[1], ..., arr[i]` 为第一部分;
* `arr[i + 1], arr[i + 2], ..., arr[j - 1]` 为第二部分;
* `arr[j], arr[j + 1], ..., arr[arr.length - 1]` 为第三部分。
* 这三个部分所表示的二进制值相等。
如果无法做到,就返回 `[-1, -1]`。
注意,在考虑每个部分所表示的二进制时,应当将其看作一个整体。例如,`[1,1,0]` 表示十进制中的 `6`,而不会是 `3`。此外,前导零也是被允许的,所以 `[0,1,1]` 和 `[1,1]` 表示相同的值。
示例 1:
```
输入:arr = [1,0,1,0,1]
输出:[0,3]
```
示例 2:
```
输入:arr = [1,1,0,1,1]
输出:[-1,-1]
```
示例 3:
```
输入:arr = [1,1,0,0,1]
输出:[0,2]
```
提示:
* $3 <= arr.length <= 3 \times 10^4$
* `arr[i]` 是 `0` 或 `1` | ### 模拟
心情不好,写的代码也不好。
就大概讲讲啥意思吧:
1. 先统计 `1` 的个数 `cnt`,若 `cnt = 0` 代表能够任意划分,直接返回 `[0, 2]`;
2. 若 `cnt` 不为 $3$ 的倍数,必然不能正常划分,返回无解 `[-1, -1]`,否则可知三段中必然每一段 `1` 的数量均为 $t = \frac{cnt}{3}$ 个;
3. 最后检查「三段中 `1` 的间隔位是否相同,后缀 `0` 个数是否相同」即可:
1. 创建二维数组 `ins` 记录三段中,相邻 `1` 之间的间隔情况,若存在间隔 `1` 不同,返回无解 `[-1, -1]`;
2. 预处理四个变量 `l1`、`l2`、`r1` 和 `r2`,分别代表能够划分出最左边 `t` 个 `1` 的左右端点,以及能够划分出最右边 `t` 个 `1` 的左右端点,同时统计最后一段的后缀 `0` 的数量 `d`,配合四个变量来检查能否划分出具有 `d` 个后缀 `0` 的前两段。
代码:
```Java
class Solution {
public int[] threeEqualParts(int[] arr) {
int[] fail = new int[]{-1, -1};
// 检查总数
int n = arr.length, cnt = 0;
for (int i = 0; i < n; i++) cnt += arr[i];
if (cnt == 0) return new int[]{0, 2};
if (cnt % 3 != 0) return fail;
// 检查间隔相对位
int t = cnt / 3;
int[][] ins = new int[3][t];
for (int i = 0, j = -1, k = 0, p = 0, idx = 0; i < n; i++) {
if (arr[i] == 0) continue;
if (j != -1) ins[p][idx++] = i - j;
if (++k == t) {
j = -1; k = 0; p++; idx = 0;
} else {
j = i;
}
}
for (int i = 0; i < t; i++) {
if (ins[0][i] == ins[1][i] && ins[0][i] == ins[2][i] && ins[1][i] == ins[2][i]) continue;
return fail;
}
// 构造答案(l1 和 l2 分别为能够划分出最左边 t 个 1 的 左右端点;r1 和 r2 分别为能够划分出最右边 t 个 1 的左右端点)
int l1 = -1, l2 = -1, r1 = -1, r2 = -1;
for (int i = 0, k = 0; i < n; i++) {
k += arr[i];
if (k == t) {
if (l1 == -1) l1 = i;
} else if (k == t + 1) {
l2 = i - 1;
break;
}
}
for (int i = n - 1, k = 0; i >= 0; i--) {
k += arr[i];
if (k == t) {
if (r2 == -1) r2 = i;
} else if (k == t + 1) {
r1 = i + 1;
break;
}
}
int d = 0; // d 为最右边一段的后缀 0 的数量
for (int i = n - 1; i >= 0; i--) {
if (arr[i] == 1) break;
d++;
}
if (l1 + d > l2 || r1 + d > r2) return fail;
return new int[]{l1 + d, r1 + d};
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.927` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/929. 独特的电子邮件地址（简单）.md | 929. 独特的电子邮件地址 | https://leetcode.cn/problems/unique-email-addresses/solution/by-ac_oier-d3zu/ | 简单 | [
"模拟"
] | 每个 有效电子邮件地址 都由一个 本地名 和一个 域名 组成,以 `'@'` 符号分隔。除小写字母之外,电子邮件地址还可以含有一个或多个 `'.'` 或 `'+'` 。
* 例如,在 `[email protected]` 中, `alice` 是 本地名 ,而 `leetcode.com` 是域名 。
如果在电子邮件地址的 本地名 部分中的某些字符之间添加句点('`.'`),则发往那里的邮件将会转发到本地名中没有点的同一地址。请注意,此规则 不适用于域名 。
* 例如,`"[email protected]”` 和 `“[email protected]”` 会转发到同一电子邮件地址。
如果在 本地名 中添加加号(`'+'`),则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件。同样,此规则 不适用于域名 。
* 例如 `[email protected]` 将转发到 `[email protected]`。
可以同时使用这两个规则。
给你一个字符串数组 `emails`,我们会向每个 `emails[i]` 发送一封电子邮件。返回实际收到邮件的不同地址数目。
示例 1:
```
输入:emails = ["[email protected]","[email protected]","[email protected]"]
输出:2
解释:实际收到邮件的是 "[email protected]" 和 "[email protected]"。
```
示例 2:
```
输入:emails = ["[email protected]","[email protected]","[email protected]"]
输出:3
```
提示:
* $1 <= emails.length <= 100$
* $1 <= emails[i].length <= 100$
* `emails[i]` 由小写英文字母、`'+'`、`'.'` 和 `'@'` 组成
* 每个 `emails[i]` 都包含有且仅有一个 `'@'` 字符
* 所有本地名和域名都不为空
* 本地名不会以 `'+'` 字符作为开头 | ### 模拟
根据题意进行模拟。
代码:
```Java
class Solution {
public int numUniqueEmails(String[] emails) {
Set<String> set = new HashSet<>();
for (String s : emails) {
StringBuilder sb = new StringBuilder();
int n = s.length(), i = 0;
boolean ok = true;
while (i < n) {
char c = s.charAt(i);
if (c == '@') break;
if (c == '.' && ++i >= 0) continue;
if (c == '+') ok = false;
if (ok) sb.append(c);
i++;
}
set.add(sb.append(s.substring(i)).toString());
}
return set.size();
}
}
```
* 时间复杂度:$O(\sum_{i = 0}^{n - 1} len(emails[i]))$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1} len(emails[i]))$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.929` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/921-930/930. 和相同的二元子数组（中等）.md | 930. 和相同的二元子数组 | https://leetcode-cn.com/problems/binary-subarrays-with-sum/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-hfoc0/ | 中等 | [
"前缀和",
"哈希表",
"双指针"
] | 给你一个二元数组 nums ,和一个整数 goal ,请你统计并返回有多少个和为 goal 的 非空 子数组。
子数组 是数组的一段连续部分。
示例 1:
```
输入:nums = [1,0,1,0,1], goal = 2
输出:4
解释:
如下面黑体所示,有 4 个满足题目要求的子数组:
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
```
示例 2:
```
输入:nums = [0,0,0,0,0], goal = 0
输出:15
```
提示:
* 1 <= nums.length <= 3 * $10^4$
* nums[i] 不是 0 就是 1
* 0 <= goal <= nums.length | ### 前缀和 + 哈希表
一个简单的想法是,先计算 $nums$ 的前缀和数组 $sum$,然后从前往后扫描 $nums$,对于右端点 $r$,通过前缀和数组可以在 $O(1)$ 复杂度内求得 $[0, r]$ 连续一段的和,根据容斥原理,我们还需要求得某个左端点 $l$,使得 $[0, r]$ 减去 $[0, l - 1]$ 和为 $t$,即满足 $sum[r] - sum[l - 1] = t$,这时候利用哈希表记录扫描过的 $sum[i]$ 的出现次数,可以实现 $O(1)$ 复杂度内求得满足要求的左端点个数。
该方法适用于 $nums[i]$ 值不固定为 $0$ 和 $1$ 的其他情况。
代码:
```Java
class Solution {
public int numSubarraysWithSum(int[] nums, int t) {
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];
Map<Integer, Integer> map = new HashMap<>();
map.put(0, 1);
int ans = 0;
for (int i = 0; i < n; i++) {
int r = sum[i + 1], l = r - t;
ans += map.getOrDefault(l, 0);
map.put(r, map.getOrDefault(r, 0) + 1);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 双指针
另外一个通用性稍差一点的做法则是利用 $nums[i]$ 没有负权值。
**$nums[i]$ 没有负权值意味着前缀和数组必然具有(非严格)单调递增特性。**
不难证明,在给定 $t$ 的情况下,当我们右端点 $r$ 往右移动时,满足条件的左端点 $l$ 必然往右移动。
实现上,我们可以使用两个左端点 $l1$ 和 $l2$,代表在给定右端点 $r$ 的前提下满足要求的左端点集合,同时使用 $s1$ 和 $s2$ 分别代表两个端点到 $r$ 这一段的和。
代码:
```Java
class Solution {
public int numSubarraysWithSum(int[] nums, int t) {
int n = nums.length;
int ans = 0;
for (int r = 0, l1 = 0, l2 = 0, s1 = 0, s2 = 0; r < n; r++) {
s1 += nums[r];
s2 += nums[r];
while (l1 <= r && s1 > t) s1 -= nums[l1++];
while (l2 <= r && s2 >= t) s2 -= nums[l2++];
ans += l2 - l1;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.930` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/933. 最近的请求次数（简单）.md | 933. 最近的请求次数 | https://leetcode-cn.com/problems/number-of-recent-calls/solution/by-ac_oier-evqe/ | 简单 | [
"分块",
"线段树(动态开点)"
] | 写一个 `RecentCounter` 类来计算特定时间范围内最近的请求。
请你实现 `RecentCounter` 类:
* `RecentCounter()` 初始化计数器,请求数为 $0$ 。
* `int ping(int t)` 在时间 $t$ 添加一个新请求,其中 $t$ 表示以毫秒为单位的某个时间,并返回过去 $3000$ 毫秒内发生的所有请求数(包括新请求)。确切地说,返回在 $[t-3000, t]$ 内发生的请求数。
保证 每次对 `ping` 的调用都使用比之前更大的 $t$ 值。
示例 1:
```
输入:
["RecentCounter", "ping", "ping", "ping", "ping"]
[[], [1], [100], [3001], [3002]]
输出:
[null, 1, 2, 3, 3]
解释:
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1); // requests = [1],范围是 [-2999,1],返回 1
recentCounter.ping(100); // requests = [1, 100],范围是 [-2900,100],返回 2
recentCounter.ping(3001); // requests = [1, 100, 3001],范围是 [1,3001],返回 3
recentCounter.ping(3002); // requests = [1, 100, 3001, 3002],范围是 [2,3002],返回 3
```
提示:
* $1 <= t <= 10^9$
* 保证每次对 `ping` 调用所使用的 $t$ 值都 严格递增
* 至多调用 `ping` 方法 $10^4$ 次 | > 以下内容(支持任意的 $[l, r]$ 查询)基于我漏看了 $t$ 递增这一条件。由于 $t$ 递增,因此往前距离大于 $3000$ 的记录无须保留,从而简化了问题,可以使用队列直接做,今天打字很多了,不补充了。
### 基本分析
根据题意,题目涉及「单点修改」和「区间查询」,根据 [区间求和问题](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 的总结,可以使用「树状数组」和「线段树」进行求解。
但是留意到 $t$ 的数据范围为 $1e9$,虽然调用次数是 $1e4$,但由于本题是「强制在线」问题,因此我们无法利用「离散化」手段来解决 `MLE` 问题,而要使用「线段树(动态开点)」来解决。
---
### 线段树(动态开点)
动态开点的优势在于,不需要事前构造空树,而是在插入操作 `update` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1 | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。
线段树的插入和查询都是 $\log{n}$ 的(如果涉及区间修改,则由懒标记来确保 $\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 = 1e4$ 分别代表值域大小和查询次数。
当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 $128M$ 可以开到 $5 * 10^6$ 以上)。
代码:
```Java
class RecentCounter {
class Node {
// ls 和 rs 分别代表当前节点(区间)的左右子节点在 tr 的下标
// val 代表在当前节点(区间)所包含的数的个数
int ls, rs, val;
}
int N = (int)1e9, M = 800010, idx = 1;
Node[] tr = new Node[M];
void update(int u, int lc, int rc, int x, int v) {
if (lc == x && rc == x) {
tr[u].val += (rc - lc + 1) * v;
return ;
}
lazyCreate(u);
int mid = lc + rc >> 1;
if (x <= mid) update(tr[u].ls, lc, mid, x, v);
else update(tr[u].rs, mid + 1, rc, x, 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);
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 = ++idx;
tr[tr[u].ls] = new Node();
}
if (tr[u].rs == 0) {
tr[u].rs = ++idx;
tr[tr[u].rs] = new Node();
}
}
void pushup(int u) {
tr[u].val = tr[tr[u].ls].val + tr[tr[u].rs].val;
}
public int ping(int t) {
update(1, 1, N, t, 1);
return query(1, 1, N, Math.max(0, t - 3000), t);
}
}
```
* 时间复杂度:令 `ping` 的调用次数为 $m$,值域大小为 $n$,线段树的插入和查询复杂度均为 $O(\log{n})$
* 空间复杂度:$O(m * \log{n})$
---
### 分块
另外一个稍有遗憾的算法是「分块」。
通常来说,值域范围为 $n = 1e9$,我们可以定义块大小为 $\sqrt{n}$,这样时空复杂度都是 $O(\sqrt{n})$。
回到本题,我们定义一个 `region` 数组,用于存储每个块所包含的数的个数。
对于在位置 $x$ 插入一个值 $v$ 而言,我们可以计算位置 $x$ 所在的块编号 $idx = \left \lfloor \frac{x}{m} \right \rfloor$,然后对块大小进行累加操作($region[idx] += x$)。同时由于在查询 $[t - 3000, t]$ 时不总是覆盖完整的块(也就是我们可能需要询问某一段的总个数,而这一段仅是块内的部分区间),因此我们需要额外记录位置 $x$ 当前所包含的总数是多少,本题值域大小达到了 $1e9$,因此不能使用静态数组来做,只能使用哈希表来实现动态记录。
我们可以分析单个 `ping` 操作的计算量/复杂度:
* `update` 操作:$O(1)$;
* `query` 操作:不限制区域大小的话,计算量为 $1e5 * C$($C$ 是一个小于 $4$ 的常数),由于存在 $[t - 3000, t]$ 的限制,相当于这部分操作全部变成块内了,计算量固定为 $3000$。
于是有通过了所有样例,居然还 `TLE` 的结果???(这是啥测评机制
但经过分析,我们知道瓶颈在于块内操作过多,我们可以利用 $[t - 3000, t]$ 来优化我们的分块算法:直接定义块大小为 $300$,然后倒推出需要多个块空间,分块算法就可以过了(~~特别说明:通过时间为 `2022-05-06`,未来可能还会有无聊的人来卡分块。~~ 我不信,卡不掉 🤣
代码:
```Java
class RecentCounter {
static int m = 300, n = (int)(1e9 / m) + 10;
static Map<Integer, Integer> map = new HashMap<>();
static int[] region = new int[n];
int getIdx(int x) {
return x / m;
}
void update(int x, int v) {
map.put(x, map.getOrDefault(x, 0) + v);
region[getIdx(x)] += v;
}
int query(int l, int r) {
int ans = 0;
if (getIdx(l) == getIdx(r)) {
for (int k = l; k <= r; k++) ans += map.getOrDefault(k, 0);
} else {
int i = l, j = r;
while (getIdx(i) == getIdx(l)) ans += map.getOrDefault(i++, 0);
while (getIdx(j) == getIdx(r)) ans += map.getOrDefault(j--, 0);
for (int k = getIdx(i); k <= getIdx(j); k++) ans += region[k];
}
return ans;
}
public RecentCounter() {
map.clear();
Arrays.fill(region, 0);
}
public int ping(int t) {
update(t, 1);
return query(Math.max(0, t - 3000), t);
}
}
```
* 时间复杂度:通常情况下:调用次数为 $m$,值域大小为 $n$,复杂度为 $O(\sqrt{n})$;本题:$O(C)$,其中 $C = 300$ 为块大小
* 空间复杂度:通常情况下:$O(m +\sqrt{n})$;本题:$O(m + M)$,其中 $M$ 为分块数组大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.933` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/934. 最短的桥（中等）.md | 934. 最短的桥 | https://leetcode.cn/problems/shortest-bridge/solution/by-ac_oier-56ly/ | 中等 | [
"并查集",
"双向 BFS"
] | 给你一个大小为 `n x n` 的二元矩阵 `g`,其中 `1` 表示陆地,`0` 表示水域。
岛是由四面相连的 `1` 形成的一个最大组,即不会与非组内的任何其他 `1` 相连,`g` 中恰好存在两座岛。
你可以将任意数量的 `0` 变为 `1` ,以使两座岛连接起来,变成一座岛。
返回必须翻转的 `0` 的最小数目。
示例 1:
```
输入:g = [[0,1],[1,0]]
输出:1
```
示例 2:
```
输入:g = [[0,1,0],[0,0,0],[0,0,1]]
输出:2
```
示例 3:
```
输入:g = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
输出:1
```
提示:
* $n = g.length = g[i].length$
* $2 <= n <= 100$
* `g[i][j]` 为 `0` 或 `1`
* `g` 中恰有两个岛 | ### 并查集 + 双向 BFS
**使用「并查集」将两个岛标记出来,然后将两个岛的点分别入队,再运用「双向 BFS」来找最短通路。**
对于所有满足 $g[i][j] = 1$ 的节点与其四联通的方向,值同为 $1$ 的节点进行并查集连通性维护。
随后建立两个队列 `d1` 和 `d2` 分别存储两个岛的节点(以二元组 $(x, y)$ 的方式出入队),并使用两个哈希表 `m1` 和 `m2` 来记录从两岛屿出发到达该节点所消耗的步数(以节点的一维编号为 `key`,以消耗步数为 `value`)。
最后是使用「双向 BFS」来求解使两岛屿联通的最小通路:每次从队列中较少的进行拓展,只有尚未被处理过的节点(没有被当前哈希表所记录)才进行入队并更新消耗步数,当拓展节点在另外一个队列对应的哈希表表中出现过,说明找到了最短通路。
Java 代码:
```Java
class Solution {
static int N = 10010;
static int[] p = new int[N];
static int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
int n;
int getIdx(int x, int y) {
return x * n + y;
}
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void union(int x, int y) {
p[find(x)] = p[find(y)];
}
public int shortestBridge(int[][] g) {
n = g.length;
for (int i = 0; i <= n * n; i++) p[i] = i;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 0) continue;
for (int[] di : dirs) {
int x = i + di[0], y = j + di[1];
if (x < 0 || x >= n || y < 0 || y >= n) continue;
if (g[x][y] == 0) continue;
union(getIdx(i, j), getIdx(x, y));
}
}
}
int a = -1, b = -1;
Deque<int[]> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
Map<Integer, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 0) continue;
int idx = getIdx(i, j), root = find(idx);
if (a == -1) a = root;
else if (a != root && b == -1) b = root;
if (root == a) {
d1.addLast(new int[]{i, j});
m1.put(idx, 0);
} else if (root == b) {
d2.addLast(new int[]{i, j});
m2.put(idx, 0);
}
}
}
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 - 1;
}
return -1; // never
}
int update(Deque<int[]> d, Map<Integer, Integer> m1, Map<Integer, Integer> m2) {
int sz = d.size();
while (sz-- > 0) {
int[] info = d.pollFirst();
int x = info[0], y = info[1], idx = getIdx(x, y), step = m1.get(idx);
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny);
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
if (m1.containsKey(nidx)) continue;
if (m2.containsKey(nidx)) return step + 1 + m2.get(nidx);
d.addLast(new int[]{nx, ny});
m1.put(nidx, step + 1);
}
}
return -1;
}
}
```
Python 代码:
```Python
import queue
class Solution:
def shortestBridge(self, g: List[List[int]]) -> int:
def getIdx(x, y):
return x * n + y
def find(x):
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(x, y):
p[find(x)] = p[find(y)]
def update(d, cur, other):
sz = d.qsize()
while sz != 0:
x, y = d.get()
idx, step = getIdx(x, y), cur.get(getIdx(x, y))
for di in dirs:
nx, ny = x + di[0], y + di[1]
nidx = getIdx(nx, ny)
if nx < 0 or nx >= n or ny < 0 or ny >= n:
continue
if nidx in cur:
continue
if nidx in other:
return step + 1 + other.get(nidx)
d.put([nx, ny])
cur[nidx] = step + 1
sz -= 1
return -1
n = len(g)
p = [i for i in range(n * n + 10)]
dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
for i in range(n):
for j in range(n):
if g[i][j] == 0:
continue
for di in dirs:
x, y = i + di[0], j + di[1]
if x < 0 or x >= n or y < 0 or y >= n:
continue
if g[x][y] == 0:
continue
union(getIdx(i, j), getIdx(x, y))
a, b = -1, -1
d1, d2 = queue.Queue(), queue.Queue()
m1, m2 = {}, {}
for i in range(n):
for j in range(n):
if g[i][j] == 0:
continue
idx, root = getIdx(i, j), find(getIdx(i, j))
if a == -1:
a = root
elif a != root and b == -1:
b = root
if a == root:
d1.put([i, j])
m1[idx] = 0
elif b == root:
d2.put([i, j])
m2[idx] = 0
while not d1.empty() and not d2.empty():
t = -1
if d1.qsize() < d2.qsize():
t = update(d1, m1, m2)
else:
t = update(d2, m2, m1)
if t != -1:
return t - 1
return -1
```
TypeScript 代码:
```TypeScript
let n: number
const p = new Array<number>(10010).fill(0)
const dirs = [[0,1],[0,-1],[1,0],[-1,0]]
function shortestBridge(g: number[][]): number {
function getIdx(x: number, y: number): number {
return x * n + y
}
function find(x: number): number {
if (p[x] != x) p[x] = find(p[x])
return p[x]
}
function union(x: number, y: number): void {
p[find(x)] = p[find(y)]
}
function update(d: Array<Array<number>>, m1: Map<number, number>, m2: Map<number, number>): number {
let sz = d.length
while (sz-- > 0) {
const info = d.shift()
const x = info[0], y = info[1], idx = getIdx(x, y), step = m1.get(idx)
for (const di of dirs) {
const nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny)
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue
if (m1.has(nidx)) continue
if (m2.has(nidx)) return step + 1 + m2.get(nidx)
d.push([nx, ny])
m1.set(nidx, step + 1)
}
}
return -1
}
n = g.length
for (let i = 0; i < n * n; i++) p[i] = i
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (g[i][j] == 0) continue
for (const di of dirs) {
const x = i + di[0], y = j + di[1]
if (x < 0 || x >= n || y < 0 || y >= n) continue
if (g[x][y] == 0) continue
union(getIdx(i, j), getIdx(x, y))
}
}
}
let a = -1, b = -1
const d1 = new Array<number[]>(), d2 = new Array<number[]>()
const m1 = new Map<number, number>(), m2 = new Map<number, number>()
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (g[i][j] == 0) continue
const idx = getIdx(i, j), root = find(idx)
if (a == -1) a = root
else if (a != root && b == -1) b = root
if (a == root) {
d1.push([i, j])
m1.set(idx, 0)
} else if (b == root) {
d2.push([i, j])
m2.set(idx, 0)
}
}
}
while (d1.length != 0 && d2.length != 0) {
let t = -1
if (d1.length < d2.length) t = update(d1, m1, m2)
else t = update(d2, m2, m1)
if (t != -1) return t - 1
}
return -1
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.934` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/937. 重新排列日志文件（简单）.md | 937. 重新排列日志文件 | https://leetcode-cn.com/problems/reorder-data-in-log-files/solution/by-ac_oier-ap28/ | 简单 | [
"排序"
] | 给你一个日志数组 logs。每条日志都是以空格分隔的字串,其第一个字为字母与数字混合的 标识符 。
有两种不同类型的日志:
* 字母日志:除标识符之外,所有字均由小写字母组成
* 数字日志:除标识符之外,所有字均由数字组成
请按下述规则将日志重新排序:
* 所有 字母日志 都排在 数字日志 之前。
* 字母日志 在内容不同时,忽略标识符后,按内容字母顺序排序;在内容相同时,按标识符排序。
* 数字日志 应该保留原来的相对顺序。
返回日志的最终顺序。
示例 1:
```
输入:logs = ["dig1 8 1 5 1","let1 art can","dig2 3 6","let2 own kit dig","let3 art zero"]
输出:["let1 art can","let3 art zero","let2 own kit dig","dig1 8 1 5 1","dig2 3 6"]
解释:
字母日志的内容都不同,所以顺序为 "art can", "art zero", "own kit dig" 。
数字日志保留原来的相对顺序 "dig1 8 1 5 1", "dig2 3 6" 。
```
示例 2:
```
输入:logs = ["a1 9 2 3 1","g1 act car","zo4 4 7","ab1 off key dog","a8 act zoo"]
输出:["g1 act car","a8 act zoo","ab1 off key dog","a1 9 2 3 1","zo4 4 7"]
```
提示:
* $1 <= logs.length <= 100$
* $3 <= logs[i].length <= 100$
* $logs[i]$ 中,字与字之间都用 单个 空格分隔
* 题目数据保证 $logs[i]$ 都有一个标识符,并且在标识符之后至少存在一个字 | ### 自定义类 + 排序
根据排序规则,我们需要对每个 $str[i]$ 进行裁剪处理,从而得知每个 $str[i]$ 是属于「字母日志」还是「数字日志」,以及得到 `sign` 部分和 `content` 部分。
在排序过程中,每个 $str[i]$ 会被访问多次,为了让每个 $str[i]$ 只进行一次这样的预处理工作,我们可以自定义类,将这部分工作放到类的实例化去做。
最后是简单将 $str[i]$ 转存成 `Log` 实例,自定义排序,用排序结果构造答案的基本逻辑。
代码:
```Java
class Solution {
class Log {
int type, idx;
String ori, sign, content;
Log(String s, int _idx) {
idx = _idx;
int n = s.length(), i = 0;
while (i < n && s.charAt(i) != ' ') i++;
sign = s.substring(0, i);
content = s.substring(i + 1);
ori = s;
type = Character.isDigit(content.charAt(0)) ? 1 : 0;
}
}
public String[] reorderLogFiles(String[] logs) {
int n = logs.length;
List<Log> list = new ArrayList<>();
for (int i = 0; i < n; i++) list.add(new Log(logs[i], i));
Collections.sort(list, (a, b)->{
if (a.type != b.type) return a.type - b.type;
if (a.type == 1) return a.idx - b.idx;
return !a.content.equals(b.content) ? a.content.compareTo(b.content) : a.sign.compareTo(b.sign);
});
String[] ans = new String[n];
for (int i = 0; i < n; i++) ans[i] = list.get(i).ori;
return ans;
}
}
```
* 时间复杂度:将所有的 $str[i]$ 转存成 `Log` 实例,复杂度为 $O(n)$;排序复杂度为 $O(n\log{n})$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.937` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/938. 二叉搜索树的范围和（简单）.md | 938. 二叉搜索树的范围和 | https://leetcode-cn.com/problems/range-sum-of-bst/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-q2fo/ | 简单 | [
"树的搜索",
"DFS",
"BFS"
] | 给定二叉搜索树的根结点 root,返回值位于范围 [low, high] 之间的所有结点的值的和。
示例 1:
```
输入:root = [10,5,15,3,7,null,18], low = 7, high = 15
输出:32
```
示例 2:
```
输入:root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
输出:23
```
提示:
* 树中节点数目在范围 [1, 2 * $10^4$] 内
* 1 <= Node.val <= $10^5$
* 1 <= low <= high <= $10^5$
* 所有 Node.val 互不相同 | ### 基本思路
这又是众多「二叉搜索树遍历」题目中的一道。
**二叉搜索树的中序遍历是有序的。**
只要对其进行「中序遍历」即可得到有序列表,在遍历过程中判断节点值是否符合要求,对于符合要求的节点值进行累加即可。
二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。**由于给定了值范围 $[low, high]$,因此可以在遍历过程中做一些剪枝操作,但并不影响时空复杂度。**
---
### 递归
递归写法十分简单,属于树的遍历中最简单的实现方式。
代码:
```Java
class Solution {
int low, high;
int ans;
public int rangeSumBST(TreeNode root, int _low, int _high) {
low = _low; high = _high;
dfs(root);
return ans;
}
void dfs(TreeNode root) {
if (root == null) return;
dfs(root.left);
if (low <= root.val && root.val <= high) ans += root.val;
dfs(root.right);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 迭代
迭代其实就是使用「栈」来模拟递归过程,也属于树的遍历中的常见实现形式。
一般简单的面试中如果问到树的遍历,面试官都不会对「递归」解法感到满意,因此掌握「迭代/非递归」写法同样重要。
代码:
```Java
class Solution {
public int rangeSumBST(TreeNode root, int low, int high) {
int ans = 0;
Deque<TreeNode> d = new ArrayDeque<>();
while (root != null || !d.isEmpty()) {
while (root != null) {
d.addLast(root);
root = root.left;
}
root = d.pollLast();
if (low <= root.val && root.val <= high) {
ans += root.val;
}
root = root.right;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.938` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/931-940/940. 不同的子序列 II（困难）.md | 940. 不同的子序列 II | https://leetcode.cn/problems/distinct-subsequences-ii/solution/by-ac_oier-ph94/ | 困难 | [
"序列 DP",
"动态规划"
] | 给定一个字符串 `s`,计算 `s` 的 不同非空子序列 的个数。
因为结果可能很大,所以返回答案需要对 $10^9 + 7$ 取余 。
字符串的 子序列 是经由原字符串删除一些(也可能不删除)字符但不改变剩余字符相对位置的一个新字符串。
例如,`"ace"` 是 `"abcde"` 的一个子序列,但 `"aec"` 不是。
示例 1:
```
输入:s = "abc"
输出:7
解释:7 个不同的子序列分别是 "a", "b", "c", "ab", "ac", "bc", 以及 "abc"。
```
示例 2:
```
输入:s = "aba"
输出:6
解释:6 个不同的子序列分别是 "a", "b", "ab", "ba", "aa" 以及 "aba"。
```
示例 3:
```
输入:s = "aaa"
输出:3
解释:3 个不同的子序列分别是 "a", "aa" 以及 "aaa"。
```
提示:
* $1 <= s.length <= 2000$
* `s` 仅由小写英文字母组成 | ### 序列 DP
为了方便,我们令 `s` 下标从 $1$ 开始,定义 $f[i][j]$ 为考虑前 $i$ 个字符,且结尾字符为 $j$ 的不同子序列的个数,其中 $j$ 的范围为 $[0, 25]$ 代指小写字符 `a-z`。
我们有显而易见的初始化条件 $f[0][X] = 0$,最终答案为 $\sum_{i = 0}^{25}f[n][i]$。
不失一般性考虑 $f[i][j]$ 该如何转移,根据 $s[i]$ 是否为 $j$ 进行分情况讨论:
* $s[i] \neq j$ : 由于状态定义限定了结尾字符必须是 $j$,因而 $s[i]$ 必然不会用到,此时有:
$$
f[i][j] = f[i - 1][j]
$$
* $s[i] = j$ : 此时 $s[i]$ 可作为结尾元素,同时由于我们统计的是「不同」的子序列个数,因而「以 $j$ 结尾的子序列方案数」与「以 $s[i]$ 结尾的子序列方案数」完全等价。
对于以 $s[i]$ 作为子序列结尾字符的方案数,容易想到其方案数等于「$s[i]$ 单独作为子序列」+「$s[i]$ 拼接在其余子序列后面形成新子序列」,即有:
$$
f[i][j] = 1 + \sum_{k = 0}^{25} f[i - 1][k]
$$
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int distinctSubseqII(String s) {
int n = s.length(), ans = 0;
int[][] f = new int[n + 1][26];
for (int i = 1; i <= n; i++) {
int c = s.charAt(i - 1) - 'a';
for (int j = 0; j < 26; j++) {
if (c != j) {
f[i][j] = f[i - 1][j];
} else {
int cur = 1;
for (int k = 0; k < 26; k++) cur = (cur + f[i - 1][k]) % MOD;
f[i][j] = cur;
}
}
}
for (int i = 0; i < 26; i++) ans = (ans + f[n][i]) % MOD;
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int distinctSubseqII(string s) {
int n = s.length(), MOD = 1e9 + 7;
vector<vector<int>> f(n + 1, vector<int>(26, 0));
for (int i = 1; i <= n; ++i) {
int c = s[i - 1] - 'a';
for (int j = 0; j < 26; ++j) {
if (c != j) {
f[i][j] = f[i - 1][j];
} else {
int cur = 1;
for (int k = 0; k < 26; ++k) cur = (cur + f[i - 1][k]) % MOD;
f[i][j] = cur;
}
}
}
int ans = 0;
for (int i = 0; i < 26; ++i) ans = (ans + f[n][i]) % MOD;
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def distinctSubseqII(self, s: str) -> int:
n, MOD = len(s), 1e9+7
f = [[0] * 26 for _ in range(n + 1)]
for i in range(1, n + 1):
c = ord(s[i - 1]) - ord('a')
for j in range(26):
f[i][j] = f[i - 1][j] if c != j else (1 + sum(f[i - 1])) % MOD
return int(sum(f[n]) % MOD)
```
TypeScript 代码:
```TypeScript
function distinctSubseqII(s: string): number {
const MOD = 1e9+7
let n = s.length, ans = 0
const f = new Array<Array<number>>(n + 1)
for (let i = 0; i <= n; i++) f[i] = new Array<number>(26).fill(0)
for (let i = 1; i <= n; i++) {
const c = s.charCodeAt(i - 1) - 'a'.charCodeAt(0)
for (let j = 0; j < 26; j++) {
if (c != j) {
f[i][j] = f[i - 1][j]
} else {
let cur = 1
for (let k = 0; k < 26; k++) cur = (cur + f[i - 1][k]) % MOD
f[i][j] = cur
}
}
}
for (let i = 0; i < 26; i++) ans = (ans + f[n][i]) % MOD
return ans
}
```
* 时间复杂度:$O(n \times C^2)$,其中 $C = 26$ 为字符集大小
* 空间复杂度:$O(n \times C)$
---
### 转移优化
根据转移的依赖关系,实现上,我们并不需要真正记录每一个 $f[i][X]$,而可以直接记录一个总的不同子序列方案数 `ans`。
这可以避免每次计算新状态时,都累加前一个 $f[i - 1][X]$ 的值,有效减低时空复杂度。
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int distinctSubseqII(String s) {
int n = s.length(), ans = 0;
int[] f = new int[26];
for (int i = 0; i < n; i++) {
int c = s.charAt(i) - 'a', prev = f[c];
f[c] = (ans + 1) % MOD;
ans = (ans + f[c]) % MOD;
ans = (ans - prev + MOD) % MOD;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int distinctSubseqII(string s) {
int n = s.length(), ans = 0, MOD = 1e9 + 7;
vector<int> f(26, 0);
for (int i = 0; i < n; ++i) {
int c = s[i] - 'a', prev = f[c];
f[c] = (ans + 1) % MOD;
ans = (ans + f[c]) % MOD;
ans = (ans - prev + MOD) % MOD;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def distinctSubseqII(self, s: str) -> int:
n, MOD, ans = len(s), 1e9+7, 0
f = [0] * 26
for i in range(n):
c = ord(s[i]) - ord('a')
prev = f[c]
f[c] = (ans + 1) % MOD
ans = (ans + f[c] - prev) % MOD
return int(ans)
```
TypeScript 代码:
```TypeScript
function distinctSubseqII(s: string): number {
const MOD = 1e9+7
let n = s.length, ans = 0
const f = new Array<number>(26).fill(0)
for (let i = 0; i < n; i++) {
const c = s.charCodeAt(i) - 'a'.charCodeAt(0), prev = f[c]
f[c] = (ans + 1) % MOD
ans = (ans + f[c]) % MOD
ans = (ans - prev + MOD) % MOD
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.940` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/942. 增减字符串匹配（简单）.md | 942. 增减字符串匹配 | https://leetcode.cn/problems/di-string-match/solution/by-ac_oier-pvjk/ | 简单 | [
"贪心",
"构造",
"双指针"
] | 由范围 $[0,n]$ 内所有整数组成的 $n + 1$ 个整数的排列序列可以表示为长度为 $n$ 的字符串 `s` ,其中:
* 如果 `perm[i] < perm[i + 1]` ,那么 `s[i] == 'I'`
* 如果 `perm[i] > perm[i + 1]` ,那么 `s[i] == 'D'`
给定一个字符串 `s` ,重构排列 `perm` 并返回它。如果有多个有效排列 `perm`,则返回其中 任何一个 。
示例 1:
```
输入:s = "IDID"
输出:[0,4,1,3,2]
```
示例 2:
```
输入:s = "III"
输出:[0,1,2,3]
```
示例 3:
```
输入:s = "DDI"
输出:[3,2,0,1]
```
提示:
* $1 <= s.length <= 10^5$
* `s` 只包含字符 `"I"` 或 `"D"` | ### 构造
根据题意,我们需要设想一种「构造」方式,使得利用 `s` 创建序列的过程能够顺利进行。
直觉上容易猜想到当 $s[i] = I$ 时,使用当前最小值进行构造,当 $s[i] = D$ 时使用当前最大值进行构造。
使用「归纳法」来证明该做法的可行性(可用数的范围为 $[0, n]$,构造答案为 $ans$ 数组):
1. 对于边界情况:起始最小值为 $0$,最大值为 $n$:
* 若有 $s[0] = I$,使用 $0$ 进行构造(即有 $ans[0] = 0$),可用数范围变为 $[1, n]$,后续再利用 $s[1]$ 进行构造 $ans[1]$ 时,可以确保始终满足 $ans[1] > ans[0]$,即上一步构造的正确性与下一步的决策无关;
* 若有 $s[1] = D$,使用 $n$ 进行构造(即有 $ans[0] = n$),可用数范围变为 $[0, n - 1]$,后续再利用 $s[1]$ 进行构造 $ans[1]$ 时,可以确保始终满足 $ans[1] < ans[0]$,即上一步构造的正确性与下一步的决策无关;
2. 原问题的非边界情况:与边界情况等同,可用数仍是连续段,且当前的决策无须考虑额外的条件(上一步的构造的正确性已有保证)。
此外,我们证明了该构造方法必然能够利用顺利构造出合法序列。
该做法成立的本质为:**始终确保可用数是连续段,每次选择位于边界的数进行构造,可以直接确保当前构造回合的正确性,从而让边界情况的归纳推理可以运用到每个构造回合。**
代码:
```Java
class Solution {
public int[] diStringMatch(String s) {
int n = s.length(), l = 0, r = n, idx = 0;
int[] ans = new int[n + 1];
for (int i = 0; i < n; i++) {
if (s.charAt(i) == 'I') ans[idx++] = l++;
else ans[idx++] = r--;
}
ans[idx] = l;
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.942` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/943. 最短超级串（困难）.md | 943. 最短超级串 | https://leetcode.cn/problems/find-the-shortest-superstring/solution/gong-shui-san-xie-zhuang-ya-dp-yun-yong-p6hlz/ | 困难 | [
"状压 DP",
"位运算"
] | 给定一个字符串数组 `words`,找到以 `words` 中每个字符串作为子字符串的最短字符串。如果有多个有效最短字符串满足题目条件,返回其中 任意一个 即可。
我们可以假设 `words` 中没有字符串是 `words` 中另一个字符串的子字符串。
示例 1:
```
输入:words = ["alex","loves","leetcode"]
输出:"alexlovesleetcode"
解释:"alex","loves","leetcode" 的所有排列都会被接受。
```
示例 2:
```
输入:words = ["catg","ctaagt","gcta","ttca","atgcatc"]
输出:"gctaagttcatgcatc"
```
提示:
* $1 <= words.length <= 12$
* $1 <= words[i].length <= 20$
* `words[i]` 由小写英文字母组成
* `words` 中的所有字符串互不相同 | ### 状压 DP
为了方便,将 `words` 记为 `ws`。
预处理二维数组 `g` 来表示字符串 `ws[i]` 和 `ws[j]` 的重叠部分的长度:若 `g[i][j] = len` 代表字符串 `ws[i]` 长度为 `len` 的后缀与字符串 `ws[j]` 长度为 `len` 的前缀相同。
另外用一个二进制数 `status` 来代表当前超级串 `ans` 对 `ws` 的使用(覆盖)情况:**若 `status` 的第 `i` 位为 `1` 代表字符串 `ws[i]` 已被使用(即 `ws[i]` 已是 `ans` 的子串),若 `status` 的第 `i` 位为 `0` 代表 `ws[i]` 未被使用。**
我们知道,当所有的 $g[i][j] = 0$ 时,代表所有拼接方式长度均为 $\sum_{i = 0}^{n - 1}ws[i].length$,即不能通过产生重叠部分来缩短超级串的长度。
因此,**最小化超级串 `ans` 的长度等价于最大化重叠部分的长度**。
定义 $f[s][i]$ 代表当前状态为 `s` 且当前最后一个使用到的字符串为 `ws[i]` (当前超级串 `ans` 的结尾部分为 `ws[i]`)时的最大重合长度。
最终超级串的长度为所有字符串的总长度 $\sum_{i = 0}^{n - 1}ws[i].length$ 减去最大重合长度 $\max(f[2^n - 1][i])$。
不失一般性考虑 $f[s][i]$ 可用于更新哪些状态,我们可枚举接在字符串 `ws[i]` 后面的字符串 `ws[j]` 为何值:
1. 由于每个字符串只能使用一次,转移需要满足 `s` 的第 `i` 位为 $1$,`s` 的第 `j` 位为 $0$ 的前提条件,含义为 `ws[i]` 已被使用,而 `ws[j]` 未被使用
2. 满足前提条件 $1$,代表 `ws[j]` 可接在 `ws[i]` 后面,此时有状态转移方程:
$$
f[s | (1 << j)][j] = f[s][i] + g[i][j]
$$
接下来,考虑如何构建具体方案。
**使用二维数组 $p[s][i]$ 记录每个状态是由哪个前驱转移而来**:若有 $p[s][i] = j$,代表取得最大重叠长度过程中,字符串 `ws[j]` 接在 `ws[i]` 后面。
我们从后往前对 `ans` 进行构造,若 `ans = ws[0] + ws[1] + ... + ws[k - 1] + ws[k]`,我们是先找 `ws[k]`,再通过 `ws[k]` 找 `ws[k - 1]`,直到将整个 `ans` 构建出来。
构造过程中使用变量解释如下:
* `ans` 为具体的超级串
* `status` 代表当前还有哪些字符串待拼接到,初始化为 $2^n - 1$,代表还没有任何字符串拼接到 `ans` 中
* `idx` 代表当前处理到的字符串下标,初始化通过遍历所有的 $f[2^n - 1][i]$ 找到合适的 $i$ 作为 `idx`
* `last` 代表前一个处理到字符串下标,初始化为 `-1`
一些细节:当 `last` 不为初始值 `-1` 时,需要跳过 `ws[idx]` 与 `ws[last]` 的重复部分进行拼接。
Java 代码:
```Java
class Solution {
public String shortestSuperstring(String[] ws) {
int n = ws.length, mask = 1 << n;
int[][] g = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
String a = ws[i], b = ws[j];
int l1 = a.length(), l2 = b.length(), len = Math.min(l1, l2);
for (int k = len; k >= 1; k--) {
if (a.substring(l1 - k).equals(b.substring(0, k))) {
g[i][j] = k;
break;
}
}
}
}
int[][] f = new int[mask][n], p = new int[mask][n];
for (int s = 0; s < mask; s++) {
for (int i = 0; i < n; i++) {
if (((s >> i) & 1) == 0) continue;
for (int j = 0; j < n; j++) {
if (((s >> j) & 1) == 1) continue;
if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {
f[s | (1 << j)][j] = f[s][i] + g[i][j];
p[s | (1 << j)][j] = i;
}
}
}
}
int max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;
for (int i = 1; i < n; i++) {
if (max < f[mask - 1][i]) {
max = f[mask - 1][i];
idx = i;
}
}
String ans = "";
while (status != 0) {
if (last == -1) ans = ws[idx];
else ans = ws[idx].substring(0, ws[idx].length() - g[idx][last]) + ans;
last = idx;
idx = p[status][idx];
status ^= (1 << last);
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def shortestSuperstring(self, ws: List[str]) -> str:
n, mask = len(ws), 1 << len(ws)
g = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n):
for j in range(n):
a, b = ws[i], ws[j]
l1, l2 = len(a), len(b)
length = min(l1, l2)
for k in range(length, 0, -1):
if a[l1 - k:] == b[:k]:
g[i][j] = k
break
f = [[0 for _ in range(n)] for _ in range(mask)]
p = [[0 for _ in range(n)] for _ in range(mask)]
for s in range(mask):
for i in range(n):
if (s >> i) & 1 == 0:
continue
for j in range(n):
if (s >> j) & 1 == 1:
continue
if f[s | (1 << j)][j] <= f[s][i] + g[i][j]:
f[s | (1 << j)][j] = f[s][i] + g[i][j]
p[s | (1 << j)][j] = i
max_val = f[mask - 1][0]
idx, last, status = 0, -1, mask - 1
for i in range(1, n):
if max_val < f[mask - 1][i]:
max_val = f[mask - 1][i]
idx = i
ans = ""
while status != 0:
if last == -1:
ans = ws[idx]
else:
ans = ws[idx][:len(ws[idx]) - g[idx][last]] + ans
last = idx
idx = p[status][idx]
status ^= 1 << last
return ans
```
C++ 代码:
```C++
class Solution {
public:
string shortestSuperstring(vector<string>& ws) {
int n = ws.size(), mask = 1 << n;
vector<vector<int>> g(n, vector<int>(n, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
string a = ws[i], b = ws[j];
int l1 = a.length(), l2 = b.length(), len = min(l1, l2);
for (int k = len; k >= 1; k--) {
if (a.substr(l1 - k) == b.substr(0, k)) {
g[i][j] = k;
break;
}
}
}
}
vector<vector<int>> f(mask, vector<int>(n, 0)), p(mask, vector<int>(n, 0));
for (int s = 0; s < mask; s++) {
for (int i = 0; i < n; i++) {
if (((s >> i) & 1) == 0) continue;
for (int j = 0; j < n; j++) {
if (((s >> j) & 1) == 1) continue;
if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {
f[s | (1 << j)][j] = f[s][i] + g[i][j];
p[s | (1 << j)][j] = i;
}
}
}
}
int max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;
for (int i = 1; i < n; i++) {
if (max < f[mask - 1][i]) {
max = f[mask - 1][i];
idx = i;
}
}
string ans = "";
while (status != 0) {
if (last == -1) ans = ws[idx];
else ans = ws[idx].substr(0, ws[idx].length() - g[idx][last]) + ans;
last = idx;
idx = p[status][idx];
status ^= (1 << last);
}
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function shortestSuperstring(ws: string[]): string {
const n = ws.length, mask = 1 << n;
const g = new Array(n).fill(0).map(() => new Array(n).fill(0));
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
const a = ws[i], b = ws[j];
const l1 = a.length, l2 = b.length;
const len = Math.min(l1, l2);
for (let k = len; k >= 1; k--) {
if (a.substring(l1 - k) === b.substring(0, k)) {
g[i][j] = k;
break;
}
}
}
}
const f = new Array(mask).fill(0).map(() => new Array(n).fill(0));
const p = new Array(mask).fill(0).map(() => new Array(n).fill(0));
for (let s = 0; s < mask; s++) {
for (let i = 0; i < n; i++) {
if (((s >> i) & 1) === 0) continue;
for (let j = 0; j < n; j++) {
if (((s >> j) & 1) === 1) continue;
if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {
f[s | (1 << j)][j] = f[s][i] + g[i][j];
p[s | (1 << j)][j] = i;
}
}
}
}
let max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;
for (let i = 1; i < n; i++) {
if (max < f[mask - 1][i]) {
max = f[mask - 1][i];
idx = i;
}
}
let ans = "";
while (status != 0) {
if (last === -1) ans = ws[idx];
else ans = ws[idx].substring(0, ws[idx].length - g[idx][last]) + ans;
last = idx;
idx = p[status][idx];
status ^= (1 << last);
}
return ans;
}
```
* 时间复杂度:将字符串 $ws[i]$ 的最大长度记为 $C = 20$,预处理复杂度为 $O(n^2 \times C)$;状态数量为 $2^n$,`DP` 复杂度为 $O(2^n \times n^2)$。构造答案复杂度为 $O(n)$。整体复杂度为 $O(2^n\times n^2)$
* 空间复杂度:$O(2^n \times n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.943` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/944. 删列造序（简单）.md | 944. 删列造序 | https://leetcode.cn/problems/delete-columns-to-make-sorted/solution/by-ac_oier-smoz/ | 简单 | [
"模拟"
] | 给你由 $n$ 个小写字母字符串组成的数组 `strs`,其中每个字符串长度相等。
这些字符串可以每个一行,排成一个网格。例如,`strs = ["abc", "bce", "cae"]` 可以排列为:
```
abc
bce
cae
```
你需要找出并删除 不是按字典序升序排列的 列。在上面的例子(下标从 $0$ 开始)中,列 $0$(`'a', 'b', 'c'`)和列 $2$(`'c', 'e', 'e'`)都是按升序排列的,而列 $1$(`'b', 'c', 'a'`)不是,所以要删除列 $1$ 。
返回你需要删除的列数。
示例 1:
```
输入:strs = ["cba","daf","ghi"]
输出:1
解释:网格示意如下:
cba
daf
ghi
列 0 和列 2 按升序排列,但列 1 不是,所以只需要删除列 1 。
```
示例 2:
```
输入:strs = ["a","b"]
输出:0
解释:网格示意如下:
a
b
只有列 0 这一列,且已经按升序排列,所以不用删除任何列。
```
示例 3:
```
输入:strs = ["zyx","wvu","tsr"]
输出:3
解释:网格示意如下:
zyx
wvu
tsr
所有 3 列都是非升序排列的,所以都要删除。
```
提示:
* $n == strs.length$
* $1 <= n <= 100$
* $1 <= strs[i].length <= 1000$
* `strs[i]` 由小写英文字母组成 | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Solution {
public int minDeletionSize(String[] strs) {
int n = strs.length, m = strs[0].length(), ans = 0;
out:for (int i = 0; i < m; i++) {
for (int j = 0, cur = -1; j < n; j++) {
int t = (int) strs[j].charAt(i);
if (t < cur && ++ans >= 0) continue out;
cur = t;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.942` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/946. 验证栈序列（中等）.md | 946. 验证栈序列 | https://leetcode.cn/problems/validate-stack-sequences/solution/by-ac_oier-84qd/ | 中等 | [
"模拟",
"栈",
"双指针"
] | 给定 `pushed` 和 `popped` 两个序列,每个序列中的 值都不重复,只有当它们可能是在最初空栈上进行的推入 `push` 和弹出 `pop` 操作序列的结果时,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出:true
解释:我们可以按以下顺序执行:
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
```
示例 2:
```
输入:pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出:false
解释:1 不能在 2 之前弹出。
```
提示:
* $1 <= pushed.length <= 1000$
* $0 <= pushed[i] <= 1000$
* `pushed` 的所有元素 互不相同
* $popped.length = pushed.length$
* `popped` 是 `pushed` 的一个排列 | ### 栈运用模拟
根据题意,利用元素各不相同,我们使用一个栈来处理 `pushed` 数组,每次将 $pushed[i]$ 放入栈中,然后比较当前栈顶元素是否与待弹出元素相同(使用变量 `j` 来代指当前待弹出元素下标),若相等则弹栈并进行 `j` 自增,当所有的元素处理完后,栈为空说明栈序列合法。
Java 代码:
```Java
class Solution {
public boolean validateStackSequences(int[] pushed, int[] popped) {
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0, j = 0; i < pushed.length; i++) {
d.addLast(pushed[i]);
while (!d.isEmpty() && d.peekLast() == popped[j] && ++j >= 0) d.pollLast();
}
return d.isEmpty();
}
}
```
Typescript 代码:
```Typescript
function validateStackSequences(pushed: number[], popped: number[]): boolean {
let n = pushed.length, he = 0, ta = 0
const stk: number[] = new Array<number>(n).fill(0)
for (let i = 0, j = 0; i < n; i++) {
stk[ta++] = pushed[i]
while (he < ta && stk[ta - 1] == popped[j] && ++j >= 0) ta--
}
return he == ta
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 双指针
我们也可以直接利用 `pushed` 充当栈,使用变量 `idx` 代指栈顶下标,变量 `j` 指向 `popped` 中待弹出的元素。
该做法好处无须额外空间,坏处是会修改入参数组。
Java 代码:
```Java
class Solution {
public boolean validateStackSequences(int[] pushed, int[] popped) {
int n = pushed.length, idx = 0;
for (int i = 0, j = 0; i < n; i++) {
pushed[idx++] = pushed[i];
while (idx > 0 && pushed[idx - 1] == popped[j] && ++j >= 0) idx--;
}
return idx == 0;
}
}
```
TypeScript 代码:
```TypeScript
function validateStackSequences(pushed: number[], popped: number[]): boolean {
let n = pushed.length, idx = 0
for (let i = 0, j = 0; i < n; i++) {
pushed[idx++] = pushed[i]
while (idx > 0 && pushed[idx - 1] == popped[j] && ++j >= 0) idx--
}
return idx == 0
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 加餐
**加餐一道同类型题目 : [常规栈运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493276&idx=1&sn=b4b1ff8e6b1794f4f2e4327399755b0c)🎉🎉** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.946` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/941-950/950. 按递增顺序显示卡牌（中等）.md | 950. 按递增顺序显示卡牌 | https://leetcode.cn/problems/reveal-cards-in-increasing-order/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-nu48/ | 中等 | [
"模拟",
"队列",
"排序",
"构造"
] | 牌组中的每张卡牌都对应有一个唯一的整数。你可以按你想要的顺序对这套卡片进行排序。
最初,这些卡牌在牌组里是正面朝下的(即,未显示状态)。
现在,重复执行以下步骤,直到显示所有卡牌为止:
1. 从牌组顶部抽一张牌,显示它,然后将其从牌组中移出。
2. 如果牌组中仍有牌,则将下一张处于牌组顶部的牌放在牌组的底部。
3. 如果仍有未显示的牌,那么返回步骤 1。否则,停止行动。
返回能以递增顺序显示卡牌的牌组顺序。
答案中的第一张牌被认为处于牌堆顶部。
示例:
```
输入:[17,13,11,2,3,5,7]
输出:[2,13,3,11,5,17,7]
解释:
我们得到的牌组顺序为 [17,13,11,2,3,5,7](这个顺序不重要),然后将其重新排序。
重新排序后,牌组以 [2,13,3,11,5,17,7] 开始,其中 2 位于牌组的顶部。
我们显示 2,然后将 13 移到底部。牌组现在是 [3,11,5,17,7,13]。
我们显示 3,并将 11 移到底部。牌组现在是 [5,17,7,13,11]。
我们显示 5,然后将 17 移到底部。牌组现在是 [7,13,11,17]。
我们显示 7,并将 13 移到底部。牌组现在是 [11,17,13]。
我们显示 11,然后将 17 移到底部。牌组现在是 [13,17]。
我们展示 13,然后将 17 移到底部。牌组现在是 [17]。
我们显示 17。
由于所有卡片都是按递增顺序排列显示的,所以答案是正确的。
```
提示:
* $1 <= A.length <= 1000$
* $1 <= A[i] <= 10^6$
* 对于所有的 `i != j`,`A[i] != A[j]` | ### 模拟
根据题意,我们可以先使用双端队列对 `deck` 进行一次模拟,并用哈希表记下每个元素 $deck[i]$ 的显示顺序(利用 $deck[i]$ 元素各不相同,可直接用 $deck[i]$ 作为 `key`)。
随后考虑如何通过哈希表来构建答案数组 `ans`。
假设原数组中的 $deck[i]$ 为首次显示的卡牌,那么 $ans[i]$ 应该放置 `deck` 中最小的元素,同理若 $deck[j]$ 若最后显示的卡牌,则 $ans[j]$ 应放置 `deck` 中的最大元素。
为了方便找 `deck` 中第 $k$ 大元素,可对 `deck` 进行拷贝并排序。
Java 代码:
```Java
class Solution {
public int[] deckRevealedIncreasing(int[] deck) {
int n = deck.length, idx = 0;
Map<Integer, Integer> map = new HashMap<>();
Deque<Integer> d = new ArrayDeque<>();
for (int x : deck) d.addLast(x);
while (!d.isEmpty()) {
map.put(d.pollFirst(), idx++);
if (!d.isEmpty()) d.addLast(d.pollFirst());
}
int[] ans = new int[n], temp = deck.clone();
Arrays.sort(temp);
for (int i = 0; i < n; i++) ans[i] = temp[map.get(deck[i])];
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> deckRevealedIncreasing(vector<int>& deck) {
int n = deck.size(), idx = 0;
map<int, int> map;
deque<int> d;
for (int x : deck) d.push_back(x);
while (!d.empty()) {
map[d.front()] = idx++;
d.pop_front();
if (!d.empty()) {
d.push_back(d.front());
d.pop_front();
}
}
vector<int> ans(n);
vector<int> temp = deck;
sort(temp.begin(), temp.end());
for (int i = 0; i < n; i++) ans[i] = temp[map[deck[i]]];
return ans;
}
};
```
Python3 代码:
```Python
class Solution:
def deckRevealedIncreasing(self, deck: List[int]) -> List[int]:
n, idx = len(deck), 0
map = {}
d = deque(deck)
while d:
map[d.popleft()] = idx
idx += 1
if d:
d.append(d.popleft())
temp = sorted(deck)
return [temp[map[deck[i]]] for i in range(n)]
```
TypeScript 代码:
```TypeScript
function deckRevealedIncreasing(deck: number[]): number[] {
let n = deck.length, idx = 0;
const map = {};
const d = [...deck];
while (d.length > 0) {
map[d.shift()!] = idx++;
if (d.length > 0) d.push(d.shift()!);
}
const ans = new Array(n);
const temp = [...deck].sort((a, b) => a - b);
for (let i = 0; i < n; i++) ans[i] = temp[map[deck[i]]];
return ans;
};
```
* 时间复杂度:使用队列模拟一次操作的复杂度为 $O(n)$(每个元素只有一次出入队机会);对原数组进行复制并排序的复杂度 $O(n\log{n})$;构建答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.950` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/951-960/952. 按公因数计算最大组件大小（困难）.md | 952. 按公因数计算最大组件大小 | https://leetcode.cn/problems/largest-component-size-by-common-factor/solution/by-ac_oier-mw04/ | 困难 | [
"数学",
"并查集"
] | 给定一个由不同正整数的组成的非空数组 `nums`,考虑下面的图:
* 有 `nums.length` 个节点,按从 `nums[0]` 到 `nums[nums.length - 1]` 标记;
* 只有当 `nums[i]` 和 `nums[j]` 共用一个大于 $1$ 的公因数时,`nums[i]` 和 `nums[j]`之间才有一条边。
返回 图中最大连通组件的大小 。
示例 1:
```
输入:nums = [4,6,15,35]
输出:4
```
示例 2:
```
输入:nums = [20,50,9,63]
输出:2
```
示例 3:
```
输入:nums = [2,3,6,7,4,12,21,39]
输出:8
```
提示:
* $1 <= nums.length <= 2 \times 10^4$
* $1 <= nums[i] <= 10^5$
* `nums` 中所有值都 不同 | ### 枚举质因数 + 并查集
先考虑如何使用 `nums` 进行建图,`nums` 大小为 $n = 2 \times 10^4$,枚举所有点对并通过判断两数之间是否存在边的做法复杂度为 $O(n^2\sqrt{M})$(其中 $M = 1e5$ 为 $nums[i]$ 的最大值),无须考虑。
而不通过「枚举点 + 求公约数」的建图方式,可以对 $nums[i]$ 进行质因数分解(复杂度为 $O(\sqrt{nums[i]})$),假设其分解出来的质因数集合为 $S$,我们可以建立从 $S_{k}$ 到 $nums[i]$ 的映射关系,若 $nums[i]$ 与 $nums[j]$ 存在边,则 $nums[i]$ 和 $nums[j]$ 至少会被同一个质因数所映射。
维护连通块数量可以使用「并查集」来做,维护映射关系可以使用「哈希表」来做。
维护映射关系时,使用质因数为 `key`,下标值 $i$ 为 `value`(我们使用下标 $i$ 作为点编号,而不是使用 $nums[i]$ ,是利用$nums[i]$ 各不相同,从而将并查集数组大小从 $1e5$ 收窄到 $2 \times 10^4$)。
同时在使用「并查集」维护连通块时,同步维护每个连通块大小 `sz` 以及当前最大的连通块大小 `ans`。
Java 代码:
```Java
class Solution {
static int N = 20010;
static int[] p = new int[N], sz = new int[N];
int ans = 1;
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void union(int a, int b) {
if (find(a) == find(b)) return ;
sz[find(a)] += sz[find(b)];
p[find(b)] = p[find(a)];
ans = Math.max(ans, sz[find(a)]);
}
public int largestComponentSize(int[] nums) {
int n = nums.length;
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < n; i++) {
int cur = nums[i];
for (int j = 2; j * j <= cur; j++) {
if (cur % j == 0) add(map, j, i);
while (cur % j == 0) cur /= j;
}
if (cur > 1) add(map, cur, i);
}
for (int i = 0; i <= n; i++) {
p[i] = i; sz[i] = 1;
}
for (int key : map.keySet()) {
List<Integer> list = map.get(key);
for (int i = 1; i < list.size(); i++) union(list.get(0), list.get(i));
}
return ans;
}
void add(Map<Integer, List<Integer>> map, int key, int val) {
List<Integer> list = map.getOrDefault(key, new ArrayList<>());
list.add(val);
map.put(key, list);
}
}
```
TypeScript 代码:
```TypeScript
const N = 20010
const p: number[] = new Array<number>(N), sz = new Array<number>(N)
let ans = 0
function find(x: number): number {
if (p[x] != x) p[x] = find(p[x])
return p[x]
}
function union(a: number, b: number): void {
if (find(a) == find(b)) return
sz[find(a)] += sz[find(b)]
p[find(b)] = p[find(a)]
ans = Math.max(ans, sz[find(a)])
}
function largestComponentSize(nums: number[]): number {
const n = nums.length
const map: Map<number, Array<number>> = new Map<number, Array<number>>()
for (let i = 0; i < n; i++) {
let cur = nums[i]
for (let j = 2; j * j <= cur; j++) {
if (cur % j == 0) add(map, j, i)
while (cur % j == 0) cur /= j
}
if (cur > 1) add(map, cur, i)
}
for (let i = 0; i < n; i++) {
p[i] = i; sz[i] = 1
}
ans = 1
for (const key of map.keys()) {
const list = map.get(key)
for (let i = 1; i < list.length; i++) union(list[0], list[i])
}
return ans
};
function add(map: Map<number, Array<number>>, key: number, val: number): void {
let list = map.get(key)
if (list == null) list = new Array<number>()
list.push(val)
map.set(key, list)
}
```
* 时间复杂度:$O(n\sqrt{M})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.952` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/951-960/953. 验证外星语词典（简单）.md | 953. 验证外星语词典 | https://leetcode.cn/problems/verifying-an-alien-dictionary/solution/by-ac_oier-sxf1/ | 简单 | [
"排序",
"模拟"
] | 某种外星语也使用英文小写字母,但可能顺序 `order` 不同。字母表的顺序(`order`)是一些小写字母的排列。
给定一组用外星语书写的单词 `words`,以及其字母表的顺序 `order`,只有当给定的单词在这种外星语中按字典序排列时,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出:true
解释:在该语言的字母表中,'h' 位于 'l' 之前,所以单词序列是按字典序排列的。
```
示例 2:
```
输入:words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
输出:false
解释:在该语言的字母表中,'d' 位于 'l' 之后,那么 words[0] > words[1],因此单词序列不是按字典序排列的。
```
示例 3:
```
输入:words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
输出:false
解释:当前三个字符 "app" 匹配时,第二个字符串相对短一些,然后根据词典编纂规则 "apple" > "app",因为 'l' > '∅',其中 '∅' 是空白字符,定义为比任何其他字符都小(更多信息)。
```
提示:
* $1 <= words.length <= 100$
* $1 <= words[i].length <= 20$
* $order.length == 26$
* 在 `words[i]` 和 `order` 中的所有字符都是英文小写字母。 | ### 自定义排序
为了快速判断某两个字符在字典序的前后关系,先使用一个大小与字符集相等的数组对 `order` 进行转存。
然后对 `words` 进行拷贝复制得到 `clone`,并执行自定义排序,最后根据排序前后顺序是否相等来返回答案。
代码:
```Java
class Solution {
public boolean isAlienSorted(String[] words, String order) {
int[] ord = new int[26];
for (int i = 0; i < 26; i++) ord[order.charAt(i) - 'a'] = i;
String[] clone = words.clone();
Arrays.sort(clone, (a, b)->{
int n = a.length(), m = b.length();
int i = 0, j = 0;
while (i < n && j < m) {
int c1 = a.charAt(i) - 'a', c2 = b.charAt(j) - 'a';
if (c1 != c2) return ord[c1] - ord[c2];
i++; j++;
}
if (i < n) return 1;
if (j < m) return -1;
return 0;
});
int n = words.length;
for (int i = 0; i < n; i++) {
if (!clone[i].equals(words[i])) return false;
}
return true;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 模拟
更近一步,我们无须对整个数组进行排序,只需要将「自定义排序」中的规则抽出来,判断相邻两个字符串是满足字典序排序即可。
代码:
```Java
class Solution {
int[] ord = new int[26];
int check(String a, String b) {
int n = a.length(), m = b.length();
int i = 0, j = 0;
while (i < n && j < m) {
int c1 = a.charAt(i) - 'a', c2 = b.charAt(j) - 'a';
if (c1 != c2) return ord[c1] - ord[c2];
i++; j++;
}
if (i < n) return 1;
if (j < m) return -1;
return 0;
}
public boolean isAlienSorted(String[] words, String order) {
for (int i = 0; i < 26; i++) ord[order.charAt(i) - 'a'] = i;
int n = words.length;
for (int i = 1; i < n; i++) {
if (check(words[i - 1], words[i]) > 0) return false;
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.953` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/951-960/954. 二倍数对数组（中等）.md | 954. 二倍数对数组 | https://leetcode-cn.com/problems/array-of-doubled-pairs/solution/by-ac_oier-d1z7/ | 中等 | [
"优先队列(堆)",
"构造",
"哈希表",
"拓扑排序"
] | 给定一个长度为偶数的整数数组 `arr`,只有对 `arr` 进行重组后可以满足 “对于每个$ 0 <= i < len(arr) / 2$,都有 $arr[2 \times i + 1] = 2 \times arr[2 \times i]$” 时,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:arr = [3,1,3,6]
输出:false
```
示例 2:
```
输入:arr = [2,1,2,6]
输出:false
```
示例 3:
```
输入:arr = [4,-2,2,-4]
输出:true
解释:可以用 [-2,-4] 和 [2,4] 这两组组成 [-2,-4,2,4] 或是 [2,4,-2,-4]
```
提示:
* $0 <= arr.length <= 3 \times 10^4$
* `arr.length` 是偶数
* $-10^5 <= arr[i] <= 10^5$ | ### 逐个构造 + 优先队列
整理一下题意:是否能对 `arr` 进行重组,使得每一个奇数位置的值均是前一个位置的值的两倍,即凑成 $\frac{n}{2}$ 组形如 $(x, 2 \times x)$ 的数对。
对于一个任意的有理数而言,对其乘 $2$ 仅会改变数值的大小,而不会改变其方向(正负性质)。
因此如果我们每次都拿最接近 $0$ 的值作为起点,整个构造过程就是唯一确定的。
具体的,我们可以借助优先队列(堆)来实现,构造一个以与 $0$ 值距离作为基准的小根堆。每次从堆中取出元素 $x$,根据当前元素 $x$ 是否被「预定」过进行分情况讨论:
* 当前值 $x$ 没有被预定过,说明 $x$ 必然是数对中的「绝对值」的较小值,此时给 $x$ 并预定一个 $x \times 2$,即对 $x \times 2$ 的预定次数加一;
* 当前值 $x$ 已经被预定过,说明 $x$ 和此前的某个数 $\frac{x}{2}$ 组成过数对,对 $x$ 的预定次数减一。
当且仅当构成过程结束后,所有数的「预定」次数为 $0$ 时,`arr` 可以凑成 $\frac{n}{2}$ 组形如 $(x, 2 \times x)$ 的数对。
> 一些细节:由于 $arr[i]$ 的数值范围为 $[-10^5, 10^5]$,同时存在乘 $2$ 操作,因此我们需要对计算结果进行 $2 \times 10^5$ 的偏移操作,确保其为正数。
代码:
```Java
class Solution {
static int N = 100010, M = N * 2;
static int[] cnts = new int[M * 2];
public boolean canReorderDoubled(int[] arr) {
Arrays.fill(cnts, 0);
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->Math.abs(a)-Math.abs(b));
for (int i : arr) q.add(i);
while (!q.isEmpty()) {
int x = q.poll(), t = x * 2;
if (cnts[x + M] != 0 && --cnts[x + M] >= 0) continue;
cnts[t + M]++;
}
for (int i = 0; i < M * 2; i++) {
if (cnts[i] != 0) return false;
}
return true;
}
}
```
* 时间复杂度:令 $n$ 为 `arr` 长度,$m$ 为 $arr[i]$ 的值域范围,起始将所有数值放入优先队列(堆)的复杂度为 $O(n\log{n})$,从优先队列(堆)中取出并构造复杂度为 $O(n\log{n})$,检查构造是否成功复杂度为 $O(m)$,整体复杂度为 $O(n\log{n} + m)$
* 空间复杂度:$O(n + m)$
---
### 成组构造 + 排序 + 预处理剪枝
上述解法中,我们不可避免的对 `arr` 进行一遍完成的尝试构造,并且在尝试构造结束后再进行一次性的合法性检查。
事实上,如果 `arr` 能够凑成 $\frac{n}{2}$ 组形如 $(x, 2 \times x)$ 的数对,并且对于某个 $x$ 可能会出现多次,我们可以统计 $arr[i]$ 的数量,并根据绝对值大小进行排序,进行成组构造:$cnts[x]$ 个 $x$ 消耗 $cnts[x]$ 个 $2 \times x$。
同时由于我们提前预处理了每个 $arr[i]$ 的出现次数,我们可以提前知道是否有 $cnts[x]$ 个 $2 \times x$ 和 $x$ 成组,从而可以边构造边检查合法性。
代码:
```Java
class Solution {
static int N = 100010, M = N * 2;
static int[] cnts = new int[M * 2];
public boolean canReorderDoubled(int[] arr) {
Arrays.fill(cnts, 0);
List<Integer> list = new ArrayList<>();
for (int i : arr) {
if (++cnts[i + M] == 1) list.add(i);
}
Collections.sort(list, (a,b)->Math.abs(a)-Math.abs(b));
for (int i : list) {
if (cnts[i * 2 + M] < cnts[i + M]) return false;
cnts[i * 2 + M] -= cnts[i + M];
}
return true;
}
}
```
* 时间复杂度:统计 $arr[i]$ 的出现次数以及对 $arr[i]$ 去重的复杂度为 $O(n)$,对去重数组进行排序的复杂度为 $O(n\log{n})$,验证是否合法复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n + m)$
---
### 成组构造 + 拓扑排序
对于上述两种解法,要么利用「优先队列」要么利用「排序」,目的都是为了找到数对中的「绝对值较小」的那一位,然后开始往后构造。
**事实上,我们可以利用任意 $x$ 只可能与 $\frac{x}{2}$ 或者 $2 \times x$ 组成数对来进行建图,通过对图跑拓扑序来验证是否能够凑成 $\frac{n}{2}$ 组形如 $(x, 2 \times x)$ 的数对。**
> 不了解「拓扑排序」的同学可以看前置 🧀:[图论拓扑排序入门](https%3A//mp.weixin.qq.com/s?__biz%3DMzU4NDE3MTEyMA%3D%3D%26mid%3D2247489706%26idx%3D1%26sn%3D771cd807f39d1ca545640c0ef7e5baec),里面通过图解演示了何为拓扑序,以及通过「反证法」证明了为何有向无环图能够能够进行拓扑排序。
特别的,我们需要特殊处理 $arr[i] = 0$ 的情况,由于 $0$ 只能与本身组成数对,为了避免自环,我们需要跳过 $arr[i] = 0$ 的点,同时特判 $arr[i] = 0$ 的出现数量为奇数时,返回无解。
和解法二一样,先对 $arr[i]$ 进行数量统计以及去重预处理(跳过 $0$),然后对去重数组 `list` 中出现的数值 $x$ 进行分情况讨论:
* $x$ 为奇数,由于 $\frac{x}{2}$ 不为整数,因此 $x$ 只能作为数对中绝对值较小的那个(即 $x$ 入度为 $0$),加入队列;
* $x$ 为偶数,首先令 $x$ 的入度 $in[x] = cnts[\frac{x}{2}]$,代表有 $cnts[\frac{x}{2}]$ 个 $\frac{x}{2}$ 与其对应。当 $in[x] = 0$ 时,说明没有 $\frac{x}{2}$ 与其成对,此时 $x$ 只能作为数对中绝对值较小的那个(即 $x$ 入度为 $0$),加入队列。
跑一遍拓扑排序,假设当前出队值为 $t$,此时需要消耗掉 $cnts[t]$ 个 $t \times 2$ 与其形成数对(即 $cnts[t \times 2] -= cnts[t]$ ),同时 $t \times 2$ 的入度也要更新(即 $in[t \times 2] -= cnts[t]$ ),若 $in[t \times 2] = 0$ 且此时 $cnts[t \times 2] > 0$,将 $t \times 2$ 进行入队。同时由于我们明确减少了 $t \times 2$ 的数量,因此需要同步更新 $t \times 4$ 的入度,同理,当 $t \times 4$ 的入度 $in[t \times 4] = 0$,同时 $cnts[t \times 4] > 0$ 时,需要将 $t \times 4$ 进行入队。
代码:
```Java
class Solution {
static int N = 100010, M = 2 * N;
static int[] cnts = new int[M * 2], in = new int[M * 2];
public boolean canReorderDoubled(int[] arr) {
Arrays.fill(cnts, 0);
Arrays.fill(in, 0);
List<Integer> list = new ArrayList<>();
for (int i : arr) {
if (++cnts[i + M] == 1 && i != 0) list.add(i);
}
if (cnts[M] % 2 != 0) return false;
Deque<Integer> d = new ArrayDeque<>();
for (int i : list) {
if (i % 2 == 0) {
in[i + M] = cnts[i / 2 + M];
if (in[i + M] == 0) d.addLast(i);
} else {
d.addLast(i);
}
}
while (!d.isEmpty()) {
int t = d.pollFirst();
if (cnts[t * 2 + M] < cnts[t + M]) return false;
cnts[t * 2 + M] -= cnts[t + M];
in[t * 2 + M] -= cnts[t + M];
if (in[t * 2 + M] == 0 && cnts[t * 2 + M] != 0) d.addLast(t * 2);
in[t * 4 + M] -= cnts[t + M];
if (in[t * 4 + M] == 0 && cnts[t * 4 + M] != 0) d.addLast(t * 4);
}
return true;
}
}
```
* 时间复杂度:统计数量和入度的复杂度为 $O(n)$;跑拓扑序验证的复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.954` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/961-970/961. 在长度 2N 的数组中找出重复 N 次的元素（简单）.md | 961. 在长度 2N 的数组中找出重复 N 次的元素 | https://leetcode.cn/problems/n-repeated-element-in-size-2n-array/solution/by-ac_oier-bslq/ | 简单 | [
"模拟",
"计数",
"构造",
"哈希表"
] | 给你一个整数数组 `nums` ,该数组具有以下属性:
* $nums.length == 2 \times n$
* `nums` 包含 $n + 1$ 个 不同的 元素
* `nums` 中恰有一个元素重复 $n$ 次
找出并返回重复了 $n$ 次的那个元素。
示例 1:
```
输入:nums = [1,2,3,3]
输出:3
```
示例 2:
```
输入:nums = [2,1,2,5,3,2]
输出:2
```
示例 3:
```
输入:nums = [5,1,5,2,5,3,5,4]
输出:5
```
提示:
* $2 <= n <= 50004
* $nums.length == 2 \times n$
* $0 <= nums[i] <= 10^4$
* `nums` 由 $n + 1$ 个 不同的 元素组成,且其中一个元素恰好重复 $n$ 次 | ### 计数模拟
根据题目给定的三个条件可推断出:数组中仅有一个元素出现多次,其余元素均出现一次。
又利用数据范围为 $10^4$,我们可以使用数组充当哈希表进行计数,当出现一个 $nums[i]$ 重复出现即是答案。
代码:
```Java
class Solution {
int[] cnts = new int[10010];
public int repeatedNTimes(int[] nums) {
for (int x : nums) {
if (++cnts[x] > 1) return x;
}
return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$
---
### 构造共性
假设重复出现的数字是 $x$,数字 $x$ 重复了 $n$ 次,要将这 $n$ 个相同的 $x$ 间隔开,需要 $n - 1$ 个额外数字,而实际上我们除 $x$ 以外还有 $n$ 个额外数字(数字总数为 $n + 1$ 个),因此在我们所能构造出的所有排列方式中,**最多** 使相邻 $x$ 之间间隔了 $2$ 个额外数字。
对于每个 $nums[i]$ 而言,我们检查往前的三个位置(若有),如果有重复相等情况,说明当前的 $nums[i]$ 即是答案。
代码:
```Java
class Solution {
public int repeatedNTimes(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
int t = nums[i];
if (i - 1 >= 0 && nums[i - 1] == t) return t;
if (i - 2 >= 0 && nums[i - 2] == t) return t;
if (i - 3 >= 0 && nums[i - 3] == t) return t;
}
return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.961` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/961-970/965. 单值二叉树（简单）.md | 965. 单值二叉树 | https://leetcode.cn/problems/univalued-binary-tree/solution/by-ac_oier-zxjl/ | 简单 | [
"DFS",
"BFS",
"二叉树",
"树的遍历",
"层序遍历"
] | 如果二叉树每个节点都具有相同的值,那么该二叉树就是单值二叉树。
只有给定的树是单值二叉树时,才返回 `true`;否则返回 `false`。
示例 1:
```
输入:[1,1,1,1,1,null,1]
输出:true
```
示例 2:
```
输入:[2,2,2,5,2]
输出:false
```
提示:
* 给定树的节点数范围是 $[1, 100]¥。
* 每个节点的值都是整数,范围为 $[0, 99]$ 。 | ### 递归
根据题意进行模拟即可。
代码:
```Java
class Solution {
int val = -1;
public boolean isUnivalTree(TreeNode root) {
if (val == -1) val = root.val;
if (root == null) return true;
if (root.val != val) return false;
return isUnivalTree(root.left) && isUnivalTree(root.right);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间消耗,复杂度为 $O(1)$
---
### 迭代
也可以使用迭代的方式进行层序遍历。
代码:
```Java
class Solution {
public boolean isUnivalTree(TreeNode root) {
int val = root.val;
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode poll = d.pollFirst();
if (poll.val != val) return false;
if (poll.left != null) d.addLast(poll.left);
if (poll.right != null) d.addLast(poll.right);
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.965` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/961-970/969. 煎饼排序（中等）.md | 969. 煎饼排序 | https://leetcode-cn.com/problems/pancake-sorting/solution/gong-shui-san-xie-mou-pao-pai-xu-yun-yon-c0mn/ | 中等 | [
"排序"
] | 给你一个整数数组 `arr`,请使用 **煎饼翻转** 完成对数组的排序。
一次煎饼翻转的执行过程如下:
* 选择一个整数 `k` ,$1 <= k <= arr.length$
* 反转子数组 `arr[0...k-1]`(下标从 $0$ 开始)
例如,`arr = [3,2,1,4]`,选择 `k = 3` 进行一次煎饼翻转,反转子数组 `[3,2,1]` ,得到 `arr = [1,2,3,4]` 。
以数组形式返回能使 `arr` 有序的煎饼翻转操作所对应的 `k` 值序列。任何将数组排序且翻转次数在 `10 * arr.length` 范围内的有效答案都将被判断为正确。
示例 1:
```
输入:[3,2,4,1]
输出:[4,2,4,3]
解释:
我们执行 4 次煎饼翻转,k 值分别为 4,2,4,和 3。
初始状态 arr = [3, 2, 4, 1]
第一次翻转后(k = 4):arr = [1, 4, 2, 3]
第二次翻转后(k = 2):arr = [4, 1, 2, 3]
第三次翻转后(k = 4):arr = [3, 2, 1, 4]
第四次翻转后(k = 3):arr = [1, 2, 3, 4],此时已完成排序。
```
示例 2:
```
输入:[1,2,3]
输出:[]
解释:
输入已经排序,因此不需要翻转任何内容。
请注意,其他可能的答案,如 [3,3] ,也将被判断为正确。
```
提示:
* $1 <= arr.length <= 100$
* $1 <= arr[i] <= arr.length$
* `arr` 中的所有整数互不相同(即,arr 是从 1 到 arr.length 整数的一个排列) | ### 冒泡排序
由于每次我们都对「某段前缀」进行整体翻转,并且规定了翻转次数在一定范围内的方案均为合法翻转方案,同时 $arr$ 又是 $1$ 到 $n$ 的排列。
我们可以很自然想到「冒泡排序」:**每次确定未排序部分最右端的元素(最大值)。**
具体的,假设下标 $[k + 1, n - 1]$ 部分已有序,如果我们希望当前值 $t$ 出现在某个位置 $k$ 上,可以进行的操作为:
* 如果当前值 $t$ 已在 $k$ 上,无须进行操作;
* 如果当前值不在 $k$ 上,根据当前值是否在数组头部(下标为 $0$)进行分情况讨论:
* 当前值在数组头部(下标为 $0$),直接将 $[0, k]$ 部分进行翻转(将 $k + 1$ 加入答案中),即可将当前值 $t$ 放到位置 $k$ 上;
* 当前值不在数组头部(下标为 $0$),而是在 $idx$ 位置上,需要先将 $[0, idx]$ 部分进行翻转(将 $idx + 1$ 加入答案中),这样使得当前值 $t$ 出现数组头部(下标为 $0$),然后再将 $[0, k]$ 部分进行翻转(将 $k + 1$ 加入答案中),即可将当前值 $t$ 放到位置 $k$ 上。
而翻转某个前缀的操作可使用「双指针」实现,复杂度为 $O(n)$。
代码:
```Java
class Solution {
public List<Integer> pancakeSort(int[] arr) {
int n = arr.length;
int[] idxs = new int[n + 10];
for (int i = 0; i < n; i++) idxs[arr[i]] = i;
List<Integer> ans = new ArrayList<>();
for (int i = n; i >= 1; i--) {
int idx = idxs[i];
if (idx == i - 1) continue;
if (idx != 0) {
ans.add(idx + 1);
reverse(arr, 0, idx, idxs);
}
ans.add(i);
reverse(arr, 0, i - 1, idxs);
}
return ans;
}
void reverse(int[] arr, int i, int j, int[] idxs) {
while (i < j) {
idxs[arr[i]] = j; idxs[arr[j]] = i;
int c = arr[i];
arr[i++] = arr[j];
arr[j--] = c;
}
}
}
```
* 时间复杂度:需要对 $n$ 个元素进行排序,每个元素最多触发两次翻转,每次翻转的复杂度为 $O(n)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.969` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/971-980/978. 最长湍流子数组（中等）.md | 978. 最长湍流子数组 | https://leetcode-cn.com/problems/longest-turbulent-subarray/solution/xiang-jie-dong-tai-gui-hua-ru-he-cai-dp-3spgj/ | 中等 | [
"线性 DP",
"序列 DP"
] | 当 `A` 的子数组 $A[i], A[i+1], ..., A[j]$ 满足下列条件时,我们称其为湍流子数组:
* 若 $i <= k < j$,当 $k$ 为奇数时,$A[k] > A[k+1]$,且当 $k$ 为偶数时,$A[k] < A[k+1]$;
* 若 $i <= k < j$,当 $k$ 为偶数时,$A[k] > A[k+1]$ ,且当 $k$ 为奇数时,$A[k] < A[k+1]$。
也就是说,如果比较符号在子数组中的每个相邻元素对之间翻转,则该子数组是湍流子数组。
返回 `A` 的最大湍流子数组的长度。
示例 1:
```
输入:[9,4,2,10,7,8,8,1,9]
输出:5
解释:(A[1] > A[2] < A[3] > A[4] < A[5])
```
示例 2:
```
输入:[4,8,12,16]
输出:2
```
示例 3:
```
输入:[100]
输出:1
```
提示:
* $1 <= A.length <= 40000$
* $0 <= A[i] <= 10^9$ | ### 基本思路
本题其实是要我们求最长一段呈 `↗ ↘ ↗ ↘` 或者 `↘ ↗ ↘ ↗` 形状的数组长度。
看一眼数据范围,有 $40000$,那么枚举起点和终点,然后对划分出来的子数组检查是否为「湍流子数组」的朴素解法就不能过了。
朴素解法的复杂度为 $O(n^3)$ ,直接放弃朴素解法。
复杂度往下优化,其实就 $O(n)$ 的 DP 解法了。
---
### 动态规划
至于 DP 如何分析,通过我们会先考虑一维 DP 能否求解,不行再考虑二维 DP。
对于本题,**由于每个位置而言,能否「接着」上一个位置**形成「湍流」,取决于上一位置是由什么形状而来。
举个例子,对于样例 `[3,4,2]`,从 4 -> 2 已经确定是 `↘` 状态,那么对于 2 这个位置能否「接着」4 形成「湍流」,要求 4 必须是由 `↗` 而来。
**因此我们还需要记录某一位是如何来的(`↗` 还是 `↘`),需要使二维 DP 来求解 ~**
我们定义 $f[i][j]$ 代表以位置 $i$ 为结尾,而结尾状态为 $j$ 的最长湍流子数组长度(0:上升状态 / 1:下降状态)
> PS. 这里的状态定义我是猜的,这其实是个技巧。通常我们做 DP 题,都是先猜一个定义,然后看看这个定义是否能分析出状态转移方程帮助我们「不重不漏」的枚举所有的方案。一般我是直接根据答案来猜定义,这里是求最长子数组长度,所以我猜一个 f(i,j) 代表最长湍流子数组长度
不失一般性考虑 $f[i][j]$ 该如何求解,我们知道位置 $i$ 是如何来是唯一确定的(取决于 $arr[i]$ 和 $arr[i - 1]$ 的大小关系),而只有三种可能性:
* $arr[i - 1] < arr[i]$:该点是由上升而来,能够「接着」的条件是 $i - 1$ 是由下降而来。则有:$f[i][0] = f[i - 1][1] + 1$
* $arr[i - 1] > arr[i]$:改点是由下降而来,能够「接着」的条件是 $i - 1$ 是由上升而来。则有:$f[i][1] = f[i - 1][0] + 1$
* $arr[i - 1] = arr[i]$:不考虑,不符合「湍流」的定义
代码:
```Java
class Solution {
public int maxTurbulenceSize(int[] arr) {
int n = arr.length, ans = 1;
int[][] f = new int[n][2];
f[0][0] = f[0][1] = 1;
for (int i = 1; i < n; i++) {
f[i][0] = f[i][1] = 1;
if (arr[i] > arr[i - 1]) f[i][0] = f[i - 1][1] + 1;
else if (arr[i] < arr[i - 1]) f[i][1] = f[i - 1][0] + 1;
ans = Math.max(ans, Math.max(f[i][0], f[i][1]));
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 空间优化:奇偶滚动
我们发现对于 $f[i][j]$ 状态的更新只依赖于 $f[i - 1][j]$ 的状态。
因此我们可以使用「奇偶滚动」方式来将第一维从 $n$ 优化到 $2$。
修改的方式也十分机械,只需要改为「奇偶滚动」的维度直接修改成 $2$ ,然后该维度的所有访问方式增加 `%2` 或者 `&1` 即可:
代码:
```Java
class Solution {
public int maxTurbulenceSize(int[] arr) {
int n = arr.length, ans = 1;
int[][] f = new int[2][2];
f[0][0] = f[0][1] = 1;
for (int i = 1; i < n; i++) {
f[i % 2][0] = f[i % 2][1] = 1;
if (arr[i] > arr[i - 1]) f[i % 2][0] = f[(i - 1) % 2][1] + 1;
else if (arr[i] < arr[i - 1]) f[i % 2][1] = f[(i - 1) % 2][0] + 1;
ans = Math.max(ans, Math.max(f[i % 2][0], f[i % 2][1]));
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用固定 `2 * 2` 的数组空间。复杂度为 $O(1)$
---
### 空间优化:维度消除
既然只需要记录上一行状态,能否直接将行的维度消除呢?
答案是可以的,当我们要转移第 $i$ 行的时候,$f[i]$ 装的就已经是 $i - 1$ 行的结果。
这也是著名「背包问题」的一维通用优手段。
但相比于「奇偶滚动」的空间优化,这种优化手段只是常数级别的优化(空间复杂度与「奇偶滚动」相同),而且优化通常涉及代码改动。
代码:
```Java
class Solution {
public int maxTurbulenceSize(int[] arr) {
int n = arr.length, ans = 1;
int[] f = new int[2];
f[0] = f[1] = 1;
for (int i = 1; i < n; i++) {
int a = f[0], b = f[1];
f[0] = arr[i - 1] < arr[i] ? b + 1 : 1;
f[1] = arr[i - 1] > arr[i] ? a + 1 : 1;
ans = Math.max(ans, Math.max(f[0], f[1]));
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.978` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/981-990/981. 基于时间的键值存储（中等）.md | 981. 基于时间的键值存储 | https://leetcode-cn.com/problems/time-based-key-value-store/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-h5et/ | 中等 | [
"设计数据结构",
"哈希表",
"二分",
"数组",
"红黑树"
] | 创建一个基于时间的键值存储类 `TimeMap`,它支持下面两个操作:
1. set(string key, string value, int timestamp)
* 存储键 key、值 value,以及给定的时间戳 timestamp。
2. get(string key, int timestamp)
* 返回先前调用 set(key, value, timestamp_prev) 所存储的值,其中 timestamp_prev <= timestamp。
* 如果有多个这样的值,则返回对应最大的 timestamp_prev 的那个值。
* 如果没有值,则返回空字符串("")。
示例 1:
```
输入:inputs = ["TimeMap","set","get","get","set","get","get"], inputs = [[],["foo","bar",1],["foo",1],["foo",3],["foo","bar2",4],["foo",4],["foo",5]]
输出:[null,null,"bar","bar",null,"bar2","bar2"]
解释:
TimeMap kv;
kv.set("foo", "bar", 1); // 存储键 "foo" 和值 "bar" 以及时间戳 timestamp = 1
kv.get("foo", 1); // 输出 "bar"
kv.get("foo", 3); // 输出 "bar" 因为在时间戳 3 和时间戳 2 处没有对应 "foo" 的值,所以唯一的值位于时间戳 1 处(即 "bar")
kv.set("foo", "bar2", 4);
kv.get("foo", 4); // 输出 "bar2"
kv.get("foo", 5); // 输出 "bar2"
```
示例 2:
```
输入:inputs = ["TimeMap","set","set","get","get","get","get","get"], inputs = [[],["love","high",10],["love","low",20],["love",5],["love",10],["love",15],["love",20],["love",25]]
输出:[null,null,null,"","high","high","low","low"]
```
提示:
* 所有的键/值字符串都是小写的。
* 所有的键/值字符串长度都在 [1, 100] 范围内。
* 所有 TimeMap.set 操作中的时间戳 timestamps 都是严格递增的。
* 1 <= timestamp <= $10^7$
* TimeMap.set 和 TimeMap.get 函数在每个测试用例中将(组合)调用总计 `120000` 次。 | ### 哈希表套数组
由于 `timestamp` 是严格递增,且没有删除 KV 的操作。
**我们可以使用哈希表套数组的方式进行实现,从而达到均摊 $O(1)$ 的插入操作和 $O(\log{n})$ 的查询操作。**
具体的,为了方便理解,我们可以先建一个 `Node` 类,类中包含键值对和时间戳信息。
然后使用一个全局哈希表 `map` 记录某个 `key` 对应了哪些 `Node`。其中多个 `Node` 是以动态数组的形式进行「以 `timestamp` 升序」存储:
* `set` 操作:以 $O(1)$ 的复杂度找到某个 `key` 对应的数组,利用 `timestamp` 严格递增的特性,以 $O(1)$ 复杂度将新 `Node` 加入当前数组尾部;
* `get` 操作:以 $O(1)$ 的复杂度找到某个 `key` 对应的数组,利用 `timestamp` 严格递增的特性,通过二分以 $O(\log{n})$ 复杂度找到可能符合条件的 `Node`。
代码:
```Java
class TimeMap {
class Node {
String k, v;
int t;
Node (String _k, String _v, int _t) {
k = _k; v = _v; t = _t;
}
}
Map<String, List<Node>> map = new HashMap<>();
public void set(String k, String v, int t) {
List<Node> list = map.getOrDefault(k, new ArrayList<>());
list.add(new Node(k, v, t));
map.put(k, list);
}
public String get(String k, int t) {
List<Node> list = map.getOrDefault(k, new ArrayList<>());
if (list.isEmpty()) return "";
int n = list.size();
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid).t <= t) {
l = mid;
} else {
r = mid - 1;
}
}
return list.get(r).t <= t ? list.get(r).v : "";
}
}
```
* 时间复杂度:`set` 操作的复杂度为 $O(1)$;`get` 操作的复杂度为 $O(\log{n})$
* 空间复杂度:$O(n)$
---
### 哈希表套树
如果增加 `del` 操作呢?我们需要做出何种调整?
考虑在原题的基础上,增加一个 `String del(String k, int t)` 的功能:将严格等于键和时间戳的 KV 对删掉。
**由于存在删除 KV 的动作,我们需要将实现从「哈希表套数组」改成「哈希表套树」,这里直接使用基于红黑树实现的 `TreeMap` 即可。**
同时为了验证删除逻辑的正确性,我们在 `get` 动作发生前,先产生一次随机性的删除,删除后又重新插入。
代码:
```Java
class TimeMap {
class Node {
String k, v;
int t;
Node (String _k, String _v, int _t) {
k = _k; v = _v; t = _t;
}
}
Map<String, TreeMap<Integer, Node>> map = new HashMap<>();
public void set(String k, String v, int t) {
update(k, t);
TreeMap<Integer, Node> ts = map.getOrDefault(k, new TreeMap<Integer, Node>());
ts.put(t, new Node(k, v, t));
map.put(k, ts);
}
Node _get(String k, int t) {
TreeMap<Integer, Node> ts = map.get(k);
if (ts == null) return null;
Map.Entry<Integer, Node> entry = ts.floorEntry(t);
if (entry == null) return null;
Node node = entry.getValue();
return node;
}
public String get(String k, int t) {
randomDel();
Node node = _get(k, t);
return node != null && node.t <= t ? node.v : "";
}
public String del(String k, int t) {
TreeMap<Integer, Node> ts = map.get(k);
if (ts == null) return null;
Map.Entry<Integer, Node> entry = ts.floorEntry(t);
if (entry == null) return null;
Node node = entry.getValue();
if (node != null && node.t == t) {
ts.remove(t);
return node.v;
}
return "";
}
List<String> allInfo = new ArrayList<>();
Random random = new Random();
// 保存所有的 kt 信息
void update(String k, int t) {
String nk = k + "_" + t;
allInfo.add(nk);
}
// 随机删除,再重新插入,验证代码正确性
void randomDel() {
int idx = random.nextInt(allInfo.size());
String[] ss = allInfo.get(idx).split("_");
String k = ss[0];
int t = Integer.parseInt(ss[1]);
Node node = _get(k, t);
del(node.k, node.t);
set(node.k, node.v, node.t);
}
}
```
* 时间复杂度:`set` 操作的复杂度为 $O(\log{n})$;`get` 操作会完成随机删除/重新插入/查询的动作,复杂度均为为 $O(\log{n})$,整个 `get` 的复杂度仍是 $O(\log{n})$(只是常数变大了)
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.981` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/981-990/985. 查询后的偶数和（中等）.md | 985. 查询后的偶数和 | https://leetcode.cn/problems/sum-of-even-numbers-after-queries/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-lwfq/ | 中等 | [
"模拟"
] | 给出一个整数数组 `A` 和一个查询数组 `queries`。
对于第 `i` 次查询,有 `val = queries[i][0]`, `index = queries[i][1]`,我们会把 `val` 加到 `A[index]` 上。然后,第 `i` 次查询的答案是 `A` 中偶数值的和。
(此处给定的 `index = queries[i][1]` 是从 `0` 开始的索引,每次查询都会永久修改数组 `A`。)
返回所有查询的答案。你的答案应当以数组 `answer` 给出,`answer[i]` 为第 `i` 次查询的答案。
示例:
```
输入:A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]
输出:[8,6,2,4]
解释:
开始时,数组为 [1,2,3,4]。
将 1 加到 A[0] 上之后,数组为 [2,2,3,4],偶数值之和为 2 + 2 + 4 = 8。
将 -3 加到 A[1] 上之后,数组为 [2,-1,3,4],偶数值之和为 2 + 4 = 6。
将 -4 加到 A[0] 上之后,数组为 [-2,-1,3,4],偶数值之和为 -2 + 4 = 2。
将 2 加到 A[3] 上之后,数组为 [-2,-1,3,6],偶数值之和为 -2 + 6 = 4。
```
提示:
* $1 <= A.length <= 10000$
* $-10000 <= A[i] <= 10000$
* $1 <= queries.length <= 10000$
* $-10000 <= queries[i][0] <= 10000$
* $0 <= queries[i][1] < A.length$ | ### 模拟
为了方便,将 `queries` 记为 `qs`。
由于每次修改都是对 `A` 的永久修改,因此我们使用一个变量 `t` 来记录当前所有偶数和即可。
具体的,我们先统计原数组所有偶数和为 `t`,从前往后处理每个 $qs[i]$,若修改前的原值 $nums[qs[i][1]]$ 为偶数,我们需要将其从 `t` 中减去,再进行实际修改 `nums[qs[i][1]] += qs[i][0]`,若修改后值为偶数,则将其累加到 `t` 上。
Java 代码:
```Java
class Solution {
public int[] sumEvenAfterQueries(int[] nums, int[][] qs) {
int m = qs.length, t = 0;
int[] ans = new int[m];
for (int x : nums) t += x % 2 == 0 ? x : 0;
for (int i = 0; i < m; i++) {
int val = qs[i][0], idx = qs[i][1];
if (nums[idx] % 2 == 0) t -= nums[idx];
nums[idx] += val;
if (nums[idx] % 2 == 0) t += nums[idx];
ans[i] = t;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> sumEvenAfterQueries(vector<int>& nums, vector<vector<int>>& qs) {
int m = qs.size(), t = 0;
std::vector<int> ans(m);
for (int x : nums) t += x % 2 == 0 ? x : 0;
for (int i = 0; i < m; i++) {
int val = qs[i][0], idx = qs[i][1];
if (nums[idx] % 2 == 0) t -= nums[idx];
nums[idx] += val;
if (nums[idx] % 2 == 0) t += nums[idx];
ans[i] = t;
}
return ans;
}
};
```
Python3 代码:
```Python3
class Solution:
def sumEvenAfterQueries(self, nums: List[int], qs: List[List[int]]) -> List[int]:
m, t = 0, sum(x for x in nums if x % 2 == 0)
ans = []
for val, idx in qs:
if nums[idx] % 2 == 0:
t -= nums[idx]
nums[idx] += val
if nums[idx] % 2 == 0:
t += nums[idx]
ans.append(t)
return ans
```
Go 代码:
```Go
func sumEvenAfterQueries(nums []int, qs [][]int) []int {
m, t := len(qs), 0
ans := make([]int, m)
for _, x := range nums {
if x % 2 == 0 {
t += x
}
}
for i := 0; i < m; i++ {
val, idx := qs[i][0], qs[i][1]
if nums[idx] % 2 == 0 {
t -= nums[idx]
}
nums[idx] += val
if nums[idx] % 2 == 0 {
t += nums[idx]
}
ans[i] = t
}
return ans
}
```
TypeScript 代码:
```TypeScript
function sumEvenAfterQueries(nums: number[], qs: number[][]): number[] {
let m = qs.length, t = 0
for (const x of nums) t += x % 2 == 0 ? x : 0
const ans = new Array(m)
for (let i = 0; i < m; i++) {
const val = qs[i][0], idx = qs[i][1]
if (nums[idx] % 2 == 0) t -= nums[idx]
nums[idx] += val
if (nums[idx] % 2 == 0) t += nums[idx]
ans[i] = t;
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.985` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/981-990/987. 二叉树的垂序遍历（困难）.md | 987. 二叉树的垂序遍历 | https://leetcode-cn.com/problems/vertical-order-traversal-of-a-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-h-wfm3/ | 困难 | [
"数据结构运用",
"二叉树",
"哈希表",
"排序",
"优先队列(堆)",
"DFS"
] | 给你二叉树的根结点 `root` ,请你设计算法计算二叉树的 垂序遍历 序列。
对位于 $(row, col)$ 的每个结点而言,其左右子结点分别位于 $(row + 1, col - 1)$ 和 $(row + 1, col + 1)$ 。树的根结点位于 $(0, 0)$ 。
二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束,按列索引每一列上的所有结点,形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点,则按结点的值从小到大进行排序。
返回二叉树的 垂序遍历 序列。
示例 1:
```
输入:root = [3,9,20,null,null,15,7]
输出:[[9],[3,15],[20],[7]]
解释:
列 -1 :只有结点 9 在此列中。
列 0 :只有结点 3 和 15 在此列中,按从上到下顺序。
列 1 :只有结点 20 在此列中。
列 2 :只有结点 7 在此列中。
```
示例 2:
```
输入:root = [1,2,3,4,5,6,7]
输出:[[4],[2],[1,5,6],[3],[7]]
解释:
列 -2 :只有结点 4 在此列中。
列 -1 :只有结点 2 在此列中。
列 0 :结点 1 、5 和 6 都在此列中。
1 在上面,所以它出现在前面。
5 和 6 位置都是 (2, 0) ,所以按值从小到大排序,5 在 6 的前面。
列 1 :只有结点 3 在此列中。
列 2 :只有结点 7 在此列中。
```
示例 3:
```
输入:root = [1,2,3,4,6,5,7]
输出:[[4],[2],[1,5,6],[3],[7]]
解释:
这个示例实际上与示例 2 完全相同,只是结点 5 和 6 在树中的位置发生了交换。
因为 5 和 6 的位置仍然相同,所以答案保持不变,仍然按值从小到大排序。
```
提示:
* 树中结点数目总数在范围 $[1, 10]$ | ### DFS + 哈希表 + 排序
根据题意,我们需要按照优先级「**“列号从小到大”,对于同列节点,“行号从小到大”,对于同列同行元素,“节点值从小到大”**」进行答案构造。
因此我们可以对树进行遍历,遍历过程中记下这些信息 $(col, row, val)$,然后根据规则进行排序,并构造答案。
我们可以先使用「哈希表」进行存储,最后再进行一次性的排序。
代码:
```Java
class Solution {
Map<TreeNode, int[]> map = new HashMap<>(); // col, row, val
public List<List<Integer>> verticalTraversal(TreeNode root) {
map.put(root, new int[]{0, 0, root.val});
dfs(root);
List<int[]> list = new ArrayList<>(map.values());
Collections.sort(list, (a, b)->{
if (a[0] != b[0]) return a[0] - b[0];
if (a[1] != b[1]) return a[1] - b[1];
return a[2] - b[2];
});
int n = list.size();
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; ) {
int j = i;
List<Integer> tmp = new ArrayList<>();
while (j < n && list.get(j)[0] == list.get(i)[0]) tmp.add(list.get(j++)[2]);
ans.add(tmp);
i = j;
}
return ans;
}
void dfs(TreeNode root) {
if (root == null) return ;
int[] info = map.get(root);
int col = info[0], row = info[1], val = info[2];
if (root.left != null) {
map.put(root.left, new int[]{col - 1, row + 1, root.left.val});
dfs(root.left);
}
if (root.right != null) {
map.put(root.right, new int[]{col + 1, row + 1, root.right.val});
dfs(root.right);
}
}
}
```
* 时间复杂度:令总节点数量为 $n$,填充哈希表时进行树的遍历,复杂度为 $O(n)$;构造答案时需要进行排序,复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### DFS + 优先队列(堆)
显然,最终要让所有节点的相应信息有序,可以使用「优先队列(堆)」边存储边维护有序性。
代码:
```Java
class Solution {
PriorityQueue<int[]> q = new PriorityQueue<>((a, b)->{ // col, row, val
if (a[0] != b[0]) return a[0] - b[0];
if (a[1] != b[1]) return a[1] - b[1];
return a[2] - b[2];
});
public List<List<Integer>> verticalTraversal(TreeNode root) {
int[] info = new int[]{0, 0, root.val};
q.add(info);
dfs(root, info);
List<List<Integer>> ans = new ArrayList<>();
while (!q.isEmpty()) {
List<Integer> tmp = new ArrayList<>();
int[] poll = q.peek();
while (!q.isEmpty() && q.peek()[0] == poll[0]) tmp.add(q.poll()[2]);
ans.add(tmp);
}
return ans;
}
void dfs(TreeNode root, int[] fa) {
if (root.left != null) {
int[] linfo = new int[]{fa[0] - 1, fa[1] + 1, root.left.val};
q.add(linfo);
dfs(root.left, linfo);
}
if (root.right != null) {
int[] rinfo = new int[]{fa[0] + 1, fa[1] + 1, root.right.val};
q.add(rinfo);
dfs(root.right, rinfo);
}
}
}
```
* 时间复杂度:令总节点数量为 $n$,将节点信息存入优先队列(堆)复杂度为 $O(n\log{n})$;构造答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### DFS + 哈希嵌套 + 排序
当然,如果想锻炼一下自己的代码能力,不使用三元组 $(col, row, val)$ 进行存储,而是使用哈希表嵌套,也是可以的。
用三个「哈希表」来记录相关信息:
1. 使用 `node2row` 和 `node2col` 分别用来记录「**节点到行**」&「**节点到列**」的映射关系,并实现 `dfs1` 对树进行遍历,目的是为了记录下相关的映射关系;
2. 使用 `col2row2nodes` 记录「**从列到行,从行到节点集**」的映射关系,具体的存储格式为 `{col : {row : [node1, node2, ... ]}}`,实现 `dfs2` 再次进行树的遍历,配合之前 `node2row` 和 `node2col`信息,填充 `col2row2nodes` 的映射关系;
3. 按照题意,按「列号从小到大」,对于同列节点,按照「行号从小到大」,对于同列同行元素,按照「节点值从小到大」的规则,使用 `col2row2nodes` + 排序 构造答案。
> 注意:本解法可以只进行一次树的遍历,分两步主要是不想 `dfs` 操作过于复杂,加大读者的阅读难度,于是在拆开不影响复杂度上界的情况,选择了分两步。
代码:
```Java
class Solution {
Map<TreeNode, Integer> node2col = new HashMap<>(), node2row = new HashMap<>();
Map<Integer, Map<Integer, List<Integer>>> col2row2nodes = new HashMap<>();
public List<List<Integer>> verticalTraversal(TreeNode root) {
List<List<Integer>> ans = new ArrayList<>();
node2col.put(root, 0);
node2row.put(root, 0);
dfs1(root);
dfs2(root);
List<Integer> cols = new ArrayList<>(col2row2nodes.keySet());
Collections.sort(cols);
for (int col : cols) {
Map<Integer, List<Integer>> row2nodes = col2row2nodes.get(col);
List<Integer> rows = new ArrayList<>(row2nodes.keySet());
Collections.sort(rows);
List<Integer> cur = new ArrayList<>();
for (int row : rows) {
List<Integer> nodes = row2nodes.get(row);
Collections.sort(nodes);
cur.addAll(nodes);
}
ans.add(cur);
}
return ans;
}
// 树的遍历,根据「节点到列」&「节点到行」的映射关系,构造出「从列到行,从行到节点集」的映射关系
void dfs2(TreeNode root) {
if (root == null) return ;
int col = node2col.get(root), row = node2row.get(root);
Map<Integer, List<Integer>> row2nodes = col2row2nodes.getOrDefault(col, new HashMap<>());
List<Integer> nodes = row2nodes.getOrDefault(row, new ArrayList<>());
nodes.add(root.val);
row2nodes.put(row, nodes);
col2row2nodes.put(col, row2nodes);
dfs2(root.left);
dfs2(root.right);
}
// 树的遍历,记录下「节点到列」&「节点到行」的映射关系
void dfs1(TreeNode root) {
if (root == null) return ;
if (root.left != null) {
int col = node2col.get(root);
node2col.put(root.left, col - 1);
int row = node2row.get(root);
node2row.put(root.left, row + 1);
dfs1(root.left);
}
if (root.right != null) {
int col = node2col.get(root);
node2col.put(root.right, col + 1);
int row = node2row.get(root);
node2row.put(root.right, row + 1);
dfs1(root.right);
}
}
}
```
* 时间复杂度:令总的节点数量为 $n$,填充几个哈希表的复杂度为 $O(n)$;构造答案时需要对行号、列号和节点值进行排序,总的复杂度上界为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.987` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/992. K 个不同整数的子数组（困难）.md | 992. K 个不同整数的子数组 | https://leetcode-cn.com/problems/subarrays-with-k-different-integers/solution/miao-dong-xi-lie-xiang-jie-shuang-zhi-zh-9k8w/ | 困难 | [
"双指针",
"滑动窗口"
] | 给定一个正整数数组 $A$,如果 $A$ 的某个子数组中不同整数的个数恰好为 $K$,则称 $A$ 的这个连续、不一定不同的子数组为好子数组。
例如,$[1,2,3,1,2]$ 中有 $3$ 个不同的整数:$1$,$2$,以及 $3$。
返回 $A$ 中好子数组的数目。
示例 1:
```
输入:A = [1,2,1,2,3], K = 2
输出:7
解释:恰好由 2 个不同整数组成的子数组:[1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]
```
示例 2:
```
输入:A = [1,2,1,3,4], K = 3
输出:3
解释:恰好由 3 个不同整数组成的子数组:[1,2,1,3], [2,1,3], [1,3,4]
```
提示:
* $1 <= A.length <= 20000$
* $1 <= A[i] <= A.length$
* $1 <= K <= A.length$ | ### 滑动窗口
对原数组每个 $nums[i]$ 而言:
1. 找到其左边「最远」满足出现 $k$ 个不同字符的下标,记为 $p$ ,这时候形成的区间为 $[p, i]$
2. 找到其左边「最远」满足出现 $k - 1$ 个不同字符的下标,记为 $j$ ,这时候形成的区间为 $[j, i]$
3. **那么对于 $j - p$ 其实就是代表以 $nums[i]$ 为右边界(必须包含 $num[i]$),不同字符数量「恰好」为 $k$ 的子数组数量**
我们使用 $lower$ 数组存起每个位置的 $p$;使用 $upper$ 数组存起每个位置的 $j$。
累积每个位置的 $upper[i] - lower[i]$ 就是答案。
计算 $lower$ 数组 和 $upper$ 数组的过程可以使用双指针。
代码:
```Java
class Solution {
public int subarraysWithKDistinct(int[] nums, int k) {
int n = nums.length;
int[] lower = new int[n], upper = new int[n];
find(nums, lower, k);
find(nums, upper, k - 1);
int ans = 0;
for (int i = 0; i < n; i++) ans += upper[i] - lower[i];
return ans;
}
void find(int[] nums, int[] arr, int k) {
int n = nums.length;
int[] cnt = new int[20010];
for (int i = 0, j = 0, sum = 0; j < n; j++) {
if (++cnt[nums[j]] == 1) sum++;
while (sum > k) {
if (--cnt[nums[i++]] == 0) sum--;
}
if (sum == k) arr[j] = i;
}
}
}
```
* 时间复杂度:对数组进行常数次扫描。复杂度为 $O(n)$。
* 空间复杂度:$O(n)$
---
### 其他
这里的 $lower$ 和 $upper$ 其实可以优化掉,但也只是常数级别的优化,空间复杂度仍为 $O(n)$。
推荐大家打印一下 $lower$ 和 $upper$ 来看看,加深对 **「 $upper[i] - lower[i]$ 代表了考虑 $nums[i]$ 为右边界,不同字符数量「恰好」为 $k$ 的子数组数量 」** 这句话的理解。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.992` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/993. 二叉树的堂兄弟节点（简单）.md | 993. 二叉树的堂兄弟节点 | https://leetcode-cn.com/problems/cousins-in-binary-tree/solution/gong-shui-san-xie-shu-de-sou-suo-dfs-bfs-b200/ | 简单 | [
"树的搜索",
"BFS",
"DFS"
] | 在二叉树中,根节点位于深度 $0$ 处,每个深度为 $k$ 的节点的子节点位于深度 $k+1$ 处。
如果二叉树的两个节点深度相同,但 父节点不同 ,则它们是一对堂兄弟节点。
我们给出了具有唯一值的二叉树的根节点 $root$ ,以及树中两个不同节点的值 $x$ 和 $y$ 。
只有与值 $x$ 和 $y$ 对应的节点是堂兄弟节点时,才返回 $true$ 。否则,返回 $false$。
示例 1:
```
输入:root = [1,2,3,4], x = 4, y = 3
输出:false
```
示例 2:
```
输入:root = [1,2,3,null,4,null,5], x = 5, y = 4
输出:true
```
示例 3:
```
输入:root = [1,2,3,null,4], x = 2, y = 3
输出:false
```
提示:
* 二叉树的节点数介于 $2$ 到 $100$ 之间。
* 每个节点的值都是唯一的、范围为 $1$ 到 $100$ 的整数。 | ### DFS
显然,我们希望得到某个节点的「父节点」&「所在深度」,不难设计出如下「DFS 函数签名」:
```Java
/**
* 查找 t 的「父节点值」&「所在深度」
* @param root 当前搜索到的节点
* @param fa root 的父节点
* @param depth 当前深度
* @param t 搜索目标值
* @return [fa.val, depth]
*/
int[] dfs(TreeNode root, TreeNode fa, int depth, int t);
```
之后按照遍历的逻辑处理即可。
需要注意的时,我们需要区分出「搜索不到」和「搜索对象为 $root$(没有 $fa$ 父节点)」两种情况。
我们约定使用 $-1$ 代指没有找到目标值 $t$,使用 $0$ 代表找到了目标值 $t$,但其不存在父节点。
代码:
```Java
class Solution {
public boolean isCousins(TreeNode root, int x, int y) {
int[] xi = dfs(root, null, 0, x);
int[] yi = dfs(root, null, 0, y);
return xi[1] == yi[1] && xi[0] != yi[0];
}
int[] dfs(TreeNode root, TreeNode fa, int depth, int t) {
if (root == null) return new int[]{-1, -1}; // 使用 -1 代表为搜索不到 t
if (root.val == t) {
return new int[]{fa != null ? fa.val : 1, depth}; // 使用 1 代表搜索值 t 为 root
}
int[] l = dfs(root.left, root, depth + 1, t);
if (l[0] != -1) return l;
return dfs(root.right, root, depth + 1, t);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归开销为 $O(1)$,否则为 $O(n)$
---
### BFS
能使用 `DFS`,自然也能使用 `BFS`,两者大同小异。
代码:
```Java
class Solution {
public boolean isCousins(TreeNode root, int x, int y) {
int[] xi = bfs(root, x);
int[] yi = bfs(root, y);
return xi[1] == yi[1] && xi[0] != yi[0];
}
int[] bfs(TreeNode root, int t) {
Deque<Object[]> d = new ArrayDeque<>(); // 存储值为 [cur, fa, depth]
d.addLast(new Object[]{root, null, 0});
while (!d.isEmpty()) {
int size = d.size();
while (size-- > 0) {
Object[] poll = d.pollFirst();
TreeNode cur = (TreeNode)poll[0], fa = (TreeNode)poll[1];
int depth = (Integer)poll[2];
if (cur.val == t) return new int[]{fa != null ? fa.val : 0, depth};
if (cur.left != null) d.addLast(new Object[]{cur.left, cur, depth + 1});
if (cur.right != null) d.addLast(new Object[]{cur.right, cur, depth + 1});
}
}
return new int[]{-1, -1};
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.993` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/995. K 连续位的最小翻转次数（困难）.md | 995. K 连续位的最小翻转次数 | https://leetcode-cn.com/problems/minimum-number-of-k-consecutive-bit-flips/solution/po-su-tan-xin-jie-fa-yu-tan-xin-chai-fen-4lyy/ | 困难 | [
"贪心",
"差分"
] | 在仅包含 0 和 1 的数组 A 中,一次 K 位翻转包括选择一个长度为 K 的(连续)子数组,同时将子数组中的每个 0 更改为 1,而每个 1 更改为 0。
返回所需的 K 位翻转的最小次数,以便数组没有值为 0 的元素。如果不可能,返回 -1。
示例 1:
```
输入:A = [0,1,0], K = 1
输出:2
解释:先翻转 A[0],然后翻转 A[2]。
```
示例 2:
```
输入:A = [1,1,0], K = 2
输出:-1
解释:无论我们怎样翻转大小为 2 的子数组,我们都不能使数组变为 [1,1,1]。
```
示例 3:
```
输入:A = [0,0,0,1,0,1,1,0], K = 3
输出:3
解释:
翻转 A[0],A[1],A[2]: A变成 [1,1,1,1,0,1,1,0]
翻转 A[4],A[5],A[6]: A变成 [1,1,1,1,1,0,0,0]
翻转 A[5],A[6],A[7]: A变成 [1,1,1,1,1,1,1,1]
```
提示:
* 1 <= A.length <= 30000
* 1 <= K <= A.length | ### 贪心解法
目标是将数组的每一位都变为 1 ,因此对于每一位 0 都需要翻转。
我们可以从前往后处理,遇到 0 则对后面的 `k` 位进行翻转。
这样我们的算法复杂度是 $O(nk)$ 的,数据范围是 3w(数量级为 $10^4$),极限数据下单秒的运算量在 $10^8$ 以上,会有超时风险。
```java []
class Solution {
public int minKBitFlips(int[] nums, int k) {
int n = nums.length;
int ans = 0;
for (int i = 0; i < n; i++) {
if (nums[i] == 0) {
if (i + k > n) return -1;
for (int j = i; j < i + k; j++) nums[j] ^= 1;
ans++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(nk)$
* 空间复杂度:$O(1)$
***
### 补充
评论有同学提出了一些有价值的疑问,我觉得挺有代表性的,因此补充到题解:
1. **为什么这样的解法是「贪心解法」,而不是「暴力解法」?**
首先「暴力解法」必然是**对所有可能出现的翻转方案进行枚举**,然后检查每一个方案得到的结果是否符合全是 1 的要求。
这样的解法,才是暴力解法,它的本质是通过「穷举」找答案。复杂度是指数级别的。
而我们的「朴素贪心解法」只是执行了众多翻转方案中的一种。
举个 🌰,对于 `nums = [0,0,1,1]` 并且 `k = 2` 的数据:
暴力解法应该是「枚举」以下三种方案:
1. 只翻转以第一个 0 开头的子数组(长度固定为 2)
2. 只翻转以第二个 0 开头的子数组(长度固定为 2)
3. 同时翻转第一个 0 开头和第二个 0 开头的子数组(长度固定为 2,只不过这时候第一个 0 被翻转了一次,第二个 0 被翻转了两次)
然后对三种方案得到的最终解进行检查,找出符合结果全是 1 的方案。这种通过「穷举」方案检查合法性的解法才是「暴力」解法。
2. **为什么我采用了与「朴素贪心」解法相似的做法,超时了?**
结果测试 C++、Python 超时,只有 Java 能过。
同样是 97 号样例数据,提交给 LeetCode 执行。Java 运行 200 ms 以内,而 C++ 运行 600 ms。
***
### 贪心 + 差分解法
由于我们总是对连续的一段进行「相同」的操作,同时只有「奇数」次数的翻转才会真正改变当前位置上的值。
自然而然,我们会想到使用数组 `arr` 来记录每一位的翻转次数。
同时我们又不希望是通过「遍历记 `arr` 的 `k` 位进行 +1」来完成统计。
因此可以使用差分数组来进行优化:当需要对某一段 `[l,r]` 进行 +1 的时候,只需要 `arr[l]++` 和 `arr[r + 1]--` 即可。
```java
class Solution {
public int minKBitFlips(int[] nums, int k) {
int n = nums.length;
int ans = 0;
int[] arr = new int[n + 1];
for (int i = 0, cnt = 0; i < n; i++) {
cnt += arr[i];
if ((nums[i] + cnt) % 2 == 0) {
if (i + k > n) return -1;
arr[i + 1]++;
arr[i + k]--;
ans++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 证明
为什么「一遇到 0 就马上进行翻转」这样的做法得到的是最优解?
这道题的贪心证明思路和 [765. 情侣牵手](https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/) 是一样的。
本质上是在证明**当我在处理第 `k` 个位置的 0 的时候,前面 `k - 1` 个位置不存在 0,接下来要如何进行操作,可使得总的翻转次数最小。**
如果你上次真正理解了我的证明过程的话,那么你会很容易就能证明出本题的贪心思路。
所以这次将这个证明过程留给大家思考 ~
***
### 为什么要「证明」或「理解证明」?
证明的意义在于,**你知道为什么这样做是对的**。
带来的好处是:
1. 一道「贪心」题目能搞清楚证明,那么同类的「贪心」题目你就都会做了。**否则就会停留在“我知道这道题可以这样贪心,别的题我不确定是否也能这样做”**。
2. 在「面试」阶段,**你可以很清晰讲解你的思路**。让面试官从你的「思维方式」上喜欢上你
***
### 更多与证明/分析相关的题解:
[561. 数组拆分 I](https://leetcode-cn.com/problems/array-partition-i/) : [反证法证明贪心算法的正确性](https://leetcode-cn.com/problems/array-partition-i/solution/jue-dui-neng-kan-dong-de-zheng-ming-fan-f7trz/)
[765. 情侣牵手](https://leetcode-cn.com/problems/couples-holding-hands/) : [为什么交换任意一个都是对的?:两种 100% 的解法:并查集 & 贪心](https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/)
[1579. 保证图可完全遍历](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/) : [为什么先处理公共边是对的?含贪心证明 + 数组模板 ~](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/solution/tan-xin-bing-cha-ji-shu-zu-shi-xian-jian-w7ko/)
[1631. 最小体力消耗路径](https://leetcode-cn.com/problems/path-with-minimum-effort/) : [反证法证明思路的合法性](https://leetcode-cn.com/problems/path-with-minimum-effort/solution/fan-zheng-fa-zheng-ming-si-lu-de-he-fa-x-ohby/)
[11. 盛最多水的容器](https://leetcode-cn.com/problems/container-with-most-water/) : [双指针+贪心解法【含证明】](https://leetcode-cn.com/problems/container-with-most-water/solution/shua-chuan-lc-shuang-zhi-zhen-tan-xin-ji-52gf/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.995` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/991-1000/997. 找到小镇的法官（简单）.md | 997. 找到小镇的法官 | https://leetcode-cn.com/problems/find-the-town-judge/solution/gong-shui-san-xie-jian-dan-chu-du-ru-du-5ms57/ | 简单 | [
"模拟",
"图论"
] | 在一个小镇里,按从 $1$ 到 $n$ 为 $n$ 个人进行编号。传言称,这些人中有一个是小镇上的秘密法官。
如果小镇的法官真的存在,那么:
* 小镇的法官不相信任何人。
* 每个人(除了小镇法官外)都信任小镇的法官。
* 只有一个人同时满足条件 $1$ 和条件 $24 。
给定数组 $trust$,该数组由信任对 $trust[i] = [a, b]$ 组成,表示编号为 $a$ 的人信任编号为 $b$ 的人。
如果小镇存在秘密法官并且可以确定他的身份,请返回该法官的编号。否则,返回 $-1$。
示例 1:
```
输入:n = 2, trust = [[1,2]]
输出:2
```
示例 2:
```
输入:n = 3, trust = [[1,3],[2,3]]
输出:3
```
示例 3:
```
输入:n = 3, trust = [[1,3],[2,3],[3,1]]
输出:-1
```
示例 4:
```
输入:n = 3, trust = [[1,2],[2,3]]
输出:-1
```
示例 5:
```
输入:n = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]
输出:3
```
提示:
* $1 <= n <= 1000$
* $0 <= trust.length <= 10^4$
* $trust[i].length == 2$
* $trust[i]$ 互不相同
* $trust[i][0] != trust[i][1]$
* $1 <= trust[i][0], trust[i][1] <= n$ | ### 模拟
今天起晚了 🤣
令 $m$ 为 `trust` 数组长度,对于每个 $trust[i] = (a, b)$ 而言,看作是从 $a$ 指向 $b$ 的有向边。
遍历 `trust`,统计每个节点的「入度」和「出度」:若存在 $a -> b$,则 $a$ 节点「出度」加一,$b$ 节点「入度」加一。
最后遍历所有点,若存在「入度」数量为 $n - 1$,且「出度」数量为 $0$ 的节点即是法官。
代码:
```Java
class Solution {
public int findJudge(int n, int[][] trust) {
int[] in = new int[n + 1], out = new int[n + 1];
for (int[] t : trust) {
int a = t[0], b = t[1];
in[b]++; out[a]++;
}
for (int i = 1; i <= n; i++) {
if (in[i] == n - 1 && out[i] == 0) return i;
}
return -1;
}
}
```
* 时间复杂度:$O(m + n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.997` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
Subsets and Splits