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/21-30/30. 串联所有单词的子串（困难）.md | 30. 串联所有单词的子串 | https://leetcode.cn/problems/substring-with-concatenation-of-all-words/solution/by-ac_oier-enjd/ | 困难 | [
"哈希表",
"滑动窗口",
"枚举"
] | 给定一个字符串 `s` 和一些长度相同的单词 `words`。
找出 `s` 中恰好可以由 `words` 中所有单词串联形成的子串的起始位置。
注意子串要与 `words` 中的单词完全匹配,中间不能有其他字符,但不需要考虑 `words` 中单词串联的顺序。
示例 1:
```
输入:
s = "barfoothefoobarman",
words = ["foo","bar"]
输出:[0,9]
解释:
从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。
输出的顺序不重要, [9,0] 也是有效答案。
```
示例 2:
```
输入:
s = "wordgoodgoodgoodbestword",
words = ["word","good","best","word"]
输出:[]
```
提示:
* $1 <= s.length <= 10^4$
* `s` 由小写英文字母组成
* $1 <= words.length <= 5000$
* $1 <= words[i].length <= 30$
* `words[i]` 由小写英文字母组成 | ### 朴素哈希表
令 `n` 为字符串 `s` 的长度,`m` 为数组 `words` 的长度(单词的个数),`w` 为单个单词的长度。
由于 `words` 里面每个单词长度固定,而我们要找的字符串只能恰好包含所有的单词,因此我们要找的目标子串的长度为 $m \times w$。
那么一个直观的思路是:
1. 使用哈希表 `map` 记录 `words` 中每个单词的出现次数
2. 枚举 `s` 中的每个字符作为起点,往后取得长度为 $m \times w$ 的子串 `sub`
3. 使用哈希表 `cur ` 统计 `sub` 每个单词的出现次数(每隔 `w` 长度作为一个单词)
4. 比较 `cur` 和 `map` 是否相同
注意:在步骤 $3$ 中,如果发现 `sub` 中包含了 `words` 没有出现的单词,可以直接剪枝。
剪枝处使用了带标签的 `continue` 语句直接回到外层循环进行。
代码:
```Java
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
int n = s.length(), m = words.length, w = words[0].length();
Map<String, Integer> map = new HashMap<>();
for (String word : words) map.put(word, map.getOrDefault(word, 0) + 1);
List<Integer> ans = new ArrayList<>();
out:for (int i = 0; i + m * w <= n; i++) {
Map<String, Integer> cur = new HashMap<>();
String sub = s.substring(i, i + m * w);
for (int j = 0; j < sub.length(); j += w) {
String item = sub.substring(j, j + w);
if (!map.containsKey(item)) continue out;
cur.put(item, cur.getOrDefault(item, 0) + 1);
}
if (cur.equals(map)) ans.add(i);
}
return ans;
}
}
```
* 时间复杂度:将 `words` 中的单词存入哈希表,复杂度为 $O(m)$(由于字符串长度固定且不超过 $30$,假定所有哈希操作均为 $O(1)$ 的);然后第一层循环枚举 `s` 中的每个字符作为起点,复杂度为 $O(n)$;在循环中将 `sub` 划分为 `m` 个单词进行统计,枚举了 `m - 1` 个下标,复杂度为 $O(m)$;每个字符串的长度为 `w`。整体复杂度为 $O(n \times m \times w)$
* 空间复杂度:$O(m \times w)$
---
### 滑动窗口 + 哈希表
事实上,我们可以**优化这个枚举起点的过程**。
我们可以将起点根据 **当前下标与单词长度的取余结果** 进行分类,这样我们就不用频繁的建立新的哈希表和进行单词统计。
代码:
```Java
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
int n = s.length(), m = words.length, w = words[0].length();
// 统计 words 中「每个目标单词」的出现次数
Map<String, Integer> map = new HashMap<>();
for (String word : words) map.put(word, map.getOrDefault(word, 0) + 1);
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < w; i++) {
// 构建一个当前子串对应 map,统计当前子串中「每个目标单词」的出现次数
Map<String, Integer> curMap = new HashMap<>();
// 滑动窗口的大小固定是 m * w,每次将下一个单词添加进 curMap,上一个单词移出 curMap
for (int j = i; j + w <= n; j += w) {
String cur = s.substring(j, j + w);
curMap.put(cur, curMap.getOrDefault(cur, 0) + 1);
if (j >= i + (m * w)) {
int idx = j - m * w;
String prev = s.substring(idx, idx + w);
if (curMap.get(prev) == 1) curMap.remove(prev);
else curMap.put(prev, curMap.get(prev) - 1);
if (!curMap.getOrDefault(prev, 0).equals(map.getOrDefault(prev, 0))) continue;
}
if (!curMap.getOrDefault(cur, 0).equals(map.getOrDefault(cur, 0))) continue;
// 上面两个 continue 可以减少 map 之间的 equals 操作
if (curMap.equals(map)) ans.add(j - (m - 1) * w);
}
}
return ans;
}
}
```
* 时间复杂度:将 `words` 中的单词存入哈希表,复杂度为 $O(m)$(由于字符串长度固定且不超过 $30$,假定所有哈希操作均为 $O(1)$ 的);然后枚举了取余的结果,复杂度为 $O(w)$;每次循环最多处理 `n` 长度的字符串,复杂度为 $O(n)$。整体复杂度为 $O(m + w \times n)$
* 空间复杂度:$O(m \times w)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.30` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2101-2110/2103. 环和杆（简单）.md | 2103. 环和杆 | https://leetcode.cn/problems/rings-and-rods/solutions/2509056/gong-shui-san-xie-liang-ge-jiao-du-jin-x-r1v1/ | 简单 | [
"模拟",
"位运算"
] | 总计有 `n` 个环,环的颜色可以是红、绿、蓝中的一种。
这些环分别穿在 $10$ 根编号为 $0$ 到 $9$ 的杆上。
给你一个长度为 `2n` 的字符串 `rings`,表示这 `n` 个环在杆上的分布。
`rings` 中每两个字符形成一个 颜色位置对 ,用于描述每个环:
* 第 `i` 对中的 第一个 字符表示第 `i` 个环的 颜色(`'R'`、`'G'`、`'B'`)。
* 第 `i` 对中的 第二个 字符表示第 `i` 个环的 位置,也就是位于哪根杆上(`'0'` 到 `'9'`)。
例如,`"R3G2B1"` 表示:共有 $n = 3$ 个环,红色的环在编号为 $3$ 的杆上,绿色的环在编号为 $2$ 的杆上,蓝色的环在编号为 $1$ 的杆上。
找出所有集齐 全部三种颜色 环的杆,并返回这种杆的数量。
示例 1:
```
输入:rings = "B0B6G0R6R0R6G9"
输出:1
解释:
- 编号 0 的杆上有 3 个环,集齐全部颜色:红、绿、蓝。
- 编号 6 的杆上有 3 个环,但只有红、蓝两种颜色。
- 编号 9 的杆上只有 1 个绿色环。
因此,集齐全部三种颜色环的杆的数目为 1 。
```
示例 2:
```
输入:rings = "B0R0G0R9R0B0G0"
输出:1
解释:
- 编号 0 的杆上有 6 个环,集齐全部颜色:红、绿、蓝。
- 编号 9 的杆上只有 1 个红色环。
因此,集齐全部三种颜色环的杆的数目为 1 。
```
示例 3:
```
输入:rings = "G4"
输出:0
解释:
只给了一个环,因此,不存在集齐全部三种颜色环的杆。
```
提示:
* $rings.length = 2 \times n$
* $1 <= n <= 100$
* 如 `i` 是 偶数 ,则 `rings[i]` 的值可以取 `'R'`、`'G'` 或 `'B'`(下标从 `0` 开始计数)
* 如 `i` 是 奇数 ,则 `rings[i]` 的值可以取 `'0'` 到 `'9'` 中的一个数字(下标从 `0` 开始计数) | ### 位运算 - 统计环
环的数量不定,但杆的数量就 $10$ 根。
我们可以从「环」的角度出发,进行统计。
用一个 `int` 来代表环的统计情况,根据题意,共有 `RGB` 三种颜色的环,共需要 $3$ 个 `int` 数(为了方便,代码直接开了大小为 $128$ 的数组)。
对于一个代表环的数值 $x$ 而言,从低位往高位数,若第 $k$ 位为 $1$,代表编号为 $k$ 的杆包含该颜色的环。
用示例 $1$ 来举个 🌰,`rings = "B0B6G0R6R0R6G9"`
* 红色:在 `0` 和 `6` 中出现过,对应数值 $x = (0001000001)_2$
* 蓝色:在 `0` 和 `6` 中出现过,对应数值 $x = (0001000001)_2$
* 绿色:在 `9` 中出现过,对应数值 $x = (100000000)_2$
在代表三种颜色的数值中,相同位均为 $1$,假设为第 $k$ 位,则代表三种颜色均在第 $k$ 杆中出现过。
最后,统计 $10$ 根杆中有多少满足要求即可。
Java 代码:
```Java
class Solution {
public int countPoints(String s) {
int n = s.length(), ans = 0;
int[] map = new int[128];
for (int i = 0; i < n; i += 2) map[s.charAt(i) - 'B'] |= 1 << (s.charAt(i + 1) - '0');
for (int i = 0; i < 10; i++) {
int tot = 0;
for (char c : new char[]{'R', 'G', 'B'}) tot += (map[c - 'B'] >> i) & 1;
if (tot == 3) ans++;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int countPoints(string s) {
int n = s.size(), ans = 0;
vector<int> map(128, 0);
for (int i = 0; i < n; i += 2) map[s[i] - 'B'] |= 1 << (s[i + 1] - '0');
for (int i = 0; i < 10; i++) {
int tot = 0;
for (char c : {'R', 'G', 'B'}) tot += (map[c - 'B'] >> i) & 1;
if (tot == 3) ans++;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def countPoints(self, s: str) -> int:
n, ans = len(s), 0
map = [0] * 128
for i in range(0, n, 2):
map[ord(s[i]) - ord('B')] |= 1 << (int(s[i + 1]) - int('0'))
for i in range(10):
tot = 0
for c in ['R', 'G', 'B']:
tot += (map[ord(c) - ord('B')] >> i) & 1
ans += 1 if tot == 3 else 0
return ans
```
TypeScript 代码:
```TypeScript
function countPoints(s: string): number {
let n = s.length, ans = 0;
const map = new Array(128).fill(0);
for (let i = 0; i < n; i += 2) {
map[s.charCodeAt(i) - 'B'.charCodeAt(0)] |= 1 << (s.charCodeAt(i + 1) - '0'.charCodeAt(0));
}
for (let i = 0; i < 10; i++) {
let tot = 0;
for (const c of ['R', 'G', 'B']) tot += ((map[c.charCodeAt(0) - 'B'.charCodeAt(0)]) >> i) & 1;
if (tot == 3) ans++;
}
return ans;
};
```
* 时间复杂度:$O(n + C \times K)$,其中 $n$ 为字符串长度,$C = 10$ 为杆的数量,$K = 3$ 为环类型
* 空间复杂度:$O(K)$
---
### 位运算 - 统计杆
虽然环的数量不定,但我们只关心其在某根杆上是否出现过,而不关心其出现次数。
因此,我们也可以从「杆」的角度出发,进行统计。
创建一个大小为 $10$ 的整型数组 `cnt`,其中 $cnt[k] = x$ 代表第 $k$ 根杆的统计情况为 $x$。
从低位到高位,我们对三种颜色 `RGB` 的出现与否进行统计,使用 `0` 和 `1` 分别代表「没出现」和「出现」两种情况。
用示例 $1$ 来举个 🌰,`rings = "B0B6G0R6R0R6G9"`
* 编号为 $0$ 的杆:三种颜色均出现过,其数值为 $cnt[0] = (...111)_2$,从低位到高位,分别代表 `RGB`
* 编号为 $6$ 的杆:`R` 和 `B` 出现过,其数值为 $cnt[6] = (...101)_2$
* 编号为 $9$ 的杆:`G` 出现过,其数值为 $cnt[9] = (...010)_2$
* 其他编号的杆:没有任何颜色出现过,其数值为 $cnt[i] = 0$
Java 代码:
```Java
class Solution {
public int countPoints(String s) {
int n = s.length(), ans = 0;
int[] cnt = new int[10];
for (int i = 0; i < n; i += 2) {
char c = s.charAt(i);
int idx = -1, t = s.charAt(i + 1) - '0';
if (c == 'R') idx = 0;
else if (c == 'G') idx = 1;
else idx = 2;
cnt[t] |= 1 << idx;
}
for (int i = 0; i < 10; i++) {
if (cnt[i] == (1 << 3) - 1) ans++;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int countPoints(string s) {
int n = s.size(), ans = 0;
vector<int> cnt(10, 0);
for (int i = 0; i < n; i += 2) {
int idx = -1, t = s[i + 1] - '0';
if (s[i] == 'R') idx = 0;
else if (s[i] == 'G') idx = 1;
else idx = 2;
cnt[t] |= 1 << idx;
}
for (int i = 0; i < 10; i++) {
if (cnt[i] == (1 << 3) - 1) ans++;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def countPoints(self, s: str) -> int:
n, ans = len(s), 0
cnt = [0] * 10
for i in range(0, n, 2):
idx, t = -1, int(s[i + 1])
if s[i] == 'R':
idx = 0
elif s[i] == 'G':
idx = 1
else:
idx = 2
cnt[t] |= 1 << idx
for i in range(10):
ans += 1 if cnt[i] == (1 << 3) - 1 else 0
return ans
```
TypeScript 代码:
```TypeScript
function countPoints(s: string): number {
let n = s.length, ans = 0;
const cnt = new Array(10).fill(0);
for (let i = 0; i < n; i += 2) {
let idx = -1, t = parseInt(s[i + 1]);
if (s[i] == 'R') idx = 0;
else if (s[i] == 'G') idx = 1;
else idx = 2;
cnt[t] |= 1 << idx;
}
for (let i = 0; i < 10; i++) {
if (cnt[i] == (1 << 3) - 1) ans++;
}
return ans;
};
```
* 时间复杂度:$O(n \times K + C)$,其中 $n$ 为字符串长度,$C = 10$ 为杆的数量,$K = 3$ 为环类型。
注:这里为什么不是 $O(n + C)$,在首个循环中,环的类型决定了分支数量,因此首个循环复杂度为 $O(n \times K)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2103` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2101-2110/2104. 子数组范围和（中等）.md | 2104. 子数组范围和 | https://leetcode-cn.com/problems/sum-of-subarray-ranges/solution/gong-shui-san-xie-yi-ti-san-jie-qu-jian-wn84z/ | 中等 | [
"区间 DP",
"单调栈"
] | 给你一个整数数组 `nums` 。`nums` 中,子数组的 **范围** 是子数组中最大元素和最小元素的差值。
返回 `nums` 中 **所有** 子数组范围的 **和** 。
子数组是数组中一个连续 **非空** 的元素序列。
示例 1:
```
输入:nums = [1,2,3]
输出:4
解释:nums 的 6 个子数组如下所示:
[1],范围 = 最大 - 最小 = 1 - 1 = 0
[2],范围 = 2 - 2 = 0
[3],范围 = 3 - 3 = 0
[1,2],范围 = 2 - 1 = 1
[2,3],范围 = 3 - 2 = 1
[1,2,3],范围 = 3 - 1 = 2
所有范围的和是 0 + 0 + 0 + 1 + 1 + 2 = 4
```
示例 2:
```
输入:nums = [1,3,3]
输出:4
解释:nums 的 6 个子数组如下所示:
[1],范围 = 最大 - 最小 = 1 - 1 = 0
[3],范围 = 3 - 3 = 0
[3],范围 = 3 - 3 = 0
[1,3],范围 = 3 - 1 = 2
[3,3],范围 = 3 - 3 = 0
[1,3,3],范围 = 3 - 1 = 2
所有范围的和是 0 + 0 + 0 + 2 + 0 + 2 = 4
```
示例 3:
```
输入:nums = [4,-2,-3,4,1]
输出:59
解释:nums 中所有子数组范围的和是 59
```
提示:
* 1 <= nums.length <= 1000
* $-10^9 <= nums[i] <= 10^9$
进阶:你可以设计一种时间复杂度为 $O(n)$ 的解决方案吗? | ### 区间 DP(预处理)
数据范围为 $10^3$,最为朴素的三层循环为:枚举区间(左右端点)+ 扫描区间统计最值,并累加到答案中。该做法复杂度为 $O(n^3)$,会 `TLE`。
考虑在此基础上优化,枚举所有区间的操作不好避免,考虑通过「预处理」手段来优化「扫描区间统计最值」操作,通常会将其优化为 $O(1)$ 查表。
定义 $f[l][r][k]$ 为区间 $[l, r]$ 范围内的最值情况,其中 $k$ 非 $0$ 即 $1$:$f[l][r][0]$ 代表区间 $[l, r]$ 内的最小值,$f[l][r][1]$ 代表区间 $[l, r]$ 内的最大值。
不失一般性考虑 $f[l][r][0]$ 和 $f[l][r][1]$ 该如何计算:$[l, r]$ 区间的最值可由 $[l, r - 1]$ 与 $nums[r]$ 更新而来:
$$
f[l][r][0] = \min(f[l][r - 1][0], nums[r])
$$
$$
f[l][r][1] = \max(f[l][r - 1][1], nums[r])
$$
最后再枚举所有区间统计答案即可。
代码:
```Java
class Solution {
public long subArrayRanges(int[] nums) {
int n = nums.length;
int[][][] f = new int[n][n][2];
for (int i = 0; i < n; i++) f[i][i][0] = f[i][i][1] = nums[i];
for (int len = 2; len <= n; len++) {
for (int l = 0; l + len - 1 < n; l++) {
int r = l + len - 1;
f[l][r][0] = Math.min(nums[r], f[l][r - 1][0]);
f[l][r][1] = Math.max(nums[r], f[l][r - 1][1]);
}
}
long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += f[i][j][1] - f[i][j][0];
}
}
return ans;
}
}
```
* 时间复杂度:区间 DP 复杂度为 $O(n^2)$;统计范围和的复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 枚举
更进一步,我们发现在转移计算 $[l, r]$ 的最值情况时,仅依赖于 $[l, r - 1]$(小区间),因此我们可以使用两变量代替动规数组,边遍历边维护并统计答案。
代码:
```Java
class Solution {
public long subArrayRanges(int[] nums) {
int n = nums.length;
long ans = 0;
for (int i = 0; i < n; i++) {
int min = nums[i], max = nums[i];
for (int j = i + 1; j < n; j++) {
min = Math.min(min, nums[j]);
max = Math.max(max, nums[j]);
ans += max - min;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$
---
### 单调栈
假设有 $m$ 个区间,最终的表达式为 $m$ 个等式 $\max - \min$ 之和。
若某个 $nums[i]$,如果在这 $k_1$ 个区间中充当最大值,则在最终等式中以 $\max$ 的形式出现 $k_1$ 次,如果在 $k_2$ 个区间中充当最小值,则在最终等式中以 $\min$ 形式出现 $k_2$ 次。
因此我们可以统计每个 $nums[i]$ 成为区间最大值的次数 $k_1$ 和成为区间最小值的次数 $k_2$,$(k_1 - k_2) * nums[i]$ 为 $nums[i]$ 对于最终答案的贡献。
考虑如何统计每个 $nums[i]$ 成为区间最值的次数:
* $nums[i]$ 作为区间最大值的次数:找到 $nums[i]$ 左右最近一个不满足「小于等于 $nums[i]$」的位置,记其为 $p$ 和 $q$。此时区间左端点共有 $i - p$ 个选择,区间右端点共有 $q - i$ 个选择,根据乘法原理,区间个数为 $(i - p) * (q - i)$ 个;
* $nums[i]$ 作为区间最小值的次数:同理,找到 $nums[i]$ 左右最近一个不满足「大于等于 $nums[i]$」的位置,记其为 $p$ 和 $q$,区间个数为 $(i - p) * (q - i)$ 个。
即问题切换为:**使用「单调栈」找到某个 $nums[i]$ 的左边/右边的最近一个符合某种性质的位置,从而知道 $nums[i]$ 作为区间最值时,左右端点的可选择个数,再结合乘法原理知道 $nums[i]$ 能够作为区间最值的区间个数,从而知道 $nums[i]$ 对答案的贡献。**
值得注意的是,由于 $nums[i]$ 存在相同元素,因此上述两边均取等号的做法会导致某些区间被重复计算,因此我们可以令最近右端点的部分不取等号,确保区间统计不重不漏。
代码:
```Java
class Solution {
int n;
public long subArrayRanges(int[] nums) {
n = nums.length;
// min[i] 为 nums[i] 作为区间最小值的次数;max[i] 为 nums[i] 作为区间最大值的次数
long[] min = getCnt(nums, true), max = getCnt(nums, false);
long ans = 0;
for (int i = 0; i < n; i++) ans += (max[i] - min[i]) * nums[i];
return ans;
}
long[] getCnt(int[] nums, boolean isMin) {
int[] a = new int[n], b = new int[n];
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && (isMin ? nums[d.peekLast()] >= nums[i] : nums[d.peekLast()] <= nums[i])) d.pollLast();
a[i] = d.isEmpty() ? -1 : d.peekLast();
d.addLast(i);
}
d.clear();
for (int i = n - 1; i >= 0; i--) {
while (!d.isEmpty() && (isMin ? nums[d.peekLast()] > nums[i] : nums[d.peekLast()] < nums[i])) d.pollLast();
b[i] = d.isEmpty() ? n : d.peekLast();
d.addLast(i);
}
long[] ans = new long[n];
for (int i = 0; i < n; i++) ans[i] = (i - a[i]) * 1L * (b[i] - i);
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2104` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/211. 添加与搜索单词 - 数据结构设计（中等）.md | 211. 添加与搜索单词 - 数据结构设计 | https://leetcode-cn.com/problems/design-add-and-search-words-data-structure/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-un94/ | 中等 | [
"DFS",
"字典树"
] | 请你设计一个数据结构,支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。
实现词典类 `WordDictionary` :
* `WordDictionary()` 初始化词典对象
* `void addWord(word)` 将 `word` 添加到数据结构中,之后可以对它进行匹配
* `bool search(word)` 如果数据结构中存在字符串与 `word` 匹配,则返回 `true` ;否则,返回 `false`
* `word` 中可能包含一些 `'.'` ,每个 `.` 都可以表示任何一个字母。
示例:
```
输入:
["WordDictionary","addWord","addWord","addWord","search","search","search","search"]
[[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
输出:
[null,null,null,null,false,true,true,true]
解释:
WordDictionary wordDictionary = new WordDictionary();
wordDictionary.addWord("bad");
wordDictionary.addWord("dad");
wordDictionary.addWord("mad");
wordDictionary.search("pad"); // return False
wordDictionary.search("bad"); // return True
wordDictionary.search(".ad"); // return True
wordDictionary.search("b.."); // return True
```
提示:
* $1 <= word.length <= 500$
* `addWord` 中的 `word` 由小写英文字母组成
* `search` 中的 `word` 由 `'.'` 或小写英文字母组成
* 最多调用 $50000$ 次 `addWord` 和 `search` | ### 基本分析
一道 $Trie$ 的轻度变形模板题,还不熟悉 $Trie$ 的同学可以看 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=1006889101&lang=zh_CN#rd),里面详细介绍了实现 $Trie$ 的两种方式、注意事项以及 $Trie$ 应用面等等,是解决本题的前置芝士 🧀。
简单回顾一下:
$Trie$ 树(又叫「前缀树」或「字典树」)是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。
其核心是使用「边」来代表有无字符,使用「点」来记录是否为「单词结尾」以及「其后续字符串的字符是什么」。
回到本题,**首先 `addWord` 操作不会带 `.` 符号,因此我们采用原有的 $Trie$ 插入方式即可;而在 `search` 操作中会有 `.` 符号,我们需要枚举某个 `.` 所代指的字母是什么,这需要结合 `DFS` 来做。**
---
### 二维数组
使用数组实现,需要预先估算数组大小。
通常估算值会很大,直接使用估算值会 MLE。利用 $Trie$ 会有很多位置被共用,以及合格的测试用例,应该至少做到「查询」调用次数和「插入」调用次数相当,我们可以使用比估算值小的数(往下调整一个数量级),更详细的估算逻辑在 [前置芝士](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=1006889101&lang=zh_CN#rd) 讲过,不再赘述。
使用数组实现,还有一个可优化的地方是使用 `static` 修饰所有用到的数组,然后在初始化 `Solution` 的时候做清理工作,这样可以有效避免跑每个样例都创建大数组。
实际测试使用 `static` 与否执行时间会相差超过一半。
代码($P1$ 带 `static` 优化):
```Java
class WordDictionary {
static int N = 250000;
static int[][] tr = new int[N][26];
static boolean[] isWord = new boolean[N];
static int idx;
public WordDictionary() {
for (int i = 0; i < idx; i++) {
Arrays.fill(tr[i], 0);
}
Arrays.fill(isWord, false);
idx = 0;
}
public void addWord(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isWord[p] = true;
}
public boolean search(String s) {
return dfs(s, 0, 0);
}
boolean dfs(String s, int trIdx, int sIdx) {
int n = s.length();
if (n == sIdx) return isWord[trIdx];
char c = s.charAt(sIdx);
if (c == '.') {
for (int j = 0; j < 26; j++) {
if (tr[trIdx][j] != 0 && dfs(s, tr[trIdx][j], sIdx + 1)) return true;
}
return false;
} else {
int u = c - 'a';
if (tr[trIdx][u] == 0) return false;
return dfs(s, tr[trIdx][u], sIdx + 1);
}
}
}
```
```Java
class WordDictionary {
int N = 250000;
int[][] tr = new int[N][26];
boolean[] isWord = new boolean[N];
int idx;
public void addWord(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
isWord[p] = true;
}
public boolean search(String s) {
return dfs(s, 0, 0);
}
boolean dfs(String s, int trIdx, int sIdx) {
int n = s.length();
if (sIdx == n) return isWord[trIdx];
char c = s.charAt(sIdx);
if (c == '.') {
for (int j = 0; j < 26; j++) {
if (tr[trIdx][j] != 0 && dfs(s, tr[trIdx][j], sIdx + 1)) return true;
}
return false;
} else {
int u = c - 'a';
if (tr[trIdx][u] == 0) return false;
return dfs(s, tr[trIdx][u], sIdx + 1);
}
}
}
```
* 时间复杂度:$L$ 为字符串的最大长度,`addWord` 操作的复杂度为 $O(L)$;`search` 操作的复杂度为 $O(C * L)$,其中 $C$ 为字符集大小,固定为 $26$
* 空间复杂度:静态数组大小固定,复杂度为 $O(1e7)$
---
### TrieNode
同理,我们也能够使用 $TrieNode$ 的方式实现。
好处是不需要进行数组大小估算,但是不可避免需要在一个样例中执行多次 $new$ 动作。
代码:
```Java
class WordDictionary {
class Node {
Node[] tns = new Node[26];
boolean isWord;
}
Node root = new Node();
public void addWord(String s) {
Node p = root;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (p.tns[u] == null) p.tns[u] = new Node();
p = p.tns[u];
}
p.isWord = true;
}
public boolean search(String s) {
return dfs(s, root, 0);
}
boolean dfs(String s, Node p, int sIdx) {
int n = s.length();
if (n == sIdx) return p.isWord;
char c = s.charAt(sIdx);
if (c == '.') {
for (int j = 0; j < 26; j++) {
if (p.tns[j] != null && dfs(s, p.tns[j], sIdx + 1)) return true;
}
return false;
} else {
int u = c - 'a';
if (p.tns[u] == null) return false;
return dfs(s, p.tns[u], sIdx + 1);
}
}
}
```
* 时间复杂度:`addWord` 操作的复杂度为 $O(L)$;`search` 操作的复杂度为 $O(C * L)$,其中 $C$ 为字符集大小,固定为 $26$
* 空间复杂度:令 `n` 为插入字符串数量,$L$ 为字符串的最大长度,复杂度为 $O(n * L)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.211` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/212. 单词搜索 II（困难）.md | 212. 单词搜索 II | https://leetcode-cn.com/problems/word-search-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hui-s-am8f/ | 困难 | [
"回溯算法",
"DFS",
"字典树"
] | 给定一个 $m x n$ 二维字符网格 $board$ 和一个单词(字符串)列表 $words$,找出所有同时在二维网格和字典中出现的单词。
单词必须按照字母顺序,通过 相邻的单元格 内的字母构成,其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。
示例 1:
```
输入:board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], words = ["oath","pea","eat","rain"]
输出:["eat","oath"]
```
示例 2:
```
输入:board = [["a","b"],["c","d"]], words = ["abcb"]
输出:[]
```
提示:
* m == board.length
* n == board[i].length
* 1 <= m, n <= 12
* board[i][j] 是一个小写英文字母
* 1 <= words.length <= 3 * $10^4$
* 1 <= words[i].length <= 10
* words[i] 由小写英文字母组成
* words 中的所有字符串互不相同 | ### 回溯算法
**数据范围只有 $12$,且 `words` 中出现的单词长度不会超过 $10$,可以考虑使用「回溯算法」。**
起始先将所有 `words` 出现的单词放到 `Set` 结构中,然后以 `board` 中的每个点作为起点进行爆搜(由于题目规定在一个单词中每个格子只能被使用一次,因此还需要一个 `vis` 数组来记录访问过的位置):
1. 如果当前爆搜到的字符串长度超过 $10$,直接剪枝;
2. 如果当前搜索到的字符串在 `Set` 中,则添加到答案(同时了防止下一次再搜索到该字符串,需要将该字符串从 `Set` 中移除)。
代码:
```Java
class Solution {
Set<String> set = new HashSet<>();
List<String> ans = new ArrayList<>();
char[][] board;
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
int n, m;
boolean[][] vis = new boolean[15][15];
public List<String> findWords(char[][] _board, String[] words) {
board = _board;
m = board.length; n = board[0].length;
for (String w : words) set.add(w);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
vis[i][j] = true;
sb.append(board[i][j]);
dfs(i, j, sb);
vis[i][j] = false;
sb.deleteCharAt(sb.length() - 1);
}
}
return ans;
}
void dfs(int i, int j, StringBuilder sb) {
if (sb.length() > 10) return ;
if (set.contains(sb.toString())) {
ans.add(sb.toString());
set.remove(sb.toString());
}
for (int[] d : dirs) {
int dx = i + d[0], dy = j + d[1];
if (dx < 0 || dx >= m || dy < 0 || dy >= n) continue;
if (vis[dx][dy]) continue;
vis[dx][dy] = true;
sb.append(board[dx][dy]);
dfs(dx, dy, sb);
vis[dx][dy] = false;
sb.deleteCharAt(sb.length() - 1);
}
}
}
```
* 时间复杂度:共有 $m * n$ 个起点,每次能往 $4$ 个方向搜索(不考虑重复搜索问题),且搜索的长度不会超过 $10$。整体复杂度为 $O(m * n * 4^{10})$
* 空间复杂度:$O(\sum_{i=0}^{words.length - 1} words[i].length)$
---
### Trie
**在「解法一」中,对于任意一个当前位置 $(i, j)$,我们都不可避免的搜索了四联通的全部方向,这导致了那些无效搜索路径最终只有长度达到 $10$ 才会被剪枝。**
**要进一步优化我们的搜索过程,需要考虑如何在每一步的搜索中进行剪枝。**
我们可以使用 $Trie$ 结构进行建树,对于任意一个当前位置 $(i, j)$ 而言,只有在 $Trie$ 中存在往从字符 $a$ 到 $b$ 的边时,我们才在棋盘上搜索从 $a$ 到 $b$ 的相邻路径。
不了解 $Trie$ 的同学,可以看看这篇题解 [(题解) 208. 实现 Trie (前缀树)](https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/),里面写了两种实现 $Trie$ 的方式。
对于本题,我们可以使用「TrieNode」的方式进行建 $Trie$。
因为 `words` 里最多有 $10^4$ 个单词,每个单词长度最多为 $10$,如果开成静态数组的话,不考虑共用行的问题,我们需要开一个大小为 $10^5 * 26$ 的大数组,可能会有 TLE 或 MLE 的风险。
与此同时,我们需要将平时建 $TrieNode$ 中的 `isEnd` 标记属性直接换成记录当前字符 `s`,这样我们在 `DFS` 的过程中则无须额外记录当前搜索字符串。
代码:
```Java
class Solution {
class TrieNode {
String s;
TrieNode[] tns = new TrieNode[26];
}
void insert(String s) {
TrieNode p = root;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (p.tns[u] == null) p.tns[u] = new TrieNode();
p = p.tns[u];
}
p.s = s;
}
Set<String> set = new HashSet<>();
char[][] board;
int n, m;
TrieNode root = new TrieNode();
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
boolean[][] vis = new boolean[15][15];
public List<String> findWords(char[][] _board, String[] words) {
board = _board;
m = board.length; n = board[0].length;
for (String w : words) insert(w);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int u = board[i][j] - 'a';
if (root.tns[u] != null) {
vis[i][j] = true;
dfs(i, j, root.tns[u]);
vis[i][j] = false;
}
}
}
List<String> ans = new ArrayList<>();
for (String s : set) ans.add(s);
return ans;
}
void dfs(int i, int j, TrieNode node) {
if (node.s != null) set.add(node.s);
for (int[] d : dirs) {
int dx = i + d[0], dy = j + d[1];
if (dx < 0 || dx >= m || dy < 0 || dy >= n) continue;
if (vis[dx][dy]) continue;
int u = board[dx][dy] - 'a';
if (node.tns[u] != null) {
vis[dx][dy] = true;
dfs(dx, dy, node.tns[u]);
vis[dx][dy] = false;
}
}
}
}
```
* 时间复杂度:共有 $m * n$ 个起点,每次能往 $4$ 个方向搜索(不考虑重复搜索问题),且搜索的长度不会超过 $10$。整体复杂度为 $O(m * n * 4^{10})$
* 空间复杂度:$O(\sum_{i=0}^{words.length - 1} words[i].length * C)$,$C$ 为字符集大小,固定为 $26$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.212` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/213. 打家劫舍 II（中等）.md | 213. 打家劫舍 II | https://leetcode-cn.com/problems/house-robber-ii/solution/gong-shui-san-xie-ru-he-jiang-xin-xian-z-zf0w/ | 中等 | [
"线性 DP"
] | 你是一个专业的小偷,计划偷窃沿街的房屋,每间房内都藏有一定的现金。
这个地方所有的房屋都 围成一圈 ,这意味着第一个房屋和最后一个房屋是紧挨着的。
同时,相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组,计算你 在不触动警报装置的情况下 ,今晚能够偷窃到的最高金额。
示例 1:
```
输入:nums = [2,3,2]
输出:3
解释:你不能先偷窃 1 号房屋(金额 = 2),然后偷窃 3 号房屋(金额 = 2), 因为他们是相邻的。
```
示例 2:
```
输入:nums = [1,2,3,1]
输出:4
解释:你可以先偷窃 1 号房屋(金额 = 1),然后偷窃 3 号房屋(金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
```
示例 3:
```
输入:nums = [0]
输出:0
```
提示:
* 1 <= nums.length <= 100
* 0 <= nums[i] <= 1000 | ### 动态规划
在 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 中,并没有「第一间」和「最后一间」不能同时选择的限制,因此我们从头到尾做一遍 DP 即可。
在 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 中,我们可以将状态定义为两维:
**$f[i][j]$ 代表考虑前 $i$ 个房间,当前 $i$ 房间的现在状态为 $j$ 的最大价值。**
* $f[i][0]$ 代表考虑前 $i$ 个房间,并且「不选」第 $i$ 个房间的最大价值。由于已经明确了第 $i$ 个房间不选,因此 $f[i][0]$ 可以直接由 $max(f[i - 1][0], f[i - 1][1])$ 转移而来。
* $f[i][1]$ 代表考虑前 $i$ 个房间,并且「选」第 $i$ 个房间的最大价值。由于已经明确了第 $i$ 个房间被选,因此 $f[i][1]$ 直接由 $f[i - 1][0] + nums[i]$ 转移过来。
到这里,你已经解决了 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 了。
对于本题,由于只是增加了「第一间」和「最后一间」不能同时选择的限制。
**通常,对于一些明显不是「增加维度」的新限制条件,我们应当考虑直接将其拎出讨论,而不是多增加一维进行状态记录。**
我们可以把「第一间」&「最后一间」单独拎出来讨论:
* 明确「不选」第一间:
1. 初始化 $f[0][0]$ 和 $f[0][1]$,均为 $0$。
2. 先从「第二间」开始递推到「倒数第二间」的最大价值。
3. 再处理「最后一间」的情况:由于明确了「不选第一间」,则最后的最大价值为 $max(f[n - 2][1], f[n - 2][0] + nums[n - 1])$。
* 允许「选」第一间:
1. 初始化 $f[0][0]$ 和 $f[0][1]$,分别为 $0$ 和 $nums[0]$。
2. 先从「第二间」开始递推到「倒数第二间」的最大价值。
3. 再处理「最后一间」的情况:由于明确了「选第一间」,则最后的最大价值为 $max(f[n - 2][0], f[n - 2][1])$。
走完两遍 DP 后,再从两种情况的最大价值中再取一个 $max$ 即是答案。
代码:
```java []
class Solution {
public int rob(int[] nums) {
int n = nums.length;
if (n == 0) return 0;
if (n == 1) return nums[0];
// 第一间「必然不选」的情况
int[][] f = new int[n][2];
for (int i = 1; i < n - 1; i++) {
f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);
f[i][1] = f[i - 1][0] + nums[i];
}
int a = Math.max(f[n - 2][1], f[n - 2][0] + nums[n - 1]);
// 第一间「允许选」的情况
f[0][0] = 0; f[0][1] = nums[0];
for (int i = 1; i < n - 1; i++) {
f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);
f[i][1] = f[i - 1][0] + nums[i];
}
int b = Math.max(f[n - 2][0], f[n - 2][1]);
return Math.max(a, b);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 空间优化
不难发现,我们状态转移最多依赖到前面的 1 行,因此可以通过很机械的「滚动数组」方式将空间修改到 $O(1)$。
代码:
```java []
class Solution {
public int rob(int[] nums) {
int n = nums.length;
if (n == 0) return 0;
if (n == 1) return nums[0];
// 第一间「必然不选」的情况
int[][] f = new int[2][2];
for (int i = 1; i < n - 1; i++) {
f[i%2][0] = Math.max(f[(i - 1)%2][0], f[(i - 1)%2][1]);
f[i%2][1] = f[(i - 1)%2][0] + nums[i];
}
int a = Math.max(f[(n - 2)%2][1], f[(n - 2)%2][0] + nums[n - 1]);
// 第一间「允许选」的情况
f[0][0] = 0; f[0][1] = nums[0];
for (int i = 1; i < n - 1; i++) {
f[i%2][0] = Math.max(f[(i - 1)%2][0], f[(i - 1)%2][1]);
f[i%2][1] = f[(i - 1)%2][0] + nums[i];
}
int b = Math.max(f[(n - 2)%2][0], f[(n - 2)%2][1]);
return Math.max(a, b);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.213` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/215. 数组中的第K个最大元素（中等）.md | 215. 数组中的第K个最大元素 | https://leetcode.cn/problems/kth-largest-element-in-an-array/solution/by-ac_oier-x9h4/ | 中等 | [
"树状数组",
"二分",
"优先队列(堆)",
"快速选择"
] | 给定整数数组 `nums` 和整数 `k`,请返回数组中第 `k` 个最大的元素。
请注意,你需要找的是数组排序后的第 `k` 个最大的元素,而不是第 `k` 个不同的元素。
你必须设计并实现时间复杂度为 $O(n)$ 的算法解决此问题。
示例 1:
```
输入: [3,2,1,5,6,4], k = 2
输出: 5
```
示例 2:
```
输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4
```
提示:
* $1 <= k <= nums.length <= 10^5$
* $-10^4 <= nums[i] <= 10^4$ | ### 值域映射 + 树状数组 + 二分
除了直接对数组进行排序,取第 $k$ 位的 $O(n\log{n})$ 做法以外。
对于值域大小 小于 数组长度本身时,我们还能使用「树状数组 + 二分」的 $O(n\log{m})$ 做法,其中 $m$ 为值域大小。
首先值域大小为 $[-10^4, 10^4]$,为了方便,我们为每个 $nums[i]$ 增加大小为 $1e4 + 10$ 的偏移量,将值域映射到 $[10, 2 \times 10^4 + 10]$ 的空间。
将每个增加偏移量后的 $nums[i]$ 存入树状数组,考虑在 $[0, m)$ 范围内进行二分,假设我们真实第 $k$ 大的值为 $t$,那么在以 $t$ 为分割点的数轴上,具有二段性质:
* 在 $[0, t]$ 范围内的数 $cur$ 满足「树状数组中大于等于 $cur$ 的数不低于 $k$ 个」
* 在 $(t, m)$ 范围内的数 $cur$ 不满足「树状数组中大于等于 $cur$ 的数不低于 $k$ 个」
二分出结果后再减去刚开始添加的偏移量即是答案。
Java 代码:
```Java
class Solution {
int M = 100010, N = 2 * M;
int[] tr = new int[N];
int lowbit(int x) {
return x & -x;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
}
void add(int x) {
for (int i = x; i < N; i += lowbit(i)) tr[i]++;
}
public int findKthLargest(int[] nums, int k) {
for (int x : nums) add(x + M);
int l = 0, r = N - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (query(N - 1) - query(mid - 1) >= k) l = mid;
else r = mid - 1;
}
return r - M;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int N = 200010, M = 100010, tr[200010];
int lowbit(int x) {
return x & -x;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
}
void add(int x) {
for (int i = x; i < N; i += lowbit(i)) tr[i]++;
}
int findKthLargest(vector<int>& nums, int k) {
for (int x : nums) add(x + M);
int l = 0, r = N - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (query(N - 1) - query(mid - 1) >= k) l = mid;
else r = mid - 1;
}
return r - M;
}
};
```
Python 代码:
```Python
class Solution:
def findKthLargest(self, nums: List[int], k: int) -> int:
N, M = 200010, 100010
tr = [0] * N
def lowbit(x):
return x & -x
def query(x):
ans = 0
i = x
while i > 0:
ans += tr[i]
i -= lowbit(i)
return ans
def add(x):
i = x
while i < N:
tr[i] += 1
i += lowbit(i)
for x in nums:
add(x + M)
l, r = 0, N - 1
while l < r:
mid = l + r + 1 >> 1
if query(N - 1) - query(mid - 1) >= k: l = mid
else: r = mid - 1
return r - M
```
TypeScript 代码:
```TypeScript
function findKthLargest(nums: number[], k: number): number {
const N = 200010, M = 100010;
const tr = new Array(N).fill(0);
const lowbit = function(x: number): number {
return x & -x;
};
const add = function(x: number): void {
for (let i = x; i < N; i += lowbit(i)) tr[i]++;
};
const query = function(x: number): number {
let ans = 0;
for (let i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
};
for (const x of nums) add(x + M);
let l = 0, r = N - 1;
while (l < r) {
const mid = l + r + 1 >> 1;
if (query(N - 1) - query(mid - 1) >= k) l = mid;
else r = mid - 1;
}
return r - M;
};
```
* 时间复杂度:将所有数字放入树状数组复杂度为 $O(n\log{m})$;二分出答案复杂度为 $O(\log^2{m})$,其中 $m = 2 \times 10^4$ 为值域大小。整体复杂度为 $O(n\log{m})$
* 空间复杂度:$O(m)$
---
### 优先队列(堆)
另外一个容易想到的想法是利用优先队列(堆),由于题目要我们求的是第 $k$ 大的元素,因此我们建立一个小根堆。
根据当前队列元素个数或当前元素与栈顶元素的大小关系进行分情况讨论:
* 当优先队列元素不足 $k$ 个,可将当前元素直接放入队列中;
* 当优先队列元素达到 $k$ 个,并且当前元素大于栈顶元素(栈顶元素必然不是答案),可将当前元素放入队列中。
Java 代码:
```Java
class Solution {
public int findKthLargest(int[] nums, int k) {
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);
for (int x : nums) {
if (q.size() < k || q.peek() < x) q.add(x);
if (q.size() > k) q.poll();
}
return q.peek();
}
}
```
C++ 代码:
```C++
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
priority_queue<int, vector<int>, greater<int>> q;
for (int x : nums) {
if (q.size() < k || q.top() < x) q.push(x);
if (q.size() > k) q.pop();
}
return q.top();
}
};
```
Python 代码:
```Python
class Solution:
def findKthLargest(self, nums: List[int], k: int) -> int:
q = []
for x in nums:
if len(q) < k or q[0] < x:
heapq.heappush(q, x)
if len(q) > k:
heapq.heappop(q)
return q[0]
```
* 时间复杂度:$O(n\log{k})$
* 空间复杂度:$O(k)$
---
### 快速选择
对于给定数组,求解第 $k$ 大元素,且要求线性复杂度,正解为使用「快速选择」做法。
基本思路与「快速排序」一致,每次敲定一个基准值 `x`,根据当前与 `x` 的大小关系,将范围在 $[l, r]$ 的 $nums[i]$ 划分为到两边。
同时利用,利用题目只要求输出第 $k$ 大的值,而不需要对数组进行整体排序,我们只需要根据划分两边后,第 $k$ 大数会落在哪一边,来决定对哪边进行递归处理即可。
> 快速排序模板为面试向重点内容,需要重要掌握。
Java 代码:
```Java
class Solution {
int[] nums;
int qselect(int l, int r, int k) {
if (l == r) return nums[k];
int x = nums[l], i = l - 1, j = r + 1;
while (i < j) {
do i++; while (nums[i] < x);
do j--; while (nums[j] > x);
if (i < j) swap(i, j);
}
if (k <= j) return qselect(l, j, k);
else return qselect(j + 1, r, k);
}
void swap(int i, int j) {
int c = nums[i];
nums[i] = nums[j];
nums[j] = c;
}
public int findKthLargest(int[] _nums, int k) {
nums = _nums;
int n = nums.length;
return qselect(0, n - 1, n - k);
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> nums;
int qselect(int l, int r, int k) {
if (l == r) return nums[k];
int x = nums[l], i = l - 1, j = r + 1;
while (i < j) {
do i++; while (nums[i] < x);
do j--; while (nums[j] > x);
if (i < j) swap(nums[i], nums[j]);
}
if (k <= j) return qselect(l, j, k);
else return qselect(j + 1, r, k);
}
int findKthLargest(vector<int>& _nums, int k) {
nums = _nums;
int n = nums.size();
return qselect(0, n - 1, n - k);
}
};
```
Python 代码:
```Python
class Solution:
def findKthLargest(self, nums: List[int], k: int) -> int:
def qselect(l, r, k):
if l == r:
return nums[k]
x, i, j = nums[l], l - 1, r + 1
while i < j:
i += 1
while nums[i] < x:
i += 1
j -= 1
while nums[j] > x:
j -= 1
if i < j:
nums[i], nums[j] = nums[j], nums[i]
if k <= j:
return qselect(l, j, k)
else:
return qselect(j + 1, r, k)
n = len(nums)
return qselect(0, n - 1, n - k)
```
TypeScript 代码:
```TypeScript
function findKthLargest(nums: number[], k: number): number {
const qselect = function(l: number, r: number, k: number): number {
if (l === r) return nums[k];
const x = nums[l];
let i = l - 1, j = r + 1;
while (i < j) {
i++;
while (nums[i] < x) i++;
j--;
while (nums[j] > x) j--;
if (i < j) [nums[i], nums[j]] = [nums[j], nums[i]];
}
if (k <= j) return qselect(l, j, k);
else return qselect(j + 1, r, k);
};
const n = nums.length;
return qselect(0, n - 1, n - k);
};
```
* 时间复杂度:期望 $O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.215` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/218. 天际线问题（困难）.md | 218. 天际线问题 | https://leetcode-cn.com/problems/the-skyline-problem/solution/gong-shui-san-xie-sao-miao-xian-suan-fa-0z6xc/ | 困难 | [
"扫描线问题",
"优先队列(堆)"
] | 城市的天际线是从远处观看该城市中所有建筑物形成的轮廓的外部轮廓。
给你所有建筑物的位置和高度,请返回由这些建筑物形成的 天际线 。
每个建筑物的几何信息由数组 `buildings` 表示,其中三元组 `buildings[i] = [lefti, righti, heighti]` 表示:
* `left[i]` 是第 `i` 座建筑物左边缘的 `x` 坐标。
* `right[i]` 是第 `i` 座建筑物右边缘的 `x` 坐标。
* `height[i]` 是第 `i` 座建筑物的高度。
天际线 应该表示为由 “关键点” 组成的列表,格式 `[[x1,y1],[x2,y2],...]`,并按 `x` 坐标 进行 排序 。
关键点是水平线段的左端点。列表中最后一个点是最右侧建筑物的终点,`y` 坐标始终为 $0$ ,仅用于标记天际线的终点。
此外,任何两个相邻建筑物之间的地面都应被视为天际线轮廓的一部分。
注意:输出天际线中不得有连续的相同高度的水平线。例如 `[...[2 3], [4 5], [7 5], [11 5], [12 7]...]` 是不正确的答案;三条高度为 $5$ 的线应该在最终输出中合并为一个:`[...[2 3], [4 5], [12 7], ...]`
示例 1:
```
输入:buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]
输出:[[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]
解释:
图 A 显示输入的所有建筑物的位置和高度,
图 B 显示由这些建筑物形成的天际线。图 B 中的红点表示输出列表中的关键点。
```
示例 2:
```
输入:buildings = [[0,2,3],[2,5,3]]
输出:[[0,3],[5,0]]
```
提示:
* $1 <= buildings.length <= 10^4$
* $0 <= lefti < righti <= 2^{31} - 1$
* $1 <= heighti <= 2^{31} - 1$
* `buildings` 按 $left_i$ 非递减排序 | ### 基本分析
这是一题特别的扫描线问题 🤣🤣🤣
既不是求周长,也不是求面积,是求轮廓中的所有的水平线的左端点 🤣🤣🤣
所以这不是一道必须用「线段树」来解决的扫描线问题(因为不需要考虑区间查询问题)。
扫描线的核心在于 **将不规则的形状按照水平或者垂直的方式,划分成若干个规则的矩形。**
---
### 扫描线
对于本题,对应的扫描线分割形状如图:
不难发现,由相邻两个横坐标以及最大高度,可以确定一个矩形。
题目要我们 **输出每个矩形的“上边”的左端点,同时跳过可由前一矩形“上边”延展而来的那些边。**
因此我们需要实时维护一个最大高度,可以使用优先队列(堆)。
实现时,我们可以先记录下 $buildings$ 中所有的左右端点横坐标及高度,并根据端点横坐标进行从小到大排序。
在从前往后遍历处理时(遍历每个矩形),根据当前遍历到的点进行分情况讨论:
* 左端点:因为是左端点,必然存在一条从右延展的边,但不一定是需要被记录的边,因为在同一矩形中,我们只需要记录最上边的边。这时候可以将高度进行入队;
* 右端点:此时意味着之前某一条往右延展的线结束了,这时候需要将高度出队(代表这结束的线不被考虑)。
然后从优先队列中取出当前的最大高度,为了防止当前的线与前一矩形“上边”延展而来的线重合,我们需要使用一个变量 `prev` 记录上一个记录的高度。
代码:
```Java
class Solution {
public List<List<Integer>> getSkyline(int[][] bs) {
List<List<Integer>> ans = new ArrayList<>();
// 预处理所有的点,为了方便排序,对于左端点,令高度为负;对于右端点令高度为正
List<int[]> ps = new ArrayList<>();
for (int[] b : bs) {
int l = b[0], r = b[1], h = b[2];
ps.add(new int[]{l, -h});
ps.add(new int[]{r, h});
}
// 先按照横坐标进行排序
// 如果横坐标相同,则按照左端点排序
// 如果相同的左/右端点,则按照高度进行排序
Collections.sort(ps, (a, b)->{
if (a[0] != b[0]) return a[0] - b[0];
return a[1] - b[1];
});
// 大根堆
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
int prev = 0;
q.add(prev);
for (int[] p : ps) {
int point = p[0], height = p[1];
if (height < 0) {
// 如果是左端点,说明存在一条往右延伸的可记录的边,将高度存入优先队列
q.add(-height);
} else {
// 如果是右端点,说明这条边结束了,将当前高度从队列中移除
q.remove(height);
}
// 取出最高高度,如果当前不与前一矩形“上边”延展而来的那些边重合,则可以被记录
int cur = q.peek();
if (cur != prev) {
List<Integer> list = new ArrayList<>();
list.add(point);
list.add(cur);
ans.add(list);
prev = cur;
}
}
return ans;
}
}
```
* 时间复杂度:需要处理的矩阵数量与 $n$ 正比,每个矩阵需要使用优先队列维护高度,其中 `remove` 操作需要先花费 $O(n)$ 复杂度进行查找,然后通过 $O(\log{n})$ 复杂度进行移除,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$
---
### 答疑
**1. 将左端点的高度存成负数再进行排序是什么意思?**
这里只是为了方便,所以采取了这样的做法,当然也能够多使用一位来代指「左右」。
只要最终可以达到如下的排序规则即可:
1. 先严格按照横坐标进行「从小到大」排序
2. 对于某个横坐标而言,可能会同时出现多个点,应当按照如下规则进行处理:
1. 优先处理左端点,再处理右端点
2. 如果同样都是左端点,则按照高度「从大到小」进行处理(将高度增加到优先队列中)
3. 如果同样都是右端点,则按照高度「从小到大」进行处理(将高度从优先队列中删掉)
代码:
```Java
class Solution {
public List<List<Integer>> getSkyline(int[][] bs) {
List<List<Integer>> ans = new ArrayList<>();
List<int[]> ps = new ArrayList<>();
for (int[] b : bs) {
int l = b[0], r = b[1], h = b[2];
ps.add(new int[]{l, h, -1});
ps.add(new int[]{r, h, 1});
}
/**
* 先严格按照横坐标进行「从小到大」排序
* 对于某个横坐标而言,可能会同时出现多个点,应当按照如下规则进行处理:
* 1. 优先处理左端点,再处理右端点
* 2. 如果同样都是左端点,则按照高度「从大到小」进行处理(将高度增加到优先队列中)
* 3. 如果同样都是右端点,则按照高度「从小到大」进行处理(将高度从优先队列中删掉)
*/
Collections.sort(ps, (a, b)->{
if (a[0] != b[0]) return a[0] - b[0];
if (a[2] != b[2]) return a[2] - b[2];
if (a[2] == -1) {
return b[1] - a[1];
} else {
return a[1] - b[1];
}
});
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
int prev = 0;
q.add(prev);
for (int[] p : ps) {
int point = p[0], height = p[1], flag = p[2];
if (flag == -1) {
q.add(height);
} else {
q.remove(height);
}
int cur = q.peek();
if (cur != prev) {
List<Integer> list = new ArrayList<>();
list.add(point);
list.add(cur);
ans.add(list);
prev = cur;
}
}
return ans;
}
}
```
**2. 为什么在处理前,先往「优先队列」添加一个 $0$ ?**
因为题目本身要求我们把一个完整轮廓的「右下角」那个点也取到,所以需要先添加一个 $0$。
也就是下图被圈出来的那些点:
**3. 优先队列的 `remove` 操作成为了瓶颈,如何优化?**
由于优先队列的 `remove` 操作需要先经过 $O(n)$ 的复杂度进行查找,再通过 $O(\log{n})$ 的复杂度进行删除。因此整个 `remove` 操作的复杂度是 $O(n)$ 的,这导致了我们算法整体复杂度为 $O(n^2)$。
优化方式包括:使用基于红黑树的 `TreeMap` 代替优先队列;或是使用「哈希表」记录「执行了删除操作的高度」及「删除次数」,在每次使用前先检查堆顶高度是否已经被标记删除,如果是则进行 `poll` 操作,并更新删除次数,直到遇到一个没被删除的堆顶高度。
代码:
```Java
class Solution {
public List<List<Integer>> getSkyline(int[][] bs) {
List<List<Integer>> ans = new ArrayList<>();
List<int[]> ps = new ArrayList<>();
for (int[] b : bs) {
int l = b[0], r = b[1], h = b[2];
ps.add(new int[]{l, h, -1});
ps.add(new int[]{r, h, 1});
}
/**
* 先严格按照横坐标进行「从小到大」排序
* 对于某个横坐标而言,可能会同时出现多个点,应当按照如下规则进行处理:
* 1. 优先处理左端点,再处理右端点
* 2. 如果同样都是左端点,则按照高度「从大到小」进行处理(将高度增加到优先队列中)
* 3. 如果同样都是右端点,则按照高度「从小到大」进行处理(将高度从优先队列中删掉)
*/
Collections.sort(ps, (a, b)->{
if (a[0] != b[0]) return a[0] - b[0];
if (a[2] != b[2]) return a[2] - b[2];
if (a[2] == -1) {
return b[1] - a[1];
} else {
return a[1] - b[1];
}
});
// 记录进行了删除操作的高度,以及删除次数
Map<Integer, Integer> map = new HashMap<>();
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
int prev = 0;
q.add(prev);
for (int[] p : ps) {
int point = p[0], height = p[1], flag = p[2];
if (flag == -1) {
q.add(height);
} else {
map.put(height, map.getOrDefault(height, 0) + 1);
}
while (!q.isEmpty()) {
int peek = q.peek();
if (map.containsKey(peek)) {
if (map.get(peek) == 1) map.remove(peek);
else map.put(peek, map.get(peek) - 1);
q.poll();
} else {
break;
}
}
int cur = q.peek();
if (cur != prev) {
List<Integer> list = new ArrayList<>();
list.add(point);
list.add(cur);
ans.add(list);
prev = cur;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.218` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/219. 存在重复元素 II（简单）.md | 219. 存在重复元素 II | https://leetcode-cn.com/problems/contains-duplicate-ii/solution/gong-shui-san-xie-hua-dong-chuang-kou-yu-q02i/ | 简单 | [
"滑动窗口",
"哈希表"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,判断数组中是否存在两个 不同的索引 `i` 和 `j` ,满足 `nums[i] == nums[j]` 且 `abs(i - j) <= k` 。如果存在,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:nums = [1,2,3,1], k = 3
输出:true
```
示例 2:
```
输入:nums = [1,0,1,1], k = 1
输出:true
```
示例 3:
```
输入:nums = [1,2,3,1,2,3], k = 2
输出:false
```
提示:
* $1 <= nums.length <= 10^5$
* $-10^9 <= nums[i] <= 10^9$
* $0 <= k <= 10^5$ | ### 滑动窗口 + 哈希表
整理题意:是否存在长度不超过的 $k + 1$ 窗口,窗口内有相同元素。
我们可以从前往后遍历 $nums$,同时使用 `Set` 记录遍历当前滑窗内出现过的元素。
假设当前遍历的元素为 $nums[i]$:
* 下标小于等于 $k$(起始滑窗长度还不足 $k + 1$):直接往滑窗加数,即将当前元素加入 `Set` 中;
* 下标大于 $k$:将上一滑窗的左端点元素 $nums[i - k - 1]$ 移除,判断当前滑窗的右端点元素 $nums[i]$ 是否存在 `Set` 中,若存在,返回 `True`,否则将当前元素 $nums[i]$ 加入 `Set` 中。
重复上述过程,若整个 $nums$ 处理完后仍未找到,返回 `False`。
**代码(感谢 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**
```Java
class Solution {
public boolean containsNearbyDuplicate(int[] nums, int k) {
int n = nums.length;
Set<Integer> set = new HashSet<>();
for (int i = 0; i < n; i++) {
if (i > k) set.remove(nums[i - k - 1]);
if (set.contains(nums[i])) return true;
set.add(nums[i]);
}
return false;
}
}
```
-
```Python3
class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
n = len(nums)
s = set()
for i in range(n):
if i > k:
s.remove(nums[i - k - 1])
if nums[i] in s:
return True
s.add(nums[i])
return False
````
-
```Go
func containsNearbyDuplicate(nums []int, k int) bool {
n := len(nums)
set := map[int]bool{}
for i := 0; i < n; i++ {
if i > k {
set[nums[i - k - 1]] = false
}
if set[nums[i]] {
return true
}
set[nums[i]] = true
}
return false
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.219` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/211-220/220. 存在重复元素 III（中等）.md | 220. 存在重复元素 III | https://leetcode-cn.com/problems/contains-duplicate-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-dlnv/ | 中等 | [
"滑动窗口",
"二分",
"桶排序"
] | 给你一个整数数组 nums 和两个整数 k 和 t 。
请你判断是否存在 两个不同下标 i 和 j,使得 abs(nums[i] - nums[j]) <= t ,同时又满足 abs(i - j) <= k 。
如果存在则返回 true,不存在返回 false。
示例 1:
```
输入:nums = [1,2,3,1], k = 3, t = 0
输出:true
```
示例 2:
```
输入:nums = [1,0,1,1], k = 1, t = 2
输出:true
```
示例 3:
```
输入:nums = [1,5,9,1,5,9], k = 2, t = 3
输出:false
```
提示:
* 0 <= nums.length <= 2 * $10^4$
* -$2^{31}$ <= nums[i] <= $2^{31}$ - 1
* 0 <= k <= $10^4$
* 0 <= t <= $2^{31}$ - 1 | ### 滑动窗口 & 二分
**根据题意,对于任意一个位置 `i`(假设其值为 `u`),我们其实是希望在下标范围为 $[max(0, i - k), i)$ 内找到值范围在 $[u - t, u + t]$ 的数。**
一个朴素的想法是每次遍历到任意位置 `i` 的时候,往后检查 `k` 个元素,但这样做的复杂度是 $O(nk)$ 的,会超时。
显然我们需要优化「检查后面 `k` 个元素」这一过程。
**我们希望使用一个「有序集合」去维护长度为 `k` 的滑动窗口内的数,该数据结构最好支持高效「查询」与「插入/删除」操作:**
* **查询:能够在「有序集合」中应用「二分查找」,快速找到「小于等于 $u$ 的最大值」和「大于等于 `u` 的最小值」(即「有序集合」中的最接近 `u` 的数)。**
* **插入/删除:在往「有序集合」添加或删除元素时,能够在低于线性的复杂度内完成(维持有序特性)。**
或许你会想到近似 $O(1)$ 操作的 `HashMap`,但注意这里我们需要找的是符合 $abs(nums[i], nums[j]) \leqslant t$ 的两个值,`nums[i]` 与 `nums[j]` 并不一定相等,而 `HashMap` 无法很好的支持「范围查询」操作。
我们还会想到「树」结构。
例如 AVL,能够让我们在最坏为 $O(\log{k})$ 的复杂度内取得到最接近 `u` 的值是多少,但本题除了「查询」以外,还涉及频繁的「插入/删除」操作(随着我们遍历 `nums` 的元素,滑动窗口不断右移,我们需要不断的往「有序集合」中删除和添加元素)。
简单采用 AVL 树,会导致每次的插入删除操作都触发 AVL 的平衡调整,一次平衡调整会伴随着若干次的旋转。
而红黑树则很好解决了上述问题:将平衡调整引发的旋转的次数从「若干次」限制到「最多三次」。
**因此,当「查询」动作和「插入/删除」动作频率相当时,更好的选择是使用「红黑树」。**
也就是对应到 Java 中的 `TreeSet` 数据结构(基于红黑树,查找和插入都具有折半的效率)。
其他细节:由于 `nums` 中的数较大,会存在 `int` 溢出问题,我们需要使用 `long` 来存储。
代码:
```Java
class Solution {
public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
int n = nums.length;
TreeSet<Long> ts = new TreeSet<>();
for (int i = 0; i < n; i++) {
Long u = nums[i] * 1L;
// 从 ts 中找到小于等于 u 的最大值(小于等于 u 的最接近 u 的数)
Long l = ts.floor(u);
// 从 ts 中找到大于等于 u 的最小值(大于等于 u 的最接近 u 的数)
Long r = ts.ceiling(u);
if(l != null && u - l <= t) return true;
if(r != null && r - u <= t) return true;
// 将当前数加到 ts 中,并移除下标范围不在 [max(0, i - k), i) 的数(维持滑动窗口大小为 k)
ts.add(u);
if (i >= k) ts.remove(nums[i - k] * 1L);
}
return false;
}
}
```
* 时间复杂度:`TreeSet` 基于红黑树,查找和插入都是 $O(\log{k})$ 复杂度。整体复杂度为 $O(n\log{k})$
* 空间复杂度:$O(k)$
---
### 桶排序
**上述解法无法做到线性的原因是:我们需要在大小为 `k` 的滑动窗口所在的「有序集合」中找到与 `u` 接近的数。**
**如果我们能够将 `k` 个数字分到 $k$ 个桶的话,那么我们就能 $O(1)$ 的复杂度确定是否有 $[u - t, u + t]$ 的数字(检查目标桶是否有元素)。**
具体的做法为:令桶的大小为 $size = t + 1$,根据 `u` 计算所在桶编号:
* 如果已经存在该桶,说明前面已有 $[u - t, u + t]$ 范围的数字,返回 `true`
* 如果不存在该桶,则检查相邻两个桶的元素是有 $[u - t, u + t]$ 范围的数字,如有 返回 `true`
* 建立目标桶,并删除下标范围不在 $[max(0, i - k), i)$ 内的桶
代码:
```Java
class Solution {
long size;
public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
int n = nums.length;
Map<Long, Long> map = new HashMap<>();
size = t + 1L;
for (int i = 0; i < n; i++) {
long u = nums[i] * 1L;
long idx = getIdx(u);
// 目标桶已存在(桶不为空),说明前面已有 [u - t, u + t] 范围的数字
if (map.containsKey(idx)) return true;
// 检查相邻的桶
long l = idx - 1, r = idx + 1;
if (map.containsKey(l) && u - map.get(l) <= t) return true;
if (map.containsKey(r) && map.get(r) - u <= t) return true;
// 建立目标桶
map.put(idx, u);
// 移除下标范围不在 [max(0, i - k), i) 内的桶
if (i >= k) map.remove(getIdx(nums[i - k] * 1L));
}
return false;
}
long getIdx(long u) {
return u >= 0 ? u / size : ((u + 1) / size) - 1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(k)$
---
### 【重点】如何理解 `getIdx()` 的逻辑
1. 为什么 `size` 需要对 `t` 进行 `+1` 操作?
**目的是为了确保差值小于等于 `t` 的数能够落到一个桶中。**
举个 🌰,假设 `[0,1,2,3]`,`t = 3`,显然四个数都应该落在同一个桶。
如果不对 `t` 进行 `+1` 操作的话,那么 `[0,1,2]` 和 `[3]` 会被落到不同的桶中,那么为了解决这种错误,我们需要对 `t` 进行 `+1` 作为 `size` 。
这样我们的数轴就能被分割成:
`0 1 2 3 | 4 5 6 7 | 8 9 10 11 | 12 13 14 15 | ...`
**总结一下,令 `size = t + 1` 的本质是因为差值为 `t` 两个数在数轴上相隔距离为 `t + 1`,它们需要被落到同一个桶中。**
**当明确了 `size` 的大小之后,对于正数部分我们则有 `idx = nums[i] / size`。**
2. 如何理解负数部分的逻辑?
由于我们处理正数的时候,处理了数值 `0`,因此我们负数部分是从 `-1` 开始的。
还是我们上述 🌰,此时我们有 `t = 3` 和 `size = t + 1 = 4`。
考虑 `[-4,-3,-2,-1]` 的情况,它们应该落在一个桶中。
如果直接复用 `idx = nums[i] / size` 的话,`[-4]` 和 `[-3,-2,-1]` 会被分到不同的桶中。
**根本原因是我们处理整数的时候,已经分掉了数值 `0`。**
**这时候我们需要先对 `nums[i]` 进行 `+1` 操作(即将负数部分在数轴上进行整体右移),即得到 `(nums[i] + 1) / size`。**
**这样一来负数部分与正数部分一样,可以被正常分割了。**
**但由于 0 号桶已经被使用了,我们还需要在此基础上进行 `-1`,相当于将负数部分的桶下标(`idx`)往左移,即得到 `((nums[i] + 1) / size) - 1`。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.220` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2121-2130/2127. 参加会议的最多员工数（困难）.md | 2127. 参加会议的最多员工数 | https://leetcode.cn/problems/maximum-employees-to-be-invited-to-a-meeting/solutions/2507559/gong-shui-san-xie-sha-shi-nei-xiang-wai-4ig79/ | 困难 | [
"基环森林",
"内向基环树",
"拓扑排序",
"图"
] | 一个公司准备组织一场会议,邀请名单上有 `n` 位员工。
公司准备了一张圆形的桌子,可以坐下任意数目的员工。
员工编号为 $0$ 到 $n - 1$。每位员工都有一位喜欢的员工,每位员工当且仅当他被安排在喜欢员工的旁边,他才会参加会议,每位员工喜欢的员工不会是他自己。
给你一个下标从 $0$ 开始的整数数组 `favorite`,其中 $favorite[i]$ 表示第 $i$ 位员工喜欢的员工。请你返回参加会议的最多员工数目。
示例 1:
```
输入:favorite = [2,2,1,2]
输出:3
解释:
上图展示了公司邀请员工 0,1 和 2 参加会议以及他们在圆桌上的座位。
没办法邀请所有员工参与会议,因为员工 2 没办法同时坐在 0,1 和 3 员工的旁边。
注意,公司也可以邀请员工 1,2 和 3 参加会议。
所以最多参加会议的员工数目为 3 。
```
示例 2:
```
输入:favorite = [1,2,0]
输出:3
解释:
每个员工都至少是另一个员工喜欢的员工。所以公司邀请他们所有人参加会议的前提是所有人都参加了会议。
座位安排同图 1 所示:
- 员工 0 坐在员工 2 和 1 之间。
- 员工 1 坐在员工 0 和 2 之间。
- 员工 2 坐在员工 1 和 0 之间。
参与会议的最多员工数目为 3 。
```
示例 3:
```
输入:favorite = [3,0,1,4,1]
输出:4
解释:
上图展示了公司可以邀请员工 0,1,3 和 4 参加会议以及他们在圆桌上的座位。
员工 2 无法参加,因为他喜欢的员工 0 旁边的座位已经被占领了。
所以公司只能不邀请员工 2 。
参加会议的最多员工数目为 4 。
```
提示:
* $n = favorite.length$
* $2 <= n <= 10^5$
* $0 <= favorite[i] <= n - 1$
* $favorite[i] != i$ | ### 内向基环森林 + 拓扑排序
根据题意,圆形桌上 $x$ 左右两边只要有一位是 $x$ 所喜欢即可。
我们可从 $i$ 向 $favorite[i]$ 添加有向边,从而得到一张包含多个「内向基环树」的图。
内向基环树,是指其满足基环树定义,且内向 ~~bushi~~。
基环树是指其具有 $n$ 个点 $n$ 条边的联通块,而「内向」是指树中任意节点有且只有一条出边,对应的「外向」是指树中任意节点有且只有一条入边。
例如,左图内向,右图外向:
根据题意,**圆桌最多放置一个长度大于 $2$ 的环(内向环,只有一条出边,即只有一个喜欢的人,安插其他非环成员,会破坏留下参加会议的必要条件),但可放置多个长度为 $2$ 的环,且多个环可延伸出最长链(利用左右两侧只需有一个喜欢的人即满足)。**
在「取长度大于 $2$ 的最大环」及「多个长度为 $2$ 的环及其最长链之和」两者中取最大长度即是答案。
Java 代码:
```Java
class Solution {
public int maximumInvitations(int[] favorite) {
int n = favorite.length;
// in 统计每个节点的入度情况, max 统计节最长链
int[] in = new int[n], max = new int[n];
for (int x : favorite) in[x]++;
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (in[i] == 0) d.addLast(i);
}
// 拓扑排序: 求基环外的最长链
while (!d.isEmpty()) {
int cur = d.pollFirst(), ne = favorite[cur];
max[ne] = Math.max(max[ne], max[cur] + 1);
if (--in[ne] == 0) d.addLast(ne);
}
// 圆桌最多放置一个大于 2 的环(ans1 统计最大值)
// 圆桌可放置多个等于 2 的环(ans2 累加该长度)
int ans1 = 0, ans2 = 0;
for (int i = 0; i < n; i++) {
if (in[i] == 0) continue;
int j = favorite[i], cur = 1;
while (j != i) {
// 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过
in[j] = 0;
j = favorite[j];
cur++;
}
if (cur == 2) ans2 += 2 + max[i] + max[favorite[i]];
else ans1 = Math.max(ans1, cur);
}
return Math.max(ans1, ans2);
}
}
```
Python 代码:
```Python
class Solution:
def maximumInvitations(self, favorite: List[int]) -> int:
n = len(favorite)
# in_degree 统计每个节点的入度情况, max_length 统计节最长链
in_degree, max_length = [0] * n, [0] * n
for x in favorite:
in_degree[x] += 1
d = deque()
for i in range(n):
if in_degree[i] == 0:
d.append(i)
# 拓扑排序: 求基环外的最长链
while d:
cur = d.popleft()
ne = favorite[cur]
max_length[ne] = max(max_length[ne], max_length[cur] + 1)
in_degree[ne] -= 1
if in_degree[ne] == 0:
d.append(ne)
# 圆桌最多放置一个大于 2 的环(ans1 统计最大值)
# 圆桌可放置多个等于 2 的环(ans2 累加该长度)
ans1, ans2 = 0, 0
for i in range(n):
if in_degree[i] == 0:
continue
j, cur = favorite[i], 1
while j != i:
# 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过
in_degree[j] = 0
j = favorite[j]
cur += 1
if cur == 2:
ans2 += 2 + max_length[i] + max_length[favorite[i]]
else:
ans1 = max(ans1, cur)
return max(ans1, ans2)
```
C++ 代码:
```C++
class Solution {
public:
int maximumInvitations(vector<int>& favorite) {
int n = favorite.size();
// in 统计每个节点的入度情况, max_length 统计节最长链
vector<int> in(n, 0);
vector<int> max_length(n, 0);
for (int x : favorite) in[x]++;
deque<int> d;
for (int i = 0; i < n; i++) {
if (in[i] == 0) d.push_back(i);
}
// 拓扑排序: 求基环外的最长链
while (!d.empty()) {
int cur = d.front();
d.pop_front();
int ne = favorite[cur];
max_length[ne] = max(max_length[ne], max_length[cur] + 1);
if (--in[ne] == 0) d.push_back(ne);
}
// 圆桌最多放置一个大于 2 的环(ans1 统计最大值)
// 圆桌可放置多个等于 2 的环(ans2 累加该长度)
int ans1 = 0, ans2 = 0;
for (int i = 0; i < n; i++) {
if (in[i] == 0) continue;
int j = favorite[i], cur = 1;
while (j != i) {
// 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过
in[j] = 0;
j = favorite[j];
cur++;
}
if (cur == 2) ans2 += 2 + max_length[i] + max_length[favorite[i]];
else ans1 = max(ans1, cur);
}
return max(ans1, ans2);
}
};
```
TypeScript 代码:
```TypeScript
function maximumInvitations(favorite: number[]): number {
const n = favorite.length;
// in_degree 统计每个节点的入度情况, max_length 统计节最长链
const in_degree = Array(n).fill(0), max_length = Array(n).fill(0);
for (const x of favorite) in_degree[x]++;
const d = [];
for (let i = 0; i < n; i++) {
if (in_degree[i] === 0) d.push(i);
}
// 拓扑排序: 求基环外的最长链
while (d.length > 0) {
const cur = d.shift() as number;
const ne = favorite[cur];
max_length[ne] = Math.max(max_length[ne], max_length[cur] + 1);
if (--in_degree[ne] === 0) d.push(ne);
}
// 圆桌最多放置一个大于 2 的环(ans1 统计最大值)
// 圆桌可放置多个等于 2 的环(ans2 累加该长度)
let ans1 = 0, ans2 = 0;
for (let i = 0; i < n; i++) {
if (in_degree[i] === 0) continue;
let j = favorite[i], cur = 1;
while (j !== i) {
// 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过
in_degree[j] = 0;
j = favorite[j];
cur++;
}
if (cur == 2) ans2 += 2 + max_length[i] + max_length[favorite[i]];
else ans1 = Math.max(ans1, cur);
}
return Math.max(ans1, ans2);
};
```
* 时间复杂度:统计入度的复杂度为 $O(n)$;拓扑排序求最长链复杂度为 $O(n)$;计算答案过程中,每个点最多被访问两次(环内节点),复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2217` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2161-2170/2170. 使数组变成交替数组的最少操作数（中等）.md | 2170. 使数组变成交替数组的最少操作数 | https://leetcode-cn.com/problems/minimum-operations-to-make-the-array-alternating/solution/gong-shui-san-xie-jian-dan-ji-shu-lei-ta-0eo4/ | 中等 | [
"贪心"
] | 给你一个下标从 $0$ 开始的数组 $nums$ ,该数组由 $n$ 个正整数组成。
如果满足下述条件,则数组 $nums$ 是一个 交替数组 :
* $nums[i - 2] == nums[i]$ ,其中 $2 <= i <= n - 1$ 。
* $nums[i - 1] != nums[i]$ ,其中 $1 <= i <= n - 1$ 。
在一步 操作 中,你可以选择下标 $i$ 并将 $nums[i]$ 更改 为 任一 正整数。
返回使数组变成交替数组的 最少操作数 。
示例 1:
```
输入:nums = [3,1,3,2,4,3]
输出:3
解释:
使数组变成交替数组的方法之一是将该数组转换为 [3,1,3,1,3,1] 。
在这种情况下,操作数为 3 。
可以证明,操作数少于 3 的情况下,无法使数组变成交替数组。
```
示例 2:
```
输入:nums = [1,2,2,2,2]
输出:2
解释:
使数组变成交替数组的方法之一是将该数组转换为 [1,2,1,2,1].
在这种情况下,操作数为 2 。
注意,数组不能转换成 [2,2,2,2,2] 。因为在这种情况下,nums[0] == nums[1],不满足交替数组的条件。
```
提示:
* $1 <= nums.length <= 10^5$
* $1 <= nums[i] <= 10^5$ | ### 贪心
根据「交替数组」的定义,我们可以将数组根据下标奇偶性分成两个序列,最终目的是:**使用最少的修改次数,使得「两个序列均成为公差为 $0$ 等差数列」,同时「两序列的首项不相等」。**
要用最少次数将一个序列修改为公差为 $0$ 等差数列,等价于修改最少的数字,等价于保留最多的数字,容易想到将序列中的其他「非众数」修改为「众数」(若有多个众数,取任一)。
而单纯对两个序列执行上述逻辑,并不能确保最终得到的是「交替数组」,即未必满足「两序列的首项不相等」的要求。
因此我们可以对 $nums$ 进行扫描,分别统计「偶数下标序列」和「奇数下标序列」的最大值(众数)和次大值(**注意是非严格的次大值,即为「其他众数」或者「出现次数比众数小的数」**),使用 `a` 和 `b` 代指「偶数下标序列」的最大值和次大值,使用 `c` 和 `d` 代指「奇数下标序列」的最大值和次大值。同时使用 `m1` 和 `m2` 分别统计「偶数下标序列」和「奇数下标序列」中某个数的出现次数。
根据两序列的最大值是否冲突进行分情况讨论:
* 若两序列的最大值不冲突($a\neq c$):那么两序列都可以取得最小修改次数(保留最大值),整体的最小修改次数为 $n - m1[a] - m2[c]$ ;
* 若两序列的最大值冲突($a\ = c$):那么仅一序列可以取得最小修改次数(保留最大值),另一序列只能取得“次小”的修改次数(保留次大值),此时整体的最小修改次数为 $n - \max(m1[a] + m2[d], m1[b] + m2[c])$。
代码:
```Java
class Solution {
static int N = 100010;
static int[] m1 = new int[N], m2 = new int[N];
public int minimumOperations(int[] nums) {
int n = nums.length;
Arrays.fill(m1, 0);
Arrays.fill(m2, 0);
int a = 0, b = 0, c = 0, d = 0;
for (int i = 0; i < n; i++) {
int t = nums[i];
if (i % 2 == 0) {
m1[t]++;
if (a == 0 || m1[t] > m1[a]) {
b = a; a = t;
} else if (t != a && (b == 0 || m1[t] > m1[b])) {
b = t;
}
} else {
m2[t]++;
if (c == 0 || m2[t] > m2[c]) {
d = c; c = t;
} else if (t != c && (d == 0 || m2[t] > m2[d])) {
d = t;
}
}
}
if (a != c) return n - m1[a] - m2[c];
else return n - Math.max(m1[a] + m2[d], m1[b] + m2[c]);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2170` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/223. 矩形面积（中等）.md | 223. 矩形面积 | https://leetcode-cn.com/problems/rectangle-area/solution/gong-shui-san-xie-yun-yong-rong-chi-yuan-hzit/ | 中等 | [
"容斥原理"
] | 给你 **二维** 平面上两个 **由直线构成的** 矩形,请你计算并返回两个矩形覆盖的总面积。
每个矩形由其 左下 顶点和 右上 顶点坐标表示:
* 第一个矩形由其左下顶点 (ax1, ay1) 和右上顶点 (ax2, ay2) 定义。
* 第二个矩形由其左下顶点 (bx1, by1) 和右上顶点 (bx2, by2) 定义。
示例 1:
```
输入:ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2
输出:45
```
示例 2:
```
输入:ax1 = -2, ay1 = -2, ax2 = 2, ay2 = 2, bx1 = -2, by1 = -2, bx2 = 2, by2 = 2
输出:16
```
提示:
* -$10^4 <= ax1, ay1, ax2, ay2, bx1, by1, bx2, by2 <= 10^4$ | ### 容斥原理
首先在给定左下顶点和右上顶点的情况下,计算矩形面积为 $(x2 - x1) * (y2 - y1)$。
因此,起始时我们可以先直接算得给定的两个矩形的面积 $A$ 和 $B$,并进行累加。
剩下的,我们需要求得两矩形的交集面积,利用「容斥原理」,减去交集面积,即是答案。
**求交集矩形面积,可以转换为求两矩形在坐标轴上的重合长度,若两矩形在 $X$ 轴上的重合长度为 $x$,在 $Y$ 轴上的重合长度为 $y$,则有重合面积为 $C = x * y$。同时考虑两矩形在任一坐标轴上没有重合长度,则不存在重合面积,因此需要将重合长度与 $0$ 取 $\max$。**
最终答案为 $A + B - C$ 。
代码;
```Java
class Solution {
public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
int x = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));
int y = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));
return (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1) - (x * y);
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.223` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/224. 基本计算器（困难）.md | 224. 基本计算器 | https://leetcode-cn.com/problems/basic-calculator/solution/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/ | 困难 | [
"表达式计算",
"栈"
] | 给你一个字符串表达式 `s` ,请你实现一个基本计算器来计算并返回它的值。
示例 1:
```
输入:s = "1 + 1"
输出:2
```
示例 2:
```
输入:s = " 2-1 + 2 "
输出:3
```
示例 3:
```
输入:s = "(1+(4+5+2)-3)+(6+8)"
输出:23
```
提示:
* $1 <= s.length <= 3 \times 10^5$
* `s` 由`数字`、`'+'`、`'-'`、`'('`、`')'`、和 `' '` 组成
* `s` 表示一个有效的表达式 | ### 双栈解法
我们可以使用两个栈 `nums` 和 `ops` 。
* `nums` : 存放所有的数字
* `ops` :存放所有的数字以外的操作,`+/-` 也看做是一种操作
然后从前往后做,对遍历到的字符做分情况讨论:
* 空格 : 跳过
* `(` : 直接加入 `ops` 中,等待与之匹配的 `)`
* `)` : 使用现有的 `nums` 和 `ops` 进行计算,直到遇到左边最近的一个左括号为止,计算结果放到 `nums`
* 数字 : 从当前位置开始继续往后取,将整一个连续数字整体取出,加入 `nums`
* `+/-` : 需要将操作放入 `ops` 中。**在放入之前先把栈内可以算的都算掉**,使用现有的 `nums` 和 `ops` 进行计算,直到没有操作或者遇到左括号,计算结果放到 `nums`
一些细节:
* 由于第一个数可能是负数,为了减少边界判断。一个小技巧是先往 `nums` 添加一个 0
* 为防止 () 内出现的首个字符为运算符,将所有的空格去掉,并将 `(-` 替换为 `(0-`,`(+` 替换为 `(0+`(当然也可以不进行这样的预处理,将这个处理逻辑放到循环里去做)
Java 代码:
```Java
class Solution {
public int calculate(String s) {
// 存放所有的数字
Deque<Integer> nums = new ArrayDeque<>();
// 为了防止第一个数为负数,先往 nums 加个 0
nums.addLast(0);
// 将所有的空格去掉
s = s.replaceAll(" ", "");
// 存放所有的操作,包括 +/-
Deque<Character> ops = new ArrayDeque<>();
int n = s.length();
char[] cs = s.toCharArray();
for (int i = 0; i < n; i++) {
char c = cs[i];
if (c == '(') {
ops.addLast(c);
} else if (c == ')') {
// 计算到最近一个左括号为止
while (!ops.isEmpty()) {
char op = ops.peekLast();
if (op != '(') {
calc(nums, ops);
} else {
ops.pollLast();
break;
}
}
} else {
if (isNum(c)) {
int u = 0, j = i;
// 将从 i 位置开始后面的连续数字整体取出,加入 nums
while (j < n && isNum(cs[j])) u = u * 10 + (int)(cs[j++] - '0');
nums.addLast(u);
i = j - 1;
} else {
if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
nums.addLast(0);
}
// 有一个新操作要入栈时,先把栈内可以算的都算了
while (!ops.isEmpty() && ops.peekLast() != '(') calc(nums, ops);
ops.addLast(c);
}
}
}
while (!ops.isEmpty()) calc(nums, ops);
return nums.peekLast();
}
void calc(Deque<Integer> nums, Deque<Character> ops) {
if (nums.isEmpty() || nums.size() < 2) return;
if (ops.isEmpty()) return;
int b = nums.pollLast(), a = nums.pollLast();
char op = ops.pollLast();
nums.addLast(op == '+' ? a + b : a - b);
}
boolean isNum(char c) {
return Character.isDigit(c);
}
}
```
C++ 代码:
```C++
class Solution {
public:
void replace(string& s){
int pos = s.find(" ");
while (pos != -1) {
s.replace(pos, 1, "");
pos = s.find(" ");
}
}
int calculate(string s) {
// 存放所有的数字
stack<int> nums;
// 为了防止第一个数为负数,先往 nums 加个 0
nums.push(0);
// 将所有的空格去掉
replace(s);
// 存放所有的操作,包括 +/-
stack<char> ops;
int n = s.size();
for(int i = 0; i < n; i++) {
char c = s[i];
if(c == '(')
ops.push(c);
else if(c == ')') {
// 计算到最近一个左括号为止
while(!ops.empty()) {
char op = ops.top();
if(op != '(')
calc(nums, ops);
else {
ops.pop();
break;
}
}
}
else {
if(isdigit(c)) {
int cur_num = 0, j = i;
// 将从 i 位置开始后面的连续数字整体取出,加入 nums
while(j <n && isdigit(s[j]))
cur_num = cur_num*10 + (s[j++] - '0');
// 注意上面的计算一定要有括号,否则有可能会溢出
nums.push(cur_num);
i = j - 1;
}
else {
if (i > 0 && (s[i - 1] == '(' || s[i - 1] == '+' || s[i - 1] == '-')) {
nums.push(0);
}
// 有一个新操作要入栈时,先把栈内可以算的都算了
while(!ops.empty() && ops.top() != '(')
calc(nums, ops);
ops.push(c);
}
}
}
while(!ops.empty())
calc(nums, ops);
return nums.top();
}
void calc(stack<int> &nums, stack<char> &ops) {
if(nums.size() < 2 || ops.empty())
return;
int b = nums.top(); nums.pop();
int a = nums.top(); nums.pop();
char op = ops.top(); ops.pop();
nums.push(op == '+' ? a+b : a-b);
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 进阶
1. 如果在此基础上,再考虑 `*` 和 `/`,需要增加什么考虑?如何维护运算符的优先级?
2. 在 $1$ 的基础上,如果考虑支持自定义符号,例如 `a / func(a, b) * (c + d)`,需要做出什么调整?
---
### 补充
1. 对应进阶 1 的补充。
一个支持 `+ - * / ^ %` 的「计算器」,基本逻辑是一样的,使用字典维护一个符号优先级:
```Java
class Solution {
Map<Character, Integer> map = new HashMap<>(){{
put('-', 1);
put('+', 1);
put('*', 2);
put('/', 2);
put('%', 2);
put('^', 3);
}};
public int calculate(String s) {
s = s.replaceAll(" ", "");
char[] cs = s.toCharArray();
int n = s.length();
Deque<Integer> nums = new ArrayDeque<>();
nums.addLast(0);
Deque<Character> ops = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
char c = cs[i];
if (c == '(') {
ops.addLast(c);
} else if (c == ')') {
while (!ops.isEmpty()) {
if (ops.peekLast() != '(') {
calc(nums, ops);
} else {
ops.pollLast();
break;
}
}
} else {
if (isNumber(c)) {
int u = 0;
int j = i;
while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');
nums.addLast(u);
i = j - 1;
} else {
if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
nums.addLast(0);
}
while (!ops.isEmpty() && ops.peekLast() != '(') {
char prev = ops.peekLast();
if (map.get(prev) >= map.get(c)) {
calc(nums, ops);
} else {
break;
}
}
ops.addLast(c);
}
}
}
while (!ops.isEmpty() && ops.peekLast() != '(') calc(nums, ops);
return nums.peekLast();
}
void calc(Deque<Integer> nums, Deque<Character> ops) {
if (nums.isEmpty() || nums.size() < 2) return;
if (ops.isEmpty()) return;
int b = nums.pollLast(), a = nums.pollLast();
char op = ops.pollLast();
int ans = 0;
if (op == '+') {
ans = a + b;
} else if (op == '-') {
ans = a - b;
} else if (op == '*') {
ans = a * b;
} else if (op == '/') {
ans = a / b;
} else if (op == '^') {
ans = (int)Math.pow(a, b);
} else if (op == '%') {
ans = a % b;
}
nums.addLast(ans);
}
boolean isNumber(char c) {
return Character.isDigit(c);
}
}
```
2. 关于进阶 $2$,其实和进阶 $1$ 一样,重点在于维护优先级。但还有一些编码细节:
对于非单个字符的运算符(例如 函数名`function`),可以在处理前先将所有非单字符的运算符进行替换(将 `function` 替换为 `@#` 等)
然后对特殊运算符做特判,确保遍历过程中识别到特殊运算符之后,往后整体读入(如 `function(a,b)` -> `@(a, b)`,`@(a, b)` 作为整体处理) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.224` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/227. 基本计算器 II（中等）.md | 227. 基本计算器 II | https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/ | 中等 | [
"表达式计算"
] | 给你一个字符串表达式 `s` ,请你实现一个基本计算器来计算并返回它的值。
整数除法仅保留整数部分。
示例 1:
```
输入:s = "3+2*2"
输出:7
```
示例 2:
```
输入:s = " 3/2 "
输出:1
```
示例 3:
```
输入:s = " 3+5 / 2 "
输出:5
```
提示:
* $1 <= s.length <= 3 \times 10^5$
* `s` 由整数和算符 (`'+'`, `'-'`, `'*'`, `'/'`) 组成,中间由一些空格隔开
* `s` 表示一个 有效表达式
* 表达式中的所有整数都是非负整数,且在范围 $[0, 2^{31} - 1]$ 内
* 题目数据保证答案是一个 `32-bit` 整数 | ### 双栈
如果你有看这篇 [224. 基本计算器](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 的话,今天这道题就是道练习题。
帮你巩固 **双栈解决「通用表达式」问题的通用解法** 。
**事实上,我提供这套解决方案不仅仅能解决只有 `+ - ( )`的 [[224. 基本计算器]](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 或者 `+ - * /` [227. 基本计算器 II(本题)] 的表达式问题,还能解决 `+ - * / ^ % ( )` 的完全表达式问题。**
甚至支持自定义运算符,只要在运算优先级上进行维护即可。
**对于「表达式计算」这一类问题,你都可以使用这套思路进行解决。我十分建议你加强理解这套处理逻辑。**
对于「任何表达式」而言,我们都使用两个栈 `nums` 和 `ops`:
* `nums` : 存放所有的数字
* `ops` :存放所有的数字以外的操作
然后从前往后做,对遍历到的字符做分情况讨论:
* 空格 : 跳过
* `(` : 直接加入 `ops` 中,等待与之匹配的 `)`
* `)` : 使用现有的 `nums` 和 `ops` 进行计算,直到遇到左边最近的一个左括号为止,计算结果放到 `nums`
* 数字 : 从当前位置开始继续往后取,将整一个连续数字整体取出,加入 `nums`
* `+ - * / ^ %` : 需要将操作放入 `ops` 中。**在放入之前先把栈内可以算的都算掉(只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算)**,使用现有的 `nums` 和 `ops` 进行计算,直到没有操作或者遇到左括号,计算结果放到 `nums`
我们可以通过 🌰 来理解 **只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算** 是什么意思:
因为我们是从前往后做的,假设我们当前已经扫描到 `2 + 1` 了(此时栈内的操作为 `+` )。
1. 如果后面出现的 `+ 2` 或者 `- 1` 的话,满足「栈内运算符」比「当前运算符」优先级高/同等,可以将 `2 + 1` 算掉,把结果放到 `nums` 中;
2. 如果后面出现的是 `* 2` 或者 `/ 1` 的话,不满足「栈内运算符」比「当前运算符」优先级高/同等,这时候不能计算 `2 + 1`。
一些细节:
* 由于第一个数可能是负数,为了减少边界判断。一个小技巧是先往 `nums` 添加一个 0
* 为防止 () 内出现的首个字符为运算符,将所有的空格去掉,并将 `(-` 替换为 `(0-`,`(+` 替换为 `(0+`(当然也可以不进行这样的预处理,将这个处理逻辑放到循环里去做)
* 从理论上分析,`nums` 最好存放的是 `long`,而不是 `int`。因为可能存在 `大数 + 大数 + 大数 + ... - 大数 - 大数` 的表达式导致中间结果溢出,最终答案不溢出的情况
代码:
```Java
class Solution {
// 使用 map 维护一个运算符优先级
// 这里的优先级划分按照「数学」进行划分即可
Map<Character, Integer> map = new HashMap<>(){{
put('-', 1);
put('+', 1);
put('*', 2);
put('/', 2);
put('%', 2);
put('^', 3);
}};
public int calculate(String s) {
// 将所有的空格去掉
s = s.replaceAll(" ", "");
char[] cs = s.toCharArray();
int n = s.length();
// 存放所有的数字
Deque<Integer> nums = new ArrayDeque<>();
// 为了防止第一个数为负数,先往 nums 加个 0
nums.addLast(0);
// 存放所有「非数字以外」的操作
Deque<Character> ops = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
char c = cs[i];
if (c == '(') {
ops.addLast(c);
} else if (c == ')') {
// 计算到最近一个左括号为止
while (!ops.isEmpty()) {
if (ops.peekLast() != '(') {
calc(nums, ops);
} else {
ops.pollLast();
break;
}
}
} else {
if (isNumber(c)) {
int u = 0;
int j = i;
// 将从 i 位置开始后面的连续数字整体取出,加入 nums
while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');
nums.addLast(u);
i = j - 1;
} else {
if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
nums.addLast(0);
}
// 有一个新操作要入栈时,先把栈内可以算的都算了
// 只有满足「栈内运算符」比「当前运算符」优先级高/同等,才进行运算
while (!ops.isEmpty() && ops.peekLast() != '(') {
char prev = ops.peekLast();
if (map.get(prev) >= map.get(c)) {
calc(nums, ops);
} else {
break;
}
}
ops.addLast(c);
}
}
}
// 将剩余的计算完
while (!ops.isEmpty()) calc(nums, ops);
return nums.peekLast();
}
void calc(Deque<Integer> nums, Deque<Character> ops) {
if (nums.isEmpty() || nums.size() < 2) return;
if (ops.isEmpty()) return;
int b = nums.pollLast(), a = nums.pollLast();
char op = ops.pollLast();
int ans = 0;
if (op == '+') ans = a + b;
else if (op == '-') ans = a - b;
else if (op == '*') ans = a * b;
else if (op == '/') ans = a / b;
else if (op == '^') ans = (int)Math.pow(a, b);
else if (op == '%') ans = a % b;
nums.addLast(ans);
}
boolean isNumber(char c) {
return Character.isDigit(c);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 总结
还记得我在 [题解](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 留的「进阶」内容?
1. 如果 `+ -` 基础上,再考虑 `*` 和 `/`,需要增加什么考虑?如何维护运算符的优先级?
这个进阶问题就对应了 LeetCode 上的两道题:
* [227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/) :本题,包含符号 `+ - * /`
* [772. 基本计算器 III](https://leetcode-cn.com/problems/basic-calculator-iii/) :有锁题,包含符号 `+ - * / ( )`
2. 在「问题1」的基础上,如果考虑支持自定义符号,例如 a / func(a, b) * (c + d),需要做出什么调整?
这个进阶问题,在 LeetCode 上也有类似的题目:
* [770. 基本计算器 IV](https://leetcode-cn.com/problems/basic-calculator-iv/) : 包含自定义函数符号
**综上,使用三叶提供的这套「双栈通用解决方案」,可以解决所有的「表达式计算」问题。因为这套「表达式计算」处理逻辑,本质上模拟了人脑的处理逻辑:根据下一位的运算符优先级决定当前运算符是否可以马上计算。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.227` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/229. 求众数 II（中等）.md | 229. 求众数 II | https://leetcode-cn.com/problems/majority-element-ii/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ws0rj/ | 中等 | [
"摩尔投票",
"哈希表"
] | 给定一个大小为 `n` 的整数数组,找出其中所有出现超过 `⌊ n/3 ⌋` 次的元素。
示例 1:
```
输入:[3,2,3]
输出:[3]
```
示例 2:
```
输入:nums = [1]
输出:[1]
```
示例 3:
```
输入:[1,1,1,3,3,2,2,2]
输出:[1,2]
```
提示:
* $1 <= nums.length <= 5 * 10^4$
* $-10^9 <= nums[i] <= 10^9$
进阶:尝试设计时间复杂度为 $O(n)$、空间复杂度为 $O(1)$ 的算法解决此问题。 | ### 哈希表计数
一个朴素的做法是使用「哈希表」进行计数,在计数完成后将所有出现次数超过 $n / 3$ 的元素加入答案。
代码:
```Java
class Solution {
public List<Integer> majorityElement(int[] nums) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
List<Integer> ans = new ArrayList<>();
for (int i : map.keySet()) {
if (map.get(i) > n / 3) ans.add(i);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 摩尔投票
在前置 🧀 [简单题学投票算法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488987&idx=1&sn=6087b1909fea1d24f15353515eee8d93&chksm=fd9cbec4caeb37d235ccad8d59724177784036a60525fa5e7b738267e9a84a572b1545528391&token=1288276346&lang=zh_CN#rd) 中,我们使用「摩尔投票」在 $O(1)$ 空间复杂度内找到了出现次数超过一半的元素,即出现次数大于 $n / 2$ 的数。
对于本题,我们需要统计出现次数超过 $n / 3$ 的数。
**我们可以不失一般性的将其拓展为「统计出现次数超过 $n / k$ 的数」。**
**可以证明,出现次数超过 $n / k$ 的数最多只有 $k - 1$ 个。否则必然违背「数总共只有 $n$ 个」或者「当前统计的是出现次数超过 $n / k$ 的数」的前提条件。**
当明确了符合要求的数的数量之后,我们可以使用有限变量来代表这 $k - 1$ 个候选数及其出现次数。
然后使用「摩尔投票」的标准做法,在建立数组时同时 `check` 这 $k - 1$ 个数,假设当前遍历到的元素为 $x$:
* 如果 $x$ 本身是候选者的话,则对其出现次数加一;
* 如果 $x$ 本身不是候选者,检查是否有候选者的出现次数为 $0$:
* 若有,则让 $x$ 代替其成为候选者,并记录出现次数为 $1$;
* 若无,则让所有候选者的出现次数减一。
当处理完整个数组后,这 $k - 1$ 个数可能会被填满,但不一定都是符合出现次数超过 $n / k$ 要求的。
需要进行二次遍历,来确定候选者是否符合要求,将符合要求的数加到答案。
**上述做法正确性的关键是:若存在出现次数超过 $n / k$ 的数,最后必然会成为这 $k - 1$ 个候选者之一。**
我们可以通过「反证法」来进行证明:若出现次数超过 $n / k$ 的数 $x$ 最终没有成为候选者。
有两种可能会导致这个结果:
1. 数值 $x$ 从来没成为过候选者:
如果 $x$ 从来没成为过候选者,那么在遍历 $x$ 的过程中,必然有 $k - 1$ 个候选者被减了超过 $n / k$ 次,假设当前 $x$ 出现次数为 $C$,已知 $C > n / k$,此时总个数为
$$
(k - 1) * C + C = C * k
$$
再根据 $C > n / k$,可知 $C * k > n$,而我们总共就只有 $n$ 个数,因此该情况恒不成立。
2. 数值 $x$ 成为过候选者,但被逐出替换了:
同理,被逐出替换,说明发生了对 $x$ 出现次数减一的动作(减到 $0$),每次的减一操作,意味着有其余的 $k - 2$ 个候选者的出现次数也发生了减一动作,加上本身被遍历到的当前数 $num[i]$,共有 $k - 1$ 个数字的和 $x$ 被一同统计。
因此,根据我们摩尔投票的处理过程,如果 $x$ 成为过候选者,并被逐出替换,那么同样能够推导出我们存在超过 $n$ 个数。
综上,如果存在出现次数超过 $n / k$ 的数,其必然会成为 $k - 1$ 个候选者之一。
代码:
```Java
class Solution {
public List<Integer> majorityElement(int[] nums) {
int n = nums.length;
int a = 0, b = 0;
int c1 = 0, c2 = 0;
for (int i : nums) {
if (c1 != 0 && a == i) c1++;
else if (c2 != 0 && b == i) c2++;
else if (c1 == 0 && ++c1 >= 0) a = i;
else if (c2 == 0 && ++c2 >= 0) b = i;
else {
c1--; c2--;
}
}
c1 = 0; c2 = 0;
for (int i : nums) {
if (a == i) c1++;
else if (b == i) c2++;
}
List<Integer> ans = new ArrayList<>();
if (c1 > n / 3) ans.add(a);
if (c2 > n / 3) ans.add(b);
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.229` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/221-230/230. 二叉搜索树中第K小的元素（中等）.md | 230. 二叉搜索树中第K小的元素 | https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/solution/gong-shui-san-xie-yi-ti-san-jie-pai-xu-y-8uah/ | 中等 | [
"二叉树",
"中序遍历",
"树的搜索"
] | 给定一个二叉搜索树的根节点 `root`,和一个整数 `k` ,请你设计一个算法查找其中第 `k` 个最小元素(从 $1$ 开始计数)。
示例 1:
```
输入:root = [3,1,4,null,2], k = 1
输出:1
```
示例 2:
```
输入:root = [5,3,6,2,4,null,null,1], k = 3
输出:3
```
提示:
* 树中的节点数为 n 。
* $1 <= k <= n <= 10^4$
* $0 <= Node.val <= 10^4$ | ### 树的遍历 + 排序
朴素的做法是先对二叉树进行一次完整遍历,将所有节点存入列表中,最后对列表排序后返回目标值。
树的遍历可以使用 `DFS` 或 `BFS`。
代码:
```Java
class Solution {
List<Integer> list = new ArrayList<>();
public int kthSmallest(TreeNode root, int k) {
dfs(root);
Collections.sort(list);
return list.get(k - 1);
}
void dfs(TreeNode root) {
if (root == null) return ;
list.add(root.val);
dfs(root.left);
dfs(root.right);
}
}
```
* 时间复杂度:树的遍历时间复杂度为 $O(n)$;排序的复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 树的遍历 + 优先队列(堆)
相比于先直接拿到所有节点再排序的解法一,另外一种做法是使用「优先队列(堆)」来做。
由于我们返回的是第 $k$ 小的数,因此我们可以构建一个容量为 $k$ 的大根堆。
根据大根堆的元素个数和当前节点与堆顶元素的关系来分情况讨论:
* 大根堆元素不足 $k$ 个:直接将当前节点值放入大根堆;
* 大根堆元素为 $k$ 个,根据堆顶元素和当前节点值的大小关系进一步分情况讨论:
* 如果当前节点值元素大于堆顶元素,说明当前节点值不可能在第 $k$ 小的范围内,直接丢弃;
* 如果当前节点值元素小于堆顶元素,说明当前节点值可能在第 $k$ 小的范围内,先 `poll` 一个再 `add` 进去。
树的遍历可以使用 `DFS` 或 `BFS`。
代码:
```Java
class Solution {
public int kthSmallest(TreeNode root, int k) {
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode node = d.pollFirst();
if (q.size() < k) {
q.add(node.val);
} else if (q.peek() > node.val) {
q.poll();
q.add(node.val);
}
if (node.left != null) d.addLast(node.left);
if (node.right != null) d.addLast(node.right);
}
return q.peek();
}
}
```
* 时间复杂度:树的遍历时间复杂度为 $O(n)$;使用优先队列(堆)复杂度为 $O(n\log{k})$。整体复杂度为 $O(n\log{k})$
* 空间复杂度:空间多少取决于 `d` 和 `q` 使用的容量,`q` 最多不超过 $k$ 个元素,复杂度为 $O(k)$,`d` 最多不超过二叉树的一层,复杂度为 $O(n)$。整体复杂度为 $O(n + k)$
---
### 中序遍历
上述两种节点,都没有利用该树为二叉搜索树的特性。
而我们知道,二叉搜索树的中序遍历是有序的,因此我们只需要对二叉搜索树执行中序遍历,并返回第 $k$ 小的值即可。
不熟悉二叉树的中序遍历的同学,可以看看 [(题解)783. 二叉搜索树节点最小距离](https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/solution/gong-shui-san-xie-yi-ti-san-jie-shu-de-s-7r17/)。
中序遍历有「迭代」和「递归」两种写法。
代码:
```Java
class Solution {
public int kthSmallest(TreeNode root, int k) {
Deque<TreeNode> d = new ArrayDeque<>();
while (root != null || !d.isEmpty()) {
while (root != null) {
d.addLast(root);
root = root.left;
}
root = d.pollLast();
if (--k == 0) return root.val;
root = root.right;
}
return -1; // never
}
}
```
```Java
class Solution {
int k, ans;
public int kthSmallest(TreeNode root, int _k) {
k = _k;
dfs(root);
return ans;
}
void dfs(TreeNode root) {
if (root == null || k <= 0) return ;
dfs(root.left);
if (--k == 0) ans = root.val;
dfs(root.right);
}
}
```
* 时间复杂度:由于存在对 $k$ 大小的剪枝,因此整个遍历顺序是从小到大进行遍历,搜索到目标值即结束。复杂度为 $O(k)$
* 空间复杂度:令 $h$ 为树高,复杂度为 $O(h)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.230` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2211-2220/2213. 由单个字符重复的最长子字符串（困难）.md | 2213. 由单个字符重复的最长子字符串 | https://leetcode-cn.com/problems/longest-substring-of-one-repeating-character/solution/by-ac_oier-0lso/ | 困难 | [
"区间求和",
"线段树"
] | 给你一个下标从 $0$ 开始的字符串 `s` 。另给你一个下标从 $0$ 开始、长度为 $k$ 的字符串 `queryCharacters`,一个下标从 $0$ 开始、长度也是 $k$ 的整数 下标 数组 `queryIndices`,这两个都用来描述 $k$ 个查询。
第 $i$ 个查询会将 `s` 中位于下标 $queryIndices[i]$ 的字符更新为 $queryCharacters[i]$。
返回一个长度为 $k$ 的数组 `lengths`,其中 $lengths[i]$ 是在执行第 $i$ 个查询之后 `s` 中仅由单个字符重复组成的 最长子字符串的长度 。
示例 1:
```
输入:s = "babacc", queryCharacters = "bcb", queryIndices = [1,3,3]
输出:[3,3,4]
解释:
- 第 1 次查询更新后 s = "bbbacc" 。由单个字符重复组成的最长子字符串是 "bbb" ,长度为 3 。
- 第 2 次查询更新后 s = "bbbccc" 。由单个字符重复组成的最长子字符串是 "bbb" 或 "ccc",长度为 3 。
- 第 3 次查询更新后 s = "bbbbcc" 。由单个字符重复组成的最长子字符串是 "bbbb" ,长度为 4 。
因此,返回 [3,3,4] 。
```
示例 2:
```
输入:s = "abyzz", queryCharacters = "aa", queryIndices = [2,1]
输出:[2,3]
解释:
- 第 1 次查询更新后 s = "abazz" 。由单个字符重复组成的最长子字符串是 "zz" ,长度为 2 。
- 第 2 次查询更新后 s = "aaazz" 。由单个字符重复组成的最长子字符串是 "aaa" ,长度为 3 。
因此,返回 [2,3] 。
```
提示:
* $1 <= s.length <= 10^5$
* `s` 由小写英文字母组成
* $k == queryCharacters.length == queryIndices.length$
* $1 <= k <= 10^5$
* `queryCharacters` 由小写英文字母组成
* $0 <= queryIndices[i] < s.length$ | ### 线段树
这是一道经典的线段树应用题。
根据题意,涉及的操作 “似乎” 是「单点修改」和「区间查询」,那么根据 [(题解) 307. 区域和检索 - 数组可修改](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 的总结,我们应该使用的是「树状数组」吗?
其实并不是(或者说不能直接是),原因在于我们查询的是「修改过后 `s` 中相同字符连续段的最大长度」,而当我们进行所谓的「单点修改」时,会导致原本的连续段被破坏,或者形成新的连续段。也就是此处的修改对于结果而言,并不是单点的。
使用线段树求解,我们唯一需要考虑的是:在 `Node` 中维护些什么信息?
对于线段树的节点信息设计,通常会包含基本的左右端点 `l`、`r` 以及查询目标值 `val` ,然后再考虑维护 `val` 还需要一些什么辅助信息。
对于本题,我们还需要额外维护 `prefix` 和 `suffix`,分别代表「当前区间 $[l, r]$ 内前缀相同字符连续段的最大长度」和「当前区间 $[l, r]$ 内后缀相同字符连续段的最大长度」。
然后考虑每次修改,如何使用子节点信息更新父节点(`pushup` 操作):
* 对于一般性的合并(当前节点的两个子节点的衔接点不是相同字符)而言:
* `tr[u].prefix = tr[u << 1].prefix`:当前父节点(区间)的前缀最大长度等于左子节点(区间)的前缀最大长度;
* `tr[u].suffix = tr[u << 1 | 1].suffix`:当前父节点(区间)的后缀最大长度等于右子节点(区间)的后缀最大长度;
* `tr[u].val = max(left.val, right.val)`:当前父节点(区间)的最大长度为两子节点(区间)的最大长度。
* 对于非一般性的合并(当前节点的两个子节点的衔接点为相同字符):
* `tr[u].val = max(tr[u].val, left.suffix + right.prefix)`:首先可以确定的是「左区间的后缀」和「右区间的前缀」可以拼接在一起,因此可以使用拼接长度来尝试更新当前节点的最大值;
* `tr[u].suffix = bLen + left.suffix`:其中 `bLen` 为右节点(区间)的长度。当且仅当右节点(区间)整一段都是相同字符时(即满足 `right.prefix = right.suffix = bLen`),可以使用 `bLen + left.suffix` 来更新 `tr[u].suffix`;
* `tr[u].prefix = aLen + right.prefix`:其中 `aLen` 为左节点(区间)的长度。当且仅当左节点(区间)整一段都是相同字符时(即满足 `left.prefix = left.prefix = aLen`),可以使用 `aLen + right.prefix` 来更新 `tr[u].prefix `。
代码:
```Java
class Solution {
class Node {
int l, r, prefix, suffix, val;
Node(int _l, int _r) {
l = _l; r = _r;
prefix = suffix = val = 1;
}
}
char[] cs;
Node[] tr;
void build(int u, int l, int r) {
tr[u] = new Node(l, r);
if (l == r) return ;
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
}
void update(int u, int x, char c) {
if (tr[u].l == x && tr[u].r == x) {
cs[x - 1] = c;
return ;
}
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) update(u << 1, x, c);
else update(u << 1 | 1, x, c);
pushup(u);
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;
int ans = 0;
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) ans = query(u << 1, l, r);
if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));
return ans;
}
void pushup(int u) {
Node left = tr[u << 1], right = tr[u << 1 | 1];
int aLen = left.r - left.l + 1, bLen = right.r - right.l + 1;
char ac = cs[left.r - 1], bc = cs[right.l - 1];
tr[u].prefix = left.prefix; tr[u].suffix = right.suffix;
tr[u].val = Math.max(left.val, right.val);
if (ac == bc) {
if (left.prefix == aLen) tr[u].prefix = aLen + right.prefix;
if (right.prefix == bLen) tr[u].suffix = bLen + left.suffix;
tr[u].val = Math.max(tr[u].val, left.suffix + right.prefix);
}
}
public int[] longestRepeating(String s, String queryCharacters, int[] queryIndices) {
cs = s.toCharArray();
int n = cs.length, m = queryCharacters.length();
tr = new Node[n * 4];
build(1, 1, n);
for (int i = 0; i < n; i++) update(1, i + 1, cs[i]);
int[] ans = new int[m];
for (int i = 0; i < m; i++) {
update(1, queryIndices[i] + 1, queryCharacters.charAt(i));
ans[i] = query(1, 1, n);
}
return ans;
}
}
```
* 时间复杂度:$O(m\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2213` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2211-2220/2216. 美化数组的最少删除数（中等）.md | 2216. 美化数组的最少删除数 | https://leetcode.cn/problems/minimum-deletions-to-make-array-beautiful/solutions/2535327/gong-shui-san-xie-zhi-ji-ben-zhi-de-ji-j-dk05/ | 中等 | [
"模拟"
] | 给你一个下标从 `0` 开始的整数数组 `nums`,如果满足下述条件,则认为数组 `nums` 是一个 美丽数组 :
* `nums.length` 为偶数
* 对所有满足 `i % 2 == 0` 的下标 `i`,`nums[i] != nums[i + 1]` 均成立
注意,空数组同样认为是美丽数组。
你可以从 `nums` 中删除任意数量的元素。当你删除一个元素时,被删除元素右侧的所有元素将会向左移动一个单位以填补空缺,而左侧的元素将会保持 不变 。
返回使 `nums` 变为美丽数组所需删除的最少元素数目。
示例 1:
```
输入:nums = [1,1,2,3,5]
输出:1
解释:可以删除 nums[0] 或 nums[1] ,这样得到的 nums = [1,2,3,5] 是一个美丽数组。可以证明,要想使 nums 变为美丽数组,至少需要删除 1 个元素。
```
示例 2:
```
输入:nums = [1,1,2,2,3,3]
输出:2
解释:可以删除 nums[0] 和 nums[5] ,这样得到的 nums = [1,2,2,3] 是一个美丽数组。可以证明,要想使 nums 变为美丽数组,至少需要删除 2 个元素。
```
提示:
* $1 <= nums.length <= 10^5$
* $0 <= nums[i] <= 10^5$ | ### 模拟
使用变量 `cnt` 代表已删除的元素个数,由于每次删除元素,剩余元素都会往前移动,因此遍历过程中,当前下标为 $i - cnt$。
若当前下标为偶数,且与下一位置元素相同,那么当前元素需被删除,令 `cnt` 自增。
最终数组长度为 $n - cnt$,若长度为奇数,需要再额外删除结尾元素(`cnt` 再加一),否则 `cnt` 即为答案。
Java 代码:
```Java
class Solution {
public int minDeletion(int[] nums) {
int n = nums.length, cnt = 0;
for (int i = 0; i < n; i++) {
if ((i - cnt) % 2 == 0 && i + 1 < n && nums[i] == nums[i + 1]) cnt++;
}
return (n - cnt) % 2 != 0 ? cnt + 1 : cnt;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minDeletion(vector<int>& nums) {
int n = nums.size(), cnt = 0;
for (int i = 0; i < n; i++) {
if ((i - cnt) % 2 == 0 && i + 1 < n && nums[i] == nums[i + 1]) cnt++;
}
return (n - cnt) % 2 != 0 ? cnt + 1 : cnt;
}
};
```
Python 代码:
```Python
class Solution:
def minDeletion(self, nums: List[int]) -> int:
n, cnt = len(nums), 0
for i in range(n):
if (i - cnt) % 2 == 0 and i + 1 < n and nums[i] == nums[i + 1]:
cnt += 1
return cnt + 1 if (n - cnt) % 2 != 0 else cnt
```
TypeScript 代码:
```TypeScript
function minDeletion(nums: number[]): number {
let n = nums.length, cnt = 0;
for (let i = 0; i < n; i++) {
if ((i - cnt) % 2 == 0 && i + 1 < n && nums[i] == nums[i + 1]) cnt++;
}
return (n - cnt) % 2 != 0 ? cnt + 1 : cnt;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2216` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2241-2250/2246. 相邻字符不同的最长路径（困难）.md | 2246. 相邻字符不同的最长路径 | https://leetcode.cn/problems/longest-path-with-different-adjacent-characters/solutions/2453857/gong-shui-san-xie-shu-xing-dp-ding-gen-d-eh5i/ | 困难 | [
"树",
"DFS",
"树形 DP",
"动态规划"
] | 给你一棵 树(即一个连通、无向、无环图),根节点是节点 `0`,这棵树由编号从 `0` 到 `n - 1` 的 `n` 个节点组成。
用下标从 `0` 开始、长度为 `n` 的数组 `parent` 来表示这棵树,其中 `parent[i]` 是节点 `i` 的父节点,由于节点 `0` 是根节点,所以 `parent[0] = -1`。
另给你一个字符串 `s`,长度也是 `n`,其中 `s[i]` 表示分配给节点 `i` 的字符。
请你找出路径上任意一对相邻节点都没有分配到相同字符的 最长路径 ,并返回该路径的长度。
示例 1:
```
输入:parent = [-1,0,0,1,1,2], s = "abacbe"
输出:3
解释:任意一对相邻节点字符都不同的最长路径是:0 -> 1 -> 3 。该路径的长度是 3 ,所以返回 3 。
可以证明不存在满足上述条件且比 3 更长的路径。
```
示例 2:
```
输入:parent = [-1,0,0,0], s = "aabc"
输出:3
解释:任意一对相邻节点字符都不同的最长路径是:2 -> 0 -> 3 。该路径的长度为 3 ,所以返回 3 。
```
提示:
* $n = parent.length = s.length$
* $1 <= n <= 10^5$
* 对所有 `i >= 1`,`0 <= parent[i] <= n - 1` 均成立
* $parent[0] = -1$
* `parent` 表示一棵有效的树
* `s` 仅由小写英文字母组成 | ### DFS
起始先用 `parent` 进行建图,随后设计 `DFS` 函数来求解每个节点“往下”的最长路径:将当前节点 `cur` 作为传入参数,返回以节点“往下”的最长路径。
这是一个由子节点最长路径推导父节点最长路径的「自下而上」的推导过程。
> 先来关注该 `DFS` 的功能本身:
假设当前处理到的节点为 `u`,将要访问到的节点为 `j`。递归调用 `DFS` 函数拿到以节点 `j` 为根节点时的“往下”最大路径 `t`,并执行如下处理流程:
* 若节点 `j` 和节点 `u` 对应字符相同,说明将节点 `j` 拼接在节点 `u` 后面并非合法路径,跳过处理
* 否则使用 `t` 来更新以当前节点 `u` 为根时,最大的“往下”子路径 `res`(该值初始值为 `0`)
当处理完节点 `u` 的所有子节点,我们 `res + 1` 即是函数返回值(含义为在合法的最长路径本身拼接节点 `u`)。
> 再来关注 `DFS` 过程中,如何计算问题答案:
在 `DFS` 函数中,我们递归处理了所有节点,而**在真实最长路径在原树中的最高点**,自然也是被处理到的。
这引导我们可以在单次递归,处理当前节点时,使用变量 `l1` 和 `l2` 分别记录当前节点的「最大子路径」和「次大子路径」。
在处理完当前节点后,`1 + l1 + l2` 即是以当前节点作为路径最高点时的最大路径长度(含义为在合法「最大子路径」和「次大子路径」基础上拼接当前节点),用其更新全局变量 `ans`。
代码:
```Java
class Solution {
int N = 100010, M = N, idx = 0, ans = 1;
int[] he = new int[N], e = new int[M], ne = new int[M];
char[] cs;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int longestPath(int[] parent, String s) {
Arrays.fill(he, -1);
for (int i = 1; i < parent.length; i++) add(parent[i], i);
cs = s.toCharArray();
dfs(0);
return ans;
}
int dfs(int u) {
int res = 0;
int l1 = 0, l2 = 0;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
int t = dfs(j);
if (cs[u] == cs[j]) continue;
if (t > l1) {
l2 = l1; l1 = t;
} else if (t > l2) {
l2 = t;
}
res = Math.max(res, t);
ans = Math.max(ans, 1 + l1 + l2);
}
return res + 1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 树形 DP
自然也是能够使用「树形 DP」思路来做。
只不过对于「定根树形 DP」来说,往往一遍 `DFS` 就能实现 $O(n)$ 做法。例如 [124. 二叉树中的最大路径和](https://leetcode.cn/problems/binary-tree-maximum-path-sum/solutions/2451624/gong-shui-san-xie-jian-dan-di-gui-shu-xi-nlci/)。
而「换根树形 DP」则只能通过对“方向”的拆分,用两遍 `DFS` 来进行求解。例如 [310. 最小高度树](https://leetcode.cn/problems/minimum-height-trees/solutions/1397905/by-ac_oier-7xio/) 和 [834. 树中距离之和](https://leetcode.cn/problems/sum-of-distances-in-tree/solutions/2449965/gong-shui-san-xie-shu-xing-dp-chang-gui-1v7ud/)。
在「定根树形 DP」题目中采用「换根树形 DP」做法,无论是从执行流程还是编码来说,都稍显“多余”(毕竟一次 `DFS` 就能以「最佳路径的最高点必然能够被处理」来得证答案的正确性),但在验证大家是否真正掌握「树形 DP」精髓来说,却有极大意义。
代码:
```Java
class Solution {
int N = 100010, M = N, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M];
char[] cs;
int[] f1 = new int[N], f2 = new int[N], g = new int[N], p = new int[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int longestPath(int[] parent, String s) {
Arrays.fill(he, -1);
for (int i = 1; i < parent.length; i++) add(parent[i], i);
cs = s.toCharArray();
dfs1(0);
dfs2(0);
int ans = 1;
int[] temp = new int[3];
for (int i = 0; i < parent.length; i++) {
temp[0] = f1[i]; temp[1] = f2[i]; temp[2] = g[i];
Arrays.sort(temp);
ans = Math.max(ans, 1 + temp[1] + temp[2]);
}
return ans;
}
int dfs1(int u) {
int ans = 0;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
int t = dfs1(j);
if (cs[u] == cs[j]) continue;
if (t > f1[u]) {
f2[u] = f1[u]; f1[u] = t;
p[u] = j;
} else if (t > f2[u]) {
f2[u] = t;
}
ans = Math.max(ans, t);
}
return ans + 1;
}
void dfs2(int u) {
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (cs[u] != cs[j]) {
// 往上再往上
g[j] = g[u] + 1;
// 往上再往下(根据 u 的往下最大路径是否由 j 参与决定使用 最大值 还是 次大值)
if (p[u] != j) g[j] = Math.max(g[j], 1 + f1[u]);
else g[j] = Math.max(g[j], 1 + f2[u]);
}
dfs2(j);
}
}
}
```
* 时间复杂度:常数较大的 $O(n)$。相比于一次 `DFS` 的做法来说,额外多了一次 `DFS`,以及构建答案时对定长数组的排序操作
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2346` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2251-2260/2258. 逃离火灾（困难）.md | 2258. 逃离火灾 | https://leetcode.cn/problems/escape-the-spreading-fire/solutions/2518985/gong-shui-san-xie-xiang-jie-ru-he-cong-e-458x/ | 困难 | [
"多源 BFS",
"二分",
"预处理"
] | 给你一个下标从 `0` 开始大小为 `m x n` 的二维整数数组 `grid`,它表示一个网格图。
每个格子为下面 $3$ 个值之一:
* `0` 表示草地。
* `1` 表示着火的格子。
* `2` 表示一座墙,你跟火都不能通过这个格子。
一开始你在最左上角的格子 $(0, 0)$ ,你想要到达最右下角的安全屋格子 $(m - 1, n - 1)$ 。
每一分钟,你可以移动到相邻的草地格子。
每次你移动之后 ,着火的格子会扩散到所有不是墙的相邻格子。
请你返回你在初始位置可以停留的最多分钟数,且停留完这段时间后你还能安全到达安全屋。
如果无法实现,请你返回 $-1$。如果不管你在初始位置停留多久,你总是能到达安全屋,请你返回 $10^9$ 。
注意,如果你到达安全屋后,火马上到了安全屋,这视为你能够安全到达安全屋。
如果两个格子有共同边,那么它们为相邻格子。
示例 1:
```
输入:grid = [[0,2,0,0,0,0,0],[0,0,0,2,2,1,0],[0,2,0,0,1,2,0],[0,0,2,2,2,0,2],[0,0,0,0,0,0,0]]
输出:3
解释:上图展示了你在初始位置停留 3 分钟后的情形。
你仍然可以安全到达安全屋。
停留超过 3 分钟会让你无法安全到达安全屋。
```
示例 2:
```
输入:grid = [[0,0,0,0],[0,1,2,0],[0,2,0,0]]
输出:-1
解释:上图展示了你马上开始朝安全屋移动的情形。
火会蔓延到你可以移动的所有格子,所以无法安全到达安全屋。
所以返回 -1 。
```
示例 3:
```
输入:grid = [[0,0,0],[2,2,0],[1,2,0]]
输出:1000000000
解释:上图展示了初始网格图。
注意,由于火被墙围了起来,所以无论如何你都能安全到达安全屋。
所以返回 109 。
```
提示:
* $m = grid.length$
* $n = grid[i].length$
* $2 <= m, n <= 300$
* $4 <= m \times n <= 2 \times 10^4$
* `grid[i][j]` 是 `0`,`1` 或者 `2`。
* $grid[0][0] = grid[m - 1][n - 1] = 0$ | ### 二分 + BFS
火势蔓延是一个固定的过程,只有人员移动需要决策。
假设人员最晚在 $t$ 秒后出发,仍能到达安全屋,说明人员对逃走路线的访问,要比火势更快。那么人员在更早的时间点($[0, t - 1]$ 秒后)出发,必然仍能按照原定路线到达安全屋(火势对路径的影响不变)。
因此,在以 $t$ 为分割点的(正整数)数轴上,具有二段性,可运用「二分」求分割点。
假设存在某个判定函数 `check`,用于检查人员在 $x$ 秒后出发能否到达安全屋,那么可知:
* 当实际延迟出发的秒数,小于等于 $t$ 秒,必然能安全到达
* 当实际延迟出发的描述,超过 $t$ 秒,必然不能安全到达
在人员移动路线中,“回头路”是没有意义的,因此人员对每个点的访问次数最多为一次。同时,不考虑墙的阻拦,火势也最多在不超过棋盘大小的时间内完全蔓延。
这指导我们最大延迟出发时间不会超过 $n \times m$,可在 $[0, n \times m]$ 值域内进行二分。
接下来,考虑如何实现 `check` 函数,函数入参为延迟出发秒数 $t$,返回值为延迟出发后能否到达安全屋。
首先,对于普通位置,如果火势和人员同时到达,是不允许的,而安全屋 $(n - 1, m - 1)$ 位置的同时到达,是允许的。
因此,我们需要使用两个二维数组 `fg` 和 `pg` 分别记录「火势」和「人员」到达某个位置的最早时间。
1. 创建用于模拟火势蔓延的队列 `fire`,遍历网格,将火源位置进行入队,更新火源位置 $fg[i][j] = 1$,表示火势在第一秒时最早出现在此处;
2. 运用 `BFS`,模拟 $t$ 秒的火势蔓延,火势在这 $t$ 秒内所蔓延到的新位置,均看作为起始火源,即有 $fg[i][j] = 1$。
若执行完 $t$ 秒后,火势已蔓延到人员起始位置 $(0, 0)$,那么延迟 $t$ 秒出发不可行,直接返回 `False`;
3. 创建用于模拟人员移动的队列 `people`,将起始位置 $(0, 0)$ 进行入队,更新 $pg[0][0] = 1$。
运用 `BFS`,按照「先火后人」的方式,同步模拟「火势蔓延」和「人员移动」过程。普通位置,只要火势蔓延到,那么人将无法移动到此处;安全屋位置,需要判断是否与火势同一时刻到达。
为了方便,将「火势蔓延」和「人员移动」统一成 `update` 操作,入参包括当前队列 `d`,标识位 `isFire`,以及移动偏移量 `offset`。
在进行 $t$ 秒的火势蔓延时,调用 $t$ 次的 `update(fire, true, 0)`。在火势和人员同步模拟时,分别调用 `update(fire, true, 1)` 和 `update(people, false, 1)`。
使用示例 $1$ 来举个 🌰:
Java 代码:
```Java
class Solution {
int[][] dirs = new int[][]{{0,1}, {0,-1}, {1,0}, {-1,0}};
int n, m;
boolean ok;
int[][] g, fg, pg;
public int maximumMinutes(int[][] grid) {
g = grid;
n = g.length; m = g[0].length;
fg = new int[n][m]; pg = new int[n][m];
if (!check(0)) return -1;
int l = 0, r = n * m;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(mid)) l = mid;
else r = mid - 1;
}
return r == m * n ? (int)1e9 : r;
}
boolean check(int t) {
ok = false;
Deque<int[]> frie = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fg[i][j] = pg[i][j] = 0;
if (g[i][j] == 1) {
fg[i][j] = 1;
frie.addLast(new int[]{i, j});
}
}
}
while(t-- > 0) update(frie, true, 0); // 先执行 t 秒的火势蔓延
if (fg[0][0] != 0) return false;
Deque<int[]> people = new ArrayDeque<>();
pg[0][0] = 1;
people.addLast(new int[]{0, 0});
while (!people.isEmpty()) {
// 先火后人, 同步进行
update(frie, true, 1);
update(people, false, 1);
if (ok) return true;
}
return false;
}
void update(Deque<int[]> deque, boolean isFire, int offset) {
int sz = deque.size();
while (sz-- > 0) {
int[] info = deque.pollFirst();
int x = info[0], y = info[1];
for (int[] dir : dirs) {
int nx = x + dir[0], ny = y + dir[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 2) continue;
if (isFire) {
if (fg[nx][ny] != 0) continue;
fg[nx][ny] = fg[x][y] + offset;
} else {
if (nx == n - 1 && ny == m - 1 && (fg[nx][ny] == 0 || fg[nx][ny] == pg[x][y] + offset)) ok = true; // 火尚未到达 或 同时到达
if (fg[nx][ny] != 0 || pg[nx][ny] != 0) continue;
pg[nx][ny] = pg[x][y] + offset;
}
deque.addLast(new int[]{nx, ny});
}
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> dirs = {{0,1}, {0,-1}, {1,0}, {-1,0}};
int n, m;
bool ok;
vector<vector<int>> g, fg, pg;
int maximumMinutes(vector<vector<int>>& grid) {
g = grid;
n = g.size(); m = g[0].size();
fg = vector<vector<int>>(n, vector<int>(m, 0)), pg = vector<vector<int>>(n, vector<int>(m, 0));
if (!check(0)) return -1;
int l = 0, r = n * m;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(mid)) l = mid;
else r = mid - 1;
}
return r == n * m ? (int)1e9 : r;
}
bool check(int t) {
ok = false;
deque<vector<int>> frie;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fg[i][j] = pg[i][j] = 0;
if (g[i][j] == 1) {
fg[i][j] = 1;
frie.push_back({i, j});
}
}
}
while (t-- > 0) update(frie, true, 0);
if (fg[0][0] != 0) return false;
deque<vector<int>> people;
pg[0][0] = 1;
people.push_back({0, 0});
while (!people.empty()) {
update(frie, true, 1);
update(people, false, 1);
if (ok) return true;
}
return false;
}
void update(deque<vector<int>>& deque, bool isFire, int offset) {
int sz = deque.size();
while (sz-- > 0) {
vector<int> info = deque.front();
deque.pop_front();
int x = info[0], y = info[1];
for (vector<int> dir : dirs) {
int nx = x + dir[0], ny = y + dir[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 2) continue;
if (isFire) {
if (fg[nx][ny] != 0) continue;
fg[nx][ny] = fg[x][y] + offset;
} else {
if (nx == n - 1 && ny == m - 1 && (fg[nx][ny] == 0 || fg[nx][ny] == pg[x][y] + offset)) ok = true;
if (fg[nx][ny] != 0 || pg[nx][ny] != 0) continue;
pg[nx][ny] = pg[x][y] + offset;
}
deque.push_back({nx, ny});
}
}
}
};
```
Python 代码:
```Python
from collections import deque
class Solution:
def maximumMinutes(self, grid: List[List[int]]) -> int:
dirs = [(0,1),(0,-1),(1,0),(-1,0)]
g = grid
n, m = len(g), len(g[0])
fg, pg, ok = None, None, False
def update(d, isFire, offset):
nonlocal ok
for _ in range(len(d)):
x, y = d.popleft()
for dx, dy in dirs:
nx, ny = x + dx, y + dy
if nx < 0 or nx >= n or ny < 0 or ny >= m: continue
if g[nx][ny] == 2: continue
if isFire:
if fg[nx][ny] != 0: continue
fg[nx][ny] = fg[x][y] + offset
else:
if nx == n - 1 and ny == m - 1 and (fg[nx][ny] == 0 or fg[nx][ny] == pg[x][y] + offset): ok = True
if fg[nx][ny] != 0 or pg[nx][ny] != 0: continue
pg[nx][ny] = pg[x][y] + offset
d.append((nx, ny))
def check(t):
nonlocal pg, fg, ok
ok = False
pg = [[0] * m for _ in range(n)]
fg = [[g[i][j] == 1 for j in range(m)] for i in range(n)]
fire = deque([(i, j) for i, j in product(range(n), range(m)) if g[i][j] == 1])
for _ in range(t): update(fire, True, 0)
if fg[0][0] != 0: return False
people = deque()
pg[0][0] = 1
people.append((0, 0))
while people:
update(fire, True, 1)
update(people, False, 1)
if ok: return True
return False
if not check(0): return -1
l, r = 0, n * m
while l < r:
mid = l + r + 1 >> 1
if check(mid): l = mid
else: r = mid - 1
return int(1e9) if r == n * m else r
```
TypeScript 代码:
```TypeScript
function maximumMinutes(grid: number[][]): number {
const dirs = [[0,1],[0,-1],[1,0],[-1,0]];
const g = grid;
const n = g.length, m = g[0].length;
const fg = Array.from({length: n}, () => Array(m).fill(0)), pg = Array.from({length: n}, () => Array(m).fill(0));
let ok = false;
const update = function(d: number[][], isFire: boolean, offset: number) {
let sz = d.length;
while (sz-- > 0) {
const info = d.shift();
const x = info[0], y = info[1];
for (let di of dirs) {
const nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 2) continue;
if (isFire) {
if (fg[nx][ny] != 0) continue;
fg[nx][ny] = fg[x][y] + offset;
} else {
if (nx == n - 1 && ny == m - 1 && (fg[nx][ny] == 0 || fg[nx][ny] == pg[x][y] + offset)) ok = true;
if (fg[nx][ny] != 0 || pg[nx][ny] != 0) continue;
pg[nx][ny] = pg[x][y] + offset;
}
d.push([nx, ny]);
}
}
}
const check = function(t: number): boolean {
ok = false
const fire = new Array()
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
fg[i][j] = pg[i][j] = 0;
if (g[i][j] == 1) {
fg[i][j] = 1;
fire.push([i, j]);
}
}
}
while (t-- > 0) update(fire, true, 0);
if (fg[0][0] != 0) return false;
const people = new Array();
pg[0][0] = 1;
people.push([0, 0]);
while (people.length != 0) {
update(fire, true, 1);
update(people, false, 1);
if (ok) return true;
}
return false;
}
if (!check(0)) return -1;
let l = 0, r = n * m;
while (l < r) {
const mid = l + r + 1 >> 1;
if (check(mid)) l = mid;
else r = mid - 1;
}
return r == n * m ? 1e9 : r;
};
```
* 时间复杂度:在值域 $[0, n \times m]$ 范围内进行二分,二分 `check` 的 `BFS` 实现复杂度为 $O(n \times m)$。整体复杂度为 $O(nm \log{nm})$
* 空间复杂度:$O(n \times m)$
---
### BFS + 分类讨论
经过上述解法,我们发现存在大量重复计算:例如每次唯一确定的“火势蔓延”过程,以及每次根据最新起始火势(由延迟出发时间 $t$ 所决定)进行的“人员移动”过程,都是不必要的,可通过比较双方到达时间来求解。
具体的,还是用 `fg` 和 `pg`,分别预处理出「火势」和「人员」到达每个网格的最早时间。其中火势蔓延唯一确定,而人员的预处理是在不考虑火势的情况下进行。
根据 $f = fg[n-1][m-1]$ 和 $p = pg[n-1][m-1]$ 进行分情况讨论:
* 若 $p = 0$:人与安全屋不连通,返回 $-1$;
* 若 $f = 0$:火与安全屋不连通,同时上述条件不满足($p \neq 0$),即人与安全屋是联通 ,返回 $1e9$;
* 若 $f < p$:火和人都能到达安全屋。即使不考虑人员中途被火影响(人员可能无法按照最佳路线前往安全屋)的情况下,火也比人要更早到达安全屋,返回 $-1$;
* 若 $f \geqslant p$:理想情况下,人比火更早到达安全屋,但存在「人火同时到达」、「人员中途被烧」或「通路被火拦截」等问题,需要进一步分情况讨论:
不难发现,由于安全屋的位于 $(n - 1, m - 1)$,人员只能从 $(n - 1, m - 2)$ 或 $(n - 2, m - 1)$ 两个位置之一到达安全屋(这两个属于普通位置,不允许人和火同时到达),因此可以将「对特殊位置安全屋」的讨论转为「对普通位置」的讨论:
* 若 $pg[n - 1][m - 2] \neq 0$,人与该位置联通,且 $f - p + pg[n - 1][m - 2] < fg[n - 1][m - 2]$,人比火更早到达该位置,返回 $f - p$;
* 若 $pg[n - 2][m - 1] \neq 0$,人与该位置联通,且 $f - p + pg[n - 2][m - 1] < fg[n - 2][m - 1]$,人比火更早到达该位置,返回 $f - p$;
* 否则,说明延迟 $f - p$ 秒出发,唯二的通路会被火提前拦截,需要早一秒出发,返回 $f - p - 1$;
Java 代码:
```Java
class Solution {
int[][] dirs = new int[][]{{0,1}, {0,-1}, {1,0}, {-1,0}};
int[][] g;
int n, m;
public int maximumMinutes(int[][] grid) {
g = grid;
n = g.length; m = g[0].length;
int[][] fg = new int[n][m], pg = new int[n][m];
Deque<int[]> fire = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] == 1) {
fg[i][j] = 1;
fire.addLast(new int[]{i, j});
}
}
}
bfs(fire, fg);
Deque<int[]> people = new ArrayDeque<>();
people.addLast(new int[]{0, 0});
pg[0][0] = 1;
bfs(people, pg);
int p = pg[n - 1][m - 1], f = fg[n - 1][m - 1], ans = f - p;
if (p == 0) return -1;
if (f == 0) return (int)1e9;
if (p > f) return -1;
if (pg[n - 1][m - 2] != 0 && ans + pg[n - 1][m - 2] < fg[n - 1][m - 2]) return ans;
if (pg[n - 2][m - 1] != 0 && ans + pg[n - 2][m - 1] < fg[n - 2][m - 1]) return ans;
return ans - 1;
}
void bfs(Deque<int[]> d, int[][] time) {
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int x = info[0], y = info[1];
for (int[] dir : dirs) {
int nx = x + dir[0], ny = y + dir[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 2) continue;
if (time[nx][ny] != 0) continue;
time[nx][ny] = time[x][y] + 1;
d.addLast(new int[]{nx, ny});
}
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<vector<int>> dirs = {{0,1}, {0,-1}, {1,0}, {-1,0}};
vector<vector<int>> g;
int n, m;
int maximumMinutes(vector<vector<int>>& grid) {
g = grid;
n = g.size(); m = g[0].size();
vector<vector<int>> fg = vector<vector<int>>(n, vector<int>(m, 0)), pg = vector<vector<int>>(n, vector<int>(m, 0));
deque<pair<int, int>> fire;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] == 1) {
fg[i][j] = 1;
fire.push_back({i, j});
}
}
}
bfs(fire, fg);
deque<pair<int, int>> people;
people.push_back({0, 0});
pg[0][0] = 1;
bfs(people, pg);
int p = pg[n - 1][m - 1], f = fg[n - 1][m - 1], ans = f - p;
if (p == 0) return -1;
if (f == 0) return (int)1e9;
if (p > f) return -1;
if (pg[n - 1][m - 2] != 0 && ans + pg[n - 1][m - 2] < fg[n - 1][m - 2]) return ans;
if (pg[n - 2][m - 1] != 0 && ans + pg[n - 2][m - 1] < fg[n - 2][m - 1]) return ans;
return ans - 1;
}
void bfs(deque<pair<int, int>>& d, vector<vector<int>>& time) {
while (!d.empty()) {
pair<int, int> info = d.front();
d.pop_front();
int x = info.first, y = info.second;
for (vector<int> dir : dirs) {
int nx = x + dir[0], ny = y + dir[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 2) continue;
if (time[nx][ny] != 0) continue;
time[nx][ny] = time[x][y] + 1;
d.push_back({nx, ny});
}
}
}
};
```
Python 代码:
```Python
from collections import deque
class Solution:
def maximumMinutes(self, grid: List[List[int]]) -> int:
dirs = [(0,1), (0,-1), (1,0), (-1,0)]
g = grid
n, m = len(g), len(g[0])
def bfs(d, tn):
while d:
x, y = d.popleft()
for dx, dy in dirs:
nx, ny = x + dx, y + dy
if nx < 0 or nx >= n or ny < 0 or ny >= m: continue
if g[nx][ny] == 2 or tn[nx][ny]: continue
tn[nx][ny] = tn[x][y] + 1
d.append((nx, ny))
fg = [[g[i][j] == 1 for j in range(m)] for i in range(n)]
fire = deque([(i, j) for i, j in product(range(n), range(m)) if g[i][j] == 1])
bfs(fire, fg)
pg = [[0] * m for _ in range(n)]
pg[0][0] = 1
people = deque([(0, 0)])
bfs(people, pg)
p, f = pg[-1][-1], fg[-1][-1]
ans = f - p
if p == 0: return -1
if f == 0: return int(1e9)
if p > f: return -1
if pg[-1][-2] != 0 and ans + pg[-1][-2] < fg[-1][-2]: return ans
if pg[-2][-1] != 0 and ans + pg[-2][-1] < fg[-2][-1]: return ans
return ans - 1
```
TypeScript 代码:
```TypeScript
function maximumMinutes(grid: number[][]): number {
const g = grid;
const n = g.length, m = g[0].length;
const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]];
const bfs = function (d: number[][], time: number[][]): void {
while (d.length > 0) {
const info = d.shift() as number[];
const x = info[0], y = info[1];
for (const dir of dirs) {
const nx = x + dir[0], ny = y + dir[1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (g[nx][ny] == 2) continue;
if (time[nx][ny] != 0) continue;
time[nx][ny] = time[x][y] + 1;
d.push([nx, ny]);
}
}
}
const fg = Array.from({ length: n }, () => Array(m).fill(0));
const pg = Array.from({ length: n }, () => Array(m).fill(0));
const fire = [];
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (g[i][j] == 1) {
fg[i][j] = 1;
fire.push([i, j]);
}
}
}
bfs(fire, fg);
const people = [];
people.push([0, 0]);
pg[0][0] = 1;
bfs(people, pg);
const p = pg[n - 1][m - 1], f = fg[n - 1][m - 1], ans = f - p;
if (p == 0) return -1;
if (f == 0) return 1e9;
if (p > f) return -1;
if (pg[n - 1][m - 2] != 0 && ans + pg[n - 1][m - 2] < fg[n - 1][m - 2]) return ans;
if (pg[n - 2][m - 1] != 0 && ans + pg[n - 2][m - 1] < fg[n - 2][m - 1]) return ans;
return ans - 1;
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2258` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2291-2300/2300. 咒语和药水的成功对数（中等）.md | 2300. 咒语和药水的成功对数 | https://leetcode.cn/problems/successful-pairs-of-spells-and-potions/solutions/2520333/gong-shui-san-xie-jing-dian-er-fen-yun-y-86y0/ | 中等 | [
"排序",
"二分"
] | 给你两个正整数数组 `spells` 和 `potions`,长度分别为 `n` 和 `m`,其中 `spells[i]` 表示第 `i` 个咒语的能量强度,`potions[j]` 表示第 `j` 瓶药水的能量强度。
同时给你一个整数 `success`。一个咒语和药水的能量强度相乘如果大于等于 `success`,那么它们视为一对成功的组合。
请你返回一个长度为 `n` 的整数数组 `pairs`,其中 `pairs[i]` 是能跟第 `i` 个咒语成功组合的 药水 数目。
示例 1:
```
输入:spells = [5,1,3], potions = [1,2,3,4,5], success = 7
输出:[4,0,3]
解释:
- 第 0 个咒语:5 * [1,2,3,4,5] = [5,10,15,20,25] 。总共 4 个成功组合。
- 第 1 个咒语:1 * [1,2,3,4,5] = [1,2,3,4,5] 。总共 0 个成功组合。
- 第 2 个咒语:3 * [1,2,3,4,5] = [3,6,9,12,15] 。总共 3 个成功组合。
所以返回 [4,0,3] 。
```
示例 2:
```
输入:spells = [3,1,2], potions = [8,5,8], success = 16
输出:[2,0,2]
解释:
- 第 0 个咒语:3 * [8,5,8] = [24,15,24] 。总共 2 个成功组合。
- 第 1 个咒语:1 * [8,5,8] = [8,5,8] 。总共 0 个成功组合。
- 第 2 个咒语:2 * [8,5,8] = [16,10,16] 。总共 2 个成功组合。
所以返回 [2,0,2] 。
```
提示:
* $n = spells.length$
* $m = potions.length$
* $1 <= n, m <= 10^5$
* $1 <= spells[i], potions[i] <= 10^5$
* $1 <= success <= 1010$ | ### 排序 + 二分
为了方便,我们将 `spells` 记为 `a`,将 `potions` 记为 `b`,将 `success` 记为 `t`。
对于每个 $a[i]$,有多少个 $b[j]$ 满足 $a[i] \times b[j] \geqslant t$,等价于问数组 `b` 中值大于等于 $\frac{t}{a[i]}$ 的个数,这容易让我们想到先对数组 `b` 排升序,再通过二分找到满足该条件的最小下标,从该下标到数组结尾,均为满足条件的 $b[j]$。
Java 代码:
```Java
class Solution {
public int[] successfulPairs(int[] a, int[] b, long t) {
int n = a.length, m = b.length;
int[] ans = new int[n];
Arrays.sort(b);
for (int i = 0; i < n; i++) {
double cur = t * 1.0 / a[i];
int l = 0, r = m - 1;
while (l < r) {
int mid = l + r >> 1;
if (b[mid] >= cur) r = mid;
else l = mid + 1;
}
if (b[r] * 1L * a[i] >= t) ans[i] = m - r;
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def successfulPairs(self, a: List[int], b: List[int], t: int) -> List[int]:
# n, m = len(a), len(b)
# b.sort()
# ans = [0] * n
# for i in range(n):
# cur = t / a[i]
# l, r = 0, m - 1
# while l < r:
# mid = l + r >> 1
# if b[mid] >= cur: r = mid
# else: l = mid + 1
# ans[i] = m - r if b[r] * a[i] >= t else 0
# return ans
b.sort()
return [len(b) - bisect_left(b, t / x) for x in a]
```
C++ 代码:
```C++
class Solution {
public:
vector<int> successfulPairs(vector<int>& a, vector<int>& b, long long t) {
// int n = a.size(), m = b.size();
// vector<int> ans(n);
// sort(b.begin(), b.end());
// for (int i = 0; i < n; i++) {
// double cur = t * 1.0 / a[i];
// int l = 0, r = m - 1;
// while (l < r) {
// int mid = l + r >> 1;
// if (b[mid] >= cur) r = mid;
// else l = mid + 1;
// }
// if (b[r] * 1L * a[i] >= t) ans[i] = m - r;
// }
// return ans;
int n = a.size(), m = b.size();
vector<int> ans(n);
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) ans[i] = b.end() - lower_bound(b.begin(), b.end(), t * 1.0 / a[i]);
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function successfulPairs(a: number[], b: number[], t: number): number[] {
const n = a.length, m = b.length;
const ans = new Array(n).fill(0);
b.sort((a,b)=>a-b);
for (let i = 0; i < n; i++) {
const cur = t * 1.0 / a[i];
let l = 0, r = m - 1;
while (l < r) {
const mid = l + r >> 1;
if (b[mid] >= cur) r = mid;
else l = mid + 1;
}
if (b[r] * a[i] >= t) ans[i] = m - r;
}
return ans;
};
```
* 时间复杂度:对数组 `b` 排序的复杂度为 $O(m\log{m})$;构建答案时,每次在值域 $[0, m - 1]$ 范围内进行二分,复杂度为 $O(n\log{m})$。整体复杂度为 $O(m\log{m} + n\log{m})$
* 空间复杂度:$O(\log{m} + n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2300` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2301-2310/2304. 网格中的最小路径代价（中等）.md | 2304. 网格中的最小路径代价 | https://leetcode.cn/problems/minimum-path-cost-in-a-grid/solutions/2536854/gong-shui-san-xie-cong-tu-lun-zui-duan-l-emxv/ | 中等 | [
"最短路",
"图",
"模拟",
"序列 DP",
"动态规划"
] | 给你一个下标从 `0` 开始的整数矩阵 `grid`,矩阵大小为 `m x n`,由从 `0` 到 $m \times n - 1$ 的不同整数组成。
你可以在此矩阵中,从一个单元格移动到下一行的任何其他单元格。
如果你位于单元格 $(x, y)$ ,且满足 $x < m - 1$,你可以移动到 $(x + 1, 0)$, $(x + 1, 1)$, ..., $(x + 1, n - 1)$ 中的任何一个单元格。注意: 在最后一行中的单元格不能触发移动。
每次可能的移动都需要付出对应的代价,代价用一个下标从 `0` 开始的二维数组 `moveCost` 表示,该数组大小为 $(m \times n) \times n$ ,其中 `moveCost[i][j]` 是从值为 `i` 的单元格移动到下一行第 `j` 列单元格的代价。从 `grid` 最后一行的单元格移动的代价可以忽略。
`grid` 一条路径的代价是:所有路径经过的单元格的值之和加上所有移动的代价之和 。从第一行任意单元格出发,返回到达最后一行任意单元格的最小路径代价。
示例 1:
```
输入:grid = [[5,3],[4,0],[2,1]], moveCost = [[9,8],[1,5],[10,12],[18,6],[2,4],[14,3]]
输出:17
解释:最小代价的路径是 5 -> 0 -> 1 。
- 路径途经单元格值之和 5 + 0 + 1 = 6 。
- 从 5 移动到 0 的代价为 3 。
- 从 0 移动到 1 的代价为 8 。
路径总代价为 6 + 3 + 8 = 17 。
```
示例 2:
```
输入:grid = [[5,1,2],[4,0,3]], moveCost = [[12,10,15],[20,23,8],[21,7,1],[8,1,13],[9,10,25],[5,3,2]]
输出:6
解释:
最小代价的路径是 2 -> 3 。
- 路径途经单元格值之和 2 + 3 = 5 。
- 从 2 移动到 3 的代价为 1 。
路径总代价为 5 + 1 = 6 。
```
提示:
* $m = grid.length$
* $n = grid[i].length$
* $2 <= m, n <= 50$
* `grid` 由从 `0` 到 `m * n - 1` 的不同整数组成
* $moveCost.length = m \times n$
* $moveCost[i].length = n$
* $1 <= moveCost[i][j] <= 100$ | ### 建新图 + 建虚拟点 + 堆优化 Dijkstra
> 注意:可以直接使用解法二的方法,但先认真看完本做法,再去看解法二,会有相当丝滑的体验。
每次移动,**实际路径权值 = 经过边的权值 + 目的地的权值**。
利用原图,构建新图:**每个单元格视为一个点,除最后一行外,每个点对下一行的所有点连一条有向边,边权 = 原图中该边的权值 + 原图中该目的地的权值**。
分析新图中的点边数量:
* 点:共 $m \times n$ 个点,数量为 $2.5 \times 10^3$
* 边:不算最后一行,共 $(m - 1) \times n$ 个点,这些点与下一行的每个点均有一条有向边,合计 $(m - 1) \times n^2$ 条边,数量为 $1.25 \times 10^5$
原问题转换为:求点 $i$ 到 $j$ 的最短路,其中点 $i$ 所在位置为第 $0$ 行,点 $j$ 所在位置为第 $m - 1$ 行。
这似乎是一个「多源汇最短路」问题?但求解多源汇最短路的 `Floyd` 算法是 $O(n^3)$ 的,会超时。
实际上,我们也并不真的关心图中任意点之间的最短路,仅仅关心第一行到最后一行的最短路。
因此,**我们可通过建立“虚拟源点”和“虚拟汇点”的方式,来将“多源汇最短路”问题转换为“单源最短路”问题。**
具体的,我们创建一个“虚拟源点”,该点向所有第一行的点连权值为 $grid[0][i]$ 的有向边;同时创建一个“虚拟汇点”,最后一行的所有点向该点连权值为 $0$ 的有向边。
问题进一步转化为:求“虚拟源点”到“虚拟汇点”的最短路。
至此,我们通过 **建新图 -> 创建虚拟源汇点(转换为单源最短路)-> 套用单源最短路算法** 解决本题。
将新图中点的数量记为 $n$,边数记为 $m$,朴素 `Dijkstra` 复杂度为 $O(n^2)$,堆优化的 `Dijkstra` 的复杂度为 $O(m\log{n})$,当 $m < n^2$ (相对稀疏)时,优先使用堆优化 `Dijkstra`。
Java 代码:
```Java
class Solution {
int N = 50 * 50 + 2, M = 50 * 50 * 50, idx = 0, n;
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
public int minPathCost(int[][] grid, int[][] moveCost) {
int N = grid.length, M = grid[0].length;
int S = N * M, T = S + 1;
n = N * M + 2;
Arrays.fill(he, -1);
//「虚拟源点」向「第一行」进行连边
for (int i = 0; i < M; i++) add(S, grid[0][i], grid[0][i]);
// 转换原图
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < M; j++) {
int a = grid[i][j];
for (int k = 0; k < M; k++) {
int b = grid[i + 1][k];
add(a, b, moveCost[a][k] + b);
}
}
}
//「最后一行」向「虚拟汇点」进行连边
for (int i = 0; i < M; i++) add(grid[N - 1][i], T, 0);
// 最短路
int[] dist = dijkstra(S);
return dist[T];
}
int[] dijkstra(int x) {
// 起始先将所有的点标记为「未更新」和「距离为正无穷」
int[] dist = new int[n];
Arrays.fill(dist, 0x3f3f3f3f);
boolean[] vis = new boolean[n];
dist[x] = 0;
// 使用「优先队列」存储所有可用于更新的点
// 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);
q.add(new int[]{x, 0});
while (!q.isEmpty()) {
// 每次从「优先队列」中弹出
int[] poll = q.poll();
int u = poll[0], step = poll[1];
// 如果弹出的点被标记「已更新」,则跳过
if (vis[u]) continue;
// 标记该点「已更新」,并使用该点更新其他点的「最短距离」
vis[u] = true;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] <= dist[u] + w[i]) continue;
dist[j] = dist[u] + w[i];
q.add(new int[]{j, dist[j]});
}
}
return dist;
}
}
```
C++ 代码:
```C++
class Solution {
public:
static const int N = 50 * 50 + 2, M = 50 * 50 * 50;
int he[N], e[M], ne[M], w[M], idx, n, INF = 0x3f3f3f3f;
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {
int N = grid.size(), M = grid[0].size();
int S = N * M, T = S + 1;
n = N * M + 2;
fill(he, he + n, -1);
//「虚拟源点」向「第一行」进行连边
for (int i = 0; i < M; i++) add(S, grid[0][i], grid[0][i]);
// 转换原图
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < M; j++) {
int a = grid[i][j];
for (int k = 0; k < M; k++) {
int b = grid[i + 1][k];
add(a, b, moveCost[a][k] + b);
}
}
}
//「最后一行」向「虚拟汇点」进行连边
for (int i = 0; i < M; i++) add(grid[N - 1][i], T, 0);
// 最短路
vector<int> dist = dijkstra(S);
return dist[T];
}
vector<int> dijkstra(int x) {
vector<int> dist(n, 0x3f3f3f3f);
vector<bool> vis(n, false);
dist[x] = 0;
// 使用「优先队列」存储所有可用于更新的点
// 以 (到起点的距离, 点编号) 进行存储,优先弹出「最短距离」较小的点
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
q.push({0, x});
while (!q.empty()) {
// 每次从「优先队列」中弹出
auto [step, u] = q.top();
q.pop();
// 如果弹出的点被标记「已更新」,则跳过
if (vis[u]) continue;
// 标记该点「已更新」,并使用该点更新其他点的「最短距离」
vis[u] = true;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] <= dist[u] + w[i]) continue;
dist[j] = dist[u] + w[i];
q.push({dist[j], j});
}
}
return dist;
}
};
```
Python 代码:
```Python
import heapq
class Solution:
def minPathCost(self, grid, moveCost):
N, M = len(grid), len(grid[0])
S, T = N * M, N * M + 1
n = N * M + 2
he = [-1] * n
e, ne, w = [-1] * (50 * 50 * 50), [-1] * (50 * 50 * 50), [-1] * (50 * 50 * 50)
idx = 0
def add(a, b, c):
nonlocal idx
e[idx] = b
ne[idx] = he[a]
w[idx] = c
he[a] = idx
idx += 1
def dijkstra(x):
dist = [float('inf')] * n
vis = [False] * n
dist[x] = 0
# 使用「优先队列」存储所有可用于更新的点
# 以 (到起点的距离, 点编号) 进行存储,优先弹出「最短距离」较小的点
q = [(0, x)]
heapq.heapify(q)
while q:
# 每次从「优先队列」中弹出
step, u = heapq.heappop(q)
# 如果弹出的点被标记「已更新」,则跳过
if vis[u]: continue
# 标记该点「已更新」,并使用该点更新其他点的「最短距离」
vis[u] = True
i = he[u]
while i != -1:
j, c = e[i], w[i]
i = ne[i]
if dist[j] <= dist[u] + c: continue
dist[j] = dist[u] + c
heapq.heappush(q, (dist[j], j))
return dist
#「虚拟源点」向「第一行」进行连边
for i in range(M):
add(S, grid[0][i], grid[0][i])
# 转换原图
for i in range(N - 1):
for j in range(M):
a = grid[i][j]
for k in range(M):
b = grid[i + 1][k]
add(a, b, moveCost[a][k] + b)
#「最后一行」向「虚拟汇点」进行连边
for i in range(M):
add(grid[N - 1][i], T, 0)
# 最短路
dist = dijkstra(S)
return dist[T]
```
* 时间复杂度:$O(m\log{n})$,其中 $n$ 为新图中的点数 $N \times M = 2.5 \times 10^3$,$m$ 为新图中的边数 $(M - 1) \times N^2 = 1.25 \times 10^5$
* 空间复杂度:$O(n + m)$
---
### 堆优化 Dijkstra
什么?你说你实在不想建新图,也不想搞什么虚拟点,就想用你心爱的 `BFS` 来做?!
我懂你意思,但那不叫 `BFS`。
只是将「建新图」和「建虚拟点」的过程省掉,仍需要使用优先队列(堆)来每次取出当前“路径代价最小”的点来进行扩充,执行过程仍为堆优化 `Dijkstra` 的核心操作。
尤其所谓“省掉” 建新图 和 建虚拟点,真就字面上的“省掉”,并非不存在,因为两种做法思路是完全一致的。可简单列举「本解法」与「解法一」的对应关系:
* 起始往队列放入首行元素,对应了解法一的“建立虚拟源点”过程;
* 从队列中取元素出来扩充时,若当前元素所在行是最后一行时,用当前路径代价来更新答案,对应了解法一的“建立虚拟汇点”过程;
* 扩充时直接遍历列(即下一行的所有点),对应的解法一的“用原图边建新图”的过程。
Java 代码:
```Java
class Solution {
public int minPathCost(int[][] grid, int[][] moveCost) {
int m = grid.length, n = grid[0].length, INF = 0x3f3f3f3f, ans = INF;
int[][] dist = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) dist[i][j] = INF;
}
PriorityQueue<int[]> d = new PriorityQueue<>((a,b)->a[2]-b[2]);
for (int i = 0; i < n; i++) {
d.add(new int[]{0, i, grid[0][i]});
dist[0][i] = grid[0][i];
}
while (!d.isEmpty()) {
int[] info = d.poll();
int x = info[0], y = info[1], cur = info[2];
if (x == m - 1) {
ans = Math.min(ans, cur);
continue;
}
for (int i = 0; i < n; i++) {
int step = moveCost[grid[x][y]][i], ne = grid[x + 1][i];
int tot = cur + step + ne;
if (tot >= ans || dist[x + 1][i] <= tot) continue;
dist[x + 1][i] = tot;
d.add(new int[]{x + 1, i, tot});
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {
int m = grid.size(), n = grid[0].size(), INF = 0x3f3f3f3f, ans = INF;
vector<vector<int>> dist(m, vector<int>(n, INF));
priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> pq;
for (int i = 0; i < n; i++) {
pq.push({0, i, grid[0][i]});
dist[0][i] = grid[0][i];
}
while (!pq.empty()) {
vector<int> info = pq.top();
pq.pop();
int x = info[0], y = info[1], cur = info[2];
if (x == m - 1) {
ans = min(ans, cur);
continue;
}
for (int i = 0; i < n; i++) {
int step = moveCost[grid[x][y]][i], ne = grid[x + 1][i];
int tot = cur + step + ne;
if (tot >= ans || dist[x + 1][i] <= tot) continue;
dist[x + 1][i] = tot;
pq.push({x + 1, i, tot});
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def minPathCost(self, grid, moveCost):
m, n, INF = len(grid), len(grid[0]), float('inf')
ans = INF
dist = [[INF] * n for _ in range(m)]
for i in range(n):
dist[0][i] = grid[0][i]
pq = [(0, i, grid[0][i]) for i in range(n)]
while pq:
x, y, cur = heapq.heappop(pq)
if x == m - 1:
ans = min(ans, cur)
continue
for i in range(n):
step, ne = moveCost[grid[x][y]][i], grid[x + 1][i]
tot = cur + step + ne
if tot >= ans or dist[x + 1][i] <= tot: continue
dist[x + 1][i] = tot
heapq.heappush(pq, (x + 1, i, tot))
return ans
```
* 时间复杂度:$O(m\log{n})$,其中 $n$ 为新图中的点数 $N \times M = 2.5 \times 10^3$,$m$ 为新图中的边数 $(M - 1) \times N^2 = 1.25 \times 10^5$
* 空间复杂度:$O(n + m)$
---
### 原地模拟
什么?你说你连图论的方法都不想用,想就着题意做一遍?
可以。甚至当你调整更新方向,还能利用已有的 `grid`,实现原地模拟。
具体的,我们将“从上往下走”调整为“从下往上走”,这样可以确保当我们使用底下一行 $grid[i + 1][j]$ 来更新当前行 $grid[i][j]$ 时,所用到的 $grid[i + 1][j]$ 不会被覆盖。
Java 代码:
```Java
class Solution {
public int minPathCost(int[][] grid, int[][] moveCost) {
int m = grid.length, n = grid[0].length, INF = 0x3f3f3f3f, ans = INF;
for (int i = m - 2; i >= 0; i--) {
for (int j = 0; j < n; j++) {
int cur = INF;
for (int k = 0; k < n; k++) cur = Math.min(cur, grid[i + 1][k] + moveCost[grid[i][j]][k]);
grid[i][j] += cur;
}
}
for (int i = 0; i < n; i++) ans = Math.min(ans, grid[0][i]);
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {
int m = grid.size(), n = grid[0].size(), INF = INT_MAX, ans = INF;
for (int i = m - 2; i >= 0; i--) {
for (int j = 0; j < n; j++) {
int cur = INF;
for (int k = 0; k < n; k++) cur = min(cur, grid[i + 1][k] + moveCost[grid[i][j]][k]);
grid[i][j] += cur;
}
}
for (int i = 0; i < n; i++) ans = min(ans, grid[0][i]);
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def minPathCost(self, grid, moveCost):
m, n = len(grid), len(grid[0])
for i in range(m - 2, -1, -1):
for j in range(n):
grid[i][j] += min([grid[i + 1][k] + moveCost[grid[i][j]][k] for k in range(n)])
return min([grid[0][i] for i in range(n)])
```
TypeScript 代码:
```TypeScript
function minPathCost(grid: number[][], moveCost: number[][]): number {
let m = grid.length, n = grid[0].length, INF = 0x3f3f3f3f, ans = INF;
for (let i = m - 2; i >= 0; i--) {
for (let j = 0; j < n; j++) {
let cur = INF;
for (let k = 0; k < n; k++) cur = Math.min(cur, grid[i + 1][k] + moveCost[grid[i][j]][k]);
grid[i][j] += cur;
}
}
for (let i = 0; i < n; i++) ans = Math.min(ans, grid[0][i]);
return ans;
};
```
* 时间复杂度:$O(m \times n^2)$,其中 $m$ 和 $n$ 分别代表给定 `grid` 的长宽
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2304` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2301-2310/2305. 公平分发饼干（中等）.md | 2305. 公平分发饼干 | https://leetcode.cn/problems/fair-distribution-of-cookies/solution/gong-shui-san-xie-jian-dan-zhuang-ya-dp-trg25/ | 中等 | [
"状压 DP",
"位运算"
] | 给你一个整数数组 `cookies`,其中 `cookies[i]` 表示在第 `i` 个零食包中的饼干数量。另给你一个整数 `k` 表示等待分发零食包的孩子数量,所有零食包都需要分发。
在同一个零食包中的所有饼干都必须分发给同一个孩子,不能分开。
分发的不公平程度定义为单个孩子在分发过程中能够获得饼干的最大总数。
返回所有分发的最小不公平程度。
示例 1:
```
输入:cookies = [8,15,10,20,8], k = 2
输出:31
解释:一种最优方案是 [8,15,8] 和 [10,20] 。
- 第 1 个孩子分到 [8,15,8] ,总计 8 + 15 + 8 = 31 块饼干。
- 第 2 个孩子分到 [10,20] ,总计 10 + 20 = 30 块饼干。
分发的不公平程度为 max(31,30) = 31 。
可以证明不存在不公平程度小于 31 的分发方案。
```
示例 2:
```
输入:cookies = [6,1,3,2,2,4,1,2], k = 3
输出:7
解释:一种最优方案是 [6,1]、[3,2,2] 和 [4,1,2] 。
- 第 1 个孩子分到 [6,1] ,总计 6 + 1 = 7 块饼干。
- 第 2 个孩子分到 [3,2,2] ,总计 3 + 2 + 2 = 7 块饼干。
- 第 3 个孩子分到 [4,1,2] ,总计 4 + 1 + 2 = 7 块饼干。
分发的不公平程度为 max(7,7,7) = 7 。
可以证明不存在不公平程度小于 7 的分发方案。
```
提示:
* $2 <= cookies.length <= 8$
* $1 <= cookies[i] <= 10^5$
* $2 <= k <= cookies.length$ | ### 状压 DP
为了方便,将 `cookies` 记为 `cs`。
**定义 $f[i][s]$ 为考虑前 $i$ 个人,对 `cs` 的分配情况为 `s` 时的最小不公平程度**。
其中 `s` 为一个二进制数,若 `s` 的第 `i` 位为 `1` 代表 `cs[i]` 已被分配,反之代表未分配。同时我们可以预处理 `g` 数组,`g[s] = t` 含义为选择 `cs` 状态为 `s` 时得到的饼干总和为 `t`。
初始化只有 $f[0][0] = 0$,其余均为正无穷 `0x3f3f3f3f`。
不失一般性考虑 $f[i][s]$ 该如何计算,**通过枚举第 $i$ 个小朋友所分配到的饼干情况 `p`(`s` 的子集)进行转移**:若第 $i$ 个小朋友分配到的饼干情况为 `p`,则此前 $i - 1$ 个小朋友分配到饼干情况为 $s - p$,前 $i - 1$ 个小朋友的最小不公平程度为 $f[i - 1][s - p]$,当前第 $i$ 个小朋友的不公平程度为 $g[p]$,两者中最大值可用于更新 $f[i][s]$。
$$
f[i][s] = \min(f[i][s], \max(f[i - 1][s - p], g[p])), p \subseteq s
$$
最终 $f[k][2^n - 1]$ 即是答案。
Java 代码:
```Java
class Solution {
public int distributeCookies(int[] cs, int k) {
int n = cs.length, mask = 1 << n, INF = 0x3f3f3f3f;
int[] g = new int[mask];
for (int s = 0; s < mask; s++) {
int t = 0;
for (int i = 0; i < n; i++) t += ((s >> i) & 1) == 1 ? cs[i] : 0;
g[s] = t;
}
int[][] f = new int[k + 10][mask];
for (int i = 0; i <= k; i++) Arrays.fill(f[i], INF);
f[0][0] = 0;
for (int i = 1; i <= k; i++) {
for (int s = 0; s < mask; s++) {
for (int p = s; p != 0; p = (p - 1) & s) {
f[i][s] = Math.min(f[i][s], Math.max(f[i - 1][s - p], g[p]));
}
}
}
return f[k][mask - 1];
}
}
```
Python 代码:
```Python
class Solution:
def distributeCookies(self, cs: List[int], k: int) -> int:
n, mask, INF = len(cs), 1 << len(cs), 0x3f3f3f3f
g = [0] * mask
for s in range(mask):
t = 0
for i in range(n):
t += cs[i] if (s >> i) & 1 == 1 else 0
g[s] = t
f = [[INF] * mask for _ in range(k + 10)]
f[0][0] = 0
for i in range(1, k + 1):
for s in range(mask):
p = s
while p != 0:
f[i][s] = min(f[i][s], max(f[i - 1][s - p], g[p]))
p = (p - 1) & s
return f[k][mask - 1]
```
C++ 代码:
```C++
class Solution {
public:
int distributeCookies(vector<int>& cs, int k) {
int n = cs.size(), mask = 1 << n, INF = 0x3f3f3f3f;
vector<int> g(mask, 0);
for (int s = 0; s < mask; s++) {
int t = 0;
for (int i = 0; i < n; i++) t += ((s >> i) & 1) == 1 ? cs[i] : 0;
g[s] = t;
}
vector<vector<int>> f(k + 10, vector<int>(mask, INF));
for (int i = 0; i <= k; i++) fill(f[i].begin(), f[i].end(), INF);
f[0][0] = 0;
for (int i = 1; i <= k; i++) {
for (int s = 0; s < mask; s++) {
for (int p = s; p != 0; p = (p - 1) & s) {
f[i][s] = min(f[i][s], max(f[i - 1][s - p], g[p]));
}
}
}
return f[k][mask - 1];
}
};
```
TypeScirpt 代码:
```TypeScript
function distributeCookies(cs: number[], k: number): number {
const n = cs.length, mask = 1 << n, INF = 0x3f3f3f3f;
const g = new Array(mask).fill(0);
for (let s = 0; s < mask; s++) {
let t = 0;
for (let i = 0; i < n; i++) t += ((s >> i) & 1) === 1 ? cs[i] : 0;
g[s] = t;
}
const f = new Array(k + 10).fill(0).map(() => new Array(mask).fill(INF));
f[0][0] = 0;
for (let i = 1; i <= k; i++) {
for (let s = 0; s < mask; s++) {
for (let p = s; p != 0; p = (p - 1) & s) {
f[i][s] = Math.min(f[i][s], Math.max(f[i - 1][s - p], g[p]));
}
}
}
return f[k][mask - 1];
};
```
* 时间复杂度:将 `cs` 长度记为 $n$,状态数量记为 $m = 2^n$,预处理复杂度为 $O(n \times m)$;`DP` 过程需要枚举二进制长度为 $n$ 的所有子集的子集,复杂度为 $O(3^n)$,`DP` 过程复杂度为 $O(k \times 3^n)$。整体复杂度为 $O(k \times 3^n)$
* 空间复杂度:$O(k \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2305` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/231. 2 的幂（简单）.md | 231. 2 的幂 | https://leetcode-cn.com/problems/power-of-two/solution/gong-shui-san-xie-2-de-mi-by-ac_oier-qm6e/ | 简单 | [
"数学",
"位运算"
] | 给你一个整数 n,请你判断该整数是否是 2 的幂次方。如果是,返回 true ;否则,返回 false 。
如果存在一个整数 x 使得 n == $2^x$ ,则认为 n 是 2 的幂次方。
示例 1:
```
输入:n = 1
输出:true
解释:20 = 1
```
示例 2:
```
输入:n = 16
输出:true
解释:24 = 16
```
示例 3:
```
输入:n = 3
输出:false
```
示例 4:
```
输入:n = 4
输出:true
```
示例 5:
```
输入:n = 5
输出:false
```
提示:
* -$2^{31}$ <= n <= $2^{31}$ - 1
进阶:你能够不使用循环/递归解决此问题吗? | ### 朴素做法
首先小于等于 $0$ 的数必然不是,$1$ 必然是。
在处理完这些边界之后,尝试将 $n$ 除干净,如果最后剩余数值为 $1$ 则说明开始是 $2$ 的幂。
代码:
```Java
class Solution {
public boolean isPowerOfTwo(int n) {
if (n <= 0) return false;
while (n % 2 == 0) n /= 2;
return n == 1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### lowbit
熟悉树状数组的同学都知道,`lowbit` 可以快速求得 `x` 二进制表示中最低位 `1` 表示的值。
如果一个数 $n$ 是 $2$ 的幂,那么有 `lowbit(n) = n` 的性质($2$ 的幂的二进制表示中必然是最高位为 $1$,低位为 $0$)。
代码;
```Java
class Solution {
public boolean isPowerOfTwo(int n) {
return n > 0 && (n & -n) == n;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.231` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/232. 用栈实现队列（简单）.md | 232. 用栈实现队列 | https://leetcode-cn.com/problems/implement-queue-using-stacks/solution/sha-shi-jun-tan-fu-za-du-ya-wo-de-suan-f-gb6d/ | 简单 | [
"栈",
"队列"
] | 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):
实现 MyQueue 类:
* void push(int x) 将元素 x 推到队列的末尾
* int pop() 从队列的开头移除并返回元素
* int peek() 返回队列开头的元素
* boolean empty() 如果队列为空,返回 true ;否则,返回 false
说明:
* 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
* 你所使用的语言也许不支持栈。你可以使用 list 或者 deque(双端队列)来模拟一个栈,只要是标准的栈操作即可。
进阶:
* 你能否实现每个操作均摊时间复杂度为 O(1) 的队列?换句话说,执行 n 个操作的总时间复杂度为 O(n) ,即使其中一个操作可能花费较长时间。
示例:
```
输入:
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出:
[null, null, null, 1, 1, false]
解释:
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
```
提示:
* 1 <= x <= 9
* 最多调用 100 次 push、pop、peek 和 empty
* 假设所有操作都是有效的 (例如,一个空的队列不会调用 pop 或者 peek 操作) | ### 基本思路
无论「用栈实现队列」还是「用队列实现栈」,思路都是类似的。
都可以通过使用两个栈/队列来解决。
我们创建两个栈,分别为 `out` 和 `in`,用作处理「输出」和「输入」操作。
其实就是两个栈来回「倒腾」。
而对于「何时倒腾」决定了是 **O(n) 解法** 还是 **均摊 O(1) 解法**。
***
### O(n) 解法
我们创建两个栈,分别为 `out` 和 `in`:
* **`in` 用作处理输入操作 `push()`,使用 `in` 时需确保 `out` 为空**
* **`out` 用作处理输出操作 `pop()` 和 `peek()`,使用 `out` 时需确保 `in` 为空**
```java
class MyQueue {
Deque<Integer> out, in;
public MyQueue() {
in = new ArrayDeque<>();
out = new ArrayDeque<>();
}
public void push(int x) {
while (!out.isEmpty()) in.addLast(out.pollLast());
in.addLast(x);
}
public int pop() {
while (!in.isEmpty()) out.addLast(in.pollLast());
return out.pollLast();
}
public int peek() {
while (!in.isEmpty()) out.addLast(in.pollLast());
return out.peekLast();
}
public boolean empty() {
return out.isEmpty() && in.isEmpty();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 均摊 O(1) 解法
事实上,我们不需要在每次的「入栈」和「出栈」操作中都进行「倒腾」。
**我们只需要保证,输入的元素总是跟在前面的输入元素的后面,而输出元素总是最早输入的那个元素即可。**
可以通过调整「倒腾」的时机来确保满足上述要求,但又不需要发生在每一次操作中:
* **只有在「输出栈」为空的时候,才发生一次性的「倒腾」**
```java
class MyQueue {
Deque<Integer> out, in;
public MyQueue() {
in = new ArrayDeque<>();
out = new ArrayDeque<>();
}
public void push(int x) {
in.addLast(x);
}
public int pop() {
if (out.isEmpty()) {
while (!in.isEmpty()) out.addLast(in.pollLast());
}
return out.pollLast();
}
public int peek() {
if (out.isEmpty()) {
while (!in.isEmpty()) out.addLast(in.pollLast());
}
return out.peekLast();
}
public boolean empty() {
return out.isEmpty() && in.isEmpty();
}
}
```
* 时间复杂度:`pop()` 和 `peek()` 操作都是均摊 $O(1)$
* 空间复杂度:$O(n)$
***
### 关于「均摊复杂度」的说明
我们先用另外一个例子来理解「均摊复杂度」,大家都知道「哈希表」底层是通过数组实现的。
正常情况下,计算元素在哈希桶的位置,然后放入哈希桶,复杂度为 $O(1)$,假定是通过简单的“拉链法”搭配「头插法」方式来解决哈希冲突。
但当某次元素插入后,「哈希表」达到扩容阈值,则需要对底层所使用的数组进行扩容,这个复杂度是 $O(n)$
显然「扩容」操作不会发生在每一次的元素插入中,因此扩容的 $O(n)$ 都会伴随着 `n` 次的 $O(1)$,也就是 $O(n)$ 的复杂度会被均摊到每一次插入当中,因此哈希表插入仍然是 $O(1)$ 的。
**同理,我们的「倒腾」不是发生在每一次的「输出操作」中,而是集中发生在一次「输出栈为空」的时候,因此 `pop` 和 `peek` 都是均摊复杂度为 $O(1)$ 的操作。**
由于本题的调用次数只有 100 次,所以铁定是一个人均 100% 的算法(0 ms)🐶 🐶
我们需要对操作进行复杂度分析进行判断,而不是看时间来判断自己是不是均摊 O(1) 哦 ~ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.232` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/233. 数字 1 的个数（困难）.md | 233. 数字 1 的个数 | https://leetcode-cn.com/problems/number-of-digit-one/solution/gong-shui-san-xie-jiang-shu-wei-dp-wen-t-c9oi/ | 困难 | [
"动态规划",
"数位 DP",
"模拟"
] | 给定一个整数 $n$,计算所有小于等于 $n$ 的非负整数中数字 $1$ 出现的个数。
示例 1:
```
输入:n = 13
输出:6
```
示例 2:
```
输入:n = 0
输出:0
```
提示:
* 0 <= n <= $2 * 10^9$ | ### 基本分析
这是一道经典的「数位 DP」模板题的简化版,原题在 [这里](https://www.luogu.com.cn/problem/P1980) 。
这几天每日一题出得挺好,「序列 DP」、「区间 DP」、「数位 DP」轮着来 🤣
但由于本题只需求 $1$ 出现的次数,而不需要求解 $0$ 到 $9$ 的出现次数,同时意味着不需要考虑统计 $0$ 次数时的前导零边界问题。
因此,也可以不当作数位 DP 题来做,只当作一道计数类模拟题来求解。
---
### 计数类模拟
回到本题,我们需要计算 $[1, n]$ 范围内所有数中 $1$ 出现的次数。
我们可以统计 $1$ 在每一位出现的次数,将其累加起来即是答案。
举个 🌰,对于一个长度为 $m$ 的数字 $n$,我们可以计算其在「个位(从右起第 $1$ 位)」、「十位(第 $2$ 位)」、「百位(第 $3$ 位)」和「第 $m$ 位」中 $1$ 出现的次数。
假设有 $n = abcde$,即 $m = 5$,假设我们需要统计第 $3$ 位中 $1$ 出现的次数,即可统计满足 $--1--$ 形式,同时满足 $1 <= --1-- <= abcde$ 要求的数有多少个,我们称 $1 <= --1-- <= abcde$ 关系为「大小要求」。
我们只需对 $c$ 前后出现的值进行分情况讨论:
* 当 $c$ 前面的部分 $< ab$,即范围为 $[0, ab)$,此时必然满足「大小要求」,因此后面的部分可以任意取,即范围为 $[0, 99]$。根据「乘法原理」,可得知此时数量为 $ab * 100$;
* 当 $c$ 前面的部分 $= ab$,这时候「大小关系」主要取决于 $c$:
* 当 $c = 0$,必然不满足「大小要求」,数量为 $0$;
* 当 $c = 1$,此时「大小关系」取决于后部分,后面的取值范围为 $[0, de]$,数量为 $1 * (de + 1)$;
* 当 $c > 1$,必然满足「大小关系」,后面的部分可以任意取,即范围为 $[0, 99]$,数量为 $1 * 100$;
* 当 $c$ 前面的部分 $> ab$,必然不满足「大小要求」,数量为 $0$。
其他数位的分析同理。
代码:
```Java
class Solution {
public int countDigitOne(int n) {
String s = String.valueOf(n);
int m = s.length();
if (m == 1) return n > 0 ? 1 : 0;
// 计算第 i 位前缀代表的数值,和后缀代表的数值
// 例如 abcde 则有 ps[2] = ab; ss[2] = de
int[] ps = new int[m], ss = new int[m];
ss[0] = Integer.parseInt(s.substring(1));
for (int i = 1; i < m - 1; i++) {
ps[i] = Integer.parseInt(s.substring(0, i));
ss[i] = Integer.parseInt(s.substring(i + 1));
}
ps[m - 1] = Integer.parseInt(s.substring(0, m - 1));
// 分情况讨论
int ans = 0;
for (int i = 0; i < m; i++) {
// x 为当前位数值,len 为当前位后面长度为多少
int x = s.charAt(i) - '0', len = m - i - 1;
int prefix = ps[i], suffix = ss[i];
int tot = 0;
tot += prefix * Math.pow(10, len);
if (x == 0) {
} else if (x == 1) {
tot += suffix + 1;
} else {
tot += Math.pow(10, len);
}
ans += tot;
}
return ans;
}
}
```
* 时间复杂度:$O(m)$
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.233` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/235. 二叉搜索树的最近公共祖先（中等）.md | 235. 二叉搜索树的最近公共祖先 | https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/solution/gong-shui-san-xie-yun-yong-dfs-qiu-jie-l-n3jh/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 `T` 的两个结点 `p`、`q`,最近公共祖先表示为一个结点 `x`,满足 `x` 是 `p`、`q` 的祖先且 `x` 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉搜索树: `root = [6,2,8,0,4,7,9,null,null,3,5]`
示例 1:
```
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。
```
示例 2:
```
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
```
说明:
* 所有节点的值都是唯一的。
* `p`、`q` 为不同节点且均存在于给定的二叉搜索树中。 | ### DFS
也是常见的 `LCA` 问题,但相比 [236. 二叉树的最近公共祖先](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247500218&idx=1&sn=a6d790dcecfee353be5f3b53c312c3d4&chksm=fd9f6aa5cae8e3b36d85448674b189ed2d35fdce18381ac7676ec90a33d62da05718f85e3103#rd),本题搜索对象为二叉搜索树,利用此特性,我们可以将搜索复杂度从 $O(n)$ 优化至 $O(h)$。
利用原函数作为递归函数,复用 `root` 作为搜索过程中的当前节点,根据 `root` 和两节点关系进行分情况讨论:
* 若 `root` 为 `p` 和 `q` 中的任一节点:由于搜索过程是从上往下,因此 `root` 必然是距离两者垂直距离最远的最近公共祖先,返回 `root`;
* 否则根据 `root` 和 `p`、`q` 的节点值大小进一步讨论,将 `root` 节点值记为 `a`,两节点值中的较小值记为 `b`,两节点中的较大值记为 `c`:
* 若有 $b < a < c$,说明 `p` 和 `q` 中值较小的节点在当前节点 `root` 的左子树内,`p` 和 `q` 中值较大的节点在当前节点 `root` 的右子树内。由于搜索过程是从上往下,因此 `root` 作为首个满足该条件的节点,必然是距离两者垂直距离最远的最近公共祖先,返回 `root`;
* 若有 $a < b$,说明两节点均在当前节点 `root` 的右子树内,递归处理 `root.right`;
* 若有 $a > c$,说明两节点均在当前节点 `root` 的左子树内,递归处理 `root.left`。
Java 代码:
```Java
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == p || root == q) return root;
int a = root.val, b = Math.min(p.val, q.val), c = Math.max(p.val, q.val);
if (a > b && a < c) return root;
else if (a < b) return lowestCommonAncestor(root.right, p, q);
else return lowestCommonAncestor(root.left, p, q);
}
}
```
C++ 代码:
```C++
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if (root == p || root == q) return root;
int a = root->val, b = min(p->val, q->val), c = max(p->val, q->val);
if (a > b && a < c) return root;
else if (a < b) return lowestCommonAncestor(root->right, p, q);
else return lowestCommonAncestor(root->left, p, q);
}
};
```
Python 代码:
```Python
class Solution:
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
if root == p or root == q:
return root
a, b = root.val, min(p.val, q.val)
c = max(p.val, q.val)
if a > b and a < c:
return root
elif a < b:
return self.lowestCommonAncestor(root.right, p, q)
else:
return self.lowestCommonAncestor(root.left, p, q)
```
TypeScript 代码:
```TypeScript
function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
if (root === p || root === q) return root;
const a = root.val, b = Math.min(p.val, q.val), c = Math.max(p.val, q.val);
if (a > b && a < c) return root;
else if (a < b) return lowestCommonAncestor(root.right, p, q);
else return lowestCommonAncestor(root.left, p, q);
};
```
* 时间复杂度:$O(h)$,其中 $h$ 为二叉搜索树的深度
* 空间复杂度:$O(h)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.235` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/236. 二叉树的最近公共祖先（中等）.md | 236. 二叉树的最近公共祖先 | https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/solutions/2402113/gong-shui-san-xie-yun-yong-dfs-qiu-jie-l-htd9/ | 中等 | [
"二叉树",
"DFS",
"递归"
] | 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为:“对于有根树 T 的两个节点 `p`、`q`,最近公共祖先表示为一个节点 `x`,满足 `x` 是 `p`、`q` 的祖先且 `x` 的深度尽可能大(一个节点也可以是它自己的祖先)。”
示例 1:
```
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出:3
解释:节点 5 和节点 1 的最近公共祖先是节点 3 。
```
示例 2:
```
输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出:5
解释:节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。
```
示例 3:
```
输入:root = [1,2], p = 1, q = 2
输出:1
```
提示:
* 树中节点数目在范围 $[2, 10^5]$ 内。
* $-10^9 <= Node.val <= 10^9$
* 所有 `Node.val` 互不相同 。
* $p != q$
* `p` 和 `q` 均存在于给定的二叉树中。 | ### DFS
常见的 `LCA` 问题。
设计 `DFS` 函数 `boolean dfs(TreeNode cur, TreeNode t, List<TreeNode> path)`:其中 **`cur` 为当前处理到的节点,`t` 为需要找到的目的节点,`path` 为从根节点到当前节点 `cur` 所经过的路径**。若能够以当前节点 `cur` 为根的子树包含目标节点 `t`,函数返回 `true`,否则返回 `false`。z
调用函数分别传入 `p` 和 `q` 作为目标节点,从而得到从根节点到 `p` 和 `q` 的路径列表,遍历路径找到最后一个相同的节点即是答案。
Java 代码:
```Java
class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
List<TreeNode> a = new ArrayList<>(), b = new ArrayList<>();
dfs(root, p, a); dfs(root, q, b);
TreeNode ans = null;
for (int i = 0; i < Math.min(a.size(), b.size()) && a.get(i) == b.get(i); i++) ans = a.get(i);
return ans;
}
boolean dfs(TreeNode cur, TreeNode t, List<TreeNode> path) {
if (cur == null) return false;
path.add(cur);
if (cur == t || dfs(cur.left, t, path) || dfs(cur.right, t, path)) {
return true;
} else {
path.remove(path.size() - 1);
return false;
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
vector<TreeNode*> a, b;
dfs(root, p, a); dfs(root, q, b);
TreeNode* ans = nullptr;
for (int i = 0; i < min(a.size(), b.size()) && a[i] == b[i]; i++) ans = a[i];
return ans;
}
bool dfs(TreeNode* cur, TreeNode* t, vector<TreeNode*>& path) {
if (!cur) return false;
path.push_back(cur);
if (cur == t || dfs(cur->left, t, path) || dfs(cur->right, t, path)) {
return true;
} else {
path.pop_back();
return false;
}
}
};
```
Python 代码:
```Python
class Solution:
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
def dfs(cur, t, path):
if not cur:
return False
path.append(cur)
if cur == t or dfs(cur.left, t, path) or dfs(cur.right, t, path):
return True
else:
path.pop()
return False
a, b = [], []
dfs(root, p, a)
dfs(root, q, b)
ans = None
for i in range(min(len(a), len(b))):
if a[i] == b[i]:
ans = a[i]
return ans
```
TypeScript 代码:
```TypeScript
function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
const a = [], b = [];
dfs(root, p, a);
dfs(root, q, b);
let ans = null;
for (let i = 0; i < Math.min(a.length, b.length) && a[i] === b[i]; i++) ans = a[i];
return ans;
}
function dfs(cur: TreeNode | null, t: TreeNode | null, path: TreeNode[]): boolean {
if (!cur) return false;
path.push(cur);
if (cur === t || dfs(cur.left, t, path) || dfs(cur.right, t, path)) {
return true;
} else {
path.pop();
return false;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.236` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/237. 删除链表中的节点（简单）.md | 237. 删除链表中的节点 | https://leetcode-cn.com/problems/delete-node-in-a-linked-list/solution/gong-shui-san-xie-jian-dan-lian-biao-mo-rovcb/ | 简单 | [
"模拟",
"链表",
"脑筋急转弯"
] | 请编写一个函数,用于**删除单链表中某个特定节点 **。
在设计函数时需要注意,你无法访问链表的头节点 head ,只能直接访问**要被删除的节点**。
题目数据保证需要删除的节点 不是末尾节点 。
示例 1:
```
输入:head = [4,5,1,9], node = 5
输出:[4,1,9]
解释:指定链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9
```
示例 2:
```
输入:head = [4,5,1,9], node = 1
输出:[4,5,9]
解释:指定链表中值为 1 的第三个节点,那么在调用了你的函数之后,该链表应变为 4 -> 5 -> 9
```
示例 3:
```
输入:head = [1,2,3,4], node = 3
输出:[1,2,4]
```
示例 4:
```
输入:head = [0,1], node = 0
输出:[1]
```
示例 5:
```
输入:head = [-3,5,-99], node = -3
输出:[5,-99]
```
提示:
* 链表中节点的数目范围是 [2, 1000]
* -1000 <= Node.val <= 1000
* 链表中每个节点的值都是唯一的
* 需要删除的节点 node 是 链表中的一个有效节点 ,且 不是末尾节点 | ### 模拟
对于一般性的链表删除操作而言,我们需要知道待删除节点的前一节点与后一节点,并对两者建立联系。
对于本题,由于我们只知道待删除节点本身,同时该链表为单链表(无法访问前一节点),因此我们只能先将后一节点的值复制到当前节点,然后将后一节点当作「待删除节点」来进行常规删除。
代码:
```Java
class Solution {
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.237` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/238. 除自身以外数组的乘积（中等）.md | 238. 除自身以外数组的乘积 | https://leetcode.cn/problems/product-of-array-except-self/solution/by-ac_oier-fqp3/ | 中等 | [
"前缀和",
"容斥原理"
] | 给你一个整数数组 `nums`,返回 数组 `answer`,其中 $answer[i]$ 等于 `nums` 中除 $nums[i]$ 之外其余各元素的乘积 。
题目数据 保证 数组 `nums` 之中任意元素的全部前缀元素和后缀的乘积都在 $32$ 位 整数范围内。
请不要使用除法,且在 $O(n)$ 时间复杂度内完成此题。
示例 1:
```
输入: nums = [1,2,3,4]
输出: [24,12,8,6]
```
示例 2:
```
输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]
```
提示:
* $2 <= nums.length <= 10^5$
* $-30 <= nums[i] <= 30$
* 保证 数组 `nums` 之中任意元素的全部前缀元素和后缀的乘积都在 $32$ 位 整数范围内
进阶:你可以在 $O(1)$ 的额外空间复杂度内完成这个题目吗?( 出于对空间复杂度分析的目的,输出数组不被视为额外空间。) | ### 前缀和
根据题意,对于每个 $ans[i]$ 均由两部分组成:
$$
(nums[0] \times nums[1] \times ... \times nums[i - 1]) \times (nums[i + 1] \times nums[i + 2] \times ... \times nums[n - 1])
$$
因此我们可以运用「前缀和」思想,使用数组 `s1` 和 `s2` 分别计算范围 $[1, x]$ 的前缀乘 和 范围 $[x, n]$ 的后缀乘法(前缀和数组下标默认从 $1$ 开始),即 $s1[i]$ 代表范围 $[1,i]$ 的前缀乘值,$s2[i]$ 代表范围 $[i, n]$ 的后缀乘值。
预处理完 `s1` 和 `s2` 之后,即可计算每个 $ans[i - 1] = s1[i - 1] \times s2[i + 1]$(`ans` 数组下标从 $0$ 开始)。
Java 代码:
```Java
class Solution {
public int[] productExceptSelf(int[] nums) {
int n = nums.length;
int[] s1 = new int[n + 10], s2 = new int[n + 10];
s1[0] = s2[n + 1] = 1;
for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] * nums[i - 1];
for (int i = n; i >= 1; i--) s2[i] = s2[i + 1] * nums[i - 1];
int[] ans = new int[n];
for (int i = 1; i <= n; i++) ans[i - 1] = s1[i - 1] * s2[i + 1];
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
int n = nums.size();
vector<int> s1(n + 2, 1), s2(n + 2, 1);
for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] * nums[i - 1];
for (int i = n; i >= 1; i--) s2[i] = s2[i + 1] * nums[i - 1];
vector<int> ans(n);
for (int i = 1; i <= n; i++) ans[i - 1] = s1[i - 1] * s2[i + 1];
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
n = len(nums)
s1, s2 = [1] * (n + 2), [1] * (n + 2)
for i in range(1, n + 1):
s1[i] = s1[i - 1] * nums[i - 1]
for i in range(n, 0, -1):
s2[i] = s2[i + 1] * nums[i - 1]
ans = [s1[i - 1] * s2[i + 1] for i in range(1, n + 1)]
return ans
```
TypeScript 代码:
```TypeScript
function productExceptSelf(nums: number[]): number[] {
const n = nums.length;
const s1 = new Array(n + 2).fill(1), s2 = new Array(n + 2).fill(1);
for (let i = 1; i <= n; i++) s1[i] = s1[i - 1] * nums[i - 1];
for (let i = n; i >= 1; i--) s2[i] = s2[i + 1] * nums[i - 1];
const ans = new Array(n);
for (let i = 1; i <= n; i++) ans[i - 1] = s1[i - 1] * s2[i + 1];
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 前缀和(空间优化)
题目的进阶部分要求我们使用 $O(1)$ 空间来做(不算 `ans` 数组)。
这样很好处理,按照我们解法一的思路,将两部分分开算即可:建立 `ans` 数组,先从前往后遍历 `nums`,计算每个 $ans[i]$ 前缀乘值部分,再从后往前遍历 `nums`,计算每个 $ans[i]$ 后缀乘值的部分,两部分相乘即是最终的 $ans[i]$。
Java 代码:
```Java
class Solution {
public int[] productExceptSelf(int[] nums) {
int n = nums.length;
int[] ans = new int[n];
for (int i = 1, j = 1; i <= n; i++) {
ans[i - 1] = j; j *= nums[i - 1];
}
for (int i = n, j = 1; i >= 1; i--) {
ans[i - 1] *= j; j *= nums[i - 1];
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
int n = nums.size();
vector<int> ans(n, 1);
for (int i = 1, j = 1; i <= n; i++) {
ans[i - 1] = j; j *= nums[i - 1];
}
for (int i = n, j = 1; i >= 1; i--) {
ans[i - 1] *= j; j *= nums[i - 1];
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
n = len(nums)
ans = [1] * n
j = 1
for i in range(1, n + 1):
ans[i - 1] *= j
j *= nums[i - 1]
j = 1
for i in range(n, 0, -1):
ans[i - 1] *= j
j *= nums[i - 1]
return ans
```
TypeScript 代码:
```TypeScript
function productExceptSelf(nums: number[]): number[] {
const n = nums.length;
const ans = new Array(n).fill(1);
for (let i = 1, j = 1; i <= n; i++) {
ans[i - 1] *= j; j *= nums[i - 1];
}
for (let i = n, j = 1; i >= 1; i--) {
ans[i - 1] *= j; j *= nums[i - 1];
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.238` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/239. 滑动窗口最大值（困难）.md | 239. 滑动窗口最大值 | https://leetcode.cn/problems/sliding-window-maximum/solution/by-ac_oier-o89l/ | 困难 | [
"优先队列(堆)",
"线段树",
"分块",
"单调队列",
"RMQ"
] | 给你一个整数数组 `nums`,有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值 。
示例 1:
```
输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
输出:[3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
```
示例 2:
```
输入:nums = [1], k = 1
输出:[1]
```
提示:
* $1 <= nums.length <= 10^5$
* $-10^4 <= nums[i] <= 10^4$
* $1 <= k <= nums.length$ | ### 优先队列(堆)
根据题意,容易想到优先队列(大根堆),同时为了确保滑动窗口的大小合法性,我们以二元组 $(idx, nums[idx])$ 的形式进行入队。
当下标达到首个滑动窗口的右端点后,每次尝试从优先队列(大根堆)中取出最大值(若堆顶元素的下标小于当前滑动窗口左端点时,则丢弃该元素)。
代码:
```Java
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->b[1]-a[1]);
int n = nums.length, m = n - k + 1, idx = 0;
int[] ans = new int[m];
for (int i = 0; i < n; i++) {
q.add(new int[]{i, nums[i]});
if (i >= k - 1) {
while (q.peek()[0] <= i - k) q.poll();
ans[idx++] = q.peek()[1];
}
}
return ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 线段树
容易将问题转换为「区间求和」问题:使用原始的 `nums` 构建线段树等价于在位置 $i$ 插入 $nums[i]$,即单点操作,而查询每个滑动窗口最大值,则对应的区间查询。
由于只涉及单点修改,无须实现懒标记 `pushdown` 操作,再结合 $n$ 的数据范围为 $10^5$,无须进行动态开点。
直接写 `build` 四倍空间的线段树数组实现即可。
代码:
```Java
class Solution {
class Node {
int l, r, val;
Node (int _l, int _r) {
l = _l; r = _r; val = Integer.MIN_VALUE;
}
}
Node[] tr = new Node[100010 * 4];
void build(int u, int l, int r) {
tr[u] = new Node(l, r);
if (l == r) return ;
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
}
void update(int u, int x, int v) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].val = Math.max(tr[u].val, v);
return ;
}
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) update(u << 1, x, v);
else update(u << 1 | 1, x, v);
pushup(u);
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;
int mid = tr[u].l + tr[u].r >> 1, ans = Integer.MIN_VALUE;
if (l <= mid) ans = query(u << 1, l, r);
if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));
return ans;
}
void pushup(int u) {
tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val);
}
public int[] maxSlidingWindow(int[] nums, int k) {
int n = nums.length, m = n - k + 1;
int[] ans = new int[m];
build(1, 1, n);
for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);
for (int i = k; i <= n; i++) ans[i - k] = query(1, i - k + 1, i);
return ans;
}
}
```
* 时间复杂度:建立线段树复杂度为 $O(n\log{n})$;构建答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 分块
另外一个做法是分块,又名「优雅的暴力」,也是莫队算法的基础。
具体的,除了给定的 `nums` 以外,我们构建一个分块数组 `region`,其中 `region[idx] = x` 含义为块编号为 `idx` 的最大值为 `x`,其中一个块对应一个原始区间 $[l, r]$。
如何定义块大小是实现分块算法的关键。
对于本题,本质是求若干个大小为 $k$ 的区间最大值。
我们可以设定块大小为 $\sqrt{k}$,这样所需创建的分块数组大小为 $\frac{n}{\sqrt{k}}$。分块数组的更新操作为 $O(1)$,而查询则为 $\sqrt{k}$。
容易证明查询操作的复杂度:对于每个长度为 $k$ 的 $[l, r]$ 查询操作而言,最多遍历两个(左右端点对应的块)的块内元素,复杂度为 $O(\sqrt{k})$,同时最多遍历 $\sqrt{k}$ 个块,复杂度同为 $O(\sqrt{k})$。
因此最多两步复杂度为 $O(\sqrt{k})$ 的块内操作,最多 $\sqrt{k}$ 步复杂度为 $O(1)$ 的块间操作,整体复杂度为 $O(\sqrt{k})$。
因此使用分块算法总的计算量为 $n\times\sqrt{k} = 10^6$,可以过。
分块算法的几个操作函数:
* `int getIdx(int x)` :计算原始下标对应的块编号;
* `void add(int x, int v)` :计算原始下标 `x` 对应的下标 `idx`,并将 `region[idx]` 和 `v` 取 `max` 来更新 `region[idx]`;
* `int query(int l, int r)` :查询 $[l, r]$ 中的最大值,如果 $l$ 和 $r$ 所在块相同,直接遍历 $[l, r]$ 进行取值;若 $l$ 和 $r$ 不同块,则处理 $l$ 和 $r$ 对应的块内元素后,对块编号在 $(getIdx(l), getIdx(r))$ 之间的块进行遍历。
代码:
```Java
class Solution {
int n, m, len;
int[] nums, region;
int getIdx(int x) {
return x / len;
}
void add(int x, int v) {
region[getIdx(x)] = Math.max(region[getIdx(x)], v);
}
int query(int l, int r) {
int ans = Integer.MIN_VALUE;
if (getIdx(l) == getIdx(r)) {
for (int i = l; i <= r; i++) ans = Math.max(ans, nums[i]);
} else {
int i = l, j = r;
while (getIdx(i) == getIdx(l)) ans = Math.max(ans, nums[i++]);
while (getIdx(j) == getIdx(r)) ans = Math.max(ans, nums[j--]);
for (int k = getIdx(i); k <= getIdx(j); k++) ans = Math.max(ans, region[k]);
}
return ans;
}
public int[] maxSlidingWindow(int[] _nums, int k) {
nums = _nums;
n = nums.length; len = (int) Math.sqrt(k); m = n / len + 10;
region = new int[m];
Arrays.fill(region, Integer.MIN_VALUE);
for (int i = 0; i < n; i++) add(i, nums[i]);
int[] ans = new int[n - k + 1];
for (int i = 0; i < n - k + 1; i++) ans[i] = query(i, i + k - 1);
return ans;
}
}
```
* 时间复杂度:数组大小为 $n$,块大小为 $\sqrt{k}$,分块数组大小为 $\frac{n}{\sqrt{k}}$。预处理分块数组复杂度为 $O(n)$(即 `add` 操作复杂度为 $O(1)$ );构造答案复杂度为 $O(n\times\sqrt{k})$(即 `query` 操作复杂度为 $O(\sqrt{k})$,最多有 $n$ 次查询)
* 空间复杂度:$\frac{n}{\sqrt{k}}$
---
### 单调队列
关于 `RMQ` 的另外一个优秀做法通常是使用「单调队列/单调栈」。
当然,我们也能不依靠经验,而从问题的本身出发,逐步分析出该做法。
假设我们当前处理到某个长度为 $k$ 的窗口,此时窗口往后滑动一格,会导致后一个数(新窗口的右端点)添加进来,同时会导致前一个数(旧窗口的左端点)移出窗口。
随着窗口的不断平移,该过程会一直发生。**若同一时刻存在两个数 $nums[j]$ 和 $nums[i]$($j < i$)所在一个窗口内,下标更大的数会被更晚移出窗口,此时如果有 $nums[j] <= nums[i]$ 的话,可以完全确定 $nums[j]$ 将不会成为后续任何一个窗口的最大值,此时可以将必然不会是答案的 $nums[j]$ 从候选中进行移除**。
不难发现,当我们将所有必然不可能作为答案的元素(即所有满足的小于等于 $nums[i]$ )移除后,候选集合满足「单调递减」特性,即集合首位元素为当前窗口中的最大值(为了满足窗口长度为 $k$ 的要求,在从集合头部取答案时需要先将下标小于的等于的 $i - k$ 的元素移除)。
为方便从尾部添加元素,从头部获取答案,我们可使用「双端队列」存储所有候选元素。
代码:
```Java
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
Deque<Integer> d = new ArrayDeque<>();
int n = nums.length, m = n - k + 1;
int[] ans = new int[m];
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && nums[d.peekLast()] <= nums[i]) d.pollLast();
d.addLast(i);
if (i >= k - 1) {
while (!d.isEmpty() && d.peekFirst() <= i - k) d.pollFirst();
ans[i - k + 1] = nums[d.peekFirst()];
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.239` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/231-240/240. 搜索二维矩阵 II（中等）.md | 240. 搜索二维矩阵 II | https://leetcode-cn.com/problems/search-a-2d-matrix-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-y1ns/ | 中等 | [
"二分",
"二叉搜索树",
"模拟"
] | 编写一个高效的算法来搜索 `m x n` 矩阵 `matrix` 中的一个目标值 `target` 。
该矩阵具有以下特性:
* 每行的元素从左到右升序排列。
* 每列的元素从上到下升序排列。
示例 1:
```
输入:matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
输出:true
```
示例 2:
```
输入:matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
输出:false
```
提示:
* m == matrix.length
* n == matrix[i].length
* 1 <= n, m <= 300
* $-10^9 <= matrix[i][j] <= 10^9$
* 每行的所有元素从左到右升序排列
* 每列的所有元素从上到下升序排列
* $-10^9 <= target <= 10^9$ | ### 前言
这道题和之前的[(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 类似,建议你将两题放到一起去做。
---
### 二分
与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 不同,本题没有确保「每行的第一个整数大于前一行的最后一个整数」,因此我们无法采取「两次二分」的做法。
只能退而求之,遍历行/列,然后再对列/行进行二分。
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length, n = matrix[0].length;
for (int i = 0; i < m; i++) {
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (matrix[i][mid] <= target) l = mid;
else r = mid - 1;
}
if (matrix[i][r] == target) return true;
}
return false;
}
}
```
```Java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length, n = matrix[0].length;
for (int i = 0; i < n; i++) {
int l = 0, r = m - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (matrix[mid][i] <= target) l = mid;
else r = mid - 1;
}
if (matrix[r][i] == target) return true;
}
return false;
}
}
```
* 时间复杂度:$O(m\log{n})$ 或 $O(n\log{m})$
* 空间复杂度:$O(1)$
---
### 抽象 BST
该做法则与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 的「解法二」完全一致。
我们可以将二维矩阵抽象成「以右上角为根的 BST」:
那么我们可以从根(右上角)开始搜索,如果当前的节点不等于目标值,可以按照树的搜索顺序进行:
1. 当前节点「大于」目标值,搜索当前节点的「左子树」,也就是当前矩阵位置的「左方格子」,即 $c$--
2. 当前节点「小于」目标值,搜索当前节点的「右子树」,也就是当前矩阵位置的「下方格子」,即 $r$++
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length, n = matrix[0].length;
int r = 0, c = n - 1;
while (r < m && c >= 0) {
if (matrix[r][c] < target) r++;
else if (matrix[r][c] > target) c--;
else return true;
}
return false;
}
}
```
* 时间复杂度:$O(m + n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.240` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2331-2340/2335. 装满杯子需要的最短总时长（简单）.md | 2335. 装满杯子需要的最短总时长 | https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247495870&idx=1&sn=a15b87852faaa33fc9d976b575ef1099 | 简单 | [
"排序",
"递归",
"模拟",
"贪心",
"数学"
] | 现有一台饮水机,可以制备冷水、温水和热水。每秒钟,可以装满 `2` 杯 不同 类型的水或者 `1` 杯任意类型的水。
给你一个下标从 `0` 开始、长度为 `3` 的整数数组 `amount`,其中 `amount[0]`、`amount[1]` 和 `amount[2]` 分别表示需要装满冷水、温水和热水的杯子数量。
返回装满所有杯子所需的 **最少** 秒数。
示例 1:
```
输入:amount = [1,4,2]
输出:4
解释:下面给出一种方案:
第 1 秒:装满一杯冷水和一杯温水。
第 2 秒:装满一杯温水和一杯热水。
第 3 秒:装满一杯温水和一杯热水。
第 4 秒:装满一杯温水。
可以证明最少需要 4 秒才能装满所有杯子。
```
示例 2:
```
输入:amount = [5,4,4]
输出:7
解释:下面给出一种方案:
第 1 秒:装满一杯冷水和一杯热水。
第 2 秒:装满一杯冷水和一杯温水。
第 3 秒:装满一杯冷水和一杯温水。
第 4 秒:装满一杯温水和一杯热水。
第 5 秒:装满一杯冷水和一杯热水。
第 6 秒:装满一杯冷水和一杯温水。
第 7 秒:装满一杯热水。
```
示例 3:
```
输入:amount = [5,0,0]
输出:5
解释:每秒装满一杯冷水。
```
提示:
* $amount.length = 3$
* $0 <= amount[i] <= 100$ | ### 排序 + 递归
水的种类固定为 `3`,且每种水的数据范围只有 $100$,可直接使用递归进行求解。
为了尽可能的凑成多的对数,我们可以每次取剩余数量最多且不为 `0` 的两类水进行成组(因此每次处理前需要先对当前 `amount` 进行排序),直到没有水剩余,或只有一类水的剩余数据量不为 `0`(剩下的水只能独自生成)。
Java 代码:
```Java
class Solution {
public int fillCups(int[] amount) {
Arrays.sort(amount);
if (amount[1] == 0) return amount[2];
amount[1]--; amount[2]--;
return 1 + fillCups(amount);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int fillCups(vector<int>& amount) {
sort(amount.begin(), amount.end());
if (amount[1] == 0) return amount[2];
amount[1]--; amount[2]--;
return 1 + fillCups(amount);
}
};
```
Python 代码:
```Python
class Solution:
def fillCups(self, amount: List[int]) -> int:
amount.sort()
if amount[1] == 0:
return amount[2]
amount[1] -= 1
amount[2] -= 1
return 1 + self.fillCups(amount)
```
TypeScript 代码:
```TypeScript
function fillCups(amount: number[]): number {
amount.sort((a, b) => a - b);
if (amount[1] === 0) return amount[2];
amount[1] -= 1;
amount[2] -= 1;
return 1 + fillCups(amount);
};
```
* 时间复杂度:由于 `amount` 的长度固定为 `3`,因此排序消耗可视为常量;每次至少会消耗两杯水,直到递归结束或只剩下一种水。复杂度为 $O(\sum_{i = 0}^{2} amount[i])$
* 空间复杂度:忽略递归和排序带来的额外空间开销,复杂度为 $O(1)$
---
### 贪心 + 数学
我们已经知道可以通过「每次取剩余数量最多且不为 `0` 的水成对」来实现最少生成次数。
那么是否存在直接计算最少生成次数的方法,而不是采用逐回合模拟。
考虑对 `amount` 进行排序,分别使用 `a`、`b` 和 `c` 代表剩余次数递增的三种种类。
根据 $a + b$ 和 $c$ 的大小关系进行分情况讨论:
* $a + b \leq c$,此时每消耗一个 $c$ 都可以顺带消除一个 $a$ 或 $b$,因此最少生成次数为 $c$;
* $a + b > c$,此时考虑其之间的差值 $t = a + b - c$,若能顺利通过 $\frac{t}{2}$ 次对 $a$ 和 $b$ 的合并,可以将局面转成情况一,最少生成次数为 $\frac{t}{2} + c$;
考虑起始是否能先对 $a$ 和 $b$ 进行 $\frac{t}{2}$ 个回合,由于我们有 $a \leq b$,我们只需考虑是否必然有 $a \geq \frac{t}{2}$ 即可,可通过反证法证明 $a < \frac{t}{2}$ 必然不成立,若有 $a < \frac{t}{2}$,则有 $2a < a + b - c$ => $a < b - c$,由于 $b \leq c$,则有 $a < 0$,与原条件冲突。
最后,为了处理 $t$ 的奇偶性问题,先用 $a$ 和 $b$ 进行 $\left \lceil \frac{a + b - c}{2} \right \rceil$ 抵消操作,再与 $c$ 进行抵消
Java 代码:
```Java
class Solution {
public int fillCups(int[] amount) {
Arrays.sort(amount);
int a = amount[0], b = amount[1], c = amount[2];
if (a + b <= c) return c;
else return (a + b - c + 1) / 2 + c;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int fillCups(vector<int>& amount) {
sort(amount.begin(), amount.end());
int a = amount[0], b = amount[1], c = amount[2];
if (a + b <= c) return c;
else return (a + b - c + 1) / 2 + c;
}
};
```
Python 代码:
```Python
class Solution:
def fillCups(self, amount: List[int]) -> int:
amount.sort()
a, b, c = amount
if a + b <= c:
return c
else:
return (a + b - c + 1) // 2 + c
```
TypeScript 代码:
```TypeScript
function fillCups(amount: number[]): number {
amount.sort((a, b) => a - b);
const [a, b, c] = amount;
if (a + b <= c) return c;
else return Math.floor((a + b - c + 1) / 2) + c;
};
```
* 时间复杂度:由于 `amount` 的长度固定为 `3`,因此排序消耗可视为常量,整体复杂度为 $O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2335` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2331-2340/2336. 无限集中的最小数字（中等）.md | 2336. 无限集中的最小数字 | https://leetcode.cn/problems/smallest-number-in-infinite-set/solutions/2546157/gong-shui-san-xie-rong-yi-you-gao-xiao-d-431o/ | 中等 | [
"优先队列(堆)",
"哈希表"
] | 现有一个包含所有正整数的集合 $[1, 2, 3, 4, 5, ...]$ 。
实现 `SmallestInfiniteSet` 类:
* `SmallestInfiniteSet()` 初始化 `SmallestInfiniteSet` 对象以包含所有正整数。
* `int popSmallest()` 移除并返回该无限集中的最小整数。
* `void addBack(int num)` 如果正整数 `num` 不存在于无限集中,则将一个 `num` 添加到该无限集中。
示例:
```
输入
["SmallestInfiniteSet", "addBack", "popSmallest", "popSmallest", "popSmallest", "addBack", "popSmallest", "popSmallest", "popSmallest"]
[[], [2], [], [], [], [1], [], [], []]
输出
[null, null, 1, 2, 3, null, 1, 4, 5]
解释
SmallestInfiniteSet smallestInfiniteSet = new SmallestInfiniteSet();
smallestInfiniteSet.addBack(2); // 2 已经在集合中,所以不做任何变更。
smallestInfiniteSet.popSmallest(); // 返回 1 ,因为 1 是最小的整数,并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 2 ,并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 3 ,并将其从集合中移除。
smallestInfiniteSet.addBack(1); // 将 1 添加到该集合中。
smallestInfiniteSet.popSmallest(); // 返回 1 ,因为 1 在上一步中被添加到集合中,
// 且 1 是最小的整数,并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 4 ,并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 5 ,并将其从集合中移除。
```
提示:
* $1 <= num <= 1000$
* 最多调用 `popSmallest` 和 `addBack` 方法 共计 $1000$ 次 | ### 优先队列(小根堆)+ 哈希表
使用 `idx` 代表顺序弹出的集合左边界,$[idx, +\infty]$ 范围内的数均为待弹出,起始有 $idx = 1$。
考虑当调用 `addBack` 往集合添加数值 `x` 时,该如何处理:
* $x \geq idx$:数值本身就存在于集合中,忽略该添加操作;
* $x = idx - 1$:数值刚好位于边界左侧,更新 $idx = idx - 1$;
* $x < idx - 1$:考虑将数值添加到某个容器中,该容器支持返回最小值,容易联想到“小根堆”;但小根堆并没有“去重”功能,为防止重复弹出,还需额外使用“哈希表”来记录哪些元素在堆中。
该做法本质上将集合分成两类:一类是从 `idx` 到正无穷的连续段,对此类操作的复杂度为 $O(1)$;一类是比 `idx` 要小的离散类数集,对该类操作复杂度为 $O(\log{n})$,其中 $n$ 为调用 `addBack` 的最大次数。
Java 代码:
```Java
class SmallestInfiniteSet {
boolean[] vis = new boolean[1010];
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);
int idx = 1;
public int popSmallest() {
int ans = -1;
if (!q.isEmpty()) {
ans = q.poll();
vis[ans] = false;
} else {
ans = idx++;
}
return ans;
}
public void addBack(int x) {
if (x >= idx || vis[x]) return ;
if (x == idx - 1) {
idx--;
} else {
q.add(x);
vis[x] = true;
}
}
}
```
C++ 代码:
```C++
class SmallestInfiniteSet {
public:
vector<bool> vis;
priority_queue<int, vector<int>, greater<int>> q;
int idx;
SmallestInfiniteSet() : idx(1) {
vis.resize(1010, false);
}
int popSmallest() {
int ans = -1;
if (!q.empty()) {
ans = q.top();
q.pop();
vis[ans] = false;
} else {
ans = idx++;
}
return ans;
}
void addBack(int x) {
if (x >= idx || vis[x]) return;
if (x == idx - 1) {
idx--;
} else {
q.push(x);
vis[x] = true;
}
}
};
```
Python 代码:
```Python
class SmallestInfiniteSet:
def __init__(self):
self.vis = [False] * 1010
self.q = []
self.idx = 1
def popSmallest(self):
ans = -1
if self.q:
ans = heapq.heappop(self.q)
self.vis[ans] = False
else:
ans = self.idx
self.idx += 1
return ans
def addBack(self, x):
if x >= self.idx or self.vis[x]:
return
if x == self.idx - 1:
self.idx -= 1
else:
heapq.heappush(self.q, x)
self.vis[x] = True
```
TypeScript 代码:
```TypeScript
class SmallestInfiniteSet {
vis: boolean[] = Array(1010).fill(false);
q: number[] = [];
idx: number = 1;
popSmallest(): number {
let ans: number = -1;
if (this.q.length !== 0) {
ans = this.q.sort((a, b) => a - b).shift() as number;
this.vis[ans] = false;
} else {
ans = this.idx++;
}
return ans;
}
addBack(x: number): void {
if (x >= this.idx || this.vis[x]) return;
if (x == this.idx - 1) {
this.idx--;
} else {
this.q.push(x);
this.vis[x] = true;
}
}
}
```
* 时间复杂度:插入和取出的最坏复杂度为 $O(\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2336` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2341-2350/2342. 数位和相等数对的最大和（中等）.md | 2342. 数位和相等数对的最大和 | https://leetcode.cn/problems/max-sum-of-a-pair-with-equal-sum-of-digits/solutions/2531511/gong-shui-san-xie-yong-bian-li-guo-cheng-kt3f/ | 中等 | [
"模拟",
"哈希表"
] | 给你一个下标从 `0` 开始的数组 `nums`,数组中的元素都是正整数。
请你选出两个下标 `i` 和 `j`(`i != j`),且 `nums[i]` 的数位和与 `nums[j]` 的数位和相等。
请你找出所有满足条件的下标 `i` 和 `j`,找出并返回 `nums[i] + nums[j]` 可以得到的最大值。
示例 1:
```
输入:nums = [18,43,36,13,7]
输出:54
解释:满足条件的数对 (i, j) 为:
- (0, 2) ,两个数字的数位和都是 9 ,相加得到 18 + 36 = 54 。
- (1, 4) ,两个数字的数位和都是 7 ,相加得到 43 + 7 = 50 。
所以可以获得的最大和是 54 。
```
示例 2:
```
输入:nums = [10,12,19,14]
输出:-1
解释:不存在满足条件的数对,返回 -1 。
```
提示:
* $1 <= nums.length <= 10^5$
* $1 <= nums[i] <= 10^9$ | ### 模拟
既然每个 $nums[i]$ 都对应一个具体的数位和,统计每个数位和的最大值和次大值,然后在所有数位和的最大值和次大值求和中取 `max` 即是答案。
利用 $1 <= nums[i] <= 10^9$,我们知道数位和不会超过 $9 \times 9 = 81$,可直接起一个大小为 $100 \times 2$ 的二维数组进行统计,$val[x][0]$ 代表数位和为 $x$ 的次大值,$val[x][1]$ 代表数位和为 $x$ 的最大值。
Java 代码:
```Java
class Solution {
public int maximumSum(int[] nums) {
int[][] val = new int[100][2];
for (int x : nums) {
int t = x, cur = 0;
while (t != 0) {
cur += t % 10;
t /= 10;
}
if (x >= val[cur][1]) { // 最大沦为次大, 更新最大
val[cur][0] = val[cur][1];
val[cur][1] = x;
} else if (x > val[cur][0]) { // 更新次大
val[cur][0] = x;
}
}
int ans = -1;
for (int i = 0; i < 100; i++) {
if (val[i][0] != 0 && val[i][1] != 0) ans = Math.max(ans, val[i][0] + val[i][1]);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maximumSum(vector<int>& nums) {
vector<vector<int>> val(100, vector<int>(2, 0));
for (int x : nums) {
int t = x, cur = 0;
while (t != 0) {
cur += t % 10;
t /= 10;
}
if (x >= val[cur][1]) {
val[cur][0] = val[cur][1];
val[cur][1] = x;
} else if (x > val[cur][0]) {
val[cur][0] = x;
}
}
int ans = -1;
for (int i = 0; i < 100; i++) {
if (val[i][0] != 0 && val[i][1] != 0) ans = max(ans, val[i][0] + val[i][1]);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maximumSum(self, nums: List[int]) -> int:
val = [[0, 0] for _ in range(100)]
for x in nums:
t, cur = x, 0
while t != 0:
cur += t % 10
t //= 10
if x >= val[cur][1]:
val[cur][0], val[cur][1] = val[cur][1], x
elif x > val[cur][0]:
val[cur][0] = x
ans = -1
for i in range(100):
if val[i][0] != 0 and val[i][1] != 0:
ans = max(ans, val[i][0] + val[i][1])
return ans
```
TypeScript 代码:
```TypeScript
function maximumSum(nums: number[]): number {
const val = Array.from({ length: 100 }, () => [0, 0]);
for (const x of nums) {
let t = x, cur = 0;
while (t !== 0) {
cur += t % 10;
t = Math.floor(t / 10);
}
if (x >= val[cur][1]) {
val[cur][0] = val[cur][1];
val[cur][1] = x;
} else if (x > val[cur][0]) {
val[cur][0] = x;
}
}
let ans = -1;
for (let i = 0; i < 100; i++) {
if (val[i][0] !== 0 && val[i][1] !== 0) ans = Math.max(ans, val[i][0] + val[i][1]);
}
return ans;
};
```
* 时间复杂度:$O(n\log{m})$,其中 $n=1e5$ 为 `nums` 长度,$m=1e9$ 为 $nums[i]$ 值域上界
* 空间复杂度:$O(C)$,其中 $C = 2 \times 9 \times \log{m}$
---
### 模拟
更进一步,我们不需要记录次大值,仅记录某个“数对和”当前的最大值即可。
每次计算出当前 $nums[i]$ 对应的数对 `cur` 后,检查 `cur` 是否已出现过,若出现过用两者之和更新答案,并用 $nums[i]$ 来更新 `cur` 下的最大值。
该做法本质是用「遍历过程」代替「次大维护」。
Java 代码:
```Java
class Solution {
public int maximumSum(int[] nums) {
int[] val = new int[100];
int ans = -1;
for (int x : nums) {
int t = x, cur = 0;
while (t != 0) {
cur += t % 10;
t /= 10;
}
if (val[cur] != 0) ans = Math.max(ans, val[cur] + x);
val[cur] = Math.max(val[cur], x);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maximumSum(vector<int>& nums) {
vector<int> val(100, 0);
int ans = -1;
for (int x : nums) {
int t = x, cur = 0;
while (t != 0) {
cur += t % 10;
t /= 10;
}
if (val[cur] != 0) ans = max(ans, val[cur] + x);
val[cur] = max(val[cur], x);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maximumSum(self, nums: List[int]) -> int:
val = [0] * 100
ans = -1
for x in nums:
t, cur = x, 0
while t != 0:
cur += t % 10
t //= 10
if val[cur] != 0:
ans = max(ans, val[cur] + x)
val[cur] = max(val[cur], x)
return ans
```
TypeScript 代码:
```TypeScript
function maximumSum(nums: number[]): number {
const val = Array(100).fill(0);
let ans = -1;
for (const x of nums) {
let t = x, cur = 0;
while (t !== 0) {
cur += t % 10;
t = Math.floor(t / 10);
}
if (val[cur] !== 0) ans = Math.max(ans, val[cur] + x);
val[cur] = Math.max(val[cur], x);
}
return ans;
};
```
* 时间复杂度:$O(n\log{m})$,其中 $n=1e5$ 为 `nums` 长度,$m=1e9$ 为 $nums[i]$ 值域上界
* 空间复杂度:$O(C)$,其中 $C = 9 \times \log{m}$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/241-250/241. 为运算表达式设计优先级（中等）.md | 241. 为运算表达式设计优先级 | https://leetcode.cn/problems/different-ways-to-add-parentheses/solution/by-ac_oier-z07i/ | 中等 | [
"DFS",
"爆搜"
] | 给你一个由数字和运算符组成的字符串 `expression`,按不同优先级组合数字和运算符,计算并返回所有可能组合的结果。你可以 按任意顺序 返回答案。
生成的测试用例满足其对应输出值符合 $32$ 位整数范围,不同结果的数量不超过 $10^4$ 。
示例 1:
```
输入:expression = "2-1-1"
输出:[0,2]
解释:
((2-1)-1) = 0
(2-(1-1)) = 2
```
示例 2:
```
输入:expression = "2*3-4*5"
输出:[-34,-14,-10,-10,10]
解释:
(2*(3-(4*5))) = -34
((2*3)-(4*5)) = -14
((2*(3-4))*5) = -10
(2*((3-4)*5)) = -10
(((2*3)-4)*5) = 10
```
提示:
* $1 <= expression.length <= 20$
* `expression` 由数字和算符 `'+'`、`'-'` 和 `'*'` 组成。
* 输入表达式中的所有整数值在范围 $[0, 99]$ | ### DFS
为了方便,我们令 `expression` 为 `s`。
数据范围为 $20$,且要统计所有的计算结果,我们可以运用 `DFS` 爆搜所有方案。
给定的 `s` 只有数字和运算符,我们可以根据运算符将式子分为左右两部分,设计递归函数 `List<Integer> dfs(int l, int r)`,含义为搜索子串 $s[l...r]$ 的所有运算结果。
最终答案为 `dfs(0,n-1)`,其中 $n$ 为入参字符串的长度,同时我们有显而易见的递归出口:当给定的 $s[l...r]$ 不包含任何运算符时,搜索结果为 $s[l...r]$ 所代表的数字本身。
考虑如何对任意 $s[l...r]$ 进行计算:我们可以通过枚举 $s[l...r]$ 范围内的所有的运算符位置来进行爆搜,假设当前枚举到的 $s[i]$ 为运算符,我们可以递归运算符的左边 `dfs(l,i-1)` 拿到左边所有的结果,递归运算符右边 `dfs(i+1,r)` 拿到右边的所有结果,结合「乘法原理」即可知道以当前运算符 $s[i]$ 为分割点的表达式的所有方案。
不难发现,上述过程都是由「小表达式」的结果推导出「大表达式」的结果,因此也可以运用「区间 DP」方式进行求解,复杂度与 `DFS` 一致。
Java 代码:
```Java
class Solution {
char[] cs;
public List<Integer> diffWaysToCompute(String s) {
cs = s.toCharArray();
return dfs(0, cs.length - 1);
}
List<Integer> dfs(int l, int r) {
List<Integer> ans = new ArrayList<>();
for (int i = l; i <= r; i++) {
if (cs[i] >= '0' && cs[i] <= '9') continue;
List<Integer> l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);
for (int a : l1) {
for (int b : l2) {
int cur = 0;
if (cs[i] == '+') cur = a + b;
else if (cs[i] == '-') cur = a - b;
else cur = a * b;
ans.add(cur);
}
}
}
if (ans.isEmpty()) {
int cur = 0;
for (int i = l; i <= r; i++) cur = cur * 10 + (cs[i] - '0');
ans.add(cur);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
string cs;
vector<int> diffWaysToCompute(string s) {
cs = s;
return dfs(0, cs.size() - 1);
}
vector<int> dfs(int l, int r) {
vector<int> ans;
for (int i = l; i <= r; i++) {
if (cs[i] >= '0' && cs[i] <= '9') continue;
auto l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);
for (int a : l1) {
for (int b : l2) {
int cur = 0;
if (cs[i] == '+') cur = a + b;
else if (cs[i] == '-') cur = a - b;
else cur = a * b;
ans.push_back(cur);
}
}
}
if (ans.empty()) {
int cur = 0;
for (int i = l; i <= r; i++) cur = cur * 10 + (cs[i] - '0');
ans.push_back(cur);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def diffWaysToCompute(self, cs: str) -> List[int]:
def dfs(l: int, r: int) -> List[int]:
ans = []
for i in range(l, r + 1):
if '0' <= cs[i] <= '9': continue
l1, l2 = dfs(l, i - 1), dfs(i + 1, r)
for a, b in product(l1, l2):
cur = 0
if cs[i] == '+':
cur = a + b
elif cs[i] == '-':
cur = a - b
else:
cur = a * b
ans.append(cur)
if not ans:
cur = 0
for i in range(l, r + 1):
cur = cur * 10 + (ord(cs[i]) - ord('0'))
ans.append(cur)
return ans
return dfs(0, len(cs) - 1)
```
TypeScript 代码:
```TypeScript
function diffWaysToCompute(cs: string): number[] {
const dfs = function(l: number, r: number): number[] {
const ans = [];
for (let i = l; i <= r; i++) {
if ("0" <= cs[i] && cs[i] <= "9") continue;
const l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);
for (const a of l1) {
for (const b of l2) {
let cur = 0;
if (cs[i] === "+") cur = a + b;
else if (cs[i] === "-") cur = a - b;
else cur = a * b;
ans.push(cur);
}
}
}
if (ans.length == 0) {
let cur = 0;
for (let i = l; i <= r; i++) cur = cur * 10 + (parseInt(cs[i]) - 0);
ans.push(cur);
}
return ans;
}
return dfs(0, cs.length - 1);
};
```
* 时间复杂度:复杂度与最终结果数相关,最终结果数为「卡特兰数」,复杂度为 $O(C_{n})$
* 空间复杂度:复杂度与最终结果数相关,最终结果数为「卡特兰数」,复杂度为 $O(C_{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.241` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2471-2480/2477. 到达首都的最少油耗（中等）.md | 2477. 到达首都的最少油耗 | https://leetcode.cn/problems/minimum-fuel-cost-to-report-to-the-capital/solutions/2554316/gong-shui-san-xie-zhu-bu-jiang-jie-zui-d-25qs/ | 中等 | [
"DFS"
] | 给你一棵 `n` 个节点的树(一个无向、连通、无环图),每个节点表示一个城市,编号从 `0` 到 `n - 1`,且恰好有 `n - 1` 条路。
`0` 是首都。给你一个二维整数数组 `roads`,其中 $roads[i] = [a_{i}, b_{i}]$ ,表示城市 $a_{i}$ 和 $b_{i}$ 之间有一条 双向路 。
每个城市里有一个代表,他们都要去首都参加一个会议。
每座城市里有一辆车。给你一个整数 `seats` 表示每辆车里面座位的数目。
城市里的代表可以选择乘坐所在城市的车,或者乘坐其他城市的车。相邻城市之间一辆车的油耗是一升汽油。
请你返回到达首都最少需要多少升汽油。
示例 1:
```
输入:roads = [[0,1],[0,2],[0,3]], seats = 5
输出:3
解释:
- 代表 1 直接到达首都,消耗 1 升汽油。
- 代表 2 直接到达首都,消耗 1 升汽油。
- 代表 3 直接到达首都,消耗 1 升汽油。
最少消耗 3 升汽油。
```
示例 2:
```
输入:roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2
输出:7
解释:
- 代表 2 到达城市 3 ,消耗 1 升汽油。
- 代表 2 和代表 3 一起到达城市 1 ,消耗 1 升汽油。
- 代表 2 和代表 3 一起到达首都,消耗 1 升汽油。
- 代表 1 直接到达首都,消耗 1 升汽油。
- 代表 5 直接到达首都,消耗 1 升汽油。
- 代表 6 到达城市 4 ,消耗 1 升汽油。
- 代表 4 和代表 6 一起到达首都,消耗 1 升汽油。
最少消耗 7 升汽油。
```
示例 3:
```
输入:roads = [], seats = 1
输出:0
解释:没有代表需要从别的城市到达首都。
```
提示:
* $1 <= n <= 105$
* $roads.length = n - 1$
* $roads[i].length = 2$
* $0 <= a_{i}, b_{i} < n$
* $a_{i} != b_{i}$
* `roads` 表示一棵合法的树。
* $1 <= seats <= 10^5$ | ### DFS
将双向图看作是以节点 `0` 为根的有向树,从每个节点出发往 `0` 前行,可看作是自底向上的移动过程。
当 `seats = 1` 时,每个节点前往 `0` 的过程相互独立,总油耗为每节点到 `0` 的最短距离之和。
当 `seats` 不为 `1` 时,考虑组成顺风车,此时总的油耗不该超过 `seats = 1` 的情况。
不难发现,**只有「深度大的节点,在前往 `0` 过程中,搭乘深度小顺风车」可减少油耗**(例如在上图节点 `3` 在经过节点 `1` 时搭乘顺风车,可与节点 `1` 合计使用一份油耗前往到 `0`),否则如果是深度小的节点先往深度大的节点走,再一同前往 `0`,会额外多经过某些边,产生不必要的油耗。
考虑组成顺风车时,总油耗该如何计算。
基于上述分析,无论 `seats` 是否为 $1$(是否组成顺风车),每个节点前往 `0` 的路径总是不变,即经过的边固定不变,必然是自底向上。
因此我们可统计每条边会被多少个节点经过,通过 `DFS` 统计「以每个节点为根时,子树的节点数量」即是经过该节点往上的边。
知道经过某条边的节点数量 `cnt` 后,$\left \lceil \frac{cnt}{seats} \right \rceil$ 即是该边对答案的贡献。
Java 代码:
```Java
class Solution {
int N = 100010, M = 2 * N, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
long ans = 0;
public long minimumFuelCost(int[][] roads, int seats) {
int n = roads.length + 1;
Arrays.fill(he, -1);
for (int[] r : roads) {
int a = r[0], b = r[1];
add(a, b); add(b, a);
}
dfs(0, -1, seats);
return ans;
}
int dfs(int u, int fa, int t) {
int cnt = 1;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
cnt += dfs(j, u, t);
}
if (u != 0) ans += Math.ceil(cnt * 1.0 / t);
return cnt;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int N = 100010, M = 2 * N, idx = 0;
int he[100010], e[200020], ne[200020];
long long ans = 0;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
long long minimumFuelCost(vector<vector<int>>& roads, int seats) {
int n = roads.size() + 1;
memset(he, -1, sizeof(he));
for (auto& r : roads) {
int a = r[0], b = r[1];
add(a, b); add(b, a);
}
dfs(0, -1, seats);
return ans;
}
int dfs(int u, int fa, int t) {
int cnt = 1;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
cnt += dfs(j, u, t);
}
if (u != 0) ans += ceil(cnt * 1.0 / t);
return cnt;
}
};
```
Python 代码:
```Python
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
n, m, ans = len(roads) + 1, len(roads) * 2 + 1, 0
he, e, ne, idx = [-1] * n, [0] * m, [0] * m, 0
def add(a, b):
nonlocal idx
e[idx] = b
ne[idx] = he[a]
he[a] = idx
idx += 1
def dfs(u, fa, t):
nonlocal ans
cnt = 1
i = he[u]
while i != -1:
j, i = e[i], ne[i]
if j == fa: continue
cnt += dfs(j, u, t)
if u != 0:
ans += math.ceil(cnt * 1.0 / t)
return cnt
for a, b in roads:
add(a, b)
add(b, a)
dfs(0, -1, seats)
return ans
```
TypeScript 代码:
```TypeScript
function minimumFuelCost(roads: number[][], seats: number): number {
const n = roads.length + 1, m = n * 2;
const he = Array(n).fill(-1), e = Array(m).fill(0), ne = Array(m).fill(0);
let ans = 0, idx = 0;
const add = function(a: number, b: number) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
const dfs = function(u: number, fa: number, t: number): number {
let cnt = 1;
for (let i = he[u]; i != -1; i = ne[i]) {
const j = e[i];
if (j == fa) continue;
cnt += dfs(j, u, t);
}
if (u != 0) ans += Math.ceil(cnt * 1.0 / t);
return cnt;
}
for (const [a, b] of roads) {
add(a, b); add(b, a);
}
dfs(0, -1, seats);
return ans;
};
```
* 时间复杂度:建图复杂度为 $O(n)$;递归统计每个子树节点数量并计算油耗复杂度 $O(n)$;整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2477` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/251-260/258. 各位相加（简单）.md | 258. 各位相加 | https://leetcode-cn.com/problems/add-digits/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-zdml/ | 简单 | [
"模拟",
"数学"
] | 给定一个非负整数 `num`,反复将各个位上的数字相加,直到结果为一位数。返回这个结果。
示例 1:
```
输入: num = 38
输出: 2
解释: 各位相加的过程为:
38 --> 3 + 8 --> 11
11 --> 1 + 1 --> 2
由于 2 是一位数,所以返回 2。
```
示例 1:
```
输入: num = 0
输出: 0
```
提示:
* $0 <= num <= 2^{31} - 1$
进阶:你可以不使用循环或者递归,在 $O(1)$ 时间复杂度内解决这个问题吗? | ### 模拟
一个直观的做法是根据题意进行模拟,只要 `num` 位数多于 $1$ 位就可以继续做。
代码:
```Java
class Solution {
public int addDigits(int num) {
while (num > 9) {
int t = 0;
while (num != 0) {
t += num % 10;
num /= 10;
}
num = t;
}
return num;
}
}
```
* 时间复杂度:$O(\log{num})$
* 空间复杂度:$O(1)$
---
### 数学
这题还是道对 [同余定理](https://baike.baidu.com/item/%E5%90%8C%E4%BD%99%E5%AE%9A%E7%90%86/1212360) 应用的题目。
对于任意一个正整数而言,我们最终是要求得 $a_0 + a_1 + a_2 + ... + a_{n - 1}$ 对 $9$ 取模的数。
而利用「同余式相加」性质,等价于每个数分别对 $9$ 取模之和,再集合任意的 $10^n$ 对 $9$ 取模恒为 $1$,可得最终答案为原数对 $9$ 取模,剩下只需要对相加结果为 $9$ 的边界情况进行处理即可。
代码:
```Java
class Solution {
public int addDigits(int num) {
return (num - 1) % 9 + 1;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.258` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/251-260/260. 只出现一次的数字 III（中等）.md | 260. 只出现一次的数字 III | https://leetcode-cn.com/problems/single-number-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-zgi4/ | 中等 | [
"模拟",
"哈希表",
"异或"
] | 给定一个整数数组 `nums`,其中恰好有两个元素只出现一次,其余所有元素均出现两次。
找出只出现一次的那两个元素,你可以按任意顺序返回答案。
示例 1:
```
输入:nums = [1,2,1,3,2,5]
输出:[3,5]
解释:[5, 3] 也是有效的答案。
```
示例 2:
```
输入:nums = [-1,0]
输出:[-1,0]
```
示例 3:
```
输入:nums = [0,1]
输出:[1,0]
```
提示:
* $2 <= nums.length <= 3 \times 10^4$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* 除两个只出现一次的整数外,`nums` 中的其他数字都出现两次
进阶:你的算法应该具有线性时间复杂度,你能否仅使用常数空间复杂度来实现? | ### 哈希表
朴素的做法是利用哈希表进行统计,最后将统计次数为 $1$ 的元素加入答案。
Java 代码:
```Java
class Solution {
public int[] singleNumber(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
int[] ans = new int[2];
int idx = 0;
for (int i : nums) {
if (map.get(i) == 1) ans[idx++] = i;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> singleNumber(vector<int>& nums) {
unordered_map<int, int> cmap;
for (int num : nums) cmap[num]++;
vector<int> ans;
for (int num : nums) {
if (cmap[num] == 1) ans.push_back(num);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def singleNumber(self, nums: List[int]) -> List[int]:
count_map = Counter(nums)
return [num for num in nums if count_map[num] == 1]
```
TypeScript 代码:
```TypeScript
function singleNumber(nums: number[]): number[] {
const countMap: Map<number, number> = new Map();
for (const num of nums) countMap.set(num, (countMap.get(num) || 0) + 1);
const ans: number[] = [];
for (const num of nums) {
if (countMap.get(num) === 1) ans.push(num);
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 异或
利用除答案以外的元素均出现两次,我们可以先对 $nums$ 中的所有元素执行异或操作,得到 $sum$,$sum$ 为两答案的异或值($sum$ 必然不为 $0$)。
然后取 $sum$ 二进制表示中为 $1$ 的任意一位 $k$,$sum$ 中的第 $k$ 位为 $1$ 意味着两答案的第 $k$ 位二进制表示不同。
对 $nums$ 进行遍历,对第 $k$ 位分别为 $0$ 和 $1$ 的元素分别求异或和(两答案必然会被分到不同的组),即为答案。
Java 代码:
```Java
class Solution {
public int[] singleNumber(int[] nums) {
int sum = 0, k = -1;
for (int i : nums) sum ^= i;
for (int i = 31; i >= 0 && k == -1; i--) {
if (((sum >> i) & 1) == 1) k = i;
}
int[] ans = new int[2];
for (int i : nums) {
if (((i >> k) & 1) == 1) ans[1] ^= i;
else ans[0] ^= i;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> singleNumber(vector<int>& nums) {
int sum = 0, k = -1;
for (int num : nums) sum ^= num;
for (int i = 31; i >= 0 && k == -1; i--) {
if ((sum >> i) & 1) k = i;
}
vector<int> ans(2, 0);
for (int num : nums) {
if ((num >> k) & 1) ans[1] ^= num;
else ans[0] ^= num;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def singleNumber(self, nums: List[int]) -> List[int]:
sum_val, k = 0, -1
for num in nums: sum_val ^= num
for i in range(31, -1, -1):
if (sum_val >> i) & 1:
k = i
break
ans = [0, 0]
for num in nums:
if (num >> k) & 1: ans[1] ^= num
else: ans[0] ^= num
return ans
```
TypeScript 代码:
```TypeScript
function singleNumber(nums: number[]): number[] {
let sum = 0, k = -1;
for (const num of nums) sum ^= num;
for (let i = 31; i >= 0 && k === -1; i--) {
if (((sum >> i) & 1) === 1) k = i;
}
const ans: number[] = [0, 0];
for (const num of nums) {
if (((num >> k) & 1) === 1) ans[1] ^= num;
else ans[0] ^= num;
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.260` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2511-2520/2520. 统计能整除数字的位数（简单）.md | 2520. 统计能整除数字的位数 | https://leetcode.cn/problems/count-the-digits-that-divide-a-number/solutions/2498966/gong-shui-san-xie-jian-dan-mo-ni-ti-shi-0ad2c/?envType=daily-question&envId=2023-10-26 | 简单 | [
"模拟"
] | 给你一个整数 `num`,返回 `num` 中能整除 `num` 的数位的数目。
如果满足 `nums % val == 0`,则认为整数 `val` 可以整除 `nums`。
示例 1:
```
输入:num = 7
输出:1
解释:7 被自己整除,因此答案是 1 。
```
示例 2:
```
输入:num = 121
输出:2
解释:121 可以被 1 整除,但无法被 2 整除。由于 1 出现两次,所以返回 2 。
```
示例 3:
```
输入:num = 1248
输出:4
解释:1248 可以被它每一位上的数字整除,因此答案是 4 。
```
提示:
* $1 <= num <= 10^9$
* `num` 的数位中不含 `0` | ### 模拟
根据题意进行模拟即可。
假设起始值为 `num`,符合要求的数位个数为 `ans`,按照「从低到高」的方式循环处理 `num` 中的每个数位:
1. 每次仅对当前数值 `num` 的最低位进行判断(当前数值 `num` 会被不断更新),**通过「模 $10$」的方式来「截取当前数值的最低位」**,并根据要求进行判断,若当前数位符合要求,对 `ans` 进行加一;
2. 判断完当前数组 `num` 的最低位后,**通过「与 $10$ 地板除」的方式来「摒弃当前数值的最低位」**,并以此更新 `num`;
3. 循环步骤 `1` 和步骤 `2`,直到 `num` 所有数位均被处理完,即 `num = 0`。
用题面的示例 3 来举个 🌰,给定 `num = 1248`,完整处理过程如下:
1. 当前数 `num = 1248`,通过 `mod 10` 取最低位 `8`,该数值满足要求,`ans = 1`;
通过 `// 10` 摒弃已处理的最低位,得到 `num = 124`
2. 当前数 `num = 124`,通过 `mod 10` 取最低位 `4`,该数值满足要求,`ans = 2`;
通过 `// 10` 摒弃已处理的最低位,得到 `num = 12`
3. 当前数 `num = 12`,通过 `mod 10` 取最低位 `2`,该数值满足要求,`ans = 3`;
通过 `// 10` 摒弃已处理的最低位,得到 `num = 1`
4. 当前数 `num = 1`,通过 `mod 10` 取最低位 `1`,该数值满足要求,`ans = 4`;
通过 `// 10` 摒弃已处理的最低位,得到 `num = 0`,循环结束
Java 代码:
```Java
class Solution {
public int countDigits(int num) {
int n = num, ans = 0;
while (num != 0) {
ans += n % (num % 10) == 0 ? 1 : 0;
num /= 10;
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def countDigits(self, num: int) -> int:
return sum(num % int(i) == 0 for i in str(num))
# n, ans = num, 0
# while num != 0:
# ans += n % (num % 10) == 0
# num //= 10
# return ans
```
C++ 代码:
```C++
class Solution {
public:
int countDigits(int num) {
int n = num, ans = 0;
while (num != 0) {
ans += n % (num % 10) == 0;
num /= 10;
}
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function countDigits(num: number): number {
let n = num, ans = 0;
while (num !== 0) {
ans += n % (num % 10) == 0 ? 1 : 0;
num = Math.floor(num / 10);
}
return ans;
};
```
Kotlin 代码:
```Kotlin
class Solution {
fun countDigits(num: Int): Int {
return num.toString().count { x -> num % (x - '0') == 0 }
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2520` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2551-2560/2558. 从数量最多的堆取走礼物（简单）.md | 2558. 从数量最多的堆取走礼物 | https://leetcode.cn/problems/take-gifts-from-the-richest-pile/solutions/2501825/gong-shui-san-xie-ke-shi-hua-shou-xie-du-pp3a/ | 简单 | [
"优先队列(堆)"
] | 给你一个整数数组 `gifts`,表示各堆礼物的数量。
每一秒,你需要执行以下操作:
* 选择礼物数量最多的那一堆。
* 如果不止一堆都符合礼物数量最多,从中选择任一堆即可。
* 选中的那一堆留下平方根数量的礼物(向下取整),取走其他的礼物。
返回在 `k` 秒后剩下的礼物数量。
示例 1:
```
输入:gifts = [25,64,9,4,100], k = 4
输出:29
解释:
按下述方式取走礼物:
- 在第一秒,选中最后一堆,剩下 10 个礼物。
- 接着第二秒选中第二堆礼物,剩下 8 个礼物。
- 然后选中第一堆礼物,剩下 5 个礼物。
- 最后,再次选中最后一堆礼物,剩下 3 个礼物。
最后剩下的礼物数量分别是 [5,8,9,4,3] ,所以,剩下礼物的总数量是 29 。
```
示例 2:
```
输入:gifts = [1,1,1,1], k = 4
输出:4
解释:
在本例中,不管选中哪一堆礼物,都必须剩下 1 个礼物。
也就是说,你无法获取任一堆中的礼物。
所以,剩下礼物的总数量是 4 。
```
提示:
* $1 <= gifts.length <= 10^3$
* $1 <= gifts[i] <= 10^9$
* $1 <= k <= 10^3$ | ### 基本思想
为了方便,将 `gifts` 记为 `gs`。
从题面看,数组大小和执行次数范围均为 $1e3$,那么暴力做法的复杂度为 $O(n^2)$,计算量为 $1e6$,是可以通过的。
稍有数据结构基础的同学,容易进一步联想:存在一种数据结构,能够快速查得集合最值,使复杂度降低。
该数据结构是「堆」,在某些 `STL` 里面又称为「优先队列」。
---
### 手写堆入门
所有高级数据结构(例如之前讲过的 [字典树 Trie] 或 [并查集],都可以使用数组进行模拟,堆自然也不例外。
**堆本质是数据集合,只不过区别于简单数组而言,其具有 $O(1)$ 查找最值特性。**
既然我们使用数组来实现堆,同时又需要实现 $O(1)$ 查找最值,一个自然而然的想法,是把集合最值放到数组的特定位置,例如数组起始位置。
开始之前,先来了解一下,堆的基本操作:
* `add`:往堆中增加元素
* `peek`:快速查得最值
* `pop`:将最值从堆中移除
我们以小根堆为例,进行学习。
> PS. 大根堆亦是同理,如果已经有写好的小根堆模板,那么将数值进行符号翻转,即可实现大根堆;或是翻转模板中的数值比较逻辑,也可将小根堆轻松切换成大根堆。
#### 1. 堆长啥样?
堆是数组实现的,但其形态为「完全二叉树」(最多只有底下一层节点不满),目的是尽量让树平衡,降低树的高度,从而更高效的维护其性质。
虽是「完全二叉树」,但其又和另外一种特殊二叉树,二叉搜索树(`BST`)不同。
在 `BST` 的定义中:任意节点的左子树上的节点值均不大于该节点,任意节点的右子树上的节点值均不小于该节点。
在小根堆对应的「完全二叉树」定义中:任意节点的节点值均不大于其左右子树中的节点值。
因此将小根堆可视化后,也十分形象:小根堆的堆顶元素最小,然后从上往下,元素“依次”增大。
{:width=400}
即对于小根堆而言,每个子树的根节点,都是该子树的最小值。
#### 2. 如何用数组进行「完全二叉树」的存储?
我们只需要将「二叉树的左右子节点关系」和「数组下标」实现某种关联即可。
我们约定,对于某个节点,若其所在数组下标为 $idx$,那么该节点的左子节点的数组下标为 $2 \times idx$,该节点的右子节点的数组下标为 $2 \times idx + 1$。
注意:基于此规则,我们需要调整数组下标从 $1$ 开始进行存储。
{:width=400}
#### 3.基本操作如何实现?
所有操作的核心最终都归结到:如何通过有限的调整,重新恢复堆所对应的完全二叉树中的节点定义。
因此可抽象出 `up` 操作和 `down` 操作,俩操作均通过递归实现:
* `up` 操作是将当前节点 `u` 与父节点 `fa = u / 2` 进行比较,若发现父节点更大,则将两者进行互换,并递归处理父节点
* `down` 操作是将当前节点 `cur` 和左右节点 `l = cur * 2` 和 `r = cur * 2 + 1` 进行比较,若当前节点并非三者最小,则进行互换,并递归处理子节点
通过上述核心 `up` 和 `down` 操作,以及「完全二叉树」在数组的放置规则,我们可以容易拼凑出堆的基本操作。
假定当前使用一维数组 `heap` 实现堆,使用变量 `sz` 记录当前堆的元素个数,同时该变量充当 `heap` 的结尾游标:
* `add`:往堆中增加元素
该操作可转换为:往数组尾部增加元素(`heap[sz++] = x`),并从尾部开始重整堆(`up(sz)`)
* `peek`:快速查得最小值
直接范围数组首位元素,注意下标从 $1$ 开始,`heap[1]`
* `pop`:将最值从堆中移除
先通过 `peek` 操作记录下待移除的最小值,然后将数组的结尾元素和首位元素互换,并更新数组长度减一(`heap[1] = heap[sz--]`),随后从头部开始重整堆(`down(1)`)
Java 完整模板:
```Java
int[] heap = new int[10010];
int sz = 0;
void swap(int a, int b) {
int c = heap[a];
heap[a] = heap[b];
heap[b] = c;
}
void up(int u) {
// 将「当前节点 i」与「父节点 i / 2」进行比较, 若父节点值更大, 则进行交换
int fa = u / 2;
if (fa != 0 && heap[fa] > heap[u]) {
swap(fa, u);
up(fa);
}
}
void down(int u) {
// 将当「前节点 cur」与「左节点 l」及「右节点 r」进行比较, 找出最小值, 若当前节点不是最小值, 则进行交换
int cur = u;
int l = u * 2, r = u * 2 + 1;
if (l <= sz && heap[l] < heap[cur]) cur = l;
if (r <= sz && heap[r] < heap[cur]) cur = r;
if (cur != u) {
swap(cur, u);
down(cur);
}
}
void add(int x) {
heap[++sz] = x;
up(sz);
}
int peek() {
return heap[1];
}
int pop() {
int ans = peek();
heap[1] = heap[sz--];
down(1);
return ans;
}
```
C++ 完整模板:
```C++
int heap[1010];
int sz = 0;
void up(int u) {
int fa = u / 2;
if (fa && heap[fa] >= heap[u]) {
swap(heap[fa], heap[u]);
up(fa);
}
}
void down(int u) {
int cur = u;
int l = cur * 2, r = cur * 2 + 1;
if (l <= sz && heap[l] < heap[cur]) cur = l;
if (r <= sz && heap[r] < heap[cur]) cur = r;
if (cur != u) {
swap(heap[cur], heap[u]);
down(cur);
}
}
void add(int x) {
heap[++sz] = x;
up(sz);
}
int peek() {
return heap[1];
}
int poll() {
int ans = peek();
heap[1] = heap[sz--];
down(1);
return ans;
}
```
---
### 模板运用
利用「上述模板」以及「小根堆如何当大根堆」使用,我们可以轻松解决本题。
1. 起始先将逐元素进行符号翻转并入堆
2. 执行 `k` 次取出并重放操作(注意符号转换)
3. 统计所有元素之和,由于此时不再需要查询最值,可通过直接扫描数组的方式(注意符号转换)
Java 代码:
```Java
class Solution {
int[] heap = new int[10010];
int sz = 0;
public long pickGifts(int[] gs, int k) {
for (int x : gs) add(-x);
while (k-- > 0) add(-(int)Math.sqrt(-pop()));
long ans = 0;
while (sz != 0) ans += -heap[sz--]; // 没必要再维持堆的有序, 直接读取累加
return ans;
}
void swap(int a, int b) {
int c = heap[a];
heap[a] = heap[b];
heap[b] = c;
}
void up(int u) {
// 将「当前节点 i」与「父节点 i / 2」进行比较, 若父节点值更大, 则进行交换
int fa = u / 2;
if (fa != 0 && heap[fa] > heap[u]) {
swap(fa, u);
up(fa);
}
}
void down(int u) {
// 将当「前节点 cur」与「左节点 l」及「右节点 r」进行比较, 找出最小值, 若当前节点不是最小值, 则进行交换
int cur = u;
int l = u * 2, r = u * 2 + 1;
if (l <= sz && heap[l] < heap[cur]) cur = l;
if (r <= sz && heap[r] < heap[cur]) cur = r;
if (cur != u) {
swap(cur, u);
down(cur);
}
}
void add(int x) {
heap[++sz] = x;
up(sz);
}
int peek() {
return heap[1];
}
int pop() {
int ans = peek();
heap[1] = heap[sz--];
down(1);
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int heap[1010];
int sz = 0;
long long pickGifts(vector<int>& gs, int k) {
for (int x : gs) add(-x);
while (k--) add(-sqrt(-poll()));
long ans = 0;
while (sz != 0) ans += -heap[sz--];
return ans;
}
void up(int u) {
int fa = u / 2;
if (fa && heap[fa] >= heap[u]) {
swap(heap[fa], heap[u]);
up(fa);
}
}
void down(int u) {
int cur = u;
int l = cur * 2, r = cur * 2 + 1;
if (l <= sz && heap[l] < heap[cur]) cur = l;
if (r <= sz && heap[r] < heap[cur]) cur = r;
if (cur != u) {
swap(heap[cur], heap[u]);
down(cur);
}
}
void add(int x) {
heap[++sz] = x;
up(sz);
}
int peek() {
return heap[1];
}
int poll() {
int ans = peek();
heap[1] = heap[sz--];
down(1);
return ans;
}
};
```
* 时间复杂度:建堆复杂度为 $O(n\log{n})$;执行 `k` 次操作复杂度为 $O(k\log{n})$;构建答案复杂度为 $O(n)$。整体复杂度为 $O((n + k) \log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2558` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2581-2590/2586. 统计范围内的元音字符串数（简单）.md | 2586. 统计范围内的元音字符串数 | https://leetcode.cn/problems/count-the-number-of-vowel-strings-in-range/solutions/2515898/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-di1t/ | 简单 | [
"模拟"
] | 给你一个下标从 $0$ 开始的字符串数组 `words` 和两个整数:`left` 和 `right`。
如果字符串以元音字母开头并以元音字母结尾,那么该字符串就是一个 元音字符串 ,其中元音字母是 `'a'`、`'e'`、`'i'`、`'o'`、`'u'`。
返回 $words[i]$ 是元音字符串的数目,其中 `i` 在闭区间 $[left, right]$ 内。
示例 1:
```
输入:words = ["are","amy","u"], left = 0, right = 2
输出:2
解释:
- "are" 是一个元音字符串,因为它以 'a' 开头并以 'e' 结尾。
- "amy" 不是元音字符串,因为它没有以元音字母结尾。
- "u" 是一个元音字符串,因为它以 'u' 开头并以 'u' 结尾。
在上述范围中的元音字符串数目为 2 。
```
示例 2:
```
输入:words = ["hey","aeo","mu","ooo","artro"], left = 1, right = 4
输出:3
解释:
- "aeo" 是一个元音字符串,因为它以 'a' 开头并以 'o' 结尾。
- "mu" 不是元音字符串,因为它没有以元音字母开头。
- "ooo" 是一个元音字符串,因为它以 'o' 开头并以 'o' 结尾。
- "artro" 是一个元音字符串,因为它以 'a' 开头并以 'o' 结尾。
在上述范围中的元音字符串数目为 3 。
```
提示:
* $1 <= words.length <= 1000$
* $1 <= words[i].length <= 10$
* $words[i]$ 仅由小写英文字母组成
* $0 <= left <= right < words.length$ | ### 模拟
检查下标范围在 $[left, right]$ 内的字符串 $words[i]$,若当前 $words[i]$ 首尾字母为 `aeiou` 之一,进行计数。
Java 代码:
```Java
class Solution {
public int vowelStrings(String[] words, int left, int right) {
int ans = 0;
for (int i = left; i <= right; i++) {
String s = words[i];
char a = s.charAt(0), b = s.charAt(s.length() - 1);
if ("aeiou".indexOf(a) != -1 && "eaiou".indexOf(b) != -1) ans++;
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def vowelStrings(self, words: List[str], left: int, right: int) -> int:
return sum(1 for i in range(left, right + 1) if words[i][0] in "aeiou" and words[i][-1] in "aeiou")
```
C++ 代码:
```C++
class Solution {
public:
int vowelStrings(vector<string>& words, int left, int right) {
int ans = 0;
for (int i = left; i <= right; i++) {
string s = words[i];
if (s.find_first_of("aeiou") == 0 && s.find_last_of("aeiou") == s.length() - 1) ans++;
}
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function vowelStrings(words: string[], left: number, right: number): number {
let ans = 0;
for (let i = left; i <= right; i++) {
const s = words[i];
if ("aeiou".includes(s[0]) && "aeiou".includes(s.charAt(s.length - 1))) ans++;
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2586` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2601-2610/2609. 最长平衡子字符串（简单）.md | 2609. 最长平衡子字符串 | https://leetcode.cn/problems/find-the-longest-balanced-substring-of-a-binary-string/solutions/2517437/gong-shui-san-xie-on-shi-jian-o1-kong-ji-i8e7/ | 简单 | [
"模拟"
] | 给你一个仅由 `0` 和 `1` 组成的二进制字符串 `s` 。
如果子字符串中 所有的 `0` 都在 `1` 之前 且其中 `0` 的数量等于 `1` 的数量,则认为 `s` 的这个子字符串是平衡子字符串。
请注意,空子字符串也视作平衡子字符串。
返回 `s` 中最长的平衡子字符串长度。
子字符串是字符串中的一个连续字符序列。
示例 1:
```
输入:s = "01000111"
输出:6
解释:最长的平衡子字符串是 "000111" ,长度为 6 。
```
示例 2:
```
输入:s = "00111"
输出:4
解释:最长的平衡子字符串是 "0011" ,长度为 4 。
```
示例 3:
```
输入:s = "111"
输出:0
解释:除了空子字符串之外不存在其他平衡子字符串,所以答案为 0 。
```
提示:
* $1 <= s.length <= 50$
* `'0' <= s[i] <= '1'` | ### 模拟
根据题意,平衡子字符串必然满足 `0...01...1` 格式(前半段全是 `0`,后半段全是 `1`,前后两段长度相同)。
使用变量 `idx` 对 `s` 进行遍历。在每轮处理过程中,按照如下流程进行:
1. 先统计连续段 `0` 的长度,记为 `a`;再统计连续段 `1` 的长度,记为 `b`(此操作满足:子串中 `0` 均在 `1` 前面)
2. 在 `a` 和 `b` 中取较小值,进行乘 $2$ 操作,作为当前平衡子字符串的长度,用于更新答案(此操作满足:子串中 `0` 和 `1` 数量相同)
3. 从当前轮的结束位置 `idx`,再进行下轮处理(重复步骤 $1$ 和步骤 $2$),直到 `s` 处理完成
Java 代码:
```Java
class Solution {
public int findTheLongestBalancedSubstring(String s) {
int n = s.length(), idx = 0, ans = 0;
while (idx < n) {
int a = 0, b = 0;
while (idx < n && s.charAt(idx) == '0' && ++a >= 0) idx++;
while (idx < n && s.charAt(idx) == '1' && ++b >= 0) idx++;
ans = Math.max(ans, Math.min(a, b) * 2);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int findTheLongestBalancedSubstring(string s) {
int n = s.size(), idx = 0, ans = 0;
while (idx < n) {
int a = 0, b = 0;
while (idx < n && s[idx] == '0' && ++a >= 0) idx++;
while (idx < n && s[idx] == '1' && ++b >= 0) idx++;
ans = max(ans, min(a, b) * 2);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def findTheLongestBalancedSubstring(self, s: str) -> int:
n, idx, ans = len(s), 0, 0
while idx < n:
a, b = 0, 0
while idx < n and s[idx] == '0':
a, idx = a + 1, idx + 1
while idx < n and s[idx] == '1':
b, idx = b + 1, idx + 1
ans = max(ans, min(a, b) * 2)
return ans
```
TypeScript 代码:
```TypeScript
function findTheLongestBalancedSubstring(s: string): number {
let n = s.length, idx = 0, ans = 0;
while (idx < n) {
let a = 0, b = 0;
while (idx < n && s[idx] == '0' && ++a >= 0) idx++;
while (idx < n && s[idx] == '1' && ++b >= 0) idx++;
ans = Math.max(ans, Math.min(a, b) * 2);
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2609` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/261-270/263. 丑数（简单）.md | 263. 丑数 | https://leetcode-cn.com/problems/ugly-number/solution/gong-shui-san-xie-jian-dan-de-fen-qing-k-dlvg/ | 简单 | [
"数学",
"模拟"
] | 给你一个整数 `n` ,请你判断 n 是否为 丑数 。如果是,返回 `true` ;否则,返回 `false` 。
丑数 就是只包含质因数 `2`、`3` 和 `5` 的正整数。
示例 1:
```
输入:n = 6
输出:true
解释:6 = 2 × 3
```
示例 2:
```
输入:n = 8
输出:true
解释:8 = 2 × 2 × 2
```
示例 3:
```
输入:n = 14
输出:false
解释:14 不是丑数,因为它包含了另外一个质因数 7 。
```
示例 4:
```
输入:n = 1
输出:true
解释:1 通常被视为丑数。
```
提示:
* $-2^{31} <= n <= 2^{31} - 1$ | ### 朴素解法
输入范围是 $-2^{31} <= n <= 2^{31} - 1$,我们只需要对输入进行分情况讨论即可:
* 如果 $n$ 不是正整数(即小于等于 0):必然不是丑数,直接返回 `false`。
* 如果 $n$ 是正整数:我们对 $n$ 执行 `2`、 `3`、 `5` 的整除操作即可,直到 $n$ 被除干净,如果 $n$ 最终为 1 说明是丑数,否则不是丑数。
注意,`2` `3` `5` 先除哪一个都是可以的,因为乘法本身具有交换律。
代码:
```java
class Solution {
public boolean isUgly(int n) {
if (n <= 0) return false;
while (n % 2 == 0) n /= 2;
while (n % 3 == 0) n /= 3;
while (n % 5 == 0) n /= 5;
return n == 1;
}
}
```
* 时间复杂度:当 $n$ 是以 $2$ 为底的对数时,需要除以 $\log{n}$ 次。复杂度为 $O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.263` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/261-270/264. 丑数 II（中等）.md | 264. 丑数 II | https://leetcode-cn.com/problems/ugly-number-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-3nvs/ | 中等 | [
"多路归并",
"优先队列(堆)"
] | 给你一个整数 `n` ,请你找出并返回第 `n` 个 丑数 。
丑数 就是只包含质因数 `2`、`3` 和 `5` 的正整数。
示例 1:
```
输入:n = 10
输出:12
解释:[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。
```
示例 2:
```
输入:n = 1
输出:1
解释:1 通常被视为丑数。
```
提示:
* $1 <= n <= 1690$ | ### 基本思路
根据丑数的定义,我们有如下结论:
* $1$ 是最小的丑数。
* 对于任意一个丑数 $x$,其与任意的质因数($2$、$3$、$5$)相乘,结果($2x$、$3x$、$5x$)仍为丑数。
---
### 优先队列(小根堆)
有了基本的分析思路,一个简单的解法是使用优先队列:
1. 起始先将最小丑数 $1$ 放入队列
2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的丑数 $2x$、$3x$ 和 $5x$ 进行入队。
3. 对步骤 2 循环多次,第 $n$ 次出队的值即是答案。
为了防止同一丑数多次进队,我们需要使用数据结构 $Set$ 来记录入过队列的丑数。
Java 代码:
```Java
class Solution {
int[] nums = new int[]{2,3,5};
public int nthUglyNumber(int n) {
Set<Long> set = new HashSet<>();
Queue<Long> pq = new PriorityQueue<>();
set.add(1L);
pq.add(1L);
for (int i = 1; i <= n; i++) {
long x = pq.poll();
if (i == n) return (int)x;
for (int num : nums) {
long t = num * x;
if (!set.contains(t)) {
set.add(t);
pq.add(t);
}
}
}
return -1;
}
}
```
Python 代码:
```Python
class Solution(object):
def nthUglyNumber(self, n):
"""
:type n: int
:rtype: int
"""
nums = [2,3,5]
explored = {1}
pq = [1]
for i in range(1, n+1):
x = heapq.heappop(pq)
if i == n:
return x
for num in nums:
t = num * x
if t not in explored:
explored.add(t)
heapq.heappush(pq,t)
return -1
```
C++ 代码:
```C++
class Solution {
public:
int nthUglyNumber(int n) {
int nums[] = {2, 3, 5};
set<long> s;
priority_queue<long, vector<long>, greater<long>> q;
s.insert(1);
q.push(1);
for (int i = 1; i <= n; i++)
{
long x = q.top();
q.pop();
if (i == n)
return (int)x;
for (int num = 0; num < 3; num++)
{
long t = nums[num] * x;
if (!s.count(t))
{
s.insert(t);
q.push(t);
}
}
}
return -1;
}
};
```
* 时间复杂度:从优先队列中取最小值为 $O(1)$,往优先队列中添加元素复杂度为 $O(\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 多路归并(多指针)
从解法一中不难发现,我们「往后产生的丑数」都是基于「已有丑数」而来(使用「已有丑数」乘上「质因数」$2$、$3$、$5$)。
因此,如果我们所有丑数的有序序列为 $a1,a2,a3,...,an$ 的话,序列中的每一个数都必然能够被以下三个序列(中的至少一个)覆盖:
* 由丑数 $\times 2$ 所得的有序序列:$1 \times 2$、$2 \times 2$、$3 \times 2$、$4 \times 2$、$5 \times 2$、$6 \times 2$、$8 \times 2$ ...
* 由丑数 $ \times 3$ 所得的有序序列:$1 \times 3$、$2 \times 3$、$3 \times 3$、$4 \times 3$、$5 \times 3$、$6 \times 3$、$8 \times 3$ ...
* 由丑数 $\times 5$ 所得的有序序列:$1 \times 5$、$2 \times 5$、$3 \times 5$、$4 \times 5$、$5 \times 5$、$6 \times 5$、$8 \times 5$ ...
举个🌰,假设我们需要求得 $[1, 2, 3, ... , 10, 12]$ 丑数序列 $arr$ 的最后一位,那么该序列可以看作以下三个有序序列归并而来:
* $1 \times 2, 2 \times 2, 3 \times 2, ... , 10 \times 2, 12 \times 2$ ,将 $2$ 提出,即 $arr \times 2$
* $1 \times 3, 2 \times 3, 3 \times 3, ... , 10 \times 3, 12 \times 3$ ,将 $3$ 提出,即 $arr \times 3$
* $1 \times 5, 2 \times 5, 3 \times 5, ... , 10 \times 5, 12 \times 5$ ,将 $5$ 提出,即 $arr \times 5$
因此我们可以使用三个指针来指向目标序列 $arr$ 的某个下标(下标 $0$ 作为哨兵不使用,起始都为 $1$),使用 $arr[下标] \times 质因数$ 代表当前使用到三个有序序列中的哪一位,同时使用 $idx$ 表示当前生成到 $arr$ 哪一位丑数。
Java 代码:
```Java
class Solution {
public int nthUglyNumber(int n) {
// ans 用作存储已有丑数(从下标 1 开始存储,第一个丑数为 1)
int[] ans = new int[n + 1];
ans[1] = 1;
// 由于三个有序序列都是由「已有丑数」*「质因数」而来
// i2、i3 和 i5 分别代表三个有序序列当前使用到哪一位「已有丑数」下标(起始都指向 1)
for (int i2 = 1, i3 = 1, i5 = 1, idx = 2; idx <= n; idx++) {
// 由 ans[iX] * X 可得当前有序序列指向哪一位
int a = ans[i2] * 2, b = ans[i3] * 3, c = ans[i5] * 5;
// 将三个有序序列中的最小一位存入「已有丑数」序列,并将其下标后移
int min = Math.min(a, Math.min(b, c));
// 由于可能不同有序序列之间产生相同丑数,因此只要一样的丑数就跳过(不能使用 else if )
if (min == a) i2++;
if (min == b) i3++;
if (min == c) i5++;
ans[idx] = min;
}
return ans[n];
}
}
```
Python 代码:
```Python
class Solution(object):
def nthUglyNumber(self, n):
"""
:type n: int
:rtype: int
"""
# ans 用作存储已有丑数(从下标 1 开始存储,第一个丑数为 1)
ans = [0] * (n+1)
ans[1] = 1
# 由于三个有序序列都是由「已有丑数」*「质因数」而来
# i2、i3 和 i5 分别代表三个有序序列当前使用到哪一位「已有丑数」下标(起始都指向 1)
i2 = i3 = i5 = 1
idx = 2
while idx <= n:
# 由 ans[iX] * X 可得当前有序序列指向哪一位
a,b,c = ans[i2] *2,ans[i3]*3,ans[i5]*5
# 将三个有序序列中的最小一位存入「已有丑数」序列,并将其下标后移
m = min(a,b,c)
# 由于可能不同有序序列之间产生相同丑数,因此只要一样的丑数就跳过(不能使用 else if )
if m == a:
i2 += 1
if m == b:
i3 += 1
if m == c:
i5 += 1
ans[idx] = m
idx += 1
return ans[n]
```
JavaScript 代码:
```JavaScript
/**
* @param {number} n
* @return {number}
*/
var nthUglyNumber = function(n) {
const ans=new Array(n+1);
ans[1]=1;
for(let i2=1, i3=1, i5=1, idx=2;idx<=n;idx++){
let a=ans[i2]*2, b=ans[i3]*3, c=ans[i5]*5;
let min=Math.min(a, b, c);
if(min===a) i2++;
if(min===b) i3++;
if(min===c) i5++;
ans[idx]=min;
}
return ans[n];
};
```
C++ 代码:
```C++
class Solution {
public:
int nthUglyNumber(int n) {
// 存储丑数
int *arr = new int[n + 1];
arr[1] = 1;
for (int x = 1, y = 1, z = 1, index = 2; index <= n; index++){
int a = arr[x] * 2, b = arr[y] * 3, c = arr[z] * 5;
int m = min(a, min(b, c));
if (m == a)x++;
if (m == b)y++;
if (m == c)z++;
arr[index] = m;
}
int ans = arr[n];
delete[] arr;
return ans;
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.264` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/261-270/268. 丢失的数字（简单）.md | 268. 丢失的数字 | https://leetcode-cn.com/problems/missing-number/solution/gong-shui-san-xie-yi-ti-wu-jie-pai-xu-ji-te3s/ | 简单 | [
"模拟",
"哈希表",
"位运算",
"数学"
] | 给定一个包含 $[0, n]$ 中 $n$ 个数的数组 $nums$ ,找出 $[0, n]$ 这个范围内没有出现在数组中的那个数。
示例 1:
```
输入:nums = [3,0,1]
输出:2
解释:n = 3,因为有 3 个数字,所以所有的数字都在范围 [0,3] 内。2 是丢失的数字,因为它没有出现在 nums 中。
```
示例 2:
```
输入:nums = [0,1]
输出:2
解释:n = 2,因为有 2 个数字,所以所有的数字都在范围 [0,2] 内。2 是丢失的数字,因为它没有出现在 nums 中。
```
示例 3:
```
输入:nums = [9,6,4,2,3,5,7,0,1]
输出:8
解释:n = 9,因为有 9 个数字,所以所有的数字都在范围 [0,9] 内。8 是丢失的数字,因为它没有出现在 nums 中。
```
示例 4:
```
输入:nums = [0]
输出:1
解释:n = 1,因为有 1 个数字,所以所有的数字都在范围 [0,1] 内。1 是丢失的数字,因为它没有出现在 nums 中。
```
提示:
* n == nums.length
* $1 <= n <= 10^4$
* $0 <= nums[i] <= n$
* nums 中的所有数字都 独一无二
进阶:你能否实现线性时间复杂度、仅使用额外常数空间的算法解决此问题? | ### 排序
一个简单的做法是直接对 $nums$ 进行排序,找到符合 $nums[i] \neq i$ 的位置即是答案,如果不存在 $nums[i] \neq i$ 的位置,则 $n$ 为答案。
代码;
```Java
class Solution {
public int missingNumber(int[] nums) {
int n = nums.length;
Arrays.sort(nums);
for (int i = 0; i < n; i++) {
if (nums[i] != i) return i;
}
return n;
}
}
```
* 时间复杂度:假定 `Arrays.sort` 使用的是双轴快排实现。复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 数组哈希
利用 $nums$ 的数值范围为 $[0,n]$,且只有一个值缺失,我们可以直接开一个大小为 $n + 1$ 的数组充当哈希表,进行计数,没被统计到的数值即是答案。
代码:
```Java
class Solution {
public int missingNumber(int[] nums) {
int n = nums.length;
boolean[] hash = new boolean[n + 1];
for (int i = 0; i < n; i++) hash[nums[i]] = true;
for (int i = 0; i < n; i++) {
if (!hash[i]) return i;
}
return n;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 原地哈希
事实上,我们可以将 $nums$ 本身作为哈希表进行使用,将 $nums[i]$ 放到其应该出现的位置 $i$ 上( $i < n$ ),然后对 $nums$ 进行检查,找到满足 $nums[i] \neq i$ 的位置即是答案,如果不存在 $nums[i] \neq i$ 的位置,则 $n$ 为答案。
代码:
```Java
class Solution {
public int missingNumber(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
if (nums[i] != i && nums[i] < n) swap(nums, nums[i], i--);
}
for (int i = 0; i < n; i++) {
if (nums[i] != i) return i;
}
return n;
}
void swap(int[] nums, int i, int j) {
int c = nums[i];
nums[i] = nums[j];
nums[j] = c;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 作差法
利用 $nums$ 的数值范围为 $[1, n]$,我们可以先计算出 $[1, n]$ 的总和 $sum$(利用等差数列求和公式),再计算 $nums$ 的总和 $cur$,两者之间的差值即是 $nums$ 中缺失的数字。
代码:
```Java
class Solution {
public int missingNumber(int[] nums) {
int n = nums.length;
int cur = 0, sum = n * (n + 1) / 2;
for (int i : nums) cur += i;
return sum - cur;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 异或
找缺失数、找出现一次数都是异或的经典应用。
我们可以先求得 $[1, n]$ 的异或和 $ans$,然后用 $ans$ 对各个 $nums[i]$ 进行异或。
这样最终得到的异或和表达式中,只有缺失元素出现次数为 $1$ 次,其余元素均出现两次($x ⊕x = 0$),即最终答案 $ans$ 为缺失元素。
代码:
```Java
class Solution {
public int missingNumber(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0; i <= n; i++) ans ^= i;
for (int i : nums) ans ^= i;
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.268` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2641-2650/2646. 最小化旅行的价格总和（困难）.md | 2646. 最小化旅行的价格总和 | null | 困难 | [
"图",
"DFS"
] | 现有一棵无向、无根的树,树中有 `n` 个节点,按从 `0` 到 `n - 1` 编号。
给你一个整数 `n` 和一个长度为 `n - 1` 的二维整数数组 `edges`,其中 $edges[i] = [a_{i}, b_{i}]$ 表示树中节点 $a_{i}$ 和 $b_{i}$ 之间存在一条边。
每个节点都关联一个价格。给你一个整数数组 `price`,其中 `price[i]` 是第 `i` 个节点的价格。
给定路径的价格总和是该路径上所有节点的价格之和。
另给你一个二维整数数组 `trips`,其中 $trips[i] = [start_{i}, end_{i}]$ 表示您从节点 $start_{i}$ 开始第 $i$ 次旅行,并通过任何你喜欢的路径前往节点 $end_{i}$。
在执行第一次旅行之前,你可以选择一些非相邻节点并将价格减半。
返回执行所有旅行的最小价格总和。
示例 1:
```
输入:n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,2,10,6], trips = [[0,3],[2,1],[2,3]]
输出:23
解释:
上图表示将节点 2 视为根之后的树结构。第一个图表示初始树,第二个图表示选择节点 0 、2 和 3 并使其价格减半后的树。
第 1 次旅行,选择路径 [0,1,3] 。路径的价格总和为 1 + 2 + 3 = 6 。
第 2 次旅行,选择路径 [2,1] 。路径的价格总和为 2 + 5 = 7 。
第 3 次旅行,选择路径 [2,1,3] 。路径的价格总和为 5 + 2 + 3 = 10 。
所有旅行的价格总和为 6 + 7 + 10 = 23 。可以证明,23 是可以实现的最小答案。
```
示例 2:
```
输入:n = 2, edges = [[0,1]], price = [2,2], trips = [[0,0]]
输出:1
解释:
上图表示将节点 0 视为根之后的树结构。第一个图表示初始树,第二个图表示选择节点 0 并使其价格减半后的树。
第 1 次旅行,选择路径 [0] 。路径的价格总和为 1 。
所有旅行的价格总和为 1 。可以证明,1 是可以实现的最小答案。
```
提示:
* $1 <= n <= 50$
* $edges.length = n - 1$
* $0 <= a_{i}, b_{i} <= n - 1$
* `edges` 表示一棵有效的树
* $price.length = n$
* $price[i]$ 是一个偶数
* $1 <= price[i] <= 1000$
* $1 <= trips.length <= 100$
* $0 <= start_{i}, end_{i} <= n - 1$ | ### DFS
Java 代码:
```Java
class Solution {
int N = 55, M = N * 2, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] trips) {
Arrays.fill(he, -1);
for (int[] info : edges) {
add(info[0], info[1]); add(info[1], info[0]);
}
int[] cnt = new int[n];
for (int[] trip : trips) dfs1(trip[0], -1, trip[1], cnt);
int[] ans = dfs2(0, -1, price, cnt);
return Math.min(ans[0], ans[1]);
}
int[] dfs2(int u, int fa, int[] price, int[] cnt) {
int a = price[u] / 2 * cnt[u], b = price[u] * cnt[u];
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
int[] info = dfs2(j, u, price, cnt);
int c = info[0], d = info[1];
a += d; b += Math.min(c, d);
}
return new int[]{a, b};
}
boolean dfs1(int u, int fa, int end, int[] cnt) {
if (u == end) {
cnt[u]++;
return true;
}
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
if (dfs1(j, u, end, cnt)) {
cnt[u]++;
return true;
}
}
return false;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int he[55], e[55 * 2], ne[55 * 2], idx = 0;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
int minimumTotalPrice(int n, vector<vector<int>>& edges, vector<int>& price, vector<vector<int>>& trips) {
memset(he, -1, sizeof(he));
for (auto& info : edges) {
add(info[0], info[1]); add(info[1], info[0]);
}
vector<int> cnt(n, 0);
for (auto& trip : trips) dfs1(trip[0], -1, trip[1], cnt);
vector<int> ans = dfs2(0, -1, price, cnt);
return min(ans[0], ans[1]);
}
vector<int> dfs2(int u, int fa, vector<int>& price, vector<int>& cnt) {
int a = price[u] / 2 * cnt[u], b = price[u] * cnt[u];
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
vector<int> info = dfs2(j, u, price, cnt);
int c = info[0], d = info[1];
a += d; b += min(c, d);
}
return {a, b};
}
bool dfs1(int u, int fa, int end, vector<int>& cnt) {
if (u == end) {
cnt[u]++;
return true;
}
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
if (dfs1(j, u, end, cnt)) {
cnt[u]++;
return true;
}
}
return false;
}
};
```
Python 代码:
```Python
class Solution:
def minimumTotalPrice(self, n: int, edges: List[List[int]], price: List[int], trips: List[List[int]]) -> int:
idx = 0
he, e, ne = [-1] * n, [0] * n * 2, [0] * n * 2
def add(a, b):
nonlocal idx
e[idx], ne[idx], he[a] = b, he[a], idx
idx += 1
def dfs1(u, fa, end):
if u == end:
cnt[u] += 1
return True
i = he[u]
while i != -1:
j, i = e[i], ne[i]
if j == fa: continue
if dfs1(j, u, end):
cnt[u] += 1
return True
return False
def dfs2(u, fa):
a, b = price[u] // 2 * cnt[u], price[u] * cnt[u]
i = he[u]
while i != -1:
j, i = e[i], ne[i]
if j == fa: continue
c, d = dfs2(j, u)
a += d
b += min(c, d)
return [a, b]
for info in edges:
add(info[0], info[1])
add(info[1], info[0])
cnt = [0] * n
for trip in trips:
dfs1(trip[0], -1, trip[1])
ans = dfs2(0, -1)
return min(ans[0], ans[1])
```
TypeScript 代码:
```TypeScript
function minimumTotalPrice(n: number, edges: number[][], price: number[], trips: number[][]): number {
let N = n + 10, M = N * 2, idx = 0;
const he = Array(N).fill(-1), e = Array(N).fill(0), ne = Array(N).fill(0);
const add = function(a: number, b: number): void {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
};
const dfs1 = function(u: number, fa: number, end: number): boolean {
if (u == end) {
cnt[u]++;
return true;
}
for (let i = he[u]; i != -1; i = ne[i]) {
const j = e[i];
if (j == fa) continue;
if (dfs1(j, u, end)) {
cnt[u]++;
return true;
}
}
return false;
};
const dfs2 = function(u: number, fa: number): number[] {
let a = price[u] / 2 * cnt[u], b = price[u] * cnt[u];
for (let i = he[u]; i != -1; i = ne[i]) {
const j = e[i];
if (j == fa) continue;
const [c, d] = dfs2(j, u);
a += d; b += Math.min(c, d);
}
return [a, b];
}
for (const [a, b] of edges) {
add(a, b); add(b, a);
}
const cnt = Array(N).fill(0)
for (const [a, b] of trips) dfs1(a, -1, b);
const [a, b] = dfs2(0, -1);
return Math.min(a, b);
};
```
* 时间复杂度:令 `m` 为 `trips` 的大小,建图复杂度为 $O(n)$;统计完成 `trips` 时,每个点的经过次数 `cnt` 的复杂度为 $O(m \times n)$;最后统计答案复杂度为 $O(n)$。整体复杂度为 $O(m \times n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2651-2660/2656. K 个元素的最大和（简单）.md | 2656. K 个元素的最大和 | https://leetcode.cn/problems/maximum-sum-with-exactly-k-elements/solutions/2527384/gong-shui-san-xie-deng-chai-shu-lie-qiu-b2g88/ | 简单 | [
"数学"
] | 给你一个下标从 `0` 开始的整数数组 `nums` 和一个整数 `k` 。
你需要执行以下操作恰好 `k` 次,最大化你的得分:
1. 从 `nums` 中选择一个元素 `m` 。
2. 将选中的元素 `m` 从数组中删除。
3. 将新元素 `m + 1` 添加到数组中。
4. 你的得分增加 `m` 。
请你返回执行以上操作恰好 `k` 次后的最大得分。
示例 1:
```
输入:nums = [1,2,3,4,5], k = 3
输出:18
解释:我们需要从 nums 中恰好选择 3 个元素并最大化得分。
第一次选择 5 。和为 5 ,nums = [1,2,3,4,6] 。
第二次选择 6 。和为 6 ,nums = [1,2,3,4,7] 。
第三次选择 7 。和为 5 + 6 + 7 = 18 ,nums = [1,2,3,4,8] 。
所以我们返回 18 。
18 是可以得到的最大答案。
```
示例 2:
```
输入:nums = [5,5,5], k = 2
输出:11
解释:我们需要从 nums 中恰好选择 2 个元素并最大化得分。
第一次选择 5 。和为 5 ,nums = [5,5,6] 。
第二次选择 6 。和为 6 ,nums = [5,5,7] 。
所以我们返回 11 。
11 是可以得到的最大答案。
```
提示:
* $1 <= nums.length <= 100$
* $1 <= nums[i] <= 100$
* $1 <= k <= 100$ | ### 数学
为了使得分最高,每次应从 `nums` 中选最大值,选完后重放仍为最大值。
假设原始 `nums` 中的最大值为 `max`,那么问题转换为「等差数列」求和:首项为 `max`,末项为 `max + k - 1`,项数为 $k$,公差为 $1$。
Java 代码:
```Java
class Solution {
public int maximizeSum(int[] nums, int k) {
int max = 0;
for (int x : nums) max = Math.max(max, x);
return k * (max + max + k - 1) / 2;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maximizeSum(vector<int>& nums, int k) {
int maxv = 0;
for (auto x : nums) maxv = max(maxv, x);
return k * (maxv + maxv + k - 1) / 2;
}
};
```
Python 代码:
```Python
class Solution:
def maximizeSum(self, nums: List[int], k: int) -> int:
return k * (2 * max(nums) + k - 1) // 2
```
TypeScript 代码:
```TypeScript
function maximizeSum(nums: number[], k: number): number {
let max = 0;
for (const x of nums) max = Math.max(max, x);
return k * (max + max + k - 1) / 2;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2656` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2661-2670/2661. 找出叠涂元素（中等）.md | 2661. 找出叠涂元素 | https://leetcode.cn/problems/first-completely-painted-row-or-column/solutions/2549034/gong-shui-san-xie-chang-gui-ha-xi-biao-y-jkxa/ | 中等 | [
"模拟",
"哈希表",
"计数"
] | 给你一个下标从 $0$ 开始的整数数组 `arr` 和一个 $m \times n$ 的整数矩阵 `mat`。
`arr` 和 `mat` 都包含范围 $[1,m \times n]$ 内的所有整数。
从下标 $0$ 开始遍历 `arr` 中的每个下标 `i` ,并将包含整数 `arr[i]` 的 `mat` 单元格涂色。
请你找出 `arr` 中在 `mat` 的某一行或某一列上都被涂色且下标最小的元素,并返回其下标 $i$ 。
示例 1:
```
输入:arr = [1,3,4,2], mat = [[1,4],[2,3]]
输出:2
解释:遍历如上图所示,arr[2] 在矩阵中的第一行或第二列上都被涂色。
```
示例 2:
```
image explanation for example 2
输入:arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]
输出:3
解释:遍历如上图所示,arr[3] 在矩阵中的第二列上都被涂色。
```
提示:
* $m = mat.length$
* $n = mat[i].length$
* $arr.length = m \times n$
* $1 <= m, n <= 10^5$
* $1 <= m \times n <= 105$
* $1 <= arr[i], mat[r][c] <= m \times n$
* `arr` 中的所有整数互不相同
* `mat` 中的所有整数互不相同 | ### 哈希表
利用 `mat` 的数值各不相同,先使用「哈希表」对 `mat` 进行转存,以 $mat[i][j]$ 为键,$(i, j)$ 为值,方便后续快速查询某个值所在位置。
创建数组 `c1` 和 `c2`,分别记录某行某列有多少单元格被涂色,如 `c1[x] = a` 代表第 $x$ 行被涂色单元格数量为 $a$ 个,`c2[y] = b` 代表第 $y$ 列被涂色单元格数量为 $b$ 个。
遍历所有的 $arr[i]$,查询到 $arr[i]$ 的所在位置 $(x, y)$ 后,更新 `c1` 和 `c2`,若某行或某列被完全涂色,返回当前下标。
Java 代码:
```Java
class Solution {
public int firstCompleteIndex(int[] arr, int[][] mat) {
int n = mat.length, m = mat[0].length;
Map<Integer, int[]> map = new HashMap<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
map.put(mat[i][j], new int[]{i, j});
}
}
int[] c1 = new int[n], c2 = new int[m];
for (int i = 0; i < n * m; i++) {
int[] info = map.get(arr[i]);
int x = info[0], y = info[1];
if (++c1[x] == m || ++c2[y] == n) return i;
}
return -1; // never
}
}
```
C++ 代码:
```C++
class Solution {
public:
int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
int n = mat.size(), m = mat[0].size();
unordered_map<int, pair<int, int>> map;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
map[mat[i][j]] = make_pair(i, j);
}
}
vector<int> c1(n), c2(m);
for (int i = 0; i < n * m; i++) {
pair<int, int> info = map[arr[i]];
int x = info.first, y = info.second;
if (++c1[x] == m || ++c2[y] == n) return i;
}
return -1; // never
}
};
```
Python 代码:
```Python
class Solution:
def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
n, m = len(mat), len(mat[0])
mapping = {mat[i][j]: (i, j) for i in range(n) for j in range(m)}
c1, c2 = [0] * n, [0] * m
for i in range(n * m):
x, y = mapping[arr[i]]
c1[x], c2[y] = c1[x] + 1, c2[y] + 1
if c1[x] == m or c2[y] == n: return i
return -1 # never
```
TypeScript 代码:
```TypeScript
function firstCompleteIndex(arr: number[], mat: number[][]): number {
const n = mat.length, m = mat[0].length;
const map: { [key: number]: [number, number] } = {};
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
map[mat[i][j]] = [i, j];
}
}
const c1 = new Array(n).fill(0), c2 = new Array(m).fill(0);
for (let i = 0; i < n * m; i++) {
const [x, y] = map[arr[i]];
if (++c1[x] == m || ++c2[y] === n) return i;
}
return -1; // never
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2661` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2698-2700/2698. 求一个整数的惩罚数（中等）.md | 2698. 求一个整数的惩罚数 | https://leetcode.cn/problems/find-the-punishment-number-of-an-integer/solutions/2497448/gong-shui-san-xie-jian-dan-di-gui-yun-yo-qdxl/ | 中等 | [
"递归",
"模拟",
"打表"
] | 给你一个正整数 $n$,请你返回 $n$ 的 惩罚数 。
$n$ 的 惩罚数 定义为所有满足以下条件 $i$ 的数的平方和:
* $1 <= i <= n$
* $i \times i$ 的十进制表示的字符串可以分割成若干连续子字符串,且这些子字符串对应的整数值之和等于 $i$ 。
示例 1:
```
输入:n = 10
输出:182
解释:总共有 3 个整数 i 满足要求:
- 1 ,因为 1 * 1 = 1
- 9 ,因为 9 * 9 = 81 ,且 81 可以分割成 8 + 1 。
- 10 ,因为 10 * 10 = 100 ,且 100 可以分割成 10 + 0 。
因此,10 的惩罚数为 1 + 81 + 100 = 182
```
示例 2:
```
输入:n = 37
输出:1478
解释:总共有 4 个整数 i 满足要求:
- 1 ,因为 1 * 1 = 1
- 9 ,因为 9 * 9 = 81 ,且 81 可以分割成 8 + 1 。
- 10 ,因为 10 * 10 = 100 ,且 100 可以分割成 10 + 0 。
- 36 ,因为 36 * 36 = 1296 ,且 1296 可以分割成 1 + 29 + 6 。
因此,37 的惩罚数为 1 + 81 + 100 + 1296 = 1478
```
提示:
* $1 <= n <= 1000$ | ### 递归
一个朴素的做法是遍历 $[1, i]$,若当前数值 $i$ 满足要求,则将 $i \times i$ 累加到答案中。
问题关键转为:如何判定 $i \times i$ 是否能够分割成多个整数,使其累加值为 $i$。
简单做法是通过递归来做:每次从当前值的低位开始截取,通过「取余」和「地板除」操作,得到截取部分和剩余部分,再继续递归处理。
Java 代码:
```Java
class Solution {
public int punishmentNumber(int n) {
int ans = 0;
for (int i = 1; i <= n; i++) {
if (check(i * i, i)) ans += i * i;
}
return ans;
}
boolean check(int t, int x) {
if (t == x) return true;
int d = 10;
while (t >= d && t % d <= x) {
if (check(t / d, x - (t % d))) return true;
d *= 10;
}
return false;
}
}
```
Python 代码:
```Python
class Solution:
def punishmentNumber(self, n: int) -> int:
def check(t, x):
if t == x:
return True
d = 10
while t >= d and t % d <= x:
if check(t // d, x - (t % d)):
return True
d *= 10
return False
return sum([i * i if check(i * i, i) else 0 for i in range(1, n + 1)])
```
C++ 代码:
```C++
class Solution {
public:
bool check(int t, int x) {
if (t == x) return true;
int d = 10;
while (t >= d && t % d <= x) {
if (check(t / d, x - (t % d))) return true;
d *= 10;
}
return false;
}
int punishmentNumber(int n) {
int ans = 0;
for (int i = 1; i <= n; i++) {
if (check(i * i, i)) ans += i * i;
}
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function punishmentNumber(n: number): number {
function check(t: number, x: number): boolean {
if (t === x) return true;
let d = 10;
while (t >= d && t % d <= x) {
if (check(Math.floor(t / d), x - (t % d))) return true;
d *= 10;
}
return false;
}
let ans = 0;
for (let i = 1; i <= n; i++) {
if (check(i * i, i)) ans += i * i;
}
return ans;
};
```
* 时间复杂度:$O(n \log{n^2})$
* 空间复杂度:$O(\log{n^2})$
---
### 打表
更进一步,对于 $[1, x]$ 范围内的惩罚数必然包含了 $[1, y]$(其中 $y < x$)中的惩罚数。
即多个样例之间必然存在重复计算,我们可通过「打表」进行预处理:定义 $f[i]$ 为 $n = i$ 时的答案(惩罚数),对于 $f[i]$ 而言,起始为 $f[i - 1]$,若数值 $i$ 本身满足要求,则将 $i \times i$ 累加到 $f[i]$ 当中。
Java 代码:
```Java
class Solution {
static int[] f = new int[1010];
static {
for (int i = 1; i <= 1000; i++) {
f[i] = f[i - 1];
if (check(i * i, i)) f[i] += i * i;
}
}
static boolean check(int t, int x) {
if (t == x) return true;
int d = 10;
while (t >= d && t % d <= x) {
if (check(t / d, x - (t % d))) return true;
d *= 10;
}
return false;
}
public int punishmentNumber(int n) {
return f[n];
}
}
```
Python 代码:
```Python
def check(t, x):
if t == x:
return True
d = 10
while t >= d and t % d <= x:
if check(t // d, x - (t % d)):
return True
d *= 10
return False
f = [0] * 1010
for i in range(1, 1010):
f[i] = f[i - 1] + (i * i if check(i * i, i) else 0)
class Solution:
def punishmentNumber(self, n: int) -> int:
return f[n]
```
C++ 代码:
```C++
inline bool check(int t, int x) {
if (t == x) return true;
int d = 10;
while (t >= d && t % d <= x) {
if (check(t / d, x - (t % d))) return true;
d *= 10;
}
return false;
}
int f[1010];
int _ = []() {
for (int i = 1; i < 1010; i++) {
f[i] = f[i - 1];
if (check(i * i, i)) f[i] += i * i;
}
return 0;
}();
class Solution {
public:
int punishmentNumber(int n) {
return f[n];
}
};
```
TypeScript 代码:
```TypeScript
function check(t: number, x: number): boolean {
if (t === x) return true;
let d = 10;
while (t >= d && t % d <= x) {
if (check(Math.floor(t / d), x - (t % d))) return true;
d *= 10;
}
return false;
}
const f = new Array(1010).fill(0);
for (let i = 1; i < 1010; i++) {
f[i] = f[i - 1];
if (check(i * i, i)) f[i] += i * i;
}
function punishmentNumber(n: number): number {
return f[n];
};
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(C)$,其中 $C = 1000$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2698` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/273. 整数转换英文表示（困难）.md | 273. 整数转换英文表示 | https://leetcode-cn.com/problems/integer-to-english-words/solution/gong-shui-san-xie-zi-fu-chuan-da-mo-ni-b-0my6/ | 困难 | [
"模拟"
] | 将非负整数 `num` 转换为其对应的英文表示。
示例 1:
```
输入:num = 123
输出:"One Hundred Twenty Three"
```
示例 2:
```
输入:num = 12345
输出:"Twelve Thousand Three Hundred Forty Five"
```
示例 3:
```
输入:num = 1234567
输出:"One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
```
示例 4:
```
输入:num = 1234567891
输出:"One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One"
```
提示:
* $0 <= num <= 2^{31} - 1$ | ### 模拟
字符串大模拟,重点之一是考察大家对数字英文单词的熟练程度。🤣
首先,英文好的同学自然知道数字表示是每三位一组进行的,英文不好的可能需要通过样例来找找规律。
由于是每三位一组进行表示,首要考虑实现一个 `num2Str` 函数,将十进制长度小于等于 $3$ 位的数字表示出来,然后在后面配合 `Billion`、`Million` 和 `Thousand` 即可表示出范围不超过 $2^{32}-1$ 的任意数字。
从定义出发 `num2Str` 需要解决 $[0, 999]$ 范围内的所有整数,但由于该函数需要复用到更大的位数来配合 `Billion`、`Million` 和 `Thousand`,而 `Zero Billion` 并不是一个合法的描述,因此我们需要将 $0$ 抠出来特判,让 `num2Str` 对范围在 $[1, 999]$ 的数值进行转换。
考虑如何实现 `num2Str`,假设当前需要转换的数字为 $x$,我们可以对 $x$ 的大小进行分情况讨论:
1. $x >= 100$:此时首先需要表示成 `??? hundred`,表示完后考虑更小的位数;
2. $x >= 20$:此时需要表示成 `??? XXX-ty` 的形式,表示完后考虑更小的位数;
3. $x < 20$:直接描述成具体的单词。
实现完 `num2Str` 后,剩下的只需要考虑如何将入参 $num$ 拆分成每三位一组处理即可。
代码:
```Java
class Solution {
static String[] num2str_small = {
"Zero",
"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
"Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"
};
static String[] num2str_medium = {
"", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"
};
static String[] num2str_large = {
"Billion", "Million", "Thousand", "",
};
String num2Str(int x) {
String ans = "";
if (x >= 100) {
ans += num2str_small[x / 100] + " Hundred ";
x %= 100;
}
if (x >= 20) {
ans += num2str_medium[x / 10] + " ";
x %= 10;
}
if (x != 0) ans += num2str_small[x] + " ";
return ans;
}
public String numberToWords(int num) {
if (num == 0) return num2str_small[0];
StringBuilder sb = new StringBuilder();
for (int i = (int)1e9, j = 0; i >= 1; i /= 1000, j++) {
if (num < i) continue;
sb.append(num2Str(num / i) + num2str_large[j] + " ");
num %= i;
}
while (sb.charAt(sb.length() - 1) == ' ') sb.deleteCharAt(sb.length() - 1);
return sb.toString();
}
}
```
* 时间复杂度:令 $n$ 为 $num$ 数值大小,复杂度取决于最终构建的答案的长度,由于是每三位一组进行处理,同时每三位一组所转换的英文描述有明确的长度上界,因此最终答案长度与 $num$ 的十进制长度成线性关系,再根据 $num$ 的长度与 $num$ 数值的关系,可得最终复杂度为 $O(\log{n})$
* 空间复杂度:令 $n$ 为 $num$ 数值大小,复杂度取决于最终构建的答案的长度,由于是每三位一组进行处理,同时每三位一组所转换的英文描述有明确的长度上界,因此最终答案长度与 $num$ 的十进制长度成线性关系,再根据 $num$ 的长度与 $num$ 数值的关系,可得最终复杂度为 $O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.273` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/274. H 指数（中等）.md | 274. H 指数 | https://leetcode.cn/problems/h-index/solutions/2502896/gong-shui-san-xie-cong-po-ti-dao-zhu-bu-7sug6/ | 中等 | [
"二分",
"数学"
] | 给你一个整数数组 `citations`,其中 `citations[i]` 表示研究者的第 `i` 篇论文被引用的次数。计算并返回该研究者的 h 指数。
根据维基百科上 `h` 指数的定义:`h` 代表“高引用次数”,一名科研人员的 h指数是指他(她)的 (`n` 篇论文中)总共有 `h` 篇论文分别被引用了至少 `h` 次。且其余的 `n - h` 篇论文每篇被引用次数 不超过 `h` 次。
如果 `h` 有多种可能的值,`h` 指数是其中最大的那个。
示例 1:
```
输入:citations = [3,0,6,1,5]
输出:3
解释:给定数组表示研究者总共有 5 篇论文,每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
由于研究者有 3 篇论文每篇 至少 被引用了 3 次,其余两篇论文每篇被引用 不多于 3 次,所以她的 h 指数是 3。
```
示例 2:
```
输入:citations = [1,3,1]
输出:1
```
提示:
* $n == citations.length$
* $1 <= n <= 5000$
* $0 <= citations[i] <= 1000$ | ### 基本分析
为了方便,将 `citations` 记为 `cs`。
所谓的 `h` 指数是指一个具体的数值,**该数值为“最大”的满足「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」定义的合法数,重点是“最大”**。
用题面的实例 $1$ 来举个 🌰,给定所有论文的引用次数情况为 `cs = [3,0,6,1,5]`,可统计满足定义的数值有哪些:
* $h = 0$,含义为「至少发表了 $0$ 篇,且这 $0$ 篇论文至少被引用 $0$ 次」,空集即满足,恒成立;
* $h = 1$,含义为「至少发表了 $1$ 篇,且这 $1$ 篇论文至少被引用 $1$ 次」,可以找到这样的组合,如 `[3]`,成立;
* $h = 2$,含义为「至少发表了 $2$ 篇,且这 $2$ 篇论文至少被引用 $2$ 次」,可以找到这样的组合,如 `[3, 6]`,成立;
* $h = 3$,含义为「至少发表了 $3$ 篇,且这 $3$ 篇论文至少被引用 $3$ 次」,可以找到这样的组合,如 `[3, 6, 5]`,成立;
* $h = 4$,含义为「至少发表了 $4$ 篇,且这 $4$ 篇论文至少被引用 $4$ 次」,找不到这样的组合,不成立;
* ...
实际上,**当遇到第一个无法满足的数时,更大的数值就没必要找了**。一个简单的推导:
至少出现 $k$ 次的论文数不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k + 1$ 篇(即更大的 $h$ 不满足)。
----
### 二分
基于此分析,我们发现对于任意的 `cs`(论文总数量为该数组长度 $n$),都必然对应了一个最大的 `h` 值,且**小于等于该 `h` 值的情况均满足,大于该 `h` 值的均不满足**。
那么,**在以最大 `h` 值为分割点的数轴上具有「二段性」**,可通过「二分」求解该分割点(答案)。
最后考虑在什么值域范围内进行二分?
一个合格的二分范围,仅需确保答案在此范围内即可。
再回看我们关于 `h` 的定义「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」,满足条件除了引用次数,还有论文数量,而总的论文数量只有 $n$,因此最大的 `h` 只能是 $n$ 本身,而不能是比 $n$ 大的数,否则论文数量就不够了。
综上,我们只需要在 $[0, n]$ 范围进行二分即可。对于任意二分值 `mid`,只需线性扫描 `cs` 即可知道其是否合法。
Java 代码:
```Java
class Solution {
public int hIndex(int[] cs) {
int n = cs.length;
int l = 0, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(cs, mid)) l = mid;
else r = mid - 1;
}
return r;
}
boolean check(int[] cs, int mid) {
int ans = 0;
for (int i : cs) if (i >= mid) ans++;
return ans >= mid;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int hIndex(vector<int>& cs) {
int n = cs.size();
int l = 0, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(cs, mid)) l = mid;
else r = mid - 1;
}
return r;
}
bool check(vector<int>& cs, int x) {
int cnt = 0;
for (int c : cs) {
if (c >= x) cnt++;
}
return cnt >= x;
}
};
```
Python 代码:
```Python
class Solution:
def hIndex(self, cs: List[int]) -> int:
n = len(cs)
l, r = 0, n
while l < r:
mid = (l + r + 1) // 2
if sum(c >= mid for c in cs) >= mid:
l = mid
else:
r = mid - 1
return r
```
TypeScript 代码:
```TypeScript
function hIndex(cs: number[]): number {
const check = function (cs: number[], x: number): boolean {
let cnt: number = 0;
for (let c of cs) {
if (c >= x) cnt++;
}
return cnt >= x;
}
const n = cs.length;
let l = 0, r = n;
while (l < r) {
const mid = Math.floor((l + r + 1) / 2);
if (check(cs, mid)) l = mid;
else r = mid - 1;
}
return r;
};
```
* 时间复杂度:对 $[0, n]$ 做二分,复杂度为 $O(\log{n})$;`check` 函数需要对数组进行线性遍历,复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(1)$
---
### 计数
根据分析,利用最大的 `h` 不超过 $n$,我们可以再进一步,利用空间换时间,将复杂度降低到 $O(n)$。
假设我们预处理出引用次数所对应的论文数量 `cnt`,其中 `cnt[a] = b` 含义为引用次数 **恰好** 为 `a` 的论文数量有 `b` 篇。
那么再利用 `h` 是“最大”的满足定义的合法数,我们从 $n$ 开始往前找,找到的第一个满足条件的数,即是答案。
具体的,创建 `cnt` 数组,对 `cs` 进行计数,由于最大 `h` 不超过 $n$,因此对于引用次数超过 $n$ 的论文,可等价为引用次数为 $n$,即有计数逻辑 `cnt[min(c, n)]++`。
再根据处理好的 `cnt`,从 $n$ 开始倒序找 `h`。
由于我们处理的 `cnt[a]` 含义为引用次数 **恰好** 为 `a`,但题目定义则是 **至少**。同时「至少出现 $k + 1$ 次」的集合必然慢「至少出现 $k$ 次」要求(子集关系),我们可以使用变量 `tot`,对处理过的 `cnt[i]` 进行累加,从而实现从 **恰好** 到 **至少** 的转换。
Java 代码:
```Java
class Solution {
public int hIndex(int[] cs) {
int n = cs.length;
int[] cnt = new int[n + 10];
for (int c : cs) cnt[Math.min(c, n)]++;
for (int i = n, tot = 0; i >= 0; i--) {
tot += cnt[i];
if (tot >= i) return i;
}
return -1; // never
}
}
```
C++ 代码:
```C++
class Solution {
public:
int hIndex(vector<int>& cs) {
int n = cs.size();
vector<int> cnt(n + 10, 0);
for (int c : cs) cnt[min(c, n)]++;
for (int i = n, tot = 0; i >= 0; i--) {
tot += cnt[i];
if (tot >= i) return i;
}
return -1; // never
}
};
```
Python 代码:
```Python
class Solution:
def hIndex(self, cs: List[int]) -> int:
n = len(cs)
cnt = [0] * (n + 10)
for c in cs:
cnt[min(c, n)] += 1
tot = 0
for i in range(n, -1, -1):
tot += cnt[i]
if tot >= i:
return i
return -1 # never
```
TypeScript 代码:
```TypeScript
function hIndex(cs: number[]): number {
const n = cs.length;
const cnt = new Array(n + 10).fill(0);
for (let c of cs) cnt[Math.min(c, n)]++;
for (let i = n, tot = 0; i >= 0; i--) {
tot += cnt[i];
if (tot >= i) return i;
}
return -1; // never
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.274` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/275. H 指数 II（中等）.md | 275. H 指数 II | https://leetcode.cn/problems/h-index-ii/solutions/2504414/gong-shui-san-xie-si-hua-guo-du-cong-xia-rs00/ | 中等 | [
"二分",
"数学"
] | 给你一个整数数组 `citations`,其中 `citations[i]` 表示研究者的第 `i` 篇论文被引用的次数,`citations` 已经按照 **升序排列 **。计算并返回该研究者的 `h` 指数。
`h` 指数的定义:`h` 代表“高引用次数”(high citations),一名科研人员的 `h` 指数是指他(她)的 (`n` 篇论文中)总共有 `h` 篇论文分别被引用了至少 `h` 次。
请你设计并实现对数时间复杂度的算法解决此问题。
示例 1:
```
输入:citations = [0,1,3,5,6]
输出:3
解释:给定数组表示研究者总共有 5 篇论文,每篇论文相应的被引用了 0, 1, 3, 5, 6 次。
由于研究者有 3 篇论文每篇 至少 被引用了 3 次,其余两篇论文每篇被引用 不多于 3 次,所以她的 h 指数是 3 。
```
示例 2:
```
输入:citations = [1,2,100]
输出:2
```
提示:
* $n = citations.length$
* $1 <= n <= 10^5$
* $0 <= citations[i] <= 1000$
* `citations` 按升序排列 | ### 与前置题关系
本题与前置题 [274. H 指数](https://leetcode.cn/problems/h-index/) 的不同,主要体现在两个方面:
1. 数据范围不同:在 [274. H 指数](https://leetcode.cn/problems/h-index/) 里 $n$ 的范围为 $5000$,而本题 $n$ 的范围为 $10^5$;
2. 数组是否有序:在 [274. H 指数](https://leetcode-cn.com/problems/h-index/) 中数组不确保有序,本题则是有序。
增加了数组有序特性,又扩大了数据范围。
容易联想,利用此特性,存在复杂度更低的算法。
---
### 基本分析
为了方便,将 `citations` 记为 `cs`。
所谓的 `h` 指数是指一个具体的数值,**该数值为“最大”的满足「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」定义的合法数,重点是“最大”**。
用题面的实例 $1$ 来举个 🌰,给定所有论文的引用次数情况为 `cs = [0,1,3,5,6]`,可统计满足定义的数值有哪些:
* $h = 0$,含义为「至少发表了 $0$ 篇,且这 $0$ 篇论文至少被引用 $0$ 次」,空集即满足,恒成立;
* $h = 1$,含义为「至少发表了 $1$ 篇,且这 $1$ 篇论文至少被引用 $1$ 次」,可以找到这样的组合,如 `[1]`,成立;
* $h = 2$,含义为「至少发表了 $2$ 篇,且这 $2$ 篇论文至少被引用 $2$ 次」,可以找到这样的组合,如 `[3, 5]`,成立;
* $h = 3$,含义为「至少发表了 $3$ 篇,且这 $3$ 篇论文至少被引用 $3$ 次」,可以找到这样的组合,如 `[3, 5, 6]`,成立;
* $h = 4$,含义为「至少发表了 $4$ 篇,且这 $4$ 篇论文至少被引用 $4$ 次」,找不到这样的组合,不成立;
* ...
实际上,**当遇到第一个无法满足的数时,更大的数值就没必要找了**。一个简单的推导:
至少出现 $k$ 次的论文数不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k + 1$ 篇(即更大的 $h$ 不满足)。
---
### 计数
首先,**仍能使用「计数」的方式进行求解,该求解为线性复杂度,且不要求数组有序**。
根据分析,最大的 `h` 不超过 $n$。
假设我们预处理出引用次数所对应的论文数量 `cnt`,其中 `cnt[a] = b` 含义为引用次数 **恰好** 为 `a` 的论文数量有 `b` 篇。
那么再利用 `h` 是“最大”的满足定义的合法数,我们从 $n$ 开始往前找,找到的第一个满足条件的数,即是答案。
具体的,创建 `cnt` 数组,对 `cs` 进行计数,由于最大 `h` 不超过 $n$,因此对于引用次数超过 $n$ 的论文,可等价为引用次数为 $n$,即有计数逻辑 `cnt[min(c, n)]++`。
再根据处理好的 `cnt`,从 $n$ 开始倒序找 `h`。
由于我们处理的 `cnt[a]` 含义为引用次数 **恰好** 为 `a`,但题目定义则是 **至少**。同时「至少出现 $k + 1$ 次」的集合必然慢「至少出现 $k$ 次」要求(子集关系),我们可以使用变量 `tot`,对处理过的 `cnt[i]` 进行累加,从而实现从 **恰好** 到 **至少** 的转换。
Java 代码:
```Java
class Solution {
public int hIndex(int[] cs) {
int n = cs.length;
int[] cnt = new int[n + 10];
for (int c : cs) cnt[Math.min(c, n)]++;
for (int i = n, tot = 0; i >= 0; i--) {
tot += cnt[i];
if (tot >= i) return i;
}
return -1; // never
}
}
```
C++ 代码:
```C++
class Solution {
public:
int hIndex(vector<int>& cs) {
int n = cs.size();
vector<int> cnt(n + 10, 0);
for (int c : cs) cnt[min(c, n)]++;
for (int i = n, tot = 0; i >= 0; i--) {
tot += cnt[i];
if (tot >= i) return i;
}
return -1; // never
}
};
```
Python 代码:
```Python
class Solution:
def hIndex(self, cs: List[int]) -> int:
n = len(cs)
cnt = [0] * (n + 10)
for c in cs:
cnt[min(c, n)] += 1
tot = 0
for i in range(n, -1, -1):
tot += cnt[i]
if tot >= i:
return i
return -1 # never
```
TypeScript 代码:
```TypeScript
function hIndex(cs: number[]): number {
const n = cs.length;
const cnt = new Array(n + 10).fill(0);
for (let c of cs) cnt[Math.min(c, n)]++;
for (let i = n, tot = 0; i >= 0; i--) {
tot += cnt[i];
if (tot >= i) return i;
}
return -1; // never
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 二分答案(线性 `check`)
除了线性复杂度的「计数」做法,我们还容易想到「二分」。
其中**最容易想到的是「二分答案」,该做法复杂度为 $O(n\log{n})$,同样并不要求数组有序。**
我们发现对于任意的 `cs`(论文总数量为该数组长度 $n$),都必然对应了一个最大的 `h` 值,且小于等于该 `h` 值的情况均满足,大于该 `h` 值的均不满足。
那么,在以最大 `h` 值为分割点的数轴上具有「二段性」,可通过「二分」求解该分割点(答案)。
最后考虑在什么值域范围内进行二分?
一个合格的二分范围,仅需确保答案在此范围内即可。
再回看我们关于 `h` 的定义「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」,满足条件除了引用次数,还有论文数量,而总的论文数量只有 $n$,因此最大的 `h` 只能是 $n$ 本身,而不能是比 $n$ 大的数,否则论文数量就不够了。
综上,我们只需要在 $[0, n]$ 范围进行二分即可。对于任意二分值 `mid`,只需线性扫描 `cs` 即可知道其是否合法。
Java 代码:
```Java
class Solution {
public int hIndex(int[] cs) {
int n = cs.length;
int l = 0, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(cs, mid)) l = mid;
else r = mid - 1;
}
return r;
}
boolean check(int[] cs, int mid) {
int ans = 0;
for (int i : cs) if (i >= mid) ans++;
return ans >= mid;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int hIndex(vector<int>& cs) {
int n = cs.size();
int l = 0, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(cs, mid)) l = mid;
else r = mid - 1;
}
return r;
}
bool check(vector<int>& cs, int x) {
int cnt = 0;
for (int c : cs) {
if (c >= x) cnt++;
}
return cnt >= x;
}
};
```
Python 代码:
```Python
class Solution:
def hIndex(self, cs: List[int]) -> int:
n = len(cs)
l, r = 0, n
while l < r:
mid = (l + r + 1) // 2
if sum(c >= mid for c in cs) >= mid:
l = mid
else:
r = mid - 1
return r
```
TypeScript 代码:
```TypeScript
function hIndex(cs: number[]): number {
const check = function (cs: number[], x: number): boolean {
let cnt: number = 0;
for (let c of cs) {
if (c >= x) cnt++;
}
return cnt >= x;
}
const n = cs.length;
let l = 0, r = n;
while (l < r) {
const mid = Math.floor((l + r + 1) / 2);
if (check(cs, mid)) l = mid;
else r = mid - 1;
}
return r;
};
```
* 时间复杂度:对 $[0, n]$ 做二分,复杂度为 $O(\log{n})$;`check` 函数需要对数组进行线性遍历,复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(1)$
---
### 二分下标(根据与 $cs[i]$ 关系)
在上述二分中,我们没有利用本题的「数组有序」的特性。
根据对 `h` 定义,若 $cs$ 升序,我们可推导出:
* 在最大的符合条件的分割点 $x$ 的右边(包含分割点),必然满足 $cs[i] >= x$
* 在最大的符合条件的分割点 $x$ 的左边,必然不满足 $cs[i] >= x$
因此,我们可以利用 **分割点右边数的个数与分割点 $cs[x]$ 的大小关系进行二分** 。
假设存在真实分割点下标 $x$,其值大小为 $cs[x]$,分割点右边的数值个数为 $n - x$,根据 `H 指数` 的定义,必然有 $cs[x] >= n - x$ 关系:
* 在分割点 $x$ 的右边:$cs[i]$ 非严格单调递增,数的个数严格单调递减,仍然满足 $cs[i] >= n - i$ 关系;
* 在分割点 $x$ 的左边:$cs[i]$ 非严格单调递减,数的个数严格单调递增,$x$ 作为真实分割点,必然不满足 $cs[i] >= n - i$ 关系。
利用此「二段性」进行二分即可,二分出下标后,再计算出数的个数。
Java 代码:
```Java
class Solution {
public int hIndex(int[] cs) {
int n = cs.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (cs[mid] >= n - mid) r = mid;
else l = mid + 1;
}
return cs[r] >= n - r ? n - r : 0;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int hIndex(vector<int>& cs) {
int n = cs.size();
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (cs[mid] >= n - mid) r = mid;
else l = mid + 1;
}
return cs[r] >= n - r ? n - r : 0;
}
};
```
Python 代码:
```Python
class Solution:
def hIndex(self, cs: List[int]) -> int:
n = len(cs)
l, r = 0, n - 1
while l < r:
mid = l + r >> 1
if cs[mid] >= n - mid:
r = mid
else:
l = mid + 1
return n - r if cs[r] >= n - r else 0
```
TypeScript 代码:
```TypeScript
function hIndex(cs: number[]): number {
const n = cs.length;
let l = 0, r = n - 1;
while (l < r) {
const mid = l + r >> 1;
if (cs[mid] >= n - mid) r = mid;
else l = mid + 1;
}
return cs[r] >= n - r ? n - r : 0;
};
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.275` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/278. 第一个错误的版本（简单）.md | 278. 第一个错误的版本 | https://leetcode-cn.com/problems/first-bad-version/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-8hpv/ | 简单 | [
"二分"
] | 你是产品经理,目前正在带领一个团队开发新的产品。不幸的是,你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的,所以错误的版本之后的所有版本都是错的。
假设你有 `n` 个版本 `[1, 2, ..., n]`,你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 `bool isBadVersion(version)` 接口来判断版本号 `version` 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 `API` 的次数。
示例:
```
给定 n = 5,并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以,4 是第一个错误的版本。
``` | ### 二分
一道交互题,根据题意可知,是尽可能少调用 `isBadVersion` 方法来找到分割点。
考虑存在「**没有错误版本**」和「**全是错误版本**」的情况,但如果往头部插入一个正确版本,往尾部插入一个错误版本作为哨兵,仍然具有「**二段性**」。
实际上,只需要进行这样的思考即可,不需要真正插入这样的哨兵,把这个哨兵逻辑放到最后返回的时候判断一下即可。
那么只需要将 `isBadVersion` 当做 `check` 函数进行二分即可。
**二分通常有以下两种写法,分别代表「找到最靠近中心的 `True`」 和「找到最靠近中心的 `False`」。**
另外根据数据范围需要注意计算 `mid` 时的爆 `int` 问题,可以通过使用类似 `l + (r - l) / 2` 的做法解决,也可以通过一个临时 `long` 来解决。
代码:
```Java
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int l = 1, r = n;
while (l < r) {
long tmp = (long)l + r >> 1;
int mid = (int)tmp;
if (isBadVersion(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return r;
}
}
```
```Java
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int l = 1, r = n;
while (l < r) {
long tmp = (long)l + r + 1 >> 1;
int mid = (int)tmp;
if (!isBadVersion(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return !isBadVersion(r) ? r + 1 : r;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 其他「二分」相关题解
* 二分模板
[29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)
* 二分本质 & 恢复二段性处理
[33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)
[81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)
[153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)
[154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)
* 二分 check 函数如何确定
[34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.278` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/271-280/279. 完全平方数（中等）.md | 279. 完全平方数 | https://leetcode-cn.com/problems/perfect-squares/solution/gong-shui-san-xie-xiang-jie-wan-quan-bei-nqes/ | 中等 | [
"完全背包",
"动态规划",
"背包问题"
] | 给定正整数 n,找到若干个完全平方数(比如 1, 4, 9, 16, ...)使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。
给你一个整数 n ,返回和为 n 的完全平方数的 最少数量 。
完全平方数 是一个整数,其值等于另一个整数的平方;换句话说,其值等于一个整数自乘的积。例如,1、4、9 和 16 都是完全平方数,而 3 和 11 不是。
示例 1:
```
输入:n = 12
输出:3
解释:12 = 4 + 4 + 4
```
示例 2:
```
输入:n = 13
输出:2
解释:13 = 4 + 9
```
提示:
* 1 <= n <= $10^4$ | ### 完全背包(朴素解法)
首先「完全平方数」有无限个,但要凑成的数字是给定的。
因此第一步可以将范围在 $[1, n]$ 内的「完全平方数」预处理出来。
这一步其实就是把所有可能用到的「物品」预处理出来。
从而将问题转换为:**给定了若干个数字,每个数字可以被使用无限次,求凑出目标值 $n$ 所需要用到的是最少数字个数是多少。**
由于题目没有限制我们相同的「完全平方数」只能使用一次,属于「完全背包」模型。
目前我们学过的两类背包问题(01 背包 & 完全背包)的原始状态定义都是两维:
* 第一维 $i$ 代表物品编号
* 第二维 $j$ 代表容量
其中第二维 $j$ 又有「不超过容量 $j$」和「容量恰好为 $j$」两种定义,本题要我们求「恰好」凑出 $n$ 所需要的最少个数。
因此我们可以调整我们的「状态定义」:
**$f[i][j]$ 为考虑前 $i$ 个数字,凑出数字总和 $j$ 所需要用到的最少数字数量。**
不失一般性的分析 $f[i][j]$,对于第 $i$ 个数字(假设数值为 $t$),我们有如下选择:
* 选 $0$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j]$
* 选 $1$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j - t] + 1$
* 选 $2$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j - 2 * t] + 2$
...
* 选 $k$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j - k * t] + k$
因此我们的状态转移方程为:
$$
f[i][j] = min(f[i-1][j-k*t]+k),0 \leqslant k * t \leqslant j
$$
当然,能够选择 $k$ 个数字 $i$ 的前提是,剩余的数字 $j - k * t$ 也能够被其他「完全平方数」凑出,即 $f[i - 1][j - k * t]$ 为有意义的值。
代码(朴素完全背包问题的复杂度是 $O(n^2 * \sqrt{n})$ 的,有超时风险,让物品下标从 $0$ 开始,单独处理第一个物品的 $P2$ 代码勉强能过):
```Java
class Solution {
int INF = 0x3f3f3f3f;
public int numSquares(int n) {
// 预处理出所有可能用到的「完全平方数」
List<Integer> list = new ArrayList<>();
int t = 1;
while (t * t <= n) {
list.add(t * t);
t++;
}
// f[i][j] 代表考虑前 i 个物品,凑出 j 所使用到的最小元素个数
int m = list.size();
int[][] f = new int[m + 1][n + 1];
// 当没有任何数时,除了 f[0][0] 为 0(花费 0 个数值凑出 0),其他均为无效值
Arrays.fill(f[0], INF);
f[0][0] = 0;
// 处理剩余数的情况
for (int i = 1; i <= m ; i++) {
int x = list.get(i - 1);
for (int j = 0; j <= n; j++) {
// 对于不选第 i 个数的情况
f[i][j] = f[i - 1][j];
// 对于选 k 次第 i 个数的情况
for (int k = 1; k * x <= j; k++) {
// 能够选择 k 个 x 的前提是剩余的数字 j - k * x 也能被凑出
if (f[i - 1][j - k * x] != INF) {
f[i][j] = Math.min(f[i][j], f[i - 1][j - k * x] + k);
}
}
}
}
return f[m][n];
}
}
```
```Java
class Solution {
int INF = -1;
public int numSquares(int n) {
// 预处理出所有可能用到的「完全平方数」
List<Integer> list = new ArrayList<>();
int idx = 1;
while (idx * idx <= n) {
list.add(idx * idx);
idx++;
}
// f[i][j] 代表考虑前 i 个物品,凑出 j 所使用到的最小元素个数
int len = list.size();
int[][] f = new int[len][n + 1];
// 处理第一个数的情况
for (int j = 0; j <= n; j++) {
int t = list.get(0);
int k = j / t;
if (k * t == j) { // 只有容量为第一个数的整数倍的才能凑出
f[0][j] = k;
} else { // 其余则为无效值
f[0][j] = INF;
}
}
// 处理剩余数的情况
for (int i = 1; i < len; i++) {
int t = list.get(i);
for (int j = 0; j <= n; j++) {
// 对于不选第 i 个数的情况
f[i][j] = f[i - 1][j];
// 对于选 k 次第 i 个数的情况
for (int k = 1; k * t <= j; k++) {
// 能够选择 k 个 t 的前提是剩余的数字 j - k * t 也能被凑出
// 使用 0x3f3f3f3f 作为最大值(预留累加空间)可以省去该判断
if (f[i - 1][j - k * t] != INF) {
f[i][j] = Math.min(f[i][j], f[i - 1][j - k * t] + k);
}
}
}
}
return f[len - 1][n];
}
}
```
* 时间复杂度:预处理出所有可能用到的数字复杂度为 $O(\sqrt{n})$,共有 $n * \sqrt{n}$ 个状态需要转移,每个状态转移最多遍历 $n$ 次,因此转移完所有状态复杂度为 $O(n^2 * \sqrt{n})$。整体复杂度为 $O(n^2 * \sqrt{n})$。
* 空间复杂度:$O(n * \sqrt{n})$。
***
### 完全背包(进阶)
显然朴素版的完全背包进行求解复杂度有点高。
这次我们还是按照同样的思路再进行一次推导,加强对这种「一维空间优化」方式的理解。
从二维的状态转移方程入手进行分析(假设第 $i$ 个数字为 $t$):
至此,我们得到了最终的状态转移方程:
$$
f[j] = min(f[j], f[j - t] + 1)
$$
同时,预处理「物品」的逻辑也能直接下放到转移过程去做。
代码:
```Java
class Solution {
public int numSquares(int n) {
int[] f = new int[n + 1];
Arrays.fill(f, 0x3f3f3f3f);
f[0] = 0;
for (int t = 1; t * t <= n; t++) {
int x = t * t;
for (int j = x; j <= n; j++) {
f[j] = Math.min(f[j], f[j - x] + 1);
}
}
return f[n];
}
}
```
* 时间复杂度:共有 $n * \sqrt{n}$ 个状态需要转移,复杂度为 $O(n * \sqrt{n})$。
* 空间复杂度:$O(n)$。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.279` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2731-2740/2736. 最大和查询（困难）.md | 2736. 最大和查询 | https://leetcode.cn/problems/maximum-sum-queries/solutions/2530269/gong-shui-san-xie-cong-yi-wei-xian-zhi-d-ww8r/ | 困难 | [
"排序",
"离散化",
"树状数组"
] | 给你两个长度为 `n`、下标从 `0` 开始的整数数组 `nums1` 和 `nums2`,另给你一个下标从 `1` 开始的二维数组 `queries`,其中 $queries[i] = [x_{i}, y_{i}]$ 。
对于第 `i` 个查询,在所有满足 $nums1[j] >= x_{i}$ 且 $nums2[j] >= y_{i}$ 的下标 `j` ($0 <= j < n$) 中,找出 $nums1[j] + nums2[j]$ 的 最大值 ,如果不存在满足条件的 `j` 则返回 $-1$。
返回数组 `answer`,其中 `answer[i]` 是第 `i` 个查询的答案。
示例 1:
```
输入:nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]
输出:[6,10,7]
解释:
对于第 1 个查询:xi = 4 且 yi = 1 ,可以选择下标 j = 0 ,此时 nums1[j] >= 4 且 nums2[j] >= 1 。nums1[j] + nums2[j] 等于 6 ,可以证明 6 是可以获得的最大值。
对于第 2 个查询:xi = 1 且 yi = 3 ,可以选择下标 j = 2 ,此时 nums1[j] >= 1 且 nums2[j] >= 3 。nums1[j] + nums2[j] 等于 10 ,可以证明 10 是可以获得的最大值。
对于第 3 个查询:xi = 2 且 yi = 5 ,可以选择下标 j = 3 ,此时 nums1[j] >= 2 且 nums2[j] >= 5 。nums1[j] + nums2[j] 等于 7 ,可以证明 7 是可以获得的最大值。
因此,我们返回 [6,10,7] 。
```
示例 2:
```
输入:nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
输出:[9,9,9]
解释:对于这个示例,我们可以选择下标 j = 2 ,该下标可以满足每个查询的限制。
```
示例 3:
```
输入:nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]
输出:[-1]
解释:示例中的查询 xi = 3 且 yi = 3 。对于每个下标 j ,都只满足 nums1[j] < xi 或者 nums2[j] < yi 。因此,不存在答案。
```
提示:
* $nums1.length = nums2.length$
* $n = nums1.length$
* $1 <= n <= 10^5$
* $1 <= nums1[i], nums2[i] <= 10^9$
* $1 <= queries.length <= 10^5$
* $queries[i].length = 2$
* $x_{i} = queries[i][1]$
* $y_{i} = queries[i][2]$
* $1 <= x_{i}, y_{i} <= 10^9$ | ### 离散化 + 排序 + 树状数组
根据题意,两个等长数组 `num1` 和 `nums2`,只能是相同下标的元素凑成一对。
不妨用两个一维数组 `nums1` 和 `nums2` 构建出一个二维数组 `nums`,方便后续处理,其中 $nums[i] = [nums1[i], nums2[i]]$。
同时对 `queries` 进行简单拓展,构建新的二维数组 `nq`,目的是对原有下标信息进行记录,其中 $nq[i] = [queries[i][0], queries[i][1], i]$(此处构建新 `nq` 的作用,下文会说)。
好了,现在我们有两个新的数组 `nums` 和 `nq`,接下来所有讨论都会针对新数组进行。
希望你牢牢记住:**$nums[i] = [nums1[i], nums2[i]]$ 是对 `nums1` 和 `nums2` 的简单合并;而 $nq[i] = [queries[i][0], queries[i][1], i]$ 是对 `queries` 原有下标的拓展记录**。
做完简单的预处理工作后,来思考一个前置问题:
假设其他内容不变,要求从满足「$nums[j][0] \geq nq[i][0]$ 且 $nums[j][1] \geq nq[i][1]$」调整为仅需满足「$nums[j][0] \geq nq[i][0]$」,如何求解?
一个简单的做法:
1. 对 `nums` 中的第一维(即 $nums[i][0] = nums1[i]$)和 `nq` 中第一维(即 $nq[i][0] = queries[i][0] = x_{i}$)排倒序;
2. 从前往后处理每个询问 $nq[i]$,同时使用变量 `idx` 对 `nums` 进行扫描,若满足 $nums[idx][0] \geq nq[i][0]$ 时,将 `idx` 右移,同时记录已被扫描的数对和 $nums[idx'][0] + nums[idx'][1]$ 。
当 `idx` 不能再后移时,说明当前所有满足 $nums[idx][0] \geq nq[i][0]$ 要求的数对已被扫描完,在记录的数对和中取最大值,即是当前询问 $nq[i]$ 的答案 $ans[nq[i][2]]$(此处解释了为什么需要构造新数组 `nq`,因为询问处理是按照排序后进行,但在 `ans` 中需要映射回原有顺序)。
3. 重复步骤 $2$,直到处理完所有询问。
搞懂前置问题后,回到原问题,需要满足「$nums[j][0] \geq nq[i][0]$ 且 $nums[j][1] \geq nq[i][1]$」要求。
进一步思考,排序 + 调整询问顺序,只能解决其中一维限制要求,另一维该如何处理?
或更直接的问题:如何在被记录的所有数对和 $nums[idx'][0] + nums[idx'][1]$ 中找出那些满足 $nums[j][1] \geq nq[i][1]$ 的最大数对和。
不失一般性,假设当前处理到的是 $nums[idx]$,其中 $nums[idx][0]$ 的限制要求,通过前置问题的排序方式解决了。另外的 **$nums[idx][1]$ 我们希望作为“位置信息”,数对和 $sum = nums[idx][0] + nums[idx][1]$ 作为“值信息”进行记录**。
由于条件 $1 \leq x_{i}, y_{i} \leq 1e9$,我们需要对将要作为“位置信息”添加到树状数组的 $nums[idx][1]$ 和 $nq[i][1]$ 进行离散化,将其映射到 $[0, m - 1]$ 范围内。
对于每个询问,都需要找到已遍历过的大于 $nq[i][1]$ 的位置上的最大值,把离散化后的值域换成数组坐标,相当于求后缀最大值,后缀最大值可通过相反数,变成求前缀最大值。
能够实现类似的前缀操作,支持“单点修改”和“区间查询”的数据结构是「树状数组」。
Java 代码:
```Java
class Solution {
int sz;
int[] tr;
int lowbit(int x) {
return x & -x;
}
void add(int a, int b) {
for (int i = a; i <= sz; i += lowbit(i)) tr[i] = Math.max(tr[i], b);
}
int query(int x) {
int ans = -1;
for (int i = x; i > 0; i -= lowbit(i)) ans = Math.max(ans, tr[i]);
return ans;
}
public int[] maximumSumQueries(int[] nums1, int[] nums2, int[][] queries) {
int n = nums1.length, m = queries.length;
// 构建新的 nums 和 nq
int[][] nums = new int[n][2];
for (int i = 0; i < n; i++) nums[i] = new int[]{nums1[i], nums2[i]};
int[][] nq = new int[m][3];
for (int i = 0; i < m; i++) nq[i] = new int[]{queries[i][0], queries[i][1], i};
// 对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])
Set<Integer> set = new HashSet<>();
for (int[] x : nums) set.add(x[1]);
for (int[] q : nq) set.add(q[1]);
List<Integer> list = new ArrayList<>(set);
Collections.sort(list);
sz = list.size();
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < sz; i++) map.put(list.get(i), i);
// 调整询问顺序, 解决其中一维限制
Arrays.sort(nums, (a,b)->b[0]-a[0]);
Arrays.sort(nq, (a,b)->b[0]-a[0]);
tr = new int[sz + 10];
Arrays.fill(tr, -1);
int[] ans = new int[m];
int idx = 0;
for (int[] q : nq) {
int x = q[0], y = q[1], i = q[2];
// 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)
while (idx < n && nums[idx][0] >= x) {
add(sz - map.get(nums[idx][1]), nums[idx][0] + nums[idx][1]);
idx++;
}
ans[i] = query(sz - map.get(y)); // 查询树状数组中的最值
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int sz;
vector<int> tr;
int lowbit(int x) {
return x & -x;
}
void add(int a, int b) {
for (int i = a; i <= sz; i += lowbit(i)) tr[i] = max(tr[i], b);
}
int query(int x) {
int ans = -1;
for (int i = x; i > 0; i -= lowbit(i)) ans = max(ans, tr[i]);
return ans;
}
vector<int> maximumSumQueries(vector<int>& nums1, vector<int>& nums2, vector<vector<int>>& queries) {
int n = nums1.size(), m = queries.size();
// 构建新的 nums 和 nq
vector<vector<int>> nums(n, vector<int>(2));
vector<vector<int>> nq(m, vector<int>(3));
for (int i = 0; i < n; i++) {
nums[i][0] = nums1[i]; nums[i][1] = nums2[i];
}
for (int i = 0; i < m; i++) {
nq[i][0] = queries[i][0]; nq[i][1] = queries[i][1]; nq[i][2] = i;
}
// 对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])
unordered_set<int> set;
for (auto& x : nums) set.insert(x[1]);
for (auto& q : nq) set.insert(q[1]);
vector<int> list(set.begin(), set.end());
sort(list.begin(), list.end());
sz = list.size();
map<int, int> map;
for (int i = 0; i < sz; i++) map[list[i]] = i;
// 调整询问顺序, 解决其中一维限制
sort(nums.begin(), nums.end(), [](const vector<int>& a, const vector<int>& b) {
return a[0] > b[0];
});
sort(nq.begin(), nq.end(), [](const vector<int>& a, const vector<int>& b) {
return a[0] > b[0];
});
tr.resize(sz + 10, -1);
vector<int> ans(m);
int idx = 0;
for (auto& q : nq) {
int x = q[0], y = q[1], i = q[2];
// 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)
while (idx < n && nums[idx][0] >= x) {
add(sz - map[nums[idx][1]], nums[idx][0] + nums[idx][1]);
idx++;
}
ans[i] = query(sz - map[y]); // 查询树状数组中的最值
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maximumSumQueries(self, nums1: List[int], nums2: List[int], queries: List[List[int]]) -> List[int]:
sz = 0
tr = []
def lowbit(x):
return x & -x
def add(a, b):
i = a
while i <= sz:
tr[i] = max(tr[i], b)
i += lowbit(i)
def query(x):
ans, i = -1, x
while i > 0:
ans = max(ans, tr[i])
i -= lowbit(i)
return ans
n, m = len(nums1), len(queries)
# 构建新的 nums 和 nq
nums = [(nums1[i], nums2[i]) for i in range(n)]
nq = [(queries[i][0], queries[i][1], i) for i in range(m)]
# 对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])
unique_set = set()
for x in nums:
unique_set.add(x[1])
for q in nq:
unique_set.add(q[1])
unique_list = list(unique_set)
unique_list.sort()
sz = len(unique_list)
mapping = {val: idx for idx, val in enumerate(unique_list)}
# 调整询问顺序, 解决其中一维限制
nums.sort(key=lambda x: x[0], reverse=True)
nq.sort(key=lambda x: x[0], reverse=True)
tr = [-1] * (sz + 10)
ans = [0] * m
idx = 0
for x, y, i in nq:
# 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)
while idx < n and nums[idx][0] >= x:
add(sz - mapping[nums[idx][1]], nums[idx][0] + nums[idx][1])
idx += 1
ans[i] = query(sz - mapping[y]) # 查询树状数组中的最值
return ans
```
TypeScript 代码:
```TypeScript
function maximumSumQueries(nums1: number[], nums2: number[], queries: number[][]): number[] {
let sz = 0;
let tr = [];
const lowbit = function(x: number): number {
return x & -x;
}
const add = function(a: number, b: number): void {
for (let i = a; i <= sz; i += lowbit(i)) tr[i] = Math.max(tr[i], b);
}
const query = function(x: number): number {
let ans = -1;
for (let i = x; i > 0; i -= lowbit(i)) ans = Math.max(ans, tr[i]);
return ans;
}
const n = nums1.length, m = queries.length;
// 构建新的 nums 和 nq
const nums = Array.from({ length: n }, (_, i) => [nums1[i], nums2[i]]);
const nq = Array.from({ length: m }, (_, i) => [...queries[i], i]);
// 对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])
const set: Set<number> = new Set();
for (const x of nums) set.add(x[1]);
for (const q of nq) set.add(q[1]);
const list: number[] = [...set];
list.sort((a, b) => a - b);
sz = list.length;
const mapping = new Map();
for (let i = 0; i < sz; i++) mapping.set(list[i], i);
// 调整询问顺序, 解决其中一维限制
nums.sort((a, b) => b[0] - a[0]);
nq.sort((a, b) => b[0] - a[0]);
tr = Array(sz + 10).fill(-1);
const ans = Array(m).fill(0);
let idx = 0;
for (let [x, y, i] of nq) {
// 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)
while (idx < n && nums[idx][0] >= x) {
add(sz - mapping.get(nums[idx][1])!, nums[idx][0] + nums[idx][1]);
idx++;
}
ans[i] = query(sz - mapping.get(y)!); // 查询树状数组中的最值
}
return ans;
};
```
* 时间复杂度:令 `nums1` 长度为 $n$,`queries` 长度为 $m$,构建 `nums` 和 `nq` 的复杂度为 $O(n + m)$;离散化复杂度为 $O((n + m) \log{(n + m)})$;对 `nums` 和 `nq` 的排序复杂度为 $O(n\log{n} + m\log{m})$;构建答案复杂度为 $O(m + n\log{n})$。整体复杂度为 $O((n + m) \log {(n + m)})$
* 空间复杂度:$O(n + m)$
---
### 进阶
本题解讲述了「从一维到二维偏序问题」时,可通过「一维排序,一维树状数组」求通解。
那三维偏序问题呢?是否存在通用的解决思路。
答:一维排序,一维归并,一维树状数组。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2751-2760/2760. 最长奇偶子数组（简单）.md | 2698. 求一个整数的惩罚数 | https://leetcode.cn/problems/longest-even-odd-subarray-with-threshold/solutions/2528837/gong-shui-san-xie-chou-si-bo-chong-tu-ji-n9r1/ | 简单 | [
"双指针",
"滑动窗口"
] | 给你一个下标从 $0$ 开始的整数数组 `nums` 和一个整数 `threshold`。
请你从 `nums` 的子数组中找出以下标 `l` 开头、下标 `r` 结尾 ($0 <= l <= r < nums.length$) 且满足以下条件的 最长子数组 :
* `nums[l] % 2 == 0`
* 对于范围 $[l, r - 1]$ 内的所有下标 `i`,`nums[i] % 2 != nums[i + 1] % 2`
* 对于范围 $[l, r]$ 内的所有下标 `i`,`nums[i] <= threshold`
以整数形式返回满足题目要求的最长子数组的长度。
注意:子数组 是数组中的一个连续非空元素序列。
示例 1:
```
输入:nums = [3,2,5,4], threshold = 5
输出:3
解释:在这个示例中,我们选择从 l = 1 开始、到 r = 3 结束的子数组 => [2,5,4] ,满足上述条件。
因此,答案就是这个子数组的长度 3 。可以证明 3 是满足题目要求的最大长度。
```
示例 2:
```
输入:nums = [1,2], threshold = 2
输出:1
解释:
在这个示例中,我们选择从 l = 1 开始、到 r = 1 结束的子数组 => [2] 。
该子数组满足上述全部条件。可以证明 1 是满足题目要求的最大长度。
```
示例 3:
```
输入:nums = [2,3,4,5], threshold = 4
输出:3
解释:
在这个示例中,我们选择从 l = 0 开始、到 r = 2 结束的子数组 => [2,3,4] 。
该子数组满足上述全部条件。
因此,答案就是这个子数组的长度 3 。可以证明 3 是满足题目要求的最大长度。
```
提示:
* $1 <= nums.length <= 100$
* $1 <= nums[i] <= 100$
* $1 <= threshold <= 100$ | ### 双指针
整体题意:找 `nums` 中的最长的子数组 $[l, r]$,对于任意 $nums[i]$ 不超过 `threshold`,且从 $nums[l]$ 开始按照「先偶后奇」顺序交替。
假设子数组的左端点为 `i`,且“最远的”合法右端点为 `j`,那么在 $[i, j]$ 之间的任意右端点 `k`,即使能够使得 $nums[i...k]$ 合法,对统计答案而言,也是没有意义的,因为我们求的是最长。
基于此,我们容易想到:**找到所有的合法左端点 `i`,并统计该合法左端点的最远右端点 `j`。跳过 $[i, j]$ 之间的点作为左端点的情况,直接从结束位置 `j` 开始找下一个合法左端点。**
该做法可将朴素的 $O(n^2)$ 做法优化至 $O(n)$。
但,这做法为什么是正确的?
我们只考虑了 $[i, j]$ 中间点作为右端点的情况,那作为左端点呢?为什么跳过 $[i, j]$ 之间的 $k$ 作为左端点,正确性也不受影响?我们不是漏到了某些方案吗?
答案:**是漏掉了,但也只是漏掉了那些必不可能是最长子数组的方案**。
具体的,我们重新整理上述的「双指针」做法:
* 从前往后扫描 `nums`,变量 `i` 作为当前子数组左端点,首先确保 `i` 的合法性(跳过不满足 `nums[i] % 2 = 0` 和 `nums[i] <= threshold` 的位置)
* 随后在固定左端点 `i` 前提下,找最远的(第一个不满足要求的)右端点 `j`(值不超过 `threshold`,且奇偶性与前值交替)
* 得到当前连续段长度 $[i, j - 1]$,更新 `ans`,从当前结束位置 `j` 开始,重复上述过程,直到处理完 `nums`
Java 代码
```Java
class Solution {
public int longestAlternatingSubarray(int[] nums, int threshold) {
int n = nums.length, ans = 0, i = 0;
while (i < n) {
if ((nums[i] % 2 != 0 || nums[i] > threshold) && ++i >= 0) continue;
int j = i + 1, cur = nums[i] % 2;
while (j < n) {
if (nums[j] > threshold || nums[j] % 2 == cur) break;
cur = nums[j++] % 2;
}
ans = Math.max(ans, j - i);
i = j;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int longestAlternatingSubarray(vector<int>& nums, int threshold) {
int n = nums.size(), ans = 0, i = 0;
while (i < n) {
if ((nums[i] % 2 != 0 || nums[i] > threshold) && ++i >= 0) continue;
int j = i + 1, cur = nums[i] % 2;
while (j < n) {
if (nums[j] > threshold || nums[j] % 2 == cur) break;
cur = nums[j++] % 2;
}
ans = max(ans, j - i);
i = j;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def longestAlternatingSubarray(self, nums: List[int], threshold: int) -> int:
n, ans, i = len(nums), 0, 0
while i < n:
if nums[i] % 2 != 0 or nums[i] > threshold:
i += 1
continue
j, cur = i + 1, nums[i] % 2
while j < n:
if nums[j] > threshold or nums[j] % 2 == cur: break
cur, j = nums[j] % 2, j + 1
ans = max(ans, j - i)
i = j
return ans
```
TypeScript 代码:
```TypeScript
function longestAlternatingSubarray(nums: number[], threshold: number): number {
let n = nums.length, ans = 0, i = 0
while (i < n) {
if ((nums[i] % 2 != 0 || nums[i] > threshold) && ++i >= 0) continue;
let j = i + 1, cur = nums[i] % 2;
while (j < n) {
if (nums[j] > threshold || nums[j] % 2 == cur) break;
cur = nums[j++] % 2;
}
ans = Math.max(ans, j - i);
i = j;
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2760` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/281-290/282. 给表达式添加运算符（困难）.md | 282. 给表达式添加运算符 | https://leetcode-cn.com/problems/peeking-iterator/solution/gong-shui-san-xie-die-dai-qi-ji-ben-ren-b77lz/ | 困难 | [
"DFS",
"数学"
] | 给定一个仅包含数字 `0-9` 的字符串 `num` 和一个目标值整数 `target` ,在 `num` 的数字之间添加 二元 运算符(不是一元)`+`、`-` 或 `*` ,返回所有能够得到目标值的表达式。
示例 1:
```
输入: num = "123", target = 6
输出: ["1+2+3", "1*2*3"]
```
示例 2:
```
输入: num = "232", target = 8
输出: ["2*3+2", "2+3*2"]
```
示例 3:
```
输入: num = "105", target = 5
输出: ["1*0+5","10-5"]
```
示例 4:
```
输入: num = "00", target = 0
输出: ["0+0", "0-0", "0*0"]
```
示例 5:
```
输入: num = "3456237490", target = 9191
输出: []
```
提示:
* 1 <= num.length <= 10
* num 仅含数字
* $-2^{31} <= target <= 2^{31} - 1$ | ### 回溯算法
最开始的想法是先使用 `DFS` 搜出来所有的表达式,然后套用 [(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 方案,计算所有表达式的结果,并将计算结果为 $target$ 的表达式加到结果集。
假设原字符串 $num$ 的长度为 $n$,由于每个位置之间存在四种插入决策(不插入符号、`+`、`-` 和 `*`),共有 $n - 1$ 个位置需要决策,因此搜索所有表达式的复杂度为 $O(4^{n - 1})$;同时需要对所有的表达式执行计算,复杂度为 $O(n)$,整体复杂度为 $O(n * 4^{n - 1})$。
添加运算符后的表达式长度不会超过 $20$,因此总的计算量应该是在 $10^7$ 以内,但可能是因为常数问题超时了(各种优化双栈操作也还是 TLE,在这上面浪费了好多时间 QWQ)。
**因此,我们需要考虑在搜索过程中进行计算,以避免使用 [(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 这种常数较大的计算方式。**
我们考虑如果只有 `+` 和 `-` 的话,可以很容易将运算和回溯搜索所有表达进行结合。但当存在 `*` 时,由于存在运算优先级的问题,我们需要记录形如 `a + b * c` 中的乘法部分。
实现上,除了记录当前决策到原串 $num$ 的哪一位 $u$,以及当前的运算结果 $cur$ 以外,还需要额外记录最后一次的计算结果 $prev$,然后在决策表达式中的第 $k$ 个部分时,对本次添加的运算符合做分情况讨论:
* 如果本次添加的 `+` 操作,且第 $k$ 项的值是 $next$:那么直接使用 $cur + next$ 来更新 $cur$,同时 $next$ 作为下一次的 $prev$;
* 如果本次添加的 `-` 操作,且第 $k$ 项的值是 $next$:同理,那么直接使用 $cur - next$ 来更新 $cur$,同时 $-next$ 作为下一次的 $prev$;
* 如果本次添加的 `*` 操作,且第 $k$ 项的值是 $next$:此时需要考虑运算符的优先级问题,由于本次的 $next$ 是与上一次的操作数 $prev$ 执行乘法,而 $cur$ 已经累加了 $prev$ 的影响,因此需要先减去 $prev$,再加上 $prev * next$,以此来更新 $cur$,同时 $prev * next$ 也作为下一次的 $prev$。
一些细节:需要注意前导零($0$ 单独作为一位是被允许的,但是多位且首部为 $0$ 是不允许的)以及 `+` 和 `-` 不作为一元运算符(运算符不能出现在表达式的首部)的情况。
代码:
```Java
class Solution {
List<String> ans = new ArrayList<>();
String s;
int n, t;
public List<String> addOperators(String num, int target) {
s = num;
n = s.length();
t = target;
dfs(0, 0, 0, "");
return ans;
}
void dfs(int u, long prev, long cur, String ss) {
if (u == n) {
if (cur == t) ans.add(ss);
return ;
}
for (int i = u; i < n; i++) {
if (i != u && s.charAt(u) == '0') break;
long next = Long.parseLong(s.substring(u, i + 1));
if (u == 0) {
dfs(i + 1, next, next, "" + next);
} else {
dfs(i + 1, next, cur + next, ss + "+" + next);
dfs(i + 1, -next, cur - next, ss + "-" + next);
long x = prev * next;
dfs(i + 1, x, cur - prev + x, ss + "*" + next);
}
}
}
}
```
* 时间复杂度:$O(4^{n})$
* 空间复杂度:$O(4^{n})$
---
### 总结
**该做法表面上,只是实现了边搜索边计算的功能,但其本质上是利用了实数集 $S$ 和运算符 `+`(`-` 的本质也是 `+`)和 `*` 能够组成代数系统。**
利用代数系统 $(S, +, *)$,我们可以确保运算过程中的任意一个中间结果,都能使用形如 `a + b * c` 的形式进行表示,因此我们只需要多维护一个后缀串结果即可。
而代数系统的相关知识,以及如何确定能否作为一个代数系统,有兴趣的同学可以尝试去了解一下。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.282` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/281-290/284. 顶端迭代器（中等）.md | 284. 顶端迭代器 | https://leetcode-cn.com/problems/peeking-iterator/solution/gong-shui-san-xie-die-dai-qi-ji-ben-ren-b77lz/ | 中等 | [
"数据结构",
"模拟"
] | 请你设计一个迭代器,除了支持 `hasNext` 和 `next` 操作外,还支持 `peek` 操作。
实现 `PeekingIterator` 类:
* `PeekingIterator(int[] nums)` 使用指定整数数组 `nums` 初始化迭代器。
* `int next()` 返回数组中的下一个元素,并将指针移动到下个元素处。
* `bool hasNext()` 如果数组中存在下一个元素,返回 `true` ;否则,返回 `false`。
* `int peek()` 返回数组中的下一个元素,但 **不** 移动指针。
示例:
```
输入:
["PeekingIterator", "next", "peek", "next", "next", "hasNext"]
[[[1, 2, 3]], [], [], [], [], []]
输出:
[null, 1, 2, 2, 3, false]
解释:
PeekingIterator peekingIterator = new PeekingIterator([1, 2, 3]); // [1,2,3]
peekingIterator.next(); // 返回 1 ,指针移动到下一个元素 [1,2,3]
peekingIterator.peek(); // 返回 2 ,指针未发生移动 [1,2,3]
peekingIterator.next(); // 返回 2 ,指针移动到下一个元素 [1,2,3]
peekingIterator.next(); // 返回 3 ,指针移动到下一个元素 [1,2,3]
peekingIterator.hasNext(); // 返回 False
```
提示:
* $1 <= nums.length <= 1000$
* $1 <= nums[i] <= 1000$
* 对 `next` 和 `peek` 的调用均有效
* `next`、`hasNext` 和 `peek` 最多调用 $1000$ 次
**进阶:你将如何拓展你的设计?使之变得通用化,从而适应所有的类型,而不只是整数型?** | ### 迭代器基本认识 + 模拟
常规的迭代器的「访问」只支持两种操作:
* `hasNext()` 操作:如果存在下一元素,返回 `True`,否则返回 `False`。实现上,就是判断游标是否到达结尾位置;
* `next()` 操作:返回下一元素(当不存在下一元素时,返回 `null`)。实现上,就是返回游标指向的元素,并让游标后移。
在本题,还需要我们额外支持 `peek()` 操作,即在移动游标的前提下,返回游标指向的元素。
实现上,我们可以让操作提前一步进行,事先调用一次 `next()` 并使用该变量 $next$ 存起该元素,通过外部调用 `peek()` 还是 `next()` 来决定是否要更新 $next$;同时由于我们事先存起了下一访问位置的元素,我们可以通过判断 $next$ 是否为 `null` 来得知是否到达迭代器结尾(`hasNext()` 实现)。
代码:
```Java
class PeekingIterator implements Iterator<Integer> {
Iterator<Integer> iter;
Integer next;
public PeekingIterator(Iterator<Integer> iterator) {
iter = iterator;
if (iter.hasNext()) next = iter.next();
}
public Integer peek() {
return next;
}
@Override
public Integer next() {
Integer ans = next;
next = iter.hasNext() ? iter.next() : null;
return ans;
}
@Override
public boolean hasNext() {
return next != null;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
---
### 进阶
* 你将如何拓展你的设计?使之变得通用化,从而适应所有的类型,而不只是整数型?
得益于 Java 的「泛型」设计,我们可以很轻松地支持任意类型:只需要将 `Integer` 修改成代指泛型的标识即可,例如 `E`。
代码:
```Java
class PeekingIterator implements Iterator<E> {
Iterator<E> iter;
E next;
public PeekingIterator(Iterator<E> iterator) {
iter = iterator;
if (iter.hasNext()) next = iter.next();
}
public E peek() {
return next;
}
@Override
public E next() {
E ans = next;
next = iter.hasNext() ? iter.next() : null;
return ans;
}
@Override
public boolean hasNext() {
return next != null;
}
}
```
Java 的泛型实现原理是「擦除法」。即实际上,都是以 `Object` 的顶层类型来存储,只不过在编译期,编译器会自动增加强制类型转换的代码,而在增加了强制类型转换的逻辑后,泛型信息也就不再需要,于是在编译过后,泛型信息会被直接擦除,而不会带到运行时。
其他不支持「泛型」的语言,可以采用类似的思路来实现:保存一个数据类型,在实现使用到泛型的接口时,先手动强转一下,再接收进来/返回出去。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.284` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/281-290/287. 寻找重复数（中等）.md | 287. 寻找重复数 | https://leetcode.cn/problems/find-the-duplicate-number/solution/by-ac_oier-az8v/ | 中等 | [
"桶排序",
"原地哈希"
] | 给定一个包含 `n + 1` 个整数的数组 `nums`,其数字都在 $[1, n]$ 范围内(包括 $1$ 和 $n$),可知至少存在一个重复的整数。
假设 `nums` 只有 一个重复的整数 ,返回 这个重复的数 。
你设计的解决方案必须 不修改 数组 `nums` 且只用常量级 $O(1)$ 的额外空间。
示例 1:
```
输入:nums = [1,3,4,2,2]
输出:2
```
示例 2:
```
输入:nums = [3,1,3,4,2]
输出:3
```
提示:
* $1 <= n <= 10^5$
* $nums.length = n + 1$
* $1 <= nums[i] <= n$
* `nums` 中 只有一个整数 出现 两次或多次 ,其余整数均只出现 一次
进阶:
* 如何证明 `nums` 中至少存在一个重复的数字?
* 你可以设计一个线性级时间复杂度 $O(n)$ 的解决方案吗? | ### 原地哈希
数组长度为 $n + 1$,同时给定的 $nums[i]$ 都在 $[1, n]$ 范围内,因此我们可以设定哈希规则为 $nums[idx] = idx + 1$,即数值 `x` 会放在下标 $x - 1$ 的位置。
如此一来,对于只出现一次的数值而言,必然能够顺利放在目标位置,而出现多次的数值必然会因为位置冲突而被找出。
Java 代码:
```Java
class Solution {
public int findDuplicate(int[] nums) {
for (int i = 0; i < nums.length; ) {
int t = nums[i], idx = t - 1;
if (nums[idx] == t) {
if (idx != i) return t;
i++;
} else {
swap(nums, idx, i);
}
}
return -1;
}
void swap(int[] nums, int i, int j) {
int c = nums[i];
nums[i] = nums[j];
nums[j] = c;
}
}
```
TypeScript 代码:
```TypeScript
function findDuplicate(nums: number[]): number {
for (let i = 0; i < nums.length; ) {
const t = nums[i], idx = t - 1
if (nums[idx] == t) {
if (idx != i) return t
i++
} else {
swap(nums, i, idx)
}
}
return -1
}
function swap(nums: number[], i: number, j: number): void {
const c = nums[i]
nums[i] = nums[j]
nums[j] = c
}
```
Python 代码:
```Python
class Solution:
def findDuplicate(self, nums: List[int]) -> int:
n, i = len(nums), 0
while i < n:
t, idx = nums[i], nums[i] - 1
if nums[idx] == t:
if idx != i:
return t
i += 1
else:
nums[i], nums[idx] = nums[idx], nums[i]
return -1
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.287` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2821-2830/2824. 统计和小于目标的下标对数目（简单）.md | 2824. 统计和小于目标的下标对数目 | https://leetcode.cn/problems/count-pairs-whose-sum-is-less-than-target/solutions/2539761/gong-shui-san-xie-xiang-jie-zuo-zhao-you-1yji/ | 简单 | [
"排序",
"二分",
"双指针"
] | 给你一个下标从 `0` 开始长度为 `n` 的整数数组 `nums` 和一个整数 `target`,请你返回满足 `0 <= i < j < n` 且 `nums[i] + nums[j] < target` 的下标对 $(i, j)$ 的数目。
示例 1:
```
输入:nums = [-1,1,2,3,1], target = 2
输出:3
解释:总共有 3 个下标对满足题目描述:
- (0, 1) ,0 < 1 且 nums[0] + nums[1] = 0 < target
- (0, 2) ,0 < 2 且 nums[0] + nums[2] = 1 < target
- (0, 4) ,0 < 4 且 nums[0] + nums[4] = 0 < target
注意 (0, 3) 不计入答案因为 nums[0] + nums[3] 不是严格小于 target 。
```
示例 2:
```
输入:nums = [-6,2,5,-2,-7,-1,3], target = -2
输出:10
解释:总共有 10 个下标对满足题目描述:
- (0, 1) ,0 < 1 且 nums[0] + nums[1] = -4 < target
- (0, 3) ,0 < 3 且 nums[0] + nums[3] = -8 < target
- (0, 4) ,0 < 4 且 nums[0] + nums[4] = -13 < target
- (0, 5) ,0 < 5 且 nums[0] + nums[5] = -7 < target
- (0, 6) ,0 < 6 且 nums[0] + nums[6] = -3 < target
- (1, 4) ,1 < 4 且 nums[1] + nums[4] = -5 < target
- (3, 4) ,3 < 4 且 nums[3] + nums[4] = -9 < target
- (3, 5) ,3 < 5 且 nums[3] + nums[5] = -3 < target
- (4, 5) ,4 < 5 且 nums[4] + nums[5] = -8 < target
- (4, 6) ,4 < 6 且 nums[4] + nums[6] = -4 < target
```
提示:
* $1 <= nums.length = n <= 50$
* $-50 <= nums[i], target <= 50$ | ### 基本分析
为了方便,先对 `nums` 进行排序。
当 `nums` 有了有序特性后,剩下的便是「遍历右端点,在右端点左侧找最大合法左端点」或「遍历左端点,在左端点右侧找最大合法右端点」过程。
---
### 排序 + 二分
这是一种「遍历右端点,在右端点左侧找最大合法左端点」做法。
遍历右端点 `i`,然后在 $[0, i - 1]$ 范围内进行二分,找到最大的满足 $nums[j] + nums[i] < target$ 的位置 `j`。
若存在这样左端点 `j`,说明以 $nums[i]$ 为右端点时,共有 $j + 1$ 个(范围为 $[0, j]$ )个合法左端点,需要被统计。
Java 代码:
```Java
class Solution {
public int countPairs(List<Integer> nums, int target) {
Collections.sort(nums);
int n = nums.size(), ans = 0;
for (int i = 1; i < n; i++) {
int l = 0, r = i - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums.get(mid) + nums.get(i) < target) l = mid;
else r = mid - 1;
}
if (nums.get(r) + nums.get(i) < target) ans += r + 1;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int countPairs(vector<int>& nums, int target) {
sort(nums.begin(), nums.end());
int n = nums.size(), ans = 0;
for (int i = 1; i < n; i++) {
int l = 0, r = i - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] + nums[i] < target) l = mid;
else r = mid - 1;
}
if (nums[r] + nums[i] < target) ans += r + 1;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def countPairs(self, nums: List[int], target: int) -> int:
nums.sort()
n, ans = len(nums), 0
for i in range(1, n):
l, r = 0, i - 1
while l < r:
mid = l + r + 1 >> 1
if nums[mid] + nums[i] < target: l = mid
else: r = mid - 1
if nums[r] + nums[i] < target: ans += r + 1
return ans
```
TypeScript 代码:
```TypeScript
function countPairs(nums: number[], target: number): number {
nums.sort((a,b)=>a-b);
let n = nums.length, ans = 0;
for (let i = 1; i < n; i++) {
let l = 0, r = i - 1;
while (l < r) {
const mid = l + r + 1 >> 1;
if (nums[mid] + nums[i] < target) l = mid;
else r = mid - 1;
}
if (nums[r] + nums[i] < target) ans += r + 1;
}
return ans;
};
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;构造答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 排序 + 双指针
这是一种「遍历左端点,在左端点右侧找最大合法右端点」做法。
使用 `l` 和 `r` 分别指向排序好的 `nums` 的首尾。
若当前 $nums[l] + nums[r] \geq target$,说明此时对于 `l` 来说,`r` 并不合法,对 `r` 自减(左移)。
直到满足 $nums[l] + nums[r] < target$,此时对于 `l` 来说,找到了最右侧的合法右端点 `r`,在 $[l + 1, r]$ 期间的数必然仍满足 $nums[l] + nums[r] < target$,共有 $r - l$ 个(范围为 $[l + 1, r]$ )个合法右端点,需要被统计。
Java 代码:
```Java
class Solution {
public int countPairs(List<Integer> nums, int target) {
Collections.sort(nums);
int n = nums.size(), ans = 0;
for (int l = 0, r = n - 1; l < r; l++) {
while (r >= 0 && nums.get(l) + nums.get(r) >= target) r--;
if (l < r) ans += r - l;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int countPairs(vector<int>& nums, int target) {
sort(nums.begin(), nums.end());
int n = nums.size(), ans = 0;
for (int l = 0, r = n - 1; l < r; l++) {
while (r >= 0 && nums[l] + nums[r] >= target) r--;
if (l < r) ans += r - l;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def countPairs(self, nums: List[int], target: int) -> int:
nums.sort()
n, ans = len(nums), 0
l, r = 0, n - 1
while l < r:
while r >= 0 and nums[l] + nums[r] >= target: r -= 1
if l < r: ans += r - l
l += 1
return ans
```
TypeScript 代码:
```TypeScript
function countPairs(nums: number[], target: number): number {
nums.sort((a,b)=>a-b);
let n = nums.length, ans = 0;
for (let l = 0, r = n - 1; l < r; l++) {
while (r >= 0 && nums[l] + nums[r] >= target) r--;
if (l < r) ans += r - l;
}
return ans;
};
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2824` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2871-2880/2876. 有向图访问计数（困难）.md | 2876. 有向图访问计数 | https://leetcode.cn/problems/count-visited-nodes-in-a-directed-graph/solutions/2512278/gong-shui-san-xie-sha-shi-nei-xiang-wai-d3lm9/ | 困难 | [
"基环森林",
"内向基环树",
"拓扑排序",
"图",
"BFS"
] | 现有一个有向图,其中包含 `n` 个节点,节点编号从 `0` 到 `n - 1`。此外,该图还包含了 `n` 条有向边。
给你一个下标从 `0` 开始的数组 `edges`,其中 `edges[i]` 表示存在一条从节点 `i` 到节点 `edges[i]` 的边。
想象在图上发生以下过程:
你从节点 `x` 开始,通过边访问其他节点,直到你在 此过程 中再次访问到之前已经访问过的节点。
返回数组 `answer` 作为答案,其中 `answer[i]` 表示如果从节点 `i` 开始执行该过程,你可以访问到的不同节点数。
示例 1:
```
输入:edges = [1,2,0,0]
输出:[3,3,3,4]
解释:从每个节点开始执行该过程,记录如下:
- 从节点 0 开始,访问节点 0 -> 1 -> 2 -> 0 。访问的不同节点数是 3 。
- 从节点 1 开始,访问节点 1 -> 2 -> 0 -> 1 。访问的不同节点数是 3 。
- 从节点 2 开始,访问节点 2 -> 0 -> 1 -> 2 。访问的不同节点数是 3 。
- 从节点 3 开始,访问节点 3 -> 0 -> 1 -> 2 -> 0 。访问的不同节点数是 4 。
```
示例 2:
```
输入:edges = [1,2,3,4,0]
输出:[5,5,5,5,5]
解释:无论从哪个节点开始,在这个过程中,都可以访问到图中的每一个节点。
```
提示:
* $n = edges.length$
* $2 <= n <= 10^5$
* $0 <= edges[i] <= n - 1$
* $edges[i] != i$ | ### 内向基环森林 + 拓扑排序
根据题意,共 `n` 个点,`n` 条边,利用 `edges`,将 `i` 向 `edges[i]` 连有向边,可知每个点有唯一的出边,因此这是一张可能包含多棵「内向基环树」的「基环森林」。
基环树是指其具有 $n$ 个点 $n$ 条边的联通块,而「内向」是指树中任意节点有且只有一条出边,对应的「外向」是指树中任意节点有且只有一条入边。
例如,左图内向,右图外向:
显然,可根据当前节点是否在“环内”进行分情况讨论:
* 对于「环内」节点来说,其答案为环节点个数;
* 对于「环外」节点来说,直观感受应该是由环上节点转移而来。但由于本题给定的是「内向基环树」,因此我们需要对原图进行“反向”,然后从环内节点开始,进行 `BFS` ,从而更新其余非环节点答案。
具体的,我们使用如下思路进行求解:
1. 创建大小为 `n` 的数组 `in`,进行入度统计;
2. 根据入度进行「拓扑排序」,剩余满足 $in[i] \neq 0$ 的点,为「环内」的点。我们可处理出每个点所在环的大小,环的大小为这些点的答案。处理过程中收集这些「环内」的点(将来要从它们出发,更新其他「环外」节点)
3. 对原图进行“反向”,从收集好的「环内」点进行出发,运用 `BFS` 得出剩余点答案。
Java 代码:
```Java
class Solution {
int N = 200010, M = N, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int[] countVisitedNodes(List<Integer> edges) {
int n = edges.size();
int[] in = new int[n], ans = new int[n];
for (int x : edges) in[x]++;
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (in[i] == 0) d.addLast(i);
}
while (!d.isEmpty()) {
int t = edges.get(d.pollFirst());
if (--in[t] == 0) d.addLast(t);
}
// 处理环上的
Set<Integer> set = new HashSet<>();
for (int i = 0; i < n; i++) {
if (in[i] == 0) continue;
List<Integer> list = new ArrayList<>();
list.add(i);
int j = edges.get(i), val = 1;
while (j != i) {
list.add(j);
j = edges.get(j);
val++;
}
for (int x : list) {
set.add(x);
in[x] = 0;
ans[x] = val;
}
}
// 建立反向图, 处理非环上的, 从环内点出发进行往外更新
Arrays.fill(he, -1);
for (int i = 0; i < n; i++) add(edges.get(i), i);
for (int u : set) {
int val = ans[u];
Deque<Integer> de = new ArrayDeque<>();
de.addLast(u);
while (!de.isEmpty()) {
int sz = de.size();
while (sz-- > 0) {
int t = de.pollFirst();
ans[t] = val;
for (int i = he[t]; i != -1; i = ne[i]) {
int j = e[i];
if (ans[j] != 0) continue;
de.addLast(j);
}
}
val++;
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int he[200010], e[200010], ne[200010], idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
vector<int> countVisitedNodes(vector<int>& edges) {
int n = edges.size();
vector<int> in(n, 0), ans(n, 0);
for (int x : edges) in[x]++;
queue<int> d;
for (int i = 0; i < n; i++) {
if (in[i] == 0) d.push(i);
}
while (!d.empty()) {
int t = edges[d.front()];
d.pop();
if (--in[t] == 0) d.push(t);
}
set<int> s;
for (int i = 0; i < n; i++) {
if (in[i] == 0) continue;
vector<int> list;
list.push_back(i);
int j = edges[i], val = 1;
while (j != i) {
list.push_back(j);
j = edges[j];
val++;
}
for (int x : list) {
s.insert(x);
in[x] = 0;
ans[x] = val;
}
}
memset(he, -1, sizeof(he));
for (int i = 0; i < n; i++) add(edges[i], i);
for (int u : s) {
int val = ans[u];
queue<int> de;
de.push(u);
while (!de.empty()) {
int sz = de.size();
while (sz-- > 0) {
int t = de.front();
de.pop();
ans[t] = val;
for (int i = he[t]; i != -1; i = ne[i]) {
int j = e[i];
if (ans[j] != 0) continue;
de.push(j);
}
}
val++;
}
}
return ans;
}
};
```
* 时间复杂度:统计入度复杂度为 $O(n)$;拓扑排序复杂度为 $O(n)$;统计「环内」节点答案复杂度为 $O(n)$;统计「环外」答案复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2876` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/292. Nim 游戏（简单）.md | 292. Nim 游戏 | https://leetcode-cn.com/problems/nim-game/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-wmz2t/ | 简单 | [
"博弈论"
] | 你和你的朋友,两个人一起玩 `Nim` 游戏:
* 桌子上有一堆石头。
* 你们轮流进行自己的回合,你作为先手。
* 每一回合,轮到的人拿掉 `1-3` 块石头。
* 拿掉最后一块石头的人就是获胜者。
假设你们每一步都是最优解。请编写一个函数,来判断你是否可以在给定石头数量为 `n` 的情况下赢得游戏。如果可以赢,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:n = 4
输出:false
解释:如果堆中有 4 块石头,那么你永远不会赢得比赛;
因为无论你拿走 1 块、2 块 还是 3 块石头,最后一块石头总是会被你的朋友拿走。
```
示例 2:
```
输入:n = 1
输出:true
```
示例 3:
```
输入:n = 2
输出:true
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 博弈论
这是一道 Nim 游戏的简化版。
**在不知晓博弈论结论前,可以先通过找规律得到猜想,然后再从「何种情况下,先手会处于必胜态」的角度来进行分析。**
根据题意,我们尝试从小范围数据的情况进行讨论:
1. 如果落到先手的局面为「**石子数量为 `1-3`**」的话,那么**先手必胜**;
2. 如果落到先手的局面为「**石子数量为 `4`**」的话,那么先手决策完(无论何种决策),交到后手的局面为「石子数量为 `1-3`」,即此时后手必胜,对应**先手必败**(到这里我们有一个推论:如果交给先手的局面为 `4` 的话,那么先手必败);
3. 如果落到先手的局面为「**石子数量为 `5-7`**」的话,那么先手可以通过控制选择石子的数量,来使得后手处于「石子数量为 `4`」的局面(此时后手必败),因此**先手必胜**;
4. 如果落到先手的局面为「**石子数量为 `8`**」的话,由于每次只能选 `1-3` 个石子,因此交由后手的局面为 `5-7`,根据流程 `3` 我们知道此时**先手必败**;
...
到这里,我们猜想 **当起始局面石子数量为 `4` 的倍数,则先手必败,否则先手必胜(即 `n % 4 != 0` 时,先手必胜)。**
然后我们通过「归纳法」证明一下该猜想的正确性。
在上面的「找规律」分析中,我们分情况讨论了最后一个决胜回合(我们称「剩余石子数量少于等于 `4` 的局面」为最后回合)的情况:**如果交由先手的石子数量为 `4`,那么先手必败,否则先手必胜。**
而对于「最后回合」前的任意回合(石子数量大于 `4`),我们需要证明 **先手可以通过调整所选石子数量,来维持「`n % 4 != 0`」直到最后回合。**
如果起始对先手而言满足「`n % 4 != 0`」,此时先手可以通过选择石子数量为「`n % 4`」来确保交到后手的局面为 `4` 的倍数。
那么根据推论,此时的原始后手作为下一回合的先手角色,且面临石子数量为 `4` 的倍数的局面,为必败态。
进一步的解释就是,由于原始后手面临石子数量为 `4` 的倍数的局面,且只能选 `1-3` 个石子,因此无论如何选择,重新回到原始先手的仍然满足「`n % 4 != 0`」(非 $4$ 的倍数)。
因此 **原始先手只需要确保每次都选择「`x % 4`」个石子($x$ 为当前石子数量),就可以确保交由自己的局面一直满足「`x % 4 != 0`」,交由对方的局面一直满足「`x % 4 == 0`」,直到最后回合的到来。**
至此,我们证明了 **如果起始石子数量 $n$ 满足「`n % 4 != 0`」条件,那么先手必胜。**
代码:
```Java
class Solution {
public boolean canWinNim(int n) {
return n % 4 != 0;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.292` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/295. 数据流的中位数（困难）.md | 295. 数据流的中位数 | https://leetcode-cn.com/problems/find-median-from-data-stream/solution/gong-shui-san-xie-jing-dian-shu-ju-jie-g-pqy8/ | 困难 | [
"优先队列(堆)"
] | 中位数是有序列表中间的数。如果列表长度是偶数,中位数则是中间两个数的平均值。
例如,
* `[2,3,4]` 的中位数是 $3$
* `[2,3]` 的中位数是 $(2 + 3) / 2 = 2.5$
设计一个支持以下两种操作的数据结构:
* `void addNum(int num)` - 从数据流中添加一个整数到数据结构中。
* `double findMedian()` - 返回目前所有元素的中位数。
示例:
```
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2
```
进阶:
* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?
* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法? | ### 优先队列(堆)
这是一道经典的数据结构运用题。
具体的,**我们可以使用两个优先队列(堆)来维护整个数据流数据,令维护数据流左半边数据的优先队列(堆)为 `l`,维护数据流右半边数据的优先队列(堆)为 `r`**。
显然,**为了可以在 $O(1)$ 的复杂度内取得当前中位数,我们应当令 `l` 为大根堆,`r` 为小根堆,并人为固定 `l` 和 `r` 之前存在如下的大小关系**:
* **当数据流元素数量为偶数:`l` 和 `r` 大小相同,此时动态中位数为两者堆顶元素的平均值;**
* **当数据流元素数量为奇数:`l` 比 `r` 多一,此时动态中位数为 `l` 的堆顶原数。**
为了满足上述说的奇偶性堆大小关系,在进行 `addNum` 时,我们应当分情况处理:
* 插入前两者大小相同,说明插入前数据流元素个数为偶数,插入后变为奇数。我们期望操作完达到「`l` 的数量为 `r` 多一,同时双堆维持有序」,进一步分情况讨论:
* 如果 `r` 为空,说明当前插入的是首个元素,直接添加到 `l` 即可;
* 如果 `r` 不为空,且 `num <= r.peek()`,说明 `num` 的插入位置不会在后半部分(不会在 `r` 中),直接加到 `l` 即可;
* 如果 `r` 不为空,且 `num > r.peek()`,说明 `num` 的插入位置在后半部分,此时将 `r` 的堆顶元素放到 `l` 中,再把 `num` 放到 `r`(相当于从 `r` 中置换一位出来放到 `l` 中)。
* 插入前两者大小不同,说明前数据流元素个数为奇数,插入后变为偶数。我们期望操作完达到「`l` 和 `r` 数量相等,同时双堆维持有序」,进一步分情况讨论(此时 `l` 必然比 `r` 元素多一):
* 如果 `num >= l.peek()`,说明 `num` 的插入位置不会在前半部分(不会在 `l` 中),直接添加到 `r` 即可。
* 如果 `num < l.peek()`,说明 `num` 的插入位置在前半部分,此时将 `l` 的堆顶元素放到 `r` 中,再把 `num` 放入 `l` 中(相等于从 `l` 中替换一位出来当到 `r` 中)。
代码:
```Java
class MedianFinder {
PriorityQueue<Integer> l = new PriorityQueue<>((a,b)->b-a);
PriorityQueue<Integer> r = new PriorityQueue<>((a,b)->a-b);
public void addNum(int num) {
int s1 = l.size(), s2 = r.size();
if (s1 == s2) {
if (r.isEmpty() || num <= r.peek()) {
l.add(num);
} else {
l.add(r.poll());
r.add(num);
}
} else {
if (l.peek() <= num) {
r.add(num);
} else {
r.add(l.poll());
l.add(num);
}
}
}
public double findMedian() {
int s1 = l.size(), s2 = r.size();
if (s1 == s2) {
return (l.peek() + r.peek()) / 2.0;
} else {
return l.peek();
}
}
}
```
* 时间复杂度:`addNum` 函数的复杂度为 $O(\log{n})$;`findMedian` 函数的复杂度为 $O(1)$
* 空间复杂度:$O(n)$
---
### 进阶
* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?
可以使用建立长度为 $101$ 的桶,每个桶分别统计每个数的出现次数,同时记录数据流中总的元素数量,每次查找中位数时,先计算出中位数是第几位,从前往后扫描所有的桶得到答案。
**这种做法相比于对顶堆做法,计算量上没有优势,更多的是空间上的优化。**
**对顶堆解法两个操作中耗时操作复杂度为 $O(\log{n})$,$\log$ 操作常数不会超过 $3$,在极限数据 $10^7$ 情况下计算量仍然低于耗时操作复杂度为 $O(C)$($C$ 固定为 $101$)桶计数解法。**
* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?
和上一问解法类似,对于 $1$% 采用哨兵机制进行解决即可,在常规的最小桶和最大桶两侧分别维护一个有序序列,即建立一个代表负无穷和正无穷的桶。
上述两个进阶问题的代码如下,但注意由于真实样例的数据分布不是进阶所描述的那样(不是绝大多数都在 $[0,100]$ 范围内),会 `TLE`。
代码:
```Java
class MedianFinder {
TreeMap<Integer, Integer> head = new TreeMap<>(), tail = new TreeMap<>();
int[] arr = new int[101];
int a, b, c;
public void addNum(int num) {
if (num >= 0 && num <= 100) {
arr[num]++;
b++;
} else if (num < 0) {
head.put(num, head.getOrDefault(num, 0) + 1);
a++;
} else if (num > 100) {
tail.put(num, tail.getOrDefault(num, 0) + 1);
c++;
}
}
public double findMedian() {
int size = a + b + c;
if (size % 2 == 0) return (find(size / 2) + find(size / 2 + 1)) / 2.0;
return find(size / 2 + 1);
}
int find(int n) {
if (n <= a) {
for (int num : head.keySet()) {
n -= head.get(num);
if (n <= 0) return num;
}
} else if (n <= a + b) {
n -= a;
for (int i = 0; i <= 100; i++) {
n -= arr[i];
if (n <= 0) return i;
}
} else {
n -= a + b;
for (int num : tail.keySet()) {
n -= tail.get(num);
if (n <= 0) return num;
}
}
return -1; // never
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.295` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/297. 二叉树的序列化与反序列化（困难）.md | 297. 二叉树的序列化与反序列化 | https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof/solution/gong-shui-san-xie-er-cha-shu-de-xu-lie-h-n89a/ | 困难 | [
"二叉树",
"层序遍历"
] | 序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。
示例 1:
```
输入:root = [1,2,3,null,null,4,5]
输出:[1,2,3,null,null,4,5]
```
示例 2:
```
输入:root = []
输出:[]
```
示例 3:
```
输入:root = [1]
输出:[1]
```
示例 4:
```
输入:root = [1,2]
输出:[1,2]
```
提示:
* 树中结点数在范围 $[0, 10^4]$ 内
* -1000 <= Node.val <= 1000 | ### 基本思路
无论使用何种「遍历方式」进行二叉树存储,为了方便,我们都需要对空节点有所表示。
其实题目本身的样例就给我们提供了很好的思路:**使用层序遍历的方式进行存储,对于某个叶子节点的空节点进行存储,同时确保不递归存储空节点对应的子节点。**
---
### 层序遍历
根据节点值的数据范围 `-1000 <= Node.val <= 1000`(我是在 [297. 二叉树的序列化与反序列化](https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/) 看的,你也可以不使用数字,使用某个特殊字符进行表示,只要能在反序列时有所区分即可),我们可以建立占位节点 `emptyNode` 用来代指空节点(`emptyNode.val = INF`)。
序列化:先特判掉空树的情况,之后就是常规的层序遍历逻辑:
1. 起始时,将 `root` 节点入队;
2. 从队列中取出节点,检查节点是否有左/右节点:
* 如果有的话,将值追加序列化字符中(注意使用分隔符),并将节点入队;
* 如果没有,检查当前节点是否为 `emptyNode` 节点,如果不是 `emptyNode` 说明是常规的叶子节点,需要将其对应的空节点进行存储,即将 `emptyNode` 入队;
3. 循环流程 $2$,直到整个队列为空。
反序列:同理,怎么「序列化」就怎么进行「反序列」即可:
1. 起始时,构造出 `root` 并入队;
2. 每次从队列取出元素时,同时从序列化字符中截取两个值(对应左右节点),检查是否为 `INF`,若不为 `INF` 则构建对应节点;
3. 循环流程 $2$,直到整个序列化字符串被处理完(注意跳过最后一位分隔符)。
代码:
```Java
public class Codec {
int INF = -2000;
TreeNode emptyNode = new TreeNode(INF);
public String serialize(TreeNode root) {
if (root == null) return "";
StringBuilder sb = new StringBuilder();
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode poll = d.pollFirst();
sb.append(poll.val + "_");
if (!poll.equals(emptyNode)) {
d.addLast(poll.left != null ? poll.left : emptyNode);
d.addLast(poll.right != null ? poll.right : emptyNode);
}
}
return sb.toString();
}
public TreeNode deserialize(String data) {
if (data.equals("")) return null;
String[] ss = data.split("_");
int n = ss.length;
TreeNode root = new TreeNode(Integer.parseInt(ss[0]));
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
for (int i = 1; i < n - 1; i += 2) {
TreeNode poll = d.pollFirst();
int a = Integer.parseInt(ss[i]), b = Integer.parseInt(ss[i + 1]);
if (a != INF) {
poll.left = new TreeNode(a);
d.addLast(poll.left);
}
if (b != INF) {
poll.right = new TreeNode(b);
d.addLast(poll.right);
}
}
return root;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.297` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/291-300/299. 猜数字游戏（中等）.md | 299. 猜数字游戏 | https://leetcode-cn.com/problems/bulls-and-cows/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-tdhs/ | 中等 | [
"模拟"
] | 你在和朋友一起玩 猜数字(`Bulls and Cows`)游戏,该游戏规则如下:
写出一个秘密数字,并请朋友猜这个数字是多少。朋友每猜测一次,你就会给他一个包含下述信息的提示:
* 猜测数字中有多少位属于数字和确切位置都猜对了(称为 `"Bulls"`, 公牛),
* 有多少位属于数字猜对了但是位置不对(称为 `"Cows"`, 奶牛)。也就是说,这次猜测中有多少位非公牛数字可以通过重新排列转换成公牛数字。
给你一个秘密数字 `secret` 和朋友猜测的数字 `guess`,请你返回对朋友这次猜测的提示。
提示的格式为 `"xAyB"` ,`x` 是公牛个数, `y` 是奶牛个数,`A` 表示公牛,`B` 表示奶牛。
请注意秘密数字和朋友猜测的数字都可能含有重复数字。
示例 1:
```
输入: secret = "1807", guess = "7810"
输出: "1A3B"
解释: 数字和位置都对(公牛)用 '|' 连接,数字猜对位置不对(奶牛)的采用斜体加粗标识。
"1807"
|
"7810"
```
示例 2:
```
输入: secret = "1123", guess = "0111"
输出: "1A1B"
解释: 数字和位置都对(公牛)用 '|' 连接,数字猜对位置不对(奶牛)的采用斜体加粗标识。
"1123" "1123"
| or |
"0111" "0111"
注意,两个不匹配的 1 中,只有一个会算作奶牛(数字猜对位置不对)。通过重新排列非公牛数字,其中仅有一个 1 可以成为公牛数字。
```
示例 3:
```
输入:secret = "1", guess = "0"
输出:"0A0B"
```
示例 4:
```
输入:secret = "1", guess = "1"
输出:"1A0B"
```
提示:
* 1 <= secret.length, guess.length <= 1000
* secret.length == guess.length
* secret 和 guess 仅由数字组成 | ### 模拟
根据题意,我们可以对 $secret$ 和 $guess$ 进行诸位比较,统计公牛数量 $a$ 和奶牛数量 $b$。
对于字符相同的位置,我们可以直接对 $a$ 进行自增;对于字符不同的位置,使用「哈希表」进行分别统计 $secret$ 和 $guess$ 的词频,某个数字 $x$ 在两者词频中的较小值,即为该数字对应的奶牛数量,统计所有数字 $[0, 9]$ 的奶牛数量总和即为 $b$。
代码:
```Java
class Solution {
public String getHint(String secret, String guess) {
int n = secret.length();
int a = 0, b = 0;
int[] cnt1 = new int[10], cnt2 = new int[10];
for (int i = 0; i < n; i++) {
int c1 = secret.charAt(i) - '0', c2= guess.charAt(i) - '0';
if (c1 == c2) {
a++;
} else {
cnt1[c1]++;
cnt2[c2]++;
}
}
for (int i = 0; i < 10; i++) b += Math.min(cnt1[i], cnt2[i]);
return a + "A" + b + "B";
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:令 $C$ 为字符集大小,$C$ 固定为 $10$。复杂度为 $O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.299` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/301. 删除无效的括号（困难）.md | 301. 删除无效的括号 | https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/yi-fen-zhong-nei-kan-dong-jiang-gua-hao-aya6k/ | 困难 | [
"括号问题",
"回溯算法",
"DFS"
] | 给你一个由若干括号和字母组成的字符串 `s`,删除最小数量的无效括号,使得输入的字符串有效。
返回所有可能的结果。答案可以按 任意顺序 返回。
示例 1:
```
输入: "()())()"
输出: ["()()()", "(())()"]
```
示例 2:
```
输入: "(a)())()"
输出: ["(a)()()", "(a())()"]
```
示例 3:
```
输入: ")("
输出: [""]
```
提示:
* $1 <= s.length <= 25$
* `s` 由小写英文字母以及括号 `'('` 和 `')'` 组成
* `s` 中至多含 `20` 个括号 | ### 搜索 + 剪枝
由于题目要求我们将所有(最长)合法方案输出,因此不可能有别的优化,只能进行「爆搜」。
我们可以使用 `DFS` 实现回溯搜索。
基本思路:
我们知道所有的合法方案,必然有左括号的数量与右括号数量相等。
首先我们令左括号的得分为 $1$;右括号的得分为 $-1$。则会有如下性质:
1. 对于一个合法的方案而言,必然有最终得分为 $0$;
2. 搜索过程中不会出现得分值为 **负数** 的情况(当且仅当子串中某个前缀中「右括号的数量」大于「左括号的数量」时,会出现负数,此时不是合法方案)。
同时我们可以预处理出「爆搜」过程的最大得分: `max = min(左括号的数量, 右括号的数量)`
**PS.「爆搜」过程的最大得分必然是:合法左括号先全部出现在左边,之后使用最多的合法右括号进行匹配。**
枚举过程中出现字符分三种情况:
* 左括号:如果增加当前 `(` 后,仍为合法子串(即 $score + 1 <= max$) 时,我们可以选择添加该左括号,也能选择不添加;
* 右括号:如果增加当前 `)` 后,仍为合法子串(即 $score - 1 >= 0$) 时,我们可以选择添加该右括号,也能选择不添加;
* 普通字符:直接添加。
使用 `Set` 进行方案去重,$len$ 记录「爆搜」过程中的最大子串,然后只保留长度等于 $len$ 的子串。
代码:
```Java
class Solution {
Set<String> set = new HashSet<>();
int n, max, len;
String s;
public List<String> removeInvalidParentheses(String _s) {
s = _s;
n = s.length();
int l = 0, r = 0;
for (char c : s.toCharArray()) {
if (c == '(') l++;
else if (c == ')') r++;
}
max = Math.min(l, r);
dfs(0, "", 0);
return new ArrayList<>(set);
}
void dfs(int u, String cur, int score) {
if (score < 0 || score > max) return ;
if (u == n) {
if (score == 0 && cur.length() >= len) {
if (cur.length() > len) set.clear();
len = cur.length();
set.add(cur);
}
return ;
}
char c = s.charAt(u);
if (c == '(') {
dfs(u + 1, cur + String.valueOf(c), score + 1);
dfs(u + 1, cur, score);
} else if (c == ')') {
dfs(u + 1, cur + String.valueOf(c), score - 1);
dfs(u + 1, cur, score);
} else {
dfs(u + 1, cur + String.valueOf(c), score);
}
}
}
```
* 时间复杂度:预处理 $max$ 的复杂度为 $O(n)$;不考虑 $score$ 带来的剪枝效果,最坏情况下,每个位置都有两种选择,搜索所有方案的复杂度为 $O(2^n)$;同时搜索过程中会产生的新字符串(最终递归树中叶子节点的字符串长度最大为 $n$,使用 `StringBuilder` 也是同理),复杂度为 $O(n)$。整体复杂度为 $O(n \times 2^n)$
* 空间复杂度:最大合法方案数与字符串长度呈线性关系。复杂度为 $O(n)$
---
### 搜索 + 剪枝
在解法一,我们是在搜索过程中去更新最后的 $len$。
但事实上,我们可以通过预处理,得到最后的「应该删除的左括号数量」和「应该删掉的右括号数量」,来直接得到最终的 $len$。
因此在此基础上,我们可以考虑多增加一层剪枝。
代码:
```Java
class Solution {
Set<String> set = new HashSet<>();
int n, max, len;
String s;
public List<String> removeInvalidParentheses(String _s) {
s = _s;
n = s.length();
int l = 0, r = 0;
for (char c : s.toCharArray()) {
if (c == '(') {
l++;
} else if (c == ')') {
if (l != 0) l--;
else r++;
}
}
len = n - l - r;
int c1 = 0, c2 = 0;
for (char c : s.toCharArray()) {
if (c == '(') c1++;
else if (c == ')') c2++;
}
max = Math.min(c1, c2);
dfs(0, "", l, r, 0);
return new ArrayList<>(set);
}
void dfs(int u, String cur, int l, int r, int score) {
if (l < 0 || r < 0 || score < 0 || score > max) return ;
if (l == 0 && r == 0) {
if (cur.length() == len) set.add(cur);
}
if (u == n) return ;
char c = s.charAt(u);
if (c == '(') {
dfs(u + 1, cur + String.valueOf(c), l, r, score + 1);
dfs(u + 1, cur, l - 1, r, score);
} else if (c == ')') {
dfs(u + 1, cur + String.valueOf(c), l, r, score - 1);
dfs(u + 1, cur, l, r - 1, score);
} else {
dfs(u + 1, cur + String.valueOf(c), l, r, score);
}
}
}
```
* 时间复杂度:预处理 $max$ 和 $len$ 的复杂度为 $O(n)$;不考虑 $score$ 带来的剪枝效果,最坏情况下,每个位置都有两种选择,搜索所有方案的复杂度为 $O(2^n)$;同时搜索过程中会产生的新字符串(最终递归树中叶子节点的字符串长度最大为 $n$,使用 `StringBuilder` 也是同理),复杂度为 $O(n)$。整体复杂度为 $O(n \times 2^n)$
* 空间复杂度:最大合法方案数与字符串长度呈线性关系。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.301` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/303. 区域和检索 - 数组不可变（简单）.md | 303. 区域和检索 - 数组不可变 | https://leetcode-cn.com/problems/range-sum-query-immutable/solution/sha-shi-qian-zhui-he-ya-tu-jie-qian-zhui-0rla/ | 简单 | [
"前缀和",
"区间求和问题"
] | 给定一个整数数组 `nums`,求出数组从索引 `i` 到 `j`(`i ≤ j`)范围内元素的总和,包含 `i`、`j` 两点。
实现 `NumArray` 类:
* `NumArray(int[] nums)` 使用数组 `nums` 初始化对象
* `int sumRange(int i, int j)` 返回数组 `nums` 从索引 `i` 到 `j`(`i ≤ j`)范围内元素的总和,包含 i、j 两点(也就是 `sum(nums[i], nums[i + 1], ... , nums[j])`)
示例:
```
输入:
["NumArray", "sumRange", "sumRange", "sumRange"]
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
输出:
[null, 1, -1, -3]
解释:
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))
```
提示:
* $0 <= nums.length <= 10^4$
* $-10^5 <= nums[i] <= 10^5$
* $0 <= i <= j < nums.length$
* 最多调用 $10^4$ 次 `sumRange` 方法 | ### 前缀和(一维)
这是一道前缀和裸题。
当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。
所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。
设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。
有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。
通用公式:`ans = sum[j] - sum[i - 1]`。
由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1$ 开始。在进行快速求和时,再根据原数组下标是否从 $1$ 开始,决定是否进行相应的下标偏移。
Java 代码:
```Java
class NumArray {
int[] sum;
public NumArray(int[] nums) {
int n = nums.length;
// 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)
sum = new int[n + 1];
// 预处理除前缀和数组(模板部分)
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
}
public int sumRange(int i, int j) {
// 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)
// 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1
i++; j++;
return sum[j] - sum[i - 1];
}
}
```
C++ 代码:
```C++
class NumArray {
public:
vector<int> sum;
NumArray(std::vector<int>& nums) {
int n = nums.size();
// 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)
sum.resize(n + 1, 0);
// 预处理除前缀和数组(模板部分)
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
}
int sumRange(int i, int j) {
// 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)
// 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1
i++; j++;
return sum[j] - sum[i - 1];
}
};
```
Python 代码:
```Python
class NumArray:
def __init__(self, nums: List[int]):
n = len(nums)
# 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)
self.sum = [0] * (n + 1)
# 预处理除前缀和数组(模板部分)
for i in range(1, n + 1):
self.sum[i] = self.sum[i - 1] + nums[i - 1]
def sumRange(self, i: int, j: int) -> int:
# 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)
# 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1
i, j = i + 1, j + 1
return self.sum[j] - self.sum[i - 1]
```
TypeScript 代码:
```TypeScript
class NumArray {
private sum: number[];
constructor(nums: number[]) {
const n: number = nums.length;
// 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)
this.sum = new Array(n + 1).fill(0);
// 预处理除前缀和数组(模板部分)
for (let i = 1; i <= n; i++) this.sum[i] = this.sum[i - 1] + nums[i - 1];
}
sumRange(i: number, j: number): number {
// 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)
// 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1
i++; j++;
return this.sum[j] - this.sum[i - 1];
}
}
```
* 时间复杂度:预处理前缀和数组需要对原数组进行线性扫描,复杂度为 $O(n)$,计算结果复杂度为 $O(1)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 一维前缀和模板
我们再来整理下一维「前缀和」的模板代码(`Java` 为例):
```java
// 预处理前缀和数组
{
sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
}
// 计算 [i, j] 结果
{
i++; j++;
ans = sum[j] - sum[i - 1];
}
```
---
### 总结
最后我们看看「前缀和」与其他知识点的联系。
为啥「前缀和」能大幅度的降低区间求和的复杂度?其实本质是利用数学进行求值:某一段的区间和 = 起点到区间右端点的和(含右端点)- 起点到区间左端点的和(不含左端点)
而求解前缀和数组的过程,则是基于动态规划思想:由于前缀和的每一位都是求「当前位置到起点位置区间的和」。因此当求解某一位的前缀和时,需要「前一位置的前缀和」和「当前位置的原数组值」(而与前一位置的前缀和是如何计算出来无关)。其过程类似于 dp 入门题 [509. 斐波那契数](https://leetcode-cn.com/problems/fibonacci-number/) 的求解过程。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.303` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/304. 二维区域和检索 - 矩阵不可变（中等）.md | 304. 二维区域和检索 - 矩阵不可变 | https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/ | 中等 | [
"前缀和",
"区间求和问题"
] | 给定一个二维矩阵,计算其子矩形范围内元素的总和,该子矩阵的左上角为 (row1, col1) ,右下角为 (row2, col2) 。
上图子矩阵左上角 (row1, col1) = (2, 1) ,右下角(row2, col2) = (4, 3),该子矩形内元素的总和为 8。
示例:
```
给定 matrix = [
[3, 0, 1, 4, 2],
[5, 6, 3, 2, 1],
[1, 2, 0, 1, 5],
[4, 1, 0, 1, 7],
[1, 0, 3, 0, 5]
]
sumRegion(2, 1, 4, 3) -> 8
sumRegion(1, 1, 2, 2) -> 11
sumRegion(1, 2, 2, 4) -> 12
```
提示:
* 你可以假设矩阵不可变。
* 会多次调用 sumRegion 方法。
* 你可以假设 row1 ≤ row2 且 col1 ≤ col2 。 | ### 前缀和解法(二维)
真就是今天的「每日一题」呗 ~
这是一道「二维前缀和」的裸题。
「二维前缀和」解决的是二维矩阵中的矩形区域求和问题。
**二维前缀和数组中的每一个格子记录的是「以当前位置为区域的右下角(区域左上角恒定为原数组的左上角)的区域和」**
贴一张官解示意图,我觉得很清晰:
**如果觉得不清晰,请将将 f[i][j] 理解成是以 (i, j) 为右下角,(0, 0) 为左上角的区域和。**
因此当我们要求 (x1, y1) 作为左上角,(x2, y2) 作为右下角 的区域和的时候,可以直接利用前缀和数组快速求解:
`sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1]`
再贴官解示意图(画图困难户在学做图了,别骂😢):
(x1, y1) == (row1, col1),(x2, y2) == (row2, col2)
代码:
```Java
class NumMatrix {
int[][] sum;
public NumMatrix(int[][] matrix) {
int n = matrix.length, m = n == 0 ? 0 : matrix[0].length;
// 与「一维前缀和」一样,前缀和数组下标从 1 开始,因此设定矩阵形状为 [n + 1][m + 1](模板部分)
sum = new int[n + 1][m + 1];
// 预处理除前缀和数组(模板部分)
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + matrix[i - 1][j - 1];
}
}
}
public int sumRegion(int x1, int y1, int x2, int y2) {
// 求某一段区域和 [i, j] 的模板是 sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];(模板部分)
// 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1
x1++; y1++; x2++; y2++;
return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}
}
```
* 时间复杂度:预处理前缀和数组需要对原数组进行线性扫描,复杂度为 $O(n * m)$,计算结果复杂度为 $O(1)$。整体复杂度为 $O(n * m)$
* 空间复杂度:$O(n * m)$
***
### 二维前缀和模板【重点】
下面重点分享下前缀和模板该如何记忆,其实很多模板都可以按照类似方式进行记忆。
虽然「二维前缀和」的模板相比「一维前缀和」的模板要长,但是逻辑是清晰的,可以现场推导。
当然也可以**在理解的基础上**,使用以下方式进行记忆:
```Java
// 预处理前缀和数组
{
sum = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
// 当前格子(和) = 上方的格子(和) + 左边的格子(和) - 左上角的格子(和) + 当前格子(值)【和是指对应的前缀和,值是指原数组中的值】
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + matrix[i - 1][j - 1];
}
}
}
// 首先我们要令左上角为 (x1, y1) 右下角为 (x2, y2)
// 计算 (x1, y1, x2, y2) 的结果
{
// 前缀和是从 1 开始,原数组是从 0 开始,上来先将原数组坐标全部 +1,转换为前缀和坐标
x1++; y1++; x2++; y2++;
// 记作 22 - 12 - 21 + 11,然后 不减,减第一位,减第二位,减两位
// 也可以记作 22 - 12(x - 1) - 21(y - 1) + 11(x y 都 - 1)
ans = sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.304` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/306. 累加数（中等）.md | 306. 累加数 | https://leetcode-cn.com/problems/additive-number/solution/gong-shui-san-xie-hui-su-gao-jing-du-jia-6o6b/ | 中等 | [
"回溯算法",
"高精度"
] | 累加数 是一个字符串,组成它的数字可以形成累加序列。
一个有效的 累加序列 必须 至少 包含 `3` 个数。除了最开始的两个数以外,字符串中的其他数都等于它之前两个数相加的和。
给你一个只包含数字 `'0'-'9'` 的字符串,编写一个算法来判断给定输入是否是 累加数 。如果是,返回 `true` ;否则,返回 `false` 。
说明:累加序列里的数 不会 以 `0` 开头,所以不会出现 `1`, `2`, `03` 或者 `1`, `02`, `3` 的情况。
示例 1:
```
输入:"112358"
输出:true
解释:累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
```
示例 2:
```
输入:"199100199"
输出:true
解释:累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199
```
提示:
* $1 <= num.length <= 35$
* `num` 仅由数字(`0` - `9`)组成
进阶:你计划如何处理由过大的整数输入导致的溢出? | ### 回溯 + 高精度加法
给定的 $nums$ 的长度只有 $35$,且要求序列的第三个数开始由前两个数相加而来。
容易想到通过 `DFS` 爆搜每个数的分割点,同时利用累加数的特性(第三个数起,每个数均由为前两数之和)进行剪枝。
具体的,我们可以实现一个 `boolean dfs(int u)` 函数,入参为当前决策到 $num$ 的哪一位,返回值为决策结果(序列)是否为累加数序列,爆搜过程中的分割数序列存放到 $list$ 中。
由于是 **从位置 $u$ 作为开始位置决策如何分割出当前数 $x$,我们可以枚举当前数的结束位置,范围为 $[u, n - 1]$,但需要注意分割数不能包含前导零,即如果 $num[u] = 0$,则当前数只能为 $0$**。
同时,一个合法的分割数必然满足「其值大小为前两数之和」,因此当前数 $x$ 能够被添加到 $list$ 的充要条件为:
1. $list$ 长度不足 $2$,即 $x$ 为序列中的前两数,不存在值大小的约束问题,$x$ 可以被直接到 $list$ 并继续爆搜;
2. $list$ 长度大于等于 $2$,即 $x$ 需要满足「其值大小为前两数之和」要求,以此条件作为剪枝,满足要求的 $x$ 才能追加到 $list$ 中并继续爆搜。
最后,在整个 `DFS` 过程中我们需要监测「当前数」与「前两数之和」是否相等,而分割数长度最大为 $35$,存在溢出风险,我们需要实现「高精度加法」,实现一个 `check` 函数,用于检查 `a + b` 是否为 `c`,其中 `a`、`b` 和 `c` 均为使用「逆序」存储数值的数组(最高位对应个位,举个 🌰,$a = 35$,则有 `[5, 3]`)。
若爆搜过程能顺利结束(得到长度至少为 $3$ 的序列),则说明能够拆分出累加数序列,返回 `True`,否则返回 `False`。
至此,我们解决了本题,并通过引入「高精度」来回答了「进阶」部分的问题。
代码:
```Java
class Solution {
String num;
int n;
List<List<Integer>> list = new ArrayList<>();
public boolean isAdditiveNumber(String _num) {
num = _num;
n = num.length();
return dfs(0);
}
boolean dfs(int u) {
int m = list.size();
if (u == n) return m >= 3;
int max = num.charAt(u) == '0' ? u + 1 : n;
List<Integer> cur = new ArrayList<>();
for (int i = u; i < max; i++) {
cur.add(0, num.charAt(i) - '0');
if (m < 2 || check(list.get(m - 2), list.get(m - 1), cur)) {
list.add(cur);
if (dfs(i + 1)) return true;
list.remove(list.size() - 1);
}
}
return false;
}
boolean check(List<Integer> a, List<Integer> b, List<Integer> c) {
List<Integer> ans = new ArrayList<>();
int t = 0;
for (int i = 0; i < a.size() || i < b.size(); i++) {
if (i < a.size()) t += a.get(i);
if (i < b.size()) t += b.get(i);
ans.add(t % 10);
t /= 10;
}
if (t > 0) ans.add(t);
boolean ok = c.size() == ans.size();
for (int i = 0; i < c.size() && ok; i++) {
if (c.get(i) != ans.get(i)) ok = false;
}
return ok;
}
}
```
* 时间复杂度:爆搜的复杂度为指数级别,且存在剪枝操作,分析时空复杂度意义不大
* 空间复杂度:爆搜的复杂度为指数级别,且存在剪枝操作,分析时空复杂度意义不大 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.306` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/307. 区域和检索 - 数组可修改（中等）.md | 307. 区域和检索 - 数组可修改 | https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/ | 中等 | [
"区间和",
"树状数组",
"线段树"
] | 给你一个数组 `nums`,请你完成两类查询,其中一类查询要求更新数组下标对应的值,另一类查询要求返回数组中某个范围内元素的总和。
实现 `NumArray` 类:
* `NumArray(int[] nums)` 用整数数组 `nums` 初始化对象
* `void update(int index, int val)` 将 `nums[index]` 的值更新为 `val`
* `int sumRange(int left, int right)` 返回子数组 `nums[left, right]` 的总和(即,`nums[left] + nums[left + 1], ..., nums[right]`)
示例:
```
输入:
["NumArray", "sumRange", "update", "sumRange"]
[[[1, 3, 5]], [0, 2], [1, 2], [0, 2]]
输出:
[null, 9, null, 8]
解释:
NumArray numArray = new NumArray([1, 3, 5]);
numArray.sumRange(0, 2); // 返回 9 ,sum([1,3,5]) = 9
numArray.update(1, 2); // nums = [1,2,5]
numArray.sumRange(0, 2); // 返回 8 ,sum([1,2,5]) = 8
```
提示:
* $1 <= nums.length <= 3 * 10^4$
* $-100 <= nums[i] <= 100$
* $0 <= index < nums.length$
* $-100 <= val <= 100$
* $0 <= left <= right < nums.length$
* 最多调用 $3 * 10^4$ 次 `update` 和 `sumRange` 方法 | ### 解题思路
这是一道很经典的题目,通常还能拓展出一大类问题。
针对不同的题目,我们有不同的方案可以选择(假设我们有一个数组):
1. 数组不变,求区间和:「前缀和」、「树状数组」、「线段树」
2. 多次修改某个数(单点),求区间和:「树状数组」、「线段树」
3. 多次修改某个区间,输出最终结果:「差分」
4. 多次修改某个区间,求区间和:「线段树」、「树状数组」(看修改区间范围大小)
5. 多次将某个区间变成同一个数,求区间和:「线段树」、「树状数组」(看修改区间范围大小)
这样看来,「线段树」能解决的问题是最多的,那我们是不是无论什么情况都写「线段树」呢?
答案并不是,而且恰好相反,只有在我们遇到第 4/5 类问题,不得不写「线段树」的时候,我们才考虑线段树。
因为「线段树」代码很长,而且常数很大,实际表现不算很好。我们只有在不得不用的时候才考虑「线段树」。
总结一下,我们应该按这样的优先级进行考虑:
1. 简单求区间和,用「前缀和」
2. 多次将某个区间变成同一个数,用「线段树」
3. 其他情况,用「树状数组」
---
### 树状数组
本题只涉及「单点修改」和「区间求和」,属于「树状数组」的经典应用。
「树状数组」本身是一个很简单的数据结构,但是要搞懂其为什么可以这样「查询」&「更新」还是比较困难的(特别是为什么可以这样更新),往往需要从「二进制分解」进行出发理解。
树状数组涉及的操作有两个,复杂度均为 $O(\log{n})$:
* `void add(int x, int u)`:含义为在 $x$ 的位置增加 $u$(注意位置下标从 $1$ 开始);
* `int query(int x)`:含义为查询从 $[1, x]$ 区间的和为多少(配合容斥原理,可实现任意区间查询)。
代码:
```Java
class NumArray {
int[] tr;
int lowbit(int x) {
return x & -x;
}
void add(int x, int u) {
for (int i = x; i <= n; i += lowbit(i)) tr[i] += u;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
}
int[] nums;
int n;
public NumArray(int[] _nums) {
nums = _nums;
n = nums.length;
tr = new int[n + 10];
for (int i = 0; i < n; i++) add(i + 1, nums[i]);
}
public void update(int index, int val) {
add(index + 1, val - nums[index]);
nums[index] = val;
}
public int sumRange(int left, int right) {
return query(right + 1) - query(left);
}
}
```
* 时间复杂度:插入和查询复杂度均为 $O(\log{n})$
* 空间复杂度:$O(n)$
---
### 线段树
相比「树状数组」,另外一个更为进阶且通用的做法是使用「线段树」。
线段树的所有操作同样为 $O(\log{n}),$由于本题不涉及「区间修改」操作,因此我们的线段树只需要实现 `pushup` 操作(子节点往上更新父节点),而不需要实现用于懒标记的 `pushdown` 操作(父节点往下传递「更新」的操作)。
关于线段树设计的几种操作:
* `void build(int u, int l, int r)`:含义为从编号为 $u$ 的节点开始,构造范围为 $[l,r]$ 的树节点;
* `void update(int u, int x, int v)`:含义为从编号为 $u$ 的节点开始,在 $x$ 位置增加 $v$;
* 更具一般性(涉及区间修改)的操作应该为 `void update(int u, int l, int r, int v)`,代表在 $[l, r]$ 范围增加 $v$;
* `int query(int u, int l, int r)`:含义为从编号为 $u$ 的节点开始,查询 $[l, r]$ 区间和为多少。
> 注意:对于编号为 `u` 的节点而言,其左子节点的编号为 `u << 1`,其右节点的编号为 `u << 1 | 1`。
代码(考虑为线段树增加 `static` 优化的代码见 $P2$,样例个数较少,优化不明显):
```Java
class NumArray {
Node[] tr;
class Node {
int l, r, v;
Node(int _l, int _r) {
l = _l; r = _r;
}
}
void build(int u, int l, int r) {
tr[u] = new Node(l, r);
if (l == r) return;
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
}
void update(int u, int x, int v) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].v += v;
return ;
}
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) update(u << 1, x, v);
else update(u << 1 | 1, x, v);
pushup(u);
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].v;
int mid = tr[u].l + tr[u].r >> 1;
int ans = 0;
if (l <= mid) ans += query(u << 1, l, r);
if (r > mid) ans += query(u << 1 | 1, l, r);
return ans;
}
void pushup(int u) {
tr[u].v = tr[u << 1].v + tr[u << 1 | 1].v;
}
int[] nums;
public NumArray(int[] _nums) {
nums = _nums;
int n = nums.length;
tr = new Node[n * 4];
build(1, 1, n);
for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);
}
public void update(int index, int val) {
update(1, index + 1, val - nums[index]);
nums[index] = val;
}
public int sumRange(int left, int right) {
return query(1, left + 1, right + 1);
}
}
```
-
```Java
class NumArray {
static int N = 30010;
static Node[] tr = new Node[N * 4];
class Node {
int l, r, v;
Node(int _l, int _r) {
l = _l; r = _r;
}
}
void build(int u, int l, int r) {
if (tr[u] == null) {
tr[u] = new Node(l, r);
} else {
tr[u].l = l; tr[u].r = r; tr[u].v = 0;
}
if (l == r) return ;
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
}
void update(int u, int x, int v) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].v += v;
return ;
}
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) update(u << 1, x, v);
else update(u << 1 | 1, x, v);
pushup(u);
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].v;
int mid = tr[u].l + tr[u].r >> 1;
int ans = 0;
if (l <= mid) ans += query(u << 1, l, r);
if (r > mid) ans += query(u << 1 | 1, l, r);
return ans;
}
void pushup(int u) {
tr[u].v = tr[u << 1].v + tr[u << 1 | 1].v;
}
int[] nums;
public NumArray(int[] _nums) {
nums = _nums;
int n = nums.length;
build(1, 1, n);
for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);
}
public void update(int index, int val) {
update(1, index + 1, val - nums[index]);
nums[index] = val;
}
public int sumRange(int left, int right) {
return query(1, left + 1, right + 1);
}
}
```
* 时间复杂度:插入和查询复杂度均为 $O(\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.307` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/301-310/310. 最小高度树（中等）.md | 310. 最小高度树 | https://leetcode-cn.com/problems/minimum-height-trees/solution/by-ac_oier-7xio/ | 中等 | [
"树形 DP",
"DFS",
"动态规划"
] | 树是一个无向图,其中任何两个顶点只通过一条路径连接。 换句话说,一个任何没有简单环路的连通图都是一棵树。
给你一棵包含 $n$ 个节点的树,标记为 $0$ 到 $n - 1$ 。给定数字 $n$ 和一个有 $n - 1$ 条无向边的 `edges` 列表(每一个边都是一对标签),其中 $edges[i] = [a_i, b_i]$ 表示树中节点 $a_i$ 和 $b_i$ 之间存在一条无向边。
可选择树中任何一个节点作为根。当选择节点 $x$ 作为根节点时,设结果树的高度为 $h$ 。在所有可能的树中,具有最小高度的树(即,`min(h)`)被称为 最小高度树 。
请你找到所有的 **最小高度树** 并按 **任意顺序** 返回它们的根节点标签列表。
树的 **高度** 是指根节点和叶子节点之间最长向下路径上边的数量。
示例 1:
```
输入:n = 4, edges = [[1,0],[1,2],[1,3]]
输出:[1]
解释:如图所示,当根是标签为 1 的节点时,树的高度是 1 ,这是唯一的最小高度树。
```
示例 2:
```
输入:n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
输出:[3,4]
```
提示:
* $1 <= n <= 2 \times 10^4$
* $edges.length = n - 1$
* $0 <= ai, bi < n$
* $ai != bi$
* 所有 $(ai, bi)$ 互不相同
* 给定的输入保证是一棵树,并且不会有重复的边 | ### 树形 DP
这是一道树形 DP 模板题。
当确定以某个点为根节点时,整棵树的形态唯一固定,不妨以编号为 $0$ 的节点作为根节点进行分析。
假设当前处理到的节点为 `u`,其是从父节点 `fa` 遍历而来,且将要遍历的子节点为 `j`。
即树的形态如图所示(一些可能有的出边用虚线表示):
**树形 DP 问题通常将问题根据「方向」进行划分**。
对于当前处理到的节点 `u` 而言,我们根据是否考虑「从 `fa` 到 `u` 的出边」将其分为「往上」和「往下」两个方向。
假设我们可以通过 `DFS` 预处理出 $f$ 数组和 $g$ 数组:
* $f[u]$ 代表在以 $0$ 号点为根节点的树中,以 `u` 节点为子树根节点时,往下的最大高度
* $g[u]$ 代表在以 $0$ 号点为根节点的树中,以 `u` 节点为子节点时,往上的最大高度
那么最终以 `u` 为根节点的最大高度为 $\max(f[u], g[u])$。
$f[u]$ 只需要简单的 `DFS` 即可处理出来。对于 $g[u]$ 而言,其同样包含「往上」和「往下」两部分:
* 对于经过 `fa` 后接着往上的部分有 $g[fa] + 1$
* 对于经过 `fa` 后转而往下的部分,我们需要考虑「`fa` 节点往下的最大值 $f[fa]$」是否由 `u` 节点参与而来进行分情况讨论:
* 如果 $f[fa]$ 本身不由 `u` 参与,那么 $g[u]$ 应当是 `fa` 节点往下的最大值 $+1$ 而来($+1$ 代表加上 `fa` 到 `u` 的边)
* 如果本身 `fa` 往下的最大值由 `u` 节点参与,此时应当使用 `fa` 往下的次大值 $+1$ 来更新 $g[u]$
因此我们需要对 $f$ 数组进行拆分,拆分为记录「最大值的 $f1$ 数组」和记录「次大值的 $f2$ 数组(注意这里的次大值是非严格的次大值)」,同时使用 $p$ 数组记录下取得 $f1[u]$ 时 `u` 的子节点 `j` 为何值。
实现上,在处理「往上」方向的 `DFS` 时,为避免对 `fa` 节点为空的处理,我们可以将「用 `fa` 来更新 `u`」调整为「用 `u` 来更新 `j`」。
代码:
```Java
class Solution {
int N = 20010, M = N * 2, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M];
int[] f1 = new int[N], f2 = new int[N], g = new int[N], p = new int[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public List<Integer> findMinHeightTrees(int n, int[][] edges) {
Arrays.fill(he, -1);
for (int[] e : edges) {
int a = e[0], b = e[1];
add(a, b); add(b, a);
}
dfs1(0, -1);
dfs2(0, -1);
List<Integer> ans = new ArrayList<>();
int min = n;
for (int i = 0; i < n; i++) {
int cur = Math.max(f1[i], g[i]);
if (cur < min) {
min = cur;
ans.clear();
ans.add(i);
} else if (cur == min) {
ans.add(i);
}
}
return ans;
}
int dfs1(int u, int fa) {
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
int sub = dfs1(j, u) + 1;
if (sub > f1[u]) {
f2[u] = f1[u];
f1[u] = sub;
p[u] = j;
} else if (sub > f2[u]) {
f2[u] = sub;
}
}
return f1[u];
}
void dfs2(int u, int fa) {
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
if (p[u] != j) g[j] = Math.max(g[j], f1[u] + 1);
else g[j] = Math.max(g[j], f2[u] + 1);
g[j] = Math.max(g[j], g[u] + 1);
dfs2(j, u);
}
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 补充
可能会初次接触「树形 DP」的同学不太理解,这里再补充说明一下。
归根结底,以 `u` 为根节点的最大深度,必然是下面三种情况之一(往下、往上 和 往上再往下)。
其中对 $f$ 数组的拆分(变为 $f1$ 和 $f2$)以及记录取得 $f1$ 对应的子节点 $p[i]$,目的都是为了能够正确统计「往上再往下」的情况(统计该情况时,不能考虑从 `fa` 经过 `u` 的路径,因此需要记录一个非严格的次大值 $f2$)。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/31. 下一个排列（中等）.md | 31. 下一个排列 | https://leetcode-cn.com/problems/next-permutation/solution/miao-dong-xi-lie-100-cong-xia-yi-ge-pai-gog8j/ | 中等 | [
"模拟",
"数学"
] | 实现获**下一个排列**的函数,算法需要将给定数字序列重新排列成字典序中下一个更大的排列。
如果不存在下一个更大的排列,则将数字重新排列成最小的排列(即升序排列)。
必须「原地」修改,只允许使用额外常数空间。
示例 1:
```
输入:nums = [1,2,3]
输出:[1,3,2]
```
示例 2:
```
输入:nums = [3,2,1]
输出:[1,2,3]
```
示例 3:
```
输入:nums = [1,1,5]
输出:[1,5,1]
```
示例 4:
```
输入:nums = [1]
输出:[1]
```
提示:
* $1 <= nums.length <= 100$
* $0 <= nums[i] <= 100$ | ### 模拟
找下一个排列的数,大家可以先想想大脑来是怎么完成这个找数的过程的。
**我们会尽可能的将低位的数字变大,这样才符合「下一个排列」的定义。**
也就是从低位往高位检查,观察某一位在「下一个排列」中是否可以被更大的数代替。
那么如何判断某一位能够被更大的数代替呢?
**其实就是将 `k` 位到低位的所有数作为候选,判断是否有更大的数可以填入 `k` 位中。**
假设当前我们检查到 `k` 位,要分析第 `k` 位在「下一个排列」中是否能被更大的数代替。
我们会先假定高位到 `k` 位的数不变,在 `k` 位到低位中是否有比 `k` 位上的数更大的数,如果有说明 `k` 在「下一个排列」中变大。
换句话说,我们要找的第 `k` 位其实就是从低位到高位的第一个下降的数。
...
为了更好理解,我们结合样例来分析,假设样例为 `[1,3,5,4,1]`:
1. **从后往前找,找到第一个下降的位置,记为 `k`。注意`k` 以后的位置是降序的。** 在样例中就是找到 3
2. **从 k 往后找,找到最小的比 k 要大的数。** 找到 4
3. **将两者交换。注意此时 `k` 以后的位置仍然是降序的。**
4. **直接将 k 以后的部分翻转(变为升序)。**
注意:如果在步骤 1 中找到头部还没找到,说明该序列已经是字典序最大的排列。按照题意,我们要将数组重新排列成最小的排列。
代码:
```Java
class Solution {
public void nextPermutation(int[] nums) {
int n = nums.length, k = n - 1;
while (k - 1 >= 0 && nums[k - 1] >= nums[k]) k--;
if (k == 0) {
reverse(nums, 0, n - 1);
} else {
int u = k;
while (u + 1 < n && nums[u + 1] > nums[k - 1]) u++;
swap(nums, k - 1, u);
reverse(nums, k, n - 1);
}
}
void reverse(int[] nums, int a, int b) {
int l = a, r = b;
while (l < r) swap(nums, l++, r--);
}
void swap(int[] nums, int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.31` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/32. 最长有效括号（困难）.md | 32. 最长有效括号 | https://leetcode.cn/problems/longest-valid-parentheses/solutions/577327/shua-chuan-lc-miao-dong-xi-lie-shi-yong-95ezk/ | 困难 | [
"栈",
"括号问题"
] | 给你一个只包含 `'('` 和 `')'` 的字符串,找出最长有效(格式正确且连续)括号子串的长度。
示例 1:
```
输入:s = "(()"
输出:2
解释:最长有效括号子串是 "()"
```
示例 2:
```
输入:s = ")()())"
输出:4
解释:最长有效括号子串是 "()()"
```
示例 3:
```
输入:s = ""
输出:0
```
提示:
* $0 <= s.length <= 3 \times 10^4$
* $s[i]$ 为 `'('` 或 `')'` | ### 栈
从前往后扫描字符串 `s`。
用 `i` 来记录当前遍历到的位置,用 `j` 来记录最近的最长有效括号的开始位置的「前一个位置」。
只对 `'('` 进行入栈(入栈的是对应的下标),当遍历到 `')'` 的时候,由于栈中只有 `'('`,所以可以直接弹出一个 `'('` 与之匹配(如果有的话)。
再检查栈中是否还有 `'('`,如果有使用栈顶元素的下标来计算长度,否则使用 `j` 下标来计算长度。
该做法的本质:**栈里只存放待匹配的 `(` 符号,虽然这些 `(` 在原字符串中的下标不一定连续,但 `(` 之间一定为有效括号,因此可以使用栈顶元素作为有效括号的左边界计算长度**。
举个 🌰,对于 `s` = `((())((` 的情况,当整个字符串处理完,栈内剩下的不是所有的 `(` 符号(不是 $5$ 个),而是剩余待匹配的 `(` 符号(而是 $3$ 个,即从左往右第 $1$、$4$ 和 $5$ 个 `(`),虽然第 $1$ 和第 $4$ 个 `(` 符号在 `s` 中不连续,但其之间必然是有效括号。
Java 代码:
```Java
class Solution {
public int longestValidParentheses(String s) {
Deque<Integer> d = new ArrayDeque<>();
int n = s.length(), ans = 0;
for (int i = 0, j = -1; i < n; i++) {
if (s.charAt(i) == '(') {
d.addLast(i);
} else {
if (!d.isEmpty()) {
d.pollLast();
int top = j;
if (!d.isEmpty()) top = d.peekLast();
ans = Math.max(ans, i - top);
} else {
j = i;
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int longestValidParentheses(string s) {
stack<int> d;
int n = s.length(), ans = 0;
for (int i = 0, j = -1; i < n; i++) {
if (s[i] == '(') {
d.push(i);
} else {
if (!d.empty()) {
d.pop();
int top = j;
if (!d.empty()) top = d.top();
ans = max(ans, i - top);
} else {
j = i;
}
}
}
return ans;
}
};
```
Python 代码:
```Python
from collections import deque
class Solution:
def longestValidParentheses(self, s: str) -> int:
d = deque()
n, ans, j = len(s), 0, -1
for i in range(n):
if s[i] == '(':
d.append(i)
else:
if d:
d.pop()
top = j
if d: top = d[-1]
ans = max(ans, i - top)
else:
j = i
return ans
```
TypeScript 代码:
```TypeScript
function longestValidParentheses(s: string): number {
const d: number[] = [];
let n = s.length, ans = 0;
for (let i = 0, j = -1; i < n; i++) {
if (s[i] === '(') {
d.push(i);
} else {
if (d.length) {
d.pop();
let top = j;
if (d.length) top = d[d.length - 1]
ans = Math.max(ans, i - top);
} else {
j = i;
}
}
}
return ans;
};
```
* 时间复杂度:每个字符最多进栈和出栈一次,复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.32` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/33. 搜索旋转排序数组（中等）.md | 33. 搜索旋转排序数组 | https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/ | 中等 | [
"二分"
] | 整数数组 `nums` 按升序排列,数组中的值互不相同。
在传递给函数之前,`nums` 在预先未知的某个下标 $k$ ($0 <= k < nums.length$)上进行了**旋转**。
使数组变为 `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]`(下标 从 $0$ 开始计数)。
例如, `[0,1,2,4,5,6,7]` 在下标 $3$ 处经旋转后可能变为 `[4,5,6,7,0,1,2] `。
给你**旋转后**的数组 `nums` 和一个整数 `target` 。
如果 `nums` 中存在这个目标值 `target` ,则返回它的下标,否则返回 `-1` 。
示例 1:
```
输入:nums = [4,5,6,7,0,1,2], target = 0
输出:4
```
示例 2:
```
输入:nums = [4,5,6,7,0,1,2], target = 3
输出:-1
```
示例 3:
```
输入:nums = [1], target = 0
输出:-1
```
提示:
* $1 <= nums.length <= 5000$
* $-10^4 <= nums[i] <= 10^4$
* `nums` 中的每个值都 独一无二
* 题目数据保证 `nums` 在预先未知的某个下标上进行了旋转
* $-10^4 <= target <= 10^4$
进阶:你可以设计一个时间复杂度为 $O(\log{n})$ 的解决方案吗? | ### 先找旋转点后二分
但凡是从有序序列中找某个数,我们第一反应应该是「二分」。
这道题是一个原本有序的数组在某个点上进行了旋转,其实就是将原本一段升序的数组分为了两段。
我们可以先找到旋转点 `idx`,然后对 `idx` 前后进行「二分」。
Java 代码:
```Java
class Solution {
public int search(int[] nums, int target) {
int n = nums.length, idx = -1;
for (int i = 0; i < n - 1 && idx == -1; i++) {
if (nums[i] > nums[i + 1]) idx = i;
}
int ans = find(nums, 0, idx, target);
if (ans != -1) return ans;
return idx + 1 < n ? find(nums, idx + 1, n - 1, target) : ans;
}
int find(int[] nums, int l, int r, int target) {
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= target) r = mid;
else l = mid + 1;
}
return nums[l] == target ? l : -1;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int search(vector<int>& nums, int target) {
int n = nums.size(), idx = -1;
for (int i = 0; i < n - 1 && idx == -1; i++) {
if (nums[i] > nums[i + 1]) idx = i;
}
int ans = find(nums, 0, idx, target);
if (ans != -1) return ans;
return idx + 1 < n ? find(nums, idx + 1, n - 1, target) : ans;
}
int find(vector<int>& nums, int l, int r, int target) {
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= target) r = mid;
else l = mid + 1;
}
return nums[l] == target ? l : -1;
}
};
```
Python 代码:
```Python
class Solution:
def search(self, nums: List[int], target: int) -> int:
n, idx = len(nums), -1
for i in range(0, n - 1):
if nums[i] > nums[i + 1]:
idx = i
break
def find(L, R):
l, r = L, R
while l < r:
mid = l + r >> 1
if nums[mid] >= target: r = mid
else: l = mid + 1
return l if nums[l] == target else -1
ans = find(0, idx)
if ans != -1: return ans
return find(idx + 1, n - 1) if idx + 1 < n else ans
```
TypeScript 代码:
```TypeScript
function search(nums: number[], target: number): number {
let n = nums.length, idx = -1;
for (let i = 0; i < n - 1 && idx == -1; i++) {
if (nums[i] > nums[i + 1]) idx = i;
}
const find = function(l: number, r: number): number {
while (l < r) {
let mid = l + r >> 1;
if (nums[mid] >= target) r = mid;
else l = mid + 1;
}
return nums[l] == target ? l : -1;
}
let ans = find(0, idx);
if (ans!= -1) return ans;
return idx + 1 < n ? find(idx + 1, n - 1) : ans;
};
```
* 时间复杂度:先对数组进行一次遍历,找到 `idx`,复杂度为 $O(n)$,对 `idx` 前后进行二分查找,复杂度为 $O(\log{n})$。整体为 $O(n)$
* 空间复杂度:$O(1)$
---
### 两次二分
不难发现,虽然在朴素解法中我们应用了「二分」查找。
但理论复杂度为 $O(n)$,实际复杂度也远达不到 $O(\log{n})$,执行效率取决于旋转点 `idx` 所在数组的下标位置。
那么我们如何实现 $O(\log{n})$ 的解法呢?
这道题其实是要我们明确「二分」的本质是什么。
「二分」不是单纯指从有序数组中快速找某个数,这只是「二分」的一个应用。
**「二分」的本质是两段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。**
经过旋转的数组,显然前半段满足 `>= nums[0]`,而后半段不满足 `>= nums[0]`。我们可以以此作为依据,通过「二分」找到旋转点。
找到旋转点之后,再通过比较 `target` 和 `nums[0]` 的大小,确定 `target` 落在旋转点的左边还是右边。
Java 代码:
```Java
class Solution {
public int search(int[] nums, int target) {
int n = nums.length;
// 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] >= nums[0]) l = mid;
else r = mid - 1;
}
// 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边
if (target >= nums[0]) {
l = 0;
} else {
l = l + 1; r = n - 1;
}
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= target) r = mid;
else l = mid + 1;
}
return nums[r] == target ? r : -1;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int search(vector<int>& nums, int target) {
int n = nums.size();
// 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] >= nums[0]) l = mid;
else r = mid - 1;
}
// 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边
if (target >= nums[0]) {
l = 0;
} else {
l = l + 1; r = n - 1;
}
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= target) r = mid;
else l = mid + 1;
}
return nums[r] == target ? r : -1;
}
};
```
Python 代码:
```Python
class Solution:
def search(self, nums: List[int], target: int) -> int:
n = len(nums)
# 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)
l, r = 0, n - 1
while l < r:
mid = l + r + 1 >> 1
if nums[mid] >= nums[0]: l = mid
else: r = mid - 1
# 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边
if target >= nums[0]:
l = 0
else:
l, r = l + 1, n - 1
while l < r:
mid = l + r >> 1
if nums[mid] >= target: r = mid
else: l = mid + 1
return r if nums[r] == target else -1
```
TypeScript 代码:
```TypeScript
function search(nums: number[], target: number): number {
const n = nums.length;
// 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)
let l = 0, r = n - 1;
while (l < r) {
let mid = l + r + 1 >> 1;
if (nums[mid] >= nums[0]) l = mid;
else r = mid - 1;
}
// 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边
if (target >= nums[0]) {
l = 0;
} else {
l = l + 1; r = n - 1;
}
while (l < r) {
let mid = l + r >> 1;
if (nums[mid] >= target) r = mid;
else l = mid + 1;
}
return nums[r] == target ? r : -1;
};
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.33` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/34. 在排序数组中查找元素的第一个和最后一个位置（中等）.md | 34. 在排序数组中查找元素的第一个和最后一个位置 | https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/sha-sha-gao-bu-qing-ru-he-ding-yi-er-fen-rrj1/ | 中等 | [
"二分"
] | 给定一个按照升序排列的整数数组 `nums`,和一个目标值 `target`。
找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 `target`,返回 $[-1, -1]$。
**进阶:**
* 你可以设计并实现时间复杂度为 $O(\log{n})$ 的算法解决此问题吗?
示例 1:
```
输入:nums = [5,7,7,8,8,10], target = 8
输出:[3,4]
```
示例 2:
```
输入:nums = [5,7,7,8,8,10], target = 6
输出:[-1,-1]
```
示例 3:
```
输入:nums = [], target = 0
输出:[-1,-1]
```
提示:
* $0 <= nums.length <= 10^5$
* $-10^9 <= nums[i] <= 10^9$
* `nums` 是一个非递减数组
* $-10^9 <= target <= 10^9$ | ### 二分解法
这是一道「二分查找」的裸题。
「二分」有一个比较容易混淆的点是:当需要找目标值第一次出现的下标时,条件应该写成 `nums[mid] >= target` 还是 `nums[mid] <= target`。
其实有一个很好理解的方法:
**由于二分是从中间开始找起的,所以找的必然是条件区间中靠近中心的的边界值。**
文字不好理解,我们结合图片来看:
代码:
```Java
class Solution {
public int[] searchRange(int[] nums, int t) {
int[] ans = new int[]{-1, -1};
int n = nums.length;
if (n == 0) return ans;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= t) r = mid;
else l = mid + 1;
}
if (nums[r] != t) return ans;
ans[0] = r;
l = 0; r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] <= t) l = mid;
else r = mid - 1;
}
ans[1] = r;
return ans;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.34` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/35. 搜索插入位置（简单）.md | 35. 搜索插入位置 | https://leetcode-cn.com/problems/search-insert-position/solution/shua-chuan-lc-jian-dan-mo-ni-ti-by-ac_oi-7d5t/ | 简单 | [
"模拟",
"二分"
] | 给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。
如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
```
输入: [1,3,5,6], 5
输出: 2
```
示例 2:
```
输入: [1,3,5,6], 2
输出: 1
```
示例 3:
```
输入: [1,3,5,6], 7
输出: 4
```
示例 4:
```
输入: [1,3,5,6], 0
输出: 0
``` | ### 朴素做法
一个朴素的做法,从前往后进行处理,直到遇到符合条件的位置。
代码:
```Java
class Solution {
public int searchInsert(int[] nums, int t) {
for (int i = 0; i < nums.length; i++) {
if (nums[i] == t || nums[i] > t) return i;
}
return nums.length;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 二分解法
利用数组本身有序,我们可以通过二分找插入位置。
具体的,通过二分找到符合 `nums[mid] >= t` 的分割点。注意二分完后需要再次检查是否位置是否符合条件,如果不符合,代表插入元素应该被添加到数组结尾。
代码:
```Java
class Solution {
public int searchInsert(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= t) {
r = mid;
} else {
l = mid + 1;
}
}
return nums[r] >= t ? r : r + 1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.35` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/36. 有效的数独（中等）.md | 36. 有效的数独 | https://leetcode-cn.com/problems/valid-sudoku/solution/gong-shui-san-xie-yi-ti-san-jie-ha-xi-bi-ssxp/ | 中等 | [
"哈希表",
"数组",
"位运算",
"数独问题"
] | 请你判断一个 `9 x 9` 的数独是否有效。只需要 根据以下规则 ,验证已经填入的数字是否有效即可。
1. 数字 `1-9` 在每一行只能出现一次。
2. 数字 `1-9` 在每一列只能出现一次。
3. 数字 `1-9` 在每一个以粗实线分隔的 `3 x 3` 宫内只能出现一次。(请参考示例图)
数独部分空格内已填入了数字,空白格用 `'.'` 表示。
注意:
* 一个有效的数独(部分已被填充)不一定是可解的。
* 只需要根据以上规则,验证已经填入的数字是否有效即可。
示例 1:
```
输入:board =
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出:true
```
示例 2:
```
输入:board =
[["8","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出:false
解释:除了第一行的第一个数字从 5 改为 8 以外,空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
```
提示:
* $board.length == 9$
* $board[i].length == 9$
* `board[i][j]` 是一位数字或者 `'.'` | ### 哈希表
由于只要我们判断是否为有效的数独。
所以我们只需要对 `board` 中出现的数进行判断,如果 `board` 中有数违反了数独的规则,返回 `false`,否则返回 `true`。
直观上,我们很容易想到使用 **哈希表** 来记录某行/某列/某个小方块出现过哪些数字,来帮助我们判断是否符合「有效数独」的定义。
这道题唯一的难点可能是在于如何确定某个数落在哪个小方块中,我们可以去小方块进行编号:
然后推导出小方块编号和行列的关系为: $idx = \left \lfloor i / 3 \right \rfloor * 3 + \left \lfloor j / 3 \right \rfloor$。
代码:
```Java
class Solution {
public boolean isValidSudoku(char[][] board) {
Map<Integer, Set<Integer>> row = new HashMap<>(), col = new HashMap<>(), area = new HashMap<>();
for (int i = 0; i < 9; i++) {
row.put(i, new HashSet<>());
col.put(i, new HashSet<>());
area.put(i, new HashSet<>());
}
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];
if (c == '.') continue;
int u = c - '0';
int idx = i / 3 * 3 + j / 3;
if (row.get(i).contains(u) || col.get(j).contains(u) || area.get(idx).contains(u)) return false;
row.get(i).add(u);
col.get(j).add(u);
area.get(idx).add(u);
}
}
return true;
}
}
```
* 时间复杂度:在固定 $9 \times 9$ 的问题里,计算量不随数据变化而变化。复杂度为 $O(1)$
* 空间复杂度:在固定 $9 \times 9$ 的问题里,存储空间不随数据变化而变化。复杂度为 $O(1)$
---
### 数组
大多数的哈希表计数问题,都能转换为使用数组解决。
虽然时间复杂度一样,但哈希表的更新和查询复杂度为均摊 $O(1)$,而定长数组的的更新和查询复杂度则是严格 $O(1)$。
因此从执行效率上来说,数组要比哈希表快上不少。
代码:
```Java
class Solution {
public boolean isValidSudoku(char[][] board) {
boolean[][] row = new boolean[10][10], col = new boolean[10][10], area = new boolean[10][10];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
int c = board[i][j];
if (c == '.') continue;
int u = c - '0';
int idx = i / 3 * 3 + j / 3;
if (row[i][u] || col[j][u] || area[idx][u]) return false;
row[i][u] = col[j][u] = area[idx][u] = true;
}
}
return true;
}
}
```
* 时间复杂度:在固定 $9*9$ 的问题里,计算量不随数据变化而变化。复杂度为 $O(1)$
* 空间复杂度:在固定 $9*9$ 的问题里,存储空间不随数据变化而变化。复杂度为 $O(1)$
---
### 位运算
更进一步,我们可以使用一个 $int$ 来记录 某行/某列/某个小方块 的数值填入情况:使用从低位开始的 $[1, 9]$ 位来记录该数值是否已被填入。
例如 $(... 111000111 .)_2$ 代表数值 $[1, 3]$ 和 $[7, 9]$ 均被填入。
代码:
```Java
class Solution {
public boolean isValidSudoku(char[][] board) {
int[] row = new int[10], col = new int[10], area = new int[10];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];
if (c == '.') continue;
int u = c - '0';
int idx = i / 3 * 3 + j / 3;
if ((((row[i] >> u) & 1) == 1) || (((col[j] >> u) & 1) == 1) || (((area[idx] >> u) & 1) == 1)) return false;
row[i] |= (1 << u);
col[j] |= (1 << u);
area[idx] |= (1 << u);
}
}
return true;
}
}
```
* 时间复杂度:在固定 $9 \times 9$ 的问题里,计算量不随数据变化而变化。复杂度为 $O(1)$
* 空间复杂度:在固定 $9 \times 9$ 的问题里,存储空间不随数据变化而变化。复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.36` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/37. 解数独（困难）.md | 37. 解数独 | https://leetcode-cn.com/problems/sudoku-solver/solution/he-n-huang-hou-yi-yang-shi-yi-dao-hui-su-lfpd/ | 困难 | [
"回溯算法",
"DFS",
"数独问题"
] | 编写一个程序,通过填充空格来解决数独问题。
数独的解法需 遵循如下规则:
1. 数字 `1-9` 在每一行只能出现一次。
2. 数字 `1-9` 在每一列只能出现一次。
3. 数字 `1-9` 在每一个以粗实线分隔的 `3 x 3` 宫内只能出现一次。(请参考示例图)
数独部分空格内已填入了数字,空白格用 '.' 表示。
示例:
```
输入:board =
[["5","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".",".","6",".",".",".","3"],
["4",".",".","8",".","3",".",".","1"],
["7",".",".",".","2",".",".",".","6"],
[".","6",".",".",".",".","2","8","."],
[".",".",".","4","1","9",".",".","5"],
[".",".",".",".","8",".",".","7","9"]]
输出:[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],
["1","9","8","3","4","2","5","6","7"],
["8","5","9","7","6","1","4","2","3"],
["4","2","6","8","5","3","7","9","1"],
["7","1","3","9","2","4","8","5","6"],
["9","6","1","5","3","7","2","8","4"],
["2","8","7","4","1","9","6","3","5"],
["3","4","5","2","8","6","1","7","9"]]
解释:输入的数独如上图所示,唯一有效的解决方案如下所示:
```
提示:
* $board.length == 9$
* $board[i].length == 9$
* `board[i][j]` 是一位数字或者 `'.'`
* 题目数据 保证 输入数独仅有一个解 | ### 回溯解法
和 N 皇后一样,是一道回溯解法裸题。
上一题「36. 有效的数独(中等)」是让我们判断给定的 `borad` 是否为有效数独。
这题让我们对给定 `board` 求数独,由于 `board` 固定是 `9 * 9` 的大小,我们可以使用回溯算法去做。
这一类题和 N 皇后一样,属于经典的回溯算法裸题。
这类题都有一个明显的特征,就是数据范围不会很大,如该题限制了范围为 `9 * 9`,而 N 皇后的 N 一般不会超过 13。
对每一个需要填入数字的位置进行填入,如果发现填入某个数会导致数独解不下去,则进行回溯。
代码:
```Java
class Solution {
boolean[][] row = new boolean[9][9];
boolean[][] col = new boolean[9][9];
boolean[][][] cell = new boolean[3][3][9];
public void solveSudoku(char[][] board) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (board[i][j] != '.') {
int t = board[i][j] - '1';
row[i][t] = col[j][t] = cell[i / 3][j / 3][t] = true;
}
}
}
dfs(board, 0, 0);
}
boolean dfs(char[][] board, int x, int y) {
if (y == 9) return dfs(board, x + 1, 0);
if (x == 9) return true;
if (board[x][y] != '.') return dfs(board, x, y + 1);
for (int i = 0; i < 9; i++) {
if (!row[x][i] && !col[y][i] && !cell[x / 3][y / 3][i]) {
board[x][y] = (char)(i + '1');
row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = true;
if (dfs(board, x, y + 1)) {
break;
} else {
board[x][y] = '.';
row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = false;
}
}
}
return board[x][y] != '.';
}
}
```
* 时间复杂度:在固定 `9*9` 的棋盘里,具有一个枚举方案的最大值(极端情况,假设我们的棋盘刚开始是空的,这时候每一个格子都要枚举,每个格子都有可能从 $1$ 枚举到 $9$,所以枚举次数为 $9 \times 9 \times 9 = 729$),即复杂度不随数据变化而变化。复杂度为 $O(1)$
* 空间复杂度:在固定 `9*9` 的棋盘里,复杂度不随数据变化而变化。复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.37` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/38. 外观数列（简单）.md | 38. 外观数列 | https://leetcode-cn.com/problems/count-and-say/solution/shua-chuan-lc-100-mo-ni-ti-shi-yong-shao-w8jl/ | 简单 | [
"模拟"
] | 给定一个正整数 n ,输出外观数列的第 n 项。
「外观数列」是一个整数序列,从数字 1 开始,序列中的每一项都是对前一项的描述。
你可以将其视作是由递归公式定义的数字字符串序列:
* countAndSay(1) = "1"
* countAndSay(n) 是对 countAndSay(n-1) 的描述,然后转换成另一个数字字符串。
前五项如下:
```
1. 1
2. 11
3. 21
4. 1211
5. 111221
第一项是数字 1
描述前一项,这个数是 1 即 “ 一 个 1 ”,记作 "11"
描述前一项,这个数是 11 即 “ 二 个 1 ” ,记作 "21"
描述前一项,这个数是 21 即 “ 一 个 2 + 一 个 1 ” ,记作 "1211"
描述前一项,这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ,记作 "111221"
```
要**描述**一个数字字符串,首先要将字符串分割为 最小 数量的组,每个组都由连续的最多 相同字符 组成。然后对于每个组,先描述字符的数量,然后描述字符,形成一个描述组。要将描述转换为数字字符串,先将每组中的字符数量用数字替换,再将所有描述组连接起来。
例如,数字字符串 "3322251" 的描述如下图:
示例 1:
```
输入:n = 1
输出:"1"
解释:这是一个基本样例。
```
示例 2:
```
输入:n = 4
输出:"1211"
解释:
countAndSay(1) = "1"
countAndSay(2) = 读 "1" = 一 个 1 = "11"
countAndSay(3) = 读 "11" = 二 个 1 = "21"
countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"
```
提示:
* 1 <= n <= 30 | ### 模拟
一个朴素的想法是:根据题意进行模拟,从起始条件 $k = 1$ 时 `ans = "1"` 出发,逐步递推到 $k = n$ 的情况,对于第 $k$ 项而言,其实就是对第 $k - 1$ 项的「连续段」的描述,而求「连续段」长度,可以使用双指针实现。
代码:
```Java
class Solution {
public String countAndSay(int n) {
String ans = "1";
for (int i = 2; i <= n; i++) {
String cur = "";
int m = ans.length();
for (int j = 0; j < m; ) {
int k = j + 1;
while (k < m && ans.charAt(j) == ans.charAt(k)) k++;
int cnt = k - j;
cur += cnt + "" + ans.charAt(j);
j = k;
}
ans = cur;
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
---
### 打表
利用数据范围只有 $30$,我们可以使用 `static` 进行打表操作,从而节省掉不同样例之间的「重复」部分的计算量。
例如对于 $n = 5$ 和 $n = 6$ 都存在先计算前五项的公共部分,打表可以确保这部分只会被计算一次,同时能够应用到后面项中。
代码:
```Java
class Solution {
static String[] f = new String[35];
static {
f[1] = "1";
for (int i = 2; i < 35; i++) {
String prev = f[i - 1], cur = "";
int m = prev.length();
for (int j = 0; j < m; ) {
int k = j + 1;
while (k < m && prev.charAt(j) == prev.charAt(k)) k++;
int cnt = k - j;
cur += cnt + "" + prev.charAt(j);
j = k;
}
f[i] = cur;
}
}
public String countAndSay(int n) {
return f[n];
}
}
```
* 时间复杂度:将打表逻辑到放本地执行,复杂度为 $O(1)$;放到 $OJ$ 执行则为 $O(n^2)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.38` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/39. 组合总和（中等）.md | 39. 组合总和 | https://leetcode-cn.com/problems/combination-sum/solution/dfs-hui-su-suan-fa-yi-ji-ru-he-que-ding-wpbo5/ | 中等 | [
"回溯算法",
"DFS",
"组合总和问题"
] | 给定一个无重复元素的数组 `candidates` 和一个目标数 `target` ,找出 `candidates` 中所有可以使数字和为 `target` 的组合。
`candidates` 中的数字可以无限制重复被选取。
说明:
* 所有数字(包括 `target`)都是正整数。
* 解集不能包含重复的组合。
示例 1:
```
输入:candidates = [2,3,6,7], target = 7,
所求解集为:
[
[7],
[2,2,3]
]
```
示例 2:
```
输入:candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3,3],
[3,5]
]
```
提示:
* $1 <= candidates.length <= 30$
* $1 <= candidates[i] <= 200$
* `candidate` 中的每个元素都是独一无二的。
* $1 <= target <= 500$ | ### DFS
这道题很明显就是在考察回溯算法。
之前跟你分享过的 [37. 解数独(困难)](https://mp.weixin.qq.com/s/0y4lGAH43U3w5loTgaeyoQ) 里面有提到我们应该如何快速判断一道题是否应该使用 DFS + 回溯算法来爆搜。
总的来说,你可以从两个方面来考虑:
* **1. 求的是所有的方案,而不是方案数。** 由于求的是所有方案,不可能有什么特别的优化,我们只能进行枚举。这时候可能的解法有动态规划、记忆化搜索、DFS + 回溯算法。
* **2. 通常数据范围不会太大,只有几十。** 如果是动态规划或是记忆化搜索的题的话,由于它们的特点在于低重复/不重复枚举,所以一般数据范围可以出到 $10^4$ 到 $10^5$,而 DFS + 回溯的话,通常会限制在 $30$ 以内。
这道题数据范围是 $30$ 以内,而且是求所有方案,因此我们使用 DFS + 回溯来求解。
代码:
```Java
class Solution {
public List<List<Integer>> combinationSum(int[] cs, int t) {
List<List<Integer>> ans = new ArrayList<>();
List<Integer> cur = new ArrayList<>();
dfs(cs, t, 0, ans, cur);
return ans;
}
/**
* cs: 原数组,从该数组进行选数
* t: 还剩多少值需要凑成。起始值为 target ,代表还没选择任何数;当 t = 0,代表选择的数凑成了 target
* u: 当前决策到 cs[] 中的第几位
* ans: 最终结果集
* cur: 当前结果集
*/
void dfs(int[] cs, int t, int u, List<List<Integer>> ans, List<Integer> cur) {
if (t == 0) {
ans.add(new ArrayList<>(cur));
return;
}
if (u == cs.length || t < 0) return;
// 枚举 cs[u] 的使用次数
for (int i = 0; cs[u] * i <= t; i++) {
dfs(cs, t - cs[u] * i, u + 1, ans, cur);
cur.add(cs[u]);
}
// 进行回溯。注意回溯总是将数组的最后一位弹出
for (int i = 0; cs[u] * i <= t; i++) {
cur.remove(cur.size() - 1);
}
}
}
```
* 时间复杂度:爆搜通常是指数级别的复杂度
* 空间复杂度:爆搜通常是指数级别的复杂度
* | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.39` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/31-40/40. 组合总和 II（中等）.md | 40. 组合总和 II | https://leetcode-cn.com/problems/combination-sum-ii/solution/dfs-hui-su-jie-fa-yi-ji-ru-he-pan-duan-s-xlwy/ | 中等 | [
"回溯算法",
"DFS",
"组合总和问题"
] | 给定一个数组 `candidates` 和一个目标数 `target` ,找出 `candidates` 中所有可以使数字和为 `target` 的组合。
`candidates` 中的每个数字在每个组合中只能使用一次。
说明:
* 所有数字(包括目标数)都是正整数。
* 解集不能包含重复的组合。
示例 1:
```
输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
```
示例 2:
```
输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
[1,2,2],
[5]
]
``` | ### DFS + 回溯
这道题和「39. 组合总和(中等)」几乎一样。
唯一的不同是这题每个数只能使用一次,而「39. 组合总和(中等)」中可以使用无限次。
我们再来回顾一下应该如何快速判断一道题是否应该使用 DFS + 回溯算法来爆搜。
这个判断方法,最早三叶在 [37. 解数独(困难)](https://mp.weixin.qq.com/s/0y4lGAH43U3w5loTgaeyoQ) 讲过。
总的来说,你可以从两个方面来考虑:
* **1. 求的是所有的方案,而不是方案数。** 由于求的是所有方案,不可能有什么特别的优化,我们只能进行枚举。这时候可能的解法有动态规划、记忆化搜索、DFS + 回溯算法。
* **2. 通常数据范围不会太大,只有几十。** 如果是动态规划或是记忆化搜索的题的话,由于它们的特点在于低重复/不重复枚举,所以一般数据范围可以出到 $10^5$ 到 $10^7$,而 DFS + 回溯的话,通常会限制在 30 以内。
这道题数据范围是 30 以内,而且是求所有方案。因此我们使用 DFS + 回溯来求解。
我们可以接着 [39. 组合总和(中等)](https://mp.weixin.qq.com/s/5Ee6jbc3lDlWFEDzTM_LkA) 的思路来修改:
1. 由于每个数字只能使用一次,我们可以直接在 DFS 中决策某个数是用还是不用。
2. 由于不允许重复答案,可以使用 set 来保存所有合法方案,最终再转为 list 进行返回。当然我们需要先对 cs 进行排序,确保得到的合法方案中数值都是从小到大的。这样 set 才能起到去重的作用。对于 `[1,2,1]` 和 `[1,1,2]`,set 不会认为是相同的数组。
代码:
```Java
class Solution {
public List<List<Integer>> combinationSum2(int[] cs, int t) {
Arrays.sort(cs);
Set<List<Integer>> ans = new HashSet<>();
List<Integer> cur = new ArrayList<>();
dfs(cs, t, 0, ans, cur);
return new ArrayList<>(ans);
}
/**
* cs: 原数组,从该数组进行选数
* t: 还剩多少值需要凑成。起始值为 target ,代表还没选择任何数;当 t = 0,代表选择的数凑成了 target
* u: 当前决策到 cs[] 中的第几位
* ans: 最终结果集
* cur: 当前结果集
*/
void dfs(int[] cs, int t, int u, Set<List<Integer>> ans, List<Integer> cur) {
if (t == 0) {
ans.add(new ArrayList<>(cur));
return;
}
if (u == cs.length || t < 0) return;
// 使用 cs[u]
cur.add(cs[u]);
dfs(cs, t - cs[u], u + 1, ans, cur);
// 进行回溯
cur.remove(cur.size() - 1);
// 不使用 cs[u]
dfs(cs, t, u + 1, ans, cur);
}
}
```
* 时间复杂度: DFS 回溯算法通常是指数级别的复杂度(因此数据范围通常为 30 以内)。这里暂定 $O(n \times 2^n)$
* 空间复杂度:同上。复杂度为 $O(n \times 2^n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.40` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/312. 戳气球（困难）.md | 312. 戳气球 | https://leetcode.cn/problems/burst-balloons/solution/by-ac_oier-9r9c/ | 困难 | [
"区间 DP",
"动态规划"
] | 有 `n` 个气球,编号为 `0` 到 `n - 1`,每个气球上都标有一个数字,这些数字存在数组 `nums` 中。
现在要求你戳破所有的气球。
戳破第 `i` 个气球,你可以获得 `nums[i - 1] * nums[i] * nums[i + 1]` 枚硬币。 这里的 `i - 1` 和 `i + 1` 代表和 `i` 相邻的两个气球的序号。
如果 `i - 1` 或 `i + 1` 超出了数组的边界,那么就当它是一个数字为 `1` 的气球。
求所能获得硬币的最大数量。
示例 1:
```
输入:nums = [3,1,5,8]
输出:167
解释:
nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
coins = 3*1*5 + 3*5*8 + 1*3*8 + 1*8*1 = 167
```
示例 2:
```
输入:nums = [1,5]
输出:10
```
提示:
* $n = nums.length$
* $1 <= n <= 300$
* $0 <= nums[i] <= 100$ | ### 区间 DP
定义 $f[l][r]$ 为考虑将 $(l, r)$ 范围内(不包含 `l` 和 `r` 边界)的气球消耗掉,所能取得的最大价值。
根据题意,我们可以对 `nums` 进行扩充,将其从长度为 $n$ 的 `nums` 变为长度 $n + 2$ 的 `arr`,其中 $arr[1...n]$ 对应了原数组 `nums`,而 $arr[0] = arr[n + 1] = 1$。
此时易知 $f[0][n + 1]$ 即是答案,不失一般性考虑 $f[l][r]$ 该如何转移,假设在 $(l, r)$ 范围内最后剩下的气球的编号为 $k$,此时的 $f[l][r]$ 由「以 $k$ 为分割点的两端所产生的价值」和「消耗 $k$ 本身带来的价值」两部分组成:
$$
f[l][r] = \max(f[l][k] + f[k][r] + arr[l] \times arr[k] \times arr[r]), k \in (l, r)
$$
为了确保转移能够顺利进行,我们需要确保在计算 $f[l][r]$ 的时候,区间长度比其小的 $f[l][k]$ 和 $f[k][r]$ 均被计算。
因此我们可以采用先枚举区间长度 `len`,然后枚举区间左端点 `l`(同时直接算得区间右端点 `r`)的方式来做。
Java 代码:
```Java
class Solution {
public int maxCoins(int[] nums) {
int n = nums.length;
int[] arr = new int[n + 2];
arr[0] = arr[n + 1] = 1;
for (int i = 1; i <= n; i++) arr[i] = nums[i - 1];
int[][] f = new int[n + 2][n + 2];
for (int len = 3; len <= n + 2; len++) {
for (int l = 0; l + len - 1 <= n + 1; l++) {
int r = l + len - 1;
for (int k = l + 1; k <= r - 1; k++) {
f[l][r] = Math.max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r]);
}
}
}
return f[0][n + 1];
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxCoins(vector<int>& nums) {
int n = nums.size();
int arr[n + 2];
arr[0] = arr[n + 1] = 1;
for (int i = 1; i <= n; i++) arr[i] = nums[i - 1];
int f[n + 2][n + 2];
memset(f, 0, sizeof f);
for (int len = 3; len <= n + 2; len++) {
for (int l = 0; l + len - 1 <= n + 1; l++) {
int r = l + len - 1;
for (int k = l + 1; k <= r - 1; k++) {
f[l][r] = max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r]);
}
}
}
return f[0][n + 1];
}
};
```
Python 代码:
```Python
class Solution:
def maxCoins(self, nums: List[int]) -> int:
n = len(nums)
arr = [1] * (n + 2)
arr[0] = arr[n + 1] = 1
for i in range(1, n + 1):
arr[i] = nums[i - 1]
f = [[0] * (n + 2) for _ in range(n + 2)]
for clen in range(3, n + 3):
for l in range(0, n + 2 - clen + 1):
r = l + clen - 1
for k in range(l + 1, r):
f[l][r] = max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r])
return f[0][n + 1]
```
TypeScript 代码:
```TypeScript
function maxCoins(nums: number[]): number {
const n = nums.length
const arr = new Array<number>(n + 2).fill(1)
for (let i = 1; i <= n; i++) arr[i] = nums[i - 1]
const f = new Array<Array<number>>(n + 2)
for (let i = 0; i < n + 2; i++) f[i] = new Array<number>(n + 2).fill(0)
for (let len = 3; len <= n + 2; len++) {
for (let l = 0; l + len - 1 <= n + 1; l++) {
const r = l + len - 1
for (let k = l + 1; k <= r - 1; k++) {
f[l][r] = Math.max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r])
}
}
}
return f[0][n + 1]
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.312` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/313. 超级丑数（中等）.md | 313. 超级丑数 | https://leetcode-cn.com/problems/super-ugly-number/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-jyow/ | 中等 | [
"优先队列(堆)",
"多路归并"
] | 超级丑数 是一个正整数,并满足其所有质因数都出现在质数数组 primes 中。
给你一个整数 n 和一个整数数组 primes ,返回第 n 个 超级丑数 。
题目数据保证第 n 个 超级丑数 在 32-bit 带符号整数范围内。
示例 1:
```
输入:n = 12, primes = [2,7,13,19]
输出:32
解释:给定长度为 4 的质数数组 primes = [2,7,13,19],前 12 个超级丑数序列为:[1,2,4,7,8,13,14,16,19,26,28,32] 。
```
示例 2:
```
输入:n = 1, primes = [2,3,5]
输出:1
解释:1 不含质因数,因此它的所有质因数都在质数数组 primes = [2,3,5] 中。
```
提示:
* 1 <= n <= $10^6$
* 1 <= primes.length <= 100
* 2 <= primes[i] <= 1000
* 题目数据 保证 primes[i] 是一个质数
* primes 中的所有值都 互不相同 ,且按 递增顺序 排列 | ### 基本分析
类似的题目在之前的每日一题也出现过。
本题做法与 [264. 丑数 II](https://leetcode-cn.com/problems/ugly-number-ii/) 类似,相关题解在 [这里](https://leetcode-cn.com/problems/ugly-number-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-3nvs/)。
回到本题,根据丑数的定义,我们有如下结论:
* $1$ 是最小的丑数。
* 对于任意一个丑数 $x$,其与任意给定的质因数 $primes[i]$ 相乘,结果仍为丑数。
---
### 优先队列(堆)
有了基本的分析思路,一个简单的解法是使用优先队列:
1. 起始先将最小丑数 $1$ 放入队列
2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的丑数 $x * primes[i]$ 进行入队。
3. 对步骤 $2$ 循环多次,第 $n$ 次出队的值即是答案。
为了防止同一丑数多次进队,我们可以使用数据结构 $Set$ 来记录入过队列的丑数,但该做法常数较大,容易被卡。
利用题目规定的答案为 $int$ 范围,以及丑数性质,我们可以直接在入队的时候做控制。
代码:
```Java
class Solution {
public int nthSuperUglyNumber(int n, int[] primes) {
PriorityQueue<Integer> q = new PriorityQueue<>();
q.add(1);
while (n-- > 0) {
int x = q.poll();
if (n == 0) return x;
for (int k : primes) {
if (k <= Integer.MAX_VALUE / x) q.add(k * x);
if (x % k == 0) break;
}
}
return -1; // never
}
}
```
* 时间复杂度:令 $primes$ 长度为 $m$,需要从优先队列(堆)中弹出 $n$ 个元素,每次弹出最多需要放入 $m$ 个元素,堆中最多有 $n * m$ 个元素。复杂度为 $O(n * m \log{(n * m)})$
* 空间复杂度:$O(n * m)$
---
### 多路归并
从解法一中不难发现,我们「往后产生的丑数」都是基于「已有丑数」而来(使用「已有丑数」乘上「给定质因数」$primes[i]$)。
因此,如果我们所有丑数的有序序列为 $a1,a2,a3,...,an$ 的话,序列中的每一个数都必然能够被以下三个序列(中的至少一个)覆盖(这里假设 $primes = [2,3,5]$):
* 由丑数 * $2$ 所得的有序序列:$1 * 2$、$2 * 2$、$3 * 2$、$4 * 2$、$5 * 2$、$6 * 2$、$8 * 2$ ...
* 由丑数 * $3$ 所得的有序序列:$1 * 3$、$2 * 3$、$3 * 3$、$4 * 3$、$5 * 3$、$6 * 3$、$8 * 3$ ...
* 由丑数 * $5$ 所得的有序序列:$1 * 5$、$2 * 5$、$3 * 5$、$4 * 5$、$5 * 5$、$6 * 5$、$8 * 5$ ...
我们令这些有序序列为 $arr$,最终的丑数序列为 $ans$。
如果 $primes$ 的长度为 $m$ 的话,我们可以使用 $m$ 个指针来指向这 $m$ 个有序序列 $arr$ 的当前下标。
显然,我们需要每次取 $m$ 个指针中值最小的一个,然后让指针后移(即将当前序列的下一个值放入堆中),不断重复这个过程,直到我们找到第 $n$ 个丑数。
当然,实现上,我们并不需要构造出这 $m$ 个有序序列。
我们可以构造一个存储三元组的小根堆,三元组信息为 $(val, i, idx)$:
* $val$ :为当前列表指针指向具体值;
* $i$ :代表这是由 $primes[i]$ 构造出来的有序序列;
* $idx$:代表丑数下标,存在关系 $val = ans[idx] * primes[i]$。
起始时,我们将所有的 $(primes[i], i, 0)$ 加入优先队列(堆)中,每次从堆中取出最小元素,那么下一个该放入的元素为 $(ans[idx + 1] * primes[i], i, idx + 1)$。
另外,由于我们每个 $arr$ 的指针移动和 $ans$ 的构造,都是单调递增,因此我们可以通过与当前最后一位构造的 $ans[x]$ 进行比较来实现去重,而无须引用常数较大的 `Set` 结构。
代码:
```Java
class Solution {
public int nthSuperUglyNumber(int n, int[] primes) {
int m = primes.length;
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]);
for (int i = 0; i < m; i++) {
q.add(new int[]{primes[i], i, 0});
}
int[] ans = new int[n];
ans[0] = 1;
for (int j = 1; j < n; ) {
int[] poll = q.poll();
int val = poll[0], i = poll[1], idx = poll[2];
if (val != ans[j - 1]) ans[j++] = val;
q.add(new int[]{ans[idx + 1] * primes[i], i, idx + 1});
}
return ans[n - 1];
}
}
```
* 时间复杂度:需要构造长度为 $n$ 的答案,每次构造需要往堆中取出和放入元素,堆中有 $m$ 个元素,起始时,需要对 $primes$ 进行遍历,复杂度为 $O(m)$。整体复杂度为 $O(\max(m, n\log{m}))$
* 空间复杂度:存储 $n$ 个答案,堆中有 $m$ 个元素,复杂度为 $O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.313` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/318. 最大单词长度乘积（中等）.md | 318. 最大单词长度乘积 | https://leetcode-cn.com/problems/maximum-product-of-word-lengths/solution/gong-shui-san-xie-jian-dan-wei-yun-suan-cqtxq/ | 中等 | [
"模拟",
"位运算",
"哈希表"
] | 给定一个字符串数组 `words`,找到 $length(word[i]) * length(word[j])$ 的最大值,并且这两个单词不含有公共字母。你可以认为每个单词只包含小写字母。如果不存在这样的两个单词,返回 $0$。
示例 1:
```
输入: ["abcw","baz","foo","bar","xtfn","abcdef"]
输出: 16
解释: 这两个单词为 "abcw", "xtfn"。
```
示例 2:
```
输入: ["a","ab","abc","d","cd","bcd","abcd"]
输出: 4
解释: 这两个单词为 "ab", "cd"。
```
示例 3:
```
输入: ["a","aa","aaa","aaaa"]
输出: 0
解释: 不存在这样的两个单词。
```
提示:
* $2 <= words.length <= 1000$
* $1 <= words[i].length <= 1000$
* $words[i]$ 仅包含小写字母 | ### 模拟
根据题意进行模拟即可,利用每个 $words[i]$ 只有小写字母,且只需要区分两字符是否有字母重复。
我们可以使用一个 `int` 来代指某个 $word[i]$:低 $26$ 来代指字母 `a-z` 是否出现过。
然后对每个「字符对」所对应的两个 `int` 值执行 `&` 操作(若两字符无重复字符,则结果为 $0$),并得出最终答案。
代码:
```Java
class Solution {
public int maxProduct(String[] words) {
int n = words.length, idx = 0;
int[] masks = new int[n];
for (String w : words) {
int t = 0;
for (int i = 0; i < w.length(); i++) {
int u = w.charAt(i) - 'a';
t |= (1 << u);
}
masks[idx++] = t;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if ((masks[i] & masks[j]) == 0) ans = Math.max(ans, words[i].length() * words[j].length());
}
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为 $words$ 数组的长度,转换出 $masks$ 的复杂度为 $O(\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\max(\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$
* 空间复杂度:$O(n)$
---
### 优化
不难发现,对于词频相同($mask$ 值相等)的两字符,只需要保留字符长度大的即可,因此我们可以使用「哈希表」代替 $masks$ 数组。
代码:
```Java
class Solution {
public int maxProduct(String[] words) {
Map<Integer, Integer> map = new HashMap<>();
for (String w : words) {
int t = 0, m = w.length();
for (int i = 0; i < m; i++) {
int u = w.charAt(i) - 'a';
t |= (1 << u);
}
if (!map.containsKey(t) || map.get(t) < m) map.put(t, m);
}
int ans = 0;
for (int a : map.keySet()) {
for (int b : map.keySet()) {
if ((a & b) == 0) ans = Math.max(ans, map.get(a) * map.get(b));
}
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为 $words$ 数组的长度,得到 $map$ 的复杂度为 $O(\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\max(\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.318` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/311-320/319. 灯泡开关（中等）.md | 319. 灯泡开关 | https://leetcode-cn.com/problems/bulb-switcher/solution/gong-shui-san-xie-jing-dian-shu-lun-tui-upnnb/ | 中等 | [
"数学"
] | 初始时有 `n` 个灯泡处于关闭状态。第一轮,你将会打开所有灯泡。接下来的第二轮,你将会每两个灯泡关闭一个。
第三轮,你每三个灯泡就切换一个灯泡的开关(即,打开变关闭,关闭变打开)。
第 `i` 轮,你每 `i` 个灯泡就切换一个灯泡的开关。直到第 `n` 轮,你只需要切换最后一个灯泡的开关。
找出并返回 `n` 轮后有多少个亮着的灯泡。
示例 1:
```
输入:n = 3
输出:1
解释:
初始时, 灯泡状态 [关闭, 关闭, 关闭].
第一轮后, 灯泡状态 [开启, 开启, 开启].
第二轮后, 灯泡状态 [开启, 关闭, 开启].
第三轮后, 灯泡状态 [开启, 关闭, 关闭].
你应该返回 1,因为只有一个灯泡还亮着。
```
示例 2:
```
输入:n = 0
输出:0
```
示例 3:
```
输入:n = 1
输出:1
```
提示:
* $0 <= n <= 10^9$ | ### 数学
这是一道经典的数论题。
整理一下题意:**第 $i$ 轮改变所有编号为 $i$ 的倍数的灯泡的状态(其中灯泡编号从 $1$ 开始)。**
**一个编号为 $x$ 的灯泡经过 $n$ 轮后处于打开状态的充要条件为「该灯泡被切换状态次数为奇数次」。**
同时,一个灯泡切换状态的次数为其约数的个数(去重)。
于是问题转换为:**在 $[1,n]$ 内有多少个数,其约数的个数为奇数**。这些约数个数为奇数的灯泡就是最后亮着的灯泡。
又根据「约数」的定义,我们知道如果某个数 $k$ 为 $x$ 的约数,那么 $\frac{x}{k}$ 亦为 $x$ 的约数,即「约数」总是成对出现,那么某个数的约数个数为奇数,意味着某个约数在分解过程中出现了 $2$ 次,且必然重复出现在同一次拆解中,即 $k = \frac{x}{k}$,即有 $x$ 为完全平方数(反之亦然)。
问题最终转换为:**在 $[1,n]$ 中完全平方数的个数为多少。**
根据数论推论,$[1,n]$ 中完全平方数的个数为 $\left \lfloor \sqrt{n} \right \rfloor$,即最后亮着的灯泡数量为 $\left \lfloor \sqrt{n} \right \rfloor$。
代码:
```Java
class Solution {
public int bulbSwitch(int n) {
return (int)Math.sqrt(n);
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.319` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/322. 零钱兑换（中等）.md | 322. 零钱兑换 | https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/ | 中等 | [
"完全背包",
"动态规划",
"背包问题"
] | 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 -1。
你可以认为每种硬币的数量是无限的。
示例 1:
```
输入:coins = [1, 2, 5], amount = 11
输出:3
解释:11 = 5 + 5 + 1
```
示例 2:
```
输入:coins = [2], amount = 3
输出:-1
```
示例 3:
```
输入:coins = [1], amount = 0
输出:0
```
示例 4:
```
输入:coins = [1], amount = 1
输出:1
```
示例 5:
```
输入:coins = [1], amount = 2
输出:2
```
提示:
* 1 <= coins.length <= 12
* 1 <= coins[i] <= $2^{31}$ - 1
* 0 <= amount <= $10^4$ | ### 完全背包(朴素解法)
硬币相当于我们的物品,每种硬币可以选择「无限次」,我们应该很自然的想到「完全背包」。
如果不能,那么从现在开始就要培养这样的习惯:
**当看到题目是给定一些「物品」,让我们从中进行选择,以达到「最大价值」或者「特定价值」时,我们应该联想到「背包问题」。**
**这本质上其实是一个组合问题:被选物品之间不需要满足特定关系,只需要选择物品,以达到「全局最优」或者「特定状态」即可。**
再根据物品的选择次数限制来判断是何种背包问题。
本题每种硬币可以被选择「无限次」,我们可以直接套用「完全背包」的状态定义进行微调:
**定义 $f[i][j]$ 为考虑前 $i$ 件物品,凑成总和为 $j$ 所需要的最少硬币数量。**
为了方便初始化,我们一般让 $f[0][x]$ 代表不考虑任何物品的情况。
因此我们有显而易见的初始化条件:$f[0][0] = 0$,其余 $f[0][x] = INF$。
代表当没有任何硬币的时候,存在凑成总和为 0 的方案,方案所使用的硬币为 0;凑成其他总和的方案不存在。
由于我们要求的是「最少」硬币数量,因此我们不希望「无效值」参与转移,因此可设 $INF = INT\_MAX$。
当「状态定义」与「基本初始化」有了之后,我们不失一般性的考虑 $f[i][j]$ 该如何转移。
对于第 $i$ 个硬币我们有两种决策方案:
* 不使用该硬币:
$$
f[i - 1][j]
$$
* 使用该硬币,由于每个硬币可以被选择多次(容量允许的情况下),因此最优解应当是所有方案中的最小值:
$$
min(f[i-1][j-k*coin] + k)
$$
代码:
```Java
class Solution {
int INF = Integer.MAX_VALUE;
public int coinChange(int[] cs, int cnt) {
int n = cs.length;
int[][] f = new int[n + 1][cnt + 1];
// 初始化(没有任何硬币的情况):只有 f[0][0] = 0;其余情况均为无效值。
// 这是由「状态定义」决定的,当不考虑任何硬币的时候,只能凑出总和为 0 的方案,所使用的硬币数量为 0
for (int i = 1; i <= cnt; i++) f[0][i] = INF;
// 有硬币的情况
for (int i = 1; i <= n; i++) {
int val = cs[i - 1];
for (int j = 0; j <= cnt; j++) {
// 不考虑当前硬币的情况
f[i][j] = f[i - 1][j];
// 考虑当前硬币的情况(可选当前硬币个数基于当前容量大小)
for (int k = 1; k * val <= j; k++) {
if (f[i - 1][j - k * val] != INF) {
f[i][j] = Math.min(f[i][j], f[i-1][j-k*val] + k);
}
}
}
}
return f[n][cnt] == INF ? -1 : f[n][cnt];
}
}
```
* 时间复杂度:共有 $n * cnt$ 个状态需要转移,每个状态转移最多遍历 $cnt$ 次。整体复杂度为 $O(n * cnt^2)$。
* 空间复杂度:$O(n * cnt)$。
***
### 无效状态的定义问题
**借这个问题,刚好说一下,我们初始化时,对于无效状态应该如何定义。**
可以看到上述解法,将 `INF` 定义为 `INT_MAX`。
这是因为我们转移时取的是较小值,我们希望无效值不要被转移,所以将 `INF` 定义为较大的数,以代表数学上的 $+\infty$ (正无穷)。
这很合理,但是我们需要注意,如果我们在 `INF` 的基础上进行累加的话,常规的语言会将其变成负数最小值。
也就是在正无穷基础上进行累加,会丢失其正无穷的含义,这与数学上的正无穷概念冲突。
因此,我们才有先判断再使用的习惯:
```Java
if (f[i-1][j] != INF) {
f[i][j] = Math.min(f[i][j], f[i-1][j]);
}
```
但事实上,如果每次使用都需要有前置检查的话,是很麻烦的。
于是我们有另外一个技巧,不直接使用 `INT_MAX` 作为 `INF`,而是使用一个比 `INT_MAX` 小的较大数来代表 `INF`。
相当于预留了一些「累加空间」给 `INF`。
比如使用 `0x3f3f3f3f` 作为最大值,这样我们使用 `INF` 做状态转移的时候,就不需要先判断再使用了。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
public int coinChange(int[] cs, int cnt) {
int n = cs.length;
int[][] f = new int[n + 1][cnt + 1];
for (int i = 1; i <= cnt; i++) f[0][i] = INF;
for (int i = 1; i <= n; i++) {
int val = cs[i - 1];
for (int j = 0; j <= cnt; j++) {
f[i][j] = f[i-1][j];
for (int k = 0; k * val <= j; k++) {
f[i][j] = Math.min(f[i][j], f[i-1][j-k*val] + k);
}
}
}
return f[n][cnt] == INF ? -1 : f[n][cnt];
}
}
```
***
### 完全背包(一维优化)
显然朴素版的完全背包进行求解复杂度有点高。
在[「学习完全背包」](https://mp.weixin.qq.com/s/nke1OjkhKACaONx1opk8AA)和[「上一讲练习」](https://mp.weixin.qq.com/s/zWh9zyIGMd-6fzz-KIQGDw)中,我们从最朴素背包转移方程出发,从数学的角度去推导一维优化是如何来的。
这十分科学,而绝对严谨。
但每次都这样推导是十分耗时的。
因此,我们这次站在一个「更高」的角度去看「完全背包」问题。
我们知道传统的「完全背包」二维状态转移方程是:
$$
f[i][j] = max(f[i - 1][j], f[i - 1][j - k * w[i]] + k* v[i])
$$
经过一维空间优化后的状态转移方程是(同时容量维度遍历顺序为「从小到大」):
$$
f[j] = max(f[j], f[j - w[i]] + v[i])
$$
这是我们在 [学习完全背包](https://mp.weixin.qq.com/s/nke1OjkhKACaONx1opk8AA) 时推导的,是经过严格证明的,具有一般性的。
然后我们只需要对「成本」&「价值」进行抽象,并结合「换元法」即可得到任意背包问题的一维优化状态转移方程。
拿我们本题的状态转移方程来分析,本题的朴素状态转移方程为:
$$
f[i][j] = min(f[i - 1][j], f[i-1][j-k*coin] + k)
$$
我们将硬币的面值抽象为「成本」,硬币的数量抽象「价值」,再对物品维度进行消除,即可得:
$$
f[j] = min(f[j], f[j-coin] + 1)
$$
**如果还不理解,可以将上述四个状态转移方程「两两成对」结合来看。**
代码:
```java []
class Solution {
int INF = 0x3f3f3f3f;
public int coinChange(int[] cs, int cnt) {
int n = cs.length;
int[] f = new int[cnt + 1];
for (int i = 1; i <= cnt; i++) f[i] = INF;
for (int i = 1; i <= n; i++) {
int val = cs[i - 1];
for (int j = val; j <= cnt; j++) {
f[j] = Math.min(f[j], f[j - val] + 1);
}
}
return f[cnt] == INF ? -1 : f[cnt];
}
}
```
* 时间复杂度:共有 $n * cnt$ 个状态需要转移,整体复杂度为 $O(n * cnt)$。
* 空间复杂度:$O(cnt)$。
***
### 总结
本节,我们先是从朴素「完全背包」的角度分析并解决了问题。
而在考虑「一维优化」的时候,由于已经有前两节「数学推导优化思路」的基础,我们这次站在了「更高」的角度去看待一维优化。
**从抽象「成本」&「价值」,结合「换元法」的角度去理解一维优化过程。**
这可以大大节省我们分析推导的时间。
建议大家加强理解 ~
下一节练习篇,我们会继续强化这个过程 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.322` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/324. 摆动排序 II（中等）.md | 324. 摆动排序 II | https://leetcode.cn/problems/wiggle-sort-ii/solution/by-ac_oier-22bq/ | 中等 | [
"构造",
"排序",
"快速选择"
] | 给你一个整数数组 `nums`,将它重新排列成 `nums[0] < nums[1] > nums[2] < nums[3]...` 的顺序。
你可以假设所有输入数组都可以得到满足题目要求的结果。
示例 1:
```
输入:nums = [1,5,1,1,6,4]
输出:[1,6,1,5,1,4]
解释:[1,4,1,5,1,6] 同样是符合题目要求的结果,可以被判题程序接受。
```
示例 2:
```
输入:nums = [1,3,2,2,3,1]
输出:[2,3,1,3,1,2]
```
提示:
* $1 <= nums.length <= 5 \times 10^4$
* $0 <= nums[i] <= 5000$
* 题目数据保证,对于给定的输入 `nums`,总能产生满足题目要求的结果
进阶:你能用 $O(n)$ 时间复杂度和 / 或原地 $O(1)$ 额外空间来实现吗? | ### 构造(快选 + 三数排序)
这道题即使不考虑空间 $O(1)$ 的进阶要求,只要求做到 $O(n)$ 时间的话,在 LC 上也属于难题了。如果大家是第一次做,并且希望在有限时间(不超过 $20$ 分钟)内做出来,可以说是难上加难。
本质上,题目要我们实现一种构造方法,能够将 `nums` 调整为满足「摆动」要求。
具体的构造方法:
1. 找到 `nums` 的中位数,这一步可以通过「快速选择」算法来做,时间复杂度为 $O(n)$,空间复杂度为 $O(\log{n})$,假设找到的中位数为 `x`;
2. 根据 $nums[i]$ 与 `x` 的大小关系,将 $nums[i]$ 分为三类(小于/等于/大于),划分三类的操作可以采用「三数排序」的做法,复杂度为 $O(n)$。
这一步做完之后,我们的数组调整为:$[a_1, a_2, a_3, ... , b_1, b_2, b_3, ... , c_1, c_2, c_3]$ ,即分成「小于 `x` / 等于 `x` / 大于 `x`」三段。
3. 构造:先放「奇数」下标,再放「偶数」下标,放置方向都是「从左到右」(即可下标从小到大进行放置),放置的值是则是「从大到小」。
到这一步之前,我们使用到的空间上界是 $O(\log{n})$,如果对空间上界没有要求的话,我们可以简单对 `nums` 进行拷贝,然后按照对应逻辑进行放置即可,但这样最终的空间复杂度为 $O(n)$(代码见 $P2$);如果不希望影响到原有的空间上界,我们需要额外通过「找规律/数学」的方式,找到原下标和目标下标的映射关系(函数 `getIdx` 中)。
容易证明该构造过程的正确性(即该构造过程必然能顺利进行):由于我们是按照值「从大到小」进行放置,如果构造出来的方案不合法,必然是相邻的两个值为相等(“应当递增实际递减”或者“应当递减实际递增”的情况已被「从大到小」进行放置所否决),而当相邻位置放置了相同的值,即存在某个奇数下标,以及其相邻的偶数下标都放置了相同的值,这等价于该值出现次数超过总个数的一半,这与「题目本身保证数据能够构造出摆动数组」所冲突。
代码:
```Java
class Solution {
int[] nums;
int n;
int qselect(int l, int r, int k) {
if (l == r) return nums[l];
int x = nums[l + r >> 1], i = l - 1, j = r + 1;
while (i < j) {
do i++; while (nums[i] < x);
do j--; while (nums[j] > x);
if (i < j) swap(i, j);
}
int cnt = j - l + 1;
if (k <= cnt) return qselect(l, j, k);
else return qselect(j + 1, r, k - cnt);
}
void swap(int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
int getIdx(int x) {
return (2 * x + 1) % (n | 1);
}
public void wiggleSort(int[] _nums) {
nums = _nums;
n = nums.length;
int x = qselect(0, n - 1, n + 1 >> 1);
int l = 0, r = n - 1, loc = 0;
while (loc <= r) {
if (nums[getIdx(loc)] > x) swap(getIdx(loc++), getIdx(l++));
else if (nums[getIdx(loc)] < x) swap(getIdx(loc), getIdx(r--));
else loc++;
}
}
}
```
-
```Java
class Solution {
int[] nums;
int n;
int qselect(int l, int r, int k) {
if (l == r) return nums[l];
int x = nums[l + r >> 1], i = l - 1, j = r + 1;
while (i < j) {
do i++; while (nums[i] < x);
do j--; while (nums[j] > x);
if (i < j) swap(i, j);
}
int cnt = j - l + 1;
if (k <= cnt) return qselect(l, j, k);
else return qselect(j + 1, r, k - cnt);
}
void swap(int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
public void wiggleSort(int[] _nums) {
nums = _nums;
n = nums.length;
int x = qselect(0, n - 1, n + 1 >> 1);
int l = 0, r = n - 1, loc = 0;
while (loc <= r) {
if (nums[loc] < x) swap(loc++, l++);
else if (nums[loc] > x) swap(loc, r--);
else loc++;
}
int[] clone = nums.clone();
int idx = 1; loc = n - 1;
while (idx < n) {
nums[idx] = clone[loc--];
idx += 2;
}
idx = 0;
while (idx < n) {
nums[idx] = clone[loc--];
idx += 2;
}
}
}
```
* 时间复杂度:快选的时间复杂度为 $O(n)$;三数排序复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:我的习惯是不算递归带来的额外空间消耗的,但如果是题目指定 $O(1)$ 空间的话,显然是不能按照习惯来,快选的空间复杂度为 $O(\log{n})$。整体复杂度为 $O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.324` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/326. 3的幂（简单）.md | 326. 3的幂 | https://leetcode-cn.com/problems/power-of-three/solution/gong-shui-san-xie-yi-ti-san-jie-shu-xue-8oiip/ | 简单 | [
"数学",
"打表"
] | 给定一个整数,写一个函数来判断它是否是 $3$ 的幂次方。如果是,返回 $true$ ;否则,返回 $false$ 。
整数 $n$ 是 $3$ 的幂次方需满足:存在整数 $x$ 使得 $n == 3^x$
示例 1:
```
输入:n = 27
输出:true
```
示例 2:
```
输入:n = 0
输出:false
```
示例 3:
```
输入:n = 9
输出:true
```
示例 4:
```
输入:n = 45
输出:false
```
提示:
* -$2^{31}$ <= n <= $2^{31}$ - 1 | ### 数学
一个不能再朴素的做法是将 $n$ 对 $3$ 进行试除,直到 $n$ 不再与 $3$ 呈倍数关系,最后判断 $n$ 是否为 $3^0 = 1$ 即可。
代码:
```Java
class Solution {
public boolean isPowerOfThree(int n) {
if (n <= 0) return false;
while (n % 3 == 0) n /= 3;
return n == 1;
}
}
```
* 时间复杂度:$O(\log_{3}n)$
* 空间复杂度:$O(1)$
---
### 倍数 & 约数
题目要求不能使用循环或递归来做,而传参 $n$ 的数据类型为 `int`,这引导我们首先分析出 `int` 范围内的最大 $3$ 次幂是多少,约为 $3^{19} = 1162261467$。
如果 $n$ 为 $3$ 的幂的话,那么必然满足 $n * 3^k = 1162261467$,即 $n$ 与 $1162261467$ 存在倍数关系。
因此,我们只需要判断 $n$ 是否为 $1162261467$ 的约数即可。
> 注意:这并不是快速判断 $x$ 的幂的通用做法,当且仅当 $x$ 为质数可用。
代码:
```Java
class Solution {
public boolean isPowerOfThree(int n) {
return n > 0 && 1162261467 % n == 0;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
---
### 打表
另外一个更容易想到的「不使用循环/递归」的做法是进行打表预处理。
使用 `static` 代码块,预处理出不超过 `int` 数据范围的所有 $3$ 的幂,这样我们在跑测试样例时,就不需要使用「循环/递归」来实现逻辑,可直接 $O(1)$ 查表返回。
代码:
```Java
class Solution {
static Set<Integer> set = new HashSet<>();
static {
int cur = 1;
set.add(cur);
while (cur <= Integer.MAX_VALUE / 3) {
cur *= 3;
set.add(cur);
}
}
public boolean isPowerOfThree(int n) {
return n > 0 && set.contains(n);
}
}
```
* 时间复杂度:将打表逻辑交给 $OJ$ 执行的话,复杂度为 $O(\log_3{C})$,$C$ 固定为 $2147483647$;将打表逻辑放到本地执行,复杂度为 $O(1)$
* 空间复杂度:$O(\log_3{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.326` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/321-330/327. 区间和的个数（困难）.md | 327. 区间和的个数 | https://leetcode.cn/problems/count-of-range-sum/solution/by-ac_oier-b36o/ | 困难 | [
"前缀和",
"离散化",
"树状数组",
"线段树(动态开点)"
] | 给你一个整数数组 `nums` 以及两个整数 `lower` 和 `upper` 。求数组中,值位于范围 $[lower, upper]$ (包含 `lower` 和 `upper`)之内的 区间和的个数 。
区间和 $S(i, j)$ 表示在 `nums` 中,位置从 $i$ 到 $j$ 的元素之和,包含 $i$ 和 $j$ (`i ≤ j`)。
示例 1:
```
输入:nums = [-2,5,-1], lower = -2, upper = 2
输出:3
解释:存在三个区间:[0,0]、[2,2] 和 [0,2] ,对应的区间和分别是:-2 、-1 、2 。
```
示例 2:
```
输入:nums = [0], lower = 0, upper = 0
输出:1
```
提示:
* $1 <= nums.length <= 10^5$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* $-10^5 <= lower <= upper <= 10^5$
* 题目数据保证答案是一个 $32$ 位 的整数 | ### 树状数组(离散化)
由于区间和的定义是子数组的元素和,容易想到「前缀和」来快速求解。
对于每个 $nums[i]$ 而言,我们需要统计以每个 $nums[i]$ 为右端点的合法子数组个数(合法子数组是指区间和值范围为 $[lower, upper]$ 的子数组)。
我们可以从前往后处理 $nums$,假设当前我们处理到位置 $k$,同时下标 $[0, k]$ 的前缀和为 $s$,那么以 $nums[k]$ 为右端点的合法子数组个数,等价于在下标 $[0, k - 1]$ 中前缀和范围在 $[s - upper, s - lower]$ 的数的个数。
我们需要使用一个数据结构来维护「遍历过程中的前缀和」,每遍历 $nums[i]$ 需要往数据结构加一个数,同时每次需要查询值在某个范围内的数的个数。涉及的操作包括「单点修改」和「区间查询」,容易想到使用树状数组进行求解。
但值域的范围是巨大的(同时还有负数域),我们可以利用 $nums$ 的长度为 $10^5$ 来做离散化。我们需要考虑用到的数组都有哪些:
1. 首先前缀和数组中的每一位 $s$ 都需要被用到(添加到树状数组中);
2. 同时对于每一位 $nums[i]$(假设对应的前缀和为 $s$),我们都需要查询以其为右端点的合法子数组个数,即查询前缀和范围在 $[s - upper, s - lower]$ 的数的个数。
因此对于前缀和数组中的每一位 $s$,我们用到的数有 $s$、$s - upper$ 和 $s - lower$ 三个数字,共有 $1e5$ 个 $s$,即最多共有 $3 \times 10^5$ 个不同数字被使用,我们可以对所有用到的数组进行排序编号(离散化),从而将值域大小控制在 $3 \times 10^5$ 范围内。
代码:
```Java
class Solution {
int m;
int[] tr = new int[100010 * 3];
int lowbit(int x) {
return x & -x;
}
void add(int x, int v) {
for (int i = x; i <= m; i += lowbit(i)) tr[i] += v;
}
int query(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
}
public int countRangeSum(int[] nums, int lower, int upper) {
Set<Long> set = new HashSet<>();
long s = 0;
set.add(s);
for (int i : nums) {
s += i;
set.add(s);
set.add(s - lower);
set.add(s - upper);
}
List<Long> list = new ArrayList<>(set);
Collections.sort(list);
Map<Long, Integer> map = new HashMap<>();
for (long x : list) map.put(x, ++m);
s = 0;
int ans = 0;
add(map.get(s), 1);
for (int i : nums) {
s += i;
int a = map.get(s - lower), b = map.get(s - upper) - 1;
ans += query(a) - query(b);
add(map.get(s), 1);
}
return ans;
}
}
```
* 时间复杂度:去重离散化的复杂度为 $O(n\log{n})$;统计答案的复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 线段树(动态开点 + STL)
值域范围爆炸,但是数组长度(查询次数)有限,容易想到「线段树(动态开点)」。
但如果按照我们 [729. 我的日程安排表 I](https://sharingsource.github.io/2022/05/04/729.%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20I%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/)、[731. 我的日程安排表 II](https://sharingsource.github.io/2022/05/04/731.%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 和 [732. 我的日程安排表 III](https://sharingsource.github.io/2022/05/04/732.%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20III%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/) 系列题解的求解方式「估点 + 静态数组 + 动态 `new`」,仍无法解决 `MLE` 问题。
究其原因,我们在 [日程安排表] 系列中使用到的方式存在「固定双边开点(一旦要对 $u$ 的子节点开点,会同时将左右子节点都开出来)」以及「查询时也会触发开点」的问题,导致我们最多处理值域范围在 $1e9$ 的情况。
对于本题的值域范围远超 $1e9$,我们需要考虑修「静态数组」和「开点方式」来解决 `MLE` 问题:
1. 由于值域太大,采用估点方式来开精挑数组会直接导致 `MLE`,我们使用支持扩容的 `STL` 容器;
2. 由于同时开点和查询也会触发开点,会导致我们不必要的空间浪费,我们直接将开点操作放在 `update` 实现中,并且只有当需要查询到左子节点才对左子节点进行开点,当查询到右子节点才对右子节点进行开点。
代码:
```Java
class Solution {
class Node {
int ls = -1, rs = -1, val = 0;
}
List<Node> tr = new ArrayList<>();
void update(int u, long lc, long rc, long x, int v) {
Node node = tr.get(u);
node.val += v;
if (lc == rc) return ;
long mid = lc + rc >> 1;
if (x <= mid) {
if (node.ls == -1) {
tr.add(new Node());
node.ls = tr.size() - 1;
}
update(node.ls, lc, mid, x, v);
} else {
if (node.rs == -1) {
tr.add(new Node());
node.rs = tr.size() - 1;
}
update(node.rs, mid + 1, rc, x, v);
}
}
int query(int u, long lc, long rc, long l, long r) {
if (u == -1) return 0;
if (r < lc || l > rc) return 0;
Node node = tr.get(u);
if (l <= lc && rc <= r) return node.val;
long mid = lc + rc >> 1;
return query(node.ls, lc, mid, l, r) + query(node.rs, mid + 1, rc, l, r);
}
public int countRangeSum(int[] nums, int lower, int upper) {
long L = 0, R = 0, s = 0;
for (int i : nums) {
s += i;
L = Math.min(Math.min(L, s), Math.min(s - lower, s - upper));
R = Math.max(Math.max(R, s), Math.max(s - lower, s - upper));
}
s = 0;
int ans = 0;
tr.add(new Node());
update(0, L, R, 0, 1);
for (int i : nums) {
s += i;
long a = s - upper, b = s - lower;
ans += query(0, L, R, a, b);
update(0, L, R, s, 1);
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为数组长度,$m$ 为值域大小,复杂度为 $O(n\log{m})$
* 空间复杂度:$O(n\log{m})$
---
### 线段树(动态指针)
更进一步,我们可以连 `STL` 都不使用,直接在 `Node` 的定义时,将左右子节点的引用存放起来。
虽然这样不会带来空间上的优化,但可以有效避免 `STL` 的创建、访问和扩容(实际运行相比解法二,用时少一半)。
代码:
```Java
class Solution {
class Node {
Node ls, rs;
int val = 0;
}
void update(Node node, long lc, long rc, long x, int v) {
node.val += v;
if (lc == rc) return ;
long mid = lc + rc >> 1;
if (x <= mid) {
if (node.ls == null) node.ls = new Node();
update(node.ls, lc, mid, x, v);
} else {
if (node.rs == null) node.rs = new Node();
update(node.rs, mid + 1, rc, x, v);
}
}
int query(Node node, long lc, long rc, long l, long r) {
if (node == null) return 0;
if (r < lc || l > rc) return 0;
if (l <= lc && rc <= r) return node.val;
long mid = lc + rc >> 1;
return query(node.ls, lc, mid, l, r) + query(node.rs, mid + 1, rc, l, r);
}
public int countRangeSum(int[] nums, int lower, int upper) {
long L = 0, R = 0, s = 0;
for (int i : nums) {
s += i;
L = Math.min(Math.min(L, s), Math.min(s - lower, s - upper));
R = Math.max(Math.max(R, s), Math.max(s - lower, s - upper));
}
s = 0;
int ans = 0;
Node root = new Node();
update(root, L, R, 0, 1);
for (int i : nums) {
s += i;
long a = s - upper, b = s - lower;
ans += query(root, L, R, a, b);
update(root, L, R, s, 1);
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为数组长度,$m$ 为值域大小,复杂度为 $O(n\log{m})$
* 空间复杂度:$O(n\log{m})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.327` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/331. 验证二叉树的前序序列化（中等）.md | 331. 验证二叉树的前序序列化 | https://leetcode-cn.com/problems/verify-preorder-serialization-of-a-binary-tree/solution/xiang-xin-ke-xue-xi-lie-xiang-jie-zhi-gu-e3y9/ | 中等 | [
"二叉树"
] | 序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时,我们可以记录下这个节点的值。如果它是一个空节点,我们可以使用一个标记值记录,例如 #。
```
_9_
/ \
3 2
/ \ / \
4 1 # 6
/ \ / \ / \
# # # # # #
```
例如,上面的二叉树可以被序列化为字符串 "9,3,4,#,#,1,#,#,2,#,6,#,#",其中 # 代表一个空节点。
给定一串以逗号分隔的序列,验证它是否是正确的二叉树的前序序列化。编写一个在不重构树的条件下的可行算法。
每个以逗号分隔的字符或为一个整数或为一个表示 null 指针的 '#' 。
你可以认为输入格式总是有效的,例如它永远不会包含两个连续的逗号,比如 "1,,3" 。
示例 1:
```
输入: "9,3,4,#,#,1,#,#,2,#,6,#,#"
输出: true
```
示例 2:
```
输入: "1,#"
输出: false
```
示例 3:
```
输入: "9,#,#,1"
输出: false
``` | ### 二叉树规律解法
事实上,我们能利用「二叉树」的特性来做。
由于**每一个非空节点都对应了 2 个出度,空节点都对应了 0 个出度;除了根节点,每个节点都有一个入度。**
我们可以使用 `in` 和 `out` 来分别记录「入度」和「出度」的数量;`m` 和 `n` 分别代表「非空节点数量」和「空节点数量」。
同时,一颗合格的二叉树最终结果必然满足 `in == out`。
**但我们又不能只利用最终 `in == out` 来判断是否合法,这很容易可以举出反例:考虑将一个合法序列的空节点全部提前,这样最终结果仍然满足 `in == out`,但这样的二叉树是不存在的。**
**我们还需要一些额外的特性,支持我们在遍历过程中提前知道一颗二叉树不合法。**
**例如,我们可以从合格二叉树的前提出发,挖掘遍历过程中 `in` 和 `out` 与 `n` 和 `m` 的关系。**
***
### 证明 1(利用不等式)
我们令非空节点数量为 $m$,空节点数量为 $n$,入度和出度仍然使用 $in$ 和 $out$ 代表。
找一下 $in$ 和 $out$ 与 $n$ 和 $m$ 之间的关系。
一颗合格二叉树 $m$ 和 $n$ 的最小的比例关系是 $1 : 2$,也就是对应了这么一个形状:
```
4
/ \
# #
```
而遍历过程中 $m$ 和 $n$ 的最小的比例关系则是 $1 : 0$,**这其实对应了二叉树空节点总是跟在非空节点的后面这一性质。**
换句话说,在没到最后一个节点之前,我们是不会遇到 空节点数量 > 非空节点数量 的情况的。
**`非空节点数量 >= 空节点数量` 在遍历没结束前恒成立:$m>=n$**
然后再结合「**每一个非空节点都对应了 $2$ 个出度,空节点都对应了 $0$ 个出度;除了根节点,每个节点都有一个入度**」特性。
在遍历尚未结束前,我们有以下关系:
1. $m >= n$
2. $in <= m + n - 1$
3. $out <= 2 * m$
简单的变形可得:
* 由 $2$ 变形可得:$m >= in + 1 - n$
* 由 $3$ 变形可得:$m >= out / 2$
即有:
1. $m >= n$
2. $m >= in + 1 - n$
3. $m >= out / 2$
再将 $1$ 和 $2$ 相加,抵消 $n$:$2m >= in + 1$
1. $2m >= in + 1$ => $in <= 2m - 1$
2. $m >= out / 2$ => $out <= 2m$
因此,在遍历尚未完成时,$in$ 和 $out$ 始终满足上述关系(与空节点数量 $n$ 无关)。
如果不从合格二叉树的前提($m>=n$)出发,我们是无法得到上述关系式的。
**因此,我们可以一边遍历一边统计「严格出度」和「严格入度」,然后写一个 `check` 函数去判定 $in$、$out$ 和 $m$ 三者关系是否符合要求,如果不符合则说明二叉树不合法。**
代码:
```Java
class Solution {
public boolean isValidSerialization(String s) {
String[] ss = s.split(",");
int n = ss.length;
int in = 0, out = 0;
for (int i = 0, m = 0; i < n; i++) {
// 统计「严格出度」和「严格入度」...
if (i != n - 1 && !check(m, in, out)) return false;
}
return in == out;
}
boolean check(int m, int in, int out) {
boolean a = (in <= 2 * m - 1), b = (out <= 2 * m);
return a && b;
}
}
```
**注意:因为我们这里的证明使用到的是不等式。因此统计的必须是「严格出度」&「严格入度」,不能假定一个「非空节点(非根)」必然对应两个「出度」和一个「入度」。**
**要想统计出「严格出度」&「严格入度」在编码上还是有一定难度的。那么是否可以推导出更加简单性质来使用呢?**
**请看「证明 2」。**
***
### 证明 2(利用技巧转换为等式)
我们令非空节点数量为 $m$,空节点数量为 $n$,入度和出度仍然使用 $in$ 和 $out$ 代表。
找一下 $in$ 和 $out$ 与 $n$ 和 $m$ 之间的关系。
一颗合格二叉树 $m$ 和 $n$ 的最小的比例关系是 $1 : 2$,也就是对应了这么一个形状:
```
4
/ \
# #
```
而遍历过程中 $m$ 和 $n$ 的最小的比例关系则是 $1 : 0$,这**其实对应了二叉树空节点总是跟在非空节点的后面这一性质。**
换句话说,在没到最后一个节点之前,我们是不会遇到 `空节点数量 > 非空节点数量` 的情况的。
**`非空节点数量 >= 空节点数量` 在遍历没结束前恒成立:$m>=n$**
之后我们再采用一个技巧,就是**遍历过程中每遇到一个「非空节点」就增加两个「出度」和一个「入度」,每遇到一个「空节点」只增加一个「入度」。而不管每个「非空节点」是否真实对应两个子节点。**
那么我们的起始条件变成:
1. $m >= n$
2. $in = m + n - 1$
3. $out = 2 * m$
从第 $2$ 个等式出发,结合第 $1$ 个等式:
$in = m + n - 1 <= m + m - 1 = 2m - 1 = out - 1$
即可得 $in + 1 <= out$ ,也就是 $in < out$ 恒成立。
代码:
```Java
class Solution {
public boolean isValidSerialization(String s) {
String[] ss = s.split(",");
int n = ss.length;
int in = 0, out = 0;
for (int i = 0; i < n; i++) {
if (!ss[i].equals("#")) out += 2;
if (i != 0) in++;
if (i != n - 1 && out <= in) return false;
}
return in == out;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.331` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/334. 递增的三元子序列（中等）.md | 334. 递增的三元子序列 | https://leetcode-cn.com/problems/increasing-triplet-subsequence/solution/gong-shui-san-xie-zui-chang-shang-sheng-xa08h/ | 中等 | [
"LIS",
"最长上升子序列",
"贪心",
"二分"
] | 给你一个整数数组 `nums`,判断这个数组中是否存在长度为 $3$ 的递增子序列。
如果存在这样的三元组下标 `(i, j, k)` 且满足 `i < j < k` ,使得 `nums[i] < nums[j] < nums[k]` ,返回 `true` ;否则,返回 `false`。
示例 1:
```
输入:nums = [1,2,3,4,5]
输出:true
解释:任何 i < j < k 的三元组都满足题意
```
示例 2:
```
输入:nums = [5,4,3,2,1]
输出:false
解释:不存在满足题意的三元组
```
示例 3:
```
输入:nums = [2,1,5,0,4,6]
输出:true
解释:三元组 (3, 4, 5) 满足题意,因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6
```
提示:
* $1 <= nums.length <= 5 * 10^5$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
进阶:你能实现时间复杂度为 $O(n$) ,空间复杂度为 $O(1)$ 的解决方案吗? | ### 最长上升子序列(贪心 + 二分)
题目要我们判断是否存在长度为 $3$ 的上升子序列,问题可以转换为求 $nums$ 的最长上升子序列(`LIS` 问题)的长度。
如果 $nums$ 的最长上升子序列长度大于等于 $3$,那么原问题答案为 `True`,否则为 `False`。
而求最长上升子序列的最优解是有基于「贪心 + 二分」的 $O(n\log{n})$ 做法,对此不了解的同学,可以先看前置 🧀 :[LCS 问题与 LIS 问题的相互关系,以及 LIS 问题的最优解证明](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892&chksm=fd9cba59caeb334f1fbfa1aefd3d9b2ab6abfccfcab8cb1dbff93191ae9b787e1b4681bbbde3&token=252055586&lang=zh_CN#rd),里面详细讲解了 `LIS` 的贪心解证明,以及与最长公共子序列(`LCS` 问题)的相互关系,本次不再赘述。
**简单来说,就是在遍历每个数 $nums[i]$ 的同时,维护一个具有单调性的 $f[]$ 数组,其中 $f[len] = x$ 代表长度为 $len$ 的最长上升子序列最小结尾元素为 $x$,可以证明 $f$ 数组具有单调性(看 [前置🧀](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892&chksm=fd9cba59caeb334f1fbfa1aefd3d9b2ab6abfccfcab8cb1dbff93191ae9b787e1b4681bbbde3&token=252055586&lang=zh_CN#rd)),因此每次可以通过二分找到小于 $nums[i]$ 的最大下标,来作为 $nums[i]$ 的前一个数。**
综上,我们使用 `LIS` 的「贪心 + 二分」做法求得最长上升子序列的最大长度,然后和 $3$ 比较即可得出答案。
**代码(感谢 [@🍭可乐可乐吗QAQ](/u/littletime_cc/) 同学提供的其他语言版本):**
```Java
class Solution {
public boolean increasingTriplet(int[] nums) {
int n = nums.length, ans = 1;
int[] f = new int[n + 1];
Arrays.fill(f, 0x3f3f3f3f);
for (int i = 0; i < n; i++) {
int t = nums[i];
int l = 1, r = i + 1;
while (l < r) {
int mid = l + r >> 1;
if (f[mid] >= t) r = mid;
else l = mid + 1;
}
f[r] = t;
ans = Math.max(ans, r);
}
return ans >= 3;
}
}
```
-
```C++
class Solution {
public:
bool increasingTriplet(vector<int>& nums) {
int n = nums.size(), ans = 1;
vector<int> f(n + 1, INT_MAX);
for(int i = 0; i < n; i++){
int t = nums[i];
int L = 1, R = i + 1;
while(L < R){
int mid = L + R >> 1;
if(f[mid] >= t) R = mid;
else L = mid + 1;
}
f[R] = t;
ans = max(ans, R);
}
return ans >= 3;
}
};
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 优化 : 定长上升子序列(贪心)
利用本题只需要我们判定是否存在长度为 $3$ 的上升子序列,而不需要回答 `LIS` 最大长度。
我们可以对 $f$ 数组进行优化:**使用有限变量进行替换(将 $f$ 数组的长度压缩为 $2$),数组含义不变,$f[1] = x$ 代表长度为 $1$ 的上升子序列最小结尾元素为 $x$,$f[2] = y$ 代表长度为 $2$ 的上升子序列的最小结尾元素为 $y$。**
**从前往后扫描每个 $nums[i]$,每次将 $nums[i]$ 分别与 $f[1]$ 和 $f[2]$ 进行比较,如果能够满足 $nums[i] > f[2]$,代表 $nums[i]$ 能够接在长度为 $2$ 的上升子序列的后面,直接返回 `True`,否则尝试使用 $nums[i]$ 来更新 $f[1]$ 和 $f[2]。$**
这样,我们只使用了有限变量,每次处理 $nums[i]$ 只需要和有限变量进行比较,时间复杂度为 $O(n)$,空间复杂度为 $O(1)$。
**代码(感谢 [@🍭可乐可乐吗QAQ](/u/littletime_cc/) 和 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**
```Java
class Solution {
public boolean increasingTriplet(int[] nums) {
int n = nums.length;
long[] f = new long[3];
f[1] = f[2] = (int)1e19;
for (int i = 0; i < n; i++) {
int t = nums[i];
if (f[2] < t) return true;
else if (f[1] < t && t < f[2]) f[2] = t;
else if (f[1] > t) f[1] = t;
}
return false;
}
}
```
-
```Python
class Solution:
def increasingTriplet(self, nums: List[int]) -> bool:
n = len(nums)
f = [inf] * 3
for i in range(n):
t = nums[i]
if f[2] < t:
return True
elif f[1] < t < f[2]:
f[2] = t
elif f[1] > t:
f[1] = t
return False
```
-
```Go
func increasingTriplet(nums []int) bool {
n := len(nums)
f := []int{math.MaxInt32,math.MaxInt32,math.MaxInt32}
for i := 0; i < n; i++ {
t := nums[i]
if f[2] < t{
return true
} else if f[1] < t && t < f[2]{
f[2] = t
} else if f[1] > t {
f[1] = t
}
}
return false
}
```
-
```C++
class Solution {
public:
bool increasingTriplet(vector<int>& nums) {
int n = nums.size();
vector<int> f(3, INT_MAX);
for(int i = 0; i < n; i++){
int t = nums[i];
if(f[2] < t) return true;
else if(f[1] < t and t < f[2]) f[2] = t;
else if(f[1] > t) f[1] = t;
}
return false;
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.334` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/335. 路径交叉（困难）.md | 335. 路径交叉 | https://leetcode-cn.com/problems/self-crossing/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-zdrb/ | 困难 | [
"找规律",
"脑筋急转弯",
"模拟"
] | 给你一个整数数组 `distance` 。
从 `X-Y` 平面上的点 $(0,0)$ 开始,先向北移动 `distance[0]` 米,然后向西移动 `distance[1]` 米,向南移动 `distance[2]` 米,向东移动 `distance[3]` 米,持续移动。也就是说,每次移动后你的方位会发生逆时针变化。
判断你所经过的路径是否相交。如果相交,返回 `true` ;否则,返回 `false`。
示例 1:
```
输入:distance = [2,1,1,2]
输出:true
```
示例 2:
```
输入:distance = [1,2,3,4]
输出:false
```
示例 3:
```
输入:distance = [1,1,1,1]
输出:true
```
提示:
* $1 <= distance.length <= 10^5$
* $1 <= distance[i] <= 10^5$ | ### 找规律 + 分情况讨论
这是一道画图找规律的题目。
**首先显然的是,至少需要 $4$ 条边才 可能 存在相交路径,如果 $distance$ 的长度小于 $4$,可直接返回 `False`,同时这引导我们如果某条边 $distance[i]$ 发生相交,不可能是与 $distance[i - 1]$ 或 $distance[i - 2]$ 之间发生的(基于条件 $1 <= distance[i] <= 10^5$)。**
为了方便,我们分别使用 $a$、$b$、$c$ 和 $d$ 来分别代指「往上」、「往左」、「往下」和「往右」的四类方向边。
然后对可能相交情况进行分情况讨论,假设当前枚举到的边为 $distance[i]$(下面使用 $d[i]$ 代指 $distance[i]$):
1. $d[i]$ 与 $d[i - 3]$ 发生相交:此时满足 $d[i] >= d[i - 2]$,同时 $d[i - 1] <= d[i - 3]$;
> **需要注意的时候 $d[i]$ 不一定是 $d$ 类边,而可以是 $abcd$ 任意类的边,此时只是矩形发生旋转,并不会影响路径相交的事实,其余分情况讨论也是同理。**
2. $d[i]$ 与 $d[i - 4]$ 发生相交:此时满足 $d[i - 1] = d[i - 3]$,同时 $d[i] + d[i - 4] >= d[i - 2]$;
3. $d[i]$ 与 $d[i - 5]$ 发生相交:此时满足$d[i - 1] <= d[i - 3]$,同时 $d[i - 2] > d[i - 4]$,同时 $d[i] + d[i - 4] >= d[i - 2]$,同时 $d[i - 1] + d[i - 5] >= d[i - 3]$。
**综上,$d[i]$ 不会与 $d[i - 1]$ 和 $d[i - 2]$ 发生相交,而 $d[i]$ 与 $d[i - 3]$、$d[i - 4]$ 和 $d[i - 5]$ 的相交条件如上述讨论。并且 $d[i]$ 不会与 $d[i - x]$ $(x > 5)$ 发生相交的同时,不与 $d[i - y]$ $(3 <= y <= 5)$ 发生相交。即 $d[i]$ 与 $d[i - x]$ $(x > 5)$ 发生相交前,必然与 $d[i - y]$ $(3 <= y <= 5)$ 发生相交。**
代码:
```Java
class Solution {
public boolean isSelfCrossing(int[] d) {
int n = d.length;
if (n < 4) return false;
for (int i = 3; i < n; i++) {
if (d[i] >= d[i - 2] && d[i - 1] <= d[i - 3]) return true;
if (i >= 4 && d[i - 1] == d[i - 3] && d[i] + d[i - 4] >= d[i - 2]) return true;
if (i >= 5 && d[i - 1] <= d[i - 3] && d[i - 2] > d[i - 4] && d[i] + d[i - 4] >= d[i - 2] && d[i - 1] + d[i - 5] >= d[i - 3]) return true;
}
return false;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.335` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/331-340/338. 比特位计数（简单）.md | 338. 比特位计数 | https://leetcode-cn.com/problems/counting-bits/solution/po-su-jie-fa-dong-tai-gui-hua-jie-fa-by-vvail/ | 简单 | [
"位运算",
"数学",
"线性 DP"
] | 给定一个非负整数 `num`。对于 `0 ≤ i ≤ num` 范围中的每个数字 `i`,计算其二进制数中的 $1$ 的数目并将它们作为数组返回。
示例 1:
```
输入: 2
输出: [0,1,1]
```
示例 2:
```
输入: 5
输出: [0,1,1,2,1,2]
```
进阶:
* 给出时间复杂度为 $O(n \times sizeof(integer))$ 的解答非常容易。但你可以在线性时间 $O(n)$ 内用一趟扫描做到吗?
* 要求算法的空间复杂度为 $O(n)$ 。
* 你能进一步完善解法吗?要求在 `C++` 或任何其他语言中不使用任何内置函数(如 `C++` 中的 `__builtin_popcount`)来执行此操作。 | ### 模拟
这道题要对每个数进行统计,因此不会有比 $O(n)$ 更低的做法。
而很容易想到的朴素做法是对每个数进行「位运算」计数,每个数都是 $32$ 位的,因此是一个 $O(32n)$ 的做法。
代码:
```Java
class Solution {
public int[] countBits(int n) {
int[] ans = new int[n + 1];
for (int i = 0; i <= n; i++) ans[i] = getCnt(i);
return ans;
}
int getCnt(int u) {
int ans = 0;
for (int i = 0; i < 32; i++) ans += (u >> i) & 1;
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$
---
### 动态规划
事实上,这道题是有严格 $O(n)$ 的解法的,要求 $O(n)$ 复杂度又是输出方案的题,通常就是递推的 DP 题。
用已算出的值去凑出要算的值。
那么对于这类问题我们该如何考虑呢?一般是靠经验,如果实在没见过这类题型的话,我们就需要在纸上画一下,分析一下我们**朴素做法的最后一步**是怎么进行的。
不失一般性的,假设当前我要统计的数的 `i`,`i` 对应的二进制表示是 `00000...0010100101`(共 32 位)
如果我们是使用「朴素解法」求解的话,无论是从高位进行统计,还是从低位进行统计,最后一位扫描的都是边缘的数(如果是 1 就计数,不是 1 就不计数)。
* **从低位到高位**,最后一步在扫描**最高位**之前,**统计出 1 的个数应该等同于将 `i` 左移一位,并在最低位补 0,也就是等于 `ans[i << 1]`,这时候就要求我们在计算 `i` 的时候 `i << 1` 已经被算出来(从大到小遍历)**
* **从高位到低位**,最后一步在扫描**最低位**之前,**统计出 1 的个数应该等同于将 `i` 右移一位,并在最高位补 0,也就是等于 `ans[i >> 1]`,这时候就要求我们在计算 `i` 的时候 `i >> 1` 已经被算出来(从小到大遍历)**
通过**对「朴素做法」的最后一步分析**,转移方程就出来了:
* 当**从大到小遍历** :$f(i) = f(i << 1) + ((i >>31 ) \& 1)$
* 当**从小到大遍历** :$f(i) = f(i >> 1) + ( i \& 1 )$
代码:
```Java
class Solution {
// 从小到大遍历
public int[] countBits(int n) {
int[] ans = new int[n + 1];
// ans[i] = 「i >> 1 所包含的 1 的个数」+「i 的最低位是否为 1」
for (int i = 1; i <= n; i++) ans[i] = ans[i >> 1] + (i & 1);
return ans;
}
}
```
-
```Java
class Solution {
// 从大到小遍历
public int[] countBits(int n) {
int[] ans = new int[n + 1];
for (int i = n; i >= 0; i--) {
// 如果计算 i 所需要的 i << 1 超过 n,则不存储在 ans 内,需要额外计算
int u = i << 1 <= n ? ans[i << 1] : getCnt(i << 1);
// ans[i] =「i << 1 所包含的 1 的个数」 + 「i 的最高位是否为 1」
ans[i] = u + ((i >> 31) & 1);
}
return ans;
}
int getCnt(int u) {
int ans = 0;
for (int i = 0; i < 32; i++) ans += (u >> i) & 1;
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$
---
### 位运算说明
* `a >> b & 1` 代表检查 `a` 的第 `b` 位是否为 $1$,有两种可能性 $0$ 或者 $1$
* `a += 1 << b` 代表将 `a` 的第 `b` 位设置为 $1$ (当第 `b` 位为 $0$ 的时候适用)
如不想写对第 `b` 位为 $0$ 的前置判断,`a += 1 << b` 也可以改成 `a |= 1 << b`
在之前的题解我就强调过,以上两个操作在位运算中**使用频率超高,建议每位同学都加深理解**。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.338` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/341-350/341. 扁平化嵌套列表迭代器（中等）.md | 341. 扁平化嵌套列表迭代器 | https://leetcode-cn.com/problems/flatten-nested-list-iterator/solution/yi-ti-shuang-jie-dfsdui-lie-di-gui-zhan-kvwhy/ | 中等 | [
"DFS",
"队列",
"栈"
] | 给你一个嵌套的整型列表。请你设计一个迭代器,使其能够遍历这个整型列表中的所有整数。
列表中的每一项或者为一个整数,或者是另一个列表。其中列表的元素也可能是整数或是其他列表。
示例 1:
```
输入: [[1,1],2,[1,1]]
输出: [1,1,2,1,1]
解释: 通过重复调用 next 直到 hasNext 返回 false,next 返回的元素的顺序应该是: [1,1,2,1,1]。
```
示例 2:
```
输入: [1,[4,[6]]]
输出: [1,4,6]
解释: 通过重复调用 next 直到 hasNext 返回 false,next 返回的元素的顺序应该是: [1,4,6]。
``` | ### DFS + 队列
由于所有的元素都是在初始化时提供的,因此一个朴素的做法是在初始化的时候进行处理。
由于存在嵌套,比较简单的做法是通过 DFS 进行处理,将元素都放至队列。
代码:
```java []
public class NestedIterator implements Iterator<Integer> {
Deque<Integer> queue = new ArrayDeque<>();
public NestedIterator(List<NestedInteger> nestedList) {
dfs(nestedList);
}
@Override
public Integer next() {
return hasNext() ? queue.pollFirst() : -1;
}
@Override
public boolean hasNext() {
return !queue.isEmpty();
}
void dfs(List<NestedInteger> list) {
for (NestedInteger item : list) {
if (item.isInteger()) {
queue.addLast(item.getInteger());
} else {
dfs(item.getList());
}
}
}
}
```
* 时间复杂度:构建迭代器的复杂度为 $O(n)$,调用 $next()$ 与 $hasNext()$ 的复杂度为 $O(1)$
* 空间复杂度:$O(n)$
***
### 递归 + 栈
另外一个做法是,我们不对所有的元素进行预处理。
而是先将所有的 `NestedInteger` 逆序放到栈中,当需要展开的时候才进行展开。
代码:
```java
public class NestedIterator implements Iterator<Integer> {
Deque<NestedInteger> stack = new ArrayDeque<>();
public NestedIterator(List<NestedInteger> list) {
for (int i = list.size() - 1; i >= 0; i--) {
NestedInteger item = list.get(i);
stack.addLast(item);
}
}
@Override
public Integer next() {
return hasNext() ? stack.pollLast().getInteger() : -1;
}
@Override
public boolean hasNext() {
if (stack.isEmpty()) {
return false;
} else {
NestedInteger item = stack.peekLast();
if (item.isInteger()) {
return true;
} else {
item = stack.pollLast();
List<NestedInteger> list = item.getList();
for (int i = list.size() - 1; i >= 0; i--) {
stack.addLast(list.get(i));
}
return hasNext();
}
}
}
}
```
* 时间复杂度:构建迭代器的复杂度为 $O(n)$,$hasNext()$ 的复杂度为均摊 $O(1)$,$next()$ 严格按照迭代器的访问顺序( 先 $hasNext()$ 再 $next()$ )的话为 $O(1)$,防御性编程生效的情况下为均摊 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.341` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/341-350/342. 4的幂（简单）.md | 342. 4的幂 | https://leetcode-cn.com/problems/power-of-four/solution/gong-shui-san-xie-zhuan-hua-wei-2-de-mi-y21lq/ | 简单 | [
"数学",
"位运算"
] | 给定一个整数,写一个函数来判断它是否是 4 的幂次方。如果是,返回 true ;否则,返回 false 。
整数 n 是 4 的幂次方需满足:存在整数 x 使得 n == $4^x$
示例 1:
```
输入:n = 16
输出:true
```
示例 2:
```
输入:n = 5
输出:false
```
示例 3:
```
输入:n = 1
输出:true
```
提示:
* -$2^{31}$ <= n <= $2^{31}$ - 1
进阶:
你能不使用循环或者递归来完成本题吗? | ### 基本分析
一个数 $n$ 如果是 $4$ 的幂,等价于 $n$ 为质因数只有 $2$ 的平方数。
因此我们可以将问题其转换:判断 $\sqrt{n}$ 是否为 $2$ 的幂。
判断某个数是否为 $2$ 的幂的分析在[(题解)231. 2 的幂](https://leetcode-cn.com/problems/power-of-two/solution/gong-shui-san-xie-2-de-mi-by-ac_oier-qm6e/) 这里。
---
### sqrt + lowbit
我们可以先对 $n$ 执行 `sqrt` 函数,然后应用 `lowbit` 函数快速判断 $\sqrt{n}$ 是否为 $2$ 的幂。
代码:
```Java
class Solution {
public boolean isPowerOfFour(int n) {
if (n <= 0) return false;
int x = (int)Math.sqrt(n);
return x * x == n && (x & -x) == x;
}
}
```
```Java
class Solution {
public boolean isPowerOfFour(int n) {
if (n <= 0) return false;
int x = getVal(n);
return x * x == n && (x & -x) == x;
}
int getVal(int n) {
long l = 0, r = n;
while (l < r) {
long mid = l + r >> 1;
if (mid * mid >= n) {
r = mid;
} else {
l = mid + 1;
}
}
return (int)r;
}
}
```
* 时间复杂度:复杂度取决于内置函数 `sqrt`。一个简单的 `sqrt` 的实现接近于 P2 的代码。复杂度为 $O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/341-350/345. 反转字符串中的元音字母（简单）.md | 345. 反转字符串中的元音字母 | https://leetcode-cn.com/problems/reverse-vowels-of-a-string/solution/gong-shui-san-xie-note-bie-pian-shuang-z-c8ii/ | 简单 | [
"双指针",
"模拟"
] | 编写一个函数,以字符串作为输入,反转该字符串中的元音字母。
示例 1:
```
输入:"hello"
输出:"holle"
```
示例 2:
```
输入:"leetcode"
输出:"leotcede"
```
提示:
* 元音字母不包含字母 "y" 。 | ### 双指针
一个朴素的做法是利用「双指针」进行前后扫描,当左右指针都是元音字母时,进行互换并移到下一位。
由于元音字母相对固定,因此我们可以使用容器将其存储,并使用 `static` 修饰,确保整个容器的创建和元音字母的填入在所有测试样例中只会发生一次。
我们期望该容器能在 $O(1)$ 的复杂度内判断是否为元音字母,可以使用语言自带的哈希类容器($P2$ 代码)或是使用数组模拟($P1$ 代码)。
> 一些细节:由于题目没有说字符串中只包含字母,因此在使用数组模拟哈希表时,我们需要用当前字符减去 ASCII 码的最小值(空字符),而不是 'A'
代码:
```Java
class Solution {
static boolean[] hash = new boolean[128];
static char[] vowels = new char[]{'a','e','i','o','u'};
static {
for (char c : vowels) {
hash[c - ' '] = hash[Character.toUpperCase(c) - ' '] = true;
}
}
public String reverseVowels(String s) {
char[] cs = s.toCharArray();
int n = s.length();
int l = 0, r = n - 1;
while (l < r) {
if (hash[cs[l] - ' '] && hash[cs[r] - ' ']) {
swap(cs, l++, r--);
} else {
if (!hash[cs[l] - ' ']) l++;
if (!hash[cs[r] - ' ']) r--;
}
}
return String.valueOf(cs);
}
void swap(char[] cs, int l, int r) {
char c = cs[l];
cs[l] = cs[r];
cs[r] = c;
}
}
```
```Java
class Solution {
static char[] vowels = new char[]{'a','e','i','o','u'};
static Set<Character> set = new HashSet<>();
static {
for (char c : vowels) {
set.add(c);
set.add(Character.toUpperCase(c));
}
}
public String reverseVowels(String s) {
char[] cs = s.toCharArray();
int n = s.length();
int l = 0, r = n - 1;
while (l < r) {
if (set.contains(cs[l]) && set.contains(cs[r])) {
swap(cs, l++, r--);
} else {
if (!set.contains(cs[l])) l++;
if (!set.contains(cs[r])) r--;
}
}
return String.valueOf(cs);
}
void swap(char[] cs, int l, int r) {
char c = cs[l];
cs[l] = cs[r];
cs[r] = c;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:由于 `toCharArray` 会创建新数组,复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.345` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/351-360/352. 将数据流变为多个不相交区间（困难）.md | 352. 将数据流变为多个不相交区间 | https://leetcode-cn.com/problems/data-stream-as-disjoint-intervals/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-afrk/ | 困难 | [
"二分",
"模拟"
] | 给你一个由非负整数 `a1, a2, ..., an` 组成的数据流输入,请你将到目前为止看到的数字总结为不相交的区间列表。
实现 `SummaryRanges` 类:
* `SummaryRanges()` 使用一个空数据流初始化对象。
* `void addNum(int val)` 向数据流中加入整数 `val` 。
* `int[][] getIntervals()` 以不相交区间 `[starti, endi]` 的列表形式返回对数据流中整数的总结。
示例:
```
输入:
["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals"]
[[], [1], [], [3], [], [7], [], [2], [], [6], []]
输出:
[null, null, [[1, 1]], null, [[1, 1], [3, 3]], null, [[1, 1], [3, 3], [7, 7]], null, [[1, 3], [7, 7]], null, [[1, 3], [6, 7]]]
解释:
SummaryRanges summaryRanges = new SummaryRanges();
summaryRanges.addNum(1); // arr = [1]
summaryRanges.getIntervals(); // 返回 [[1, 1]]
summaryRanges.addNum(3); // arr = [1, 3]
summaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3]]
summaryRanges.addNum(7); // arr = [1, 3, 7]
summaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3], [7, 7]]
summaryRanges.addNum(2); // arr = [1, 2, 3, 7]
summaryRanges.getIntervals(); // 返回 [[1, 3], [7, 7]]
summaryRanges.addNum(6); // arr = [1, 2, 3, 6, 7]
summaryRanges.getIntervals(); // 返回 [[1, 3], [6, 7]]
```
提示:
* 0 <= val <= $10^4$
* 最多调用 addNum 和 getIntervals 方法 $3 * 10^4$ 次
**进阶:如果存在大量合并,并且与数据流的大小相比,不相交区间的数量很小,该怎么办?** | ### 二分查找 + 朴素维护区间
一个朴素的做法是直接使用 `ArrayList`(数组)来维护所有的不相交区间,然后调用 `addNum` 时先通过二分找到当前值相邻的区间,然后根据题意进行模拟即可。
同时为了简化复杂的分情况讨论,起始时我们可以先往 `ArrayList` 添加两个哨兵分别代表正无穷和负无穷。
代码(不使用哨兵的代码见 $P2$):
```Java
class SummaryRanges {
List<int[]> list = new ArrayList<>();
int[] head = new int[]{-10, -10}, tail = new int[]{10010, 10010};
public SummaryRanges() {
list.add(head);
list.add(tail);
}
public void addNum(int val) {
int n = list.size();
if (n == 0) {
list.add(new int[]{val, val});
return ;
}
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid)[0] <= val) l = mid;
else r = mid - 1;
}
int[] cur = new int[]{val, val};
int[] prev = list.get(r);
int[] next = list.get(r + 1);
if ((prev[0] <= val && val <= prev[1]) || (next[0] <= val && val <= next[1])) {
// pass
} else if (prev[1] + 1 == val && val == next[0] - 1) {
prev[1] = next[1];
list.remove(next);
} else if (prev[1] + 1 == val) {
prev[1] = val;
} else if (next[0] - 1 == val) {
next[0] = val;
} else {
list.add(r + 1, cur);
}
}
public int[][] getIntervals() {
int n = list.size();
int[][] ans = new int[n - 2][2];
int idx = 0;
for (int i = 1; i < n - 1; i++) ans[idx++] = list.get(i);
return ans;
}
}
```
```Java
class SummaryRanges {
List<int[]> list = new ArrayList<>();
public void addNum(int val) {
int n = list.size();
if (n == 0) {
list.add(new int[]{val, val});
return ;
}
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid)[0] <= val) l = mid;
else r = mid - 1;
}
int[] cur = list.get(r);
if (cur[0] > val) {
if (val + 1 == cur[0]) {
cur[0] = val;
} else {
list.add(r, new int[]{val, val});
}
return ;
}
if (cur[0] <= val && val <= cur[1]) {
// pass
} else if (r == n - 1) {
if (cur[1] + 1 == val) {
cur[1] = val;
} else {
list.add(new int[]{val, val});
}
} else {
int[] next = list.get(r + 1);
if (cur[1] + 1 == val && val == next[0] - 1) {
cur[1] = next[1];
list.remove(r + 1);
} else if (cur[1] + 1 == val) {
cur[1] = val;
} else if (next[0] - 1 == val) {
next[0] = val;
} else {
list.add(r + 1, new int[]{val, val});
}
}
}
public int[][] getIntervals() {
int n = list.size();
int[][] ans = new int[n][2];
for (int i = 0; i < n; i++) ans[i] = list.get(i);
return ans;
}
}
```
* 时间复杂度:令 $m$ 为不交区间个数,`addNum` 操作中查询相邻区间的复杂度为 $O(\log{m})$,维护不相交区间时,由于需要针对 $list$ 的索引位置进行元素插入和删除,复杂度为 $O(m)$,整体复杂度为 $O(m)$;`getIntervals` 操作需要遍历所有的 $list$ 元素,复杂度为 $O(m)$
* 空间复杂度:$O(m)$
---
### 二分查找 + 优化维护区间
解法一中虽然在 `addNum` 使用到了复杂度诶 $O(\log{m})$ 的二分查找,但在维护区间时,由于要对 $list$ 进行针对索引的插入和删除,导致整体复杂度为 $O(m)$。
我们期望找到一种插入/删除操作复杂度同样为 $O(\log{m})$ 的方式来维护区间,这引导我们使用 `TreeSet`(红黑树)等数据结构。
具体做法不变,仍然是先使用「二分」(`TreeSet` 自带的 `floor/ceiling`)来找到当前值的相邻区间,
同时为了简化复杂的分情况讨论,起始时我们可以先往 `TreeSet` 添加两个哨兵分别代表正无穷和负无穷,以确保调用 `floor/ceiling` 时不会返回空。
代码:
```Java
class SummaryRanges {
TreeSet<int[]> ts = new TreeSet<>((a, b)->a[0]-b[0]);
int[] head = new int[]{-10, -10}, tail = new int[]{10010, 10010};
public SummaryRanges() {
ts.add(head);
ts.add(tail);
}
public void addNum(int val) {
int[] cur = new int[]{val, val};
int[] prev = ts.floor(cur);
int[] next = ts.ceiling(cur);
if ((prev[0] <= val && val <= prev[1]) || (next[0] <= val && val <= next[1])) {
// pass
} else if (prev[1] + 1 == val && next[0] - 1 == val) {
prev[1] = next[1];
ts.remove(next);
} else if (prev[1] + 1 == val) {
prev[1] = val;
} else if (next[0] - 1 == val) {
next[0] = val;
} else {
ts.add(cur);
}
}
public int[][] getIntervals() {
// using ceiling
// int n = ts.size();
// int[][] ans = new int[n - 2][2];
// int[] cur = head;
// for (int i = 0; i < n - 2; i++) {
// ans[i] = ts.ceiling(new int[]{cur[0] + 1, cur[1] + 1});
// cur = ans[i];
// }
// return ans;
// using iterator
int n = ts.size();
int[][] ans = new int[n - 2][2];
Iterator<int[]> iterator = ts.iterator();
iterator.next();
for (int i = 0; i < n - 2; i++) ans[i] = iterator.next();
return ans;
}
}
```
* 时间复杂度:令 $m$ 为不交区间个数,`addNum` 操作中「查询相邻区间」和「维护不相交区间」的复杂度为 $O(\log{m})$,整体复杂度为 $O(\log{m})$;`getIntervals` 操作需要获取有序集合中的所有元素,使用 `ceiling` 复杂度为 $O(m\log{m})$。使用 `iterator` 的话,由于 `TreeSet` 底层同步维护了一个 `TreeMap`,迭代器由 `TreeMap` 所提供,获取 `iterator` 来遍历所有元素的复杂度为 $O(m)$
* 空间复杂度:$O(m)$
---
### 进阶
如果存在大量合并,并且与数据流的大小相比,不相交区间的数量很小,该怎么办?
即需要确保 `addNum` 的复杂度,而对 `getIntervals` 复杂度要求不高,上述解法就已经是这么做的了。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.352` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/351-360/354. 俄罗斯套娃信封问题（困难）.md | 354. 俄罗斯套娃信封问题 | https://leetcode-cn.com/problems/russian-doll-envelopes/solution/zui-chang-shang-sheng-zi-xu-lie-bian-xin-6s8d/ | 困难 | [
"二分",
"序列 DP"
] | 给你一个二维整数数组 envelopes ,其中 envelopes[i] = [wi, hi] ,表示第 i 个信封的宽度和高度。
当另一个信封的宽度和高度都比这个信封大的时候,这个信封就可以放进另一个信封里,如同俄罗斯套娃一样。
请计算「最多能有多少个」信封能组成一组“俄罗斯套娃”信封(即可以把一个信封放到另一个信封里面)。
注意:不允许旋转信封。
示例 1:
```
输入:envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出:3
解释:最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。
```
示例 2:
```
输入:envelopes = [[1,1],[1,1],[1,1]]
输出:1
```
提示:
* 1 <= envelopes.length <= 5000
* envelopes[i].length == 2
* 1 <= wi, hi <= $10^4$ | ### 动态规划
这是一道经典的 DP 模型题目:最长上升子序列(LIS)。
首先我们先对 `envelopes` 进行排序,确保信封是从小到大进行排序。
问题就转化为我们从这个序列中选择 `k` 个信封形成新的序列,使得新序列中的每个信封都能严格覆盖前面的信封(宽高都严格大于)。
我们可以**定义状态 $f[i]$ 为考虑前 i 个物品,并以第 $i$ 个物品为结尾的最大值。**
对于每个$f[i]$ 而言,最小值为 $1$,代表只选择自己一个信封。
那么对于一般的 $f[i]$ 该如何求解呢?因为第 i 件物品是必须选择的。我们可以枚举前面的 $i - 1$ 件物品,哪一件可以作为第 $i$ 件物品的上一件物品。
在前 $i - 1$ 件物品中只要有符合条件的,我们就使用 $max(f[i], f[j] + 1)$ 更新 $f[i]$。
然后在所有方案中取一个 `max` 即是答案。
代码:
```Java
class Solution {
public int maxEnvelopes(int[][] es) {
int n = es.length;
if (n == 0) return n;
// 因为我们在找第 i 件物品的前一件物品时,会对前面的 i - 1 件物品都遍历一遍,因此第二维(高度)排序与否都不影响
Arrays.sort(es, (a, b)->a[0]-b[0]);
int[] f = new int[n]; // f(i) 为考虑前 i 个物品,并以第 i 个物品为结尾的最大值
int ans = 1;
for (int i = 0; i < n; i++) {
// 对于每个 f[i] 都满足最小值为 1
f[i] = 1;
// 枚举第 i 件物品的前一件物品,
for (int j = i - 1; j >= 0; j--) {
// 只要有满足条件的前一件物品,我们就尝试使用 f[j] + 1 更新 f[i]
if (check(es, j, i)) {
f[i] = Math.max(f[i], f[j] + 1);
}
}
// 在所有的 f[i] 中取 max 作为 ans
ans = Math.max(ans, f[i]);
}
return ans;
}
boolean check(int[][] es, int mid, int i) {
return es[mid][0] < es[i][0] && es[mid][1] < es[i][1];
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
***
### 二分 + 动态规划
上述方案其实算是一个朴素方案,复杂度是 $O(n^2)$ 的,也是我最先想到思路,但是题目没有给出数据范围,也不知道能不能过。
唯唯诺诺交了一个居然过了。
下面讲下其他优化解法。
首先还是和之前一样,我们可以通过复杂度分析来想优化方向。
指数算法往下优化就是对数解法或者线性解法。
仔细观察朴素解法,其实可优化的地方主要就是找第 $i$ 件物品的前一件物品的过程。
如果想要加快这个查找过程,我们需要使用某种数据结构进行记录。
并且是边迭代边更新数据结构里面的内容。
首先因为我们对 `w` 进行了排序(从小到大),然后迭代也是从前往后进行,因此我们只需要保证迭代过程中,对于 `w` 相同的数据不更新,就能保证 `g` 中只会出现满足 `w` 条件的信封。
到这一步,还需要用到的东西有两个:一个是 `h`,因为只有 `w` 和 `h` 都同时满足,我们才能加入上升序列中;一个是信封所对应的上升序列长度,这是我们加速查找的核心。
我们使用数组 `g` 来记录,$g[i]$ 表示长度为 $i$ 的最长上升子序列的中的最小「信封高度」,同时需要使用 `len` 记录当前记录到的最大长度。
还是不理解?没关系,我们可以直接看看代码,我把基本逻辑写在了注释当中(你的重点应该落在对 $g[]$ 数组的理解上)。
代码:
```Java
class Solution {
public int maxEnvelopes(int[][] es) {
int n = es.length;
if (n == 0) return n;
// 由于我们使用了 g 记录高度,因此这里只需将 w 从小到达排序即可
Arrays.sort(es, (a, b)->a[0] - b[0]);
// f(i) 为考虑前 i 个物品,并以第 i 个物品为结尾的最大值
int[] f = new int[n];
// g(i) 记录的是长度为 i 的最长上升子序列的最小「信封高度」
int[] g = new int[n];
// 因为要取 min,用一个足够大(不可能)的高度初始化
Arrays.fill(g, Integer.MAX_VALUE);
g[0] = 0;
int ans = 1;
for (int i = 0, j = 0, len = 1; i < n; i++) {
// 对于 w 相同的数据,不更新 g 数组
if (es[i][0] != es[j][0]) {
// 限制 j 不能越过 i,确保 g 数组中只会出现第 i 个信封前的「历史信封」
while (j < i) {
int prev = f[j], cur = es[j][1];
if (prev == len) {
// 与当前长度一致了,说明上升序列多增加一位
g[len++] = cur;
} else {
// 始终保留最小的「信封高度」,这样可以确保有更多的信封可以与其行程上升序列
// 举例:同样是上升长度为 5 的序列,保留最小高度为 5 记录(而不是保留任意的,比如 10),这样之后高度为 7 8 9 的信封都能形成序列;
g[prev] = Math.min(g[prev], cur);
}
j++;
}
}
// 二分过程
// g[i] 代表的是上升子序列长度为 i 的「最小信封高度」
int l = 0, r = len;
while (l < r) {
int mid = l + r >> 1;
// 令 check 条件为 es[i][1] <= g[mid](代表 w 和 h 都严格小于当前信封)
// 这样我们找到的就是满足条件,最靠近数组中心点的数据(也就是满足 check 条件的最大下标)
// 对应回 g[] 数组的含义,其实就是找到 w 和 h 都满足条件的最大上升长度
if (es[i][1] <= g[mid]) {
r = mid;
} else {
l = mid + 1;
}
}
// 更新 f[i] 与答案
f[i] = r;
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
* 时间复杂度:对于每件物品都是通过「二分」找到其前一件物品。复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
***
### 证明
我们可以这样做的前提是 `g` 数组具有二段性,可以通过证明其具有「单调性」来实现。
当然这里指的是 `g` 被使用的部分,也就是 $[0, len - 1]$ 的部分。
我们再回顾一下 `g[]` 数组的定义:**$g[i]$ 表示长度为 $i$ 的最长上升子序列的中的最小「信封高度」**
例如 $g[] = [0, 3, 4, 5]$ 代表的含义是:
* 上升序列长度为 0 的最小历史信封高度为 0
* 上升序列长度为 1 的最小历史信封高度为 3
* 上升序列长度为 2 的最小历史信封高度为 4
* 上升序列长度为 3 的最小历史信封高度为 5
可以通过反证法来证明其单调性:
假设 $g[]$ 不具有单调性,即至少有 $g[i] > g[j]$ ( $i < j$,令 $a = g[i]$, $b = g[j]$)
显然与我们的处理逻辑冲突。因为如果考虑一个「最小高度」为 `b` 的信封能够凑出长度为 `j` 的上升序列,自然也能凑出比 `j` 短的上升序列,对吧?
举个🌰,我们有信封:[[1,1],[2,2],[3,3],[4,4],[5,5]],我们能凑出很多种长度为 2 的上升序列方案,其中最小的方案是高度最小的方案是 [[1,1],[2,2]]。因此这时候 g[2] = 2,代表能凑出长度为 2 的上升序列所 **必须使用的信封** 的最小高度为 2。
这时候反过来考虑,如果使用 [2,2] 能够凑出长度为 2 的上升序列,必然也能凑出长度为 1 的上升序列(删除前面的其他信封即可)。
**推而广之,如果我们有 $g[j] = b$,也就是凑成长度为 `j` 必须使用的最小信封高度为 b。那么我必然能够保留高度为 `b` 的信封,删掉上升序列中的一些信封,凑成任意长度比 `j` 小的上升序列。**
综上,$g[i] > g[j](i < j)$ 与处理逻辑冲突,$g[]$ 数组为严格单调上升数组。
既然 $g[]$ 具有单调性,我们可以通过「二分」找到恰满足 check 条件的最大下标(最大下标达标表示最长上升序列长度)。
***
### 树状数组 + 动态规划
在「二分 + 动态规划」的解法中,我们通过「二分」来优化找第 $i$ 个文件的前一个文件过程。
这个过程同样能通过「树状数组」来实现。
首先仍然是对 `w` 进行排序,然后使用「树状数组」来维护 h 维度的前缀最大值。
对于 `h` 的高度,我们只关心多个信封之间的大小关系,而不关心具体相差多少,我们需要对 `h` 进行离散化。
通常使用「树状数组」都需要进行离散化,尤其是这里我们本身就要使用 $O(n)$ 的空间来存储 dp 值。
代码:
```java
class Solution {
int[] tree;
int lowbit(int x) {
return x & -x;
}
public int maxEnvelopes(int[][] es) {
int n = es.length;
if (n == 0) return n;
// 由于我们使用了 g 记录高度,因此这里只需将 w 从小到达排序即可
Arrays.sort(es, (a, b)->a[0] - b[0]);
// 先将所有的 h 进行离散化
Set<Integer> set = new HashSet<>();
for (int i = 0; i < n; i++) set.add(es[i][1]);
int cnt = set.size();
int[] hs = new int[cnt];
int idx = 0;
for (int i : set) hs[idx++] = i;
Arrays.sort(hs);
for (int i = 0; i < n; i++) es[i][1] = Arrays.binarySearch(hs, es[i][1]) + 1;
// 创建树状数组
tree = new int[cnt + 1];
// f(i) 为考虑前 i 个物品,并以第 i 个物品为结尾的最大值
int[] f = new int[n];
int ans = 1;
for (int i = 0, j = 0; i < n; i++) {
// 对于 w 相同的数据,不更新 tree 数组
if (es[i][0] != es[j][0]) {
// 限制 j 不能越过 i,确保 tree 数组中只会出现第 i 个信封前的「历史信封」
while (j < i) {
for (int u = es[j][1]; u <= cnt; u += lowbit(u)) {
tree[u] = Math.max(tree[u], f[j]);
}
j++;
}
}
f[i] = 1;
for (int u = es[i][1] - 1; u > 0; u -= lowbit(u)) {
f[i] = Math.max(f[i], tree[u] + 1);
}
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
* 时间复杂度:处理每个物品时更新「树状数组」复杂度为$O(\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.354` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |