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/171-180/179. 最大数（中等）.md | 179. 最大数 | https://leetcode-cn.com/problems/largest-number/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-vn86e/ | 中等 | [
"贪心"
] | 给定一组非负整数 `nums`,重新排列每个数的顺序(每个数不可拆分)使之组成一个最大的整数。
注意:输出结果可能非常大,所以你需要返回一个字符串而不是整数。
示例 1:
```
输入:nums = [10,2]
输出:"210"
```
示例 2:
```
输入:nums = [3,30,34,5,9]
输出:"9534330"
```
示例 3:
```
输入:nums = [1]
输出:"1"
```
示例 4:
```
输入:nums = [10]
输出:"10"
```
提示:
* $1 <= nums.length <= 100$
* $0 <= nums[i] <= 10^9$ | ### 贪心
对于 $nums$ 中的任意两个值 $a$ 和 $b$,我们无法直接从常规角度上确定其大小/先后关系。
但我们可以根据「结果」来决定 $a$ 和 $b$ 的排序关系:
如果拼接结果 $ab$ 要比 $ba$ 好,那么我们会认为 $a$ 应该放在 $b$ 前面。
另外,注意我们需要处理前导零(最多保留一位)。
Java 代码:
```java
class Solution {
public String largestNumber(int[] nums) {
int n = nums.length;
String[] ss = new String[n];
for (int i = 0; i < n; i++) ss[i] = "" + nums[i];
Arrays.sort(ss, (a, b) -> {
String sa = a + b, sb = b + a ;
return sb.compareTo(sa);
});
StringBuilder sb = new StringBuilder();
for (String s : ss) sb.append(s);
int len = sb.length();
int k = 0;
while (k < len - 1 && sb.charAt(k) == '0') k++;
return sb.substring(k);
}
}
```
C++ 代码:
```C++
class Solution {
public:
string largestNumber(vector<int>& nums) {
int n = nums.size();
vector<string> ss(n);
for (int i = 0; i < n; i++) ss[i] = to_string(nums[i]);
sort(ss.begin(), ss.end(), [](const string& a, const string& b) {
return a + b > b + a;
});
string result;
for (const string& s : ss) result += s;
int len = result.length(), k = 0;
while (k < len - 1 && result[k] == '0') k++;
return result.substr(k);
}
};
```
Python 代码:
```Python
class Solution:
def largestNumber(self, nums: List[int]) -> str:
nums = list(map(str, nums))
nums.sort(key=lambda x: x * 10, reverse=True)
result = ''.join(nums)
k = 0
while k < len(result) - 1 and result[k] == '0':
k += 1
return result[k:]
```
TypeScript 代码:
```TypeScript
function largestNumber(nums: number[]): string {
const ss = nums.map(num => num.toString());
ss.sort((a, b) => (b + a).localeCompare(a + b));
let result = '';
for (const s of ss) result += s;
let k = 0;
while (k < result.length - 1 && result[k] === '0') k++;
return result.substring(k);
};
```
* 时间复杂度:由于是对 $String$ 进行排序,当排序对象不是 $Java$ 中的基本数据类型时,不会使用快排(考虑排序稳定性问题)。`Java` 中的 `Arrays.sort()` 的底层实现会「元素数量/元素是否大致有序」决定是使用插入排序还是归并排序。这里直接假定使用的是「插入排序」。复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$
---
### 证明
上述解法,我们需要证明两个内容:
* 该贪心策略能取到全局最优解。
* 这样的「排序比较逻辑」应用在集合 $nums$ 上具有[「全序关系」](https://baike.baidu.com/item/%E5%85%A8%E5%BA%8F%E5%85%B3%E7%B3%BB)。
#### 1. 该贪心策略能取到全局最优解
令我们经过这样的贪心操作得到的贪心解为 $ans$,真实最优解为 $max$。
由于真实最优解为全局最大值,而我们的贪心解至少是一个合法解(一个数),因此天然有 $ans \leqslant max$。
**接下来我们只需要证明 $ans \geqslant max$,即可得 $ans = max$(贪心解即为最优解)。**
我们使用「反证法」来证明 $ans \geqslant max$ 成立:
假设 $ans \geqslant max$ 不成立,即有 $ans < max$。
$ans$ 和 $max$ 都是由同样一批数字凑成的,如果有 $ans < max$。
这意味着我们可以将 $ans$ 中的某些低位数字和高位数字互换,使得 $ans$ 更大(调整为 $max$),这与我们根据「结果」进行排序的逻辑冲突。
因此 $ans < max$ 必然不成立,得证 $ans \geqslant max$ 成立,结合 $ans \leqslant max$ 可得贪心解为最优。
举个🌰,如果有 $ans < max$,那么意味着在 $ans$ 中至少有一对数字互换可以使得 $ans$ 变大,
那么在排序逻辑中 $x$ 所在的整体(可能不只有 $x$ 一个数)应该被排在 $y$ 所在的整体(可能不只有 $y$ 一个数)前面。
#### 2. 全序关系
我们使用符号 $@$ 来代指我们的「排序」逻辑:
* 如果 $a$ 必须排在 $b$ 的前面,我们记作 $a @ b$;
* 如果 $a$ 必须排在 $b$ 的后面,我们记作 $b @ a$;
* 如果 $a$ 既可以排在 $b$ 的前面,也可以排在 $b$ 的后面,我们记作 $a\#b$;
**2.1 完全性**
**具有完全性是指从集合 $nums$ 中任意取出两个元素 $a$ 和 $b$,必然满足 $a @ b$、$b @ a$ 和 $a\#b$ 三者之一。**
**这点其实不需要额外证明,因为由 $a$ 和 $b$ 拼接的字符串 $ab$ 和 $ba$ 所在「字典序大小关系中」要么完全相等,要么具有明确的字典序大小关系,导致 $a$ 必须排在前面或者后面。**
**2.2 反对称性**
**具有反对称性是指由 $a@b$ 和 $b@a$ 能够推导出 $a\#b$。**
$a@b$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值大。
$b@a$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值小。
**这样,基于「字典序本身满足全序关系」和「数学上的 $a \geqslant b$ 和 $a \leqslant b$ 可推导出 $a = b$」。**
**得证 $a@b$ 和 $b@a$ 能够推导出 $a\#b$。**
**2.3 传递性**
**具有传递性是指由 $a@b$ 和 $b@c$ 能够推导出 $a@c$。**
这里的「传递性」其实也可以使用与 [官方题解](https://leetcode-cn.com/problems/largest-number/solution/zui-da-shu-by-leetcode-solution-sid5/) 类似的手法来证明。
**我们可以利用「两个等长的拼接字符串,字典序大小关系与数值大小关系一致」这一性质来证明,因为字符串 $ac$ 和 $ca$ 必然是等长的。**
接下来,让我们从「自定义排序逻辑」出发,换个思路来证明 $a@c$:
**然后我们只需要证明在不同的 $i$ $j$ 关系之间(共三种情况),$a@c$ 恒成立即可:**
1. 当 $i == j$ 的时候:
2. 当 $i > j$ 的时候:
3. 当 $i < j$ 的时候:
**综上,我们证明了无论在何种情况下,只要有 $a@b$ 和 $b@c$ 的话,那么 $a@c$ 恒成立。**
**我们之所以能这样证明「传递性」,本质是利用了自定义排序逻辑中「对于确定任意元素 $a$ 和 $b$ 之间的排序关系只依赖于 $a$ 和 $b$ 的第一个不同元素之间的大小关系」这一性质。**
---
### 找 $i$ 的越界问题
考虑
(1) a = 304 b = 30
(2) a = 301 b = 30
两种情况。
显然,(1)下我们会得到 $a@b$,而(2)下我们会得到 $b@a$
但是,在这种情况下 $i$ 实际上位于 $b$ 界外,那我们还能不能找 $i$ 呢?$b[i]$ 是多少呢?
实际上是可以的,我们在比较 $a$ 和 $b$ 的时候,实际上是在比较 $ab$ 和 $ba$ 两个字符串,所以实际上我们是在用 $a[0]$, $a[1]$, $a[2]$ ... 去填补 $b$ 本体结束后的空缺。换而言之(1)和(2)里的 b 实际上被填补为 `303` (填进来 $a[0]$)
再比如
(3)a = 3131248 b = 3131 ,比较的时候实际上是用 $a$ 开头的 `4` 位去填补上 $b$ 的空缺,所以 $b$ 实际上相当于 `31313131` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.179` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1711. 大餐计数（中等）.md | 1711. 大餐计数 | https://leetcode-cn.com/problems/count-good-meals/solution/gong-shui-san-xie-xiang-jie-san-chong-gu-nn4f/ | 中等 | [
"哈希表",
"位运算"
] | 大餐 是指 恰好包含两道不同餐品 的一餐,其美味程度之和等于 2 的幂。
你可以搭配 任意 两道餐品做一顿大餐。
给你一个整数数组 deliciousness ,其中 deliciousness[i] 是第 i 道餐品的美味程度,返回你可以用数组中的餐品做出的不同 大餐 的数量。结果需要对 $10^9$ + 7 取余。
注意,只要餐品下标不同,就可以认为是不同的餐品,即便它们的美味程度相同。
示例 1:
```
输入:deliciousness = [1,3,5,7,9]
输出:4
解释:大餐的美味程度组合为 (1,3) 、(1,7) 、(3,5) 和 (7,9) 。
它们各自的美味程度之和分别为 4 、8 、8 和 16 ,都是 2 的幂。
```
示例 2:
```
输入:deliciousness = [1,1,1,3,3,3,7]
输出:15
解释:大餐的美味程度组合为 3 种 (1,1) ,9 种 (1,3) ,和 3 种 (1,7) 。
```
提示:
* 1 <= deliciousness.length <= $10^5$
* 0 <= deliciousness[i] <= $2^{20}$ | ### 枚举前一个数(TLE)
一个朴素的想法是,从前往后遍历 $deliciousness$ 中的所有数,当遍历到下标 $i$ 的时候,回头检查下标小于 $i$ 的数是否能够与 $deliciousness[i]$ 相加形成 $2$ 的幂。
这样的做法是 $O(n^2)$ 的,防止同样的数值被重复计算,我们可以使用「哈希表」记录某个数出现了多少次,但这并不改变算法仍然是 $O(n^2)$ 的。
而且我们需要一个 `check` 方法来判断某个数是否为 $2$ 的幂:
* 朴素的做法是对 $x$ 应用试除法,当然因为精度问题,我们需要使用乘法实现试除;
* 另一个比较优秀的做法是利用位运算找到符合「大于等于 $x$」的最近的 $2$ 的幂,然后判断是否与 $x$ 相同。
两种做法差距有多大呢?方法一的复杂度为 $O(\log{n})$,方法二为 $O(1)$。
根据数据范围 $0 <= deliciousness[i] <= 2^{20}$,方法一最多也就是执行不超过 $22$ 次循环。
显然,采用何种判断 $2$ 的幂的做法不是关键,在 OJ 判定上也只是分别卡在 $60/70$ 和 $62/70$ 的 TLE 上。
**但通过这样的分析,我们可以发现「枚举前一个数」的做法是与 $n$ 相关的,而枚举「可能出现的 $2$ 的幂」则是有明确的范围,这引导出我们的解法二。**
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int countPairs(int[] ds) {
int n = ds.length;
long ans = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
int x = ds[i];
for (int other : map.keySet()) {
if (check(other + x)) ans += map.get(other);
}
map.put(x, map.getOrDefault(x, 0) + 1);
}
return (int)(ans % mod);
}
boolean check(long x) {
// 方法一
// long cur = 1;
// while (cur < x) {
// cur = cur * 2;
// }
// return cur == x;
// 方法二
return getVal(x) == x;
}
long getVal(long x) {
long n = x - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return n < 0 ? 1 : n + 1;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
---
### 枚举 2 的幂(容斥原理)
根据对朴素解法的分析,我们可以先使用「哈希表」对所有在 $deliciousness$ 出现过的数进行统计。
然后对于每个数 $x$,检查所有可能出现的 $2$ 的幂 $i$,再从「哈希表」中反查 $t = i - x$ 是否存在,并实现计数。
一些细节:如果哈希表中存在 $t = i - x$,并且 $t = x$,这时候方案数应该是 $(cnts[x] - 1) * cnts[x]$;其余一般情况则是 $cnts[t] * cnts[x]$。
同时,这样的计数方式,我们对于二元组 $(x, t)$ 会分别计数两次(遍历 $x$ 和 遍历 $t$),因此最后要利用容斥原理,对重复计数的进行减半操作。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
int max = 1 << 22;
public int countPairs(int[] ds) {
Map<Integer, Integer> map = new HashMap<>();
for (int d : ds) map.put(d, map.getOrDefault(d, 0) + 1);
long ans = 0;
for (int x : map.keySet()) {
for (int i = 1; i < max; i <<= 1) {
int t = i - x;
if (map.containsKey(t)) {
if (t == x) ans += (map.get(x) - 1) * 1L * map.get(x);
else ans += map.get(x) * 1L * map.get(t);
}
}
}
ans >>= 1;
return (int)(ans % mod);
}
}
```
* 时间复杂度:根据数据范围,令 $C$ 为 $2^{21}$。复杂度为 $O(n * \log{C})$
* 空间复杂度:$O(n)$
---
### 枚举 2 的幂(边遍历边统计)
当然,我们也可以采取「一边遍历一边统计」的方式,这样取余操作就可以放在遍历逻辑中去做,也就顺便实现了不使用 $long$ 来计数(以及不使用 `%` 实现取余)。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
int max = 1 << 22;
public int countPairs(int[] ds) {
Map<Integer, Integer> map = new HashMap<>();
int ans = 0;
for (int x : ds) {
for (int i = 1; i < max; i <<= 1) {
int t = i - x;
if (map.containsKey(t)) {
ans += map.get(t);
if (ans >= mod) ans -= mod;
}
}
map.put(x, map.getOrDefault(x, 0) + 1);
}
return ans;
}
}
```
* 时间复杂度:根据数据范围,令 $C$ 为 $2^{21}$。复杂度为 $O(n * \log{C})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1711` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1713. 得到子序列的最少操作次数（困难）.md | 1713. 得到子序列的最少操作次数 | https://leetcode-cn.com/problems/minimum-operations-to-make-a-subsequence/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-oj7yu/ | 困难 | [
"最长公共子序列",
"最长上升子序列",
"贪心",
"二分"
] | 给你一个数组 target ,包含若干 互不相同 的整数,以及另一个整数数组 arr ,arr 可能 包含重复元素。
每一次操作中,你可以在 arr 的任意位置插入任一整数。比方说,如果 arr = [1,4,1,2] ,那么你可以在中间添加 3 得到 [1,4,3,1,2] 。你可以在数组最开始或最后面添加整数。
请你返回 最少 操作次数,使得 target 成为 arr 的一个子序列。
一个数组的 子序列 指的是删除原数组的某些元素(可能一个元素都不删除),同时不改变其余元素的相对顺序得到的数组。比方说,[2,7,4] 是 [4,2,3,7,2,1,4] 的子序列(加粗元素),但 [2,4,2] 不是子序列。
示例 1:
```
输入:target = [5,1,3], arr = [9,4,2,3,4]
输出:2
解释:你可以添加 5 和 1 ,使得 arr 变为 [5,9,4,1,2,3,4] ,target 为 arr 的子序列。
```
示例 2:
```
输入:target = [6,4,8,1,3,2], arr = [4,7,6,2,3,8,6,1]
输出:3
```
提示:
* 1 <= target.length, arr.length <= $10^5$
* 1 <= target[i], arr[i] <= $10^9$
* target 不包含任何重复元素。 | ### 基本分析
为了方便,我们令 $target$ 长度为 $n$,$arr$ 长度为 $m$,$target$ 和 $arr$ 的最长公共子序列长度为 $max$,不难发现最终答案为 $n - max$。
因此从题面来说,这是一道最长公共子序列问题(LCS)。
但朴素求解 LCS 问题复杂度为 $O(n * m)$,使用状态定义「**$f[i][j]$ 为考虑 `a` 数组的前 $i$ 个元素和 `b` 数组的前 $j$ 个元素的最长公共子序列长度为多少**」进行求解。
而本题的数据范围为 $10^5$,使用朴素求解 LCS 的做法必然超时。
一个很显眼的切入点是 $target$ 数组元素各不相同,当 LCS 问题增加某些条件限制之后,会存在一些很有趣的性质。
其中一个经典的性质就是:**当其中一个数组元素各不相同时,最长公共子序列问题(LCS)可以转换为最长上升子序列问题(LIS)进行求解。同时最长上升子序列问题(LIS)存在使用「维护单调序列 + 二分」的贪心解法,复杂度为 $O(n\log{n})$。**
**因此本题可以通过「抽象成 LCS 问题」->「利用 $target$ 数组元素各不相同,转换为 LIS 问题」->「使用 LIS 的贪心解法」,做到 $O(n\log{n})$ 的复杂度。**
基本方向确定后,我们证明一下第 $2$ 步和第 $3$ 步的合理性与正确性。
---
### 证明
#### 1. 为何其中一个数组元素各不相同,LCS 问题可以转换为 LIS 问题?
**本质是利用「当其中一个数组元素各不相同时,这时候每一个“公共子序列”都对应一个不重复元素数组的下标数组“上升子序列”,反之亦然」。**
我们可以使用题目给定的两个数组($target$ 和 $arr$)理解上面的话。
由于 $target$ 元素各不相同,那么首先 $target$ 元素和其对应下标,具有唯一的映射关系。
然后我们可以**将重点放在两者的公共元素上(忽略非公共元素),每一个“公共子序列”自然对应了一个下标数组“上升子序列”,反之亦然**。
注意:下图只画出了两个数组的某个片段,不要错误理解为两数组等长。
如果存在某个“公共子序列”,根据“子序列”的定义,那么对应下标序列必然递增,也就是对应了一个“上升子序列”。
反过来,对于下标数组的某个“上升子序列”,首先意味着元素在 $target$ 出现过,并且出现顺序递增,符合“公共子序列”定义,即对应了一个“公共子序列”。
至此,我们将原问题 LCS 转换为了 LIS 问题。
#### 2. 贪心求解 LIS 问题的正确性证明?
朴素的 LIS 问题求解,我们需要定义一个 $f[i]$ 数组代表以 $nums[i]$ 为结尾的最长上升子序列的长度为多少。
对于某个 $f[i]$ 而言,我们需要往回检查 $[0, i - 1]$ 区间内,所有可以将 $nums[i]$ 接到后面的位置 $j$,在所有的 $f[j] + 1$ 中取最大值更新 $f[i]$。因此朴素的 LIS 问题复杂度是 $O(n^2)$ 的。
**LIS 的贪心解法则是维护一个额外 $g$ 数组,$g[len] = x$ 代表上升子序列长度为 $len$ 的上升子序列的「最小结尾元素」为 $x$。**
整理一下,我们总共有两个数组:
* $f$ 动规数组:与朴素 LIS 解法的动规数组含义一致。$f[i]$ 代表以 $nums[i]$ 为结尾的上升子序列的最大长度;
* $g$ 贪心数组:$g[len] = x$ 代表上升子序列长度为 $len$ 的上升子序列的「最小结尾元素」为 $x$。
由于我们计算 $f[i]$ 时,需要找到满足 $nums[j] < nums[i]$,同时取得最大 $f[j]$ 的位置 $j$。
我们期望通过 $g$ 数组代替线性遍历。
显然,如果 $g$ 数组具有「单调递增」特性的话,我们可以通过「二分」找到符合 $g[idx] < nums[i]$ 分割点 $idx$(下标最大),即利用 $O(\log{n})$ 复杂度找到最佳转移位置。
我们可以很容易 **通过反证法结合 $g$ 数组的定义来证明 $g$ 数组具有「单调递增」特性。**
假设存在某个位置 $i$ 和 $j$,且 $i < j$,不满足「单调递增」,即如下两种可能:
* $g[i] = g[j] = x$:这意味着某个值 $x$ 既能作为长度 $i$ 的上升子序列的最后一位,也能作为长度为 $j$ 的上升子序列的最后一位。
根据我们对 $g$ 数组的定义,$g[i] = x$ 意味在所有长度为 $i$ 上升子序列中「最小结尾元素」为 $x$,但同时由于 $g[j] = x$,而且「上升子序列」必然是「严格单调」,因此我们可以通过删除长度为 $j$ 的子序列后面的元素(调整出一个长度为 $i$ 的子序列)来找到一个比 $g[i]$ 小的合法值。
也就是我们找到了一个长度为 $i$ 的上升子序列,且最后一位元素必然严格小于 $x$。因此 $g[i] = g[j] = x$ 恒不成立;
* $g[i] > g[j] = x$:同理,如果存在一个长度为 $j$ 的合法上升子序列的「最小结尾元素」为 $x$ 的话,那么必然能够找到一个比 $x$ 小的值来更新 $g[i]$。即 $g[i] > g[j]$ 恒不成立。
根据全序关系,在证明 $g[i] = g[j]$ 和 $g[i] > g[j]$ 恒不成立后,可得 $g[i] < g[j]$ 恒成立。
至此,我们证明了 $g$ 数组具有单调性,从而证明了每一个 $f[i]$ 均与朴素 LIS 解法得到的值相同,即贪心解是正确的。
---
### 动态规划 + 贪心 + 二分
根据「基本分析 & 证明」,通过维护一个贪心数组 $g$,来更新动规数组 $f$,在求得「最长上升子序列」长度之后,利用「“公共子序列”和“上升子序列”」的一一对应关系,可以得出“最长公共子序列”长度,从而求解出答案。
代码:
```Java
class Solution {
public int minOperations(int[] t, int[] arr) {
int n = t.length, m = arr.length;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
map.put(t[i], i);
}
List<Integer> list = new ArrayList<>();
for (int i = 0; i < m; i++) {
int x = arr[i];
if (map.containsKey(x)) list.add(map.get(x));
}
int len = list.size();
int[] f = new int[len], g = new int[len + 1];
Arrays.fill(g, Integer.MAX_VALUE);
int max = 0;
for (int i = 0; i < len; i++) {
int l = 0, r = len;
while (l < r) {
int mid = l + r + 1 >> 1;
if (g[mid] < list.get(i)) l = mid;
else r = mid - 1;
}
int clen = r + 1;
f[i] = clen;
g[clen] = Math.min(g[clen], list.get(i));
max = Math.max(max, clen);
}
return n - max;
}
}
```
* 时间复杂度:通过 $O(n)$ 复杂度得到 $target$ 的下标映射关系;通过 $O(m)$ 复杂度得到映射数组 $list$;贪心求解 LIS 的复杂度为 $O(m\log{m})$。整体复杂度为 $O(n + m\log{m})$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1713` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1716. 计算力扣银行的钱（简单）.md | 1716. 计算力扣银行的钱 | https://leetcode-cn.com/problems/calculate-money-in-leetcode-bank/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-ifit/ | 简单 | [
"数学",
"模拟"
] | Hercy 想要为购买第一辆车存钱。他 **每天** 都往力扣银行里存钱。
最开始,他在周一的时候存入 `1` 块钱。从周二到周日,他每天都比前一天多存入 `1` 块钱。在接下来每一个周一,他都会比 前一个周一 多存入 `1` 块钱。
给你 `n` ,请你返回在第 `n` 天结束的时候他在力扣银行总共存了多少块钱。
示例 1:
```
输入:n = 4
输出:10
解释:第 4 天后,总额为 1 + 2 + 3 + 4 = 10 。
```
示例 2:
```
输入:n = 10
输出:37
解释:第 10 天后,总额为 (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4) = 37 。注意到第二个星期一,Hercy 存入 2 块钱。
```
示例 3:
```
输入:n = 20
输出:96
解释:第 20 天后,总额为 (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4 + 5 + 6 + 7 + 8) + (3 + 4 + 5 + 6 + 7 + 8) = 96 。
```
提示:
* $1 <= n <= 1000$ | ### 模拟
根据题意进行模拟即可,分两步进行计算。
先计算完整周:共 $a = \left \lfloor \frac{n}{7} \right \rfloor$ 周,第一周起始日金额为 $1$,每周的起始日的金额递增 $1$,周内金额可使用「等差数列求和」公式直接求解。
然后再计算最后一周(若有)的金额:共 $b = n \pmod 7$ 天,使用紧接的起始日金额继续进行累加即可。
代码:
```Java
class Solution {
public int totalMoney(int n) {
int a = n / 7, b = n % 7;
int ans = 0, k = 1;
while (a-- > 0) {
ans += (k + (k + 6)) * 7 / 2;
k++;
}
while (b-- > 0) ans += k++;
return ans;
}
}
```
* 时间复杂度:$O(a + b)$
* 空间复杂度:$O(1)$
---
### (优化)模拟
更进一步,每个完整周的起始日金额相比上周起始日金额多 $1$,同时周内每日金额递增 $1$,因此相邻完整周的金额之和也满足「等差」性质,可直接使用「等差数列求和」公式 $O(1)$ 求解完整周部分的金额之和;最后一周(若有)的金额也是同理。
代码:
```Java
class Solution {
public int totalMoney(int n) {
int a = n / 7, b = n % 7;
int a1 = (1 + 7) * 7 / 2, an = (a + (a + 6)) * 7 / 2;
int s1 = (a1 + an) * a / 2;
a++;
int s2 = (a + (a + b - 1)) * b / 2;
return s1 + s2;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1716` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1719. 重构一棵树的方案数（困难）.md | 1719. 重构一棵树的方案数 | https://leetcode-cn.com/problems/number-of-ways-to-reconstruct-a-tree/solution/gong-shui-san-xie-gou-zao-yan-zheng-he-f-q6fc/ | 困难 | [
"树"
] | 给你一个数组 `pairs`,其中 $pairs[i] = [x_i, y_i]$ ,并且满足:
* `pairs` 中没有重复元素
* $x_i < y_i$
令 ways 为满足下面条件的有根树的方案数:
* 树所包含的所有节点值都在 `pairs` 中。
* 一个数对 $[x_i, y_i]$ 出现在 `pairs` 中 当且仅当 $x_i$ 是 $y_i$ 的祖先或者 $y_i$ 是 $x_i$ 的祖先。
* 注意:构造出来的树不一定是二叉树。
两棵树被视为不同的方案当存在至少一个节点在两棵树中有不同的父节点。
请你返回:
* 如果 ways == 0 ,返回 0 。
* 如果 ways == 1 ,返回 1 。
* 如果 ways > 1 ,返回 2 。
一棵 有根树 指的是只有一个根节点的树,所有边都是从根往外的方向。
我们称从根到一个节点路径上的任意一个节点(除去节点本身)都是该节点的 祖先 。根节点没有祖先。
示例 1:
```
输入:pairs = [[1,2],[2,3]]
输出:1
解释:如上图所示,有且只有一个符合规定的有根树。
```
示例 2:
```
输入:pairs = [[1,2],[2,3],[1,3]]
输出:2
解释:有多个符合规定的有根树,其中三个如上图所示。
```
示例 3:
```
输入:pairs = [[1,2],[2,3],[2,4],[1,5]]
输出:0
解释:没有符合规定的有根树。
```
提示:
* $1 <= pairs.length <= 10^5$
* $1 <= xi < yi <= 500$
* `pairs` 中的元素互不相同。 | ### 构造 + 验证(合法性 + 非唯一性)
这道题是名副其实的困难题,我最早的提交时间是去年 $3$ 月,起初只能想到 $O(n * m)$ 的做法,对于一颗多叉树来说显然会 `TLE`,虽然到现在印象不深了,但如果不是之前做过,今天大概率会很晚才能发布题解。
该题突破口在于如何利用 `pairs` 构造出一种具体方案,然后辨别方案的合法性(是否返回 $0$)和方案中的某些点是否可相互替换(返回 $1$ 还是 $2$)。
给定 `pairs` 数组为父子关系,对于 $pairs[i] = (a,b)$ 而言,既可以是 $a$ 为 $b$ 祖宗节点,也可以是 $b$ 为 $a$ 祖宗节点。
题目的「当且仅当」含义为所有的 `pairs` 在具体方案中均有体现,因此先考虑如何使用 `pairs` 构造出具体方案。
如果使用一棵合法树而言:**每个子树的根节点在 `pairs` 中的出现数量满足大于等于其子节点在 `pairs` 中出现的数量(当某个根节点只有一个子节点时可取等号)。**
利用此性质,**虽然我们无法得知某个 $pairs[i]$ 真实的父子关系,但统计每个点的「度数」可以作为决策根节点的依据**。
具体的,遍历 `pairs` 并统计所有点的度数,同时为了后续构造可以快速查询某两个点是否为父子关系,使用邻接矩阵 $g$ 存储关系,并使用 `Set` 统计点集。
之后将点按照「度数」降序,从前往后处理每个点,尝试构建具体方案(第一个点作为具体方案的根节点)。
对于每个非根节点 $a$ 而言,按道理我们可以将其添加到任意一个「度数不小于 $cnt[i]$」且「与其存在父子关系的」$b$ 中,但这样构造方式,只能确保能够得到「合法性」的结果,会为对于后续的「非唯一性」验证带来巨大困难。
因此这里尝试构造的关键点在于:**我们为 $a$ 找 $b$ 的时候,应当找符合条件的、度数与 $a$ 相近的点。由于我们已经提前根据「度数」进行降序,这个找最优点的操作可从 $a$ 所在位置开始进行往回找,找到第一个满足「与 $a$ 存在父子关系」的点 $b$ 作为具体方案中 $a$ 的根节点。**
这样的构造逻辑为后续的「非唯一性」验证带来的好处是:**如果存在多个点能够相互交换位置的话,其在具体方案中必然为直接的父子关系,即我们能够通过判断 $cnts[i]$ 和 $cnts[fa[i]]$ 是否相等,来得知在具体方案中点 $i$ 和 $fa[i]$ 能够交换,并且如果能够交换,具体方案的合法性不会发生改变。**
> 一些细节:`pairs` 的数据范围为 $10^4$,而后续的尝试构造,最坏情况下点数也在这个数量级上,为了防止在复杂度为 $O(n^2)$ 的尝试构造上耗费大量时间,可以增加 $m < n - 1$ 的判断,在点数为 $n$ 的情况下,父子关系的最小值为 $n - 1$,当且仅当有一个根节点,其余均为叶子节点时取得,因此如果父子关系数量小于 $n - 1$,必然不为单棵子树,而是森林。
代码:
```Java
class Solution {
int N = 510;
int[] cnts = new int[N], fa = new int[N];
boolean[][] g = new boolean[N][N];
public int checkWays(int[][] pairs) {
int m = pairs.length;
Set<Integer> set = new HashSet<>();
for (int[] p : pairs) {
int a = p[0], b = p[1];
g[a][b] = g[b][a] = true;
cnts[a]++; cnts[b]++;
set.add(a); set.add(b);
}
List<Integer> list = new ArrayList<>(set);
Collections.sort(list, (a,b)->cnts[b]-cnts[a]);
int n = list.size(), root = list.get(0);
if (m < n - 1) return 0; // 森林
fa[root] = -1;
for (int i = 1; i < n; i++) {
int a = list.get(i);
boolean ok = false;
for (int j = i - 1; j >= 0 && !ok; j--) {
int b = list.get(j);
if (g[a][b]) {
fa[a] = b;
ok = true;
}
}
if (!ok) return 0;
}
int c = 0, ans = 1;
for (int i : set) {
int j = i;
while (fa[j] != -1) {
if (!g[i][fa[j]]) return 0;
if (cnts[i] == cnts[fa[j]]) ans = 2;
c++;
j = fa[j];
}
}
return c < m ? 0 : ans;
}
}
```
* 时间复杂度:令 $n$ 为 `pairs` 的长度,统计度数和点集复杂度为 $O(n)$;最多有 $2 * n$ 个点,将点根据度数进行排序复杂度为 $O(n\log{n})$;尝试根据度数构造树的复杂度为 $O(n^2)$;检验树的合法性复杂度为 $O(n + m)$,其中 $m$ 是构造树的边数,数量级上与 $n$ 相等。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1719` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1711-1720/1720. 解码异或后的数组（简单）.md | 1720. 解码异或后的数组 | https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/ | 简单 | [
"数学",
"模拟",
"位运算"
] | 未知 整数数组 arr 由 n 个非负整数组成。
经编码后变为长度为 n - 1 的另一个整数数组 encoded ,其中 encoded[i] = arr[i] XOR arr[i + 1] 。
例如,arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3] 。
给你编码后的数组 encoded 和原数组 arr 的第一个元素 first(arr[0])。
请解码返回原数组 arr 。
可以证明答案存在并且是唯一的。
示例 1:
```
输入:encoded = [1,2,3], first = 1
输出:[1,0,2,1]
解释:若 arr = [1,0,2,1] ,那么 first = 1 且 encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3]
```
示例 2:
```
输入:encoded = [6,2,7,3], first = 4
输出:[4,2,0,7,4]
```
提示:
* 2 <= n <= $10^4$
* encoded.length == n - 1
* 0 <= encoded[i] <= $10^5$
* 0 <= first <= $10^5$ | ### 模拟
这是道模拟(重拳出击)题。
根据题目给定的规则,利用如下异或性质从头做一遍即可:
1. 相同数值异或,结果为 $0$
2. 任意数值与 $0$ 进行异或,结果为数值本身
3. 异或本身满足交换律
已知 `encoded[i-1] = arr[i-1] XOR arr[i]`,将等式两边同时「异或」上 `arr[i-1]`。可得:
1. `encoded[i-1] XOR arr[i-1] = arr[i-1] XOR arr[i] XOR arr[i-1]`
2. 结合「性质三」和「性质一」,可化简「右式」得 `encoded[i-1] XOR arr[i-1] = arr[i] XOR 0`
3. 结合「性质二」,可化简「右式」得 `encoded[i-1] XOR arr[i-1] = arr[i]`
代码:
```Java
class Solution {
public int[] decode(int[] encoded, int first) {
int n = encoded.length + 1;
int[] ans = new int[n];
ans[0] = first;
for (int i = 1; i < n; i++) {
ans[i] = ans[i - 1] ^ encoded[i - 1];
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:构建与 `encoded` 同等规模的答案。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1720` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1721-1730/1723. 完成所有工作的最短时间（困难）.md | 1723. 完成所有工作的最短时间 | https://leetcode-cn.com/problems/find-minimum-time-to-finish-all-jobs/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-4epdd/ | 困难 | [
"DFS",
"模拟退火",
"启发式搜索",
"随机化"
] | 给你一个整数数组 `jobs` ,其中 $jobs[i]$ 是完成第 $i$ 项工作要花费的时间。
请你将这些工作分配给 $k$ 位工人。所有工作都应该分配给工人,且每项工作只能分配给一位工人。
工人的 工作时间 是完成分配给他们的所有工作花费时间的总和。
请你设计一套最佳的工作分配方案,使工人的 最大工作时间 得以 最小化 。
返回分配方案中尽可能「最小」的 最大工作时间 。
示例 1:
```
输入:jobs = [3,2,3], k = 3
输出:3
解释:给每位工人分配一项工作,最大工作时间是 3 。
```
示例 2:
```
输入:jobs = [1,2,4,7,8], k = 2
输出:11
解释:按下述方式分配工作:
1 号工人:1、2、8(工作时间 = 1 + 2 + 8 = 11)
2 号工人:4、7(工作时间 = 4 + 7 = 11)
最大工作时间是 11 。
```
提示:
* $1 <= k <= jobs.length <= 12$
* $1 <= jobs[i] <= 10^7$ | ### DFS(TLE)
一看数据范围只有 $12$,我猜不少同学上来就想 `DFS`,但是注意 `n` 和 `k` 同等规模的,爆搜(`DFS`)的复杂度是 $O(k^n)$ 的。
那么极限数据下的计算量为 $12^{12}$,远超运算量 $10^7$。
抱着侥幸的心理一运行,很顺利的卡在了 $43/60$ 个数据:
```Java
[254,256,256,254,251,256,254,253,255,251,251,255] // n = 12
10 // k = 10
```
代码:
```Java
class Solution {
int[] jobs;
int n, k;
int ans = 0x3f3f3f3f;
public int minimumTimeRequired(int[] _jobs, int _k) {
jobs = _jobs;
n = jobs.length;
k = _k;
int[] sum = new int[k];
dfs(0, sum, 0);
return ans;
}
/**
* u : 当前处理到那个 job
* sum : 工人的分配情况 例如:sum[0] = x 代表 0 号工人工作量为 x
* max : 当前的「最大工作时间」
*/
void dfs(int u, int[] sum, int max) {
if (max >= ans) return;
if (u == n) {
ans = max;
return;
}
for (int i = 0; i < k; i++) {
sum[i] += jobs[u];
dfs(u + 1, sum, Math.max(sum[i], max));
sum[i] -= jobs[u];
}
}
}
```
* 时间复杂度:$O(k^n)$
* 空间复杂度:$O(k)$
---
### 优先分配「空闲工人」的 DFS
那么 `DFS` 就没法过了吗?
除了 `max >= ans` 以外,我们还要做些别的剪枝吗?
我们可以重新审视一下这道题。
**题目其实是让我们将 $n$ 个数分为 $k$ 份,并且尽可能让 $k$ 份平均。这样的「最大工作时间」才是最小的。**
但在朴素的 `DFS` 中,我们是将每个任务依次分给每个工人,并递归此过程。
**对应的递归树其实是一颗高度为 $n$ 的 $k$ 阶树。**
所以其实我们第一次更新的 `ans` 其实是「最差」的答案(所有的任务都会分配给 $0$ 号工人),最差的 `ans` 为所有的 `job` 的总和(带编号的方块代表工人):
因此我们朴素版的 `DFS` 其实是弱化了 `max >= ans` 剪枝效果的。
那么想要最大化剪枝效果,并且尽量让 $k$ 份平均的话,我们应当调整我们对于「递归树」的搜索方向:将任务优先分配给「空闲工人」(带编号的方块代表工人):
树还是那棵树,但是搜索调整分配优先级后,我们可以在首次取得一个「较好」的答案,来增强我们的 `max >= ans` 剪枝效益。
事实上,当做完这个调整,我们能实现从 TLE 到 99% 的提升 🤣 🤣
代码:
```Java
class Solution {
int[] jobs;
int n, k;
int ans = 0x3f3f3f3f;
public int minimumTimeRequired(int[] _jobs, int _k) {
jobs = _jobs;
n = jobs.length;
k = _k;
int[] sum = new int[k];
dfs(0, 0, sum, 0);
return ans;
}
/**
* 【补充说明】不理解可以看看下面的「我猜你问」的 Q5 哦 ~
*
* u : 当前处理到那个 job
* used : 当前分配给了多少个工人了
* sum : 工人的分配情况 例如:sum[0] = x 代表 0 号工人工作量为 x
* max : 当前的「最大工作时间」
*/
void dfs(int u, int used, int[] sum, int max) {
if (max >= ans) return;
if (u == n) {
ans = max;
return;
}
// 优先分配给「空闲工人」
if (used < k) {
sum[used] = jobs[u];
dfs(u + 1, used + 1, sum, Math.max(sum[used], max));
sum[used] = 0;
}
for (int i = 0; i < used; i++) {
sum[i] += jobs[u];
dfs(u + 1, used, sum, Math.max(sum[i], max));
sum[i] -= jobs[u];
}
}
}
```
* 时间复杂度:$O(k^n)$
* 空间复杂度:$O(k)$
---
### 模拟退火
事实上,这道题还能使用「模拟退火」进行求解。
**因为将 $n$ 个数划分为 $k$ 份,等效于用 $n$ 个数构造出一个「特定排列」,然后对「特定排列」进行固定模式的任务分配逻辑,就能实现「答案」与「最优排列」的对应关系。**
基于此,我们可以使用「模拟退火」进行求解。
单次迭代的基本流程:
1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」
2. 如果温度下降(交换后的序列更优),进入下一次迭代
3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)
> 对于一个能够运用模拟退火求解的问题,最核心的是如何实现 `calc` 方法(即如何定义一个具体方案的得分),其余均为模板内容。
代码:
```Java
class Solution {
int[] jobs;
int[] works = new int[20];
int n, k;
int ans = 0x3f3f3f3f;
Random random = new Random(20210508);
// 最高温/最低温/变化速率(以什么速度进行退火,系数越低退火越快,迭代次数越少,落入「局部最优」(WA)的概率越高;系数越高 TLE 风险越大)
double hi = 1e8, lo = 1e-4, fa = 0.90;
// 迭代次数,与变化速率同理
int N = 400;
// 计算当前 jobs 序列对应的最小「最大工作时间」是多少
int calc() {
Arrays.fill(works, 0);
for (int i = 0; i < n; i++) {
// [固定模式分配逻辑] : 每次都找最小的 worker 去分配
int idx = 0, cur = works[idx];
for (int j = 0; j < k; j++) {
if (works[j] < cur) {
cur = works[j];
idx = j;
}
}
works[idx] += jobs[i];
}
int cur = 0;
for (int i = 0; i < k; i++) cur = Math.max(cur, works[i]);
ans = Math.min(ans, cur);
return cur;
}
void shuffle(int[] nums) {
for (int i = n; i > 0; i--) {
int idx = random.nextInt(i);
swap(nums, idx, i - 1);
}
}
void swap(int[] arr, int i, int j) {
int c = arr[i];
arr[i] = arr[j];
arr[j] = c;
}
void sa() {
shuffle(jobs);
for (double t = hi; t > lo; t *= fa) {
int a = random.nextInt(n), b = random.nextInt(n);
int prev = calc(); // 退火前
swap(jobs, a, b);
int cur = calc(); // 退火后
int diff = cur - prev;
// 退火为负收益(温度上升),以一定概率回退现场
if (Math.log(diff / t) > random.nextDouble()) swap(jobs, a, b);
}
}
public int minimumTimeRequired(int[] _jobs, int _k) {
jobs = _jobs;
n = jobs.length;
k = _k;
while (N-- > 0) sa();
return ans;
}
}
```
* 时间复杂度:启发式搜索不讨论时空复杂度
* 空间复杂度:启发式搜索不讨论时空复杂度
---
### 我猜你问
**Q0. 模拟退火有何风险?**
随机算法,会面临 `WA` 和 `TLE` 风险。
**Q1. 模拟退火中的参数如何敲定的?**
根据经验猜的,然后提交。根据结果是 `WA` 还是 `TLE` 来决定之后的调参方向。如果是 `WA` 说明部分数据落到了「局部最优」或者尚未达到「全局最优」。
**Q2. 参数如何调整?**
如果是 `WA` 了,一般我是优先调大 fa 参数,使降温变慢,来变相增加迭代次数;如果是 `TLE` 了,一般是优先调小 fa 参数,使降温变快,减小迭代次数。总迭代参数 `N` 也是同理。
可以简单理解调大 fa 代表将「大步」改为「baby step」,防止越过全局最优,同时增加总执行步数。
可以结合我不同的 fa 参数的提交结果来感受下:
**Q3. 关于「模拟退火」正确性?**
随机种子不变,测试数据不变,迭代参数不变,那么退火的过程就是恒定的,必然都能找到这些测试样例的「全局最优」。
**Q4. 需要掌握「模拟退火」吗?**
还是那句话,特别特别特别有兴趣的可以去了解一下。
但绝对是在你已经彻底理解「剪枝 DFS」和我没写的「状态压缩 DP」之后再去了解。
**Q5. 在「剪枝 DFS」中为什么「优先分配空闲工人」的做法是对的?**
首先要明确,递归树还是那棵递归树。
**所谓的「优先分配空闲工人」它并不是「贪心模拟」思路,而只是一个「调整搜索顺序」的做法。**
「优先分配空闲工人」不代表不会将任务分配给有工作的工人,仅仅代表我们先去搜索那些「优先分配空闲工人」的方案。
然后将得到的「合法解」配合 `max >= ans` 去剪枝掉那些「必然不是最优解」的方案。
**本质上,我们并没有主动的否决某些方案(也就是我们并没有改动递归树),我们只是调整了搜索顺序来剪枝掉了一些「必然不是最优」的搜索路径。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1723` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1721-1730/1725. 可以形成最大正方形的矩形数目（简单）.md | 1725. 可以形成最大正方形的矩形数目 | https://leetcode-cn.com/problems/number-of-rectangles-that-can-form-the-largest-square/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-7756/ | 简单 | [
"模拟"
] | 给你一个数组 `rectangles`,其中 $rectangles[i] = [l_i, w_i]$ 表示第 $i$ 个矩形的长度为 $l_i$ 、宽度为 $w_i$ 。
如果存在 `k` 同时满足 $k <= l_i$ 和 $k <= w_i$ ,就可以将第 `i` 个矩形切成边长为 `k` 的正方形。例如,矩形 $[4,6]$ 可以切成边长最大为 $4$ 的正方形。
设 `maxLen` 为可以从矩形数组 `rectangles` 切分得到的 最大正方形 的边长。
请你统计有多少个矩形能够切出边长为 `maxLen` 的正方形,并返回矩形 数目 。
示例 1:
```
输入:rectangles = [[5,8],[3,9],[5,12],[16,5]]
输出:3
解释:能从每个矩形中切出的最大正方形边长分别是 [5,3,5,5] 。
最大正方形的边长为 5 ,可以由 3 个矩形切分得到。
```
示例 2:
```
输入:rectangles = [[2,3],[3,7],[4,3],[3,7]]
输出:3
```
提示:
* $1 <= rectangles.length <= 1000$
* $rectangles[i].length == 2$
* $1 <= li, wi <= 10^9$
* $li != wi$ | ### 模拟
根据题意,对于任意一个矩形 $rectangles[i]$ 而言,其能分割出的最大方形边长为 $\min(rectangles[i][0], rectangles[i][1])$。
我们在遍历过程中使用变量 `max` 维护最大边长,同时使用 `ans` 记录能够分割出最大边长 `max` 的矩形数量。
代码:
```Java
class Solution {
public int countGoodRectangles(int[][] rectangles) {
int max = 0, ans = 0;
for (int[] r : rectangles) {
int cur = Math.min(r[0], r[1]);
if (cur == max) ans++;
else if (cur > max) {
max = cur; ans = 1;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1725` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1721-1730/1728. 猫和老鼠 II（困难）.md | 1728. 猫和老鼠 II | https://leetcode.cn/problems/cat-and-mouse-ii/solution/by-ac_oier-gse8/ | 困难 | [
"博弈论",
"动态规划",
"记忆化搜索"
] | 一只猫和一只老鼠在玩一个叫做猫和老鼠的游戏。
它们所处的环境设定是一个 `rows x cols` 的方格 `grid` ,其中每个格子可能是一堵墙、一块地板、一位玩家(猫或者老鼠)或者食物。
* 玩家由字符 `'C'` (代表猫)和 `'M'` (代表老鼠)表示。
* 地板由字符 `'.'` 表示,玩家可以通过这个格子。
* 墙用字符 `'#'` 表示,玩家不能通过这个格子。
* 食物用字符 `'F'` 表示,玩家可以通过这个格子。
* 字符 `'C'` , `'M'` 和 `'F'` 在 `grid` 中都只会出现一次。
猫和老鼠按照如下规则移动:
* 老鼠 先移动 ,然后两名玩家轮流移动。
* 每一次操作时,猫和老鼠可以跳到上下左右四个方向之一的格子,他们不能跳过墙也不能跳出 grid 。
* `catJump` 和 `mouseJump` 是猫和老鼠分别跳一次能到达的最远距离,它们也可以跳小于最大距离的长度。
* 它们可以停留在原地。
* 老鼠可以跳跃过猫的位置。
游戏有 $4$ 种方式会结束:
* 如果猫跟老鼠处在相同的位置,那么猫获胜。
* 如果猫先到达食物,那么猫获胜。
* 如果老鼠先到达食物,那么老鼠获胜。
* 如果老鼠不能在 $1000$ 次操作以内到达食物,那么猫获胜。
给你 `rows x cols` 的矩阵 `grid` 和两个整数 `catJump` 和 `mouseJump`,双方都采取最优策略,如果老鼠获胜,那么请你返回 `true`,否则返回 `false`。
示例 1:
```
输入:grid = ["####F","#C...","M...."], catJump = 1, mouseJump = 2
输出:true
解释:猫无法抓到老鼠,也没法比老鼠先到达食物。
```
示例 2:
```
输入:grid = ["M.C...F"], catJump = 1, mouseJump = 4
输出:true
```
示例 3:
```
输入:grid = ["M.C...F"], catJump = 1, mouseJump = 3
输出:false
```
示例 4:
```
输入:grid = ["C...#","...#F","....#","M...."], catJump = 2, mouseJump = 5
输出:false
```
示例 5:
```
输入:grid = [".M...","..#..","#..#.","C#.#.","...#F"], catJump = 3, mouseJump = 1
输出:true
```
提示:
* $rows == grid.length$
* $cols = grid[i].length$
* $1 <= rows, cols <= 8$
* $grid[i][j]$ 只包含字符 `'C'` ,`'M'` ,`'F'` ,`'.'` 和 `'#'` 。
* `grid` 中只包含一个 `'C'` ,`'M'` 和 `'F'` 。
* $1 <= catJump, mouseJump <= 8$ | ### 博弈论 DP
当时在 [(题解) 913. 猫和老鼠](https://leetcode.cn/problems/cat-and-mouse/solution/gong-shui-san-xie-dong-tai-gui-hua-yun-y-0bx1/) 没能证出来更小 $K$ 值(回合数)的正确性,用的 $2n^2$ 做的 ,其余题解说 $2 n$ 合法,后来也被证实是错误的。
对于本题如果用相同的分析思路,状态数多达 $8 \times 8 \times 8 \times 8 \times 2 = 8192$ 种,题目很贴心调整了规则为 $1000$ 步以内为猫获胜,但证明 $K$ 的理论上界仍是困难(上次分析不出来,这次压根不想分析
如果忽略 $K$ 值分析,代码还是很好写的:定义函数 `int dfs(int x, int y, int p, int q, int k)` 并配合记忆化搜索,其中鼠位于 $(x, y)$,猫位于 $(p, q)$,当前轮数为 $k$(由 $k$ 的奇偶性可知是谁的回合)。
对边界情况进行讨论,移动过程中按照规则进行(四联通,移动最大距离为 `mouseJump` 和 `catJump`),注意一旦遇到边界或者墙就要截断。
Java 使用静态数组,用一个 `int` 代表双方所在位置,最大回合数 $K = 1000$,`2022-05-10` 可以过。这道题给的时间上限很高,我调整为 $K = 1500$ 跑成 $2.5s$ 也可以过。本来想要加个卡常,每 $200$ 轮检查一下运行总时长,尽量将时间压在 $850ms$ 以内,现在看来好像用不到。
代码:
```Java
import java.time.Clock;
class Solution {
static int S = 8 * 8 * 8 * 8, K = 1000;
static int[][] f = new int[S][K]; // mouse : 0 / cat : 1
String[] g;
int n, m, a, b, tx, ty;
int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};
// mouse : (x, y) / cat : (p, q)
int dfs(int x, int y, int p, int q, int k) {
int state = (x << 9) | (y << 6) | (p << 3) | q;
if (k == K - 1) return f[state][k] = 1;
if (x == p && y == q) return f[state][k] = 1;
if (x == tx && y == ty) return f[state][k] = 0;
if (p == tx && q == ty) return f[state][k] = 1;
if (f[state][k] != -1) return f[state][k];
if (k % 2 == 0) { // mouse
for (int[] di : dirs) {
for (int i = 0; i <= b; i++) {
int nx = x + di[0] * i, ny = y + di[1] * i;
if (nx < 0 || nx >= n || ny < 0 || ny >= m) break;
if (g[nx].charAt(ny) == '#') break;
if (dfs(nx, ny, p, q, k + 1) == 0) return f[state][k] = 0;
}
}
return f[state][k] = 1;
} else { // cat
for (int[] di : dirs) {
for (int i = 0; i <= a; i++) {
int np = p + di[0] * i, nq = q + di[1] * i;
if (np < 0 || np >= n || nq < 0 || nq >= m) break;
if (g[np].charAt(nq) == '#') break;
if (dfs(x, y, np, nq, k + 1) == 1) return f[state][k] = 1;
}
}
return f[state][k] = 0;
}
}
public boolean canMouseWin(String[] grid, int catJump, int mouseJump) {
g = grid;
n = g.length; m = g[0].length(); a = catJump; b = mouseJump;
for (int i = 0; i < S; i++) Arrays.fill(f[i], -1);
int x = 0, y = 0, p = 0, q = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i].charAt(j) == 'M') {
x = i; y = j;
} else if (g[i].charAt(j) == 'C') {
p = i; q = j;
} else if (g[i].charAt(j) == 'F') {
tx = i; ty = j;
}
}
}
return dfs(x, y, p, q, 0) == 0;
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别为矩阵的长宽,最长移动距离为 $L$,复杂度为 $O(n^2 \times m^2 \times 1000 \times 4 \times L)$
* 空间复杂度:$O(n^2 \times m^2 \times 1000)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1728` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1732. 找到最高海拔（简单）.md | 1732. 找到最高海拔 | https://leetcode.cn/problems/find-the-highest-altitude/solution/by-ac_oier-a0j8/ | 简单 | [
"模拟"
] | 有一个自行车手打算进行一场公路骑行,这条路线总共由 $n + 1$ 个不同海拔的点组成。自行车手从海拔为 `0` 的点 `0` 开始骑行。
给你一个长度为 `n` 的整数数组 `gain`,其中 `gain[i]` 是点 `i` 和点 `i + 1` 的 净海拔高度差($0 <= i < n$)。请你返回 最高点的海拔 。
示例 1:
```
输入:gain = [-5,1,5,0,-7]
输出:1
解释:海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
```
示例 2:
```
输入:gain = [-4,-3,-2,-1,4,3,2]
输出:0
解释:海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。
```
提示:
* $n = gain.length$
* $1 <= n <= 100$
* $-100 <= gain[i] <= 100$ | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int largestAltitude(int[] g) {
int cur = 0, ans = 0;
for (int x : g) {
cur += x;
ans = Math.max(ans, cur);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function largestAltitude(g: number[]): number {
let cur = 0, ans = 0
for (let x of g) {
cur += x
ans = Math.max(ans, cur)
}
return ans
}
```
Python3 代码:
```Python
class Solution:
def largestAltitude(self, g: List[int]) -> int:
cur, ans = 0, 0
for x in g:
cur += x
ans = max(ans, cur)
return ans
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1732` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1734. 解码异或后的排列（中等）.md | 1734. 解码异或后的排列 | https://leetcode-cn.com/problems/decode-xored-permutation/solution/gong-shui-san-xie-note-bie-pian-li-yong-zeh6o/ | 中等 | [
"数学",
"异或"
] | 给你一个整数数组 perm ,它是前 n 个正整数的排列,且 n 是个 奇数 。
它被加密成另一个长度为 n - 1 的整数数组 encoded ,满足 encoded[i] = perm[i] XOR perm[i + 1] 。比方说,如果 perm = [1,3,2] ,那么 encoded = [2,1] 。
给你 encoded 数组,请你返回原始数组 perm 。题目保证答案存在且唯一。
示例 1:
```
输入:encoded = [3,1]
输出:[1,2,3]
解释:如果 perm = [1,2,3] ,那么 encoded = [1 XOR 2,2 XOR 3] = [3,1]
```
示例 2:
```
输入:encoded = [6,5,4,6]
输出:[2,4,1,5,3]
```
提示:
* 3 <= n < $10^5$
* n 是奇数。
* encoded.length == n - 1 | ### 基本分析
我们知道异或运算有如下性质:
1. 相同数值异或,结果为 $0$
2. 任意数值与 $0$ 进行异或,结果为数值本身
3. 异或本身满足交换律
本题与 [1720. 解码异或后的数组](https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/) 的主要区别是没有给出首位元素。
因此,求得答案数组的「首位元素」或者「结尾元素」可作为本题切入点。
---
### 数学 & 模拟
我们定义答案数组为 `ans[]`,`ans[]` 数组的长度为 `n`,且 `n` 为奇数。
即有 $[ans[0], ans[1], ans[2], ... , ans[n - 1]]$。
给定的数组 `encoded[]` 其实是 $[ans[0] ⊕ ans[1], ans[1] ⊕ ans[2], ... , ans[n - 3] ⊕ ans[n - 2], ans[n - 2] ⊕ ans[n - 1]]$,长度为 `n - 1`。
由于每相邻一位会出现相同的数组成员 `ans[x]`,考虑“每隔一位”进行异或:
1. **从 `encoded[]` 的第 $0$ 位开始,每隔一位进行异或:可得 $ans[0] ⊕ ans[1] ⊕ ... ⊕ ans[n - 2]$,即除了 `ans[]` 数组中的 $ans[n - 1]$ 以外的所有异或结果。**
2. **利用 `ans[]` 数组是 `n` 个正整数的排列,我们可得 $ans[0] ⊕ ans[1] ⊕ ... ⊕ ans[n - 2] ⊕ ans[n - 1]$,即 `ans[]` 数组中所有元素的异或结果。**
将两式进行「异或」,可得 $ans[n - 1]$。
有了结尾元素后,问题变为与 [1720. 解码异或后的数组](https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/) 类似的模拟题。
代码:
```Java
class Solution {
public int[] decode(int[] encoded) {
int n = encoded.length + 1;
int[] ans = new int[n];
// 求得除了 ans[n - 1] 的所有异或结果
int a = 0;
for (int i = 0; i < n - 1; i += 2) a ^= encoded[i];
// 求得 ans 的所有异或结果
int b = 0;
for (int i = 1; i <= n; i++) b ^= i;
// 求得 ans[n - 1] 后,从后往前做
ans[n - 1] = a ^ b;
for (int i = n - 2; i >= 0; i--) {
ans[i] = encoded[i] ^ ans[i + 1];
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:构建同等数量级的答案数组。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1734` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1736. 替换隐藏数字得到的最晚时间（简单）.md | 1736. 替换隐藏数字得到的最晚时间 | https://leetcode-cn.com/problems/latest-time-by-replacing-hidden-digits/solution/gong-shui-san-xie-ti-huan-yin-cang-shu-z-2l1h/ | 简单 | [
"贪心"
] | 给你一个字符串 `time`,格式为 `hh:mm`(小时:分钟),其中某几位数字被隐藏(用 `?` 表示)。
有效的时间为 `00:00` 到 `23:59` 之间的所有时间,包括 `00:00` 和 `23:59` 。
替换 `time` 中隐藏的数字,返回你可以得到的最晚有效时间。
示例 1:
```
输入:time = "2?:?0"
输出:"23:50"
解释:以数字 '2' 开头的最晚一小时是 23 ,以 '0' 结尾的最晚一分钟是 50 。
```
示例 2:
```
输入:time = "0?:3?"
输出:"09:39"
```
示例 3:
```
输入:time = "1?:22"
输出:"19:22"
```
提示:
* `time` 的格式为 `hh:mm`
* 题目数据保证你可以由输入的字符串生成有效的时间 | ### 贪心 + 模拟
规则十分简单,对每一位进行分情况讨论即可:
* 第一位:如果需要被替换,优先替换为 `2`,当然前提是第二位不能超过 `4`。否则会出现 `24:xx`、`25:xx` 等;
* 第二位:如果需要被替换,根据第一位是什么,决定替换为 `9` 还是 `3`;
* 第三位:固定为 `:`;
* 第四位:如果需要被替换,替换为 `5`;
* 第五位:如果需要被替换,替换为 `9`。
代码:
```Java
class Solution {
public String maximumTime(String time) {
StringBuilder sb = new StringBuilder();
sb.append(time.charAt(0) == '?' ? (time.charAt(1) == '?' || time.charAt(1) < '4') ? '2' : '1' : time.charAt(0));
sb.append(time.charAt(1) == '?' ? sb.charAt(0) == '2' ? '3' : '9' : time.charAt(1));
sb.append(':');
sb.append(time.charAt(3) == '?' ? '5' : time.charAt(3));
sb.append(time.charAt(4) == '?' ? '9' : time.charAt(4));
return sb.toString();
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1737. 满足三条件之一需改变的最少字符数（中等）.md | 1737. 满足三条件之一需改变的最少字符数 | https://leetcode.cn/problems/change-minimum-characters-to-satisfy-one-of-three-conditions/solution/by-ac_oier-vs5u/ | 中等 | [
"枚举",
"计数",
"模拟"
] | 给你两个字符串 `a` 和 `b` ,二者均由小写字母组成。
一步操作中,你可以将 `a` 或 `b` 中的 任一字符 改变为 任一小写字母 。
操作的最终目标是满足下列三个条件 之一 :
* `a` 中的 每个字母 在字母表中 **严格小于** `b` 中的 每个字母 。
* `b` 中的 每个字母 在字母表中 **严格小于** `a` 中的 每个字母 。
* `a` 和 `b` 都 由 同一个 字母组成。
返回达成目标所需的 最少 操作数。
示例 1:
```
输入:a = "aba", b = "caa"
输出:2
解释:满足每个条件的最佳方案分别是:
1) 将 b 变为 "ccc",2 次操作,满足 a 中的每个字母都小于 b 中的每个字母;
2) 将 a 变为 "bbb" 并将 b 变为 "aaa",3 次操作,满足 b 中的每个字母都小于 a 中的每个字母;
3) 将 a 变为 "aaa" 并将 b 变为 "aaa",2 次操作,满足 a 和 b 由同一个字母组成。
最佳的方案只需要 2 次操作(满足条件 1 或者条件 3)。
```
示例 2:
```
输入:a = "dabadd", b = "cda"
输出:3
解释:满足条件 1 的最佳方案是将 b 变为 "eee" 。
```
提示:
* $1 <= a.length, b.length <= 10^5$
* `a` 和 `b` 只由小写字母组成 | ### 计数 + 枚举
使用 `c1` 和 `c2` 对字符串 `a` 和 `b` 分别进行词频统计,记字符串 `a` 和 `b` 的长度为 $n$ 和 $m$。
然后枚举字符 $i$,分别对三种情况的修改次数进行统计:
1. 对应条件 $1$:目的是要将字符串 `a` 中所有的字符变得「严格小于」字符 $i$,将字符串 `b` 中的所有字符变成「不小于/大于等于」字符 $i$。
这可以分别统计 `a` 中大小满足「大于等于」字符 $i$ 的字符数量,以及 `b` 中大小满足「小于」字符 $i$ 数量,两者之和即是满足该条件的最小修改次数。
注意,当 $i = 0$(含义为枚举到小写字母 $a$)时,需要跳过,因为不存在值大小「严格小于」字母 $a$ 的字符,即无法做到将某个字符串替换成所有字符都「严格小于」字母 $a$;
2. 对应条件 $2$:与条件 $1$ 同理;
3. 对应条件 $3$:如果要将两字符的所有字符都变成 $i$,其中字符串 `a` 要修改的字符数为 $ca = n - c1[i]$,字符串 `b` 要修改的字符数为 $cb = m - c2[i]$,总修改次数为 $ca + cb$。
枚举完所有的字符 $i$ 后,统计到的所有修改次数的最小值即是答案。
代码:
```Java
class Solution {
public int minCharacters(String a, String b) {
int n = a.length(), m = b.length(), ans = 0x3f3f3f3f;
int[] c1 = new int[26], c2 = new int[26];
for (char c : a.toCharArray()) c1[c - 'a']++;
for (char c : b.toCharArray()) c2[c - 'a']++;
for (int i = 0; i < 26 && ans != 0; i++) {
// 3
int ca = n - c1[i], cb = m - c2[i];
ans = Math.min(ans, ca + cb);
if (i == 0) continue;
int r1 = 0, r2 = 0;
// 1
for (int j = i; j < 26; j++) r1 += c1[j];
for (int j = 0; j < i; j++) r1 += c2[j];
// 2
for (int j = i; j < 26; j++) r2 += c2[j];
for (int j = 0; j < i; j++) r2 += c1[j];
ans = Math.min(ans, Math.min(r1, r2));
}
return ans;
}
}
```
* 时间复杂度:统计词频的复杂度为 $O(n + m)$,统计答案的复杂度为 $O(C^2)$,其中 $C = 26$ 为字符集大小
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1737` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1731-1740/1738. 找出第 K 大的异或坐标值（中等）.md | 1738. 找出第 K 大的异或坐标值 | https://leetcode-cn.com/problems/find-kth-largest-xor-coordinate-value/solution/gong-shui-san-xie-xiang-jie-li-yong-er-w-ai0d/ | 中等 | [
"Top K",
"数学",
"前缀和"
] | 给你一个二维矩阵 matrix 和一个整数 k ,矩阵大小为 m x n 由非负整数组成。
矩阵中坐标 (a, b) 的 值 可由对所有满足 0 <= i <= a < m 且 0 <= j <= b < n 的元素 matrix[i][j](下标从 0 开始计数)执行异或运算得到。
请你找出 matrix 的所有坐标中第 k 大的值(k 的值从 1 开始计数)。
示例 1:
```
输入:matrix = [[5,2],[1,6]], k = 1
输出:7
解释:坐标 (0,1) 的值是 5 XOR 2 = 7 ,为最大的值。
```
示例 2:
```
输入:matrix = [[5,2],[1,6]], k = 2
输出:5
解释:坐标 (0,0) 的值是 5 = 5 ,为第 2 大的值。
```
示例 3:
```
输入:matrix = [[5,2],[1,6]], k = 3
输出:4
解释:坐标 (1,0) 的值是 5 XOR 1 = 4 ,为第 3 大的值。
```
示例 4:
```
输入:matrix = [[5,2],[1,6]], k = 4
输出:0
解释:坐标 (1,1) 的值是 5 XOR 2 XOR 1 XOR 6 = 0 ,为第 4 大的值。
```
提示:
* m == matrix.length
* n == matrix[i].length
* 1 <= m, n <= 1000
* 0 <= `matrix[i][j]` <= $10^6$
* 1 <= k <= m * n | ### 基本分析
根据题意,我们知道其实就是求「所有子矩阵中第 $k$ 大的异或和」,同时规定所有子矩阵的左上角端点为 $(0, 0)$。
数据范围为 $10^3$,因此「枚举所有右下角」并「每次计算子矩阵异或和」的朴素做法 $O(m^2 * n^2)$ 不用考虑。
要在全局中找最优,「枚举所有右下角」过程不可避免,我们可以优化「每次计算子矩阵异或和」的过程。
这个分析过程与 [1310. 子数组异或查询](https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/) 类似。
**异或作为不进位加法,可以利用「偶数次异或结果为 $0$」的特性实现类似「前缀和」的容斥。这使得我们可以在 $O(1)$ 的复杂度内计算「某个子矩阵的异或和」。**
---
### 二维前缀异或 & 优先队列(堆)
创建二维数组 $sum[][]$,令 $sum[i][j]$ 为以 $(i, j)$ 为右下角的子矩阵的异或和,我们可以得出计算公式:
$$
sum[i][j] = sum[i - 1][j] ⊕ sum[i][j - 1] ⊕ sum[i - 1][j - 1] ⊕ matrix[i - 1][j - 1]
$$
剩下的问题是,如果从所有的「子矩阵异或和」找到第 $k$ 大的值。
变成了 [Top K](https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/solution/jian-da-ti-de-duo-chong-jie-fa-mou-pao-p-d1qi/) 问题,可以使用「排序」或「堆」进行求解。
具体的,我们可以建立一个大小为 $k$ 的小根堆,在计算二维前缀异或时,判断当前「子矩阵异或和」是否大于堆顶元素:
* 大于堆顶元素:当前子矩阵异或和可能是第 $k$ 大的值,堆顶元素不可能为第 $k$ 大的值。将堆顶元素弹出,并将当前子矩阵和加入堆中
* 小于堆顶元素:不会是第 $k$ 大的值,直接丢弃。
* 等于堆顶元素:有相同元素在堆中,直接丢弃。
最终的堆顶元素即为答案。
代码:
```Java
class Solution {
public int kthLargestValue(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
int[][] sum = new int[m + 1][n + 1];
PriorityQueue<Integer> q = new PriorityQueue<>(k, (a, b)->a - b);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i - 1][j] ^ sum[i][j - 1] ^ sum[i - 1][j - 1] ^ mat[i - 1][j - 1];
if (q.size() < k) {
q.add(sum[i][j]);
} else {
if (sum[i][j] > q.peek()) {
q.poll();
q.add(sum[i][j]);
}
}
}
}
return q.peek();
}
}
```
* 时间复杂度:$O(m * n * \log{k})$
* 空间复杂度:$O(m * n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1738` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1742. 盒子中小球的最大数量（简单）.md | 1742. 盒子中小球的最大数量 | https://leetcode.cn/problems/maximum-number-of-balls-in-a-box/solution/by-ac_oier-3mxf/ | 简单 | [
"哈希表",
"模拟"
] | 你在一家生产小球的玩具厂工作,有 `n` 个小球,编号从 `lowLimit` 开始,到 `highLimit` 结束(包括 `lowLimit` 和 `highLimit` ,即 `n == highLimit - lowLimit + 1`)。另有无限数量的盒子,编号从 `1` 到 `infinity` 。
你的工作是将每个小球放入盒子中,其中盒子的编号应当等于小球编号上每位数字的和。例如,编号 `321` 的小球应当放入编号 `3 + 2 + 1 = 6` 的盒子,而编号 `10` 的小球应当放入编号 `1 + 0 = 1` 的盒子。
给你两个整数 `lowLimit` 和 `highLimit` ,返回放有最多小球的盒子中的小球数量。如果有多个盒子都满足放有最多小球,只需返回其中任一盒子的小球数量。
示例 1:
```
输入:lowLimit = 1, highLimit = 10
输出:2
解释:
盒子编号:1 2 3 4 5 6 7 8 9 10 11 ...
小球数量:2 1 1 1 1 1 1 1 1 0 0 ...
编号 1 的盒子放有最多小球,小球数量为 2 。
```
示例 2:
```
输入:lowLimit = 5, highLimit = 15
输出:2
解释:
盒子编号:1 2 3 4 5 6 7 8 9 10 11 ...
小球数量:1 1 1 1 2 2 1 1 1 0 0 ...
编号 5 和 6 的盒子放有最多小球,每个盒子中的小球数量都是 2 。
```
示例 3:
```
输入:lowLimit = 19, highLimit = 28
输出:2
解释:
盒子编号:1 2 3 4 5 6 7 8 9 10 11 12 ...
小球数量:0 1 1 1 1 1 1 1 1 2 0 0 ...
编号 10 的盒子放有最多小球,小球数量为 2 。
```
提示:
* $1 <= lowLimit <= highLimit <= 10^5$ | ### 模拟
数据范围 $n = 1e5$,因此最大盒子编号 `99999 = 5 * 9 = 45`,我们可以用一个大小为 $50$ 的数组 `cnts` 来统计每个编号盒子中小球的数量,$cnts[idx] = x$ 含义为编号为 $idx$ 的盒子有 $x$ 个小球。
Java 代码:
```Java
class Solution {
public int countBalls(int l, int r) {
int ans = 0;
int[] cnts = new int[50];
for (int i = l; i <= r; i++) {
int j = i, cur = 0;
while (j != 0) {
cur += j % 10; j /= 10;
}
if (++cnts[cur] > ans) ans = cnts[cur];
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function countBalls(l: number, r: number): number {
let ans = 0
const cnts = new Array<number>(50).fill(0)
for (let i = l; i <= r; i++) {
let j = i, cur = 0
while (j != 0) {
cur += j % 10
j = Math.floor(j / 10)
}
if (++cnts[cur] > ans) ans = cnts[cur]
}
return ans
}
```
Python 代码:
```Python
class Solution:
def countBalls(self, l: int, r: int) -> int:
ans = 0
cnts = [0] * 50
for i in range(l, r + 1):
j, cur = i, 0
while j != 0:
j, cur = j // 10, cur + j % 10
cnts[cur] += 1
if cnts[cur] > ans:
ans = cnts[cur]
return ans
```
* 时间复杂度:$O(n\log{r})$
* 空间复杂度:$O(C)$,其中 $C = 50$ 为最大盒子编号 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1742` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1743. 从相邻元素对还原数组（中等）.md | 1743. 从相邻元素对还原数组 | https://leetcode-cn.com/problems/restore-the-array-from-adjacent-pairs/solution/gong-shui-san-xie-yi-ti-shuang-jie-dan-x-elpx/ | 中等 | [
"哈希表",
"双指针",
"模拟"
] | 存在一个由 `n` 个不同元素组成的整数数组 `nums` ,但你已经记不清具体内容,好在你还记得 `nums` 中的每一对相邻元素。
给你一个二维整数数组 `adjacentPairs` ,大小为 `n - 1` ,其中每个 $adjacentPairs[i] = [u_i, v_i]$ 表示元素 $u_i$ 和 $v_i$ 在 `nums` 中相邻。
题目数据保证所有由元素 `nums[i]` 和 `nums[i+1]` 组成的相邻元素对都存在于 `adjacentPairs` 中,存在形式可能是 `[nums[i], nums[i+1]]` ,也可能是 `[nums[i+1], nums[i]]` 。这些相邻元素对可以「按任意顺序」出现。
返回原始数组 `nums` 。如果存在多种解答,返回其中任意一个即可。
示例 1:
```
输入:adjacentPairs = [[2,1],[3,4],[3,2]]
输出:[1,2,3,4]
解释:数组的所有相邻元素对都在 adjacentPairs 中。
特别要注意的是,adjacentPairs[i] 只表示两个元素相邻,并不保证其 左-右 顺序。
```
示例 2:
```
输入:adjacentPairs = [[4,-2],[1,4],[-3,1]]
输出:[-2,4,1,-3]
解释:数组中可能存在负数。
另一种解答是 [-3,1,4,-2] ,也会被视作正确答案。
```
示例 3:
```
输入:adjacentPairs = [[100000,-100000]]
输出:[100000,-100000]
```
提示:
* $nums.length == n$
* $adjacentPairs.length == n - 1$
* $adjacentPairs[i].length == 2$
* $2 <= n <= 10^5$
* $-10^5 <= nums[i], u_i, v_i <= 10^5$
* 题目数据保证存在一些以 `adjacentPairs` 作为元素对的数组 | ### 单向构造(哈希表计数)
根据题意,由于所有的相邻关系都会出现在 $nums$ 中,假设其中一个合法数组为 $ans$,长度为 $n$。
那么显然 $ans[0]$ 和 $ans[n - 1]$ 在 $nums$ 中只存在一对相邻关系,而其他 $ans[i]$ 则存在两对相邻关系。
因此我们可以使用「哈希表」对 $nums$ 中出现的数值进行计数,找到“出现一次”的数值作为 $ans$ 数值的首位,然后根据给定的相邻关系进行「单向构造」,为了方便找到某个数其相邻的数是哪些,我们还需要再开一个「哈希表」记录相邻关系。
Java 代码:
```Java
class Solution {
public int[] restoreArray(int[][] adjacentPairs) {
int m = adjacentPairs.length, n = m + 1;
Map<Integer, Integer> cnts = new HashMap<>();
Map<Integer, List<Integer>> map = new HashMap<>();
for (int[] ap : adjacentPairs) {
int a = ap[0], b = ap[1];
cnts.put(a, cnts.getOrDefault(a, 0) + 1);
cnts.put(b, cnts.getOrDefault(b, 0) + 1);
List<Integer> alist = map.getOrDefault(a, new ArrayList<>());
alist.add(b);
map.put(a, alist);
List<Integer> blist = map.getOrDefault(b, new ArrayList<>());
blist.add(a);
map.put(b, blist);
}
int start = -1;
for (int i : cnts.keySet()) {
if (cnts.get(i) == 1) {
start = i;
break;
}
}
int[] ans = new int[n];
ans[0] = start;
ans[1] = map.get(start).get(0);
for (int i = 2; i < n; i++) {
int x = ans[i - 1];
List<Integer> list = map.get(x);
for (int j : list) {
if (j != ans[i - 2]) ans[i] = j;
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> restoreArray(vector<vector<int>>& adjacentPairs) {
unordered_map<int, int> cnts;
unordered_map<int, vector<int>> map;
for(auto& pair : adjacentPairs){
int a = pair[0], b = pair[1];
cnts[a]++, cnts[b]++;
map[a].push_back(b);
map[b].push_back(a);
}
int start;
for(auto& i : cnts) {
if(i.second == 1){
start = i.first;
break;
}
}
int n = adjacentPairs.size() + 1;
vector<int> ans(n);
ans[0] = start;
ans[1] = map[start][0];
for(int i = 2; i < n; i++){
int x = ans[i - 1];
for(int j : map[x])
if(j != ans[i-2]) ans[i] = j;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:
cnts = defaultdict(int)
map = defaultdict(list)
for ap in adjacentPairs:
a, b = ap[0], ap[1]
cnts[a] += 1
cnts[b] += 1
map[a].append(b)
map[b].append(a)
start = next(i for i in cnts if cnts[i] == 1)
n = len(adjacentPairs) + 1
ans = [0] * n
ans[0] = start
ans[1] = map[start][0]
for i in range(2, n):
x = ans[i - 1]
for j in map[x]:
if j != ans[i - 2]:
ans[i] = j
return ans
```
TypeScript 代码:
```TypeScript
function restoreArray(adjacentPairs: number[][]): number[] {
const cnts: {[key: number]: number} = {};
const map: {[key: number]: number[]} = {};
for(let pair of adjacentPairs){
let a: number = pair[0], b: number = pair[1];
cnts[a] = !cnts[a] ? 1 : cnts[a] + 1;
cnts[b] = !cnts[b] ? 1 : cnts[b] + 1;
if(!map[a]) map[a] = [];
if(!map[b]) map[b] = [];
map[a].push(b);
map[b].push(a);
}
let start: number;
for(let key in cnts){
if(cnts[key] == 1){
start = Number(key);
break;
}
}
const n: number = adjacentPairs.length + 1;
const ans: number[] = Array(n).fill(0);
ans[0] = start;
ans[1] = map[start][0];
for(let i = 2; i<n; i++){
let x: number = ans[i-1];
for(let j of map[x]){
if(j !== ans[i-2]) ans[i] = j;
}
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 双向构造(双指针)
在解法一中,我们通过「哈希表」计数得到 $ans$ 首位元素作为起点,进行「单向构造」。
那么是否存在使用任意数值作为起点进行的双向构造呢?
答案是显然的,我们可以利用 $ans$ 的长度为 $2 <= n <= 10^5$,构造一个长度 $10^6$ 的数组 $q$(这里可以使用 `static` 进行加速,让多个测试用例共享一个大数组)。
> 这里 $q$ 数组不一定要开成 $1e6$ 大小,只要我们 $q$ 大小大于 $ans$ 的两倍,就不会存在越界问题。
从 $q$ 数组的 **中间位置** 开始,先随便将其中一个元素添加到中间位置,使用「双指针」分别往「两边拓展」(`l` 和 `r` 分别指向左右待插入的位置)。
当 `l` 指针和 `r` 指针之间已经有 $n$ 个数值,说明整个 $ans$ 构造完成,我们将 $[l + 1, r - 1]$ 范围内的数值输出作为答案即可。
Java 代码:
```Java
class Solution {
static int N = (int)1e6+10;
static int[] q = new int[N];
public int[] restoreArray(int[][] adjacentPairs) {
int m = adjacentPairs.length, n = m + 1;
Map<Integer, List<Integer>> map = new HashMap<>();
for (int[] ap : adjacentPairs) {
int a = ap[0], b = ap[1];
List<Integer> alist = map.getOrDefault(a, new ArrayList<>());
alist.add(b);
map.put(a, alist);
List<Integer> blist = map.getOrDefault(b, new ArrayList<>());
blist.add(a);
map.put(b, blist);
}
int l = N / 2, r = l + 1;
int std = adjacentPairs[0][0];
List<Integer> list = map.get(std);
q[l--] = std;
q[r++] = list.get(0);
if (list.size() > 1) q[l--] = list.get(1);
while ((r - 1) - (l + 1) + 1 < n) {
List<Integer> alist = map.get(q[l + 1]);
int j = l;
for (int i : alist) {
if (i != q[l + 2]) q[j--] = i;
}
l = j;
List<Integer> blist = map.get(q[r - 1]);
j = r;
for (int i : blist) {
if (i != q[r - 2]) q[j++] = i;
}
r = j;
}
int[] ans = new int[n];
for (int i = l + 1, idx = 0; idx < n; i++, idx++) {
ans[idx] = q[i];
}
return ans;
}
}
```
C++ 代码:
```C++
#define N 1000010
class Solution {
public:
vector<int> restoreArray(vector<vector<int>>& adjacentPairs) {
int m = adjacentPairs.size(), n = m + 1;
unordered_map<int, vector<int>> map;
for(auto& pair : adjacentPairs){
int a = pair[0], b = pair[1];
map[a].push_back(b);
map[b].push_back(a);
}
int l = N / 2, r = l + 1;
int s = adjacentPairs[0][0];
vector<int> q(N, 0);
q[l--] = s;
q[r++] = map[s][0];
if (map[s].size() > 1) q[l--] = map[s][1];
while ((r - 1) - (l + 1) + 1 < n){
vector<int> list = map[q[l + 1]];
int j = l;
for(auto& i : list){
if(i != q[l + 2]) q[j--] = i;
}
l = j;
list = map[q[r - 1]];
j = r;
for(auto& i : list){
if(i != q[r - 2]) q[j++] = i;
}
r = j;
}
vector<int> ans(n);
for(int i = l + 1, idx = 0; idx < n; ++i, ++idx){
ans[idx] = q[i];
}
return ans;
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1743` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗？（中等）.md | 1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗? | https://leetcode-cn.com/problems/can-you-eat-your-favorite-candy-on-your-favorite-day/solution/gong-shui-san-xie-qian-zhui-he-qiu-jie-c-b38y/ | 中等 | [
"前缀和"
] | 给你一个下标从 `0` 开始的正整数数组 `candiesCount`,其中 `candiesCount[i]` 表示你拥有的第 `i` 类糖果的数目。
同时给你一个二维数组 `queries` ,其中 $queries[i] = [favoriteType_{i}, favoriteDay_{i}, dailyCap_{i}]$ 。
你按照如下规则进行一场游戏:
* 你从第 `0` 天开始吃糖果。
* 你在吃完 所有 第 `i - 1` 类糖果之前,不能 吃任何一颗第 `i` 类糖果。
* 在吃完所有糖果之前,你必须每天 至少 吃 一颗 糖果。
请你构建一个布尔型数组 `answer`,满足 `answer.length == queries.length`。`answer[i]` 为 `true` 的条件是:在每天吃 不超过 $dailyCap_i$ 颗糖果的前提下,你可以在第 $favoriteDay_i$ 天吃到第 $favoriteType_i$ 类糖果;否则 `answer[i]` 为 `false`。注意,只要满足上面 `3` 条规则中的第二条规则,你就可以在同一天吃不同类型的糖果。
请你返回得到的数组 `answer` 。
示例 1:
```
输入:candiesCount = [7,4,5,3,8], queries = [[0,2,2],[4,2,4],[2,13,1000000000]]
输出:[true,false,true]
提示:
1- 在第 0 天吃 2 颗糖果(类型 0),第 1 天吃 2 颗糖果(类型 0),第 2 天你可以吃到类型 0 的糖果。
2- 每天你最多吃 4 颗糖果。即使第 0 天吃 4 颗糖果(类型 0),第 1 天吃 4 颗糖果(类型 0 和类型 1),你也没办法在第 2 天吃到类型 4 的糖果。换言之,你没法在每天吃 4 颗糖果的限制下在第 2 天吃到第 4 类糖果。
3- 如果你每天吃 1 颗糖果,你可以在第 13 天吃到类型 2 的糖果。
```
示例 2:
```
输入:candiesCount = [5,2,6,4,1], queries = [[3,1,2],[4,10,3],[3,10,100],[4,100,30],[1,3,1]]
输出:[false,true,true,false,false]
```
提示:
* $1 <= candiesCount.length <= 10^5$
* $1 <= candiesCount[i] <= 10^5$
* $1 <= queries.length <= 10^5$
* $queries[i].length == 3$
* $0 <= favoriteType_{i} < candiesCount.length$
* $0 <= favoriteDay_{i} <= 10^9$
* $1 <= dailyCap_{i} <= 10^9$ | ### 基本分析
根据题意,在处理某个询问时,每天的吃糖数量为 $[1, queries[i][2]]$,因此我们可以计算出「最早/最晚」吃到第 $queries[i][0]$ 类糖果的时间,然后判断 $queries[i][1]$ 是否落在范围内,若落在范围内返回则有 $ans[i]$ 为 `True`,否则为 `False`。
---
### 前缀和
问题转换为如何快速求得「最早/最晚」吃到第 $queries[i][0]$ 类糖果的时间。
我们需要先预处理出 $candiesCount$ 的前缀和数组 $sum$(下标从 $1$ 开始),方便快速求得第 $i$ 类糖果之前有多少糖果。
为了方便,在处理某个询问时,我们令 $t = queries[i][0],d = queries[i][1] + 1,c = queries[i][2]$。其中 $d = queries[i][1] + 1$ 是因为题目天数是从 $0$ 开始计算,而我们的计算是从 $1$ 开始。
然后计算「最早/最晚」吃到第 $t$ 类糖果的时间:
* 最早时间(第一颗 $t$ 类糖的最早时间):当以最大速率 $c$ 吃糖时,可以在最早时间内吃到糖。时间为吃掉第 $t$ 类糖果 **前面** 的所有糖果的时间(下取整)加 $1$ :
$$
\left \lfloor \frac{sum[t]}{c} \right \rfloor + 1
$$
* 最晚时间(最后一颗 $t$ 类糖的最晚时间):当以最小速率 $1$ 吃糖时,可以计算出最晚吃糖时间。时间为吃掉所有 $t$ 类糖的时间:
$$
sum[t + 1]
$$
代码:
```Java
class Solution {
public boolean[] canEat(int[] cs, int[][] qs) {
int n = qs.length, m = cs.length;
boolean[] ans = new boolean[n];
long[] sum = new long[m + 1];
for (int i = 1; i <= m; i++) sum[i] = sum[i - 1] + cs[i - 1];
for (int i = 0; i < n; i++) {
int t = qs[i][0], d = qs[i][1] + 1, c = qs[i][2];
long a = sum[t] / c + 1, b = sum[t + 1];
ans[i] = a <= d && d <= b;
}
return ans;
}
}
```
* 时间复杂度:`cs` 数组的长度为 `n`,`qs` 数组的长度为 `m`。预处理前缀和的复杂度为 $O(n)$;处理每个询问的复杂度为 $O(1)$,共有 $m$ 个询问,复杂度为 $O(m)$。整体复杂度为 $O(\max(n, m))$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1744` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1748. 唯一元素的和（简单）.md | 1748. 唯一元素的和 | https://leetcode-cn.com/problems/sum-of-unique-elements/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-atnd/ | 简单 | [
"模拟",
"哈希表",
"双指针",
"排序"
] | 给你一个整数数组 nums 。数组中唯一元素是那些只出现「恰好一次」的元素。
请你返回 nums 中唯一元素的和 。
示例 1:
```
输入:nums = [1,2,3,2]
输出:4
解释:唯一元素为 [1,3] ,和为 4 。
```
示例 2:
```
输入:nums = [1,1,1,1,1]
输出:0
解释:没有唯一元素,和为 0 。
```
示例 3 :
```
输入:nums = [1,2,3,4,5]
输出:15
解释:唯一元素为 [1,2,3,4,5] ,和为 15 。
```
提示:
* 1 <= nums.length <= 100
* 1 <= nums[i] <= 100 | ### 排序 + 双指针
根据题意,其中一个做法是先对 `nums` 进行排序,使用双指针找到值相同的连续段 $[i, j)$,若连续段长度为 $1$,则将该值累加到答案。
代码:
```Java
class Solution {
public int sumOfUnique(int[] nums) {
Arrays.sort(nums);
int n = nums.length, ans = 0;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && nums[j] == nums[i]) j++;
if (j - i == 1) ans += nums[i];
i = j;
}
return ans;
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 哈希表
另外容易想到使用「哈希表」统计某个数的出现次数,又根据 $nums[i]$ 的范围为 $[1, 100]$,可直接使用数组充当哈希表。
代码:
```Java
class Solution {
int[] cnt = new int[110];
public int sumOfUnique(int[] nums) {
for (int i : nums) cnt[i]++;
int ans = 0;
for (int i = 1; i <= 100; i++) {
if (cnt[i] == 1) ans += i;
}
return ans;
}
}
```
* 时间复杂度:令 $C$ 为 $nums[i]$ 的值域大小,本题固定为 $110$。整体复杂度为 $O(n + C)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1748` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1741-1750/1749. 任意子数组和的绝对值的最大值（中等）.md | 1749. 任意子数组和的绝对值的最大值 | https://leetcode-cn.com/problems/maximum-absolute-sum-of-any-subarray/solution/xiang-jie-qian-zhui-he-jie-fa-fen-xi-si-yibby/ | 中等 | [
"前缀和"
] | 给你一个整数数组 nums 。
一个子数组 `[numsl, numsl+1, ..., numsr-1, numsr]` 的「和的绝对值」为 `abs(numsl + numsl+1 + ... + numsr-1 + numsr) `。
请你找出 nums 中 和的绝对值 最大的任意子数组(可能为空),并返回该 最大值 。
abs(x) 定义如下:
* 如果 x 是负整数,那么 abs(x) = -x 。
* 如果 x 是非负整数,那么 abs(x) = x 。
示例 1:
```
输入:nums = [1,-3,2,3,-4]
输出:5
解释:子数组 [2,3] 和的绝对值最大,为 abs(2+3) = abs(5) = 5 。
```
示例 2:
```
输入:nums = [2,-5,1,-4,3,-2]
输出:8
解释:子数组 [-5,1,-4] 和的绝对值最大,为 abs(-5+1-4) = abs(-8) = 8 。
```
提示:
* 1 <= nums.length <= $10^5$
* -$10^4$ <= nums[i] <= $10^4$ | ### 前缀和
题目要我们求连续一段的子数组的和,很自然就能想到前缀和。
当我们有了前缀和数组 `sum` 之后,需要求任意一段子数组 `[i,j]` 的和可以直接通过 `sum[j] - sum[i - 1]` 得出。
要使得 `abs(sum[j] - sum[i - 1])` 最大,其实有这么几种情况:
* 找到前缀和数组中的最大值减去最小值,得到一个最大正数(前提是最大值出现在最小值的后面,并且最小值是个负数,否则应该直接取最大值作为答案)
* 找到前缀和的最小值减去最大值,得到一个最小负数(前提是最小值出现在最大值的后面,而且最大值是一个正数,否则直接取最小值作为答案)。
也就是说最终答案只与前缀和数组中的最大值和最小值相关,而且最大值可能会出现在最小值前面或者后面。
因此我们可以边循环边做更新答案。
代码:
```Java
class Solution {
public int maxAbsoluteSum(int[] nums) {
int n = nums.length;
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
int ans = 0;
for (int i = 1, min = 0, max = 0; i <= n; i++) {
ans = Math.max(ans, Math.abs(sum[i] - min));
ans = Math.max(ans, Math.abs(sum[i] - max));
max = Math.max(max, sum[i]);
min = Math.min(min, sum[i]);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1749` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1751. 最多可以参加的会议数目 II（困难）.md | 1751. 最多可以参加的会议数目 II | https://leetcode-cn.com/problems/maximum-number-of-events-that-can-be-attended-ii/solution/po-su-dp-er-fen-dp-jie-fa-by-ac_oier-88du/ | 困难 | [
"二分",
"序列 DP"
] | 给你一个 `events` 数组,其中 $events[i] = [startDay_i, endDay_i, value_i]$ ,表示第 $i$ 个会议在 $startDay_i$ 天开始,第 $endDay_i$ 天结束,如果你参加这个会议,你能得到价值 $value_i$ 。
同时给你一个整数 $k$ 表示你能参加的最多会议数目。
你同一时间只能参加一个会议。如果你选择参加某个会议,那么你必须完整地参加完这个会议。
会议结束日期是包含在会议内的,也就是说你不能同时参加一个开始日期与另一个结束日期相同的两个会议。
请你返回能得到的会议价值最大和。
示例 1:
```
输入:events = [[1,2,4],[3,4,3],[2,3,1]], k = 2
输出:7
解释:选择绿色的活动会议 0 和 1,得到总价值和为 4 + 3 = 7 。
```
示例 2:
```
输入:events = [[1,2,4],[3,4,3],[2,3,10]], k = 2
输出:10
解释:参加会议 2 ,得到价值和为 10 。
你没法再参加别的会议了,因为跟会议 2 有重叠。你 不 需要参加满 k 个会议。
```
示例 3:
```
输入:events = [[1,1,1],[2,2,2],[3,3,3],[4,4,4]], k = 3
输出:9
解释:尽管会议互不重叠,你只能参加 3 个会议,所以选择价值最大的 3 个会议。
```
提示:
* $1 <= k <= events.length$
* $1 <= k * events.length <= 10^6$
* $1 <= startDay_i <= endDay_i <= 10^9$
* $1 <= value_i <= 10^6$ | ### 基本思路
**定义 $f[i][j]$ 为考虑前 $i$ 个事件,选择不超过 $j$ 的最大价值**
对于每个事件,都有选择与不选两种选择:
* 不选: $f[i][j] = f[i - 1][j]$
* 选:找到第 $i$ 件事件之前,与第 $i$ 件事件不冲突的事件,记为 `last`,则有 $f[i][j] = f[last][j - 1] + value_i$
两者取 $max$,则是 $f[i][j]$ 的值。
分析到这里,因为我们要找 `last`,我们需要先对 `events` 的结束时间排序,然后找从右往左找,找到第一个满足 `结束时间 小于 当前事件的开始时间` 的事件,就是 `last`
而找 `last` 的过程,可以直接循环找,也可以通过二分来找,都能过。
---
### 动态规划
不通过「二分」来找 `last` 的 DP 解法。
代码:
```Java
class Solution {
public int maxValue(int[][] es, int k) {
int n = es.length;
Arrays.sort(es, (a, b)->a[1]-b[1]);
// f[i][j] 代表考虑前 i 个事件,选择不超过 j 的最大价值
int[][] f = new int[n + 1][k + 1];
for (int i = 1; i <= n; i++) {
int[] ev = es[i - 1];
int s = ev[0], e = ev[1], v = ev[2];
// 找到第 i 件事件之前,与第 i 件事件不冲突的事件
// 对于当前事件而言,冲突与否,与 j 无关
int last = 0;
for (int p = i - 1; p >= 1; p--) {
int[] prev = es[p - 1];
if (prev[1] < s) {
last = p;
break;
}
}
for (int j = 1; j <= k; j++) {
f[i][j] = Math.max(f[i - 1][j], f[last][j - 1] + v);
}
}
return f[n][k];
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,循环 `n` 个事件,每次循环需要往回找一个事件,复杂度为 $O(n)$,并更新 `k` 个状态,复杂度为 $O(k)$,因此转移的复杂度为 $O(n \times (n + k))$;总的复杂度为 $O(n \times (n + k + \log{n}))$
* 空间复杂度:$O(n \times k)$
---
### 二分 + 动态规划
通过「二分」来找 `last` 的 DP 解法。
代码:
```Java
class Solution {
public int maxValue(int[][] es, int k) {
int n = es.length;
Arrays.sort(es, (a, b)->a[1]-b[1]);
// f[i][j] 代表考虑前 i 个事件,选择不超过 j 的最大价值
int[][] f = new int[n + 1][k + 1];
for (int i = 1; i <= n; i++) {
int[] ev = es[i - 1];
int s = ev[0], e = ev[1], v = ev[2];
// 通过「二分」,找到第 i 件事件之前,与第 i 件事件不冲突的事件
// 对于当前事件而言,冲突与否,与 j 无关
int l = 1, r = i - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
int[] prev = es[mid - 1];
if (prev[1] < s) l = mid;
else r = mid - 1;
}
int last = (r > 0 && es[r - 1][1] < s) ? r : 0;
for (int j = 1; j <= k; j++) {
f[i][j] = Math.max(f[i - 1][j], f[last][j - 1] + v);
}
}
return f[n][k];
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,循环 `n` 个事件,每次循环需要往回找一个事件,复杂度为 $O(\log{n})$,并更新 `k` 个状态,复杂度为 $O(k)$,因此转移的复杂度为 $O(n \times (\log{n} + k))$;总的复杂度为 $O(n \times (k + \log{n}))$
* 空间复杂度:$O(n \times k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1751` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1758. 生成交替二进制字符串的最少操作数（简单）.md | 1758. 生成交替二进制字符串的最少操作数 | https://leetcode.cn/problems/minimum-changes-to-make-alternating-binary-string/solution/by-ac_oier-gclh/ | 简单 | [
"模拟"
] | 给你一个仅由字符 `'0'` 和 `'1'` 组成的字符串 `s` 。一步操作中,你可以将任一 `'0'` 变成 `'1'` ,或者将 `'1'` 变成 `'0'` 。
交替字符串 定义为:如果字符串中不存在相邻两个字符相等的情况,那么该字符串就是交替字符串。例如,字符串 `"010"` 是交替字符串,而字符串 `"0100"` 不是。
返回使 `s` 变成 交替字符串 所需的 最少 操作数。
示例 1:
```
输入:s = "0100"
输出:1
解释:如果将最后一个字符变为 '1' ,s 就变成 "0101" ,即符合交替字符串定义。
```
示例 2:
```
输入:s = "10"
输出:0
解释:s 已经是交替字符串。
```
示例 3:
```
输入:s = "1111"
输出:2
解释:需要 2 步操作得到 "0101" 或 "1010" 。
```
提示:
* $1 <= s.length <= 10^4$
* `s[i]` 是 `'0'` 或 `'1'` | ### 模拟
最终结果只有「从 `0` 开始的交替串」和「从 `1` 开始的交替串」两种。
对于一个长度为 `n` 的未知序列 `A` 而言,假设我们需要花费 `cnt` 次操作将其变为「从 `0` 开始的交替串」,那么我们想要将其变为「从 `1` 开始的交替串」则需要 `n - cnt` 次操作:原本操作的 `cnt` 个位置不能动,而原本没操作的位置则都需要翻转,从而确保两种交替串对应位均相反。
Java 代码:
```Java
class Solution {
public int minOperations(String s) {
int n = s.length(), cnt = 0;
for (int i = 0; i < n; i++) cnt += (s.charAt(i) - '0') ^ (i & 1);
return Math.min(cnt, n - cnt);
}
}
```
TypeScript 代码:
```TypeScript
function minOperations(s: string): number {
let n = s.length, cnt = 0
for (let i = 0; i < n; i++) cnt += (s.charCodeAt(i) - '0'.charCodeAt(0)) ^ (i & 1)
return Math.min(cnt, n - cnt)
}
```
Python3 代码:
```Python3
class Solution:
def minOperations(self, s: str) -> int:
n, cnt = len(s), 0
for i, c in enumerate(s):
cnt += (ord(c) - ord('0')) ^ (i & 1)
return min(cnt, n - cnt)
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1758` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1759. 统计同构子字符串的数目（中等）.md | 1759. 统计同构子字符串的数目 | https://acoier.com/2022/12/26/1759.%20%E7%BB%9F%E8%AE%A1%E5%90%8C%E6%9E%84%E5%AD%90%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E6%95%B0%E7%9B%AE%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"双指针",
"数学"
] | 给你一个字符串 `s`,返回 `s` 中 同构子字符串 的数目。
由于答案可能很大,只需返回对 $10^9 + 7$ 取余 后的结果。
同构字符串的定义为:如果一个字符串中的所有字符都相同,那么该字符串就是同构字符串。
子字符串是字符串中的一个连续字符序列。
示例 1:
```
输入:s = "abbcccaa"
输出:13
解释:同构子字符串如下所列:
"a" 出现 3 次。
"aa" 出现 1 次。
"b" 出现 2 次。
"bb" 出现 1 次。
"c" 出现 3 次。
"cc" 出现 2 次。
"ccc" 出现 1 次。
3 + 1 + 2 + 1 + 3 + 2 + 1 = 13
```
示例 2:
```
输入:s = "xy"
输出:2
解释:同构子字符串是 "x" 和 "y" 。
```
示例 3:
```
输入:s = "zzzzz"
输出:15
```
提示:
* $1 <= s.length <= 10^5$
* `s` 由小写字符串组成 | ### 双指针 + 数学
根据题意,我们需要找出 `s` 中所有字符相同的连续段。
假设 $s[i...(j - 1)]$ 为某个连续段,长度为 $m$,根据「等差数列求和」可知该连续段所能提供的同构字符串数量为 $\frac{(1 + m) \times m}{2}$。
具体的,我们可以从前往后扫描 `s`,假设当前处理到的位置为 `i`,将其看作连续段的左端点,然后从 `i` 出发找到当前最长连续段的右端点 `j - 1`,统计 $s[i...(j - 1)]$ 所能贡献同构字符串数量,并调整下个发起点为 $i = j$ 以扫描下一个连续段。
Java 代码:
```Java
class Solution {
public int countHomogenous(String s) {
int n = s.length(), MOD = (int)1e9+7;
long ans = 0;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && s.charAt(j) == s.charAt(i)) j++;
long cnt = j - i;
ans += (1 + cnt) * cnt / 2;
ans %= MOD;
i = j;
}
return (int) ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int countHomogenous(string s) {
int n = s.size(), MOD = 1e9+7;
long ans = 0;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && s[j] == s[i]) j++;
long cnt = j - i;
ans += (1 + cnt) * cnt / 2;
ans %= MOD;
i = j;
}
return (int) ans;
}
};
```
Python3 代码:
```Python
class Solution:
def countHomogenous(self, s: str) -> int:
n, mod, i, ans = len(s), 1e9+7, 0, 0
while i < n:
j = i
while j < n and s[j] == s[i]:
j += 1
cnt = j - i
ans += (cnt + 1) * cnt / 2
ans %= mod
i = j
return int(ans)
```
TypeScript 代码:
```TypeScript
function countHomogenous(s: string): number {
let n = s.length, mod = 1e9+7, ans = 0
for (let i = 0; i < n; ) {
let j = i
while (j < n && s.charAt(j) == s.charAt(i)) j++
const cnt = j - i
ans += (1 + cnt) * cnt / 2
ans %= mod
i = j
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1759` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1751-1760/1760. 袋子里最少数目的球（中等）.md | 1760. 袋子里最少数目的球 | https://leetcode.cn/problems/minimum-limit-of-balls-in-a-bag/solutions/2519994/gong-shui-san-xie-jing-dian-er-fen-yun-y-pj6r/ | 中等 | [
"二分"
] | 给你一个整数数组 `nums`,其中 `nums[i]` 表示第 `i` 个袋子里球的数目。同时给你一个整数 `maxOperations`。
你可以进行如下操作至多 `maxOperations` 次:
* 选择任意一个袋子,并将袋子里的球分到 `2` 个新的袋子中,每个袋子里都有 正整数 个球。
* 比方说,一个袋子里有 `5` 个球,你可以把它们分到两个新袋子里,分别有 `1` 个和 `4` 个球,或者分别有 `2` 个和 `3` 个球。
你的开销是单个袋子里球数目的 最大值 ,你想要 最小化 开销。
请你返回进行上述操作后的最小开销。
示例 1:
```
输入:nums = [9], maxOperations = 2
输出:3
解释:
- 将装有 9 个球的袋子分成装有 6 个和 3 个球的袋子。[9] -> [6,3] 。
- 将装有 6 个球的袋子分成装有 3 个和 3 个球的袋子。[6,3] -> [3,3,3] 。
装有最多球的袋子里装有 3 个球,所以开销为 3 并返回 3 。
```
示例 2:
```
输入:nums = [2,4,8,2], maxOperations = 4
输出:2
解释:
- 将装有 8 个球的袋子分成装有 4 个和 4 个球的袋子。[2,4,8,2] -> [2,4,4,4,2] 。
- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,4,4,4,2] -> [2,2,2,4,4,2] 。
- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,4,4,2] -> [2,2,2,2,2,4,2] 。
- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,2,2,4,2] -> [2,2,2,2,2,2,2,2] 。
装有最多球的袋子里装有 2 个球,所以开销为 2 并返回 2 。
```
示例 3:
```
输入:nums = [7,17], maxOperations = 2
输出:7
```
提示:
* $1 <= nums.length <= 10^5$
* $1 <= maxOperations, nums[i] <= 10^9$ | ### 二分
最小化不超过 `max` 次划分操作后的单个袋子最大值,我们将其称为「划分值」。
**答案具有二段性:若使用 $k \leq \max$ 次划分操作后可达到最小划分值,此时减少划分操作次数,会使得划分值非单调上升。**
因此我们可以二分答案,从而将问题进行等价转换:
**假设当前二分到的值为 $limit$,我们需要实现一个线性复杂度为 `check` 函数,判断能否使用不超过 $\max$ 次划分次数,来使得划分值不超过 $limit$**:
* 若能满足,说明 $[limit, +\infty]$ 范围的划分值,均能使用不超过 $\max$ 次的实现,此时让 $r = limit$
* 若不能满足,比 $limit$ 更小的划分值,则更无法在 $\max$ 次操作中满足,说明 $[1, limit]$ 范围划分值均不是答案,此时让 $l = limit + 1$
考虑如何实现 `check` 函数,从前往后处理每个 $nums[i]$,根据 $nums[i]$ 与当前限制 $limit$ 的大小关系进行分情况讨论:
* 若 $nums[i] \leq limit$:说明当前袋子不会成为瓶颈,无须消耗划分次数
* 若 $nums[i] > limit$:此时需要对当前袋子进行划分,直到满足单个袋子球的数量不超过 $limit$ 为止,由于每次划分相当于增加一个袋子,而将 $nums[i]$ 划分成若干个不超过 $limit$ 个球的袋子,需要 $\left \lceil \frac{nums[i]}{limit} \right \rceil$ 个袋子,减去原本的一个,共需要增加 $\left \lceil \frac{nums[i]}{limit} \right \rceil$ 个新袋子,即划分 $\left \lceil \frac{nums[i]}{limit} \right \rceil$ 次
Java 代码:
```Java
class Solution {
public int minimumSize(int[] nums, int max) {
int l = 1, r = 0x3f3f3f3f;
while (l < r) {
int mid = l + r >> 1;
if (check(nums, mid, max)) r = mid;
else l = mid + 1;
}
return r;
}
boolean check(int[] nums, int limit, int max) {
int cnt = 0;
for (int x : nums) cnt += Math.ceil(x * 1.0 / limit) - 1;
return cnt <= max;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minimumSize(vector<int>& nums, int maxv) {
int l = 1, r = 0x3f3f3f3f;
while (l < r) {
int mid = l + r >> 1;
if (check(nums, mid, maxv)) r = mid;
else l = mid + 1;
}
return r;
}
bool check(vector<int>& nums, int limit, int maxv) {
int cnt = 0;
for (int x : nums) cnt += ceil(x * 1.0 / limit) - 1;
return cnt <= maxv;
}
};
```
Python 代码:
```Python
class Solution:
def minimumSize(self, nums: List[int], maxv: int) -> int:
def check(nums, limit, maxv):
return sum([(x + limit - 1) // limit - 1 for x in nums]) <= maxv
l, r = 1, 0x3f3f3f3f
while l < r:
mid = l + r >> 1
if check(nums, mid, maxv):
r = mid
else:
l = mid + 1
return r
```
TypeScript 代码:
```TypeScript
function minimumSize(nums: number[], max: number): number {
function check(nums: number[], limit: number, max: number): boolean {
let cnt = 0
for (const x of nums) cnt += Math.ceil(x / limit) - 1
return cnt <= max
}
let l = 1, r = 0x3f3f3f3f
while (l < r) {
const mid = l + r >> 1
if (check(nums, mid, max)) r = mid
else l = mid + 1
}
return r
}
```
* 时间复杂度:$O(n \log{M})$,其中 $M = 1e9$ 为值域大小
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1758` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1763. 最长的美好子字符串（简单）.md | 1763. 最长的美好子字符串 | https://leetcode-cn.com/problems/longest-nice-substring/solution/gong-shui-san-xie-yi-ti-san-jie-po-su-ji-oflj/ | 简单 | [
"模拟",
"前缀和",
"位运算"
] | 当一个字符串 `s` 包含的每一种字母的大写和小写形式 同时 出现在 `s` 中,就称这个字符串 `s` 是 美好 字符串。
比方说,`"abABB"` 是美好字符串,因为 `'A'` 和 `'a'` 同时出现了,且 `'B'` 和 `'b'` 也同时出现了。然而,`"abA"` 不是美好字符串因为 `'b'` 出现了,而 `'B'` 没有出现。
给你一个字符串 `s` ,请你返回 `s` 最长的 美好子字符串 。如果有多个答案,请你返回 最早 出现的一个。如果不存在美好子字符串,请你返回一个空字符串。
示例 1:
```
输入:s = "YazaAay"
输出:"aAa"
解释:"aAa" 是一个美好字符串,因为这个子串中仅含一种字母,其小写形式 'a' 和大写形式 'A' 也同时出现了。
"aAa" 是最长的美好子字符串。
```
示例 2:
```
输入:s = "Bb"
输出:"Bb"
解释:"Bb" 是美好字符串,因为 'B' 和 'b' 都出现了。整个字符串也是原字符串的子字符串。
```
示例 3:
```
输入:s = "c"
输出:""
解释:没有美好子字符串。
```
示例 4:
```
输入:s = "dDzeE"
输出:"dD"
解释:"dD" 和 "eE" 都是最长美好子字符串。
由于有多个美好子字符串,返回 "dD" ,因为它出现得最早。
```
提示:
* $1 <= s.length <= 100$
* `s` 只包含大写和小写英文字母。 | ### 朴素解法
数据范围只有 $100$,最为简单的做法是枚举所有的子串( 复杂度为 $O(n^2)$ ),然后对子串进行合法性检查( 复杂度为 $O(n)$ ),整体复杂度为 $O(n^3)$,可以过。
代码:
```Java
class Solution {
public String longestNiceSubstring(String s) {
int n = s.length();
String ans = "";
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (j - i + 1 > ans.length() && check(s.substring(i, j + 1))) ans = s.substring(i, j + 1);
}
}
return ans;
}
boolean check(String s) {
Set<Character> set = new HashSet<>();
for (char c : s.toCharArray()) set.add(c);
for (char c : s.toCharArray()) {
char a = Character.toLowerCase(c), b = Character.toUpperCase(c);
if (!set.contains(a) || !set.contains(b)) return false;
}
return true;
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n)$
---
### 前缀和优化
在 `check` 中,我们不可避免的遍历整个子串,复杂度为 $O(n)$。
该过程可以使用前缀和思想进行优化:**构建二维数组 $cnt$ 来记录子串的词频,$cnt[i]$ 为一个长度为 $128$ 的数组,用于记录字符串 `s` 中下标范围为 $[0, i - 1]$ 的词频。即 $cnt[i + 1][j]$ 所代表的含义为在子串 $s[0...i]$ 中字符 $j$ 的出现次数。**
那么利用「容斥原理」,对于 `s` 的任意连续段 $[l, r]$ 所代表的子串中的任意字符 $i$ 的词频,我们可以作差算得:
$$
res[i] = cnt[r + 1][i] - cnt[l][i]
$$
这样我们在 `check` 实现中,只要检查 $26$ 个字母对应的大小写词频(ASCII 相差 $32$),是否同时为 $0$ 或者同时不为 $0$ 即可,复杂度为 $O(C)$。
代码:
```Java
class Solution {
public String longestNiceSubstring(String s) {
int n = s.length();
int[][] cnt = new int[n + 1][128];
for (int i = 1; i <= n; i++) {
char c = s.charAt(i - 1);
cnt[i] = cnt[i - 1].clone();
cnt[i][c - 'A']++;
}
int idx = -1, len = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (j - i + 1 <= len) continue;
int[] a = cnt[i], b = cnt[j + 1];
if (check(a, b)) {
idx = i; len = j - i + 1;
}
}
}
return idx == -1 ? "" : s.substring(idx, idx + len);
}
boolean check(int[] a, int[] b) {
for (int i = 0; i < 26; i++) {
int low = b[i] - a[i], up = b[i + 32] - a[i + 32]; // 'A' = 65、'a' = 97
if (low != 0 && up == 0) return false;
if (low == 0 && up != 0) return false;
}
return true;
}
}
```
* 时间复杂度:令 $C$ 为字符集大小,本题固定为 $26$,构建 $cnt$ 的复杂度为 $O(n * 128)$;枚举所有子串复杂度为 $O(n^2)$;`check` 的复杂度为 $O(C)$。整体复杂度为 $O(n^2 * C)$
* 空间复杂度:$O(n * 128)$
---
### 二进制优化
更进一步,对于某个子串而言,我们只关心大小写是否同时出现,而不关心出现次数。
因此我们无须使用二维数组来记录具体的词频,可以在枚举子串时,使用两个 `int` 的低 $26$ 位分别记录大小写字母的出现情况,利用枚举子串时右端点后移,维护两变量,当且仅当两变量相等时,满足 $26$ 个字母的大小写同时出现或同时不出现。
代码:
```Java
class Solution {
public String longestNiceSubstring(String s) {
int n = s.length();
int idx = -1, len = 0;
for (int i = 0; i < n; i++) {
int a = 0, b = 0;
for (int j = i; j < n; j++) {
char c = s.charAt(j);
if (c >= 'a' && c <= 'z') a |= (1 << (c - 'a'));
else b |= (1 << (c - 'A'));
if (a == b && j - i + 1 > len) {
idx = i; len = j - i + 1;
}
}
}
return idx == -1 ? "" : s.substring(idx, idx + len);
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1763` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1764. 通过连接另一个数组的子数组得到一个数组（中等）.md | 1764. 通过连接另一个数组的子数组得到一个数组 | https://leetcode-cn.com/problems/form-array-by-concatenating-subarrays-of-another-array/solution/clean-solutionni-jue-dui-neng-kan-dong-d-l4ts/ | 中等 | [
"双指针"
] | 给你一个长度为 `n` 的二维整数数组 `groups` ,同时给你一个整数数组 `nums` 。
你是否可以从 `nums` 中选出 `n` 个 不相交 的子数组,使得第 `i` 个子数组与 `groups[i]` (下标从 `0` 开始)完全相同,且如果 `i > 0` ,那么第 (`i-1`) 个子数组在 `nums` 中出现的位置在第 `i` 个子数组前面。(也就是说,这些子数组在 `nums` 中出现的顺序需要与 `groups` 顺序相同)
如果你可以找出这样的 `n` 个子数组,请你返回 `true` ,否则返回 `false`。
如果不存在下标为 `k` 的元素 `nums[k]` 属于不止一个子数组,就称这些子数组是 不相交 的。子数组指的是原数组中连续元素组成的一个序列。
示例 1:
```
输入:groups = [[1,-1,-1],[3,-2,0]], nums = [1,-1,0,1,-1,-1,3,-2,0]
输出:true
解释:你可以分别在 nums 中选出第 0 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 和第 1 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 。
这两个子数组是不相交的,因为它们没有任何共同的元素。
```
示例 2:
```
输入:groups = [[10,-2],[1,2,3,4]], nums = [1,2,3,4,10,-2]
输出:false
解释:选择子数组 [1,2,3,4,10,-2] 和 [1,2,3,4,10,-2] 是不正确的,因为它们出现的顺序与 groups 中顺序不同。
[10,-2] 必须出现在 [1,2,3,4] 之前。
```
示例 3:
```
输入:groups = [[1,2,3],[3,4]], nums = [7,7,1,2,3,4,7,7]
输出:false
解释:选择子数组 [7,7,1,2,3,4,7,7] 和 [7,7,1,2,3,4,7,7] 是不正确的,因为它们不是不相交子数组。
它们有一个共同的元素 nums[4] (下标从 0 开始)。
```
提示:
* $groups.length == n$
* $1 <= n <= 10^3$
* $1 <= groups[i].length, sum(groups[i].length) <= 10^3$
* $1 <= nums.length <= 10^3$
* $-10^7 <= groups[i][j], nums[k] <= 10^7$ | ### 双指针
为了方便,将 `groups` 记为 `gs`。
从前往后处理每个 $gs[i]$,使用 `idx` 记录当前使用到 `nums` 中的哪一位(即 $[0, ... (idx - 1)]$ 的 $nums[i]$ 已经用于匹配 $gs[0, ... (i - 1)]$。
每次尝试从 `idx` 出发匹配 `gs[i]`,若能匹配成功,则整段更新 $idx = idx + gs[i].length$;否则将 `idx` 后移一位,继续尝试匹配 `gs[i]`。
代码:
```Java
class Solution {
public boolean canChoose(int[][] gs, int[] nums) {
int m = nums.length, idx = 0;
out:for (int[] info : gs) {
for (int j = idx; j + info.length <= m; j++) {
boolean ok = true;
for (int k = 0; k < info.length && ok; k++) {
if (nums[j + k] != info[k]) ok = false;
}
if (ok) {
idx = j + info.length;
continue out;
}
}
return false;
}
return true;
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1764` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1765. 地图中的最高点（中等）.md | 1765. 地图中的最高点 | https://leetcode-cn.com/problems/map-of-highest-peak/solution/gong-shui-san-xie-duo-yuan-bfs-yun-yong-8sw0f/ | 中等 | [
"图论搜索",
"多源 BFS"
] | 给你一个大小为 `m x n` 的整数矩阵 `isWater` ,它代表了一个由 陆地 和 水域 单元格组成的地图。
* 如果 `isWater[i][j] == 0` ,格子 `(i, j)` 是一个 陆地 格子。
* 如果 `isWater[i][j] == 1` ,格子 `(i, j)` 是一个 水域 格子。
你需要按照如下规则给每个单元格安排高度:
* 每个格子的高度都必须是非负的。
* 如果一个格子是是 **水域** ,那么它的高度必须为 $0$ 。
* 任意相邻的格子高度差 至多 为 `1` 。当两个格子在正东、南、西、北方向上相互紧挨着,就称它们为相邻的格子。(也就是说它们有一条公共边)
找到一种安排高度的方案,使得矩阵中的最高高度值 最大 。
请你返回一个大小为 `m x n` 的整数矩阵 `height` ,其中 `height[i][j]` 是格子 `(i, j)` 的高度。如果有多种解法,请返回 任意一个 。
示例 1:
```
输入:isWater = [[0,1],[0,0]]
输出:[[1,0],[2,1]]
解释:上图展示了给各个格子安排的高度。
蓝色格子是水域格,绿色格子是陆地格。
```
示例 2:
```
输入:isWater = [[0,0,1],[1,0,0],[0,0,0]]
输出:[[1,1,0],[0,1,1],[1,2,2]]
解释:所有安排方案中,最高可行高度为 2 。
任意安排方案中,只要最高高度为 2 且符合上述规则的,都为可行方案。
```
提示:
* $m == isWater.length$
* $n == isWater[i].length$
* $1 <= m, n <= 1000$
* `isWater[i][j]` 要么是 $0$ ,要么是 $1$ 。
* 至少有 $1$ 个水域格子。 | ### 多源 BFS
这是一道「多源 `BFS`」板子题,对「多源 `BFS`」不熟悉的同学,可以看看前置 🧀:[多源 BFS 入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&scene=178&cur_album_id=1917113998693449732#rd)。
里面详解了「多源 `BFS`」与「单源 `BFS`」板子上的区别,强调了可以通过建立「虚拟源点」的方式,将「多源 `BFS`」转换回「单源 `BFS`」问题。
回到本题,题目规定了水域区域的高度为 $0$,然后相邻格子之间的高度差至多为 $1$,
我们可以将所有水域(高度为 $0$)区域进行入队,然后跑一遍 `BFS` 即可。
将所有水域(高度为 $0$)区域进行入队的操作可看作是将与「虚拟源点」链接的节点进行入队(也等价于起始只将虚拟源点入队):
容易证明这样做法的正确性:**对于一个「陆地」区域(高度可变)而言,其所能填入的高度,取决于其距离其他「水域」区域的距离,而我们最终要让整个答案矩阵合法,因此每个「陆地」区域应该取其所能填入的高度的「下界」,即只由「距离它最近的水域」区域所更新,这符合 `BFS` 的性质。**
**代码(感谢 [@Benhao](/u/himymben/) 和 [@5cm/s 🌸](/u/megurine/) 同学提供的其他语言版本):**
```Java
class Solution {
public int[][] highestPeak(int[][] g) {
int m = g.length, n = g[0].length;
int[][] ans = new int[m][n];
Deque<int[]> d = new ArrayDeque<>();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == 1) d.addLast(new int[]{i, j});
ans[i][j] = g[i][j] == 1 ? 0 : -1;
}
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int x = info[0], y = info[1];
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (ans[nx][ny] != -1) continue;
ans[nx][ny] = ans[x][y] + 1;
d.addLast(new int[]{nx, ny});
}
}
return ans;
}
}
```
-
```Python3
class Solution:
def highestPeak(self, isWater: List[List[int]]) -> List[List[int]]:
m, n = len(isWater), len(isWater[0])
ans = [[0] * n for _ in range(m)]
d = deque()
for i in range(m):
for j in range(n):
if isWater[i][j]:
d.append((i, j))
ans[i][j] = 0 if isWater[i][j] else -1
dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
h = 1
while d:
size = len(d)
for _ in range(size):
x, y = d.popleft()
for di in dirs:
nx, ny = x + di[0], y + di[1]
if 0 <= nx < m and 0 <= ny < n and ans[nx][ny] == -1:
ans[nx][ny] = h
d.append((nx, ny))
h += 1
return ans
```
-
```Go
func highestPeak(isWater [][]int) [][]int {
m, n := len(isWater), len(isWater[0])
ans, d := make([][]int, m), [][]int{}
for i := 0; i < m; i++ {
ans[i] = make([]int, n)
for j := 0; j < n; j++ {
if isWater[i][j] == 1 {
d = append(d, []int{i, j})
ans[i][j] = 0
} else {
ans[i][j] = -1
}
}
}
dirs := [][]int{{1,0}, {-1,0}, {0,1}, {0,-1}}
for h := 1; len(d) > 0; h++ {
for size := len(d); size > 0; size--{
info := d[0]
d = d[1:]
x, y := info[0], info[1]
for _, di := range dirs {
nx, ny := x + di[0], y + di[1]
if nx >= 0 && nx < m && ny >= 0 && ny < n && ans[nx][ny] == -1 {
ans[nx][ny] = h
d = append(d, []int{nx, ny})
}
}
}
}
return ans
}
```
-
```C++
const int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
class Solution {
public:
vector<vector<int>> highestPeak(vector<vector<int>>& g) {
int n = g.size(), m = g[0].size();
queue<pair<int, int>> q;
vector<vector<int>> ans(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (g[i][j] == 1) {
q.emplace(i, j);
} else {
ans[i][j] = -1;
}
}
}
while (!q.empty()) {
auto [x, y] = q.front(); q.pop();
for (int i = 0; i < 4; ++i) {
int a = x + dx[i], b = y + dy[i];
if (a < 0 || a == n || b < 0 || b == m) continue;
if (ans[a][b] >= 0) continue;
ans[a][b] = ans[x][y] + 1;
q.emplace(a, b);
}
}
return ans;
}
};
```
* 时间复杂度:$O(m * n)$
* 空间复杂度:$O(m * n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1765` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1766. 互质树（困难）.md | 1766. 互质树 | https://leetcode-cn.com/problems/tree-of-coprimes/solution/bu-tai-yi-yang-de-dfs-ji-lu-suo-you-zui-d3xeu/ | 困难 | [
"DFS"
] | 给你一个 `n` 个节点的树(也就是一个无环连通无向图),节点编号从 `0` 到 `n - 1`,且恰好有 `n - 1` 条边,每个节点有一个值,树的根节点为 `0` 号点。
给你一个整数数组 `nums` 和一个二维数组 `edges` 来表示这棵树。
`nums[i]` 表示第 `i` 个点的值,$edges[j] = [u_{j}, v_{j}]$ 表示节点 $u_{j}$ 和节点 $v_{j}$ 在树中有一条边。
当 `gcd(x, y) == 1`,我们称两个数 `x` 和 `y` 是 互质的 ,其中 `gcd(x, y)` 是 `x` 和 `y` 的最大公约数。
从节点 `i` 到根最短路径上的点都是节点 `i` 的祖先节点,一个节点不是它自己的祖先节点。
请你返回一个大小为 `n` 的数组 `ans`,其中 `ans[i]` 是离节点 `i` 最近的祖先节点且满足 `nums[i]` 和 `nums[ans[i]]` 是互质的,如果不存在这样的祖先节点,`ans[i]` 为 `-1`。
示例 1:
```
输入:nums = [2,3,3,2], edges = [[0,1],[1,2],[1,3]]
输出:[-1,0,0,1]
解释:上图中,每个节点的值在括号中表示。
- 节点 0 没有互质祖先。
- 节点 1 只有一个祖先节点 0 。它们的值是互质的(gcd(2,3) == 1)。
- 节点 2 有两个祖先节点,分别是节点 1 和节点 0 。节点 1 的值与它的值不是互质的(gcd(3,3) == 3)但节点 0 的值是互质的(gcd(2,3) == 1),所以节点 0 是最近的符合要求的祖先节点。
- 节点 3 有两个祖先节点,分别是节点 1 和节点 0 。它与节点 1 互质(gcd(3,2) == 1),所以节点 1 是离它最近的符合要求的祖先节点。
```
示例 2:
```
输入:nums = [5,6,10,2,3,6,15], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]
输出:[-1,0,-1,0,0,0,-1]
```
提示:
* $nums.length = n$
* $1 <= nums[i] <= 50$
* $1 <= n <= 10^5$
* $edges.length = n - 1$
* $edges[j].length = 2$
* $0 <= u_{j}, v_{j} < n$
* $u_{j} \neq v_{j}$ | ### DFS
题目描述很长,但其实就是说每个节点从下往上找,找到最近的「与其互质」的节点。
数据范围是 $10^5$,如果每个节点都直接往上找最近「互质」祖宗节点的话,当树为线性时,复杂度是 $O(n^2)$ ,会超时。
因此我们要利用 $nums[i]$ 范围只有 $50$ 的特性。
我们可以先预处理除 $[1, 50]$ 范围内的每个数,求出他们互质的数有哪些,存到一个字典里。
那么对于某个节点而言,假设节点的值为 `x` ,所在层数为 `y`。
那么问题转化为求与 `x` 互质的数有哪些,最近的在哪一层。
用 `dep[x]` 表示距离值为 `x` 的节点最近的层是多少;`pos[x]` 代表具体的节点编号。
代码:
```java
class Solution {
int[] ans;
Map<Integer, List<Integer>> map = new HashMap<>(); // 边映射
Map<Integer, List<Integer>> val = new HashMap<>(); // 互质数字典
int[] dep;
int[] pos = new int[52];
public int[] getCoprimes(int[] nums, int[][] edges) {
int n = nums.length;
ans = new int[n];
dep = new int[n];
Arrays.fill(ans, - 1);
Arrays.fill(pos, -1);
for (int[] edge : edges) {
int a = edge[0], b = edge[1];
List<Integer> alist = map.getOrDefault(a, new ArrayList<>());
alist.add(b);
map.put(a, alist);
List<Integer> blist = map.getOrDefault(b, new ArrayList<>());
blist.add(a);
map.put(b, blist);
}
for (int i = 1; i <= 50; i++) {
for (int j = 1; j <= 50; j++) {
if (gcd(i, j) == 1) {
List<Integer> list = val.getOrDefault(i, new ArrayList<>());
list.add(j);
val.put(i, list);
}
}
}
dfs(nums, 0, -1);
return ans;
}
void dfs(int[] nums, int u, int form) {
int t = nums[u];
for (int v : val.get(t)) {
if (pos[v] == -1) continue;
if (ans[u] == -1 || dep[ans[u]] < dep[pos[v]]) ans[u] = pos[v];
}
int p = pos[t];
pos[t] = u;
for (int i : map.get(u)) {
if (i == form) continue;
dep[i] = dep[u] + 1;
dfs(nums, i, u);
}
pos[t] = p;
}
int gcd(int a, int b) {
if (b == 0) return a;
if (a == 0) return b;
return gcd(b, a % b);
}
}
```
* 时间复杂度:对于每个节点而言,会检查与其数值互质的数有哪些,在哪层。最坏情况下会检查 50 个互质数(当前数值为 1)。复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1766` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1768. 交替合并字符串（简单）.md | 1768. 交替合并字符串 | https://leetcode.cn/problems/merge-strings-alternately/solution/by-ac_oier-rjve/ | 简单 | [
"模拟"
] | 给你两个字符串 `word1` 和 `word2`。请你从 `word1` 开始,通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长,就将多出来的字母追加到合并后字符串的末尾。
返回 合并后的字符串 。
示例 1:
```
输入:word1 = "abc", word2 = "pqr"
输出:"apbqcr"
解释:字符串合并情况如下所示:
word1: a b c
word2: p q r
合并后: a p b q c r
```
示例 2:
```
输入:word1 = "ab", word2 = "pqrs"
输出:"apbqrs"
解释:注意,word2 比 word1 长,"rs" 需要追加到合并后字符串的末尾。
word1: a b
word2: p q r s
合并后: a p b q r s
```
示例 3:
```
输入:word1 = "abcd", word2 = "pq"
输出:"apbqcd"
解释:注意,word1 比 word2 长,"cd" 需要追加到合并后字符串的末尾。
word1: a b c d
word2: p q
合并后: a p b q c d
```
提示:
* $1 <= word1.length, word2.length <= 100$
* `word1` 和 `word2` 由小写英文字母组成 | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public String mergeAlternately(String s1, String s2) {
int n = s1.length(), m = s2.length(), i = 0, j = 0;
StringBuilder sb = new StringBuilder();
while (i < n || j < m) {
if (i < n) sb.append(s1.charAt(i++));
if (j < m) sb.append(s2.charAt(j++));
}
return sb.toString();
}
}
```
TypeScript 代码:
```TypeScript
function mergeAlternately(s1: string, s2: string): string {
let n = s1.length, m = s2.length, i = 0, j = 0
let ans = ""
while (i < n || j < m) {
if (i < n) ans += s1[i++]
if (j < m) ans += s2[j++]
}
return ans
}
```
Python 代码:
```Python
class Solution:
def mergeAlternately(self, s1: str, s2: str) -> str:
n, m, i, j = len(s1), len(s2), 0, 0
ans = ""
while i < n or j < m:
if i < n:
ans += s1[i]
i += 1
if j < m:
ans += s2[j]
j += 1
return ans
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1768` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1761-1770/1769. 移动所有球到每个盒子所需的最小操作数（中等）.md | 1769. 移动所有球到每个盒子所需的最小操作数 | null | 中等 | [
"模拟"
] | 有 `n` 个盒子。给你一个长度为 `n` 的二进制字符串 `boxes`,其中 `boxes[i]` 的值为 `'0'` 表示第 `i` 个盒子是 空 的,而 `boxes[i]` 的值为 `'1'` 表示盒子里有 一个 小球。
在一步操作中,你可以将 一个 小球从某个盒子移动到一个与之相邻的盒子中。第 `i` 个盒子和第 `j` 个盒子相邻需满足 `abs(i - j) == 1`。注意,操作执行后,某些盒子中可能会存在不止一个小球。
返回一个长度为 `n` 的数组 `answer`,其中 `answer[i]` 是将所有小球移动到第 `i` 个盒子所需的 最小 操作数。
每个 `answer[i]` 都需要根据盒子的 初始状态 进行计算。
示例 1:
```
输入:boxes = "110"
输出:[1,1,3]
解释:每个盒子对应的最小操作数如下:
1) 第 1 个盒子:将一个小球从第 2 个盒子移动到第 1 个盒子,需要 1 步操作。
2) 第 2 个盒子:将一个小球从第 1 个盒子移动到第 2 个盒子,需要 1 步操作。
3) 第 3 个盒子:将一个小球从第 1 个盒子移动到第 3 个盒子,需要 2 步操作。将一个小球从第 2 个盒子移动到第 3 个盒子,需要 1 步操作。共计 3 步操作。
```
示例 2:
```
输入:boxes = "001011"
输出:[11,8,5,4,3,4]
```
提示:
* $n = boxes.length$
* $1 <= n <= 2000$
* `boxes[i]` 为 `'0'` 或 `'1'` | ### 模拟
预处理两个与 `boxes` 等长的数组 `l` 和 `r`:$l[i]$ 和 $r[i]$ 分别代表「将 $[0, i]$ 的小球移动到位置 $i$」以及「将 $[i, n - 1]$ 的小球移动到位置 $i$」所需要的步数。
所求的答案数组 `ans` 与数组 `l` 和 `r` 的关系为:$ans[i] = l[i] + r[i]$。
预处理两数组是简单的:分别从两个方向遍历 `boxes`,使用变量 `cur` 代表当前处理到的前缀/后缀的小球总个数,变量 `step` 代表将当前所有前缀/后缀小球移动到位置 $i$ 所需要的步数。
Java 代码:
```Java
class Solution {
public int[] minOperations(String boxes) {
int n = boxes.length();
int[] l = new int[n + 10], r = new int[n + 10];
for (int i = 0, cur = 0, step = 0; i < n; i++) {
step += cur; cur += boxes.charAt(i) - '0'; l[i] = step;
}
for (int i = n - 1, cur = 0, step = 0; i >= 0; i--) {
step += cur; cur += boxes.charAt(i) - '0'; r[i] = step;
}
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = l[i] + r[i];
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function minOperations(boxes: string): number[] {
const n = boxes.length
const l = new Array<number>(n + 10).fill(0), r = new Array<number>(n + 10).fill(0)
for (let i = 0, cur = 0, step = 0; i < n; i++) {
step += cur; cur += boxes[i] == '1' ? 1 : 0; l[i] = step;
}
for (let i = n - 1, cur = 0, step = 0; i >= 0; i--) {
step += cur; cur += boxes[i] == '1' ? 1 : 0; r[i] = step;
}
const ans = new Array<number>(n).fill(0)
for (let i = 0; i < n; i++) ans[i] = l[i] + r[i]
return ans
}
```
Python 代码:
```Python
class Solution:
def minOperations(self, boxes: str) -> List[int]:
n = len(boxes)
l, r = [0] * n, [0] * n
step, cur = 0, 0
for i in range(n):
step, cur = step + cur, cur + 1 if boxes[i] == '1' else cur
l[i] = step
step, cur = 0, 0
for i in range(n - 1, -1, -1):
step, cur = step + cur, cur + 1 if boxes[i] == '1' else cur
r[i] = step
return [l[i] + r[i] for i in range(n)]
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1769` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1771-1780/1773. 统计匹配检索规则的物品数量（简单）.md | 1773. 统计匹配检索规则的物品数量 | https://leetcode.cn/problems/count-items-matching-a-rule/solution/by-ac_oier-qyd6/ | 简单 | [
"模拟"
] | 给你一个数组 `items` ,其中 $items[i] = [type_{i}, color_{i}, name_{i}]$ ,描述第 `i` 件物品的类型、颜色以及名称。
另给你一条由两个字符串 `ruleKey` 和 `ruleValue` 表示的检索规则。
如果第 `i` 件物品能满足下述条件之一,则认为该物品与给定的检索规则 匹配 :
* `ruleKey = "type"` 且 $ruleValue = type_{i}$ 。
* `ruleKey = "color"` 且 $ruleValue = color_{i}$。
* `ruleKey = "name"` 且 $ruleValue = name{i}$。
统计并返回 匹配检索规则的物品数量 。
示例 1:
```
输入:items = [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]], ruleKey = "color", ruleValue = "silver"
输出:1
解释:只有一件物品匹配检索规则,这件物品是 ["computer","silver","lenovo"] 。
```
示例 2:
```
输入:items = [["phone","blue","pixel"],["computer","silver","phone"],["phone","gold","iphone"]], ruleKey = "type", ruleValue = "phone"
输出:2
解释:只有两件物品匹配检索规则,这两件物品分别是 ["phone","blue","pixel"] 和 ["phone","gold","iphone"] 。注意,["computer","silver","phone"] 未匹配检索规则。
```
提示:
* $1 <= items.length <= 10^4$
* $1 <= type_{i}.length, color_{i}.length, name_{i}.length, ruleValue.length <= 10$
* `ruleKey` 等于 `"type"`、`"color"` 或 `"name"`
* 所有字符串仅由小写字母组成 | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int countMatches(List<List<String>> items, String k, String v) {
int ans = 0, idx = k.charAt(0) == 't' ? 0 : k.charAt(0) == 'c' ? 1 : 2;
for (List<String> item : items) {
if (item.get(idx).equals(v)) ans++;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function countMatches(items: string[][], k: string, v: string): number {
let ans = 0, idx = k[0] == 't' ? 0 : k[0] == 'c' ? 1 : 2
for (const item of items) {
if (item[idx] == v) ans++
}
return ans
}
```
Python 代码:
```Python
class Solution:
def countMatches(self, items: List[List[str]], k: str, v: str) -> int:
ans, idx = 0, 0 if k[0] == 't' else 1 if k[0] == 'c' else 2
for item in items:
if item[idx] == v:
ans += 1
return ans
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1773` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1771-1780/1775. 通过最少操作次数使数组的和相等（中等）.md | 1775. 通过最少操作次数使数组的和相等量 | https://leetcode.cn/problems/equal-sum-arrays-with-minimum-number-of-operations/solutions/2582561/gong-shui-san-xie-fen-qing-kuang-tao-lun-saa1/ | 中等 | [
"枚举",
"贪心",
"数学"
] | 给你两个长度可能不等的整数数组 `nums1` 和 `nums2` 。两个数组中的所有值都在 `1` 到 `6` 之间(包含 `1` 和 `6`)。
每次操作中,你可以选择 任意 数组中的任意一个整数,将它变成 `1` 到 `6` 之间 任意 的值(包含 `1` 和 `6`)。
请你返回使 `nums1` 中所有数的和与 `nums2` 中所有数的和相等的最少操作次数。如果无法使两个数组的和相等,请返回 `-1` 。
示例 1:
```
输入:nums1 = [1,2,3,4,5,6], nums2 = [1,1,2,2,2,2]
输出:3
解释:你可以通过 3 次操作使 nums1 中所有数的和与 nums2 中所有数的和相等。以下数组下标都从 0 开始。
- 将 nums2[0] 变为 6 。 nums1 = [1,2,3,4,5,6], nums2 = [6,1,2,2,2,2] 。
- 将 nums1[5] 变为 1 。 nums1 = [1,2,3,4,5,1], nums2 = [6,1,2,2,2,2] 。
- 将 nums1[2] 变为 2 。 nums1 = [1,2,2,4,5,1], nums2 = [6,1,2,2,2,2] 。
```
示例 2:
```
输入:nums1 = [1,1,1,1,1,1,1], nums2 = [6]
输出:-1
解释:没有办法减少 nums1 的和或者增加 nums2 的和使二者相等。
```
示例 3:
```
输入:nums1 = [6,6], nums2 = [1]
输出:3
解释:你可以通过 3 次操作使 nums1 中所有数的和与 nums2 中所有数的和相等。以下数组下标都从 0 开始。
- 将 nums1[0] 变为 2 。 nums1 = [2,6], nums2 = [1] 。
- 将 nums1[1] 变为 2 。 nums1 = [2,2], nums2 = [1] 。
- 将 nums2[0] 变为 4 。 nums1 = [2,2], nums2 = [4] 。
```
提示:
* $1 <= nums1.length, nums2.length <= 10^5$
* $1 <= nums1[i], nums2[i] <= 6$ | ### 枚举 + 贪心 + 数学
令 `nums1` 的长度为 `n`,`nums2` 的长度为 `m`,根据题意两数组的值域分别为 $[n, 6n]$ 和 $[m, 6m]$,可分别视为数轴上的两条线段。
为了方便,我们人为固定 $n\leq m$,若不满足则交换两数组,返回 `minOperations(nums2, nums1)` 即可。
先来考虑无解的情况:当 $6n < m$ 时,说明两线段不重合,必然无法通过变换使得总和相等,直接返回 `-1`。
由于 $\max(n, m)$ 的范围为 $1e5$,且 $nums[i]$ 的值域大小 $C = 6$,因此我们可以通过枚举最终目标和 `x`(两线段的重合部分)来做,枚举范围不超过 $6 \times 1e5$。
于是问题转换为:**对于一个原总和为 `sum` 的数组 `nums` 而言,按照题目的变换规则,至少经过多少次变换,才能将其总和变为 `x`**。
根据原总和 `sum` 和目标结果 `x` 的大小关系进行分情况讨论(将两者差值绝对值记为 `d`):
* 当 $sum < x$ 时,对于原数为 $nums[i]$ 的数而言,其能变为不超过 $nums[i] - 1$ 的任意数。
例如 $6$ 能够变化为 $[1, 5]$ 中的任意数,即单个数值 $6$ 最多能够抵消 $6 - 1$ 个差值,不失一般性的可概括为原数为 $nums[i]$ 所能抵消的差值为 $nums[i] - 1$。
因此,我们贪心的使用较大数进行变换(从 $6$ 往 $2$ 枚举 `i`),对于每个数值 `i` 而言,其所能提供的个数为 $\min(\left \lceil \frac{d}{i - 1} \right \rceil, cnst[i])$。
* 当 $sum > x$ 时,同理,原数为 $nums[i]$ 所能提供的最大抵消数为 $6 - nums[i]$,因此我们贪心使用较小数进行变换(从 $1$ 往 $5$ 枚举 `i`),对于每个数值 `i` 而言,其所能提供的个数为 $\min(\left \lceil \frac{d}{6 - i} \right \rceil, cnst[i])$。
如此一来,我们通过枚举两线段重合点 `x`,复杂度为 $O(C \times \max(n, m))$,并通过复杂度为 $O(C)$ 的数学方法来得知将两原数组总和变为 `x` 所需要的操作次数 `cnt`,在所有的 `cnt` 取最小值即是答案。整体计算量为 $3.6 \times 10^6$,可以过。
Java 代码:
```Java
class Solution {
int[] c1 = new int[10], c2 = new int[10];
int s1, s2;
public int minOperations(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
if (n > m) return minOperations(nums2, nums1);
if (m > 6 * n) return -1;
for (int x : nums1) {
c1[x]++; s1 += x;
}
for (int x : nums2) {
c2[x]++; s2 += x;
}
int ans = n + m;
for (int i = m; i <= 6 * n; i++) ans = Math.min(ans, getCnt(c1, s1, i) + getCnt(c2, s2, i));
return ans;
}
int getCnt(int[] cnts, int sum, int x) {
int ans = 0;
if (sum > x) {
for (int i = 6, d = sum - x; i >= 2 && d > 0; i--) {
int c = Math.min((int) Math.ceil(d * 1.0 / (i - 1)), cnts[i]);
ans += c; d -= c * (i - 1);
}
} else if (sum < x) {
for (int i = 1, d = x - sum; i <= 5 && d > 0; i++) {
int c = Math.min((int) Math.ceil(d * 1.0 / (6 - i)), cnts[i]);
ans += c; d -= c * (6 - i);
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int c1[10], c2[10];
int s1, s2;
int minOperations(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size(), m = nums2.size();
if (n > m) return minOperations(nums2, nums1);
if (m > 6 * n) return -1;
for (int x : nums1) {
c1[x]++; s1 += x;
}
for (int x : nums2) {
c2[x]++; s2 += x;
}
int ans = n + m;
for (int i = m; i <= 6 * n; i++) {
ans = min(ans, getCnt(c1, s1, i) + getCnt(c2, s2, i));
}
return ans;
}
int getCnt(int cnts[], int sum, int x) {
int ans = 0;
if (sum > x) {
for (int i = 6, d = sum - x; i >= 2 && d > 0; i--) {
int c = min((int) ceil(d * 1.0 / (i - 1)), cnts[i]);
ans += c; d -= c * (i - 1);
}
} else if (sum < x) {
for (int i = 1, d = x - sum; i <= 5 && d > 0; i++) {
int c = min((int) ceil(d * 1.0 / (6 - i)), cnts[i]);
ans += c; d -= c * (6 - i);
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def minOperations(self, nums1: List[int], nums2: List[int]) -> int:
n, m = len(nums1), len(nums2)
if n > m:
return self.minOperations(nums2, nums1)
if m > 6 * n:
return -1
c1, c2 = Counter(nums1), Counter(nums2)
s1, s2 = sum(nums1), sum(nums2)
def getCnt(cnts, tot, x):
ans = 0
if tot > x:
d = tot - x
for i in range(6, 1, -1):
if d <= 0:
break
c = min(math.ceil(d / (i - 1)), cnts[i])
ans, d = ans + c, d - c * (i - 1)
elif tot < x:
d = x - tot
for i in range(1, 6):
if d <= 0:
break
c = min(math.ceil(d / (6 - i)), cnts[i])
ans, d = ans + c, d - c * (6 - i)
return ans
ans = n + m
for i in range(m, 6 * n + 1):
ans = min(ans, getCnt(c1, s1, i) + getCnt(c2, s2, i))
return ans
```
* 时间复杂度:$O(C \times \max(n, m) \times C)$,其中 $C = 6$ 为 $nums[i]$ 的值域大小
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1775` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1771-1780/1780. 判断一个数字是否可以表示成三的幂的和（中等）.md | 1780. 判断一个数字是否可以表示成三的幂的和 | https://acoier.com/2022/12/12/1780.%20%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E6%95%B0%E5%AD%97%E6%98%AF%E5%90%A6%E5%8F%AF%E4%BB%A5%E8%A1%A8%E7%A4%BA%E6%88%90%E4%B8%89%E7%9A%84%E5%B9%82%E7%9A%84%E5%92%8C%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"数学"
] | 给你一个整数 `n`,如果你可以将 `n` 表示成若干个不同的三的幂之和,请你返回 `true`,否则请返回 `false`。
对于一个整数 `y`,如果存在整数 `x` 满足 $y = 3^x$,我们称这个整数 `y` 是三的幂。
示例 1:
```
输入:n = 12
输出:true
解释:12 = 31 + 32
```
示例 2:
```
输入:n = 91
输出:true
解释:91 = 30 + 32 + 34
```
示例 3:
```
输入:n = 21
输出:false
```
提示:
* $1 <= n <= 10^7$ | ### 数学
这是一道考察「进制转换」基本认识的题目。
将 `n` 看作一个三进制数,例如对于 $(210)_{3}$ 而言,其代表的是 $2 \times 3^2 + 1 \times 3^1 + 0 \times 3^0$ 十进制数。
由于题目规定组成和的三的幂需要满足「不同」的条件,因此 `n` 所代表的三进制表示中的系数只能是 $1$ 或 $0$,而不是能是 $2$。
Java 代码:
```Java
class Solution {
public boolean checkPowersOfThree(int n) {
while (n != 0) {
if (n % 3 == 2) return false;
n /= 3;
}
return true;
}
}
```
C++ 代码
```C++
class Solution {
public:
bool checkPowersOfThree(int n) {
while (n != 0) {
if (n % 3 == 2) return false;
n /= 3;
}
return true;
}
};
```
Python 代码
```Python
class Solution:
def checkPowersOfThree(self, n: int) -> bool:
while n != 0:
if n % 3 == 2:
return False
n //= 3
return True
```
TypeScript 代码:
```TypeScript
function checkPowersOfThree(n: number): boolean {
while (n != 0) {
if (n % 3 == 2) return false
n = Math.floor(n / 3)
}
return true
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1780` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1781. 所有子字符串美丽值之和（中等）.md | 1781. 所有子字符串美丽值之和 | null | 中等 | [
"模拟",
"哈希表"
] | 一个字符串的 美丽值 定义为:出现频率最高字符与出现频率最低字符的出现次数之差。
比方说,`"abaacc"` 的美丽值为 `3 - 1 = 2`。
给你一个字符串 `s` ,请你返回它所有子字符串的 美丽值 之和。
示例 1:
```
输入:s = "aabcb"
输出:5
解释:美丽值不为零的字符串包括 ["aab","aabc","aabcb","abcb","bcb"] ,每一个字符串的美丽值都为 1 。
```
示例 2:
```
输入:s = "aabcbaa"
输出:17
```
提示:
* $1 <= s.length <= 500$
* `s` 只包含小写英文字母。 | ### 模拟 + 哈希表
数据范围只有 $500$,我们可以通过两层循环的方式枚举所有子串,当枚举子串左端点 `i` 的时候,可以同步开一个大小为 $C = 26$ 的数组来记录每个字母的出现次数,随后通过遍历该数组来得知最大和最小频次,将当前子串对应的美丽值累加到答案。
该做法复杂度为 $O(n^2 \times C)$,计算量约为 $500 \times 500 \times 26 = 6.5 \times 10^6$,可以过。
在确定了子串的左端点 `i`,枚举右端点 `j` 的过程中,维护最大频次是简单的,关键在于如果知晓最小频次,我们可以额外起一个哈希表 `map` 来记录出现频次为 `x` 的字符有多少个,`map[x] = cnt` 含义为频次为 `x` 的字符类型有 `cnt` 种。
假设当前我们处理的字符为 `c`,根据字符 `c` 原来的频次进行分情况讨论(使用 `max` 和 `min` 分别记录当前最大最小频次):
* 若字符 `c` 为首次出现,即原频次为 $0$,此时有最小频次 `min = 1`
* 当字符 `c` 为并非首次出现,假设原频次数为 `x`,此时频次为 `x` 的字符数量减一;频次为 `x + 1` 的字符数量加一,若频次为 `x` 的字符数量在减一后 $map[min] \leq 0$,说明没有频次为 `min` 的字符了,此时最小频次为 `min + 1`
Java 代码:
```Java
class Solution {
public int beautySum(String s) {
int n = s.length(), ans = 0;
for (int i = 0; i < n; i++) {
int[] cnts = new int[26];
Map<Integer, Integer> map = new HashMap<>();
int min = -1, max = -1;
for (int j = i; j < n; j++) {
int c = s.charAt(j) - 'a';
map.put(cnts[c], map.getOrDefault(cnts[c], 0) - 1);
map.put(cnts[c] + 1, map.getOrDefault(cnts[c] + 1, 0) + 1);
cnts[c]++;
if (cnts[c] == 1) min = 1;
else if (map.get(min) <= 0) min++;
max = Math.max(max, cnts[c]);
ans += max - min;
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int beautySum(string s) {
int n = s.size(), cnts[26], ans = 0;
unordered_map<int, int> map;
for(int i = 0; i < n; ++i) {
memset(cnts, 0, sizeof(cnts));
map.clear();
int min = -1, maxv = -1;
for(int j = i; j < n; ++j) {
int c = s[j] - 'a';
map[cnts[c]]--; map[cnts[c] + 1]++;
cnts[c]++;
if(cnts[c] == 1) min = 1;
else if(map[min] <= 0) min++;
maxv = max(maxv, cnts[c]);
ans += maxv - min;
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def beautySum(self, s: str) -> int:
n, ans = len(s), 0
for i in range(n):
cnts = [0] * 26
dmap = defaultdict(int)
maxv, minv = -1, -1
for j in range(i, n):
c = ord(s[j]) - ord('a')
dmap[cnts[c]] -= 1
dmap[cnts[c] + 1] += 1
cnts[c] += 1
if cnts[c] == 1:
minv = 1
elif dmap[minv] <= 0:
minv += 1
maxv = max(maxv, cnts[c])
ans += maxv - minv
return ans
```
TypeScript 代码:
```TypeScript
function beautySum(s: string): number {
let n = s.length, ans = 0
for (let i = 0; i < n; i++) {
const cnts = new Array<number>(26).fill(0)
const map = new Map()
let min = 0, max = 0
for (let j = i; j < n; j++) {
const c = s.charCodeAt(j) - 'a'.charCodeAt(0)
if (!map.has(cnts[c])) map.set(cnts[c], 0)
map.set(cnts[c], map.get(cnts[c]) - 1)
if (!map.has(cnts[c] + 1)) map.set(cnts[c] + 1, 0)
map.set(cnts[c] + 1, map.get(cnts[c] + 1) + 1)
cnts[c]++
if (cnts[c] == 1) min = 1
else if (map.get(min) <= 0) min++
max = Math.max(max, cnts[c])
ans += max - min
}
}
return ans
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1781` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1784. 检查二进制字符串字段（简单）.md | 1784. 检查二进制字符串字段 | https://leetcode.cn/problems/check-if-binary-string-has-at-most-one-segment-of-ones/solution/by-ac_oier-kiu6/ | 简单 | [
"模拟"
] | 给你一个二进制字符串 `s` ,该字符串 不含前导零 。
如果 `s` 包含 零个或一个由连续的 `'1'` 组成的字段 ,返回 `true`。否则,返回 `false`。
如果 `s` 中 由连续若干个 `'1'` 组成的字段 数量不超过 `1`,返回 `true`。否则,返回 `false`。
示例 1:
```
输入:s = "1001"
输出:false
解释:由连续若干个 '1' 组成的字段数量为 2,返回 false
```
示例 2:
```
输入:s = "110"
输出:true
```
提示:
* $1 <= s.length <= 100$
* `s[i]` 为 `'0'` 或 `'1'`
* `s[0]` 为 `'1'` | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public boolean checkOnesSegment(String s) {
int n = s.length(), cnt = 0, idx = 0;
while (idx < n && cnt <= 1) {
while (idx < n && s.charAt(idx) == '0') idx++;
if (idx < n) {
while (idx < n && s.charAt(idx) == '1') idx++;
cnt++;
}
}
return cnt <= 1;
}
}
```
TypeScript 代码:
```TypeScript
function checkOnesSegment(s: string): boolean {
let n = s.length, cnt = 0, idx = 0
while (idx < n && cnt <= 1) {
while (idx < n && s[idx] == '0') idx++
if (idx < n) {
while (idx < n && s[idx] == '1') idx++
cnt++
}
}
return cnt <= 1
};
```
Python 代码:
```Python
class Solution:
def checkOnesSegment(self, s: str) -> bool:
n, cnt, idx = len(s), 0, 0
while idx < n and cnt <= 1:
while idx < n and s[idx] == '0':
idx += 1
if idx < n:
while idx < n and s[idx] == '1':
idx += 1
cnt += 1
return cnt <= 1
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1784` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1785. 构成特定和需要添加的最少元素（中等）.md | 1785. 构成特定和需要添加的最少元素 | https://acoier.com/2022/12/16/1785.%20%E6%9E%84%E6%88%90%E7%89%B9%E5%AE%9A%E5%92%8C%E9%9C%80%E8%A6%81%E6%B7%BB%E5%8A%A0%E7%9A%84%E6%9C%80%E5%B0%91%E5%85%83%E7%B4%A0%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/ | 中等 | [
"贪心",
"模拟"
] | 给你一个整数数组 `nums`,和两个整数 `limit` 与 `goal`。
数组 `nums` 有一条重要属性:`abs(nums[i]) <= limit`。
返回使数组元素总和等于 `goal` 所需要向数组中添加的 最少元素数量 ,添加元素 不应改变 数组中 `abs(nums[i]) <= limit` 这一属性。
注意,如果 `x >= 0`,那么 `abs(x)` 等于 `x` ;否则,等于 `-x`。
示例 1:
```
输入:nums = [1,-1,1], limit = 3, goal = -4
输出:2
解释:可以将 -2 和 -3 添加到数组中,数组的元素总和变为 1 - 1 + 1 - 2 - 3 = -4 。
```
示例 2:
```
输入:nums = [1,-10,9,1], limit = 100, goal = 0
输出:1
```
提示:
* $1 <= nums.length <= 10^5$
* $1 <= limit <= 10^6$
* $-limit <= nums[i] <= limit$
* $-10^9 <= goal <= 10^9$ | ### 贪心
对于 `nums` 而言,我们可以先通过 $O(n)$ 的遍历求得其原总和 `sum` 为何值。
若 `sum` 与 `goal` 不等,我们可以按照「贪心」的方式里添加元素。
由于添加的元素需要满足 `abs(x) <= limit` 要求,因此我们添加数的范围在 $[-limit, limit]$ 之间。
为确保添加的元素最小,我们应当优先添加能够有效抵消两者差值的数值(添加 $limit$ 或 $-limit$),添加个数为 $\left \lceil \frac{\left | sum - goal \right |}{limit} \right \rceil$。
Java 代码:
```Java
class Solution {
public int minElements(int[] nums, int limit, int goal) {
long sum = 0;
for (int x : nums) sum += x;
return (int) ((Math.abs(sum - goal) + limit - 1) / limit);
}
}
```
TypeScript 代码:
```TypeScript
function minElements(nums: number[], limit: number, goal: number): number {
let sum = 0
for (const x of nums) sum += x
return Math.ceil(Math.abs(sum - goal) / limit)
}
```
Python 代码:
```Python
class Solution:
def minElements(self, nums: List[int], limit: int, goal: int) -> int:
sumv = sum(nums)
return (abs(sumv - goal) + limit - 1) // limit
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1785` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1786. 从第一个节点出发到最后一个节点的受限路径数（中等）.md | 1786. 从第一个节点出发到最后一个节点的受限路径数 | https://leetcode-cn.com/problems/number-of-restricted-paths-from-first-to-last-node/solution/xiang-jie-dui-you-hua-dijkstra-dong-tai-i6j0d/ | 中等 | [
"最短路",
"线性 DP"
] | 现有一个加权无向连通图。给你一个正整数 `n` ,表示图中有 `n` 个节点,并按从 `1` 到 `n` 给节点编号;另给你一个数组 `edges`,其中每个 $edges[i] = [u_{i}, v_{i}, weight_{i}]$ 表示存在一条位于节点 $u_{i}$ 和 $v_{i}$ 之间的边,这条边的权重为 $weight_{i}$ 。
从节点 start 出发到节点 `end` 的路径是一个形如 $[z_{0}, z_{1}, z_{2}, ..., z_{k}]$ 的节点序列,满足 $z_{0} = start$ 、$z_{k} = end$ 且在所有符合 $0 <= i <= k-1$ 的节点 $z_{i}$ 和 $z_{i}+1$ 之间存在一条边。
路径的距离定义为这条路径上所有边的权重总和。用 `distanceToLastNode(x)` 表示节点 `n` 和 `x` 之间路径的最短距离。受限路径 为满足 $distanceToLastNode(z_{i}) > distanceToLastNode(z_{i}+1)$ 的一条路径,其中 $0 <= i <= k-1$ 。
返回从节点 `1` 出发到节点 `n` 的 受限路径数 。由于数字可能很大,请返回对 $10^9 + 7$ 取余 的结果。
示例 1:
```
输入:n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]
输出:3
解释:每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。三条受限路径分别是:
1) 1 --> 2 --> 5
2) 1 --> 2 --> 3 --> 5
3) 1 --> 3 --> 5
```
示例 2:
```
输入:n = 7, edges = [[1,3,1],[4,1,2],[7,3,4],[2,5,3],[5,6,1],[6,7,2],[7,5,3],[2,6,4]]
输出:1
解释:每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。唯一一条受限路径是:1 --> 3 --> 7 。
```
提示:
* $1 <= n <= 2 \times 10^4$
* $n - 1 <= edges.length <= 4 \times 10^4$
* $edges[i].length == 3$
* $1 <= ui, vi <= n$
* $u_i != v_i$
* $1 <= weighti <= 10^5$
* 任意两个节点之间至多存在一条边
* 任意两个节点之间至少存在一条路径 | ### 堆优化 Dijkstra + 动态规划
`n` 为点的数量,`m` 为边的数量。
为了方便理解,我们将第 `n` 个点称为「起点」,第 `1` 个点称为「结尾」。
按照题意,我们需要先求每个点到结尾的「最短路」,求最短路的算法有很多,通常根据「有无负权边」& 「稠密图还是稀疏图」进行选择。
该题只有正权变,而且“边”和“点”的数量在一个数量级上,属于稀疏图。
因此我们可以采用「最短路」算法:堆优化的 Dijkstra,复杂度为 $O(m\log{n})$。
> PS. 通常会优先选择 SPFA,SPFA 通常情况下复杂度为 $O(m)$,但最坏情况下复杂度为 $O(n \times m)$。从数据上来说 SPFA 也会超,而且本题还结合了 DP,因此可能会卡掉图论部分的 SPFA。出于这些考虑,我直接使用堆优化 Dijkstra。
当我们求得了每个点到结尾的「最短路」之后,接下来我们需要求得从「起点」到「结尾」的**受限路径数量**。
这显然可以用 DP 来做。
我们定义 `f(i)` 为从第 `i` 个点到结尾的受限路径数量,`f(1)` 就是我们的答案,而 `f(n) = 1` 是一个显而易见的起始条件。
因为题目的**受限路径数**的定义,我们需要找的路径所包含的点,必须是其距离结尾的最短路越来越近的。
举个🌰,对于示例 `1`,其中一条符合要求的路径为 `1 --> 2 --> 3 --> 5`。
这条路径的搜索过程可以看做,从结尾(第 5 个点)出发,逆着走,每次选择一个点(例如 a)之后,再选择下一个点(例如 b)时就必须**满足最短路距离比上一个点(点 a)要远**,如果最终能选到起点(第一个点),说明统计出一条有效路径。
我们的搜索方式决定了需要先按照最短路距离进行从小到大排序。
**不失一般性,当我们要求 `f(i)` 的时候,其实找的是 `i` 点可以到达的点 `j`,并且 `j` 点到结尾的最短路要严格小于 `i` 点到结尾的最短路。**
符合条件的点 `j` 有很多个,将所有的 `f(j)` 累加即是 `f(i)`。
代码:
```java
class Solution {
int mod = 1000000007;
public int countRestrictedPaths(int n, int[][] es) {
// 预处理所有的边权。 a b w -> a : { b : w } + b : { a : w }
Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
for (int[] e : es) {
int a = e[0], b = e[1], w = e[2];
Map<Integer, Integer> am = map.getOrDefault(a, new HashMap<Integer, Integer>());
am.put(b, w);
map.put(a, am);
Map<Integer, Integer> bm = map.getOrDefault(b, new HashMap<Integer, Integer>());
bm.put(a, w);
map.put(b, bm);
}
// 堆优化 Dijkstra:求 每个点 到 第n个点 的最短路
int[] dist = new int[n + 1];
boolean[] st = new boolean[n + 1];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[n] = 0;
Queue<int[]> q = new PriorityQueue<int[]>((a, b)->a[1]-b[1]); // 点编号,点距离。根据点距离从小到大
q.add(new int[]{n, 0});
while (!q.isEmpty()) {
int[] e = q.poll();
int idx = e[0], cur = e[1];
if (st[idx]) continue;
st[idx] = true;
Map<Integer, Integer> mm = map.get(idx);
if (mm == null) continue;
for (int i : mm.keySet()) {
dist[i] = Math.min(dist[i], dist[idx] + mm.get(i));
q.add(new int[]{i, dist[i]});
}
}
// dp 过程
int[][] arr = new int[n][2];
for (int i = 0; i < n; i++) arr[i] = new int[]{i + 1, dist[i + 1]}; // 点编号,点距离
Arrays.sort(arr, (a, b)->a[1]-b[1]); // 根据点距离从小到大排序
// 定义 f(i) 为从第 i 个点到结尾的受限路径数量
// 从 f[n] 递推到 f[1]
int[] f = new int[n + 1];
f[n] = 1;
for (int i = 0; i < n; i++) {
int idx = arr[i][0], cur = arr[i][1];
Map<Integer, Integer> mm = map.get(idx);
if (mm == null) continue;
for (int next : mm.keySet()) {
if (cur > dist[next]) {
f[idx] += f[next];
f[idx] %= mod;
}
}
// 第 1 个节点不一定是距离第 n 个节点最远的点,但我们只需要 f[1],可以直接跳出循环
if (idx == 1) break;
}
return f[1];
}
}
```
* 时间复杂度:求最短路的复杂度为 $O(m\log{n})$,DP 过程坏情况下要扫完所有的边,复杂度为 $O(m)$。整体复杂度为 $O(m\log{n})$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1786` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1787. 使所有区间的异或结果为零（困难）.md | 1787. 使所有区间的异或结果为零 | https://leetcode-cn.com/problems/make-the-xor-of-all-segments-equal-to-zero/solution/gong-shui-san-xie-chou-xiang-cheng-er-we-ww79/ | 困难 | [
"线性 DP",
"异或",
"数学"
] | 给你一个整数数组 `nums` 和一个整数 `k` 。
区间 `[left, right]``(left <= right)`的 异或结果 是对下标位于 `left` 和 `right`(包括 `left` 和 `right` )之间所有元素进行 XOR 运算的结果:`nums[left] XOR nums[left+1] XOR ... XOR nums[right]` 。
返回数组中**要更改的最小元素数** ,以使所有长度为 `k` 的区间异或结果等于零。
示例 1:
```
输入:nums = [1,2,0,3,0], k = 1
输出:3
解释:将数组 [1,2,0,3,0] 修改为 [0,0,0,0,0]
```
示例 2:
```
输入:nums = [3,4,5,2,1,7,3,4,7], k = 3
输出:3
解释:将数组 [3,4,5,2,1,7,3,4,7] 修改为 [3,4,7,3,4,7,3,4,7]
```
示例 3:
```
输入:nums = [1,2,4,1,2,5,1,2,6], k = 3
输出:3
解释:将数组[1,2,4,1,2,5,1,2,6] 修改为 [1,2,3,1,2,3,1,2,3]
```
提示:
* 1 <= k <= nums.length <= 2000
* 0 <= nums[i] < $2^{10}$ | ### 基本分析
题目示例所包含的提示过于明显了,估计很多同学光看三个样例就猜出来了:**答案数组必然是每 $k$ 个一组进行重复的。**
这样的性质是可由「答案数组中所有长度为 $k$ 的区间异或结果为 $0$」推导出来的:
* 假设区间 $[i, j]$ 长度为 $k$,其异或结果为 $0$。即 $nums[i] ⊕ nums[i + 1] ⊕ ... ⊕ nums[j] = 0$
* 长度不变,将区间整体往后移动一位 $[i + 1, j + 1]$,其异或结果为 $0$。即 $nums[i + 1] ⊕ ... ⊕ nums[j] ⊕ nums[j + 1] = 0$
* 两式结合,中间 $[i + 1, j]$ 区间的数值出现两次,抵消掉最终剩下 $nums[i] ⊕ nums[j + 1] = 0$,即推出 $nums[i]$ 必然等于 $num[j + 1]$。
即答案数组必然每 $k$ 个一组进行重复。
也可以从滑动窗口的角度分析:窗口每滑动一格,会新增和删除一个值。对于异或而言,新增和删除都是对值本身做异或,因此新增值和删除值相等(保持窗口内异或值为 $0$)。
因此我们将这个一维的输入看成二维,从而将问题转化为:**使得最终每列相等,同时「首行」的异或值为 $0$ 的最小修改次数。**
当然 $n$ 和 $k$ 未必成倍数关系,这时候最后一行可能为不足 $k$ 个。这也是为什么上面没有说「每行异或结果为 $0$」,而是说「首行异或结果为 $0$」的原因:
***
### 动态规划
定义 $f[i][xor]$ 为考虑前 $i$ 列,且首行前 $i$ 列异或值为 $xor$ 的最小修改次数,最终答案为 $f[k - 1][0]$。
第一维的范围为 $[0, k)$,由输入参数给出;第二维为 $[0, 2^{10})$,根据题目给定的数据范围 `0 <= nums[i] < 2^10` 可得(异或为不进位加法,因此最大异或结果不会超过 $2^{10}$)。
为了方便,我们需要使用哈希表 $map$ 记录每一列的数字分别出现了多少次,使用变量 $cnt$ 统计该列有多少数字(因为最后一行可能不足 $k$ 个)。
不失一般性的考虑 $f[i][xor]$ 如何转移:
* 当前处于第 $0$ 列:由于没有前一列,这时候只需要考虑怎么把该列变成 $xor$ 即可:
$$
f[0][xor] = cnt - map.get(xor)
$$
* 当前处于其他列:需要考虑与前面列的关系。
我们知道最终的 $f[i][xor]$ 由两部分组成:一部分是前 $i - 1$ 列的修改次数,一部分是当前列的修改次数。
这时候需要分情况讨论:
* **仅修改当列的部分数**:这时候需要从哈希表中遍历已存在的数,在所有方案中取 $min$:
$$
f[i][xor] = f[i - 1][xor ⊕ cur] + cnt - map.get(cur)
$$
* **对整列进行修改替换**:此时当前列的修改成本固定为 $cnt$,只需要取前 $i - 1$ 列的最小修改次数过来即可:
$$
f[i][xor] = f[i - 1][xor'] + cnt
$$
最终 $f[i][xor]$ 在所有上述方案中取 $min$。为了加速「取前 $i - 1$ 列的最小修改次数」的过程,我们可以多开一个 $g[]$ 数组来记录前一列的最小状态值。
代码:
```Java
class Solution {
public int minChanges(int[] nums, int k) {
int n = nums.length;
int max = 1024;
int[][] f = new int[k][max];
int[] g = new int[k];
for (int i = 0; i < k; i++) {
Arrays.fill(f[i], 0x3f3f3f3f);
g[i] = 0x3f3f3f3f;
}
for (int i = 0, cnt = 0; i < k; i++, cnt = 0) {
// 使用 map 和 cnt 分别统计当前列的「每个数的出现次数」和「有多少个数」
Map<Integer, Integer> map = new HashMap<>();
for (int j = i; j < n; j += k) {
map.put(nums[j], map.getOrDefault(nums[j], 0) + 1);
cnt++;
}
if (i == 0) { // 第 0 列:只需要考虑如何将该列变为 xor 即可
for (int xor = 0; xor < max; xor++) {
f[0][xor] = Math.min(f[0][xor], cnt - map.getOrDefault(xor, 0));
g[0] = Math.min(g[0], f[0][xor]);
}
} else { // 其他列:考虑与前面列的关系
for (int xor = 0; xor < max; xor++) {
f[i][xor] = g[i - 1] + cnt; // 整列替换
for (int cur : map.keySet()) { // 部分替换
f[i][xor] = Math.min(f[i][xor], f[i - 1][xor ^ cur] + cnt - map.get(cur));
}
g[i] = Math.min(g[i], f[i][xor]);
}
}
}
return f[k - 1][0];
}
}
```
* 时间复杂度:共有 $O(C * k)$ 个状态需要被转移(其中 $C$ 固定为 $2^{10}$),每个状态的转移需要遍历哈希表,最多有 $\frac{n}{k}$ 个数,复杂度为 $O(\frac{n}{k})$。整体复杂度为 $O(C * n)$
* 空间复杂度:$O(C * k)$,其中 $C$ 固定为 $2^{10} + 1$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1787` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1781-1790/1790. 仅执行一次字符串交换能否使两个字符串相等（简单）.md | 1790. 仅执行一次字符串交换能否使两个字符串相等 | https://leetcode-cn.com/problems/make-the-xor-of-all-segments-equal-to-zero/solution/gong-shui-san-xie-chou-xiang-cheng-er-we-ww79/ | 简单 | [
"模拟"
] | 给你长度相等的两个字符串 `s1` 和 `s2` 。一次 字符串交换 操作的步骤如下:选出某个字符串中的两个下标(不必不同),并交换这两个下标所对应的字符。
如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:s1 = "bank", s2 = "kanb"
输出:true
解释:例如,交换 s2 中的第一个和最后一个字符可以得到 "bank"
```
示例 2:
```
输入:s1 = "attack", s2 = "defend"
输出:false
解释:一次字符串交换无法使两个字符串相等
```
示例 3:
```
输入:s1 = "kelb", s2 = "kelb"
输出:true
解释:两个字符串已经相等,所以不需要进行字符串交换
```
示例 4:
```
输入:s1 = "abcd", s2 = "dcba"
输出:false
```
提示:
* $1 <= s1.length, s2.length <= 100$
* $s1.length = s2.length$
* `s1` 和 `s2` 仅由小写英文字母组成 | ### 模拟
根据题意进行模拟即可 : 使用 `a` 和 `b` 记录不同的位置下标,初始值为 `-1`,若「不同位置超过 $2$ 个」或「只有 $1$ 个」直接返回 `false`,若「不存在不同位置」或「不同位置字符相同」,则返回 `true`。
Java 代码:
```Java
class Solution {
public boolean areAlmostEqual(String s1, String s2) {
int n = s1.length(), a = -1, b = -1;
for (int i = 0; i < n; i++) {
if (s1.charAt(i) == s2.charAt(i)) continue;
if (a == -1) a = i;
else if (b == -1) b = i;
else return false;
}
if (a == -1) return true;
if (b == -1) return false;
return s1.charAt(a) == s2.charAt(b) && s1.charAt(b) == s2.charAt(a);
}
}
```
TypeScript 代码:
```TypeScript
function areAlmostEqual(s1: string, s2: string): boolean {
let n = s1.length, a = -1, b = -1
for (let i = 0; i < n; i++) {
if (s1[i] == s2[i]) continue
if (a == -1) a = i
else if (b == -1) b = i
else return false
}
if (a == -1) return true
if (b == -1) return false
return s1[a] == s2[b] && s1[b] == s2[a]
}
```
Python 代码:
```Python
class Solution:
def areAlmostEqual(self, s1: str, s2: str) -> bool:
n, a, b = len(s1), -1, -1
for i in range(n):
if s1[i] == s2[i]:
continue
if a == -1:
a = i
elif b == -1:
b = i
else:
return False
if a == -1:
return True
if b == -1:
return False
return s1[a] == s2[b] and s1[b] == s2[a]
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1790` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1791-1800/1791. 找出星型图的中心节点（简单）.md | 1791. 找出星型图的中心节点 | https://leetcode-cn.com/problems/find-center-of-star-graph/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-qoix/ | 简单 | [
"模拟"
] | 有一个无向的 星型 图,由 $n$ 个编号从 $1$ 到 $n$ 的节点组成。星型图有一个 中心 节点,并且恰有 $n - 1$ 条边将中心节点与其他每个节点连接起来。
给你一个二维整数数组 `edges` ,其中 $edges[i] = [u_i, v_i]$ 表示在节点 $u_i$ 和 $v_i$ 之间存在一条边。请你找出并返回 `edges` 所表示星型图的中心节点。
示例 1:
```
输入:edges = [[1,2],[2,3],[4,2]]
输出:2
解释:如上图所示,节点 2 与其他每个节点都相连,所以节点 2 是中心节点。
```
示例 2:
```
输入:edges = [[1,2],[5,1],[1,3],[1,4]]
输出:1
```
提示:
* $3 <= n <= 10^5$
* $edges.length == n - 1$
* $edges[i].length == 2$
* $1 <= u_i, v_i <= n$
* $u_i != v_i$
* 题目数据给出的 `edges` 表示一个有效的星型图 | ### 模拟
根据题意,中心节点必然出现在所有的 $edges[i]$ 中,因此使用前两条边即可确定答案。
起始让 $edges[0][0]$ 和 $edges[0][1]$ 作为答案候选,然后在 $edges[1]$ 关系中检查哪个候选出现过。
代码:
```Java
class Solution {
public int findCenter(int[][] edges) {
int a = edges[0][0], b = edges[0][1];
if (a == edges[1][0] || a == edges[1][1]) return a;
else return b;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
---
### 进阶
**显然,如果将每个 $edges[i]$ 看做两点之间的「双向边」的话,那么星型图为「欧拉图」,所有点的出度均等于入度。**
容易将题拓展为求欧拉回路的问题:
>**给定星与星之间的距离,从某个星的位置出发,经过所有的边(可重复经过)并回到起点的最短距离,输出能够取得最短距离的路径(无解输出 $-1$)**。
答案就是求「欧拉回路」,其中「可重复经过边」包含了「可重复经过点」的含义。
由于星星图存在中心点,必然有解(但为了题目描述的完整性,出题都会预设一个无解返回值);同时也不会重复经过某条边(仍然是为了题目描述完整性才这样写)。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1791` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1791-1800/1797. 设计一个验证系统（中等）.md | 1797. 设计一个验证系统 | null | 中等 | [
"链表",
"哈希表"
] | 你需要设计一个包含验证码的验证系统。
每一次验证中,用户会收到一个新的验证码,这个验证码在 `ct` 时刻之后 `timeToLive` 秒过期。
如果验证码被更新了,那么它会在 `ct` (可能与之前的 `ct` 不同)时刻延长 `timeToLive` 秒。
请你实现 `AuthenticationManager` 类:
* `AuthenticationManager(int timeToLive)` 构造 `AuthenticationManager` 并设置 `timeToLive` 参数。
* `generate(string id, int ct)` 给定 `id`,在当前时间 `ct` 生成一个新的验证码。
* `renew(string id, int ct)` 将给定 `id` 且未过期的验证码在 `ct` 时刻更新。
如果给定 `id` 对应的验证码不存在或已过期,请你忽略该操作,不会有任何更新操作发生。
* `countUnexpiredTokens(int ct)` 请返回在给定 `ct` 时刻,未过期的验证码数目。
如果一个验证码在时刻 `t` 过期,且另一个操作恰好在时刻 `t` 发生(`renew` 或者 `countUnexpiredTokens` 操作),过期事件优先于其他操作。
示例 1:
```
输入:
["AuthenticationManager", "renew", "generate", "countUnexpiredTokens", "generate", "renew", "renew", "countUnexpiredTokens"]
[[5], ["aaa", 1], ["aaa", 2], [6], ["bbb", 7], ["aaa", 8], ["bbb", 10], [15]]
输出:
[null, null, null, 1, null, null, null, 0]
解释:
AuthenticationManager authenticationManager = new AuthenticationManager(5); // 构造 AuthenticationManager ,设置 timeToLive = 5 秒。
authenticationManager.renew("aaa", 1); // 时刻 1 时,没有验证码的 tokenId 为 "aaa" ,没有验证码被更新。
authenticationManager.generate("aaa", 2); // 时刻 2 时,生成一个 tokenId 为 "aaa" 的新验证码。
authenticationManager.countUnexpiredTokens(6); // 时刻 6 时,只有 tokenId 为 "aaa" 的验证码未过期,所以返回 1 。
authenticationManager.generate("bbb", 7); // 时刻 7 时,生成一个 tokenId 为 "bbb" 的新验证码。
authenticationManager.renew("aaa", 8); // tokenId 为 "aaa" 的验证码在时刻 7 过期,且 8 >= 7 ,所以时刻 8 的renew 操作被忽略,没有验证码被更新。
authenticationManager.renew("bbb", 10); // tokenId 为 "bbb" 的验证码在时刻 10 没有过期,所以 renew 操作会执行,该 token 将在时刻 15 过期。
authenticationManager.countUnexpiredTokens(15); // tokenId 为 "bbb" 的验证码在时刻 15 过期,tokenId 为 "aaa" 的验证码在时刻 7 过期,所有验证码均已过期,所以返回 0 。
```
提示:
* $1 <= timeToLive <= 10^8$
* $1 <= currentTime <= 10^8$
* $1 <= tokenId.length <= 5$
* `id` 只包含小写英文字母。
* 所有 `generate` 函数的调用都会包含独一无二的 `id` 值。
* 所有函数调用中,`ct` 的值严格递增。
* 所有函数的调用次数总共不超过 `2000` 次。 | ### 哈希表
数据范围只有 `20`,我们使用哈希表记录每个 `id` 的过期时间 `ct`,在每次查询时遍历整个哈希表来统计未过期的验证码数量。
Java 代码:
```Java
class AuthenticationManager {
int d;
Map<String, Integer> map = new HashMap<>();
public AuthenticationManager(int timeToLive) {
d = timeToLive;
}
public void generate(String id, int ct) {
map.put(id, ct + d);
}
public void renew(String id, int ct) {
if (!map.containsKey(id) || map.get(id) <= ct) return ;
map.put(id, ct + d);
}
public int countUnexpiredTokens(int ct) {
int ans = 0;
for (String id : map.keySet()) {
if (map.get(id) > ct) ans++;
}
return ans;
}
}
```
C++ 代码:
```C++
class AuthenticationManager {
int d;
unordered_map<string, int> map;
public:
AuthenticationManager(int timeToLive) : d(timeToLive){}
void generate(string id, int ct) {
map[id] = ct + d;
}
void renew(string id, int ct) {
if (!map.count(id) || map[id] <= ct) return;
map[id] = ct + d;
}
int countUnexpiredTokens(int ct) {
int ans = 0;
for (auto it = map.begin(); it != map.end(); ++it) {
if (it->second > ct) ans++;
}
return ans;
}
};
```
Python 代码:
```Python
class AuthenticationManager:
def __init__(self, timeToLive):
self.d = timeToLive
self.map = {}
def generate(self, id: str, ct: int) -> None:
self.map[id] = ct + self.d
def renew(self, id: str, ct: int) -> None:
if id not in self.map or self.map[id] <= ct:
return
self.map[id] = ct + self.d
def countUnexpiredTokens(self, ct: int) -> int:
ans = 0
for id in self.map:
if self.map[id] > ct:
ans += 1
return ans
```
TypeScript 代码:
```TypeScript
class AuthenticationManager {
d: number;
map: { [id: string]: number } = {};
constructor(timeToLive: number) {
this.d = timeToLive;
}
generate(id: string, ct: number): void {
this.map[id] = ct + this.d;
}
renew(id: string, ct: number): void {
if (!this.map.hasOwnProperty(id) || this.map[id] <= ct) {
return;
}
this.map[id] = ct + this.d;
}
countUnexpiredTokens(ct: number): number {
let ans = 0;
for (const id in this.map) {
if (this.map[id] > ct) {
ans++;
}
}
return ans;
}
}
```
* 时间复杂度:`generate` 操作和 `renew` 操作的复杂度为 $O(1)$;`countUnexpiredTokens` 操作的复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 双向链表
在所有函数的调用过程中,`timeToLive` 都在单调递增。
在哈希表的做法里,我们没有清理旧验证码的操作,同时每次执行 `countUnexpiredTokens` 时,需要对整个哈希表进行遍历。
实际上,如果我们引入 **双向链表**,并将哈希表的键值对定义从 `{验证码:过期时间值}` 调整为 `{验证码:链表节点}` 时(链表节点属性仅包含验证码字符串 `id` 及其过期时间 `t`),我们便能实现如下优化:
* **减少统计未过期验证码时的无效遍历**:由于构建的双向链表严格按照 `timeToLive` 递增,因此可以从尾部出发,从后往前利用链表节点的 `prev` 指针进行遍历统计。
如此一来,有多少未过期的验证码,我们就会遍历多少个链表节点,其余已过期的节点对象并不会被访问;
* **引入清理时机**:由于上述的统计过程,我们会找到最靠前的一个未过期节点。可以将其作为新的双向链表新头结点,从而将整段的过期节点从双向链表中删除
最后,我们像对其他链表题目一样,为了方便,引入 `he` 和 `ta` 的头尾链表哨兵节点以减少边界处理。
Java 代码:
```Java
class AuthenticationManager {
class Node {
String id;
int t;
Node prev, next;
Node (String _id, int _t) {
id = _id; t = _t;
}
}
int d;
Node he, ta;
Map<String, Node> map = new HashMap<>();
public AuthenticationManager(int timeToLive) {
he = new Node("", -1); ta = new Node("", (int)1e9);
he.next = ta; ta.prev = he;
d = timeToLive;
}
public void generate(String id, int ct) {
Node node = new Node(id, ct + d);
node.prev = ta.prev;
node.next = ta;
ta.prev.next = node;
ta.prev = node;
map.put(id, node);
}
public void renew(String id, int ct) {
if (!map.containsKey(id) || map.get(id).t <= ct) return ;
Node node = map.get(id);
node.prev.next = node.next;
node.next.prev = node.prev;
generate(id, ct);
}
public int countUnexpiredTokens(int ct) {
int ans = 0;
Node cur = ta.prev;
while (cur.t > ct && ++ans >= 0) cur = cur.prev;
he.next = cur.next;
cur.next.prev = he;
return ans;
}
}
```
C++ 代码:
```C++
class AuthenticationManager {
struct Node {
string id;
int t;
Node *prev, *next;
Node (string _id, int _t) : id(_id), t(_t), prev(nullptr), next(nullptr) {}
};
int d;
Node *he, *ta;
unordered_map<string, Node*> map;
public:
AuthenticationManager(int timeToLive) : d(timeToLive) {
he = new Node("", -1);
ta = new Node("", (int)1e9);
he->next = ta;
ta->prev = he;
}
void generate(string id, int ct) {
Node* node = new Node(id, ct + d);
node->prev = ta->prev;
node->next = ta;
ta->prev->next = node;
ta->prev = node;
map[id] = node;
}
void renew(string id, int ct) {
if (!map.count(id) || map[id]->t <= ct) return;
Node* node = map[id];
node->prev->next = node->next;
node->next->prev = node->prev;
generate(id, ct);
}
int countUnexpiredTokens(int ct) {
int ans = 0;
Node* cur = ta->prev;
while (cur->t > ct && ++ans >= 0) cur = cur->prev;
he->next = cur->next;
cur->next->prev = he;
return ans;
}
};
```
TypeScript 代码:
```TypeScript
class Node {
id: string;
t: number;
prev: Node | null;
next: Node | null;
constructor(_id: string, _t: number) {
this.id = _id;
this.t = _t;
this.prev = null
this.next = null
}
}
class AuthenticationManager {
d: number;
he: Node;
ta: Node;
map: {[id: string]: Node};
constructor(timeToLive: number) {
this.d = timeToLive;
this.he = new Node("", -1)
this.ta = new Node("", 1e9)
this.he.next = this.ta
this.ta.prev = this.he
this.map = {};
}
generate(id: string, ct: number) {
let node : Node = new Node(id, ct + this.d) ;
node.prev = this.ta.prev;
node.next = this.ta;
this.ta.prev!.next = node;
this.ta.prev = node;
this.map[id] = node;
}
renew(id: string, ct: number) {
if (!this.map.hasOwnProperty(id) || this.map[id].t <= ct) {
return;
}
var node : Node = this.map[id];
node.prev!.next = node.next;
node.next!.prev = node.prev;
this.generate(id, ct);
}
countUnexpiredTokens(ct: number) {
let ans = 0;
let cur : Node = this.ta.prev!;
while (cur.t > ct && ++ans >= 0)
cur = cur.prev!;
this.he.next = cur.next;
cur.next!.prev = this.he;
return ans;
}
}
```
* 时间复杂度:`generate` 操作和 `renew` 操作的复杂度为 $O(1)$;`countUnexpiredTokens` 操作的复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1797` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1791-1800/1798. 你能构造出连续值的最大数目（中等）.md | 1798. 你能构造出连续值的最大数目 | https://leetcode.cn/problems/maximum-number-of-consecutive-values-you-can-make/solutions/2607482/gong-shui-san-xie-shu-xue-lei-gou-zao-ti-wf47/ | 中等 | [
"数学",
"脑筋急转弯",
"排序",
"构造"
] | 给你一个长度为 `n` 的整数数组 `coins`,它代表你拥有的 `n` 个硬币。第 `i` 个硬币的值为 `coins[i]`。如果你从这些硬币中选出一部分硬币,它们的和为 `x` ,那么称,你可以构造出 `x` 。
请返回从 `0` 开始(包括 `0` ),你最多能构造出多少个连续整数。
你可能有多个相同值的硬币。
示例 1:
```
输入:coins = [1,3]
输出:2
解释:你可以得到以下这些值:
- 0:什么都不取 []
- 1:取 [1]
从 0 开始,你可以构造出 2 个连续整数。
```
示例 2:
```
输入:coins = [1,1,1,4]
输出:8
解释:你可以得到以下这些值:
- 0:什么都不取 []
- 1:取 [1]
- 2:取 [1,1]
- 3:取 [1,1,1]
- 4:取 [4]
- 5:取 [4,1]
- 6:取 [4,1,1]
- 7:取 [4,1,1,1]
从 0 开始,你可以构造出 8 个连续整数。
```
示例 3:
```
输入:nums = [1,4,10,3,1]
输出:20
```
提示:
* $coins.length = n$
* $1 <= n <= 4 \times 10^4$
* $1 <= coins[i] <= 4 \times 10^4$ | ### 数学
`n` 的数据范围为 $4 \times 10^4$,必然不是考察我们使用 `coins` 来构造单个数值 `x` 的逻辑,因为「遍历 + 逐个构造验证」的做法会超时,**因此只能是考察我们能否推导出整段构造的相关性质**。
假设我们已经用前 `k` 个数值构造出连段 $[0, x]$ 中的任意数,当增加第 $k + 1$ 个数值时,还能否进行连续构造:
* 若不能,则连续构造中断,答案为 $[0, x]$,共 $x + 1$ 个
* 若能,则再考虑连续构造的右边界会到哪个地方
由于题目允许我们任意使用 `coins` 中的数,同时整段构造又是不断扩大 $[0, x]$ 中右边界的过程(从小到大),为了方便,我们可以先对 `coins` 进行排序。
不失一般性,假设我们已经使用 `coins` 中的前 `k` 个数构造出了范围 $[0, x]$ 中的任意数。当考虑增加一个 $coins[k]$ 后,我们可在每一个原有构造方案中增加 $coins[k]$,这样由 $coins[k]$ 所拓展出的构造范围便是 $[coins[k], coins[k] + x]$。
原来的连续数是 $[0, x]$,若要保证连续,我们需要保证 $coins[k] <= x + 1$,此时构造连续段也从 $[0, x]$ 变为 $[0, coins[k] + x]$。
即 $coins[k] > k + 1$ 是中断构造必要条件,再结合我们实现对 `coins` 进行了排序,容易证明如果 $coins[k]$ 都不能满足 $coins[k] <= x + 1$,排在 $coins[k]$ 后面比其大的数均不能满足要求。
一些细节:起始时,我们可以不选 `coins` 中的任何数,即此时连续构造范围为 $[0, 0]$,随后从小到大遍历 `coins`,检查当前 $coins[i]$ 是否会中断构造。
Java 代码:
```Java
class Solution {
public int getMaximumConsecutive(int[] coins) {
Arrays.sort(coins);
int ans = 0;
for (int c : coins) {
if (c > ans + 1) break;
ans += c;
}
return ans + 1;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int getMaximumConsecutive(vector<int>& coins) {
sort(coins.begin(), coins.end());
int ans = 0;
for (int c : coins) {
if (c > ans + 1) break;
ans += c;
}
return ans + 1;
}
};
```
Python 代码:
```Python
class Solution:
def getMaximumConsecutive(self, coins: List[int]) -> int:
coins.sort()
ans = 0
for c in coins:
if c > ans + 1: break
ans += c
return ans + 1
```
TypeScript 代码:
```TypeScript
function getMaximumConsecutive(coins: number[]): number {
coins.sort((a,b)=>a-b)
let ans = 0
for (const c of coins) {
if (c > ans + 1) break
ans += c
}
return ans + 1
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1798` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1801-1810/1801. 积压订单中的订单总数（中等）.md | 1801. 积压订单中的订单总数 | https://leetcode-cn.com/problems/number-of-orders-in-the-backlog/solution/gss-by-ac_oier-4pqk/ | 中等 | [
"数据结构",
"模拟",
"优先队列(堆)"
] | 给你一个二维整数数组 $orders$ ,其中每个 $orders[i] = [price_i, amount_i, orderType_i]$ 表示有 $amount_i$ 笔类型为 $orderType_i$、价格为 $price_i$ 的订单。
订单类型 $orderType_i$ 可以分为两种:
* $0$ 表示这是一批采购订单 `buy`
* $1$ 表示这是一批销售订单 `sell`
注意,$orders[i]$ 表示一批共计 $amount_i$ 笔的独立订单,这些订单的价格和类型相同。
对于所有有效的 $i$ ,由 $orders[i]$ 表示的所有订单提交时间均早于 $orders[i+1]$ 表示的所有订单。
存在由未执行订单组成的积压订单。积压订单最初是空的。
提交订单时,会发生以下情况:
* 如果该订单是一采购订单 `buy`,则可以查看积压订单中价格 **最低** 的销售订单 `sell`。如果该销售订单 `sell` 的价格 **低于或等于** 当前采购订单 `buy` 的价格,则匹配并执行这两笔订单,并将销售订单 `sell` 从积压订单中删除。否则,采购订单 `buy` 将会添加到积压订单中。
* 反之亦然,如果该订单是一笔销售订单 `sell`,则可以查看积压订单中价格 **最高** 的采购订单 `buy`。如果该采购订单 `buy` 的价格 **高于或等于** 当前销售订单 `sell` 的价格,则匹配并执行这两笔订单,并将采购订单 `buy` 从积压订单中删除。否则,销售订单 `sell` 将会添加到积压订单中。
输入所有订单后,返回积压订单中的订单总数。
由于数字可能很大,所以需要返回对 $10^9 + 7$ 取余的结果。
示例 1:
```
输入:orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]
输出:6
解释:输入订单后会发生下述情况:
- 提交 5 笔采购订单,价格为 10 。没有销售订单,所以这 5 笔订单添加到积压订单中。
- 提交 2 笔销售订单,价格为 15 。没有采购订单的价格大于或等于 15 ,所以这 2 笔订单添加到积压订单中。
- 提交 1 笔销售订单,价格为 25 。没有采购订单的价格大于或等于 25 ,所以这 1 笔订单添加到积压订单中。
- 提交 4 笔采购订单,价格为 30 。前 2 笔采购订单与价格最低(价格为 15)的 2 笔销售订单匹配,从积压订单中删除这 2 笔销售订单。第 3 笔采购订单与价格最低的 1 笔销售订单匹配,销售订单价格为 25 ,从积压订单中删除这 1 笔销售订单。积压订单中不存在更多销售订单,所以第 4 笔采购订单需要添加到积压订单中。
最终,积压订单中有 5 笔价格为 10 的采购订单,和 1 笔价格为 30 的采购订单。所以积压订单中的订单总数为 6 。
```
示例 2:
```
输入:orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]
输出:999999984
解释:输入订单后会发生下述情况:
- 提交 109 笔销售订单,价格为 7 。没有采购订单,所以这 109 笔订单添加到积压订单中。
- 提交 3 笔采购订单,价格为 15 。这些采购订单与价格最低(价格为 7 )的 3 笔销售订单匹配,从积压订单中删除这 3 笔销售订单。
- 提交 999999995 笔采购订单,价格为 5 。销售订单的最低价为 7 ,所以这 999999995 笔订单添加到积压订单中。
- 提交 1 笔销售订单,价格为 5 。这笔销售订单与价格最高(价格为 5 )的 1 笔采购订单匹配,从积压订单中删除这 1 笔采购订单。
最终,积压订单中有 (1000000000-3) 笔价格为 7 的销售订单,和 (999999995-1) 笔价格为 5 的采购订单。所以积压订单中的订单总数为 1999999991 ,等于 999999984 % (109 + 7) 。
```
提示:
* $1 <= orders.length <= 10^5$
* $orders[i].length == 3$
* $1 <= pricei, amounti <= 10^9$
* `orderTypei` 为 $0$ 或 $1$ | ### 模拟 + 数据结构
整理题意:从前往后处理所有的 $orders[i]$,对于 `buy` 类型的订单,从积压订单中找价格低于等于当前价格的 `sell` 订单进行抵消;同理,对于 `sell` 类型的订单,从积压订单中找价格高于等于当前价格的 `buy` 订单进行抵消。问最终有多少积压订单。
这个找「最低/最高」价格的操作可以利用优先队列(堆)来做,对于积压的 `buy` 类型订单,我们总是要找价格高的,使用大根堆维护;对于积压的 `sell` 类型订单,我们总是要找价格低的,使用小根堆维护。
两个优先队列(堆)均维护形如 $(price_i, amount_i)$ 的二元组信息,代表价格为 $price_i$ 的订单积压了 $amount_i$ 单。
当处理(尝试匹配)了所有的 $orders[i]$ 之后,统计两个优先队列(堆)中订单数量即是答案。
代码:
```Java
class Solution {
public int getNumberOfBacklogOrders(int[][] orders) {
PriorityQueue<int[]> buy = new PriorityQueue<>((a,b)->b[0]-a[0]), sell = new PriorityQueue<>((a,b)->a[0]-b[0]);
PriorityQueue<int[]> from = null, to = null;
boolean fromIsSell = false;
for (int[] order : orders) {
int p = order[0], a = order[1], t = order[2];
if (t == 0) {
from = sell; to = buy; fromIsSell = true;
} else {
from = buy; to = sell; fromIsSell = false;
}
while (a > 0 && !from.isEmpty() && (fromIsSell ? from.peek()[0] <= p : from.peek()[0] >= p)) {
int[] cur = from.poll();
int cnt = Math.min(cur[1], a);
cur[1] -= cnt; a -= cnt;
if (cur[1] > 0) from.add(cur);
}
if (a > 0) to.add(new int[]{p, a});
}
int ans = 0;
for (PriorityQueue<int[]> q : new PriorityQueue[]{buy, sell}) {
while (!q.isEmpty()) {
ans += q.poll()[1];
ans %= (int)1e9+7;
}
}
return ans;
}
}
```
-
```Python
class Solution:
def getNumberOfBacklogOrders(self, orders: List[List[int]]) -> int:
buy, sell = [], []
for p, a, t in orders:
if t == 0:
from_heap, to_heap, from_is_sell = sell, buy, True
else:
from_heap, to_heap, from_is_sell = buy, sell, False
while a and from_heap and (from_heap[0][0] <= p if from_is_sell else -from_heap[0][0] >= p):
cur = heapq.heappop(from_heap)
if cur[1] > a:
heapq.heappush(from_heap, (cur[0], cur[1] - a))
a = 0
else:
a -= cur[1]
if a:
heapq.heappush(to_heap, (-p if from_is_sell else p, a))
ans, mod = 0, int(1e9)+7
for _, a in buy + sell:
ans += a
return ans % mod
```
* 时间复杂度:令$n$ 为数组 `orders` 的长度,复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1801` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1801-1810/1802. 有界数组中指定下标处的最大值（中等）.md | 1802. 有界数组中指定下标处的最大值 | https://leetcode.cn/problems/maximum-value-at-a-given-index-in-a-bounded-array/solutions/2363016/gong-shui-san-xie-chang-gui-zong-he-ti-b-ohvx/ | 中等 | [
"二分",
"数学",
"构造",
"贪心",
"模拟"
] | 给你三个正整数 `n`、`index` 和 `maxSum`。
你需要构造一个同时满足下述所有条件的数组 `nums`(下标 从 `0` 开始 计数):
* `nums.length == n`
* `nums[i]` 是 正整数 ,其中 `0 <= i < n`
* `abs(nums[i] - nums[i+1]) <= 1` ,其中 `0 <= i < n-1`
* `nums` 中所有元素之和不超过 `maxSum`
* `nums[index]` 的值被 最大化
* 返回你所构造的数组中的 `nums[index]`
注意:`abs(x)` 等于 `x` 的前提是 `x >= 0`;否则,`abs(x)` 等于 `-x`。
示例 1:
```
输入:n = 4, index = 2, maxSum = 6
输出:2
解释:数组 [1,1,2,1] 和 [1,2,2,1] 满足所有条件。不存在其他在指定下标处具有更大值的有效数组。
```
示例 2:
```
输入:n = 6, index = 1, maxSum = 10
输出:3
```
提示:
* $1 <= n <= maxSum <= 10^9$
* $0 <= index < n$ | ### 二分 + 贪心 + 数学
根据题意,容易想到以 `ans` 为分割点的正整数数组具有二段性,其中 `ans` 为最大的 $nums[idx]$。
小于等于 `ans` 的值均能通过直接调整 $nums[idx]$ 来构造,不会违反总和不超过 `max` 的限制;大于 `ans` 的值则无法满足 `max` 限制。基于此我们可通过「二分」的方式来找分割点。
假设当前二分到的值为 `x`,考虑如何实现一个 `check` 函数,该函数用于判断 `x` 能否作为 $nums[idx]$:
为了令 $nums[idx] = x$ 时,数组总和 `sum` 不超过 `max` 限制,我们应当贪心构造 $nums$ 的剩余元素:从 $idx$ 开始往两侧构造,按照递减的方式进行逐个构造,若递减到 $1$ 则维持不变。
这样可确保构造出来的 $nums$ 既满足 $nums[idx] = x$ 同时元素总和最小。
位置 `idx` 的值为 `x`,其左边有 `idx` 个元素,其右边有 `n - idx - 1` 个元素。
利用「等差数列求和」公式分别从 `x - 1` 开始构造(注意:这里说的构造仅是计算 $nums$ 总和),若总和不超过 `max` 说明 $nums[idx] = x$ 满足要求,我们令 $l = mid$,否则令 $r = mid - 1$。
Java 代码:
```Java
class Solution {
public int maxValue(int n, int index, int max) {
long l = 1, r = max;
while (l < r) {
long mid = l + r + 1 >> 1;
if (check(n, mid, index, max)) l = mid;
else r = mid - 1;
}
return (int) r;
}
boolean check(int n, long x, int idx, int max) {
long sum = x;
if (idx > x - 1) {
long an = x - 1, a1 = 1, cnt = x - 1;
sum += cnt * (a1 + an) / 2;
sum += idx - cnt;
} else {
long cnt = idx, an = x - 1, a1 = an - cnt + 1;
sum += cnt * (a1 + an) / 2;
}
if (n - idx - 1 > x - 1) {
long an = x - 1, a1 = 1, cnt = x - 1;
sum += cnt * (a1 + an) / 2;
sum += n - idx - 1 - cnt;
} else {
long cnt = n - idx - 1, an = x - 1, a1 = an - cnt + 1;
sum += cnt * (a1 + an) / 2;
}
return sum <= max;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxValue(int n, int index, int maxSum) {
long l = 1, r = maxSum;
while (l < r) {
long mid = (l + r + 1) >> 1;
if (check(n, mid, index, maxSum)) l = mid;
else r = mid - 1;
}
return (int) r;
}
bool check(int n, long x, int idx, int maxSum) {
long sum = x;
if (idx > x - 1) {
long an = x - 1, a1 = 1, cnt = x - 1;
sum += cnt * (a1 + an) / 2;
sum += idx - cnt;
} else {
long cnt = idx, an = x - 1, a1 = an - cnt + 1;
sum += cnt * (a1 + an) / 2;
}
if (n - idx - 1 > x - 1) {
long an = x - 1, a1 = 1, cnt = x - 1;
sum += cnt * (a1 + an) / 2;
sum += n - idx - 1 - cnt;
} else {
long cnt = n - idx - 1, an = x - 1, a1 = an - cnt + 1;
sum += cnt * (a1 + an) / 2;
}
return sum <= maxSum;
}
};
```
Python 代码:
```Python
class Solution:
def maxValue(self, n: int, index: int, maxSum: int) -> int:
l, r = 1, maxSum
while l < r:
mid = (l + r + 1) >> 1
if self.check(n, mid, index, maxSum):
l = mid
else:
r = mid - 1
return int(r)
def check(self, n, x, idx, maxSum):
sumv = x
if idx > x - 1:
an, a1, cnt = x - 1, 1, x - 1
sumv += cnt * (a1 + an) // 2
sumv += idx - cnt
else:
cnt, an, a1 = idx, x - 1, x - idx
sumv += cnt * (a1 + an) // 2
if n - idx - 1 > x - 1:
an, a1, cnt = x - 1, 1, x - 1
sumv += cnt * (a1 + an) // 2
sumv += n - idx - 1 - cnt
else:
cnt, an, a1 = n - idx - 1, x - 1, x - n + idx + 1
sumv += cnt * (a1 + an) // 2
return sumv <= maxSum
```
TypeScript 代码:
```TypeScript
function maxValue(n: number, index: number, maxSum: number): number {
const check = function(n: number, x: number, idx: number, maxSum: number): boolean {
let sum = x;
if (idx > x - 1) {
let an = x - 1, a1 = 1, cnt = x - 1;
sum += cnt * (a1 + an) / 2;
sum += idx - cnt;
} else {
let cnt = idx, an = x - 1, a1 = an - cnt + 1;
sum += cnt * (a1 + an) / 2;
}
if (n - idx - 1 > x - 1) {
let an = x - 1, a1 = 1, cnt = x - 1;
sum += cnt * (a1 + an) / 2;
sum += n - idx - 1 - cnt;
} else {
let cnt = n - idx - 1, an = x - 1, a1 = an - cnt + 1;
sum += cnt * (a1 + an) / 2;
}
return sum <= maxSum;
};
let l = 1, r = maxSum;
while (l < r) {
let mid = (l + r + 1) >> 1;
if (check(n, mid, index, maxSum)) l = mid;
else r = mid - 1;
}
return r;
};
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1802` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/181-190/187. 重复的DNA序列（中等）.md | 187. 重复的DNA序列 | https://leetcode-cn.com/problems/repeated-dna-sequences/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-30pg/ | 中等 | [
"滑动窗口",
"哈希表",
"字符串哈希",
"前缀和"
] | 所有 DNA 都由一系列缩写为 `'A'`,`'C'`,`'G'` 和 `'T'` 的核苷酸组成,例如:`"ACGAATTCCG"`。在研究 DNA 时,识别 DNA 中的重复序列有时会对研究非常有帮助。
编写一个函数来找出所有目标子串,目标子串的长度为 $10$,且在 DNA 字符串 `s` 中出现次数超过一次。
示例 1:
```
输入:s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
输出:["AAAAACCCCC","CCCCCAAAAA"]
```
示例 2:
```
输入:s = "AAAAAAAAAAAAA"
输出:["AAAAAAAAAA"]
```
提示:
* 0 <= s.length <= $10^5$
* `s[i]` 为 `'A'`、`'C'`、`'G'` 或 `'T'` | ### 滑动窗口 + 哈希表
数据范围只有 $10^5$,一个朴素的想法是:从左到右处理字符串 $s$,使用滑动窗口得到每个以 $s[i]$ 为结尾且长度为 $10$ 的子串,同时使用哈希表记录每个子串的出现次数,如果该子串出现次数超过一次,则加入答案。
为了防止相同的子串被重复添加到答案,而又不使用常数较大的 `Set` 结构。我们可以规定:当且仅当该子串在之前出现过一次(加上本次,当前出现次数为两次)时,将子串加入答案。
代码:
```Java
class Solution {
public List<String> findRepeatedDnaSequences(String s) {
List<String> ans = new ArrayList<>();
int n = s.length();
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i + 10 <= n; i++) {
String cur = s.substring(i, i + 10);
int cnt = map.getOrDefault(cur, 0);
if (cnt == 1) ans.add(cur);
map.put(cur, cnt + 1);
}
return ans;
}
}
```
* 时间复杂度:每次检查以 $s[i]$ 为结尾的子串,需要构造出新的且长度为 $10$ 的字符串。令 $C = 10$,复杂度为 $O(n * C)$
* 空间复杂度:长度固定的子串数量不会超过 $n$ 个。复杂度为 $O(n)$
---
### 字符串哈希 + 前缀和
子串长度为 $10$,因此上述解法的计算量为 $10^6$。
若题目给定的子串长度大于 $100$ 时,加上生成子串和哈希表本身常数操作,那么计算量将超过 $10^7$,会 TLE。
因此一个能够做到严格 $O(n)$ 的做法是使用「字符串哈希 + 前缀和」。
具体做法为,我们使用一个与字符串 $s$ 等长的哈希数组 $h[]$,以及次方数组 $p[]$。
由字符串预处理得到这样的哈希数组和次方数组复杂度为 $O(n)$。当我们需要计算子串 $s[i...j]$ 的哈希值,只需要利用前缀和思想 $h[j] - h[i - 1] * p[j - i + 1]$ 即可在 $O(1)$ 时间内得出哈希值(与子串长度无关)。
**到这里,还有一个小小的细节需要注意:如果我们期望做到严格 $O(n)$,进行计数的「哈希表」就不能是以 `String` 作为 `key`,只能使用 `Integer`(也就是 hash 结果本身)作为 `key`。因为 Java 中的 `String` 的 `hashCode` 实现是会对字符串进行遍历的,这样哈希计数过程仍与长度有关,而 `Integer` 的 `hashCode` 就是该值本身,这是与长度无关的。**
代码:
```Java
class Solution {
int N = (int)1e5+10, P = 131313;
int[] h = new int[N], p = new int[N];
public List<String> findRepeatedDnaSequences(String s) {
int n = s.length();
List<String> ans = new ArrayList<>();
p[0] = 1;
for (int i = 1; i <= n; i++) {
h[i] = h[i - 1] * P + s.charAt(i - 1);
p[i] = p[i - 1] * P;
}
Map<Integer, Integer> map = new HashMap<>();
for (int i = 1; i + 10 - 1 <= n; i++) {
int j = i + 10 - 1;
int hash = h[j] - h[i - 1] * p[j - i + 1];
int cnt = map.getOrDefault(hash, 0);
if (cnt == 1) ans.add(s.substring(i - 1, i + 10 - 1));
map.put(hash, cnt + 1);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 我猜你问
1. 字符串哈希的「构造 $p$ 数组」和「计算哈希」的过程,不会溢出吗?
会溢出,溢出就会变为负数,当且仅当两个哈希值溢出程度与 `Integer.MAX_VALUE` 呈不同的倍数关系时,会产生错误结果(哈希冲突),此时考虑修改 $P$ 或者采用表示范围更大的 `long` 来代替 `int`。
2. $P = 131313$ 这个数字是怎么来的?
WA 出来的,刚开始使用的 $P = 131$,被卡在了 $30/31$ 个样例。
字符串哈希本身存在哈希冲突的可能,一般会在尝试 $131$ 之后尝试使用 $13131$,然后再尝试使用比 $13131$ 更大的质数。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.187` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。
```
``` |
LeetCode/181-190/190. 颠倒二进制位（简单）.md | 190. 颠倒二进制位 | https://leetcode-cn.com/problems/reverse-bits/solution/yi-ti-san-jie-dui-cheng-wei-zhu-wei-fen-ub1hi/ | 简单 | [
"位运算",
"模拟"
] | 颠倒给定的 32 位无符号整数的二进制位。
提示:
* 请注意,在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,输入和输出都将被指定为有符号整数类型,并且不应影响您的实现,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的。
* 在 Java 中,编译器使用二进制补码记法来表示有符号整数。因此,在上面的 示例 2 中,输入表示有符号整数 -3,输出表示有符号整数 -1073741825。
进阶:
* 如果多次调用这个函数,你将如何优化你的算法?
示例 1:
```
输入: 00000010100101000001111010011100
输出: 00111001011110000010100101000000
解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596,
因此返回 964176192,其二进制表示形式为 00111001011110000010100101000000。
```
示例 2:
```
输入:11111111111111111111111111111101
输出:10111111111111111111111111111111
解释:输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293,
因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。
```
提示:
* 输入是一个长度为 32 的二进制字符串 | ### 「对称位」构造
一个简单的做法是对输入的 $n$ 做诸位检查。
**如果某一位是 1 的话,则将答案相应的对称位置修改为 1。**
代码:
```Java
public class Solution {
public int reverseBits(int n) {
int ans = 0;
for (int i = 0; i < 32; i++) {
int t = (n >> i) & 1;
if (t == 1) {
ans |= (1 << (31 - i));
}
}
return ans;
}
}
```
* 时间复杂度:$int$ 固定 32 位,循环次数不随输入样本发生改变。复杂度为 $O(1)$
* 空间复杂度:$O(1)$
***
### 「逐位分离」构造
另外一种做法是,每次都使用 $n$ 的最低一位,使用 $n$ 的最低一位去更新答案的最低一位,使用完将 $n$ 进行右移一位,将答案左移一位。
**相当于每次都用 $n$ 的最低一位更新成 $ans$ 的最低一位。**
代码:
```Java
public class Solution {
public int reverseBits(int n) {
int ans = 0;
int cnt = 32;
while (cnt-- > 0) {
ans <<= 1;
ans += (n & 1);
n >>= 1;
}
return ans;
}
}
```
* 时间复杂度:$int$ 固定 32 位,循环次数不随输入样本发生改变。复杂度为 $O(1)$
* 空间复杂度:$O(1)$
***
### 「分组互换」
事实上,可以对于长度固定的 $int$ 类型,我们可以使用「分组构造」的方式进行。
**两位互换 -> 四位互换 -> 八位互换 -> 十六位互换。**
代码:
```Java
public class Solution {
public int reverseBits(int n) {
n = ((n & 0xAAAAAAAA) >>> 1) | ((n & 0x55555555) << 1);
n = ((n & 0xCCCCCCCC) >>> 2) | ((n & 0x33333333) << 2);
n = ((n & 0xF0F0F0F0) >>> 4) | ((n & 0x0F0F0F0F) << 4);
n = ((n & 0xFF00FF00) >>> 8) | ((n & 0x00FF00FF) << 8);
n = ((n & 0xFFFF0000) >>> 16) | ((n & 0x0000FFFF) << 16);
return n;
}
}
```
* 时间复杂度:如何进行互换操作取决于 $int$ 长度。复杂度为 $O(1)$
* 空间复杂度:$O(1)$
**PS. 类似的做法我在 [191. 位1的个数](https://leetcode-cn.com/problems/number-of-1-bits/solution/yi-ti-san-jie-wei-shu-jian-cha-you-yi-to-av1r/) 也介绍过。如果大家学有余力的话,建议大家在纸上模拟一下这个过程。如果不想深入,也可以当成模板背过(写法非常固定)。**
**但请不要认为「方法三」一定就比「方法一」等直接采用循环的方式更快。此类做法的最大作用,不是处理 int,而是处理更大位数的情况,在长度只有 32 位的 int 的情况下,该做法不一定就比循环要快(该做法会产生多个的中间结果,导致赋值发生多次,而且由于指令之间存在对 n 数值依赖,可能不会被优化为并行指令),这个道理和对于排序元素少的情况下,我们会选择「冒泡排序」而不是「归并排序」是一样的,因为「冒泡排序」常数更小。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.190` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。
```
``` |
LeetCode/1811-1820/1816. 截断句子（简单）.md | 1816. 截断句子 | https://leetcode-cn.com/problems/truncate-sentence/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-l7gu/ | 简单 | [
"模拟"
] | 句子 是一个单词列表,列表中的单词之间用单个空格隔开,且不存在前导或尾随空格。
每个单词仅由大小写英文字母组成(不含标点符号)。
例如,`"Hello World"`、`"HELLO"` 和 `"hello world hello world"` 都是句子。
给你一个句子 `s` 和一个整数 `k` ,请你将 `s` 截断 ,使截断后的句子仅含 前 `k` 个单词。返回 截断 `s` 后得到的句子。
示例 1:
```
输入:s = "Hello how are you Contestant", k = 4
输出:"Hello how are you"
解释:
s 中的单词为 ["Hello", "how" "are", "you", "Contestant"]
前 4 个单词为 ["Hello", "how", "are", "you"]
因此,应当返回 "Hello how are you"
```
示例 2:
```
输入:s = "What is the solution to this problem", k = 4
输出:"What is the solution"
解释:
s 中的单词为 ["What", "is" "the", "solution", "to", "this", "problem"]
前 4 个单词为 ["What", "is", "the", "solution"]
因此,应当返回 "What is the solution"
```
示例 3:
```
输入:s = "chopper is not a tanuki", k = 5
输出:"chopper is not a tanuki"
```
提示:
* `1 <= s.length <= 500`
* `k` 的取值范围是 `[1, s 中单词的数目]`
* `s` 仅由大小写英文字母和空格组成
* `s` 中的单词之间由单个空格隔开
* 不存在前导或尾随空格 | ### 模拟
根据题意进行模拟,在拼接答案时对「空格」进行计数即可。
可通过 `StringBuilder` 实现拼接,也可以使用变量 `idx` 记录答案的结尾位置。
代码:
```Java
class Solution {
public String truncateSentence(String s, int k) {
StringBuilder sb = new StringBuilder();
int n = s.length();
for (int i = 0, cnt = 0; i < n && cnt < k; i++) {
char c = s.charAt(i);
if (c == ' ') cnt++;
if (cnt < k) sb.append(c);
}
return sb.toString();
}
}
```
```Java
class Solution {
public String truncateSentence(String s, int k) {
int n = s.length(), idx = 0;
while (idx < n) {
if (s.charAt(idx) == ' ' && --k == 0) break;
idx++;
}
return s.substring(0, idx);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1816` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1811-1820/1818. 绝对差值和（中等）.md | 1818. 绝对差值和 | https://leetcode-cn.com/problems/minimum-absolute-sum-difference/solution/gong-shui-san-xie-tong-guo-er-fen-zhao-z-vrmq/ | 中等 | [
"二分"
] | 给你两个正整数数组 `nums1` 和 `nums2` ,数组的长度都是 `n` 。
数组 `nums1` 和 `nums2` 的 **绝对差值和** 定义为所有 `|nums1[i] - nums2[i]|(0 <= i < n)`的 总和(下标从 $0$ 开始)。
你可以选用 `nums1` 中的 **任意一个** 元素来替换 `nums1` 中的 **至多** 一个元素,以 **最小化** 绝对差值和。
在替换数组 `nums1` 中最多一个元素 之后 ,返回最小绝对差值和。因为答案可能很大,所以需要对 $10^9 + 7$ 取余 后返回。
`|x|` 定义为:
* 如果 $x >= 0$,值为 `x` ,或者
* 如果 $x <= 0$,值为 `-x`
示例 1:
```
输入:nums1 = [1,7,5], nums2 = [2,3,5]
输出:3
解释:有两种可能的最优方案:
- 将第二个元素替换为第一个元素:[1,7,5] => [1,1,5] ,或者
- 将第二个元素替换为第三个元素:[1,7,5] => [1,5,5]
两种方案的绝对差值和都是 |1-2| + (|1-3| 或者 |5-3|) + |5-5| = 3
```
示例 2:
```
输入:nums1 = [2,4,6,8,10], nums2 = [2,4,6,8,10]
输出:0
解释:nums1 和 nums2 相等,所以不用替换元素。绝对差值和为 0
```
示例 3:
```
输入:nums1 = [1,10,4,4,2,7], nums2 = [9,3,5,1,7,4]
输出:20
解释:将第一个元素替换为第二个元素:[1,10,4,4,2,7] => [10,10,4,4,2,7]
绝对差值和为 |10-9| + |10-3| + |4-5| + |4-1| + |2-7| + |7-4| = 20
```
提示:
* $n == nums1.length$
* $n == nums2.length$
* $1 <= n <= 10^5$
* $1 <= nums1[i], nums2[i] <= $10^5$ | ### 二分
这是一道二分陈题,具体做法如下:
我们在进行处理前,先对 $nums1$ 进行拷贝并排序,得到 $sorted$ 数组。
然后 **在遍历 $nums1$ 和 $nums2$ 计算总的差值 $sum$ 时,通过对 $sorted$ 进行二分查找,找到最合适替换 $nums[i]$ 的值**。
具体的,当我们处理到第 $i$ 位时,假设该位的原差值为 $x = abs(nums1[i] - nums2[i])$,然后从 $sorted$ 数组中通过二分找到最接近 $nums2[i]$ 的值,计算一个新的差值 $nd$(注意要检查分割点与分割点的下一位),如果满足 $nd < x$ 说明存在一个替换方案使得差值变小,我们使用变量 $max$ 记下来这个替换方案所带来的变化,并不断更新 $max$。
当整个数组被处理完,$max$ 存储着最优方案对应的差值变化,此时 $sum - max$ 即是答案。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int minAbsoluteSumDiff(int[] nums1, int[] nums2) {
int n = nums1.length;
int[] sorted = nums1.clone();
Arrays.sort(sorted);
long sum = 0, max = 0;
for (int i = 0; i < n; i++) {
int a = nums1[i], b = nums2[i];
if (a == b) continue;
int x = Math.abs(a - b);
sum += x;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (sorted[mid] <= b) l = mid;
else r = mid - 1;
}
int nd = Math.abs(sorted[r] - b);
if (r + 1 < n) nd = Math.min(nd, Math.abs(sorted[r + 1] - b));
if (nd < x) max = Math.max(max, x - nd);
}
return (int)((sum - max) % mod);
}
}
```
* 时间复杂度:对 `sorted` 进行拷贝并排序的复杂度为 $O(n\log{n})$;遍历处理数组时会一边统计,一边尝试二分,找最合适的替换数值,复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:使用 `sorted` 数组需要 $O(n)$ 的空间复杂度,同时排序过程中会使用 $O(\log{n})$ 的空间复杂度;整体复杂度为 $O(n + \log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1818` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1821-1830/1822. 数组元素积的符号（简单）.md | 1822. 数组元素积的符号 | https://leetcode.cn/problems/sign-of-the-product-of-an-array/solution/by-ac_oier-qy0n/ | 简单 | [
"模拟"
] | 已知函数 `signFunc(x)` 将会根据 `x` 的正负返回特定值:
* 如果 `x` 是正数,返回 `1` 。
* 如果 `x` 是负数,返回 `-1` 。
* 如果 `x` 是等于 `0` ,返回 `0` 。
给你一个整数数组 `nums`。令 `product` 为数组 `nums` 中所有元素值的乘积。
返回 `signFunc(product)` 。
示例 1:
```
输入:nums = [-1,-2,-3,-4,3,2,1]
输出:1
解释:数组中所有值的乘积是 144 ,且 signFunc(144) = 1
```
示例 2:
```
输入:nums = [1,5,0,2,-3]
输出:0
解释:数组中所有值的乘积是 0 ,且 signFunc(0) = 0
```
示例 3:
```
输入:nums = [-1,1,-1,1,-1]
输出:-1
解释:数组中所有值的乘积是 -1 ,且 signFunc(-1) = -1
```
提示:
* $1 <= nums.length <= 1000$
* $-100 <= nums[i] <= 100$ | ### 模拟
根据题意进行模拟。
Java 代码:
```Java
class Solution {
public int arraySign(int[] nums) {
int ans = 1;
for (int x : nums) {
if (x == 0) return 0;
if (x < 0) ans *= -1;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function arraySign(nums: number[]): number {
let ans = 0
for (const x of nums) {
if (x == 0) return 0
if (x < 0) ans *= -1
}
return ans
}
```
Python 代码:
```Python
class Solution:
def arraySign(self, nums: List[int]) -> int:
ans = 1
for x in nums:
if x == 0:
return 0
if x < 0:
ans *= -1
return ans
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1822s` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1821-1830/1823. 找出游戏的获胜者（中等）.md | 1823. 找出游戏的获胜者 | https://leetcode-cn.com/problems/find-the-winner-of-the-circular-game/solution/by-ac_oier-qsuq/ | 中等 | [
"模拟",
"约瑟夫环"
] | 共有 $n$ 名小伙伴一起做游戏。小伙伴们围成一圈,按 顺时针顺序 从 $1$ 到 $n$ 编号。确切地说,从第 $i$ 名小伙伴顺时针移动一位会到达第 ($i+1$) 名小伙伴的位置,其中 $1 <= i < n$ ,从第 $n$ 名小伙伴顺时针移动一位会回到第 $1$ 名小伙伴的位置。
游戏遵循如下规则:
1. 从第 $1$ 名小伙伴所在位置 开始 。
2. 沿着顺时针方向数 $k$ 名小伙伴,计数时需要 包含 起始时的那位小伙伴。逐个绕圈进行计数,一些小伙伴可能会被数过不止一次。
3. 你数到的最后一名小伙伴需要离开圈子,并视作输掉游戏。
4. 如果圈子中仍然有不止一名小伙伴,从刚刚输掉的小伙伴的 顺时针下一位 小伙伴 开始,回到步骤 2 继续执行。
5. 否则,圈子中最后一名小伙伴赢得游戏。
给你参与游戏的小伙伴总数 $n$ ,和一个整数 $k$ ,返回游戏的获胜者。
示例 1:
```
输入:n = 5, k = 2
输出:3
解释:游戏运行步骤如下:
1) 从小伙伴 1 开始。
2) 顺时针数 2 名小伙伴,也就是小伙伴 1 和 2 。
3) 小伙伴 2 离开圈子。下一次从小伙伴 3 开始。
4) 顺时针数 2 名小伙伴,也就是小伙伴 3 和 4 。
5) 小伙伴 4 离开圈子。下一次从小伙伴 5 开始。
6) 顺时针数 2 名小伙伴,也就是小伙伴 5 和 1 。
7) 小伙伴 1 离开圈子。下一次从小伙伴 3 开始。
8) 顺时针数 2 名小伙伴,也就是小伙伴 3 和 5 。
9) 小伙伴 5 离开圈子。只剩下小伙伴 3 。所以小伙伴 3 是游戏的获胜者。
```
示例 2:
```
输入:n = 6, k = 5
输出:1
解释:小伙伴离开圈子的顺序:5、4、6、2、3 。小伙伴 1 是游戏的获胜者。
```
提示:
* $1 <= k <= n <= 500$ | ### 模拟
利用数据范围 $1 <= k <= n <= 500$,我们可以直接根据规则进行模拟。
创建一个标记数组 $vis$,若有 $vis[idx] = true$ 则代表点编号为 $idx$ 已被淘汰,每次我们都从当前位置 $cur$ 开始,找到第 $k$ 个尚未淘汰的点($vis[idx] = false$),并将其进行标记($vis[idx] = true$),共有 $n - 1$ 个点需要被淘汰。
一些细节,为了方便取模,我们调整点编号从 $1$ 开始,在返回答案时再重新调整为从 $1$ 开始。
代码:
```Java
class Solution {
public int findTheWinner(int n, int k) {
boolean[] vis = new boolean[n + 10];
int cnt = 0, cur = 0;
while (cnt != n - 1) {
for (int j = 0; j < k - 1; j++) {
cur++;
while (vis[cur % n]) cur++;
}
vis[cur % n] = true;
cnt++; cur++;
while (vis[cur % n]) cur++;
}
return (cur % n) + 1;
}
}
```
* 时间复杂度:要消除(被标记)的点数量为 $n - 1$,每次找到要消除的点编号,最多遍历 $n$ 个点,复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$
---
### 约瑟夫环
这还是一道约瑟夫环经典题。
> 另外一道同款题在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490948&idx=1&sn=a71c4ec3529277ad119702d7dacf510e&chksm=fd9cb69bcaeb3f8d5461518a15d969b45a13558a4c5810100f40200a12aac66f1876f2ef6de7&token=831443013&lang=zh_CN#rd) 🎉🎉
每次往同一方向,以固定步长 $k$ 进行消数。由于下一次操作的发起点为消除位置的下一个点(即前后两次操作发起点在原序列下标中相差 $k$),同时问题规模会从 $n$ 变为 $n - 1$,因此原问题答案等价于 `findTheWinner(n - 1, k) + k`。
一些细节,由于编号从 $1$ 开始,在返回答案时我们需要将结果为 $0$ 的值映射回编号 $n$。
代码:
```Java
class Solution {
public int findTheWinner(int n, int k) {
if (n <= 1) return n;
int ans = (findTheWinner(n - 1, k) + k) % n;
return ans == 0 ? n : ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1823` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1831-1840/1833. 雪糕的最大数量（中等）.md | 1833. 雪糕的最大数量 | https://leetcode-cn.com/problems/maximum-ice-cream-bars/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-yrhjx/ | 中等 | [
"贪心",
"排序"
] | 夏日炎炎,小男孩 Tony 想买一些雪糕消消暑。
商店中新到 `n` 支雪糕,用长度为 n 的数组 `costs` 表示雪糕的定价,其中 `costs[i]` 表示第 `i` 支雪糕的现金价格。
Tony 一共有 `coins` 现金可以用于消费,他想要买尽可能多的雪糕。
给你价格数组 `costs` 和现金量 `coins`,请你计算并返回 Tony 用 `coins` 现金能够买到的雪糕的 最大数量 。
注意:Tony 可以按任意顺序购买雪糕。
示例 1:
```
输入:costs = [1,3,2,4,1], coins = 7
输出:4
解释:Tony 可以买下标为 0、1、2、4 的雪糕,总价为 1 + 3 + 2 + 1 = 7
```
示例 2:
```
输入:costs = [10,6,8,7,7,8], coins = 5
输出:0
解释:Tony 没有足够的钱买任何一支雪糕。
```
```
示例 3:
输入:costs = [1,6,3,1,2,5],
输出:6
解释:Tony 可以买下所有的雪糕,总价为 1 + 6 + 3 + 1 + 2 + 5 = 18 。
```
提示:
* $costs.length = n$
* $1 <= n <= 10^5$
* $1 <= costs[i] <= 10^5$
* $1 <= coins <= 10^8$ | ### 基本分析
从题面看,是一道「01 背包」问题,每个物品的成本为 $cost[i]$,价值为 $1$。
但「01 背包」的复杂度为 $O(N\times C)$,其中 $N$ 为物品数量(数量级为 $10^5$),$C$ 为背包容量(数量级为 $10^8$)。显然会 `TLE`。
换个思路发现,每个被选择的物品对答案的贡献都是 $1$,优先选择价格小的物品会使得我们剩余金额尽可能的多,将来能够做的决策方案也就相应变多。
因此一个直观的做法是,对物品数组进行「从小到大」排序,然后「从前往后」开始决策购买。
---
### 证明
直观上,这样的贪心思路可以使得最终选择的物品数量最多。
接下来证明一下该思路的正确性。
假定贪心思路取得的序列为 $[a1,a2,a3,...,an]$(长度为 $n$),真实最优解所取得的序列为 $[b1,b2,b3,..,bm]$(长度为 $m$)。
两个序列均为「单调递增序列」。
其中最优解所对应具体方案不唯一,即存在多种选择方案使得物品数量相同。
因此,**我们只需要证明两个序列长度一致即可**。
按照贪心逻辑,最终选择的方案总成本不会超过 $coins$,因此至少是一个合法的选择方案,天然有 $n \leq m$,只需要证明 $n \geq m$ 成立,即可得证 $n = m$。
通过反证法证明 $n \geq m$ 成立,假设 $n \geq m$ 不成立,即有 $n < m$。
根据贪心决策,**我们选择的物品序列在「排序好的 $cost$ 数组」里,必然是一段连续的前缀。并且再选择下一物品将会超过总费用 $coins$;而真实最优解的选择方案在「排序好的 $cost$ 数组」里分布不定。**
这时候我们可以利用「**每个物品对答案的贡献均为 $1$,将最优解中的分布靠后的物品,替换为分布较前的物品,不会使得费用增加,同时答案不会变差**」。
从而将真实最优解也调整为某段连续的前缀。
**综上,通过反证法得证 $n \geq m$ 成立,结合 $n \leq m$,可推出 $n = m$。**
**即贪心解必然能够取得与最优解一样的长度。**
---
### 贪心
排序,从前往后决策,直到不能决策为止。
Java 代码:
```Java
class Solution {
public int maxIceCream(int[] costs, int coins) {
int n = costs.length;
Arrays.sort(costs);
int ans = 0;
for (int i = 0; i < n; i++) {
if (coins >= costs[i]) {
ans++; coins -= costs[i];
}
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def maxIceCream(self, costs: List[int], coins: int) -> int:
costs.sort()
ans = 0
for i in range(len(costs)):
if coins >= costs[i]:
ans += 1
coins -= costs[i]
return ans
```
C++ 代码:
```C++
class Solution {
public:
int maxIceCream(vector<int>& costs, int coins) {
int n = costs.size();
sort(costs.begin(), costs.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if (coins >= costs[i]) {
ans++; coins -= costs[i];
}
}
return ans;
}
};
```
TypeScript 代码:
```TypeScript
function maxIceCream(costs: number[], coins: number): number {
costs.sort((a, b) => a - b);
let ans = 0;
for (let i = 0; i < costs.length; i++) {
if (coins >= costs[i]) {
ans++; coins -= costs[i];
}
}
return ans;
};
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;获取答案的复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:排序复杂度为 $O(\log{n})$。整体复杂度为 $O(\log{n})$
PS. 这里假定 `Arrays.sort` 使用的是「双轴排序」的实现。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1833` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1831-1840/1834. 单线程 CPU（中等）.md | 1834. 单线程 CPU | https://leetcode-cn.com/problems/single-threaded-cpu/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-1qk0/ | 中等 | [
"模拟",
"排序",
"优先队列(堆)"
] | 给你一个二维数组 $tasks$,用于表示 $n$ 项从 $0$ 到 $n - 1$ 编号的任务。
其中 $tasks[i] = [enqueueTime_i, processingTime_i]$ 意味着第 $i$ 项任务将会于 $enqueueTime_i$ 时进入任务队列,需要 $processingTime_i$ 的时长完成执行。
现有一个单线程 CPU ,同一时间只能执行**最多一项**任务,该 CPU 将会按照下述方式运行:
* 如果 CPU 空闲,且任务队列中没有需要执行的任务,则 CPU 保持空闲状态。
* 如果 CPU 空闲,但任务队列中有需要执行的任务,则 CPU 将会选择 执行时间最短 的任务开始执行。如果多个任务具有同样的最短执行时间,则选择下标最小的任务开始执行。
* 一旦某项任务开始执行,CPU 在 执行完整个任务 前都不会停止。
* CPU 可以在完成一项任务后,立即开始执行一项新任务。
返回 CPU 处理任务的顺序。
示例 1:
```
输入:tasks = [[1,2],[2,4],[3,2],[4,1]]
输出:[0,2,3,1]
解释:事件按下述流程运行:
- time = 1 ,任务 0 进入任务队列,可执行任务项 = {0}
- 同样在 time = 1 ,空闲状态的 CPU 开始执行任务 0 ,可执行任务项 = {}
- time = 2 ,任务 1 进入任务队列,可执行任务项 = {1}
- time = 3 ,任务 2 进入任务队列,可执行任务项 = {1, 2}
- 同样在 time = 3 ,CPU 完成任务 0 并开始执行队列中用时最短的任务 2 ,可执行任务项 = {1}
- time = 4 ,任务 3 进入任务队列,可执行任务项 = {1, 3}
- time = 5 ,CPU 完成任务 2 并开始执行队列中用时最短的任务 3 ,可执行任务项 = {1}
- time = 6 ,CPU 完成任务 3 并开始执行任务 1 ,可执行任务项 = {}
- time = 10 ,CPU 完成任务 1 并进入空闲状态
```
示例 2:
```
输入:tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]
输出:[4,3,2,0,1]
解释:事件按下述流程运行:
- time = 7 ,所有任务同时进入任务队列,可执行任务项 = {0,1,2,3,4}
- 同样在 time = 7 ,空闲状态的 CPU 开始执行任务 4 ,可执行任务项 = {0,1,2,3}
- time = 9 ,CPU 完成任务 4 并开始执行任务 3 ,可执行任务项 = {0,1,2}
- time = 13 ,CPU 完成任务 3 并开始执行任务 2 ,可执行任务项 = {0,1}
- time = 18 ,CPU 完成任务 2 并开始执行任务 0 ,可执行任务项 = {1}
- time = 28 ,CPU 完成任务 0 并开始执行任务 1 ,可执行任务项 = {}
- time = 40 ,CPU 完成任务 1 并进入空闲状态
```
提示:
* tasks.length == n
* 1 <= n <= $10^5$
* 1 <= $enqueueTime_i$, $processingTime_i$ <= $10^9$ | ### 模拟 + 数据结构
先将 $tasks$ 按照「入队时间」进行升序排序,同时为了防止任务编号丢失,排序前需要先将二元组的 $tasks$ 转存为三元组,新增记录的是原任务编号。
然后可以按照「时间线」进行模拟:
1. 起始令 $time$ 从 $1$ 开始进行递增,每次将到达「入队时间」的任务进行入队;
2. 判断当前队列是否有可以执行的任务:
1. 如果没有,说明还没到达下一个入队任务的入队时间,直接将 $times$ 快进到下一个入队任务的入队时间;
2. 如果有,从队列中取出任务执行,同时由于是单线程执行,在该任务结束前,不会有新任务被执行,将 $times$ 快进到该任务的结束时间。
代码:
```Java
class Solution {
public int[] getOrder(int[][] ts) {
int n = ts.length;
// 将 ts 转存成 nts,保留任务编号
int[][] nts = new int[n][3];
for (int i = 0; i < n; i++) nts[i] = new int[]{ts[i][0], ts[i][1], i};
// 根据任务入队时间进行排序
Arrays.sort(nts, (a,b)->a[0]-b[0]);
// 根据题意,先按照「持续时间」排序,再根据「任务编号」排序
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{
if (a[1] != b[1]) return a[1] - b[1];
return a[2] - b[2];
});
int[] ans = new int[n];
for (int time = 1, j = 0, idx = 0; idx < n; ) {
// 如果当前任务可以添加到「队列」中(满足入队时间)则进行入队
while (j < n && nts[j][0] <= time) q.add(nts[j++]);
if (q.isEmpty()) {
// 如果当前「队列」没有任务,直接跳到下个任务的入队时间
time = nts[j][0];
} else {
// 如果有可执行任务的话,根据优先级将任务出队(记录下标),并跳到该任务完成时间点
int[] cur = q.poll();
ans[idx++] = cur[2];
time += cur[1];
}
}
return ans;
}
}
```
* 时间复杂度:将 $ts$ 转存成 $nts$ 的复杂度为 $O(n)$;对 $nts$ 排序复杂度为 $O(n\log{n})$;模拟时间线,将任务进行入队出队操作,并构造最终答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1834` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1831-1840/1838. 最高频元素的频数（中等）.md | 1838. 最高频元素的频数 | https://leetcode-cn.com/problems/frequency-of-the-most-frequent-element/solution/gong-shui-san-xie-cong-mei-ju-dao-pai-xu-kxnk/ | 中等 | [
"枚举",
"哈希表",
"排序",
"前缀和",
"二分",
"滑动窗口",
"双指针"
] | 元素的**频数**是该元素在一个数组中出现的次数。
给你一个整数数组 $nums$ 和一个整数 $k$ 。
在一步操作中,你可以选择 $nums$ 的一个下标,并将该下标对应元素的值增加 $1$ 。
执行最多 $k$ 次操作后,返回数组中最高频元素的**最大可能频数**。
示例 1:
```
输入:nums = [1,2,4], k = 5
输出:3
解释:对第一个元素执行 3 次递增操作,对第二个元素执 2 次递增操作,此时 nums = [4,4,4] 。
4 是数组中最高频元素,频数是 3 。
```
示例 2:
```
输入:nums = [1,4,8,13], k = 5
输出:2
解释:存在多种最优解决方案:
- 对第一个元素执行 3 次递增操作,此时 nums = [4,4,8,13] 。4 是数组中最高频元素,频数是 2 。
- 对第二个元素执行 4 次递增操作,此时 nums = [1,8,8,13] 。8 是数组中最高频元素,频数是 2 。
- 对第三个元素执行 5 次递增操作,此时 nums = [1,4,13,13] 。13 是数组中最高频元素,频数是 2 。
```
示例 3:
```
输入:nums = [3,9,6], k = 2
输出:1
```
提示:
* 1 <= nums.length <= $10^5$
* 1 <= nums[i] <= $10^5$
* 1 <= k <= $10^5$ | ### 枚举
一个朴素的做法是,先对原数组 $nums$ 进行排序,然后枚举最终「频数对应值」是哪个。
利用每次操作只能对数进行加一,我们可以从「频数对应值」开始往回检查,从而得出在操作次数不超过 $k$ 的前提下,以某个值作为「频数对应值」最多能够凑成多少个。
算法整体复杂度为 $O(n^2)$,Java 2021/07/19 可过。
代码:
```Java
class Solution {
public int maxFrequency(int[] nums, int k) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
List<Integer> list = new ArrayList<>(map.keySet());
Collections.sort(list);
int ans = 1;
for (int i = 0; i < list.size(); i++) {
int x = list.get(i), cnt = map.get(x);
if (i > 0) {
int p = k;
for (int j = i - 1; j >= 0; j--) {
int y = list.get(j);
int diff = x - y;
if (p >= diff) {
int add = p / diff;
int min = Math.min(map.get(y), add);
p -= min * diff;
cnt += min;
} else {
break;
}
}
}
ans = Math.max(ans, cnt);
}
return ans;
}
}
```
* 时间复杂度:得到去重后的频数后选集合复杂度为 $O(n)$;最坏情况下去重后仍有 $n$ 个频数,且判断 $k$ 次操作内某个频数最多凑成多少复杂度为 $O(n)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$
---
### 排序 + 前缀和 + 二分 + 滑动窗口
**先对原数组 $nums$ 进行从小到大排序,如果存在真实最优解 $len$,意味着至少存在一个大小为 $len$ 的区间 $[l, r]$,使得在操作次数不超过 $k$ 的前提下,区间 $[l, r]$ 的任意值 $nums[i]$ 的值调整为 $nums[r]$。**
这引导我们利用「数组有序」&「前缀和」快速判断「某个区间 $[l, r]$ 是否可以在 $k$ 次操作内将所有值变为 $nums[r]$」:
具体的,我们可以二分答案 $len$ 作为窗口长度,利用前缀和我们可以在 $O(1)$ 复杂度内计算任意区间的和,同时由于每次操作只能对数进行加一,即窗口内的所有数最终变为 $nums[r]$ ,最终目标区间和为 $nums[r] * len$,通过比较目标区间和和真实区间和的差值,我们可以知道 $k$ 次操作是否能将当前区间变为 $nums[r]$。
上述判断某个值 $len$ 是否可行的 `check` 操作复杂度为 $O(n)$,因此算法复杂度为 $O(n\log{n})$。
代码:
```Java
class Solution {
int[] nums, sum;
int n, k;
public int maxFrequency(int[] _nums, int _k) {
nums = _nums;
k = _k;
n = nums.length;
Arrays.sort(nums);
sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
int l = 0, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(mid)) l = mid;
else r = mid - 1;
}
return r;
}
boolean check(int len) {
for (int l = 0; l + len - 1 < n; l++) {
int r = l + len - 1;
int cur = sum[r + 1] - sum[l];
int t = nums[r] * len;
if (t - cur <= k) return true;
}
return false;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$;计算前缀和数组复杂度为 $O(n)$;`check` 函数的复杂度为 $O(n)$,因此二分复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1838` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1841-1850/1846. 减小和重新排列数组后的最大元素（中等）.md | 1846. 减小和重新排列数组后的最大元素 | https://leetcode-cn.com/problems/maximum-element-after-decreasing-and-rearranging/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-yh9qt/ | 中等 | [
"贪心"
] | 给你一个正整数数组 `arr`。请你对 `arr` 执行一些操作(也可以不进行任何操作),使得数组满足以下条件:
* `arr` 中 第一个 元素必须为 $1$ 。
* 任意相邻两个元素的差的绝对值 小于等于 $1$ ,也就是说,对于任意的 $1 <= i < arr.length$ (数组下标从 $0$ 开始),都满足 `abs(arr[i] - arr[i - 1]) <= 1`。`abs(x)` 为 `x` 的绝对值。
你可以执行以下 $2$ 种操作任意次:
* 减小 `arr` 中任意元素的值,使其变为一个 更小的正整数 。
* 重新排列 `arr` 中的元素,你可以以任意顺序重新排列。
请你返回执行以上操作后,在满足前文所述的条件下,`arr` 中可能的 最大值 。
示例 1:
```
输入:arr = [2,2,1,2,1]
输出:2
解释:
我们可以重新排列 arr 得到 [1,2,2,2,1] ,该数组满足所有条件。
arr 中最大元素为 2 。
```
示例 2:
```
输入:arr = [100,1,1000]
输出:3
解释:
一个可行的方案如下:
1. 重新排列 arr 得到 [1,100,1000] 。
2. 将第二个元素减小为 2 。
3. 将第三个元素减小为 3 。
现在 arr = [1,2,3] ,满足所有条件。
arr 中最大元素为 3 。
```
示例 3:
```
输入:arr = [1,2,3,4,5]
输出:5
解释:数组已经满足所有条件,最大元素为 5 。
```
提示:
* $1 <= arr.length <= 10^5$
* $1 <= arr[i] <= 10^9$ | ### 基本分析 & 证明
根据题意,数组的第一位必须是 $1$,且每个数只能 **减小** 或 **不变**,数值位置可以任意调整。
求解经过调整后,符合要求的数组中的最大值是多少。
首先符合条件的数组相邻位差值绝对值不超过 $1$,这限定了数组的必然是如下三种分布之一:
* (非严格)单调递减
* 存在波段
* (非严格)单调递增
**证明一:取得最优解对应的数组「必然是」或者「可调整为」(非严格)单调递增的形式。**
我们使用反证法来证明另外两种分布不能取得最优解:
* (非严格)单调递减:题目限定了数的范围为正整数,且第一位为 $1$,这种情况不用讨论了,跳过;
* 存在波段:我们始终可以将波峰的右侧出现的值,纳入到波峰的左侧,从而消掉这个波峰,最终将整个分布调整为「(非严格)单调递增」的形式,结果不会变差:
多个波段的情况也是同理,可以自己在纸上画画。
都是利用 **波峰右侧的点可以调整成波峰左侧的点,从而使分布变为(非严格)单调递增。**
**至此,我们证明了最优解对应的数组必然符合(非严格)单调递增。**
这启发我们可以先对原数组排个序,在此基础上进行分析。
对原数组排序得到的有序数组,不一定是符合「相邻位差值绝对值不超过 $1$」的,同时由于每个数值可以选择 **减小** 或 **不变**。
**证明二:当必须要对当前位进行调整的时,优先选择调整为「与前一值差值为 $1$ 的较大数」不会比调整为「与前一差值为 $0$ 的较小数」更差。**
这可以使用归纳推理,假设采取「优先调整为与前一值差值为 $1$ 的较大数」得到的序列为 `a`,采用「优先调整与前一差值为 $0$ 的较小数」得到的序列为 `b`。
**根据「$a[0] = b[0] = 1$」、「`a` 和 `b` 长度一致」、「`a` 和 `b` 均为(非严格)单调递增」以及「`a` 和 `b` 均满足相邻位差值不超过 $1$」,可推导出 $sum(a) >= sum(b)$,和任意位置 $a[i] >= b[i]$,从而推导出 `a` 序列的最后一位必然大于等于 `b` 的最后一位。**
即 `b` 不会比 `a` 更优。
**证明三:调整大小的操作不会改变数组元素之间的相对位置关系。**
在证明二的分析中,我们会对某些元素进行“减小”操作,使得整个数组最终满足「相邻位差值绝对值不超过 $1$」。
但该证明成立的还有一个很重要的前提条件,就是调整操作不会出发元素的位置重排。
那么该前提条件是否必然成立呢?答案是必然成立。
假设原排序数组中存在需要调整的点 $i$ 和点 $j$,且 $nums[i] <= nums[j]$。
为了让数组满足条件,它们都进行了“减少”操作的调整,分别变为了 $p$ 和 $q$,如果触发位置重排的话,必然有 $nums[p] >= nums[q]$。
此时,我们能够通过调整它们的变化关系:点 $i$ 变为点 $q$、点 $j$ 变成点 $p$ 来确保同样满足条件,且不触发元素在有序数组中的位置重排。
---
### 贪心
排序,限定第一位值为 $1$,从前往后处理,根据每一位是否「必须修改(与上一位差值是否大于 $1$)」做决策,如果必须被修改,则修改为与前一值差值为 $1$ 的较大数。
代码:
```Java
class Solution {
public int maximumElementAfterDecrementingAndRearranging(int[] arr) {
int n = arr.length;
Arrays.sort(arr);
arr[0] = 1;
for (int i = 1; i < n; i++) {
if (arr[i] - arr[i - 1] > 1) {
arr[i] = arr[i - 1] + 1;
}
}
return arr[n - 1];
}
}
```
* 时间复杂度:假定 `Arrays.sort` 使用的是双轴快排实现。复杂度为 $O(n\log{n})$
* 空间复杂度:假定 `Arrays.sort` 使用的是双轴快排实现。复杂度为 $O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1846` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1871-1880/1877. 数组中最大数对和的最小值（中等）.md | 1877. 数组中最大数对和的最小值 | https://leetcode-cn.com/problems/minimize-maximum-pair-sum-in-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ru29y/ | 中等 | [
"贪心"
] | 一个数对 (a,b) 的 数对和 等于 a + b 。最大数对和 是一个数对数组中最大的 数对和 。
比方说,如果我们有数对 (1,5) ,(2,3) 和 (4,4),最大数对和 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8 。
给你一个长度为 偶数 n 的数组 nums ,请你将 nums 中的元素分成 n / 2 个数对,使得:
* nums 中每个元素 恰好 在 一个 数对中,且
* 最大数对和 的值 最小 。
请你在最优数对划分的方案下,返回最小的 最大数对和 。
示例 1:
```
输入:nums = [3,5,2,3]
输出:7
解释:数组中的元素可以分为数对 (3,3) 和 (5,2) 。
最大数对和为 max(3+3, 5+2) = max(6, 7) = 7 。
```
示例 2:
```
输入:nums = [3,5,4,2,4,6]
输出:8
解释:数组中的元素可以分为数对 (3,5),(4,4) 和 (6,2) 。
最大数对和为 max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8 。
```
提示:
* n == nums.length
* 2 <= n <= $10^5$
* n 是 偶数 。
* 1 <= nums[i] <= $10^5$ | ### 基本分析 & 证明
直觉上,我们会认为「**尽量让“较小数”和“较大数”组成数对,可以有效避免出现“较大数成对”的现象**」。
我们来证明一下该猜想是否成立。
假定 $nums$ 本身有序,由于我们要将 $nums$ 拆分成 $n / 2$ 个数对,根据猜想,我们得到的数对序列为:
$$
(nums[0], nums[n - 1]), (nums[1], nums[n - 2]), ... , (nums[(n / 2) - 1], nums[n / 2])
$$
**换句话说,构成答案的数对必然是较小数取自有序序列的左边,较大数取自有序序列的右边,且与数组中心对称**。
假设最大数对是 $(nums[i], nums[j])$,其中 $i < j$,记两者之和为 $ans = nums[i] + nums[j]$。
反证法证明,不存在别的数对组合会比 $(nums[i], nums[j])$ 更优:
假设存在数对 $(nums[p], nums[q])$ 与 $(nums[i], nums[j])$ 进行调整使答案更优。
接下来分情况讨论:
* 调整为 $(nums[i], nums[p])$ 和 $(nums[q], nums[j])$:此时最大数对答案为 $nums[q] + nums[j]$,显然 $nums[q] + nums[j] >= nums[i] + nums[j] = ans$。我们要最小化最大数对和,因此该调整方案不会让答案更好;
* 调整为 $(nums[i], nums[q])$ 和 $(nums[p], nums[j])$:此时最大数对答案为 $\max(nums[i] + nums[q], nums[p] + nums[j]) = nums[p] + nums[j] >= nums[i] + nums[j] = ans$。我们要最小化最大数对和,因此该调整方案不会让答案更好;
**上述分析可以归纳推理到每一个“非对称”的数对配对中。**
至此我们得证,将原本对称的数对调整为不对称的数对,不会使得答案更优,即贪心解可取得最优解。
---
### 贪心
对原数组 $nums$ 进行排序,然后从一头一尾开始往中间组「数对」,取所有数对中的最大值即是答案。
代码:
```Java
class Solution {
public int minPairSum(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
int ans = nums[0] + nums[n - 1];
for (int i = 0, j = n - 1; i < j; i++, j--) {
ans = Math.max(ans, nums[i] + nums[j]);
}
return ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 答疑
关于「证明」部分,不少小伙伴有一些疑问,觉得挺有代表性的,特意加到题解内。
Q1. 「证明」部分是不是缺少了“非对称”得最优的情况?
A1. 并没有,证明的基本思路如下:
1. 猜想对称组数对的方式,会得到最优解;
2. 证明非对称数组不会被对称数对方式更优。
然后我们证明了“非对称方式”不会比“对称方式”更优,因此“对称方式”可以取得最优解。
**至于非对称和非对称之间怎么调整,会更优还是更差,我不关心,也不需要证明,因为已经证明了非对称不会比对称更优。**
Q2. 证明部分的图 $p$、$q$ 是在 $i$、$j$ 内部,那么其他 $p$、$q$、$i$、$j$ 大小关系的情况呢?
A2. 有这个疑问,说明没有重点理解「证明」中的加粗部分(原话):
> **上述分析可以归纳推理到每一个“非对称”的数对配对中。**
也就是说,上述的分析是可以推广到每一步都成立的,包括第一步,当 $i$ 为排序数组的第一位原始,$j$ 为排序数组中最后一位时,任意 $p$ 和 $q$ 都是在 $i$、$j$ 内部的。
**因此,「证明」对边界情况成立,同时对任意不成“对称”关系的数对也成立(其实也就是「证明」部分中的原话)。**
**更大白话一点是:对于任意“非对称”的数对组合,将其调整为“对称”数对组合,结果不会变差。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1877` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1871-1880/1879. 两个数组最小的异或值之和（困难）.md | 1879. 两个数组最小的异或值之和 | https://leetcode.cn/problems/minimum-xor-sum-of-two-arrays/solutions/2402125/gong-shui-san-xie-yi-ti-shuang-jie-zhuan-iusv/ | 困难 | [
"状压 DP",
"动态规划",
"启发式搜索"
] | 给你两个整数数组 `nums1` 和 `nums2`,它们长度都为 `n`。
两个数组的 异或值之和 为 `(nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1])` (下标从 `0` 开始)。
比方说,`[1,2,3]` 和 `[3,2,1]` 的 异或值之和 等于 `(1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4`。
请你将 `nums2` 中的元素重新排列,使得异或值之和最小 。
请你返回重新排列之后的 异或值之和 。
示例 1:
```
输入:nums1 = [1,2], nums2 = [2,3]
输出:2
解释:将 nums2 重新排列得到 [3,2] 。
异或值之和为 (1 XOR 3) + (2 XOR 2) = 2 + 0 = 2 。
```
示例 2:
```
输入:nums1 = [1,0,3], nums2 = [5,3,4]
输出:8
解释:将 nums2 重新排列得到 [5,4,3] 。
异或值之和为 (1 XOR 5) + (0 XOR 4) + (3 XOR 3) = 4 + 4 + 0 = 8 。
```
提示:
* $n = nums1.length$
* $n == nums2.length$
* $1 <= n <= 14$
* $0 <= nums1[i], nums2[i] <= 10^7$ | ### 状压 DP
这是一道「状压 DP」模板题。
为了方便,我们令下标从 $1$ 开始。
**定义 $f[i][s]$ 为考虑前 $i$ 个元素,且对 `nums2` 的使用情况为 $s$ 时的最小异或值**。其中 $s$ 是一个长度为 $n$ 的二进制数:若 $s$ 中的第 $k$ 位为 $1$,说明 `nums2[k]` 已被使用;若 $s$ 中的第 $k$ 位为 $0$,说明 `nums2[k]` 未被使用。
起始时,只有 $f[0][0] = 0$,其余均为无穷大 `INF`。$f[0][0]$ 含义为在不考虑任何数,对 `nums2` 没有任何占用情况时,最小异或值为 $0$。最终 $f[n][2^n - 1]$ 即为答案。
不失一般性考虑 $f[i][s]$ 该如何转移,可以以 `nums1[i]` 是与哪个 `nums2[j]` 进行配对作为切入点:
* 由于总共考虑了前 $i$ 个成员,因此 $s$ 中 $1$ 的数量必然为 $i$,否则 $f[i][s]$ 就不是一个合法状态,跳过转移
* 枚举 `nums1[i]` 是与哪一个 `nums2[j]` 进行配对的,且枚举的 $j$ 需满足在 $s$ 中的第 $j$ 位值为 $1$,若满足则有
$$
f[i][s] = \min(f[i][s], f[i - 1][prev] + nums1[i] ⊕ nums2[j])
$$
其中 `prev` 为将 $s$ 中的第 $j$ 位进行置零后的二进制数,即 `prev = s ^ (1 << j)`,符号 ⊕ 代表异或操作。
Java 代码:
```Java
class Solution {
public int minimumXORSum(int[] nums1, int[] nums2) {
int n = nums1.length, mask = 1 << n, INF = 0x3f3f3f3f;
int[][] f = new int[n + 10][mask];
for (int i = 0; i <= n; i++) Arrays.fill(f[i], INF);
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int s = 0; s < mask; s++) {
if (getCnt(s, n) != i) continue;
for (int j = 1; j <= n; j++) {
if (((s >> (j - 1)) & 1) == 0) continue;
f[i][s] = Math.min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]));
}
}
}
return f[n][mask - 1];
}
int getCnt(int s, int n) {
int ans = 0;
for (int i = 0; i < n; i++) ans += (s >> i) & 1;
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minimumXORSum(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size(), mask = 1 << n, INF = 0x3f3f3f3f;
vector<vector<int>> f(n + 10, vector<int>(mask, INF));
f[0][0] = 0;
auto getCnt = [&](int s, int n) {
int ans = 0;
for (int i = 0; i < n; i++) ans += (s >> i) & 1;
return ans;
};
for (int i = 1; i <= n; i++) {
for (int s = 0; s < mask; s++) {
if (getCnt(s, n) != i) continue;
for (int j = 1; j <= n; j++) {
if (((s >> (j - 1)) & 1) == 0) continue;
f[i][s] = min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]));
}
}
}
return f[n][mask - 1];
}
};
```
Python 代码:
```Python
class Solution:
def minimumXORSum(self, nums1: List[int], nums2: List[int]) -> int:
n, mask, INF = len(nums1), 1 << len(nums1), 0x3f3f3f3f
f = [[INF] * mask for _ in range(n + 10)]
f[0][0] = 0
for i in range(1, n + 1):
for s in range(mask):
if sum([1 for i in range(n) if (s >> i) & 1]) != i:
continue
for j in range(1, n + 1):
if ((s >> (j - 1)) & 1) == 0:
continue
f[i][s] = min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]))
return f[n][mask - 1]
```
TypeScript 代码:
```TypeScript
function minimumXORSum(nums1: number[], nums2: number[]): number {
const n = nums1.length, mask = 1 << n, INF = 0x3f3f3f3f;
const f: number[][] = new Array(n + 10).fill([]).map(() => new Array(mask).fill(INF));
f[0][0] = 0;
const getCnt = (s: number, n: number): number => {
let ans = 0;
for (let i = 0; i < n; i++) ans += (s >> i) & 1;
return ans;
};
for (let i = 1; i <= n; i++) {
for (let s = 0; s < mask; s++) {
if (getCnt(s, n) !== i) continue;
for (let j = 1; j <= n; j++) {
if (((s >> (j - 1)) & 1) === 0) continue;
f[i][s] = Math.min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]));
}
}
}
return f[n][mask - 1];
};
```
* 时间复杂度:$O(n^2 \times 2^n)$
* 空间复杂度:$O(n \times 2^n)$
---
### 模拟退火
事实上,这道题还能使用「模拟退火」进行求解。
由于我们可以无限次对 `nums2` 进行打乱互换,先来思考如何衡量一个 `nums2` 排列的“好坏”。
一个简单的方式:固定计算 `(nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1])` 作为衡量当前 `nums2` 的得分,得分越小,当前的 `nums2` 排列越好。
迭代开始前先对 `nums2` 进行一次随机打乱,随后每个回合随机选择 `nums2` 的两个成员进行互换,并比较互换前后的得分情况,若互换后变好,那么保留该互换操作;若变差,则以一定概率进行重置(重新换回来)。
重复迭代多次,使用一个全局变量 `ans` 保存下最小异或值之和。
即「模拟退火」的单次迭代基本流程:
1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」
2. 如果温度下降(交换后的序列更优),进入下一次迭代
3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)
> 对于一个能够运用模拟退火求解的问题,最核心的是如何实现 `calc` 方法(即如何定义一个具体方案的得分),其余均为模板内容。
Java 代码(2024/04/29 可过):
```Java
class Solution {
int N = 400;
double hi = 1e5, lo = 1e-5, fa = 0.90;
Random random = new Random(20230823);
void swap(int[] n, int a, int b) {
int c = n[a];
n[a] = n[b];
n[b] = c;
}
int calc() {
int res = 0;
for (int i = 0; i < n; i++) res += n1[i] ^ n2[i];
ans = Math.min(ans, res);
return res;
}
void shuffle(int[] nums) {
for (int i = n; i > 0; i--) swap(nums, random.nextInt(i), i - 1);
}
void sa() {
shuffle(n2);
for (double t = hi; t > lo; t *= fa) {
int a = random.nextInt(n), b = random.nextInt(n);
int prev = calc();
swap(n2, a, b);
int cur = calc();
int diff = cur - prev;
if (Math.log(diff / t) >= random.nextDouble()) swap(n2, a, b);
}
}
int[] n1, n2;
int n;
int ans = Integer.MAX_VALUE;
public int minimumXORSum(int[] nums1, int[] nums2) {
n1 = nums1; n2 = nums2;
n = n1.length;
while (N-- > 0) sa();
return ans;
}
}
```
* 时间复杂度:启发式搜索不讨论时空复杂度
* 空间复杂度:启发式搜索不讨论时空复杂度 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1879` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1891-1900/1893. 检查是否区域内所有整数都被覆盖（简单）.md | 1893. 检查是否区域内所有整数都被覆盖 | https://leetcode-cn.com/problems/check-if-all-the-integers-in-a-range-are-covered/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-j83x/ | 简单 | [
"模拟",
"树状数组",
"线段树"
] | 给你一个二维整数数组 `ranges` 和两个整数 `left` 和 `right`。每个 $ranges[i] = [start_i, end_i]$ 表示一个从 $start_i$ 到 $end_i$ 的 闭区间 。
如果闭区间 $[left, right]$ 内每个整数都被 `ranges` 中 至少一个 区间覆盖,那么请你返回 `true`,否则返回 `false`。
已知区间 $ranges[i] = [start_i, end_i]$,如果整数 `x` 满足 $start_i <= x <= end_i$,那么我们称整数 `x` 被覆盖了。
示例 1:
```
输入:ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5
输出:true
解释:2 到 5 的每个整数都被覆盖了:
- 2 被第一个区间覆盖。
- 3 和 4 被第二个区间覆盖。
- 5 被第三个区间覆盖。
```
示例 2:
```
输入:ranges = [[1,10],[10,20]], left = 21, right = 21
输出:false
解释:21 没有被任何一个区间覆盖。
```
提示:
* $1 <= ranges.length <= 50$
* $1 <= start_i <= end_i <= 50$
* $1 <= left <= right <= 50$ | ### 模拟
一个简单的想法是根据题意进行模拟,检查 $[left, right]$ 中的每个整数,如果检查过程中发现某个整数没被 $ranges$ 中的闭区间所覆盖,那么直接返回 `False`,所有数值通过检查则返回 `True`。
代码:
```Java
class Solution {
public boolean isCovered(int[][] rs, int l, int r) {
for (int i = l; i <= r; i++) {
boolean ok = false;
for (int[] cur : rs) {
int a = cur[0], b = cur[1];
if (a <= i && i <= b) {
ok = true;
break;
}
}
if (!ok) return false;
}
return true;
}
}
```
* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$ranges$ 长度为 $m$。整体复杂度为 $O(n * m)$
* 空间复杂度:$O(1)$
---
### 树状数组
**针对此题,可以有一个很有意思的拓展,将本题难度提升到【中等】甚至是【困难】。**
将查询 $[left, right]$ 修改为「四元查询数组」$querys$,每个 $querys[i]$ 包含四个指标 $(a,b,l,r)$:代表询问 $[l, r]$ 中的每个数是否在 $range$ 中 $[a, b]$ 的闭区间所覆盖过。
**如果进行这样的拓展的话,那么我们需要使用「持久化树状数组」或者「主席树」来配合「容斥原理」来做。**
基本思想都是使用 $range[0,b]$ 的计数情况减去 $range[0, a-1]$ 的计数情况来得出 $[a, b]$ 的计数情况。
回到本题,由于数据范围很小,只有 $50$,我们可以使用「树状数组」进行求解:
* `void add(int x, int u)`:对于数值 $x$ 出现次数进行 $+u$ 操作;
* `int query(int x)`:查询某个满足 $<= x$ 的数值的个数。
那么显然,如果我们需要查询一个数值 $x$ 是否出现过,可以通过查询 $cnt = query(x) - query(x - 1)$ 来得知。
代码:
```Java
class Solution {
int n = 55;
int[] tr = new int[n];
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;
}
public boolean isCovered(int[][] rs, int l, int r) {
for (int[] cur : rs) {
int a = cur[0], b = cur[1];
for (int i = a; i <= b; i++) {
add(i, 1);
}
}
for (int i = l; i <= r; i++) {
int cnt = query(i) - query(i - 1);
if (cnt == 0) return false;
}
return true;
}
}
```
* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$\sum_{i = 0}^{range.legth - 1}ranges[i].length$ 为 $sum$,常数 $C$ 固定为 $55$。建树复杂度为 $O(sum\log C)$,查询查询复杂度为 $O(n\log{C})$。整体复杂度为 $O(sum\log{C} + n\log{C})$
* 空间复杂度:$O(C)$
---
### 树状数组(去重优化)
在朴素的「树状数组」解法中,我们无法直接查询 $[l, r]$ 区间中被覆盖过的个数的根本原因是「某个值可能会被重复添加到树状数组中」。
因此,一种更加优秀的做法:**在往树状数组中添数的时候进行去重,然后通过 $cnt = query(r) - query(l - 1)$ 直接得出 $[l, r]$ 范围内有多少个数被添加过。**
这样的 `Set` 去重操作可以使得我们查询的复杂度从 $O(n\log{C})$ 下降到 $O(\log{C})$。
> 由于数值范围很小,自然也能够使用数组来代替 `Set` 进行标记(见 P2)
代码:
```Java
class Solution {
int n = 55;
int[] tr = new int[n];
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;
}
public boolean isCovered(int[][] rs, int l, int r) {
Set<Integer> set = new HashSet<>();
for (int[] cur : rs) {
int a = cur[0], b = cur[1];
for (int i = a; i <= b; i++) {
if (!set.contains(i)) {
add(i, 1);
set.add(i);
}
}
}
int tot = r - l + 1, cnt = query(r) - query(l - 1);
return tot == cnt;
}
}
```
```Java
class Solution {
int n = 55;
int[] tr = new int[n];
boolean[] vis = new boolean[n];
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;
}
public boolean isCovered(int[][] rs, int l, int r) {
for (int[] cur : rs) {
int a = cur[0], b = cur[1];
for (int i = a; i <= b; i++) {
if (!vis[i]) {
add(i, 1);
vis[i] = true;
}
}
}
int tot = r - l + 1, cnt = query(r) - query(l - 1);
return tot == cnt;
}
}
```
* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$\sum_{i = 0}^{range.legth - 1}ranges[i].length$ 为 $sum$,常数 $C$ 固定为 $55$。建树复杂度为 $O(sum\log C)$,查询查询复杂度为 $O(\log{C})$。整体复杂度为 $O(sum\log{C} + \log{C})$
* 空间复杂度:$O(C + \sum_{i = 0}^{range.legth - 1}ranges[i].length)$
---
### 线段树(不含“懒标记”)
更加进阶的做法是使用「线段树」来做,与「树状数组(优化)」解法一样,线段树配合持久化也可以用于求解「在线」问题。
**与主要解决「单点修改 & 区间查询」的树状数组不同,线段树能够解决绝大多数「区间修改(区间修改/单点修改)& 区间查询」问题。**
对于本题,由于数据范围只有 $55$,因此我们可以使用与「树状数组(优化)」解法相同的思路,实现一个不包含“懒标记”的线段树来做(仅支持单点修改 & 区间查询)。
代码:
```Java
class Solution {
// 代表 [l, r] 区间有 cnt 个数被覆盖
class Node {
int l, r, cnt;
Node (int _l, int _r, int _cnt) {
l = _l; r = _r; cnt = _cnt;
}
}
int N = 55;
Node[] tr = new Node[N * 4];
void pushup(int u) {
tr[u].cnt = tr[u << 1].cnt + tr[u << 1 | 1].cnt;
}
void build(int u, int l, int r) {
if (l == r) {
tr[u] = new Node(l, r, 0);
} else {
tr[u] = new Node(l, r, 0);
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
}
// 从 tr 数组的下标 u 开始,在数值 x 的位置进行标记
void update(int u, int x) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].cnt = 1;
} else {
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) update(u << 1, x);
else update(u << 1 | 1, x);
pushup(u);
}
}
// 从 tr 数组的下标 u 开始,查询 [l,r] 范围内有多少个数值被标记
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].cnt;
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;
}
public boolean isCovered(int[][] rs, int l, int r) {
build(1, 1, N);
for (int[] cur : rs) {
int a = cur[0], b = cur[1];
for (int i = a; i <= b; i++) {
update(1, i);
}
}
int tot = r - l + 1 , cnt = query(1, l, r);
return tot == cnt;
}
}
```
* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$\sum_{i = 0}^{range.legth - 1}ranges[i].length$ 为 $sum$,常数 $C$ 固定为 $55$。建树复杂度为 $O(sum\log C)$,查询查询复杂度为 $O(\log{C})$。整体复杂度为 $O(sum\log{C} + \log{C})$
* 空间复杂度:$O(C * 4)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1893` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1891-1900/1894. 找到需要补充粉笔的学生编号（中等）.md | 1894. 找到需要补充粉笔的学生编号 | https://leetcode-cn.com/problems/find-the-student-that-will-replace-the-chalk/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-kpqsk/ | 中等 | [
"前缀和",
"二分",
"模拟"
] | 一个班级里有 n 个学生,编号为 0 到 n - 1 。每个学生会依次回答问题,编号为 0 的学生先回答,然后是编号为 1 的学生,以此类推,直到编号为 n - 1 的学生,然后老师会重复这个过程,重新从编号为 0 的学生开始回答问题。
给你一个长度为 n 且下标从 0 开始的整数数组 chalk 和一个整数 k 。一开始粉笔盒里总共有 k 支粉笔。当编号为 i 的学生回答问题时,他会消耗 chalk[i] 支粉笔。如果剩余粉笔数量 严格小于 chalk[i] ,那么学生 i 需要 补充 粉笔。
请你返回需要 **补充** 粉笔的学生 **编号** 。
示例 1:
```
输入:chalk = [5,1,5], k = 22
输出:0
解释:学生消耗粉笔情况如下:
- 编号为 0 的学生使用 5 支粉笔,然后 k = 17 。
- 编号为 1 的学生使用 1 支粉笔,然后 k = 16 。
- 编号为 2 的学生使用 5 支粉笔,然后 k = 11 。
- 编号为 0 的学生使用 5 支粉笔,然后 k = 6 。
- 编号为 1 的学生使用 1 支粉笔,然后 k = 5 。
- 编号为 2 的学生使用 5 支粉笔,然后 k = 0 。
编号为 0 的学生没有足够的粉笔,所以他需要补充粉笔。
```
示例 2:
```
输入:chalk = [3,4,1,2], k = 25
输出:1
解释:学生消耗粉笔情况如下:
- 编号为 0 的学生使用 3 支粉笔,然后 k = 22 。
- 编号为 1 的学生使用 4 支粉笔,然后 k = 18 。
- 编号为 2 的学生使用 1 支粉笔,然后 k = 17 。
- 编号为 3 的学生使用 2 支粉笔,然后 k = 15 。
- 编号为 0 的学生使用 3 支粉笔,然后 k = 12 。
- 编号为 1 的学生使用 4 支粉笔,然后 k = 8 。
- 编号为 2 的学生使用 1 支粉笔,然后 k = 7 。
- 编号为 3 的学生使用 2 支粉笔,然后 k = 5 。
- 编号为 0 的学生使用 3 支粉笔,然后 k = 2 。
编号为 1 的学生没有足够的粉笔,所以他需要补充粉笔。
```
提示:
* chalk.length == n
* 1 <= n <= $10^5$
* 1 <= chalk[i] <= $10^5$
* 1 <= k <= $10^9$ | ### 前缀和 + 二分
根据题意,每个学生消耗的粉笔为定值,所有粉笔最终会像老师的教导一样孜孜不倦地循环投入在所有的学生身上。
因此我们可以预处理出前缀和数组 $sum$,将 $k$ 对所有学生一次循环所消耗总粉笔数($sum[n]$)进行取模,得到最后一轮开始前的粉笔数量。
然后对前缀和数组进行二分,找到最后一位满足粉笔要求的学生,其往后一位的同学编号即是答案。
代码:
```Java
class Solution {
public int chalkReplacer(int[] chalk, int k) {
int n = chalk.length;
long[] sum = new long[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + chalk[i - 1];
k = (int)(k % sum[n]);
int l = 1, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
if (sum[mid] <= k) l = mid;
else r = mid - 1;
}
return sum[r] <= k ? r : r - 1;
}
}
```
* 时间复杂度:预处理前缀和的复杂度为 $O(n)$;二分求答案的复杂度为 $O(\log{n})$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 模拟
通过解法一,我们发现复杂度的上界为预处理前缀和的复杂度 $O(n)$,同时「对单次循环消耗的总粉笔数取模操作」确保了剩余的粉笔数必然会在单次遍历中消耗完成。
因此 $O(\log{n})$ 的二分其实是没有必要的,只需要再对 `chalk` 进行最后一轮的遍历模拟即可。
代码:
```Java
class Solution {
public int chalkReplacer(int[] chalk, int k) {
int n = chalk.length;
long max = 0;
for (int i : chalk) max += i;
k = (int)(k % max);
for (int i = 0; i < n; i++) {
k -= chalk[i];
if (k < 0) return i;
}
return -1; // never
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1894` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/191-200/191. 位1的个数（简单）.md | 191. 位1的个数 | https://leetcode-cn.com/problems/number-of-1-bits/solution/yi-ti-san-jie-wei-shu-jian-cha-you-yi-to-av1r/ | 简单 | [
"位运算"
] | 编写一个函数,输入是一个无符号整数(以二进制串的形式),返回其二进制表达式中数字位数为 '1' 的个数(也被称为汉明重量)。
提示:
* 请注意,在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,输入和输出都将被指定为有符号整数类型,并且不应影响您的实现,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的。
* 在 Java 中,编译器使用二进制补码记法来表示有符号整数。因此,在上面的 示例 3 中,输入表示有符号整数 -3。
示例 1:
```
输入:00000000000000000000000000001011
输出:3
解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'。
```
示例 2:
```
输入:00000000000000000000000010000000
输出:1
解释:输入的二进制串 00000000000000000000000010000000 中,共有一位为 '1'。
```
示例 3:
```
输入:11111111111111111111111111111101
输出:31
解释:输入的二进制串 11111111111111111111111111111101 中,共有 31 位为 '1'。
```
提示:
* 输入必须是长度为 32 的 二进制串 。
进阶:
* 如果多次调用这个函数,你将如何优化你的算法? | ### 「位数检查」解法
一个朴素的做法是,对 `int` 的每一位进行检查,并统计 $1$ 的个数。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
for (int i = 0; i < 32; i++) {
ans += ((n >> i) & 1);
}
return ans;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位
* 空间复杂度:$O(1)$
***
### 「右移统计」解法
对于方法一,即使 $n$ 的高位均为是 $0$,我们也会对此进行循环检查。
因此另外一个做法是:通过 `n & 1` 来统计当前 $n$ 的最低位是否为 $1$,同时每次直接对 $n$ 进行右移并高位补 0。
当 $n = 0$ 代表,我们已经将所有的 $1$ 统计完成。
这样的做法,可以确保只会循环到最高位的 $1$。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
while (n != 0) {
ans += (n & 1);
n >>>= 1;
}
return ans;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$
* 空间复杂度:$O(1)$
---
### 「lowbit」解法
对于方法二,如果最高位 $1$ 和 最低位 $1$ 之间全是 $0$,我们仍然会诸次右移,直到处理到最高位的 $1$ 为止。
那么是否有办法,只对位数为 $1$ 的二进制位进行处理呢?
使用 `lowbit` 即可做到,`lowbit` 会在 $O(1)$ 复杂度内返回二进制表示中最低位 $1$ 所表示的数值。
例如 $(0000...111100)_2$ 传入 `lowbit` 返回 $(0000...000100)_2$;$(0000...00011)_2$ 传入 `lowbit` 返回 $(0000...00001)_2$ ...
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
for (int i = n; i != 0; i -= lowbit(i)) ans++;
return ans;
}
int lowbit(int x) {
return x & -x;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$
* 空间复杂度:$O(1)$
---
### 「分组统计」解法
以上三种解法都是 $O(k)$ 的,事实上我们可以通过分组统计的方式,做到比 $O(k)$ 更低的复杂度。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
n = (n & 0x55555555) + ((n >>> 1) & 0x55555555);
n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
n = (n & 0x0f0f0f0f) + ((n >>> 4) & 0x0f0f0f0f);
n = (n & 0x00ff00ff) + ((n >>> 8) & 0x00ff00ff);
n = (n & 0x0000ffff) + ((n >>> 16) & 0x0000ffff);
return n;
}
}
```
* 时间复杂度:$O(\log{k})$,$k$ 为 `int` 的位数,固定为 $32$ 位
* 空间复杂度:$O(1)$
PS. 对于该解法,如果大家学有余力的话,还是建议大家在纸上模拟一下这个过程。如果不想深入,也可以当成模板背过(写法非常固定),但通常如果不是写底层框架,你几乎不会遇到需要一个 $O(\log{k})$ 解法的情况。
而且这个做法的最大作用,不是处理 `int`,而是处理更大位数的情况,在长度只有 $32$ 位的 `int` 的情况下,该做法不一定就比循环要快(该做法会产生多个的中间结果,导致赋值发生多次,而且由于指令之间存在对 $n$ 数值依赖,可能不会被优化为并行指令),这个道理和对于排序元素少的情况下,我们会选择「选择排序」而不是「归并排序」是一样的。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.191` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/191-200/198. 打家劫舍（中等）.md | 198. 打家劫舍 | https://leetcode.cn/problems/house-robber/solution/by-ac_oier-7v1g/ | 中等 | [
"线性 DP",
"状态机 DP",
"动态规划"
] | 你是一个专业的小偷,计划偷窃沿街的房屋。每间房内都藏有一定的现金,影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组,计算你 不触动警报装置的情况下 ,一夜之内能够偷窃到的最高金额。
示例 1:
```
输入:[1,2,3,1]
输出:4
解释:偷窃 1 号房屋 (金额 = 1) ,然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
```
示例 2:
```
输入:[2,7,9,3,1]
输出:12
解释:偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9),接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。
```
提示:
* $1 <= nums.length <= 100$
* $0 <= nums[i] <= 400$ | ### 状态机 DP
这是一道入门级的状态机线性 DP 题。
定义 $f[i][j]$ 为考虑前 $i$ 间房子,且第 $i$ 间房子的状态为 $j$ 时所能取得的最大价值(其中 $j = 0$ 代表不偷该房子,$j = 1$ 代表偷该房子)。
再结合题意,因为相邻房子不能同时被偷,可推导出状态转移方程为:
* 当前房子不偷,则对前一间房子的状态无要求,状态值为前一状态的较大值:$f[i][0] = \max(f[i - 1][0], f[i - 1][1])$
* 当前房子偷,此时限定了前一间只能不偷,状态值为前一间房子不偷时的最大价值,加上当前房子的价值: $f[i][1] = f[i - 1][0] + nums[i - 1]$
最终 $\max(f[n][0], f[n][1])$ 即是答案。
Java 代码:
```Java
class Solution {
public int rob(int[] nums) {
int n = nums.length;
int[][] f = new int[n + 10][2];
for (int i = 1; i <= n; i++) {
f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);
f[i][1] = f[i - 1][0] + nums[i - 1];
}
return Math.max(f[n][0], f[n][1]);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int rob(vector<int>& nums) {
int n = nums.size();
int f[n + 10][2];
f[0][0] = f[0][1] = 0;
for (int i = 1; i <= n; i++) {
f[i][0] = max(f[i - 1][0], f[i - 1][1]);
f[i][1] = f[i - 1][0] + nums[i - 1];
}
return max(f[n][0], f[n][1]);
}
};
```
TypeScript 代码:
```TypeScript
function rob(nums: number[]): number {
const n = nums.length
const f = new Array<Array<number>>(n + 10)
f[0] = new Array<number>(2).fill(0)
for (let i = 1; i <= n; i++) {
f[i] = new Array<number>(2).fill(0)
f[i][0] = Math.max(f[i - 1][0], f[i - 1][1])
f[i][1] = f[i - 1][0] + nums[i - 1]
}
return Math.max(f[n][0], f[n][1])
}
```
Python 代码:
```Python
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
f = [[0] * 2 for _ in range(n + 10)]
for i in range(1, n + 1):
f[i][0] = max(f[i - 1][0], f[i - 1][1])
f[i][1] = f[i - 1][0] + nums[i - 1]
return max(f[n][0], f[n][1])
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 优化
利用 $f[i][X]$ 仅依赖于 $f[i - 1][X]$,我们可以通过「滚动数组」的方式将空间优化至 $O(1)$。
Java 代码:
```Java
class Solution {
public int rob(int[] nums) {
int n = nums.length;
int[][] f = new int[][]{{0, 0}, {0, 0}};
for (int i = 1; i <= n; i++) {
int a = (i - 1) & 1, b = i & 1;
f[b][0] = Math.max(f[a][0], f[a][1]);
f[b][1] = f[a][0] + nums[i - 1];
}
return Math.max(f[n & 1][0], f[n & 1][1]);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int rob(vector<int>& nums) {
int n = nums.size();
int f[][2] = {{0, 0}, {0, 0}};
for (int i = 1; i <= n; i++) {
int a = (i - 1) & 1, b = i & 1;
f[b][0] = max(f[a][0], f[a][1]);
f[b][1] = f[a][0] + nums[i - 1];
}
return max(f[n & 1][0], f[n & 1][1]);
}
};
```
TypeScript 代码:
```TypeScript
function rob(nums: number[]): number {
const n = nums.length
const f = [[0, 0], [0, 0]]
for (let i = 1; i <= n; i++) {
const a = (i - 1) & 1, b = i & 1
f[b][0] = Math.max(f[a][0], f[a][1])
f[b][1] = f[a][0] + nums[i - 1]
}
return Math.max(f[n & 1][0], f[n & 1][1])
}
```
Python 代码:
```Python
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
f = [[0, 0], [0, 0]]
for i in range(1, n + 1):
a, b = (i - 1) & 1, i & 1
f[b][0] = max(f[a][0], f[a][1])
f[b][1] = f[a][0] + nums[i - 1]
return max(f[n & 1][0], f[n & 1][1])
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.198` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/191-200/199. 二叉树的右视图（中等）.md | 199. 二叉树的右视图 | null | 中等 | [
"二叉树",
"BFS",
"DFS",
"层序遍历"
] | 给定一个二叉树的 根节点 `root`,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。
示例 1:
```
输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
```
示例 2:
```
输入: [1,null,3]
输出: [1,3]
```
示例 3:
```
输入: []
输出: []
```
提示:
* 二叉树的节点个数的范围是 $[0,100]$
* $-100 <= Node.val <= 100$ | ### BFS
本质就是找层序遍历过程中,每层的最后一个节点。
Java 代码:
```Java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> ans = new ArrayList<>();
if (root == null) return ans;
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
int sz = d.size();
while (sz-- > 0) {
TreeNode node = d.pollFirst();
if (node.left != null) d.addLast(node.left);
if (node.right != null) d.addLast(node.right);
if (sz == 0) ans.add(node.val);
}
}
return ans;
}
}
```
C++ 代码:
```C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
vector<int> ans;
if (!root) return ans;
queue<TreeNode*> d;
d.push(root);
while (!d.empty()) {
int sz = d.size();
while (sz-- > 0) {
TreeNode* node = d.front();
d.pop();
if (node->left) d.push(node->left);
if (node->right) d.push(node->right);
if (sz == 0) ans.push_back(node->val);
}
}
return ans;
}
};
```
Python 代码:
```Python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
ans = []
if not root:
return ans
d = deque()
d.append(root)
while d:
sz = len(d)
while sz > 0:
node = d.popleft()
if node.left:
d.append(node.left)
if node.right:
d.append(node.right)
if sz == 1:
ans.append(node.val)
sz -= 1
return ans
```
TypeScript 代码:
```TypeScript
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function rightSideView(root: TreeNode | null): number[] {
const ans = [];
if (!root) return ans;
const d = [];
d.push(root);
while (d.length > 0) {
let sz = d.length;
while (sz-- > 0) {
const node = d.shift()!;
if (node.left) d.push(node.left);
if (node.right) d.push(node.right);
if (sz === 0) ans.push(node.val);
}
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### DFS
`DFS` 解法同理,规定好节点的遍历顺序(例如 `中-右-左`),并在 `DFS` 过程中传递当前层参数 `level`(根节点为第 `0` 层),同时使用一个 `Set` 数据结构记录处理过的层编号,从而实现只将当前层的首个节点添加到答案中。
Java 代码:
```Java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
List<Integer> ans = new ArrayList<>();
Set<Integer> set = new HashSet<>();
public List<Integer> rightSideView(TreeNode root) {
dfs(root, 0);
return ans;
}
void dfs(TreeNode node, int level) {
if (node == null) return ;
if (!set.contains(level)) {
ans.add(node.val);
set.add(level);
}
dfs(node.right, level + 1);
dfs(node.left, level + 1);
}
}
```
C++ 代码:
```C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> ans;
unordered_set<int> levels;
vector<int> rightSideView(TreeNode* root) {
dfs(root, 0);
return ans;
}
void dfs(TreeNode* node, int level) {
if (!node) return;
if (levels.find(level) == levels.end()) {
ans.push_back(node->val);
levels.insert(level);
}
dfs(node->right, level + 1);
dfs(node->left, level + 1);
}
};
```
Python 代码:
```Python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
def dfs(node, level):
if not node:
return
if level not in levels:
ans.append(node.val)
levels.add(level)
dfs(node.right, level + 1)
dfs(node.left, level + 1)
ans = []
levels = set()
dfs(root, 0)
return ans
```
TypeScript 代码:
```TypeScript
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function rightSideView(root: TreeNode | null): number[] {
const ans = [];
const levels = new Set();
function dfs(node: TreeNode | null, level: number) {
if (!node) return;
if (!levels.has(level)) {
ans.push(node.val);
levels.add(level);
}
dfs(node.right, level + 1);
dfs(node.left, level + 1);
}
dfs(root, 0);
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.198` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1971-1980/1976. 到达目的地的方案数（中等）.md | 1976. 到达目的地的方案数 | https://leetcode.cn/problems/number-of-ways-to-arrive-at-destination/solution/by-ac_oier-4ule/ | 中等 | [
"最短路",
"拓扑排序",
"动态规划"
] | 你在一个城市里,城市由 $n$ 个路口组成,路口编号为 $0$ 到 $n - 1$ ,某些路口之间有 双向 道路。输入保证你可以从任意路口出发到达其他任意路口,且任意两个路口之间最多有一条路。
给你一个整数 `n` 和二维整数数组 `roads`,其中 $roads[i] = [u_i, v_i, time_i]$ 表示在路口 $u_i$ 和 $v_i$ 之间有一条需要花费 $time_i$ 时间才能通过的道路。你想知道花费 最少时间 从路口 $0$ 出发到达路口 $n - 1$ 的方案数。
请返回花费 最少时间 到达目的地的 路径数目 。由于答案可能很大,将结果对 $10^9 + 7$ 取余 后返回。
示例 1:
```
输入:n = 7, roads = [[0,6,7],[0,1,2],[1,2,3],[1,3,3],[6,3,3],[3,5,1],[6,5,1],[2,5,1],[0,4,5],[4,6,2]]
输出:4
解释:从路口 0 出发到路口 6 花费的最少时间是 7 分钟。
四条花费 7 分钟的路径分别为:
- 0 ➝ 6
- 0 ➝ 4 ➝ 6
- 0 ➝ 1 ➝ 2 ➝ 5 ➝ 6
- 0 ➝ 1 ➝ 3 ➝ 5 ➝ 6
```
示例 2:
```
输入:n = 2, roads = [[1,0,10]]
输出:1
解释:只有一条从路口 0 到路口 1 的路,花费 10 分钟。
```
提示:
* $1 <= n <= 200$
* $n - 1 <= roads.length <= \frac{n \times (n - 1)}{2}$
* $roads[i].length == 3$
* $0 <= u_i, v_i <= n - 1$
* $1 <= time_i <= 10^9$
* $u_i != v_i$
* 任意两个路口之间至多有一条路。
* 从任意路口出发,你能够到达其他任意路口。 | ### Dijkstra + 拓扑排序 + DP
为了方便,我们记 `roads` 为 `rs`,令点数为 `n`,边数为 `m`。
边数与点数不在一个数量级上($m \approx n^2$),属于「稠密图」,我们可以使用「邻接矩阵」进行存图,同时使用朴素 `Dijkstra` 求解从 $0$ 号点到其他点的最短路,记为 `dist` 数组,$dist[i] = x$ 代表以 $0$ 号点为起点到到 $i$ 点的最短路径为 $x$。
当我们预处理出 $0$ 点到其他点的最短距离后,考虑如何统计从 $0$ 点到 $n - 1$ 点,且路径和为 $dist[n - 1]$ 的方案数。
一个容易想到的性质:**在任意的合法方案中,途径的该路径中的每个点时,都是以最短路径的方式到达的。**
使用「反证法」证明该性质的正确性:假设其中一条合法路径为 `a -> ... -> k -> ... -> z`(其中 `a` 为 $0$ 号点,`z` 为 $n - 1$ 号点),其为合法路径,意味着从 `a` 到 `z` 的路径和为 $dist[n - 1]$。若我们在经过某个途经点,假设为 `k` 时,所途径的路径总和 $x$ 不是 $dist[k]$ 的话,意味着我们可以调整从 `a` 到 `k` 的路径,使其变为 $dist[k]$,而后续路径不变(从 `k` 到 `z` 的路径不变)来得到一条路径和比 $dist[n - 1]$ 要小的从 `a` 到 `z` 的路径,这与 $dist[n - 1]$ 为从 `a` 到 `z` 的最短路冲突。
至此,我们证明了「**在任意的合法方案中,途径的该路径中的每个点时,都是以最短路径的方式到达的**」这一性质。
利用该性质,我们可以对图进行「重建」,对于原图中点 $a$ 与点 $b$ 权重为 $c$ 的无向边,我们根据 $dist[a]$、$dist[b]$ 和 $c$ 三者关系建立有向边,并统计入度:
* 若有 $dist[b] = dist[a] + c$,在新图上增加从 $a$ 到 $b$ 的权重为 $c$ 的有向边,同时 $b$ 入度加一;
* 若有 $dist[a] = dist[b] + c$,在新图上增加从 $b$ 到 $a$ 的权重为 $c$ 的有向边,同时 $a$ 入度加一。
构建新图的目的是能够在跑「拓扑排序」过程中进行 `DP`,统计方案数。
**定义 $f[i]$ 为从 $0$ 到达 $i$ 点的方案数,$f[n - 1]$ 为答案,同时我们有显而易见的初始化条件 $f[0] = 1$。**
不失一般性考虑 $f[i]$ 如何计算,若我们存在一条从 $i$ 到 $j$ 的出边,并且 $f[i]$ 已确定更新完成(通过判断 $i$ 的入度是为 $0$ 得知,入度为 $0$ 意味着已经没有其他状态可以更新 $f[i]$),我们可以用 $f[i]$ 来更新 $f[j]$,即有 $f[j] = f[j] + f[i]$,含义将到达 $i$ 的路径数累加到到达 $j$ 的路径数中,同时更新 $j$ 的入度。
代码:
```Java
class Solution {
int N = 210, MOD = (int)1e9+7;
long INF = (long)1e12;
int[][] g = new int[N][N];
int[] in = new int[N];
long[] dist = new long[N];
boolean[] vis = new boolean[N];
int n;
public int countPaths(int _n, int[][] rs) {
n = _n;
for (int[] info : rs) {
int a = info[0], b = info[1], c = info[2];
g[a][b] = g[b][a] = c;
}
// 朴素 Dijkstra 求解从 0 点到其他点的最短路
dijkstra();
// 利用最短路重新建图,并统计入度
for (int[] info : rs) {
int a = info[0], b = info[1], c = info[2];
g[a][b] = g[b][a] = 0;
if (dist[a] + c == dist[b]) {
g[a][b] = c; in[b]++;
} else if (dist[b] + c == dist[a]) {
g[b][a] = c; in[a]++;
}
}
// 跑拓扑排序统计方案数
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (in[i] == 0) d.addLast(i);
}
int[] f = new int[n];
f[0] = 1;
while (!d.isEmpty()) {
int x = d.pollFirst();
for (int i = 0; i < n; i++) {
if (g[x][i] == 0) continue;
f[i] += f[x];
f[i] %= MOD;
if (--in[i] == 0) d.addLast(i);
}
}
return f[n - 1];
}
void dijkstra() {
Arrays.fill(dist, INF);
dist[0] = 0;
for (int i = 0; i < n; i++) {
int t = -1;
for (int j = 0; j < n; j++) {
if (!vis[j] && (t == -1 || dist[j] < dist[t])) t = j;
}
vis[t] = true;
for (int j = 0; j < n; j++) {
if (g[t][j] == 0) continue;
dist[j] = Math.min(dist[j], dist[t] + g[t][j]);
}
}
}
}
```
* 时间复杂度:首次建图复杂度为 $O(m)$;Dijkstra 求最短路复杂度为 $O(n^2)$;再次建图复杂度为 $O(m)$,跑拓扑排序统计方案数复杂度为 $O(n + m)$。整体复杂度为 $O(n^2 + m)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1976` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1981-1990/1984. 学生分数的最小差值（简单）.md | 1984. 学生分数的最小差值 | https://leetcode-cn.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/solution/gong-shui-san-xie-pai-xu-hua-dong-chuang-ru6e/ | 简单 | [
"二分",
"滑动窗口"
] | 给你一个 下标从 $0$ 开始 的整数数组 $nums$ ,其中 $nums[i]$ 表示第 $i$ 名学生的分数。另给你一个整数 $k$ 。
从数组中选出任意 $k$ 名学生的分数,使这 $k$ 个分数间 **最高分** 和 **最低分** 的 差值 达到 最小化 。
返回可能的 **最小差值** 。
示例 1:
```
输入:nums = [90], k = 1
输出:0
解释:选出 1 名学生的分数,仅有 1 种方法:
- [90] 最高分和最低分之间的差值是 90 - 90 = 0
可能的最小差值是 0
```
示例 2:
```
输入:nums = [9,4,1,7], k = 2
输出:2
解释:选出 2 名学生的分数,有 6 种方法:
- [9,4,1,7] 最高分和最低分之间的差值是 9 - 4 = 5
- [9,4,1,7] 最高分和最低分之间的差值是 9 - 1 = 8
- [9,4,1,7] 最高分和最低分之间的差值是 9 - 7 = 2
- [9,4,1,7] 最高分和最低分之间的差值是 4 - 1 = 3
- [9,4,1,7] 最高分和最低分之间的差值是 7 - 4 = 3
- [9,4,1,7] 最高分和最低分之间的差值是 7 - 1 = 6
可能的最小差值是 2
```
提示:
* $1 <= k <= nums.length <= 1000$
* $0 <= nums[i] <= 10^5$ | ### 排序 + 滑动窗口
从 $n$ 个元素里找 $k$ 个,使得 $k$ 个元素最大差值最小。
**最大值最小化问题容易想到「二分」,利用答案本身具有「二段性」,来将原本的求解问题转化为判断定问题。**
回到本题,容易证明,这 $k$ 个元素必然是有序数组中(排序后)的连续段。反证法,若最佳 $k$ 个选择不是连续段,能够调整为连续段,结果不会变差。
因此我们可以先对 $nums$ 进行排序,然后扫描所有大小为 $k$ 的窗口,直接找到答案,而无须使用「二分」。
代码(二分答案代码见 $P2$):
```Java
class Solution {
public int minimumDifference(int[] nums, int k) {
Arrays.sort(nums);
int n = nums.length, ans = nums[k - 1] - nums[0];
for (int i = k; i < n; i++) {
ans = Math.min(ans, nums[i] - nums[i - k + 1]);
}
return ans;
}
}
```
-
```Java
class Solution {
int[] nums; int k;
public int minimumDifference(int[] _nums, int _k) {
nums = _nums; k = _k;
Arrays.sort(nums);
int l = 0, r = 100010;
while (l < r) {
int mid = l + r >> 1;
if (check(mid)) r = mid;
else l = mid + 1;
}
return r;
}
boolean check(int x) {
int n = nums.length, ans = nums[k - 1] - nums[0];
for (int i = k; i < n && ans > x; i++) {
ans = Math.min(ans, nums[i] - nums[i - k + 1]);
}
return ans <= x;
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;遍历得到答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1894` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/1994. 好子集的数目（困难）.md | 1994. 好子集的数目 | https://leetcode-cn.com/problems/the-number-of-good-subsets/solution/gong-shui-san-xie-zhuang-ya-dp-yun-yong-gz4w5/ | 困难 | [
"状压 DP"
] | 给你一个整数数组 `nums`。如果 `nums` 的一个子集中,所有元素的乘积可以表示为一个或多个 互不相同的质数 的乘积,那么我们称它为 好子集 。
* 比方说,如果 `nums = [1, 2, 3, 4]` :
* `[2, 3]` ,`[1, 2, 3]` 和 `[1, 3]` 是 好 子集,乘积分别为 `6 = 2*3` ,`6 = 2*3` 和 `3 = 3` 。
* `[1, 4]` 和 `[4]` 不是 好 子集,因为乘积分别为 `4 = 2*2` 和 `4 = 2*2` 。
请你返回 `nums` 中不同的 好 子集的数目对 $10^9 + 7$ 取余 的结果。
`nums` 中的 子集 是通过删除 `nums` 中一些(可能一个都不删除,也可能全部都删除)元素后剩余元素组成的数组。如果两个子集删除的下标不同,那么它们被视为不同的子集。
示例 1:
```
输入:nums = [1,2,3,4]
输出:6
解释:好子集为:
- [1,2]:乘积为 2 ,可以表示为质数 2 的乘积。
- [1,2,3]:乘积为 6 ,可以表示为互不相同的质数 2 和 3 的乘积。
- [1,3]:乘积为 3 ,可以表示为质数 3 的乘积。
- [2]:乘积为 2 ,可以表示为质数 2 的乘积。
- [2,3]:乘积为 6 ,可以表示为互不相同的质数 2 和 3 的乘积。
- [3]:乘积为 3 ,可以表示为质数 3 的乘积。
```
示例 2:
```
输入:nums = [4,2,3,15]
输出:5
解释:好子集为:
- [2]:乘积为 2 ,可以表示为质数 2 的乘积。
- [2,3]:乘积为 6 ,可以表示为互不相同质数 2 和 3 的乘积。
- [2,15]:乘积为 30 ,可以表示为互不相同质数 2,3 和 5 的乘积。
- [3]:乘积为 3 ,可以表示为质数 3 的乘积。
- [15]:乘积为 15 ,可以表示为互不相同质数 3 和 5 的乘积。
```
提示:
* $1 <= nums.length <= 10^5$
* $1 <= nums[i] <= 30$ | ### 状压 DP
该问题属于 NP 完全问题,注定不存在多项式解决方案,只能通过「爆搜 + 剪枝」或「状压 DP」来求解。
对子集的乘积进行质数分解,等价于对子集每一位数进行质数分解。
一个显然的突破口是 $1 <= nums[i] <= 30$,再加上题目对于「好子集」的定义,我们可以进一步缩减可选数的数量,不超过 $30$ 的质数个数包括 $[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$(共 $10$ 个),将其记作 $p$,在一个好子集中,每个 $p[i]$ 最多出现一次。
同时,题目规定数值相同,下标不同均视为不同方案,因此我们可以先使用数组 $cnts$ 统计在 $nums$ 中每个数的出现次数,$cnts[val] = x$ 含义为数值 $val$ 在 $nums$ 中的出现次数为 $x$ 次。
使用的数有限(共 $10$ 个),并且使用到的数最多出现一次,容易想到使用「状压 DP」来求解:我们使用一个二进制数来表示好子集乘积最终能拆解成哪些质数,如果拆解结果中包含 $p[i]$,对应的二进制表示中的第 $i$ 位则为 $1$,否则为 $0$。
**定义 $f[state]$ 为当前子集乘积拆解结果的用到的质数为 $state$ 时的方案数,$state$ 为一个长度 $10$ 的二进制数,若 $state$ 中的第 $k$ 位二进制表示为 $1$,代表数值 $p[k]$ 在拆解结果中出现过;若第 $k$ 位二进制表示为 $0$ 代表 $p[k]$ 在拆解结果中没出现过。**
我们有起始化条件:空集,即 $f[0] = 1$。
不失一般性考虑 $f[s]$ 该如何计算:从前往后考虑每个数值(范围 $[2, 30]$ 的数,$1$ 添加与否不对好子集产生影响,最后讨论)是否可以加入到子集中,一个数值 $t$ 能够添加到子集中的充要条件为题目给定的条件:**该数不会被相同的质数相乘表示**。
如果一个数值 $t$ 能够添加到好子集中,我们通过「试除法」将其分解为 $p$ 中的多个质数,并使用二进制数 $cur$ 来表示用到了 $p$ 中的哪些质数,然后需要判断 $t$ 能够添加到那些子集中,其实就是枚举与 $cur$ 无交集的状态 $prev$,最终的 $f[s]$ 为「所有合法的 $prev$ 的状态数 $f[prev]$」与「数值 $t$ 的出现次数 $cnts[t]$ 」的乘积之和。
需要注意的是,由于我们是从范围 $[2, 30]$ 范围内从前往后考虑每个 $t$,因此**在枚举 $prev$ 时需要进行倒序遍历,确保计算 $f[s]$ 所依赖的 $f[prev]$ 为不考虑当前数值 $t$ 时的方案数**。
由「质数 $p$ 组成的好子集方案数」为 $ans = \sum_{state' = 1}^{{1024}} f[state']$,其中 $state'$ 对应一个合法的好子集方案。
在此基础上,再考虑数值 $1$ 对答案的影响:**在每个合法的 $state'$ 前提下,增加若干个 $1$ 并不影响子集乘积(即好子集增加 $1$ 后仍为好子集),因此每个合法子集 $state'$ 可以对应出 $2^{cnts[1]}$ 个具体方案(代表每个 $1$ 即可以选,也可以不选)**。
代码:
```Java
class Solution {
int MOD = (int)1e9+7;
int[] p = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
int[] cnts = new int[35];
public int numberOfGoodSubsets(int[] nums) {
int n = nums.length;
for (int i : nums) cnts[i]++;
int mask = 1 << 10;
long[] f = new long[mask];
f[0] = 1;
for (int i = 2; i <= 30; i++) {
if (cnts[i] == 0) continue;
// 对 i 进行试除
int cur = 0, x = i;
boolean ok = true;
for (int j = 0; j < 10 && ok; j++) {
int t = p[j], c = 0;
while (x % t == 0) {
cur |= (1 << j);
x /= t; c++;
}
// 如果 i 能够被同一质数试除多次,说明 i 不能加到子集,跳过
if (c > 1) ok = false;
}
if (!ok) continue;
// 枚举前一状态 prev
//(确保考虑一个新数值 i 时,依赖的子集 prev 存储的为尚未考虑 i 的方案数)
for (int prev = mask - 1; prev >= 0; prev--) {
// 只有当前选择数与前一状态不冲突,则能够进行转移,将方案数进行累加
if ((prev & cur) != 0) continue;
f[prev | cur] = (f[prev | cur] + f[prev] * cnts[i]) % MOD;
}
}
long ans = 0;
// 统计所有非空集的方案数
for (int i = 1; i < mask; i++) ans = (ans + f[i]) % MOD;
// 在此基础上,考虑每个 1 选择与否对答案的影响
for (int i = 0; i < cnts[1]; i++) ans = ans * 2 % MOD;
return (int) ans;
}
}
```
* 时间复杂度:预处理每个数值的出现次数复杂度为 $O(n)$;令数值范围 $C = 30$,状态数为 $M = 1024$,DP 部分复杂度为 $O(C \times M)$。整体复杂度为 $O(n + C \times M)$
* 空间复杂度:$O(C + M)$
---
### 关于「倒序遍历」状态的答疑
上述的分析推理基于我们进行了「一维空间优化」。
原始的状态定义应该是 **$f[i][state]$ 为考虑范围在 $[1,30]$ 的前 $i$ 个数,并且好子集拆解结果的用到的质数为 $state$ 时的方案数。**
我们有显然的初始化条件:$f[1][0] = 1$,代表当只有数值 $1$ 的话,只有空集为合法方案。
不失一般性的考虑 $f[i][s]$ 该如何计算,根据使用数值 $i$ 来进行分情况讨论:
* 不考虑数值 $i$(或是数值 $i$ 在 $nums$ 中没有出现,无法考虑),则有 $f[i][s] = f[i - 1][s]$;
* 考虑数值 $i$,分析方法同「一维空间优化」,对数值 $i$ 应用「试除法」拆解成对应的质数状态 $cur$,然后找到可以转移的前一状态 $prev$ 来尝试转移,则有 $f[i][cur | prev] = f[i][cur | prev] + f[i - 1][prev]$。
基于对「原始状态定义」的分析,我们发现 $f[i][cur | prev]$ 的更新(累加)依赖于 $f[i][prev]$,同时 $prev$ 是 $cur | prev$ 的子集,因此在进行「一维空间优化」,我们需要确保所依赖的状态没有被覆盖更新,即采用「倒序遍历」。
代码:
```Java
class Solution {
int MOD = (int)1e9+7;
int[] p = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
int[] cnts = new int[35];
public int numberOfGoodSubsets(int[] nums) {
for (int i : nums) cnts[i]++;
int mask = 1 << 10;
long[][] f = new long[35][mask];
f[1][0] = 1;
for (int i = 2; i <= 30; i++) {
for (int s = 0; s < mask; s++) f[i][s] = f[i - 1][s];
if (cnts[i] == 0) continue;
int cur = 0, x = i;
boolean ok = true;
for (int j = 0; j < 10 && ok; j++) {
int t = p[j], c = 0;
while (x % t == 0) {
cur |= (1 << j);
x /= t; c++;
}
if (c > 1) ok = false;
}
if (!ok) continue;
for (int prev = 0; prev < mask; prev++) {
if ((prev & cur) != 0) continue;
f[i][prev | cur] = (f[i][prev | cur] + f[i - 1][prev] * cnts[i]) % MOD;
}
}
long ans = 0;
for (int i = 1; i < mask; i++) ans = (ans + f[30][i]) % MOD;
for (int i = 0; i < cnts[1]; i++) ans = ans * 2 % MOD;
return (int) ans;
}
}
```
* 时间复杂度:预处理每个数值的出现次数复杂度为 $O(n)$;令数值范围 $C = 30$,状态数为 $M = 1024$,DP 部分复杂度为 $O(C \times M)$。整体复杂度为 $O(n + C \times M)$
* 空间复杂度:$O(C \times M)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1994` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/1995. 统计特殊四元组（简单）.md | 1995. 统计特殊四元组 | https://leetcode-cn.com/problems/count-special-quadruplets/solution/gong-shui-san-xie-yi-ti-si-jie-mei-ju-ha-gmhv/ | 简单 | [
"枚举",
"哈希表",
"背包 DP"
] | 给你一个 下标从 `0` 开始 的整数数组 `nums`,返回满足下述条件的**不同**四元组 `(a, b, c, d)` 的 数目 :
`nums[a] + nums[b] + nums[c] == nums[d]`,且 `a < b < c < d`。
示例 1:
```
输入:nums = [1,2,3,6]
输出:1
解释:满足要求的唯一一个四元组是 (0, 1, 2, 3) 因为 1 + 2 + 3 == 6 。
```
示例 2:
```
输入:nums = [3,3,6,4,5]
输出:0
解释:[3,3,6,4,5] 中不存在满足要求的四元组。
```
示例 3:
```
输入:nums = [1,1,1,3,5]
输出:4
解释:满足要求的 4 个四元组如下:
- (0, 1, 2, 3): 1 + 1 + 1 == 3
- (0, 1, 3, 4): 1 + 1 + 3 == 5
- (0, 2, 3, 4): 1 + 1 + 3 == 5
- (1, 2, 3, 4): 1 + 1 + 3 == 5
```
提示:
* $4 <= nums.length <= 50$
* $1 <= nums[i] <= 100$ | ### 朴素解法
利用数据范围只有 $50$,可直接根据题意进行模拟。
代码:
```Java
class Solution {
public int countQuadruplets(int[] nums) {
int n = nums.length, ans = 0;
for (int a = 0; a < n; a++) {
for (int b = a + 1; b < n; b++) {
for (int c = b + 1; c < n; c++) {
for (int d = c + 1; d < n; d++) {
if (nums[a] + nums[b] + nums[c] == nums[d]) ans++;
}
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^4)$
* 空间复杂度:$O(1)$
---
### 哈希表
利用等式关系 $nums[a] + nums[b] + nums[c] = nums[d]$,可以调整枚举 $c$ 的顺序为「逆序」,每次 $c$ 往左移动一个单位,$d$ 的可取下标范围增加一个(即 $c + 1$ 位置),使用数组代替哈希表对 $nums[d]$ 的个数进行统计,可使复杂度下降到 $O(n^3)$。
代码:
```Java
class Solution {
public int countQuadruplets(int[] nums) {
int n = nums.length, ans = 0;
int[] cnt = new int[10010];
for (int c = n - 2; c >= 2; c--) {
cnt[nums[c + 1]]++;
for (int a = 0; a < n; a++) {
for (int b = a + 1; b < c; b++) {
ans += cnt[nums[a] + nums[b] + nums[c]];
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(C)$
---
### 哈希表
更进一步,根据等式关系进行移项可得:$nums[a] + nums[b] = nums[d] - nums[c]$,其中各下标满足 $a < b < c < d$。
我们可在「逆序」枚举 $b$ 时,将新产生的 $c$(即 $b + 1$ 位置)所能产生的新 $nums[d] - nums[c]$ 的值存入哈希表(即 从 $[b + 2, n)$ 范围内枚举 $d$),最后通过枚举 $a$ 来统计答案。
> 一些细节:由于 $nums[d] - nums[c]$ 可能为负,在使用数组代替哈希表时,可利用 $1 <= nums[i] <= 100$ 做一个值偏移。
代码:
```Java
class Solution {
public int countQuadruplets(int[] nums) {
int n = nums.length, ans = 0;
int[] cnt = new int[10010];
for (int b = n - 3; b >= 1; b--) {
for (int d = b + 2; d < n; d++) cnt[nums[d] - nums[b + 1] + 200]++;
for (int a = 0; a < b; a++) ans += cnt[nums[a] + nums[b] + 200];
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(C)$
---
### 多维背包
利用等式关系 $nums[a] + nums[b] + nums[c] = nums[d]$,具有明确的「数值」和「个数」关系,可将问题抽象为组合优化问题求方案数。
限制组合个数的维度有两个,均为「恰好」限制,转换为「二维费用背包问题求方案数」问题。
**定义 $f[i][j][k]$ 为考虑前 $i$ 个物品(下标从 $1$ 开始),凑成数值恰好 $j$,使用个数恰好为 $k$ 的方案数。**
最终答案为 $\sum_{i = 3}^{n - 1}(f[i][nums[i]][3])$,起始状态 $f[0][0][0] = 1$ 代表不考虑任何物品时,所用个数为 $0$,凑成数值为 $0$ 的方案数为 $1$。
不失一般性考虑 $f[i][j][k]$ 该如何转移,根据 $nums[i - 1]$ 是否参与组合进行分情况讨论:
* $nums[i - 1]$ 不参与组成,此时有:$f[i - 1][j][k]$;
* $nums[i - 1]$ 参与组成,此时有:$f[i - 1][j - t][k - 1]$;
最终 $f[i][j][k]$ 为上述两种情况之和,最终统计 $\sum_{i = 3}^{n - 1}(f[i][nums[i]][3])$ 即是答案。
> 利用 $f[i][j][k]$ 仅依赖于 $f[i - 1][j][k]$ 和 `j` `k` 维度值更小的 $f[i - 1][X][X]$,可进行维度优化,并在转移过程中统计答案。
代码(维度优化见 $P2$):
```Java
class Solution {
public int countQuadruplets(int[] nums) {
int n = nums.length;
int[][][] f = new int[n + 1][110][4];
f[0][0][0] = 1;
for (int i = 1; i <= n; i++) {
int t = nums[i - 1];
for (int j = 0; j < 110; j++) {
for (int k = 0; k < 4; k++) {
f[i][j][k] += f[i - 1][j][k];
if (j - t >= 0 && k - 1 >= 0) f[i][j][k] += f[i - 1][j - t][k - 1];
}
}
}
int ans = 0;
for (int i = 3; i < n; i++) ans += f[i][nums[i]][3];
return ans;
}
}
```
```Java
class Solution {
public int countQuadruplets(int[] nums) {
int n = nums.length, ans = 0;
int[][] f = new int[110][4];
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
int t = nums[i - 1];
ans += f[t][3];
for (int j = 109; j >= 0; j--) {
for (int k = 3; k >= 0; k--) {
if (j - t >= 0 && k - 1 >= 0) f[j][k] += f[j - t][k - 1];
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(n * 110 * 4)$
* 空间复杂度:$O(n * 110 * 4)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1995` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/1996. 游戏中弱角色的数量（中等）.md | 1996. 游戏中弱角色的数量 | https://leetcode-cn.com/problems/the-number-of-weak-characters-in-the-game/solution/gong-shui-san-xie-tan-xin-yun-yong-ti-by-5ok6/ | 中等 | [
"贪心"
] | 你正在参加一个多角色游戏,每个角色都有两个主要属性:攻击 和 防御 。
给你一个二维整数数组 `properties`,其中 $properties[i] = [attack_i, defense_i]$ 表示游戏中第 $i$ 个角色的属性。
如果存在一个其他角色的攻击和防御等级 都严格高于 该角色的攻击和防御等级,则认为该角色为 弱角色 。
更正式地,如果认为角色 `i` 弱于 存在的另一个角色 `j` ,那么 $attack_j > attack_i$ 且 $defense_j > defense_i$ 。
返回 **弱角色** 的数量。
示例 1:
```
输入:properties = [[5,5],[6,3],[3,6]]
输出:0
解释:不存在攻击和防御都严格高于其他角色的角色。
```
示例 2:
```
输入:properties = [[2,2],[3,3]]
输出:1
解释:第一个角色是弱角色,因为第二个角色的攻击和防御严格大于该角色。
```
示例 3:
```
输入:properties = [[1,5],[10,4],[4,3]]
输出:1
解释:第三个角色是弱角色,因为第二个角色的攻击和防御严格大于该角色。
```
提示:
* $2 <= properties.length <= 10^5$
* $properties[i].length == 2$
* $1 <= attacki, defensei <= 10^5$ | ### 排序 + 贪心 + 计数
为了方便,我们使用 `ps` 来代指 `properties`。
决定角色「强弱」的维度有两个,同时由于我们只关心某个角色是否为弱角色,而不关心有多少比其(严格)强的角色有多少个。
因此我们先对 `ps` 进行排序:**优先根据第一维度(攻击力)排序,在第一维度(攻击力)相同时,根据第二维度(防御力)进行排序**。
由于我们统计的是「严格弱角色」,因此在从前往后处理 `ps` 过程中,要将第一维度(攻击力)相同的作为一组进行处理,假设 $[i, j)$ 为第一维度(攻击力)相同的连续段,假设当前处理到连续段 $[i, j)$ 中的第 $k$ 个角色 $ps[k]$,那么 $ps[k]$ 为弱角色的充要条件为:
1. **存在比 $ps[k][0]$ 攻击力高的角色,由于我们先按照了攻击力进行排序,同时又是按照攻击相同为一组进行处理,因此这等价于当前连续段 $[i, j)$ 不是第一组,即 $i \neq 0$;**
2. **在满足 $1$ 的前提下,存在防御力比 $ps[k][1]$ 高的角色,由于要求弱角色为「严格」,因此我们只能在之前的组(攻击力比 $ps[k][0]$ 大的相同连续段)去找。这意味着我们在遍历过程中需要贪心地维护一个防御力的最大值 $\max$,并在处理完相同连续段后尝试对其进行更新。**
代码:
```Java
class Solution {
public int numberOfWeakCharacters(int[][] ps) {
int n = ps.length, ans = 0;
Arrays.sort(ps, (a, b)->{
if (a[0] != b[0]) return b[0] - a[0];
return b[1] - a[1];
});
for (int i = 0, max = ps[0][1]; i < n; ) {
int j = i, cur = max;
while (j < n && ps[j][0] == ps[i][0]) {
if (i != 0 && ps[j][1] < max) ans++;
cur = Math.max(cur, ps[j][1]);
j++;
}
i = j; max = cur;
}
return ans;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$;统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1996` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1991-2000/2000. 反转单词前缀（简单）.md | 2000. 反转单词前缀 | https://leetcode-cn.com/problems/reverse-prefix-of-word/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-dp9u/ | 简单 | [
"模拟",
"双指针"
] | 给你一个下标从 $0$ 开始的字符串 `word` 和一个字符 `ch` 。找出 `ch` 第一次出现的下标 `i` ,反转 `word` 中从下标 $0$ 开始、直到下标 `i` 结束(含下标 `i` )的那段字符。如果 `word` 中不存在字符 `ch` ,则无需进行任何操作。
* 例如,如果 `word = "abcdefd"` 且 `ch = "d"` ,那么你应该 反转 从下标 $0$ 开始、直到下标 `3` 结束(含下标 `3` )。结果字符串将会是 `"dcbaefd"` 。
返回 结果字符串 。
示例 1:
```
输入:word = "abcdefd", ch = "d"
输出:"dcbaefd"
解释:"d" 第一次出现在下标 3 。
反转从下标 0 到下标 3(含下标 3)的这段字符,结果字符串是 "dcbaefd" 。
```
示例 2:
```
输入:word = "xyxzxe", ch = "z"
输出:"zxyxxe"
解释:"z" 第一次也是唯一一次出现是在下标 3 。
反转从下标 0 到下标 3(含下标 3)的这段字符,结果字符串是 "zxyxxe" 。
```
示例 3:
```
输入:word = "abcd", ch = "z"
输出:"abcd"
解释:"z" 不存在于 word 中。
无需执行反转操作,结果字符串是 "abcd" 。
```
提示:
* $1 <= word.length <= 250$
* `word` 由小写英文字母组成
* `ch` 是一个小写英文字母 | ### 模拟
先从前往后遍历,找到第一个 `ch` 的下标 $idx$(初始值为 $-1$),然后对 $[0, idx]$ 应用双指针进行翻转(若没有 `ch` 字符,则 $idx = -1$,则 $[0, idx]$ 为不合法区间,翻转过程被跳过)。
代码:
```Java
class Solution {
public String reversePrefix(String word, char ch) {
char[] cs = word.toCharArray();
int n = cs.length, idx = -1;
for (int i = 0; i < n && idx == -1; i++) {
if (cs[i] == ch) idx = i;
}
int l = 0, r = idx;
while (l < r) {
char c = cs[l];
cs[l++] = cs[r];
cs[r--] = c;
}
return String.valueOf(cs);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:`toCharArray` 会产生新数组,复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2000` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2001-2010/2003. 每棵子树内缺失的最小基因值（困难）.md | 2003. 每棵子树内缺失的最小基因值 | https://leetcode.cn/problems/smallest-missing-genetic-value-in-each-subtree/solutions/2505877/gong-shui-san-xie-tu-jie-san-da-jie-lun-mxjrn/ | 困难 | [
"DFS",
"图",
"脑筋急转弯"
] | 有一棵根节点为 `0` 的 家族树 ,总共包含 `n` 个节点,节点编号为 `0` 到 `n - 1`。
给你一个下标从 `0` 开始的整数数组 `parents`,其中 $parents[i]$ 是节点 `i` 的父节点。由于节点 `0` 是根 ,所以 $parents[0] = -1$。
总共有 $10^5$ 个基因值,每个基因值都用 闭区间 $[1, 10^5]$ 中的一个整数表示。
给你一个下标从 `0` 开始的整数数组 `nums`,其中 $nums[i]$ 是节点 `i` 的基因值,且基因值 互不相同 。
请你返回一个数组 `ans`,长度为 `n`,其中 $ans[i]$ 是以节点 `i` 为根的子树内缺失的最小基因值。
节点 `x` 为根的子树包含节点 `x` 和它所有的后代节点。
示例 1:
```
输入:parents = [-1,0,0,2], nums = [1,2,3,4]
输出:[5,1,1,1]
解释:每个子树答案计算结果如下:
- 0:子树包含节点 [0,1,2,3] ,基因值分别为 [1,2,3,4] 。5 是缺失的最小基因值。
- 1:子树只包含节点 1 ,基因值为 2 。1 是缺失的最小基因值。
- 2:子树包含节点 [2,3] ,基因值分别为 [3,4] 。1 是缺失的最小基因值。
- 3:子树只包含节点 3 ,基因值为 4 。1是缺失的最小基因值。
```
示例 2:
```
输入:parents = [-1,0,1,0,3,3], nums = [5,4,6,2,1,3]
输出:[7,1,1,4,2,1]
解释:每个子树答案计算结果如下:
- 0:子树内包含节点 [0,1,2,3,4,5] ,基因值分别为 [5,4,6,2,1,3] 。7 是缺失的最小基因值。
- 1:子树内包含节点 [1,2] ,基因值分别为 [4,6] 。 1 是缺失的最小基因值。
- 2:子树内只包含节点 2 ,基因值为 6 。1 是缺失的最小基因值。
- 3:子树内包含节点 [3,4,5] ,基因值分别为 [2,1,3] 。4 是缺失的最小基因值。
- 4:子树内只包含节点 4 ,基因值为 1 。2 是缺失的最小基因值。
- 5:子树内只包含节点 5 ,基因值为 3 。1 是缺失的最小基因值。
```
示例 3:
```
输入:parents = [-1,2,3,0,2,4,1], nums = [2,3,4,5,6,7,8]
输出:[1,1,1,1,1,1,1]
解释:所有子树都缺失基因值 1 。
```
提示:
* $n = parents.length = nums.length$
* $2 <= n <= 10^5$
* 对于 `i != 0`,满足 $0 <= parents[i] <= n - 1$
* $parents[0] = -1$
* `parents` 表示一棵合法的树。
* $1 <= nums[i] <= 10^5$
* `nums[i]` 互不相同。 | ### DFS
#### 破题
先用几句话破题。
共由 $n$ 个节点组成一棵树(节点编号从 $0$ 到 $n - 1$),`parents` 描述了该树的形态,同时每个节点有一个基因值 $nums[i]$。
题目要我们求:**以每个节点为根的子树中,权重集合在 $[1, n + 1]$ 范围内缺失的最小数**。
> 需要重点注意:是权重集合在 $[1, n + 1]$ 范围内缺失的最小数,而不是在 `nums` 中缺失的最小数。
举个 🌰,假设由 $4$ 个节点组成树,基因值 `nums = [2,3,4,5]`,那么对应的 `ans = [1,1,1,1]`。
再次强调:我们求的是每个节点为根的子树中,权重集合在 $[1, n + 1]$ 范围内的最小缺失值,而非在 `nums` 中的缺失值。
#### 结论一:当`nums` 中没有 $1$,所有节点答案为 $1$
由于我们是求 $[1, n + 1]$ 范围内的最小缺失值,当 `nums` 中不存在 $1$ 时,所有节点缺失的最小值为 $1$。
#### 结论二:`nums` 有 $1$,所有该节点的“非祖先”节点,答案为 $1$
基因值互不相同,同时统计的是,以每个节点为“根”时,子树的权值情况,因此节点 $1$ 只会对其“祖先”产生影响。
#### 结论三:从「$1$ 节点」到「根节点」的路径中,答案必然满足“非递减”性质
这个结论不明显,但不难理解。
先假设存在某个节点 `X`,其最小缺失值为 $k$:
再通过节点 `X` 的最小缺失值,推理出父节点 `Fa` 的情况:
综上,我们只需要考虑「节点 $1$」到「根节点」这一节点答案即可。
并且由于从下往上,答案非递减,我们采取「先算子节点,再算父节点」的方式。
具体的,用变量 `cur` 代指当前节点,使用 `ne` 代指当前节点的子节点,`vis` 数组记录在子树中出现过的基因值,`val` 代表当前的节点的最小缺失值。
一些细节:由于题目只说了 $1 \leq nums[i] \leq 1e5$,没说 $nums[i]$ 与 $n$ 的关系,因此我们开辟 `vis` 数组时需要开到 $100010$,或是干脆使用 `Set` 充当 `vis`。
Java 代码:
```Java
class Solution {
// 考虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点一有两个子节点 2 和 3
Map<Integer, List<Integer>> g = new HashMap<>();
public int[] smallestMissingValueSubtree(int[] parents, int[] nums) {
int n = nums.length, cur = -1;
int[] ans = new int[n];
Arrays.fill(ans, 1);
// 找节点 1, 建图
for (int i = 0; i < n; i++) {
if (nums[i] == 1) cur = i;
List<Integer> list = g.getOrDefault(parents[i], new ArrayList<>());
list.add(i);
g.put(parents[i], list);
}
// 若 nums 中没 1, 对应结论一
if (cur == -1) return ans;
boolean[] vis = new boolean[100010];
// 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点
int ne = cur, val = 1;
while (cur != -1) {
// 每次对当前节点所在子树的进行标记
dfs(cur, ne, nums, vis);
// 在 [val, n+1] 范围内找第一个未被标记基因值
for (int i = val; i <= n + 1; i++) {
if (vis[i]) continue;
ans[cur] = val = i;
break;
}
ne = cur; cur = parents[cur]; // 指针上移
}
return ans;
}
void dfs(int idx, int block, int[] nums, boolean[] vis) {
vis[nums[idx]] = true;
List<Integer> list = g.getOrDefault(idx, new ArrayList<>());
for (int x : list) {
if (x == block) continue;
dfs(x, block, nums, vis);
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
// 考虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点一有两个子节点 2 和 3
unordered_map<int, vector<int>> g;
vector<int> smallestMissingValueSubtree(std::vector<int>& parents, std::vector<int>& nums) {
int n = nums.size(), cur = -1;
vector<int> ans(n, 1);
// 找节点 1, 建图
for (int i = 0; i < n; i++) {
if (nums[i] == 1) cur = i;
g[parents[i]].push_back(i);
}
// 若 nums 中没 1, 对应结论一
if (cur == -1) return ans;
unordered_set<int> vis;
// 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点
int ne = cur, val = 1;
while (cur != -1) {
// 每次对当前节点所在子树的进行标记
dfs(cur, ne, nums, vis);
// 在 [val, n+1] 范围内找第一个未被标记基因值
for (int i = val; i <= n + 1; i++) {
if (vis.count(i)) continue;
ans[cur] = val = i;
break;
}
ne = cur; cur = parents[cur]; // 指针上移
}
return ans;
}
void dfs(int idx, int block, vector<int>& nums, unordered_set<int>& vis) {
vis.insert(nums[idx]);
for (int x : g[idx]) {
if (x == block) continue;
dfs(x, block, nums, vis);
}
}
};
```
Python 代码:
```Python
class Solution:
def smallestMissingValueSubtree(self, parents: List[int], nums: List[int]) -> List[int]:
# 虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点 1 有两个子节点 2 和 3
g = defaultdict(list)
def dfs(idx, block):
nonlocal val
vis.add(nums[idx])
for x in g[idx]:
if x == block:
continue
dfs(x, block)
n, cur = len(nums), -1
ans = [1] * n
# 找节点 1, 建图
for i in range(n):
if nums[i] == 1:
cur = i
g[parents[i]].append(i)
# 若 nums 中没 1, 对应结论一
if cur == -1:
return ans
vis = set()
# 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点
ne, val = cur, 1
while cur != -1:
# 每次对当前节点所在子树的进行标记
dfs(cur, ne)
# 在 [val, n+1] 范围内找第一个未被标记基因值
for i in range(val, n + 2):
if i in vis:
continue
ans[cur] = val = i
break
ne, cur = cur, parents[cur] # 指针上移
return ans
```
TypeScript 代码:
```TypeScript
function smallestMissingValueSubtree(parents: number[], nums: number[]): number[] {
// 考虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点 1 有两个子节点 2 和 3
const g = {};
const dfs = function (g: { [key: number]: number[] }, idx: number, block: number, nums: number[], vis: Set<number>): void {
vis.add(nums[idx]);
if (Array.isArray(g[idx])) {
for (let x of g[idx]) {
if (x == block) continue;
dfs(g, x, block, nums, vis);
}
}
}
let n = nums.length, cur = -1;
const ans = new Array(n).fill(1);
// 找节点 1, 建图
for (let i = 0; i < n; i++) {
if (nums[i] === 1) cur = i;
if (!g[parents[i]]) g[parents[i]] = [];
g[parents[i]].push(i);
}
// 若 nums 中没 1, 对应结论一
if (cur == -1) return ans;
const vis = new Set<number>();
// 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点
let ne = cur, val = 1;
while (cur !== -1) {
// 每次对当前节点所在子树的进行标记
dfs(g, cur, ne, nums, vis);
// 在 [val, n+1] 范围内找第一个未被标记基因值
for (let i = val; i <= n + 1; i++) {
if (vis.has(i)) continue;
ans[cur] = val = i;
break;
}
ne = cur; cur = parents[cur]; // 指针上移
}
return ans;
}
```
Java 代码(链式向前星,使用 `Set` 充当 `vis`):
```Java
class Solution {
int N = 100010, M = N, idx = 1;
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[] smallestMissingValueSubtree(int[] parents, int[] nums) {
Arrays.fill(he, -1);
int n = parents.length, cur = -1, val = 1;
int[] ans = new int[n];
Arrays.fill(ans, 1);
for (int i = 0; i < n; i++) {
if (i >= 1) add(parents[i], i);
if (nums[i] == 1) cur = i;
}
if (cur == -1) return ans;
Set<Integer> vis = new HashSet();
while (cur != -1) {
dfs(cur, vis, nums);
for (int i = val; i <= n + 1; i++) {
if (vis.contains(i)) continue;
ans[cur] = val = i;
break;
}
cur = parents[cur];
}
return ans;
}
void dfs(int u, Set<Integer> vis, int[] nums) {
vis.add(nums[u]);
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (vis.contains(nums[j])) continue;
dfs(j, vis, nums);
}
}
}
```
* 时间复杂度:找 $1$ 和建图的复杂度为 $O(n)$;构造从根节点到 $1$节点的链条答案时,会对子树节点进行标记,同时每个节点的答案会从 $[val, n + 1]$ 范围内找缺失值,复杂度为 $O(n)$。 整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2003` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2001-2010/2006. 差的绝对值为 K 的数对数目（简单）.md | 2006. 差的绝对值为 K 的数对数目 | https://leetcode-cn.com/problems/count-number-of-pairs-with-absolute-difference-k/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-1jel/ | 简单 | [
"模拟",
"哈希表"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,请你返回数对 $(i, j)$ 的数目,满足 $i < j$ 且`|nums[i] - nums[j]| == k`。
`|x|` 的值定义为:
* 如果 $x >= 0$ ,那么值为 $x$ 。
* 如果 $x < 0$ ,那么值为 $-x$ 。
示例 1:
```
输入:nums = [1,2,2,1], k = 1
输出:4
解释:差的绝对值为 1 的数对为:
- [1,2,2,1]
- [1,2,2,1]
- [1,2,2,1]
- [1,2,2,1]
```
示例 2:
```
输入:nums = [1,3], k = 3
输出:0
解释:没有任何数对差的绝对值为 3 。
```
示例 3:
```
输入:nums = [3,2,1,5,4], k = 2
输出:3
解释:差的绝对值为 2 的数对为:
- [3,2,1,5,4]
- [3,2,1,5,4]
- [3,2,1,5,4]
```
提示:
* $1 <= nums.length <= 200$
* $1 <= nums[i] <= 100$
* $1 <= k <= 99$ | ### 朴素解法
数据范围很小,直接根据题意模拟即可。
代码:
```Java
class Solution {
public int countKDifference(int[] nums, int k) {
int n = nums.length, ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (Math.abs(nums[i] - nums[j]) == k) ans++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$
---
### 哈希表
对于每个 $t = nums[j]$ 而言,是要找与其相对差值为 $k$ 且下标比其小的数(即 $t - k$ 和 $t + k$),可以采取边遍历边记录某个数出现次数,从而将复杂度优化到 $O(n)$。
再利用数据范围 $1 <= nums[i] <= k$,可以直接使用数组充当哈希表。
代码:
```Java
class Solution {
public int countKDifference(int[] nums, int k) {
int[] cnts = new int[110];
int n = nums.length, ans = 0;
for (int i = 0; i < n; i++) {
int t = nums[i];
if (t - k >= 1) ans += cnts[t - k];
if (t + k <= 100) ans += cnts[t + k];
cnts[t]++;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2006` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/203. 移除链表元素（简单）.md | 203. 移除链表元素 | https://leetcode-cn.com/problems/remove-linked-list-elements/solution/gong-shui-san-xie-yi-chu-lian-biao-yuan-ca6fu/ | 简单 | [
"链表"
] | 给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
示例 1:
```
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
```
示例 2:
```
输入:head = [], val = 1
输出:[]
```
示例 3:
```
输入:head = [7,7,7,7], val = 7
输出:[]
```
提示:
* 列表中的节点在范围 [0, $10^4$] 内
* 1 <= Node.val <= 50
* 0 <= k <= 50 | ### 递归
一个直观的做法是:写一个递归函数来将某个值为 `val` 的节点从链表中移除。
由于是单链表,无法通过某个节点直接找到「前一个节点」,因此为了方便,我们可以为递归函数多设置一个入参,代表「前一个节点」。
代码:
```Java
class Solution {
public ListNode removeElements(ListNode head, int val) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
dfs(dummy, dummy.next, val);
return dummy.next;
}
void dfs(ListNode prev, ListNode root, int val) {
if (root == null) return ;
if (root.val == val) {
prev.next = root.next;
} else {
prev = root;
}
dfs(prev, prev.next, val);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销。复杂度为 $O(1)$
---
### 迭代
同理,我们可以使用「迭代」方式来实现,而迭代有 `while` 和 `for` 两种写法。
代码:
```Java
class Solution {
public ListNode removeElements(ListNode head, int val) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
for (ListNode tmp = dummy.next, prev = dummy; tmp != null; tmp = tmp.next) {
if (tmp.val == val) {
prev.next = tmp.next;
} else {
prev = tmp;
}
}
return dummy.next;
}
}
```
```Java
class Solution {
public ListNode removeElements(ListNode head, int val) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode tmp = dummy.next, prev = dummy;
while (tmp != null) {
if (tmp.val == val) {
prev.next = tmp.next;
} else {
prev = tmp;
}
tmp = tmp.next;
}
return dummy.next;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.203` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/207. 课程表（中等）.md | 207. 课程表 | https://leetcode.cn/problems/course-schedule/solution/by-ac_oier-byxo/ | 中等 | [
"图论",
"拓扑排序"
] | 你这个学期必须选修 `numCourses` 门课程,记为 $0$ 到 $numCourses - 1$ 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 `prerequisites` 给出,其中 $prerequisites[i] = [a_i, b_i]$ ,表示如果要学习课程 $a_i$ 则 必须 先学习课程 $b_i$ 。
* 例如,先修课程对 $[0, 1$] 表示:想要学习课程 $0$ ,你需要先完成课程 $1$ 。
请你判断是否可能完成所有课程的学习?如果可以,返回 `true`;否则,返回 `false`。
示例 1:
```
输入:numCourses = 2, prerequisites = [[1,0]]
输出:true
解释:总共有 2 门课程。学习课程 1 之前,你需要完成课程 0 。这是可能的。
```
示例 2:
```
输入:numCourses = 2, prerequisites = [[1,0],[0,1]]
输出:false
解释:总共有 2 门课程。学习课程 1 之前,你需要先完成课程 0 ;并且学习课程 0 之前,你还应先完成课程 1 。这是不可能的。
```
提示:
* $1 <= numCourses <= 10^5$
* $0 <= prerequisites.length <= 5000$
* $prerequisites[i].length == 2$
* $0 <= a_i, b_i < numCourses$
* `prerequisites[i]` 中的所有课程对 互不相同 | ### 拓扑排序
为了方便,我们记 `numCourses` 为 `n`,`prerequisites` 为 `g`。
若课程 `a` 存在前置课程 `b` 的话,我们添加一条从 `b` 到 `a` 的有向边,同时统计所有点的入度。
当处理完所有的 $g[i]$ 后,将所有的入度为 $0$ 的课程(含义为没有前置课程要求的科目)进行入队操作,跑一遍「拓扑排序」,若所有课程都能顺利出队,说明所有课程都能使完成。
代码:
```Java
class Solution {
int N = 100010, M = 5010;
int[] in = new int[N], he = new int[N], e = new int[M], ne = new int[M];
int idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
in[b]++;
}
public boolean canFinish(int n, int[][] g) {
Arrays.fill(he, -1);
for (int[] info : g) add(info[1], info[0]);
int ans = 0;
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (in[i] == 0) d.addLast(i);
}
while (!d.isEmpty()) {
int t = d.pollFirst();
ans++;
for (int i = he[t]; i != -1; i = ne[i]) {
int j = e[i];
if (--in[j] == 0) d.addLast(j);
}
}
return ans == n;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.207` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/208. 实现 Trie (前缀树)（中等）.md | 208. 实现 Trie (前缀树) | https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/ | 中等 | [
"字典树"
] | Trie(发音类似 "try")或者说 前缀树 是一种树形数据结构,用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景,例如自动补完和拼写检查。
请你实现 Trie 类:
* Trie() 初始化前缀树对象。
* void insert(String word) 向前缀树中插入字符串 word 。
* boolean search(String word) 如果字符串 word 在前缀树中,返回 true(即,在检索之前已经插入);否则,返回 false 。
* boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ,返回 true ;否则,返回 false 。
示例:
```
输入
["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
输出
[null, null, true, false, true, null, true]
解释
Trie trie = new Trie();
trie.insert("apple");
trie.search("apple"); // 返回 True
trie.search("app"); // 返回 False
trie.startsWith("app"); // 返回 True
trie.insert("app");
trie.search("app"); // 返回 True
```
提示:
* 1 <= word.length, prefix.length <= 2000
* word 和 prefix 仅由小写英文字母组成
* insert、search 和 startsWith 调用次数 总计 不超过 3 * $10^4$ 次 | ### Trie 树
$Trie$ 树(又叫「前缀树」或「字典树」)是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。
其核心是使用「边」来代表有无字符,使用「点」来记录是否为「单词结尾」以及「其后续字符串的字符是什么」。
---
### 二维数组
一个朴素的想法是直接使用「二维数组」来实现 $Trie$ 树。
* 使用二维数组 $trie[]$ 来存储我们所有的单词字符。
* 使用 $index$ 来自增记录我们到底用了多少个格子(相当于给被用到格子进行编号)。
* 使用 $count[]$ 数组记录某个格子被「被标记为结尾的次数」(当 $idx$ 编号的格子被标记了 $n$ 次,则有 $cnt[idx] = n$)。
代码 :
```java []
class Trie {
int N = 100009; // 直接设置为十万级
int[][] trie;
int[] count;
int index;
public Trie() {
trie = new int[N][26];
count = new int[N];
index = 0;
}
public void insert(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (trie[p][u] == 0) trie[p][u] = ++index;
p = trie[p][u];
}
count[p]++;
}
public boolean search(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (trie[p][u] == 0) return false;
p = trie[p][u];
}
return count[p] != 0;
}
public boolean startsWith(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (trie[p][u] == 0) return false;
p = trie[p][u];
}
return true;
}
}
```
* 时间复杂度:$Trie$ 树的每次调用时间复杂度取决于入参字符串的长度。复杂度为 $O(Len)$。
* 空间复杂度:二维数组的高度为 $n$,字符集大小为 $k$。复杂度为 $O(nk)$。
---
### TrieNode
相比二维数组,更加常规的做法是建立 $TrieNode$ 结构节点。
随着数据的不断插入,根据需要不断创建 $TrieNode$ 节点。
代码:
```java []
class Trie {
class TrieNode {
boolean end;
TrieNode[] tns = new TrieNode[26];
}
TrieNode root;
public Trie() {
root = new TrieNode();
}
public 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.end = true;
}
public boolean search(String s) {
TrieNode p = root;
for(int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (p.tns[u] == null) return false;
p = p.tns[u];
}
return p.end;
}
public boolean startsWith(String s) {
TrieNode p = root;
for(int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (p.tns[u] == null) return false;
p = p.tns[u];
}
return true;
}
}
```
* 时间复杂度:$Trie$ 树的每次调用时间复杂度取决于入参字符串的长度。复杂度为 $O(Len)$。
* 空间复杂度:结点数量为 $n$,字符集大小为 $k$。复杂度为 $O(nk)$。
---
### 两种方式的对比
使用「二维数组」的好处是写起来飞快,同时没有频繁 $new$ 对象的开销。但是需要根据数据结构范围估算我们的「二维数组」应该开多少行。
坏处是使用的空间通常是「$TrieNode$」方式的数倍,而且由于通常对行的估算会很大,导致使用的二维数组开得很大,如果这时候每次创建 $Trie$ 对象时都去创建数组的话,会比较慢,而且当样例多的时候甚至会触发 $GC$(因为 $OJ$ 每测试一个样例会创建一个 $Trie$ 对象)。
因此还有一个小技巧是将使用到的数组转为静态,然后利用 $index$ 自增的特性在初始化 $Trie$ 时执行清理工作 & 重置逻辑。
这样的做法能够使评测时间降低一半,运气好的话可以得到一个与「$TrieNode$」方式差不多的时间。
```java []
class Trie {
// 以下 static 成员独一份,被创建的多个 Trie 共用
static int N = 100009; // 直接设置为十万级
static int[][] trie = new int[N][26];
static int[] count = new int[N];
static int index = 0;
// 在构造方法中完成重置 static 成员数组的操作
// 这样做的目的是为减少 new 操作(无论有多少测试数据,上述 static 成员只会被 new 一次)
public Trie() {
for (int row = index; row >= 0; row--) {
Arrays.fill(trie[row], 0);
}
Arrays.fill(count, 0);
index = 0;
}
public void insert(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (trie[p][u] == 0) trie[p][u] = ++index;
p = trie[p][u];
}
count[p]++;
}
public boolean search(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (trie[p][u] == 0) return false;
p = trie[p][u];
}
return count[p] != 0;
}
public boolean startsWith(String s) {
int p = 0;
for (int i = 0; i < s.length(); i++) {
int u = s.charAt(i) - 'a';
if (trie[p][u] == 0) return false;
p = trie[p][u];
}
return true;
}
}
```
---
### 关于「二维数组」是如何工作 & 1e5 大小的估算
要搞懂为什么行数估算是 1e5,首先要搞清楚「二维数组」是如何工作的。
在「二维数组」中,我们是通过 $index$ 自增来控制使用了多少行的。
当我们有一个新的字符需要记录,我们会将 $index$ 自增(代表用到了新的一行),然后将这新行的下标记录到当前某个前缀的格子中。
举个🌰,假设我们先插入字符串 `abc` 这时候,前面三行会被占掉。
* 第 0 行 `a` 所对应的下标有值,值为 1,代表前缀 `a` 后面接的字符串会被记录在下标为 1 的行内
* 第 1 行 `b` 所对应的下标有值,值为 2,代表前缀 `ab` 后面接的字符串会被记录在下标为 2 的行内
* 第 2 行 `c` 所对应的下标有值,值为 3,代表前缀 `abc` 后面接的字符串会被记录在下标为 3 的行内
当再插入 `abcl` 的时候,这时候会先定位到 `abl` 的前缀行(第 3 行),将 `l` 的下标更新为 4,代表 `abcl` 被加入前缀树,并且前缀 `abcl` 接下来会用到第 4 行进行记录。
但当插入 `abl` 的时候,则会定位到 `ab` 的前缀行(第 2 行),然后将 `l` 的下标更新为 5,代表 `abl` 被加入前缀树,并且前缀 `abl` 接下来会使用第 5 行进行记录。
当搞清楚了「二维数组」是如何工作之后,我们就能开始估算会用到多少行了,调用次数为 $10^4$,传入的字符串长度为 $10^3$,假设每一次的调用都是 $insert$,并且每一次调用都会使用到新的 $10^3$ 行。那么我们的行数需要开到 $10^7$。
**但由于我们的字符集大小只有 26,因此不太可能在 $10^4$ 次调用中都用到新的 $10^3$ 行。**
**而且正常的测试数据应该是 $search$ 和 $startsWith$ 调用次数大于 $insert$ 才有意义的,一个只有 $insert$ 调用的测试数据,任何实现方案都能 AC。**
**因此我设定了 $10^5$ 为行数估算,当然直接开到 $10^6$ 也没有问题。**
---
### 关于 Trie 的应用面
首先,在纯算法领域,前缀树算是一种较为常用的数据结构。
不过如果在工程中,不考虑前缀匹配的话,基本上使用 hash 就能满足。
如果考虑前缀匹配的话,工程也不会使用 Trie 。
一方面是字符集大小不好确定(题目只考虑 26 个字母,字符集大小限制在较小的 26 内)因此可以使用 Trie,但是工程一般兼容各种字符集,一旦字符集大小很大的话,Trie 将会带来很大的空间浪费。
另外,对于个别的超长字符 Trie 会进一步变深。
这时候如果 Trie 是存储在硬盘中,Trie 结构过深带来的影响是多次随机 IO,随机 IO 是成本很高的操作。
同时 Trie 的特殊结构,也会为分布式存储将会带来困难。
因此在工程领域中 Trie 的应用面不广。
至于一些诸如「联想输入」、「模糊匹配」、「全文检索」的典型场景在工程主要是通过 ES (ElasticSearch) 解决的。
而 ES 的实现则主要是依靠「倒排索引」 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.208` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/201-210/209. 长度最小的子数组（中等）.md | 209. 长度最小的子数组 | https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/ | 中等 | [
"前缀和",
"二分",
"滑动窗口"
] | 给定一个含有 `n` 个正整数的数组和一个正整数 `target`。
找出该数组中满足其和 `≥ target` 的长度最小的 连续子数组 $[nums_l, nums_{l+1}, ..., nums_{r-1}, nums_r]$ ,并返回其长度。如果不存在符合条件的子数组,返回 $0$ 。
示例 1:
```
输入:target = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
```
示例 2:
```
输入:target = 4, nums = [1,4,4]
输出:1
```
示例 3:
```
输入:target = 11, nums = [1,1,1,1,1,1,1,1]
输出:0
```
提示:
* $1 <= target <= 10^9$
* $1 <= nums.length <= 10^5$
* $1 <= nums[i] <= 10^5$ | ### 前缀和 + 二分
利用 $nums[i]$ 的数据范围为 $[1, 10^5]$,可知前缀和数组满足「单调递增」。
我们先预处理出前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于每个 $nums[i]$ 而言,假设其对应的前缀和值为 $s = sum[i + 1]$,我们将 $nums[i]$ 视为子数组的右端点,问题转换为:在前缀和数组下标 $[0, i]$ 范围内找到满足「**值小于等于 $s - t$**」的最大下标,充当子数组左端点的前一个值。
利用前缀和数组的「单调递增」(即具有二段性),该操作可使用「二分」来做。
Java 代码:
```Java
class Solution {
public int minSubArrayLen(int t, int[] nums) {
int n = nums.length, ans = n + 10;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
for (int i = 1; i <= n; i++) {
int d = sum[i] - t;
int l = 0, r = i;
while (l < r) {
int mid = l + r + 1 >> 1;
if (sum[mid] <= d) l = mid;
else r = mid - 1;
}
if (sum[r] <= d) ans = Math.min(ans, i - r);
}
return ans == n + 10 ? 0 : ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int minSubArrayLen(int t, vector<int>& nums) {
int n = nums.size(), ans = n + 10;
vector<int> sum(n + 10, 0);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
for (int i = 1; i <= n; i++) {
int d = sum[i] - t;
int l = 0, r = i;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (sum[mid] <= d) l = mid;
else r = mid - 1;
}
if (sum[r] <= d) ans = min(ans, i - r);
}
return ans == n + 10 ? 0 : ans;
}
};
```
Python 代码:
```Python
class Solution:
def minSubArrayLen(self, t: int, nums: List[int]) -> int:
n, ans = len(nums), len(nums) + 10
s = [0] * (n + 10)
for i in range(1, n + 1):
s[i] = s[i - 1] + nums[i - 1]
for i in range(1, n + 1):
d = s[i] - t
l, r = 0, i
while l < r:
mid = (l + r + 1) // 2
if s[mid] <= d:
l = mid
else:
r = mid - 1
if s[r] <= d:
ans = min(ans, i - r)
return 0 if ans == n + 10 else ans
```
TypeScript 代码:
```TypeScript
function minSubArrayLen(t: number, nums: number[]): number {
let n = nums.length, ans = n + 10;
const sum = new Array(n + 10).fill(0);
for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
for (let i = 1; i <= n; i++) {
const d = sum[i] - t;
let l = 0, r = i;
while (l < r) {
const mid = l + r + 1 >> 1;
if (sum[mid] <= d) l = mid;
else r = mid - 1;
}
if (sum[r] <= d) ans = Math.min(ans, i - r);
}
return ans == n + 10 ? 0 : ans;
};
```
* 时间复杂度:预处理前缀和数组的复杂度为 $O(n)$,遍历前缀和数组统计答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 滑动窗口
另外一个,复杂度比 $O(n\log{n})$ 更低的做法,是滑动窗口。
在一次遍历过程中,使用 `j` 和 `i` 分别代表窗口的左右端点,变量 `c` 用于记录窗口内的数值总和。
遍历过程其实就是右端点 `i` 不断右移的过程,每次将当前右端点 `i` 的值累加到 `c` 上,若累加后,左端点右移仍能满足「总和大于等于 `t`」的要求,那么我们则让左端点 `j` 右移。
如此一来,我们便得到了每个右端点 `i` 固定时,下标最大的合法左端点 `j`(若有)。所有合法窗口长度的最小值即是答案。
代码:
```Java
class Solution {
public int minSubArrayLen(int t, int[] nums) {
int n = nums.length, ans = n + 10;
for (int i = 0, j = 0, c = 0; i < n; i++) {
c += nums[i];
while (j < i && c - nums[j] >= t) c -= nums[j++];
if (c >= t) ans = Math.min(ans, i - j + 1);
}
return ans > n ? 0 : ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.209` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2011-2020/2013. 检测正方形（中等）.md | 2013. 检测正方形 | https://leetcode-cn.com/problems/detect-squares/solution/gong-shui-san-xie-jian-dan-ha-xi-biao-yu-748e/ | 中等 | [
"哈希表"
] | 给你一个在 X-Y 平面上的点构成的数据流。设计一个满足下述要求的算法:
* 添加 一个在数据流中的新点到某个数据结构中。可以添加 重复 的点,并会视作不同的点进行处理。
* 给你一个查询点,请你从数据结构中选出三个点,使这三个点和查询点一同构成一个 面积为正 的 轴对齐正方形 ,统计 满足该要求的方案数目。
轴对齐正方形 是一个正方形,除四条边长度相同外,还满足每条边都与 x-轴 或 y-轴 平行或垂直。
实现 `DetectSquares` 类:
* `DetectSquares()` 使用空数据结构初始化对象
* `void add(int[] point)` 向数据结构添加一个新的点 `point = [x, y]`
* `int count(int[] point)` 统计按上述方式与点 `point = [x, y]` 共同构造 轴对齐正方形 的方案数。
示例:
```
输入:
["DetectSquares", "add", "add", "add", "count", "count", "add", "count"]
[[], [[3, 10]], [[11, 2]], [[3, 2]], [[11, 10]], [[14, 8]], [[11, 2]], [[11, 10]]]
输出:
[null, null, null, null, 1, 0, null, 2]
解释:
DetectSquares detectSquares = new DetectSquares();
detectSquares.add([3, 10]);
detectSquares.add([11, 2]);
detectSquares.add([3, 2]);
detectSquares.count([11, 10]); // 返回 1 。你可以选择:
// - 第一个,第二个,和第三个点
detectSquares.count([14, 8]); // 返回 0 。查询点无法与数据结构中的这些点构成正方形。
detectSquares.add([11, 2]); // 允许添加重复的点。
detectSquares.count([11, 10]); // 返回 2 。你可以选择:
// - 第一个,第二个,和第三个点
// - 第一个,第三个,和第四个点
```
提示:
* $point.length == 2$
* $0 <= x, y <= 1000$
* 调用 `add` 和 `count` 的 总次数 最多为 $5000$ | ### 哈希表
对于 `add` 操作,我们可以使用「哈希表 套 哈希表」的方式,以 `{x, {y : 点 (x,y) 数量}}` 的形式对传入点进行存储。
对于 `count` 查询而言,假定传入的点为 $(x, y)$,我们可以先查询 $x$ 行都有哪些列,枚举这些列( 即枚举点 $(x, ny)$ ),由 $y$ 和 $ny$ 可得正方形边长 $len$,此时再检查唯一确定的两点 $(x \pm len, y)$ 和 $(x \pm len, ny)$ 的出现次数,应用乘法原理,即可知道该正方形的方案数,统计所有合法方案数即是该询问的答案。
利用题目范围给定的 `x` 和 `y` 具有明确的范围 `0 <= x, y <= 1000`,我们可以使用数组充当哈希表,但是为了拓展性和减少边界判断,即支持将平面拓展到任意大小,最好还是直接使用哈希表。
代码(数组充当哈希表代码见 $P2$):
```Java
class DetectSquares {
Map<Integer, Map<Integer, Integer>> row2Col = new HashMap<>();
public void add(int[] point) {
int x = point[0], y = point[1];
Map<Integer, Integer> col2Cnt = row2Col.getOrDefault(x, new HashMap<>());
col2Cnt.put(y, col2Cnt.getOrDefault(y, 0) + 1);
row2Col.put(x, col2Cnt);
}
public int count(int[] point) {
int x = point[0], y = point[1];
int ans = 0;
Map<Integer, Integer> col2Cnt = row2Col.getOrDefault(x, new HashMap<>());
for (int ny : col2Cnt.keySet()) {
if (ny == y) continue;
int c1 = col2Cnt.get(ny);
int len = y - ny;
int[] nums = new int[]{x + len, x - len};
for (int nx : nums) {
Map<Integer, Integer> temp = row2Col.getOrDefault(nx, new HashMap<>());
int c2 = temp.getOrDefault(y, 0), c3 = temp.getOrDefault(ny, 0);
ans += c1 * c2 * c3;
}
}
return ans;
}
}
```
-
```Java
class DetectSquares {
int N = 1010;
int[][] cnts = new int[N][N];
public void add(int[] point) {
int x = point[0], y = point[1];
cnts[x][y]++;
}
public int count(int[] point) {
int x = point[0], y = point[1];
int ans = 0;
for (int ny = 0; ny < N; ny++) {
if (y == ny) continue;
int c1 = cnts[x][ny];
if (c1 == 0) continue;
int len = y - ny;
int[] nums = new int[]{x + len, x - len};
for (int nx : nums) {
if (nx < 0 || nx >= N) continue;
int c2 = cnts[nx][y], c3 = cnts[nx][ny];
ans += c1 * c2 * c3;
}
}
return ans;
}
}
```
* 时间复杂度:`add` 操作的复杂度为 $O(1)$,`count` 最坏情况会扫描完所有此前加入的点,复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2013` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2011-2020/2016. 增量元素之间的最大差值（简单）.md | 2016. 增量元素之间的最大差值 | https://leetcode-cn.com/problems/maximum-difference-between-increasing-elements/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-gisg/ | 简单 | [
"模拟"
] | 给你一个下标从 $0$ 开始的整数数组 $nums$ ,该数组的大小为 $n$ ,请你计算 $nums[j] - nums[i]$ 能求得的 最大差值 ,其中 $0 <= i < j < n$ 且 $nums[i] < nums[j]$ 。
返回 最大差值 。如果不存在满足要求的 $i$ 和 $j$ ,返回 $-1$ 。
示例 1:
```
输入:nums = [7,1,5,4]
输出:4
解释:
最大差值出现在 i = 1 且 j = 2 时,nums[j] - nums[i] = 5 - 1 = 4 。
注意,尽管 i = 1 且 j = 0 时 ,nums[j] - nums[i] = 7 - 1 = 6 > 4 ,但 i > j 不满足题面要求,所以 6 不是有效的答案。
```
示例 2:
```
输入:nums = [9,4,3,2]
输出:-1
解释:
不存在同时满足 i < j 和 nums[i] < nums[j] 这两个条件的 i, j 组合。
```
示例 3:
```
输入:nums = [1,5,2,10]
输出:9
解释:
最大差值出现在 i = 0 且 j = 3 时,nums[j] - nums[i] = 10 - 1 = 9 。
```
提示:
* $n == nums.length$
* $2 <= n <= 1000$
* $1 <= nums[i] <= 10^9$ | ### 模拟
一个显然的做法是两层循环找合适的 `i` 和 `j`,这样的做法是 $O(n^2)$ 的。
利用我们目的是找到能够取得最大差值的数对,对于每个数对中的 $nums[i]$ 而言,对应的 $nums[j]$ 必然第是坐标 $i$ 左侧的最小值,因此可以通过边遍历边维护最小值 $min$ 的做法,从而将复杂度降到 $O(n)$。
代码:
```Java
class Solution {
public int maximumDifference(int[] nums) {
int n = nums.length, ans = -1;
for (int i = 0, min = nums[0]; i < n; i++) {
if (nums[i] > min) ans = Math.max(ans, nums[i] - min);
min = Math.min(min, nums[i]);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2016` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2022. 将一维数组转变成二维数组（简单）.md | 2022. 将一维数组转变成二维数组 | https://leetcode-cn.com/problems/convert-1d-array-into-2d-array/solution/gong-shui-san-xie-jiang-2021-de-1-gai-ch-qc1a/ | 简单 | [
"模拟"
] | 给你一个下标从 $0$ 开始的一维整数数组 `original` 和两个整数 `m` 和 `n` 。
你需要使用 `original` 中 所有 元素创建一个 `m` 行 `n` 列的二维数组。
`original` 中下标从 `0` 到 `n - 1` (都 包含 )的元素构成二维数组的第一行,下标从 `n` 到 `2 * n - 1` (都 包含 )的元素构成二维数组的第二行,依此类推。
请你根据上述过程返回一个 `m x n` 的二维数组。如果无法构成这样的二维数组,请你返回一个空的二维数组。
示例 1:
```
输入:original = [1,2,3,4], m = 2, n = 2
输出:[[1,2],[3,4]]
解释:
构造出的二维数组应该包含 2 行 2 列。
original 中第一个 n=2 的部分为 [1,2] ,构成二维数组的第一行。
original 中第二个 n=2 的部分为 [3,4] ,构成二维数组的第二行。
```
示例 2:
```
输入:original = [1,2,3], m = 1, n = 3
输出:[[1,2,3]]
解释:
构造出的二维数组应该包含 1 行 3 列。
将 original 中所有三个元素放入第一行中,构成要求的二维数组。
```
示例 3:
```
输入:original = [1,2], m = 1, n = 1
输出:[]
解释:
original 中有 2 个元素。
无法将 2 个元素放入到一个 1x1 的二维数组中,所以返回一个空的二维数组。
```
示例 4:
```
输入:original = [3], m = 1, n = 2
输出:[]
解释:
original 中只有 1 个元素。
无法将 1 个元素放满一个 1x2 的二维数组,所以返回一个空的二维数组。
```
提示:
* $1 <= original.length <= 5 * 10^4$
* $1 <= original[i] <= 10^5$
* $1 <= m, n <= 4 * 10^4$ | ### 模拟
**新年快乐,祝大家身体健康,各种上岸 🎉 🎉(带着 $2021$ 年的一切美好品质继续前行**
构造 $m * n$ 的新二维矩阵 `year2022`,并使用 $idx$ 对旧矩阵 `year2021` 进行遍历即可。
代码:
```Java
class Solution {
public int[][] construct2DArray(int[] year2021, int m, int n) {
if (year2021.length != m * n) return new int[0][0];
int[][] year2022 = new int[m][n];
for (int i = 0, idx = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
year2022[i][j] = year2021[idx++];
}
}
return year2022;
}
}
```
* 时间复杂度:$O(m * n)$
* 空间复杂度:$O(m * n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2021` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2024. 考试的最大困扰度（中等）.md | 2024. 考试的最大困扰度 | https://leetcode-cn.com/problems/maximize-the-confusion-of-an-exam/solution/by-ac_oier-2rii/ | 中等 | [
"滑动窗口",
"双指针"
] | 一位老师正在出一场由 $n$ 道判断题构成的考试,每道题的答案为 `true` (用 `'T'` 表示)或者 `false` (用 `'F'` 表示)。老师想增加学生对自己做出答案的不确定性,方法是最大化有连续相同结果的题数。(也就是连续出现 `true` 或者连续出现 `false`)。
给你一个字符串 $answerKey$ ,其中 $answerKey[i]$ 是第 $i$ 个问题的正确结果。除此以外,还给你一个整数 $k$,表示你能进行以下操作的最多次数:
每次操作中,将问题的正确答案改为 `'T'` 或者 `'F'` (也就是将 $answerKey[i]$ 改为 `'T'` 或者 `'F'` )。
请你返回在不超过 $k$ 次操作的情况下,最大 连续 `'T'` 或者 `'F'` 的数目。
示例 1:
```
输入:answerKey = "TTFF", k = 2
输出:4
解释:我们可以将两个 'F' 都变为 'T' ,得到 answerKey = "TTTT" 。
总共有四个连续的 'T' 。
```
示例 2:
```
输入:answerKey = "TFFT", k = 1
输出:3
解释:我们可以将最前面的 'T' 换成 'F' ,得到 answerKey = "FFFT" 。
或者,我们可以将第二个 'T' 换成 'F' ,得到 answerKey = "TFFF" 。
两种情况下,都有三个连续的 'F' 。
```
示例 3:
```
输入:answerKey = "TTFTTFTT", k = 1
输出:5
解释:我们可以将第一个 'F' 换成 'T' ,得到 answerKey = "TTTTTFTT" 。
或者我们可以将第二个 'F' 换成 'T' ,得到 answerKey = "TTFTTTTT" 。
两种情况下,都有五个连续的 'T' 。
```
提示:
* $n == answerKey.length$
* $1 <= n <= 5 \times 10^4$
* $answerKey[i]$ 要么是 `'T'` ,要么是 `'F'`
* $1 <= k <= n$ | ### 滑动窗口
题目求修改次数不超过 $k$ 的前提下,连续段 `'T'` 或 `'F'` 的最大长度。
等价于求一个包含 `'F'` 或者 `'T'` 的个数不超过 $k$ 的最大长度窗口。
假定存在一个 `int getCnt(char c)` 函数,返回包含字符 `c` 数量不超过 $k$ 的最大窗口长度,那么最终 `max(getCnt('T'), getCnt('F'))` 即是答案。
其中 `getCnt` 函数的实现可以使用「滑动窗口」:使用 $j$ 和 $i$ 分别代表窗口的左右端点,$cnt$ 为区间 $[j, i]$ 中的字符 `c` 的数量,每次右端点 $i$ 移动时,若满足 $s[i] = c$,让 $cnt$ 自增,当 $cnt > k$ 时,使左端点 $j$ 往右移动,同时更新 $cnt$,直到 $[j, i]$ 区间恢复合法性(包含字符 `c` 的数量 $cnt$ 不超过 $k$ 个)。
代码:
```Java
class Solution {
String s;
int n, k;
public int maxConsecutiveAnswers(String answerKey, int _k) {
s = answerKey;
n = s.length(); k = _k;
return Math.max(getCnt('T'), getCnt('F'));
}
int getCnt(char c) {
int ans = 0;
for (int i = 0, j = 0, cnt = 0; i < n; i++) {
if (s.charAt(i) == c) cnt++;
while (cnt > k) {
if (s.charAt(j) == c) cnt--;
j++;
}
ans = Math.max(ans, i - j + 1);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2024` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2028. 找出缺失的观测数据（中等）.md | 2028. 找出缺失的观测数据 | https://leetcode-cn.com/problems/find-missing-observations/solution/by-ac_oier-x22k/ | 中等 | [
"模拟",
"构造"
] | 现有一份 $n + m$ 次投掷单个「六面」骰子的观测数据,骰子的每个面从 $1$ 到 $6$ 编号。观测数据中缺失了 $n$ 份,你手上只拿到剩余 $m$ 次投掷的数据。幸好你有之前计算过的这 $n + m$ 次投掷数据的平均值。
给你一个长度为 $m$ 的整数数组 `rolls` ,其中 $rolls[i]$ 是第 $i$ 次观测的值。同时给你两个整数 $mean$ 和 $n$ 。
返回一个长度为 $n$ 的数组,包含所有缺失的观测数据,且满足这 $n + m$ 次投掷的平均值是 $mean$。
如果存在多组符合要求的答案,只需要返回其中任意一组即可。如果不存在答案,返回一个空数组。
$k$ 个数字的 平均值 为这些数字求和后再除以 $k$ 。
注意 $mean$ 是一个整数,所以 $n + m$ 次投掷的总和需要被 $n + m$ 整除。
示例 1:
```
输入:rolls = [3,2,4,3], mean = 4, n = 2
输出:[6,6]
解释:所有 n + m 次投掷的平均值是 (3 + 2 + 4 + 3 + 6 + 6) / 6 = 4 。
```
示例 2:
```
输入:rolls = [1,5,6], mean = 3, n = 4
输出:[2,3,2,2]
解释:所有 n + m 次投掷的平均值是 (1 + 5 + 6 + 2 + 3 + 2 + 2) / 7 = 3 。
```
示例 3:
```
输入:rolls = [1,2,3,4], mean = 6, n = 4
输出:[]
解释:无论丢失的 4 次数据是什么,平均值都不可能是 6 。
```
示例 4:
```
输入:rolls = [1], mean = 3, n = 1
输出:[5]
解释:所有 n + m 次投掷的平均值是 (1 + 5) / 2 = 3 。
```
提示:
* $m == rolls.length$
* $1 <= n, m <= 10^5$
* $1 <= rolls[i], mean <= 6$ | ### 构造
根据题意,我们需要构造长度为 $n$ 的序列 $ans$,使得 $ans$ 和 $rolls$ 并集的平均值为 $mean$。
由于最终的平均值 $mean$ 已知,我们可以直接算得两序列之和为 $t = (m + n) \times mean$。
使用 $t$ 减去 $$\sum_{i = 0}^{m}rolls[i]$$ 可得 $$\sum_{i = 0}^{n}ans[i]$$。我们知道一个长度为 $n$ 的有效序列的元素和范围为 $[n, 6 \times n]$(骰子编号为 $[1, 6]$),根据 $\sum_{i = 0}^{m}rolls[i]$ 与 $[n, 6 \times n]$ 关系进行分情况讨论:
* 如果 $$\sum_{i = 0}^{n}ans[i]$$ 不落在 $[n, 6 \times n]$ 范围内,无解,直接返回空数组;
* 如果 $$\sum_{i = 0}^{m} rool[i]$$ 落在 $[n, 6 \times n]$ 范围内,有解,此时尝试构造一个合法的 $ans$ : 起始使用 $$\left \lfloor \frac{\sum_{i = 0}^{n}ans[i]}{n} \right \rfloor$$ 填充 $ans$,若 $$\left \lfloor \frac{\sum_{i = 0}^{n}ans[i]}{n} \right \rfloor \times n < \sum_{i = 0}^{n}ans[i]$$,计算两者差异值 $d$,并尝试将 $d$ 分摊到前 $d$ 个 $ans[i]$ 上(该过程一定可以顺利进行)。
代码:
```Java
class Solution {
public int[] missingRolls(int[] rolls, int mean, int n) {
int m = rolls.length, cnt = m + n;
int t = mean * cnt;
for (int i : rolls) t -= i;
if (t < n || t > 6 * n) return new int[0];
int[] ans = new int[n];
Arrays.fill(ans, t / n);
if (t / n * n < t) {
int d = t - (t / n * n), idx = 0;
while (d-- > 0) ans[idx++]++;
}
return ans;
}
}
```
* 时间复杂度:$O(m + n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2028` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2021-2030/2029. 石子游戏 IX（中等）.md | 2029. 石子游戏 IX | https://leetcode-cn.com/problems/stone-game-ix/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-h1oa/ | 中等 | [
"博弈论"
] | `Alice` 和 `Bob` 轮流进行自己的回合,`Alice` 先手。每一回合,玩家需要从 `stones` 中移除任一石子。
如果玩家移除石子后,导致 所有已移除石子 的价值 总和 可以被 $3$ 整除,那么该玩家就 输掉游戏 。
如果不满足上一条,且移除后没有任何剩余的石子,那么 `Bob` 将会直接获胜(即便是在 `Alice` 的回合)。
假设两位玩家均采用 最佳 决策。如果 `Alice` 获胜,返回 `true` ;如果 `Bob` 获胜,返回 `false` 。
示例 1:
```
输入:stones = [2,1]
输出:true
解释:游戏进行如下:
- 回合 1:Alice 可以移除任意一个石子。
- 回合 2:Bob 移除剩下的石子。
已移除的石子的值总和为 1 + 2 = 3 且可以被 3 整除。因此,Bob 输,Alice 获胜。
```
示例 2:
```
输入:stones = [2]
输出:false
解释:Alice 会移除唯一一个石子,已移除石子的值总和为 2 。
由于所有石子都已移除,且值总和无法被 3 整除,Bob 获胜。
```
示例 3:
```
输入:stones = [5,1,2,4,3]
输出:false
解释:Bob 总会获胜。其中一种可能的游戏进行方式如下:
- 回合 1:Alice 可以移除值为 1 的第 2 个石子。已移除石子值总和为 1 。
- 回合 2:Bob 可以移除值为 3 的第 5 个石子。已移除石子值总和为 = 1 + 3 = 4 。
- 回合 3:Alices 可以移除值为 4 的第 4 个石子。已移除石子值总和为 = 1 + 3 + 4 = 8 。
- 回合 4:Bob 可以移除值为 2 的第 3 个石子。已移除石子值总和为 = 1 + 3 + 4 + 2 = 10.
- 回合 5:Alice 可以移除值为 5 的第 1 个石子。已移除石子值总和为 = 1 + 3 + 4 + 2 + 5 = 15.
Alice 输掉游戏,因为已移除石子值总和(15)可以被 3 整除,Bob 获胜。
```
提示:
* $1 <= stones.length <= 10^5$
* $1 <= stones[i] <= 10^4$ | ### 分情况讨论博弈
为了方便,我们用 `A` 来代指 `Alice`,用 `B` 带代指 `Bob`。
`A` 只有一种获胜方式,是使得 `B` 在选石子时凑成 $3$ 的倍数;而 `B` 除了能够通过让 `A` 凑成 $3$ 的倍数以外,还能通过让游戏常规结束来获胜。
因此整个游戏过程,我们只需要关心「已被移除的石子总和」和「剩余石子个数/价值情况」即可。
更进一步的,我们只需关心已被移除的石子总和是否为 $3$ 的倍数,以及剩余石子的价值与已移除石子总和相加是否凑成 $3$ 的倍数即可。
所以我们可以按照石子价值除以 $3$ 的余数分成三类,并统计相应数量。
不失一般性考虑,某个回合开始前,已移除的石子总和状态为 $x$(共三种,分别为除以 $3$ 余数为 $0$、$1$ 和 $2$,其中当状态为 $0$,且非首个回合时,说明凑成 $3$ 的倍数,游戏结束),剩余石子价值除以 $3$ 的余数 $s$ 分别为 $0$、$1$ 和 $2$。
**首先如果当前 $x = 1$ 时,不能选择 $s = 2$ 的石子,否则会导致凑成总和为 $3$ 的倍数而失败;同理 $x = 2$ 时,不能选择 $s = 1$ 的石子;而选择 $s = 0$ 的数字,不会改变 $x$ 的状态,可看做换手操作。**
**同时成对的 $s = 0$ 的等价于没有 $s = 0$ 的石子(双方只需要轮流选完这些 $s = 0$ 的石子,最终会回到先手最开始的局面);而选择与 $x$ 相同的 $s$ 会导致 $x$ 改变(即 $x = 1$ 时,选择 $s = 1$ 的石子,会导致 $x = 2$;而 $x = 2$ 时,选 $s = 2$ 的石子,会导致 $x = 1$)。**
明确规则后,是分情况讨论的过程:
* **$s = 0$ 的石子数量为偶数**:此时等价于没有 $s = 0$ 的石子,我们只需要关心 $s = 1$ 和 $s = 2$ 即可:
* **$s = 1$ 的石子数量为 $0$**: 这意味着 `A` 开始选择的只能是 $s = 2$,此时交给 `B` 的局面为「$x = 2$、剩余石子只有 $s = 2$」,此时 `B` 只能选 $s = 2$ 的石子,由于 $x = 2$ 且选择的石子 $s = 2$,因此交由回 `A` 的局面为「$x = 1$,剩余是在只有 $s = 2$」,因此游戏继续的话 `A` 必败,同时如果在该过程的任何时刻石子被取完,也是 `B` 直接获胜,即 **`A` 仍为必败**;
* **$s = 2$ 的石子数量为 $0$**:分析同理,`A` 只能选 $s = 1$,此时交给 `B` 的局面为「$x = 1$、剩余石子只有 $s = 1$」,此时 `B` 只能选 $s = 1$ 的石子,由于 $x = 1$ 且选择的石子 $s = 1$,因此交由回 `A` 的局面为「$x = 2$,剩余是在只有 $s = 1$」,因此游戏继续的话 `A` 必败,同时如果在该过程的任何时刻石子被取完,也是 `B` 直接获胜,即 **`A` 仍为必败**;
* **$s = 1$ 和 $s = 2$ 的石子数量均不为 $0$**:`A` 选数量不是最多的一类石子,`B` 下一回合只能选择相同类型的石子(或是无从选择导致失败),然后游戏继续,最终 `B` 会先进入「只能凑成 $3$ 的倍数」的局面导致失败,即 **`A` 必胜。**
* **$s = 0$ 的石子数量为奇数**:此时等价于有一次换手机会,该换手机会必然应用在「对必败局面进行转移」才有意义,因此只有 $s = 1$ 和 $s = 2$ 的石子数量差大于 $2$,`A` 的先手优势不会因为存在换手机会而被转移:
* **两者数量差不超过 $2$**:此时 `B` 可以利用「对方凑成 $3$ 的倍数必败」规则和「优先使用 $s = 0$ 石子」权利来进入确保自己为必胜态:
* 举个 🌰,当 $s = 1$ 和 $s = 2$ 的石子数量相等,虽然有 $s = 0$ 的石子,`A` 先手,但是 `A` 的首个回合必然不能选 $s = 0$,否则马上失败结束,因此 `A` 只能选 $s = 1$ 或 $s = 2$,此时 `B`直接选择 $s = 0$ 的石子,交由给 `A` 的局面 $x$ 没有发生改变,`A` 只能选择与首个回合相同的 $s$ 游戏才能继续,因此局面会变为「`B` 先手、$s = 1$ 和 $s = 2$ 的石子数量差为 $2$」,游戏继续,最终 `A` 会先遇到「只能凑成 $3$ 的倍数」的局面,即 **`B` 必胜**。
* 两者数量不等,但数量差不超过 $2$:此时无论 `A` 选择数量较少或较多的 `s`,`B` 都在第二回合马上使用 $s = 0$ 的石子进行换手,`A` 只能继续选与第一回合相同类型的的石子,游戏才能进行,最终 `A` 会先遇到「只能凑成 $3$ 的倍数」或「石子被取完」的局面,即 **`B` 必胜**。
* **两者数量差超过 $2$** :此时即使 `A` 只要确保第一次选择数量较多的 $s$,不管 `B` 是否使用「优先使用 $s = 0$」的石子,`A` 都有足够次数数量多 $s$ 来抵消换手(或是在 `B` 放弃使用 $s = 0$ 之后马上使用),最终都是 `B` 最先遇到「只能凑成 $3$ 的倍数」的局面,即 **`A` 获胜**。
代码:
```Java
class Solution {
public boolean stoneGameIX(int[] stones) {
int[] cnts = new int[3];
for (int i : stones) cnts[i % 3]++;
return cnts[0] % 2 == 0 ? !(cnts[1] == 0 || cnts[2] == 0) : Math.abs(cnts[1] - cnts[2]) > 2;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2029` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2031. 1 比 0 多的子数组个数（中等）.md | 2031. 1 比 0 多的子数组个数 | null | 中等 | [
"树状数组",
"前缀和"
] | 给你一个只包含 $0$ 和 $1$ 的数组 $nums$,请返回 $1$ 的数量 大于 $04 的数量的子数组的个数。
由于答案可能很大,请返回答案对 $10^9 + 7$ 取余 的结果。
一个 子数组 指的是原数组中连续的一个子序列。
示例 1:
```
输入: nums = [0,1,1,0,1]
输出: 9
解释:
长度为 1 的、1 的数量大于 0 的数量的子数组有: [1], [1], [1]
长度为 2 的、1 的数量大于 0 的数量的子数组有: [1,1]
长度为 3 的、1 的数量大于 0 的数量的子数组有: [0,1,1], [1,1,0], [1,0,1]
长度为 4 的、1 的数量大于 0 的数量的子数组有: [1,1,0,1]
长度为 5 的、1 的数量大于 0 的数量的子数组有: [0,1,1,0,1]
```
示例 2:
```
输入: nums = [0]
输出: 0
解释:
没有子数组的 1 的数量大于 0 的数量。
```
示例 3:
```
输入: nums = [1]
输出: 1
解释:
长度为 1 的、1 的数量大于 0 的数量的子数组有: [1]
```
提示:
* $1 <= nums.length <= 10^5$
* $0 <= nums[i] <= 1$ | ### 树状数组
为了方便,我们调整数组 $nums$ 下标从 $1$ 开始。同时将 $nums[i] = 0$ 的值看作 $nums[i] = -1$,并预处理出前缀和数组 $sum$。对于任意 $sum[i]$ 而言,其值域范围为 $[-n, n]$,我们可以通过对 $sum[i]$ 做整体 $n + 1$ 的偏移,将值域映射到 $[1, 2 * n + 1]$。
对于任意一个子数组 $i...j$ 而言,如果满足 $1$ 的数量大于 $0$,则必然有 $sum[j] - sum[i - 1] > 0$。
因此在求解以 $nums[j]$ 为右端点的「满足 $1$ 数量大于 $0$ 数量」的子数组个数时,等价于在问 $[0, j - 1]$ 范围内有多少个下标 $i$ 满足 $sum[i] < sum[j]$(即有多少个下标可以作为左端点)。
求解比 $x$ 小的数有多少个,可以使用「树状数组」来做。
具体的,我们可以遍历每个位置,假设当前处理到的位置是 $i$,其前缀和值 $t = sum[i]$,我们可以通过查询小于等于 $t - 1$ 的值数量来得知以 $i$ 为右端点的合法子数组数量,统计后,我们需要对数值为 $t$ 出现次数进行加一。
代码:
```Java
class Solution {
int N = 200010, MOD = (int)1e9+7;
int[] tr = new int[N];
int n;
int lowbit(int x) {
return x & -x;
}
void add(int x, int v) {
for (int i = x; i <= 2 * n + 1; 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 subarraysWithMoreZerosThanOnes(int[] nums) {
n = nums.length;
int ans = 0;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1);
for (int i = 0; i <= n; i++) {
int t = sum[i] + n + 1;
ans = (ans + query(t - 1)) % MOD;
add(t, 1);
}
return ans;
}
}
```
* 时间复杂度:预处理前缀和数组的复杂度为 $O(n)$;查询和插入的复杂度均为 $O(\log{n})$,整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2031` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2034. 股票价格波动（中等）.md | 2034. 股票价格波动 | https://leetcode-cn.com/problems/stock-price-fluctuation/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-u6f4/ | 中等 | [
"数据结构"
] | 给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。
不巧的是,由于股票市场内在的波动性,股票价格记录可能不是按时间顺序到来的。某些情况下,有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中,前一条记录视为错误记录,后出现的记录 更正 前一条错误的记录。
请你设计一个算法,实现:
* 更新 股票在某一时间戳的股票价格,如果有之前同一时间戳的价格,这一操作将 更正 之前的错误价格。
* 找到当前记录里 最新股票价格 。最新股票价格 定义为时间戳最晚的股票价格。
* 找到当前记录里股票的 最高价格 。
* 找到当前记录里股票的 最低价格 。
请你实现 `StockPrice` 类:
* `StockPrice()` 初始化对象,当前无股票价格记录。
* `void update(int timestamp, int price)` 在时间点 `timestamp` 更新股票价格为 `price`。
* `int current()` 返回股票 最新价格 。
* `int maximum()` 返回股票 最高价格 。
* `int minimum()` 返回股票 最低价格 。
示例 1:
```
输入:
["StockPrice", "update", "update", "current", "maximum", "update", "maximum", "update", "minimum"]
[[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
输出:
[null, null, null, 5, 10, null, 5, null, 2]
解释:
StockPrice stockPrice = new StockPrice();
stockPrice.update(1, 10); // 时间戳为 [1] ,对应的股票价格为 [10] 。
stockPrice.update(2, 5); // 时间戳为 [1,2] ,对应的股票价格为 [10,5] 。
stockPrice.current(); // 返回 5 ,最新时间戳为 2 ,对应价格为 5 。
stockPrice.maximum(); // 返回 10 ,最高价格的时间戳为 1 ,价格为 10 。
stockPrice.update(1, 3); // 之前时间戳为 1 的价格错误,价格更新为 3 。
// 时间戳为 [1,2] ,对应股票价格为 [3,5] 。
stockPrice.maximum(); // 返回 5 ,更正后最高价格为 5 。
stockPrice.update(4, 2); // 时间戳为 [1,2,4] ,对应价格为 [3,5,2] 。
stockPrice.minimum(); // 返回 2 ,最低价格时间戳为 4 ,价格为 2 。
```
提示:
* $1 <= timestamp, price <= 10^9$
* `update`,`current`,`maximum` 和 `minimum` **总** 调用次数不超过 $10^5$
* `current`,`maximum` 和 `minimum` 被调用时,`update` 操作 **至少** 已经被调用过 一次 。 | ### 模拟 + 数据结构
容易想到我们需要使用「哈希表」来记录 `{时间:价格}` 的映射关系。
**关于 `current` 操作,我们可以维护一个最大的时间戳 `cur`,在调用 `current` 的时候直接 $O(1)$ 查得结果。**
然后考虑解决 `update` 操作中对相同时间点的更新问题,我们可以使用 `TreeMap`(红黑树)来解决该问题。以 `{价格:该价格对应的时间点数量}` 的 `KV` 形式进行存储,`key` 按照「升序」进行排序。
然后对传入的 `timestamp` 是否已经被记录(是否已经存在哈希表中)进行分情况讨论:
* 传入的 `timestamp` 未被记录,直接更新哈希表和 `TreeMap`;
* 传入的 `timestamp` 已被记录,此时需要先从哈希表取出旧价格 `old`,然后用旧价格对 `TreeMap` 进行修改(如果该价格只有一个时间点,将该价格直接从 `TreeMap` 中移除;若有多个时间点,则对该价格对应的时间点数量进行减一操作),然后再使用传入的新价格 `price` 更新哈希表和 `TreeMap`。
**`minimum` 和 `maximum` 操作则只需要取得 `TreeMap` 的首尾 `Key` 即可。**
代码:
```Java
class StockPrice {
int cur;
Map<Integer, Integer> map = new HashMap<>();
TreeMap<Integer, Integer> ts = new TreeMap<>();
public void update(int timestamp, int price) {
cur = Math.max(cur, timestamp);
if (map.containsKey(timestamp)) {
int old = map.get(timestamp);
int cnt = ts.get(old);
if (cnt == 1) ts.remove(old);
else ts.put(old, cnt - 1);
}
map.put(timestamp, price);
ts.put(price, ts.getOrDefault(price, 0) + 1);
}
public int current() {
return map.get(cur);
}
public int maximum() {
return ts.lastKey();
}
public int minimum() {
return ts.firstKey();
}
}
```
* 时间复杂度:令 $n$ 为最大调用次数,`update` 复杂度为 $O(\log{n})$;`current`、`maximum` 和 `minimum` 操作复杂度为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2034` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2038. 如果相邻两个颜色均相同则删除当前颜色（中等）.md | 2038. 如果相邻两个颜色均相同则删除当前颜色 | https://leetcode-cn.com/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-y-a8xm/ | 中等 | [
"脑筋急转弯",
"模拟"
] | 总共有 $n$ 个颜色片段排成一列,每个颜色片段要么是 `'A'` 要么是 `'B'` 。
给你一个长度为 $n$ 的字符串 `colors` ,其中 $colors[i]$ 表示第 $i$ 个颜色片段的颜色。
Alice 和 Bob 在玩一个游戏,他们轮流从这个字符串中删除颜色。Alice 先手 。
* 如果一个颜色片段为 `'A'` 且相邻两个颜色都是颜色 `'A'` ,那么 Alice 可以删除该颜色片段。Alice 不可以删除任何颜色 `'B'` 片段。
* 如果一个颜色片段为 `'B'` 且相邻两个颜色都是颜色 `'B'` ,那么 Bob 可以删除该颜色片段。Bob 不可以删除任何颜色 `'A'` 片段。
* Alice 和 Bob 不能从字符串两端删除颜色片段。
* 如果其中一人无法继续操作,则该玩家输掉游戏且另一玩家获胜。
假设 Alice 和 Bob 都采用最优策略,如果 Alice 获胜,请返回 true,否则 Bob 获胜,返回 false。
示例 1:
```
输入:colors = "AAABABB"
输出:true
解释:
AAABABB -> AABABB
Alice 先操作。
她删除从左数第二个 'A' ,这也是唯一一个相邻颜色片段都是 'A' 的 'A' 。
现在轮到 Bob 操作。
Bob 无法执行任何操作,因为没有相邻位置都是 'B' 的颜色片段 'B' 。
因此,Alice 获胜,返回 true 。
```
示例 2:
```
输入:colors = "AA"
输出:false
解释:
Alice 先操作。
只有 2 个 'A' 且它们都在字符串的两端,所以她无法执行任何操作。
因此,Bob 获胜,返回 false 。
```
示例 3:
```
输入:colors = "ABBBBBBBAAA"
输出:false
解释:
ABBBBBBBAAA -> ABBBBBBBAA
Alice 先操作。
她唯一的选择是删除从右数起第二个 'A' 。
ABBBBBBBAA -> ABBBBBBAA
接下来轮到 Bob 操作。
他有许多选择,他可以选择任何一个 'B' 删除。
然后轮到 Alice 操作,她无法删除任何片段。
所以 Bob 获胜,返回 false 。
```
提示:
* $1 <= colors.length <= 10^5$
* `colors` 只包含字母 `'A'` 和 `'B'` | ### 脑筋急转弯
根据删除规则,删除任意一个 `A` 不会影响可被删删除的 `B` 的数量,反之亦然。
因此直接统计「可删除的 `A` 的数量」和「可删除的 `B` 的数量」,分别记为 $a$ 和 $b$,比较 $a$ 和 $b$ 的大小即可得到答案(只有 $a > b$ 时,先手获胜)。
代码:
```Java
class Solution {
public boolean winnerOfGame(String colors) {
char[] cs = colors.toCharArray();
int n = cs.length;
int a = 0, b = 0;
for (int i = 1; i < n - 1; i++) {
if (cs[i] == 'A' && cs[i - 1] == 'A' && cs[i + 1] == 'A') a++;
if (cs[i] == 'B' && cs[i - 1] == 'B' && cs[i + 1] == 'B') b++;
}
return a > b;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用 `toCharArray` 操作会产生新数组,复杂度为 $O(n)$,而使用 `charAt` 代替的话复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2038` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2031-2040/2039. 网络空闲的时刻（中等）.md | 2039. 网络空闲的时刻 | https://leetcode-cn.com/problems/the-time-when-the-network-becomes-idle/solution/by-ac_oier-5txs/ | 中等 | [
"BFS"
] | 给你一个有 $n$ 个服务器的计算机网络,服务器编号为 $0$ 到 $n - 1$ 。同时给你一个二维整数数组 `edges` ,其中 $edges[i] = [u_i, v_i]$ 表示服务器 $u_i$ 和 $v_i$ 之间有一条信息线路,在一秒内它们之间可以传输任意数目的信息。再给你一个长度为 $n$ 且下标从 $0$ 开始的整数数组 `patience` 。
题目保证所有服务器都是相通的,也就是说一个信息从任意服务器出发,都可以通过这些信息线路直接或间接地到达任何其他服务器。
编号为 $0$ 的服务器是主服务器,其他服务器为数据服务器。每个数据服务器都要向主服务器发送信息,并等待回复。信息在服务器之间按最优线路传输,也就是说每个信息都会以最少时间到达主服务器。主服务器会处理所有新到达的信息并立即按照每条信息来时的路线反方向发送回复信息。
在 $0$ 秒的开始,所有数据服务器都会发送各自需要处理的信息。从第 $1$ 秒开始,每一秒最开始时,每个数据服务器都会检查它是否收到了主服务器的回复信息(包括新发出信息的回复信息):
* 如果还没收到任何回复信息,那么该服务器会周期性重发信息。数据服务器 $i$ 每 $patience[i]$ 秒都会重发一条信息,也就是说,数据服务器 $i$ 在上一次发送信息给主服务器后的 $patience[i]$ 秒 后 会重发一条信息给主服务器。
* 否则,该数据服务器不会重发信息。
当没有任何信息在线路上传输或者到达某服务器时,该计算机网络变为空闲状态。
请返回计算机网络变为空闲状态的最早秒数。
示例 1:
```
输入:edges = [[0,1],[1,2]], patience = [0,2,1]
输出:8
解释:
0 秒最开始时,
- 数据服务器 1 给主服务器发出信息(用 1A 表示)。
- 数据服务器 2 给主服务器发出信息(用 2A 表示)。
1 秒时,
- 信息 1A 到达主服务器,主服务器立刻处理信息 1A 并发出 1A 的回复信息。
- 数据服务器 1 还没收到任何回复。距离上次发出信息过去了 1 秒(1 < patience[1] = 2),所以不会重发信息。
- 数据服务器 2 还没收到任何回复。距离上次发出信息过去了 1 秒(1 == patience[2] = 1),所以它重发一条信息(用 2B 表示)。
2 秒时,
- 回复信息 1A 到达服务器 1 ,服务器 1 不会再重发信息。
- 信息 2A 到达主服务器,主服务器立刻处理信息 2A 并发出 2A 的回复信息。
- 服务器 2 重发一条信息(用 2C 表示)。
...
4 秒时,
- 回复信息 2A 到达服务器 2 ,服务器 2 不会再重发信息。
...
7 秒时,回复信息 2D 到达服务器 2 。
从第 8 秒开始,不再有任何信息在服务器之间传输,也不再有信息到达服务器。
所以第 8 秒是网络变空闲的最早时刻。
```
示例 2:
```
输入:edges = [[0,1],[0,2],[1,2]], patience = [0,10,10]
输出:3
解释:数据服务器 1 和 2 第 2 秒初收到回复信息。
从第 3 秒开始,网络变空闲。
```
提示:
* $n == patience.length$
* $2 <= n <= 10^5$
* $patience[0] == 0$
* 对于 $1 <= i < n$ ,满足 $1 <= patience[i] <= 10^5$
* $1 <= edges.length <= \min(105, n * (n - 1) / 2)$
* $edges[i].length == 2$
* $0 <= ui, vi < n$
* $ui != vi$
* 不会有重边。
* 每个服务器都直接或间接与别的服务器相连。 | ### 建图 + BFS
根据题目可知这是一个边权为 $1$ 的无向连通图,我们可以采用「邻接表建图 + BFS」的方式预处理出 $dist$ 数组,$dist[i]$ 含义为节点 $i$ 到 $0$ 号点的最短距离。
一个数据服务器 $i$ 往主服务器发送消息所消耗的时间为两节点之间的最短路径 $dist[i]$,而从发送消息到收到回复所需的时间为 $di = 2 * dist[i]$。
同时每个数据服务器还存在时间间隔为 $t = patience[i]$ 的重发动作,并且动作只有在第一次收到主服务的回复后才会停止。
因此如果 $di <= t$,那么数据服务器不会发生重发动作,该节点活动停止时间点为 $di$;当 $di > t$,数据服务器将会发生重发动作,且最后一个数据包的发送时间为 $(di - 1) / t * t$,只有当最后一个数据包收到回复,该节点的所有活动才算停止,停止时间点为 $(di - 1) / t * t + di$。所有节点的活动停止时间点的最大值即是答案。
> 一些细节:老规矩,为了避免每个样例都 `new` 大数组,我们使用 `static` 优化。使用 `static` 优化后,你甚至会收获一个稳定 $100$% 的结果 🤣
代码:
```Java
class Solution {
static int N = 100010, M = N * 2, INF = 0x3f3f3f3f;
static int[] he = new int[N], e = new int[M], ne = new int[M];
static int[] dist = new int[N];
int idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int networkBecomesIdle(int[][] edges, int[] patience) {
Arrays.fill(he, -1);
Arrays.fill(dist, INF);
int n = patience.length;
for (int[] e : edges) {
add(e[0], e[1]);
add(e[1], e[0]);
}
Deque<Integer> d = new ArrayDeque<>();
d.addLast(0);
dist[0] = 0;
while (!d.isEmpty()) {
int t = d.pollFirst();
for (int i = he[t]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] != INF) continue;
dist[j] = dist[t] + 1;
d.addLast(j);
}
}
int ans = 0;
for (int i = 1; i < n; i++) {
int di = dist[i] * 2, t = patience[i];
int cur = di <= t ? di : (di - 1) / t * t + di;
if (cur > ans) ans = cur;
}
return ans + 1;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2039` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2043. 简易银行系统（中等）.md | 2043. 简易银行系统 | https://leetcode-cn.com/problems/simple-bank-system/solution/by-ac_oier-9pqi/ | 中等 | [
"模拟"
] | 你的任务是为一个很受欢迎的银行设计一款程序,以自动化执行所有传入的交易(转账,存款和取款)。
银行共有 $n$ 个账户,编号从 $1$ 到 $n$ 。每个账号的初始余额存储在一个下标从 $0$ 开始的整数数组 `balance` 中,其中第 $(i + 1)$ 个账户的初始余额是 $balance[i]$ 。
请你执行所有 **有效的** 交易。如果满足下面全部条件,则交易有效 :
* 指定的账户数量在 $1$ 和 $n$ 之间,且
* 取款或者转账需要的钱的总数 小于或者等于 账户余额。
实现 `Bank` 类:
* `Bank(long[] balance)` 使用下标从 $0$ 开始的整数数组 `balance` 初始化该对象。
* `boolean transfer(int account1, int account2, long money)` 从编号为 `account1` 的账户向编号为 `account2` 的账户转帐 `money` 美元。如果交易成功,返回 `true` ,否则,返回 `false` 。
* `boolean deposit(int account, long money)` 向编号为 `account` 的账户存款 `money` 美元。如果交易成功,返回 `true` ;否则,返回 `false` 。
* `boolean withdraw(int account, long money)` 从编号为 `account` 的账户取款 `money` 美元。如果交易成功,返回 `true` ;否则,返回 `false` 。
示例:
```
输入:
["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"]
[[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
输出:
[null, true, true, true, false, false]
解释:
Bank bank = new Bank([10, 100, 20, 50, 30]);
bank.withdraw(3, 10); // 返回 true ,账户 3 的余额是 $20 ,所以可以取款 $10 。
// 账户 3 余额为 $20 - $10 = $10 。
bank.transfer(5, 1, 20); // 返回 true ,账户 5 的余额是 $30 ,所以可以转账 $20 。
// 账户 5 的余额为 $30 - $20 = $10 ,账户 1 的余额为 $10 + $20 = $30 。
bank.deposit(5, 20); // 返回 true ,可以向账户 5 存款 $20 。
// 账户 5 的余额为 $10 + $20 = $30 。
bank.transfer(3, 4, 15); // 返回 false ,账户 3 的当前余额是 $10 。
// 所以无法转账 $15 。
bank.withdraw(10, 50); // 返回 false ,交易无效,因为账户 10 并不存在。
```
提示:
* $n == balance.length$
* $1 <= n, account, account_1, account_2 <= 10^5$
* $0 <= balance[i], money <= 10^{12}$
* `transfer`, `deposit`, `withdraw` 三个函数,每个 最多调用 $10^4$ 次 | ### 模拟
根据题意进行模拟即可。
代码:
```Java
class Bank {
long[] val;
public Bank(long[] balance) {
val = balance;
}
boolean check(int account) {
return 1 <= account && account <= val.length;
}
public boolean transfer(int a, int b, long c) {
if (!check(a) || !check(b)) return false;
if (val[a - 1] >= c) {
val[a - 1] -= c; val[b - 1] += c;
return true;
}
return false;
}
public boolean deposit(int a, long c) {
if (!check(a)) return false;
val[a - 1] += c;
return true;
}
public boolean withdraw(int a, long c) {
if (!check(a)) return false;
if (val[a - 1] >= c) {
val[a - 1] -= c;
return true;
}
return false;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2043` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2044. 统计按位或能得到最大值的子集数目（中等）.md | 2044. 统计按位或能得到最大值的子集数目 | https://leetcode-cn.com/problems/count-number-of-maximum-bitwise-or-subsets/solution/by-ac_oier-dos6/ | 中等 | [
"二进制枚举",
"位运算",
"DFS",
"状压 DP"
] | 给你一个整数数组 $nums$ ,请你找出 $nums$ 子集 **按位或** 可能得到的 **最大值** ,并返回按位或能得到最大值的 **不同非空子集的数目** 。
如果数组 $a$ 可以由数组 $b$ 删除一些元素(或不删除)得到,则认为数组 $a$ 是数组 $b$ 的一个 子集 。如果选中的元素下标位置不一样,则认为两个子集 不同 。
对数组 $a$ 执行 **按位或** ,结果等于 $a[0]$ `OR` $a[1]$ `OR` `...` `OR` $a[a.length - 1]$(下标从 $0$ 开始)。
示例 1:
```
输入:nums = [3,1]
输出:2
解释:子集按位或能得到的最大值是 3 。有 2 个子集按位或可以得到 3 :
- [3]
- [3,1]
```
示例 2:
```
输入:nums = [2,2,2]
输出:7
解释:[2,2,2] 的所有非空子集的按位或都可以得到 2 。总共有 23 - 1 = 7 个子集。
```
示例 3:
```
输入:nums = [3,2,1,5]
输出:6
解释:子集按位或可能的最大值是 7 。有 6 个子集按位或可以得到 7 :
- [3,5]
- [3,1,5]
- [3,2,5]
- [3,2,1,5]
- [2,5]
- [2,1,5]
```
提示:
* $1 <= nums.length <= 16$
* $1 <= nums[i] <= 10^5$ | ### 二进制枚举
令 $n$ 为 $nums$ 的长度,利用 $n$ 不超过 $16$,我们可以使用一个 `int` 数值来代指 $nums$ 的使用情况(子集状态)。
假设当前子集状态为 $state$,$state$ 为一个仅考虑低 $n$ 位的二进制数,当第 $k$ 位为 $1$,代表 $nums[k]$ 参与到当前的按位或运算,当第 $k$ 位为 $0$,代表 $nums[i]$ 不参与到当前的按位或运算。
在枚举这 $2^n$ 个状态过程中,我们使用变量 `max` 记录最大的按位或得分,使用 `ans` 记录能够取得最大得分的状态数量。
代码:
```Java
class Solution {
public int countMaxOrSubsets(int[] nums) {
int n = nums.length, mask = 1 << n;
int max = 0, ans = 0;
for (int s = 0; s < mask; s++) {
int cur = 0;
for (int i = 0; i < n; i++) {
if (((s >> i) & 1) == 1) cur |= nums[i];
}
if (cur > max) {
max = cur; ans = 1;
} else if (cur == max) {
ans++;
}
}
return ans;
}
}
```
* 时间复杂度:令 $nums$ 长度为 $n$,共有 $2^n$ 个子集状态,计算每个状态的按位或得分的复杂度为 $O(n)$。整体复杂度为 $O(2^n * n)$
* 空间复杂度:$O(1)$
---
### 状压 DP
为了优化解法一中「每次都要计算某个子集的得分」这一操作,我们可以将所有状态的得分记下来,采用「动态规划」思想进行优化。
需要找到当前状态 $state$ 可由哪些状态转移而来:假设当前 $state$ 中处于最低位的 $1$ 位于第 $idx$ 位,首先我们可以使用 `lowbit` 操作得到「仅保留第 $idx$ 的 $1$ 所对应的数值」,记为 $lowbit$,那么显然对应的状态方程为:
$$
f[state] = f[state - lowbit] \wedge nums[idx]
$$
再配合我们从小到大枚举所有的 $state$ 即可确保计算 $f[state]$ 时所依赖的 $f[state - lowbit]$ 已被计算。
最后为了快速知道数值 $lowbit$ 最低位 $1$ 所处于第几位(也就是 $idx$ 为何值),我们可以利用 $nums$ 长度最多不超过 $16$ 来进行「打表」预处理。
代码:
```Java
class Solution {
static Map<Integer, Integer> map = new HashMap<>();
static {
for (int i = 0; i < 20; i++) map.put((1 << i), i);
}
public int countMaxOrSubsets(int[] nums) {
int n = nums.length, mask = 1 << n;
int[] f = new int[mask];
int max = 0, ans = 0;
for (int s = 1; s < mask; s++) {
int lowbit = (s & -s);
int prev = s - lowbit, idx = map.get(lowbit);
f[s] = f[prev] | nums[idx];
if (f[s] > max) {
max = f[s]; ans = 1;
} else if (f[s] == max) {
ans++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(2^n)$
* 空间复杂度:$O(2^n)$
---
### DFS
解法一将「枚举子集/状态」&「计算状态对应的得分」两个过程分开进行,导致了复杂度上界为 $O(2^n * n)$。
事实上,我们可以在「枚举子集」的同时「计算相应得分」,设计 `void dfs(int u, int val)` 的 `DFS` 函数来实现「爆搜」,其中 $u$ 为当前的搜索到 $nums$ 的第几位,$val$ 为当前的得分情况。
对于任意一位 $x$ 而言,都有「选」和「不选」两种选择,分别对应了 `dfs(u + 1, val | nums[x])` 和 `dfs(u + 1, val)` 两条搜索路径,在搜索所有状态过程中,使用全局变量 `max` 和 `ans` 来记录「最大得分」以及「取得最大得分的状态数量」。
该做法将多条「具有相同前缀」的搜索路径的公共计算部分进行了复用,从而将算法复杂度下降为 $O(2^n)$。
代码:
```Java
class Solution {
int[] nums;
int max = 0, ans = 0;
public int countMaxOrSubsets(int[] _nums) {
nums = _nums;
dfs(0, 0);
return ans;
}
void dfs(int u, int val) {
if (u == nums.length) {
if (val > max) {
max = val; ans = 1;
} else if (val == max) {
ans++;
}
return ;
}
dfs(u + 1, val);
dfs(u + 1, val | nums[u]);
}
}
```
* 时间复杂度:令 $nums$ 长度为 $n$,共有 $2^n$ 个子集状态。整体复杂度为 $O(2^n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2044` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2045. 到达目的地的第二短时间（困难）.md | 2045. 到达目的地的第二短时间 | https://leetcode-cn.com/problems/second-minimum-time-to-reach-destination/solution/gong-shui-san-xie-yi-ti-shuang-jie-dui-y-88np/ | 困难 | [
"最短路",
"BFS",
"堆优化 Dijkstra",
"AStar 算法",
"启发式搜索"
] | 城市用一个 双向连通 图表示,图中有 $n$ 个节点,从 $1$ 到 $n$ 编号(包含 $1$ 和 $n$)。图中的边用一个二维整数数组 $edges$ 表示,其中每个 $edges[i] = [u_i, v_i]$ 表示一条节点 $u_i$ 和节点 $v_i$ 之间的双向连通边。每组节点对由 最多一条 边连通,顶点不存在连接到自身的边。穿过任意一条边的时间是 $time$ 分钟。
每个节点都有一个交通信号灯,每 $change$ 分钟改变一次,从绿色变成红色,再由红色变成绿色,循环往复。所有信号灯都 同时 改变。你可以在 任何时候 进入某个节点,但是 只能 在节点 信号灯是绿色时 才能离开。如果信号灯是 绿色 ,你 不能 在节点等待,必须离开。
第二小的值 是 严格大于 最小值的所有值中最小的值。
* 例如,`[2, 3, 4]` 中第二小的值是 $3$ ,而 `[2, 2, 4]` 中第二小的值是 $4$ 。
给你 $n$、$edges$、$time$ 和 $change$ ,返回从节点 $1$ 到节点 $n$ 需要的 第二短时间 。
注意:
* 你可以 任意次 穿过任意顶点,包括 1 和 n 。
* 你可以假设在 启程时 ,所有信号灯刚刚变成 绿色 。
示例 1:
```
输入:n = 5, edges = [[1,2],[1,3],[1,4],[3,4],[4,5]], time = 3, change = 5
输出:13
解释:
上面的左图展现了给出的城市交通图。
右图中的蓝色路径是最短时间路径。
花费的时间是:
- 从节点 1 开始,总花费时间=0
- 1 -> 4:3 分钟,总花费时间=3
- 4 -> 5:3 分钟,总花费时间=6
因此需要的最小时间是 6 分钟。
右图中的红色路径是第二短时间路径。
- 从节点 1 开始,总花费时间=0
- 1 -> 3:3 分钟,总花费时间=3
- 3 -> 4:3 分钟,总花费时间=6
- 在节点 4 等待 4 分钟,总花费时间=10
- 4 -> 5:3 分钟,总花费时间=13
因此第二短时间是 13 分钟。
```
示例 2:
```
输入:n = 2, edges = [[1,2]], time = 3, change = 2
输出:11
解释:
最短时间路径是 1 -> 2 ,总花费时间 = 3 分钟
最短时间路径是 1 -> 2 -> 1 -> 2 ,总花费时间 = 11 分钟
```
提示:
* $2 <= n <= 10^4$
* $n - 1 <= edges.length <= min(2 * 10^4, n * (n - 1) / 2)$
* $edges[i].length == 2$
* $1 <= u_i, v_i <= n$
* $u_i != v_i$
* 不含重复边
* 每个节点都可以从其他节点直接或者间接到达
* $1 <= time, change <= 10^3$ | ### 堆优化 Dijkstra
整体题意:在一张正权无向图上求严格次短路,该图无重边与自环。
同时根据提示 $edges.length <= \min(2 * 10^4, n * (n - 1) / 2)$ 可知,该图为「稀疏图」,容易想到「堆优化 Dijkstra」做法。
对「堆优化 Dijkstra」或者「其他最短路算法」不熟悉的同学,可以看前置 🧀 :[【最短路/必背模板】涵盖所有的「存图方式」与「最短路算法(详尽注释)」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=211780171&lang=zh_CN#rd)。内容如题,首次接触的话,建议每个模板先敲十遍。
回到本题,与常规的「求最短路」不同,本题需要求得「严格次短路」,我们可以在原来的最短路算法基础上($dist1[]$ 数组用于记录最短路)多引入一个 $dist2[]$ 数组,$dist2[x]$ 用于记录从节点 $1$ 到节点 $x$ 的严格次短路。
维护次短路是容易的,基本思路为:
* 若当前距离 $dist$ 小于 $dist1[x]$,原本的最短路 $dist1[x]$ 沦为次短路 $dist2[x]$,即先用 $dist1[x]$ 更新 $dist2[x]$ 后,再用 $dist$ 更新 $dist1[x]$;
* 若当前距离 $dist$ 等于 $dist1[x]$,不符合「严格次短路」,忽略;
* 若当前距离 $dist$ 大于 $dist1[x]$,且 $dist$ 小于 $dist2[x]$,则使用 $dist$ 更新 $dist2[x]$。
同时,由于处理「严格次短路包含重复边」的情况,我们无须使用 $vis[]$ 数组记录处理过的点,而要确保每次「最短路」或者「次短路」被更新时,都进行入堆操作。
然后考虑「红绿灯」切换问题,这本质是引入动态边权,假设我们当前经过 $step$ 步到达节点 $i$,根据其与 $change$ 的关系分情况讨论即可:
* $\left \lfloor \frac{step}{change} \right \rfloor$ 为偶数:当前处于绿灯,动态边权为 $0$;
* $\left \lfloor \frac{step}{change} \right \rfloor$ 为奇数:当前处于红灯,需要增加动态边权(等待时间),增加的动态边权为 `change - (step % change)`。
最后,为了避免每个样例都 `new` 大数组,我们可以使用 `static` 修饰需要用到的数组,并在执行逻辑前进行重置工作。
代码:
```Java
class Solution {
static int N = 10010, M = 4 * N, INF = 0x3f3f3f3f, idx = 0;
static int[] he = new int[N], e = new int[M], ne = new int[M];
static int[] dist1 = new int[N], dist2 = new int[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx;
idx++;
}
public int secondMinimum(int n, int[][] edges, int time, int change) {
Arrays.fill(dist1, INF);
Arrays.fill(dist2, INF);
Arrays.fill(he, -1);
idx = 0;
for (int[] e : edges) {
int u = e[0], v = e[1];
add(u, v); add(v, u);
}
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);
q.add(new int[]{1, 0});
dist1[1] = 0;
while (!q.isEmpty()) {
int[] poll = q.poll();
int u = poll[0], step = poll[1];
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
int a = step / change, b = step % change;
int wait = a % 2 == 0 ? 0 : change - b;
int dist = step + time + wait;
if (dist1[j] > dist) {
dist2[j] = dist1[j];
dist1[j] = dist;
q.add(new int[]{j, dist1[j]});
q.add(new int[]{j, dist2[j]});
} else if (dist1[j] < dist && dist < dist2[j]) {
dist2[j] = dist;
q.add(new int[]{j, dist2[j]});
}
}
}
return dist2[n];
}
}
```
* 时间复杂度:令 $n$ 为点数,$m$ 为边数,堆优化 Dijkstra 的复杂度为 $O(m\log{n})$
* 空间复杂度:$O(n + m)$
---
### BFS
更进一步,原图边权虽然由「固定部分 $time$」和「动态部分 $change$ 相关」所组成,但在路径固定的前提下,其实边权之和完全确定。
因此我们可以先将原图等价为边权为 $1$ 的新图,通过 `BFS` 求出最短路 $dist1[x]$ 和严格次短路 $dist2[x]$,然后利用此时的 $dist2[n]$ 其实是严格次短路的边数,计算原图上的边权之和。
代码:
```Java
class Solution {
static int N = 10010, M = 4 * N, INF = 0x3f3f3f3f, idx = 0;
static 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;
idx++;
}
public int secondMinimum(int n, int[][] edges, int time, int change) {
Arrays.fill(he, -1);
idx = 0;
for (int[] e : edges) {
int u = e[0], v = e[1];
add(u, v); add(v, u);
}
Deque<int[]> d = new ArrayDeque<>();
int[] dist1 = new int[n + 10], dist2 = new int[n + 10];
Arrays.fill(dist1, INF);
Arrays.fill(dist2, INF);
d.addLast(new int[]{1, 0});
dist1[1] = 0;
while (!d.isEmpty()) {
int[] poll = d.pollFirst();
int u = poll[0], dist = poll[1];
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (dist1[j] > dist + 1) {
dist2[j] = dist1[j];
dist1[j] = dist + 1;
d.addLast(new int[]{j, dist1[j]});
d.addLast(new int[]{j, dist2[j]});
} else if (dist1[j] < dist + 1 && dist + 1 < dist2[j]) {
dist2[j] = dist + 1;
d.addLast(new int[]{j, dist2[j]});
}
}
}
int ans = 0;
for (int i = 0; i < dist2[n]; i++) {
int a = ans / change, b = ans % change;
int wait = a % 2 == 0 ? 0 : change - b;
ans += time + wait;
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为点数,$m$ 为边数,BFS 的复杂度为 $O(n + m)$
* 空间复杂度:$O(n + m)$
---
### AStar 算法
在 `BFS` 的基础上再进一步,我们可以将问题拓展为「使用 AStar 算法来找第 `K` 短路」(修改代码的 `K` 即可),利用终点的第 $k$ 次出队必然是第 $k$ 短路(注意要求的是严格的第 $k$ 短路)。
代码:
```Java
class Solution {
static int N = 10010, M = 4 * N, INF = 0x3f3f3f3f, K = 2, idx = 0, n = 0;
static int[] he = new int[N], e = new int[M], ne = new int[M];
static int[] dist = new int[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx;
idx++;
}
void bfs() {
Arrays.fill(dist, INF);
Deque<Integer> d = new ArrayDeque<>();
d.addLast(n);
dist[n] = 0;
while (!d.isEmpty()) {
int x = d.pollFirst(), step = dist[x];
for (int i = he[x]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] != INF) continue;
dist[j] = step + 1;
d.addLast(j);
}
}
}
int astar() {
int k = K, min = -1;
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[2]-b[2]);
q.add(new int[]{1, 0, dist[1]});
while (!q.isEmpty()) {
int[] poll = q.poll();
int x = poll[0], step = poll[1];
if (x == n && min != step) {
min = step;
if (--k == 0) return min;
}
for (int i = he[x]; i != -1; i = ne[i]) {
int j = e[i];
q.add(new int[]{j, step + 1, step + 1 + dist[j]});
}
}
return -1; // never
}
public int secondMinimum(int _n, int[][] edges, int time, int change) {
n = _n; idx = 0;
Arrays.fill(he, -1);
for (int[] e : edges) {
int u = e[0], v = e[1];
add(u, v); add(v, u);
}
bfs();
int cnt = astar(), ans = 0;
for (int i = 0; i < cnt; i++) {
int a = ans / change, b = ans % change;
int wait = a % 2 == 0 ? 0 : change - b;
ans += time + wait;
}
return ans;
}
}
```
* 时间复杂度:启发式搜索不讨论时空复杂度
* 空间复杂度:启发式搜索不讨论时空复杂度 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2045` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2047. 句子中的有效单词数（简单）.md | 2047. 句子中的有效单词数 | https://leetcode-cn.com/problems/number-of-valid-words-in-a-sentence/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-5pcz/ | 简单 | [
"模拟",
"双指针"
] | 句子仅由小写字母(`'a'` 到 `'z'`)、数字('0' 到 '9')、连字符(`'-'`)、标点符号(`'!'`、`'.'` 和 `','`)以及空格(`' '`)组成。每个句子可以根据空格分解成 一个或者多个 `token` ,这些 `token` 之间由一个或者多个空格 `' '` 分隔。
如果一个 `token` 同时满足下述条件,则认为这个 `token` 是一个有效单词:
* 仅由小写字母、连字符和/或标点(不含数字)。
* 至多一个 连字符 `'-'` 。如果存在,连字符两侧应当都存在小写字母(`"a-b"` 是一个有效单词,但 `"-ab"` 和 `"ab-"` 不是有效单词)。
* 至多一个 标点符号。如果存在,标点符号应当位于 `token` 的 末尾 。
这里给出几个有效单词的例子:`"a-b."`、`"afad"`、`"ba-c"`、`"a!"` 和 `"!"` 。
给你一个字符串 `sentence` ,请你找出并返回 `sentence` 中 有效单词的数目 。
示例 1:
```
输入:sentence = "cat and dog"
输出:3
解释:句子中的有效单词是 "cat"、"and" 和 "dog"
```
示例 2:
```
输入:sentence = "!this 1-s b8d!"
输出:0
解释:句子中没有有效单词
"!this" 不是有效单词,因为它以一个标点开头
"1-s" 和 "b8d" 也不是有效单词,因为它们都包含数字
```
示例 3:
```
输入:sentence = "alice and bob are playing stone-game10"
输出:5
解释:句子中的有效单词是 "alice"、"and"、"bob"、"are" 和 "playing"
"stone-game10" 不是有效单词,因为它含有数字
```
示例 4:
```
输入:sentence = "he bought 2 pencils, 3 erasers, and 1 pencil-sharpener."
输出:6
解释:句子中的有效单词是 "he"、"bought"、"pencils,"、"erasers,"、"and" 和 "pencil-sharpener."
```
提示:
* $1 <= sentence.length <= 1000$
* `sentence` 由小写英文字母、数字(`0-9`)、以及字符(`' '`、`'-'`、`'!'`、`'.'` 和 ',')组成
* 句子中至少有 $1$ 个 `token` | ### 模拟
根据题意进行模拟即可,先将 `sentence` 按照空格进行分割,得到多个 `item`,再对每个 `item` 进行合法性检查,最后统计合法的 `item` 个数即为答案。
在对 `item` 进行合法性检查时,分别使用 $c1$ 和 $c2$ 代表「连字符」和「标点符号」的出现次数。
> 特别说明:Java 的 `split` 操作基于正则,复杂度为线性,其他语言可能需要使用「双指针」手写 `split` 操作
代码( 双指针实现 `split` 的代码见 $P2$ ):
```Java
class Solution {
public int countValidWords(String sentence) {
String[] ss = sentence.split(" ");
int ans = 0;
for (String s : ss) if (check(s)) ans++;
return ans;
}
boolean check(String s) {
int n = s.length();
if (n == 0) return false;
for (int i = 0, c1 = 0, c2 = 0; i < n; i++) {
char c = s.charAt(i);
if (Character.isDigit(c)) return false;
if (c == ' ') return false;
if (c == '-' && ++c1 >= 0) {
if (c1 > 1 || (i == 0 || i == n - 1)) return false;
if (!Character.isLetter(s.charAt(i - 1)) || !Character.isLetter(s.charAt(i + 1))) return false;
}
if ((c == '!' || c == '.' || c == ',') && ++c2 >= 0) {
if (c2 > 1 || (i != n - 1)) return false;
}
}
return true;
}
}
```
-
```Java
class Solution {
public int countValidWords(String sentence) {
int n = sentence.length(), ans = 0;
for (int i = 0; i < n; ) {
if (sentence.charAt(i) == ' ' && ++i >= 0) continue;
int j = i;
while (j < n && sentence.charAt(j) != ' ') j++;
if (check(sentence.substring(i, j))) ans++;
i = j + 1;
}
return ans;
}
boolean check(String s) {
int n = s.length();
if (n == 0) return false;
for (int i = 0, c1 = 0, c2 = 0; i < n; i++) {
char c = s.charAt(i);
if (Character.isDigit(c)) return false;
if (c == ' ') return false;
if (c == '-' && ++c1 >= 0) {
if (c1 > 1 || (i == 0 || i == n - 1)) return false;
if (!Character.isLetter(s.charAt(i - 1)) || !Character.isLetter(s.charAt(i + 1))) return false;
}
if ((c == '!' || c == '.' || c == ',') && ++c2 >= 0) {
if (c2 > 1 || (i != n - 1)) return false;
}
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:执行过程会产生若干子串,子串总长度与 `s` 相同。复杂度为 $O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2047` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2041-2050/2049. 统计最高分的节点数目（中等）.md | 2049. 统计最高分的节点数目 | https://leetcode-cn.com/problems/count-nodes-with-the-highest-score/solution/gong-shui-san-xie-jian-tu-dfs-by-ac_oier-ujfo/ | 中等 | [
"图论",
"线性 DP"
] | 给你一棵根节点为 $0$ 的 二叉树 ,它总共有 $n$ 个节点,节点编号为 $0$ 到 $n - 1$ 。
同时给你一个下标从 $0$ 开始的整数数组 $parents$ 表示这棵树,其中 $parents[i]$ 是节点 $i$ 的父节点。由于节点 $0$ 是根,所以 $parents[0] == -1$ 。
一个子树的 **大小** 为这个子树内节点的数目。每个节点都有一个与之关联的 **分数** 。求出某个节点分数的方法是,将这个节点和与它相连的边全部 **删除** ,剩余部分是若干个 **非空** 子树,这个节点的 **分数** 为所有这些子树 大小的乘积 。
请你返回有 **最高得分** 节点的 数目 。
示例 1:
```
输入:parents = [-1,2,0,2,0]
输出:3
解释:
- 节点 0 的分数为:3 * 1 = 3
- 节点 1 的分数为:4 = 4
- 节点 2 的分数为:1 * 1 * 2 = 2
- 节点 3 的分数为:4 = 4
- 节点 4 的分数为:4 = 4
最高得分为 4 ,有三个节点得分为 4 (分别是节点 1,3 和 4 )。
```
示例 2:
```
输入:parents = [-1,2,0]
输出:2
解释:
- 节点 0 的分数为:2 = 2
- 节点 1 的分数为:2 = 2
- 节点 2 的分数为:1 * 1 = 1
最高分数为 2 ,有两个节点分数为 2 (分别为节点 0 和 1 )。
```
提示:
* $n == parents.length$
* $2 <= n <= 10^5$
* $parents[0] == -1$
* 对于 $i != 0$ ,有 $0 <= parents[i] <= n - 1$
* $parents$ 表示一棵二叉树。 | ### 建图 + DFS + 统计答案
为了更具有一般性,我们假定该树为多叉树。
由于题目给定的 `parents` 数组仅支持我们快速查找某个节点的父节点,为了方便遍历整棵树,我们先使用「邻接表」将图(树)建起来。
还不熟悉「邻接表」存图方式的同学可以看看前置 🧀 : [涵盖所有的「存图方式」模板](https%3A//mp.weixin.qq.com/s?__biz%3DMzU4NDE3MTEyMA%3D%3D%26mid%3D2247488007%26idx%3D1%26sn%3D9d0dcfdf475168d26a5a4bd6fcd3505d%26chksm%3Dfd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f%26mpshare%3D1%26scene%3D23%26srcid%3D0311tjKy74JijYzXhHo8Qob7%26sharer_sharetime%3D1646964421353%26sharer_shareid%3D1221771780968b30ef07c3f22cd356ed%2523rd)。
然后使用 `DFS` 预处理出 `f` 数组,其中 $f[i]$ 代表以节点 $i$ 为根节点的子树所包含的节点数量。
考虑如何计算「删除某个节点 $x$ 后,剩余连通块的数量,以及每个连通块的节点数量」,根据节点 $x$ 是否为根节点进行分情况讨论:
* 若 $x$ 为根节点,删除后的连通块的数量为「$x$ 的出边数量」,假定共有 $k$ 条出边,根据题目定义,对应的 **大小** 为各个连通块的节点数量乘积:
$$
f[u_1] \times f[u_2] \times ... \times f[u_k]
$$
* 若 $x$ 不是根节点,删除后的连通块的数量为「$x$ 的出边数量 + $1$」,其中 $1$ 代指「以 $x$ 节点的父节点所在的整体连通块」。
假定节点 $x$ 共有 $k$ 条出边,根据题目定义,对应的 **大小** 为「(各个连通块的节点数量乘积) $\times$ ($x$ 节点的父节点所在的整体连通块大小)」,而「$x$ 节点的父节点所在的整体连通块大小」,利用容斥原理可知为 $f[root] - f[u] = n - f[u]$,含义为「从原树中减掉以节点 $x$ 为根节点的子树」的部分,即最终 **大小** 为:
$$
(f[u_1] \times f[u_2] \times ... \times f[u_k]) \times (n - f[x])
$$
代码:
```Java
class Solution {
static int N = 100010, M = N * 2;
static int[] he = new int[N], e = new int[M], ne = new int[M];
static int[] f = new int[N];
int idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
public int countHighestScoreNodes(int[] parents) {
Arrays.fill(he, -1);
int n = parents.length;
for (int i = 1; i < n; i++) add(parents[i], i);
dfs(0);
long max = 0;
int ans = 0;
for (int x = 0; x < n; x++) {
long cur = 1;
for (int i = he[x]; i != -1; i = ne[i]) cur *= f[e[i]];
if (x != 0) cur *= n - f[x];
if (cur > max) {
max = cur; ans = 1;
} else if (cur == max) {
ans++;
}
}
return ans;
}
int dfs(int u) {
int ans = 1;
for (int i = he[u]; i != -1; i = ne[i]) ans += dfs(e[i]);
f[u] = ans;
return ans;
}
}
```
* 时间复杂度:建图复杂度为 $O(n)$;通过 `DFS` 预处理 `f` 数组复杂度为 $O(n + m)$,其中 $m$ 为边数,对于本题(二叉树)而言,点边数量级相等,因此 `DFS` 预处理的复杂度为 $O(n)$;模拟删除任意点并统计答案的复杂度为 $O(n + m)$,对于本题(二叉树)而言,数量级为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 拓扑排序 + 统计答案
通过对「待删除节点是否为根节点」的分情况讨论可知:若要算得删除某个节点后的得分,重点需要知道「当前节点的左右子树(如果有)所包含的节点数量」以及「当前节点的父节点所在连通块的节点数量」。
我们解法 $1$ 的建图目的就是为了得到某个节点的子树情况,`DFS` 预处理 `f` 数组的目的就是知道以某个节点为根的子树所包含的总节点数量。
而这个「建图 + `DFS`」过程可由「拓扑排序」所代替。
具体的,我们可以先对 `parents`进行遍历, 统计所有节点的出度 $out[i]$,然后将所有出度为 $0$ 的节点(叶子节点)进行入队。跑一遍求拓扑排序的 `BFS`,每次某个节点 $t$ 出队,我们就对节点 $t$ 的父节点 $fa = parents[t]$ 进行出度减一操作(若出度减至 $0$,则将 $fa$ 进行入队,注意 $fa$ 不能为根节点,因为 $fa$ 入队没有意义,其入队不能更新其他点的出度),并在求拓扑序的过程中预处理出 `l` 和 `r` 数组,$l[i]$ 和 $r[i]$ 分别代表节点 $i$ 的左子树的节点数和右节点的节点数。
跑完拓扑排序后,我们得到的 `l` 和 `r` 数组就足够我们统计答案,仍然是对删除节点 $x$ 是否为根节点的分情况讨论:
* 若 $x$ 不是根节点,得分为 $\max(l[x], 1) \times \max( r[x], 1)$
* 若 $x$ 为根节点,得分为 $\max(l[x], 1) \times \max( r[x], 1) \times (n - (l[x] + r[x] + 1)$
代码:
```Java
class Solution {
public int countHighestScoreNodes(int[] parents) {
int n = parents.length;
int[] out = new int[n];
for (int i = 1; i < n; i++) out[parents[i]]++;
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
if (out[i] == 0) d.addLast(i);
}
// l[i] 和 r[i] 分别代表节点 i 的左子树的节点数和右节点的节点数
int[] l = new int[n], r = new int[n];
while (!d.isEmpty()) {
int t = d.pollFirst(), fa = parents[t];
out[fa]--;
if (l[fa] == 0) l[fa] = l[t] + r[t] + 1;
else r[fa] = l[t] + r[t] + 1;
if (out[fa] == 0 && fa != 0) d.addLast(fa);
}
long max = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
long cur = Math.max(l[i], 1) * Math.max(r[i], 1);
if (i != 0) cur *= n - (l[i] + r[i] + 1);
if (cur > max) {
max = cur; ans = 1;
} else if (cur == max) {
ans++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2049` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2051-2060/2055. 蜡烛之间的盘子（中等）.md | 2055. 蜡烛之间的盘子 | https://leetcode-cn.com/problems/plates-between-candles/solution/gong-shui-san-xie-er-fen-qian-zhui-he-yu-0qt0/ | 中等 | [
"前缀和",
"二分"
] | 给你一个长桌子,桌子上盘子和蜡烛排成一列。给你一个下标从 $0$ 开始的字符串 `s` ,它只包含字符 `'*'` 和 `'|'` ,其中 `'*'` 表示一个 盘子 ,`'|'` 表示一支 蜡烛 。
同时给你一个下标从 $0$ 开始的二维整数数组 `queries` ,其中 $queries[i] = [lefti, righti]$ 表示 子字符串 $s[left_i...right_i]$ (包含左右端点的字符)。对于每个查询,你需要找到 子字符串中 在 两支蜡烛之间 的盘子的 数目 。如果一个盘子在 子字符串中 左边和右边 都 至少有一支蜡烛,那么这个盘子满足在 两支蜡烛之间 。
比方说,`s = "||**||**|*"` ,查询 $[3, 8]$ ,表示的是子字符串 `"*||**|"` 。子字符串中在两支蜡烛之间的盘子数目为 $2$ ,子字符串中右边两个盘子在它们左边和右边 都 至少有一支蜡烛。
请你返回一个整数数组 $answer$ ,其中 $answer[i]$ 是第 $i$ 个查询的答案。
示例 1:
```
输入:s = "**|**|***|", queries = [[2,5],[5,9]]
输出:[2,3]
解释:
- queries[0] 有两个盘子在蜡烛之间。
- queries[1] 有三个盘子在蜡烛之间。
```
示例 2:
```
输入:s = "***|**|*****|**||**|*", queries = [[1,17],[4,5],[14,17],[5,11],[15,16]]
输出:[9,0,0,0,0]
解释:
- queries[0] 有 9 个盘子在蜡烛之间。
- 另一个查询没有盘子在蜡烛之间。
```
提示:
* $3 <= s.length <= 10^5$
* `s` 只包含字符 `'*'` 和 `'|'` 。
* $1 <= queries.length <= 10^5$
* $queries[i].length == 2$
* $0 <= lefti <= righti < s.length$ | ### 二分 + 前缀和
对于任意一个查询 $[a, b]$ 而言,我们需要统计所有左边和右边能够找到蜡烛的盘子数量。
一个自然的想法是:**找到区间 $[a, b]$ 两边缘的蜡烛,分别记为 $c$ 和 $d$,显然区间 $[c, d]$ 内的盘子都是需要被统计的。**
因此,我们可以对字符串 `s` 进行从前往后的扫描,将所有的蜡烛下标添加到数组(数组严格递增),并预处理出盘子的「前缀和」数组。
然后处理询问时的「找区间 $[a, b]$ 边缘蜡烛」操作可通过对数组「二分」来做,而「查询区间 $[c, d]$ 内的盘子数量」操作可直接查询「前缀和」数组。
Java 代码:
```Java
class Solution {
public int[] platesBetweenCandles(String s, int[][] qs) {
char[] cs = s.toCharArray();
int n = cs.length, m = qs.length;
int[] ans = new int[m], sum = new int[n + 1];
List<Integer> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (cs[i] == '|') list.add(i);
sum[i + 1] = sum[i] + (cs[i] == '*' ? 1 : 0);
}
if (list.size() == 0) return ans;
for (int i = 0; i < m; i++) {
int a = qs[i][0], b = qs[i][1];
int c = -1, d = -1;
// 找到 a 右边最近的蜡烛
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r >> 1;
if (list.get(mid) >= a) r = mid;
else l = mid + 1;
}
if (list.get(r) >= a) c = list.get(r);
else continue;
// 找到 b 左边最近的蜡烛
l = 0; r = list.size() - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid) <= b) l = mid;
else r = mid - 1;
}
if (list.get(r) <= b) d = list.get(r);
else continue;
if (c <= d) ans[i] = sum[d + 1] - sum[c];
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> platesBetweenCandles(string s, vector<vector<int>>& qs) {
vector<int> ans(qs.size(), 0);
vector<int> sum(s.length() + 1, 0);
vector<int> list;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '|') list.push_back(i);
sum[i + 1] = sum[i] + (s[i] == '*' ? 1 : 0);
}
if (list.empty()) return ans;
for (int i = 0; i < qs.size(); i++) {
int a = qs[i][0], b = qs[i][1];
int c = -1, d = -1;
// 找到 a 右边最近的蜡烛
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r >> 1;
if (list[mid] >= a) r = mid;
else l = mid + 1;
}
if (list[r] >= a) c = list[r];
else continue;
// 找到 b 左边最近的蜡烛
l = 0; r = list.size() - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list[mid] <= b) l = mid;
else r = mid - 1;
}
if (list[r] <= b) d = list[r];
else continue;
if (c <= d) ans[i] = sum[d + 1] - sum[c];
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def platesBetweenCandles(self, s: str, qs: List[List[int]]) -> List[int]:
ans = [0] * len(qs)
sum_val = [0] * (len(s) + 1)
candle_positions = [i for i, char in enumerate(s) if char == '|']
for i in range(len(s)):
sum_val[i + 1] = sum_val[i] + (s[i] == '*')
if not candle_positions:
return ans
for i in range(len(qs)):
a, b = qs[i]
c, d = -1, -1
# 找到 a 右边最近的蜡烛
l, r = 0, len(candle_positions) - 1
while l < r:
mid = l + r >> 1
if candle_positions[mid] >= a:
r = mid
else:
l = mid + 1
if candle_positions[r] >= a:
c = candle_positions[r]
else:
continue
# 找到 b 左边最近的蜡烛
l, r = 0, len(candle_positions) - 1
while l < r:
mid = l + r + 1 >> 1
if candle_positions[mid] <= b:
l = mid
else:
r = mid - 1
if candle_positions[r] <= b:
d = candle_positions[r]
else:
continue
if c <= d:
ans[i] = sum_val[d + 1] - sum_val[c]
return ans
```
TypeScript 代码:
```TypeScript
function platesBetweenCandles(s: string, qs: number[][]): number[] {
const ans = new Array(qs.length).fill(0);
const sum = new Array(s.length + 1).fill(0);
const list = [];
for (let i = 0; i < s.length; i++) {
if (s[i] == '|') list.push(i);
sum[i + 1] = sum[i] + (s[i] === '*' ? 1 : 0);
}
if (list.length == 0) return ans;
for (let i = 0; i < qs.length; i++) {
const a = qs[i][0], b = qs[i][1];
let c = -1, d = -1;
// 找到 a 右边最近的蜡烛
let l = 0, r = list.length - 1;
while (l < r) {
const mid = l + r >> 1;
if (list[mid] >= a) r = mid;
else l = mid + 1;
}
if (list[r] >= a) c = list[r];
else continue;
// 找到 b 左边最近的蜡烛
l = 0; r = list.length - 1;
while (l < r) {
const mid = l + r + 1 >> 1;
if (list[mid] <= b) l = mid;
else r = mid - 1;
}
if (list[r] <= b) d = list[r];
else continue;
if (c <= d) ans[i] = sum[d + 1] - sum[c];
}
return ans;
};
```
* 时间复杂度:令 `s` 的长度为 $n$,`qs` 长度为 $m$。统计所有的蜡烛并存入 `list` 的复杂度为 $O(n)$;预处理前缀和数组复杂度为 $O(n)$;处理单个询问需要进行两次二分(蜡烛数量最多为 $n$),复杂度为 $O(\log{n})$,共有 $m$ 个询问需要处理,复杂度为 $O(m \times \log{n})$。整体复杂度为 $O(n + m\log{n})$
* 空间复杂度:$O(n)$
---
### 前缀和
更进一步,在给定 `s` 的前提下,每个位置其左边和右边最近的蜡烛唯一确定。
我们可以在预处理前缀和的同时,预处理每个位置左右最近的蜡烛下标,从而省去每次二分。
Java 代码:
```Java
class Solution {
public int[] platesBetweenCandles(String s, int[][] qs) {
char[] cs = s.toCharArray();
int n = cs.length, m = qs.length;
int[] l = new int[n], r = new int[n];
int[] sum = new int[n + 1];
for (int i = 0, j = n - 1, p = -1, q = -1; i < n; i++, j--) {
if (cs[i] == '|') p = i;
if (cs[j] == '|') q = j;
l[i] = p; r[j] = q;
sum[i + 1] = sum[i] + (cs[i] == '*' ? 1 : 0);
}
int[] ans = new int[m];
for (int i = 0; i < m; i++) {
int a = qs[i][0], b = qs[i][1];
int c = r[a], d = l[b];
if (c != -1 && c <= d) ans[i] = sum[d + 1] - sum[c];
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> platesBetweenCandles(string s, vector<vector<int>>& qs) {
vector<int> l(s.length(), 0), r(s.length(), 0);
vector<int> sum(s.length() + 1, 0);
for (int i = 0, j = s.length() - 1, p = -1, q = -1; i < s.length(); i++, j--) {
if (s[i] == '|') p = i;
if (s[j] == '|') q = j;
l[i] = p; r[j] = q;
sum[i + 1] = sum[i] + (s[i] == '*' ? 1 : 0);
}
vector<int> ans(qs.size(), 0);
for (int i = 0; i < qs.size(); i++) {
int a = qs[i][0], b = qs[i][1];
int c = r[a], d = l[b];
if (c != -1 && c <= d) ans[i] = sum[d + 1] - sum[c];
}
return ans;
}
};
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2055` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2051-2060/2059. 转化数字的最小运算数（中等）.md | 2059. 转化数字的最小运算数 | https://leetcode-cn.com/problems/minimum-operations-to-convert-number/solution/gong-shui-san-xie-shuang-xiang-bfs-mo-ba-uckg/ | 中等 | [
"图论 BFS",
"双向 BFS"
] | 给你一个下标从 `0` 开始的整数数组 `nums`,该数组由 互不相同 的数字组成。
另给你两个整数 `start` 和 `goal` 。
整数 `x` 的值最开始设为 `start` ,你打算执行一些运算使 `x` 转化为 `goal` 。
你可以对数字 `x` 重复执行下述运算:
如果 `0 <= x <= 1000`,那么,对于数组中的任一下标 `i` `(0 <= i < nums.length)`,可以将 `x` 设为下述任一值:
* `x + nums[i]`
* `x - nums[i]`
* `x ^ nums[i](按位异或 XOR)`
注意,你可以按任意顺序使用每个 `nums[i]` 任意次。使 `x` 越过 `0 <= x <= 1000` 范围的运算同样可以生效,但该该运算执行后将不能执行其他运算。
返回将 `x = start` 转化为 `goal` 的最小操作数;如果无法完成转化,则返回 `-1` 。
示例 1:
```
输入:nums = [1,3], start = 6, goal = 4
输出:2
解释:
可以按 6 → 7 → 4 的转化路径进行,只需执行下述 2 次运算:
- 6 ^ 1 = 7
- 7 ^ 3 = 4
```
示例 2:
```
输入:nums = [2,4,12], start = 2, goal = 12
输出:2
解释:
可以按 2 → 14 → 12 的转化路径进行,只需执行下述 2 次运算:
- 2 + 12 = 14
- 14 - 2 = 12
```
示例 3:
```
输入:nums = [3,5,7], start = 0, goal = -4
输出:2
解释:
可以按 0 → 3 → -4 的转化路径进行,只需执行下述 2 次运算:
- 0 + 3 = 3
- 3 - 7 = -4
注意,最后一步运算使 x 超过范围 0 <= x <= 1000 ,但该运算仍然可以生效。
```
示例 4:
```
输入:nums = [2,8,16], start = 0, goal = 1
输出:-1
解释:
无法将 0 转化为 1
```
示例 5:
```
输入:nums = [1], start = 0, goal = 3
输出:3
解释:
可以按 0 → 1 → 2 → 3 的转化路径进行,只需执行下述 3 次运算:
- 0 + 1 = 1
- 1 + 1 = 2
- 2 + 1 = 3
```
提示:
* $1 <= nums.length <= 1000$
* $-10^9 <= nums[i], goal <= 10^9$
* $0 <= start <= 1000$
* start != goal
* $nums$ 中的所有整数互不相同 | ### 常规 BFS
题目给定了从当前值 $x$ 到 $x'$ 的转换规则,同时只有满足 $0 <= x <= 1000$ 的数值才能继续进行转换,因此配合去重,转换次数具有明确上界,使用常规的 `BFS` 即可求解。
需要注意的是,为了避免 TLE,我们应当将「满足 $0 <= x <= 1000$ 才能进行下一步转换」这一规则应用到「限制入队」,而不是简单的应用在「限制拓展」。
即如果由 $x$ 拓展出来的 $x'$,既不与 $goal$ 相等,也不满足 $0 <= x' <= 1000$ 条件,那么 $x'$ 并无入队必要。
代码:
```Java
class Solution {
public int minimumOperations(int[] nums, int s, int t) {
Deque<Integer> d = new ArrayDeque<>();
Map<Integer, Integer> map = new HashMap<>();
d.addLast(s);
map.put(s, 0);
while (!d.isEmpty()) {
int cur = d.pollFirst();
int step = map.get(cur);
for (int i : nums) {
int[] result = new int[]{cur + i, cur - i, cur ^ i};
for (int next : result) {
if (next == t) return step + 1;
if (next < 0 || next > 1000) continue;
if (map.containsKey(next)) continue;
map.put(next, step + 1);
d.addLast(next);
}
}
}
return -1;
}
}
```
* 时间复杂度:令 $n$ 为 $nums$ 的长度,常数 $C$ 为队列内元素的值域大小(本题值域范围为 $[0, 1000]$ )。整体复杂度为 $O(C * n)$
* 空间复杂度:$O(C)$
---
### 双向 BFS
这还是一道很好的双向 `BFS` 模板题。
之前我没有找到这样的模板题,不得已使用了 LeetCode 难度标记为「困难」的 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=1901895674&lang=zh_CN#rd) 来作为双向 `BFS` 的入门题。
> PS. 事实上,那道题也不难,如果你还没做过 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=1901895674&lang=zh_CN#rd),在学习完本题解后,可以尝试做一下。
回到本题,我们可以同时从两个方向进行搜索:
1. 正向搜索:使用队列 `d1` 实现从 $start$ 到 $goal$ 的通路搜索,为满足「$0 <= x <= 1000$」的条件限制,我们需要进行「出队检查」,只有满足「$0 <= x <= 1000$」的出队元素,才进行下一步的拓展;
2. 反向搜索:使用队列 `d2` 实现从 $goal$ 到 $start$ 的通路搜索,为满足「$0 <= x <= 1000$」的条件限制,我们需要进行「入队检查」,只有下一个拓展元素 $next$ 满足「$0 <= x <= 1000$」才能进行入队。
同时,我们使用两个「哈希表」分别记录两个搜索方向中出现过的结果。
一旦在某条搜索通路中搜到了另一条搜索通路中出现过的结果,说明找到了一条合法的搜索通路,返回该通路长度。
代码:
```Java
class Solution {
int[] nums;
public int minimumOperations(int[] _nums, int s, int t) {
nums = _nums;
Deque<Long> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
Map<Long, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
d1.addLast(s * 1L);
d2.addLast(t * 1L);
m1.put(s * 1L, 0);
m2.put(t * 1L, 0);
while (!d1.isEmpty() && !d2.isEmpty()) {
if (d1.size() < d2.size()) {
int ans = update(d1, m1, d2, m2, true);
if (ans != -1) return ans;
} else {
int ans = update(d2, m2, d1, m1, false);
if (ans != -1) return ans;
}
}
return -1;
}
int update(Deque<Long> d1, Map<Long, Integer> m1, Deque<Long> d2, Map<Long, Integer> m2, boolean flag) {
int m = d1.size();
while (m-- > 0) {
long cur = d1.pollFirst();
int step = m1.get(cur);
for (int i : nums) {
if (flag) {
// 正向搜索:进行出队检查,只有出队元素符合条件,才能使用出队元素往下拓展
if (0 <= cur && cur <= 1000) {
long[] result = new long[]{cur + i, cur - i, cur ^ i};
for (long next : result) {
if (m2.containsKey(next)) return step + 1 + m2.get(next);
if (!m1.containsKey(next)) {
d1.addLast(next);
m1.put(next, step + 1);
}
}
}
} else {
// 反向搜索:进行入队检查,只有拓展元素符合条件,才能将拓展元素入队
long[] result = new long[]{cur + i, cur - i, cur ^ i};
for (long next : result) {
if (0 <= next && next <= 1000) {
if (m2.containsKey(next)) return step + 1 + m2.get(next);
if (!m1.containsKey(next)) {
d1.addLast(next);
m1.put(next, step + 1);
}
}
}
}
}
}
return -1;
}
}
```
* 时间复杂度:令 $n$ 为 $nums$ 的长度,常数 $C$ 为队列内元素的值域大小(本题值域范围为 $[0, 1000]$ )。整体复杂度为 $O(C * n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2059` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2061-2070/2069. 模拟行走机器人 II（中等）.md | 2069. 模拟行走机器人 II | https://leetcode-cn.com/problems/walking-robot-simulation-ii/solution/by-ac_oier-6zib/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 给你一个在 `XY` 平面上的 `width x height` 的网格图,左下角 的格子为 $(0, 0)$,右上角的格子为 $(width - 1, height - 1)$ 。网格图中相邻格子为四个基本方向之一(`"North"`,`"East"`,`"South"` 和 `"West"`)。一个机器人初始在格子 $(0, 0)$ ,方向为 `"East"`。
机器人可以根据指令移动指定的步数。每一步,它可以执行以下操作。
1. 沿着当前方向尝试往前一步 。
2. 如果机器人下一步将到达的格子超出了边界,机器人会逆时针转 90 度,然后再尝试往前一步。
如果机器人完成了指令要求的移动步数,它将停止移动并等待下一个指令。
请你实现 `Robot` 类:
* `Robot(int width, int height)` 初始化一个 `width x height` 的网格图,机器人初始在 $(0, 0)$,方向朝 `"East"`。
* `void move(int num)` 给机器人下达前进 `num` 步的指令。
* `int[] getPos()` 返回机器人当前所处的格子位置,用一个长度为 $2$ 的数组 $[x, y]$ 表示。
* `String getDir()` 返回当前机器人的朝向,为 `"North"`,`"East"`,`"South"` 或者 `"West"`。
示例 1:
```
输入:
["Robot", "move", "move", "getPos", "getDir", "move", "move", "move", "getPos", "getDir"]
[[6, 3], [2], [2], [], [], [2], [1], [4], [], []]
输出:
[null, null, null, [4, 0], "East", null, null, null, [1, 2], "West"]
解释:
Robot robot = new Robot(6, 3); // 初始化网格图,机器人在 (0, 0) ,朝东。
robot.move(2); // 机器人朝东移动 2 步,到达 (2, 0) ,并朝东。
robot.move(2); // 机器人朝东移动 2 步,到达 (4, 0) ,并朝东。
robot.getPos(); // 返回 [4, 0]
robot.getDir(); // 返回 "East"
robot.move(2); // 朝东移动 1 步到达 (5, 0) ,并朝东。
// 下一步继续往东移动将出界,所以逆时针转变方向朝北。
// 然后,往北移动 1 步到达 (5, 1) ,并朝北。
robot.move(1); // 朝北移动 1 步到达 (5, 2) ,并朝 北 (不是朝西)。
robot.move(4); // 下一步继续往北移动将出界,所以逆时针转变方向朝西。
// 然后,移动 4 步到 (1, 2) ,并朝西。
robot.getPos(); // 返回 [1, 2]
robot.getDir(); // 返回 "West"
```
提示:
* $2 <= width, height <= 100$
* $1 <= num <= 10^5$
* `move`,`getPos` 和 `getDir` 总共调用次数不超过 $10^4$ 次。 | ### 模拟
根据题目给定的移动规则可知,机器人总是在外圈移动(共上下左右四条),而移动方向分为四类:
当行走步数为 $mod = 2 * (w - 1) + 2 * (h - 1)$ 的整数倍时,会回到起始位置,因此我们可以通过维护一个变量 `loc` 来记录行走的总步数,并且每次将 `loc` 对 `mod` 进行取模来得到有效步数。
在回答 `getPos` 和 `getDir` 询问时,根据当前 `loc` 进行分情况讨论(见注释)。
另外还有一个小细节:根据题意,如果当前处于 $(0, 0)$ 位置,并且没有移动过,方向为 `East`,若移动过,方向则为 `South`,这可以通过一个变量 `moved` 来进行特判处理。
代码:
```Java
class Robot {
String[] ss = new String[]{"East", "North", "West", "South"};
int w, h, loc; // loc: 有效(取模后)移动步数
boolean moved; // 记录是否经过移动,用于特判 (0,0) 的方向
public Robot(int width, int height) {
w = width; h = height;
}
public void step(int num) {
moved = true;
loc += num;
loc %= 2 * (w - 1) + 2 * (h - 1);
}
public int[] getPos() {
int[] info = move();
return new int[]{info[0], info[1]};
}
public String getDir() {
int[] info = move();
int x = info[0], y = info[1], dir = info[2];
// 特殊处理当前在 (0,0) 的情况,当未移动过方向为 East,移动过方向为 South
if (x == 0 && y == 0) return moved ? ss[3] : ss[0];
return ss[dir];
}
int[] move() {
if (loc <= w - 1) {
// 当移动步数范围在 [0,w-1] 时,所在位置为外圈的下方,方向为 East
return new int[]{loc, 0, 0};
} else if (loc <= (w - 1) + (h - 1)) {
// 当移动步数范围在 [w,(w-1)+(h-1)] 时,所在位置为外圈的右方,方向为 North
return new int[]{w - 1, loc - (w - 1), 1};
} else if (loc <= 2 * (w - 1) + (h - 1)) {
// 当移动步数范围在 [(w-1)+(h-1)+1,2*(w-1)+(h-1)] 时,所在位置为外圈的上方,方向为 West
return new int[]{(w - 1) - (loc - ((w - 1) + (h - 1))), h - 1, 2};
} else {
// 当移动步数范围在 [2*(w-1)+(h-1)+1,2*(w-1)+2*(h-1)] 时,所在位置为外圈的左方,方向为 South
return new int[]{0, (h - 1) - (loc - (2 * (w - 1) + (h - 1))), 3};
}
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2069` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/2091-2100/2100. 适合打劫银行的日子（中等）.md | 2100. 适合打劫银行的日子 | https://leetcode-cn.com/problems/find-good-days-to-rob-the-bank/solution/gong-shui-san-xie-qian-zhui-he-yun-yong-gf604/ | 中等 | [
"前缀和"
] | 你和一群强盗准备打劫银行。给你一个下标从 $0$ 开始的整数数组 $security$ ,其中 $security[i]$ 是第 $i$ 天执勤警卫的数量。日子从 $0$ 开始编号。同时给你一个整数 $time$ 。
如果第 $i$ 天满足以下所有条件,我们称它为一个适合打劫银行的日子:
* 第 $i$ 天前和后都分别至少有 $time$ 天。
* 第 $i$ 天前连续 $time$ 天警卫数目都是非递增的。
* 第 $i$ 天后连续 $time$ 天警卫数目都是非递减的。
更正式的,第 $i$ 天是一个合适打劫银行的日子当且仅当:
$security[i - time] >= security[i - time + 1] >= ... >= security[i] <= ... <= security[i + time - 1] <= security[i + time]$
请你返回一个数组,包含 所有 适合打劫银行的日子(下标从 $0$ 开始)。返回的日子可以 **任意** 顺序排列。
示例 1:
```
输入:security = [5,3,3,3,5,6,2], time = 2
输出:[2,3]
解释:
第 2 天,我们有 security[0] >= security[1] >= security[2] <= security[3] <= security[4] 。
第 3 天,我们有 security[1] >= security[2] >= security[3] <= security[4] <= security[5] 。
没有其他日子符合这个条件,所以日子 2 和 3 是适合打劫银行的日子。
```
示例 2:
```
输入:security = [1,1,1,1,1], time = 0
输出:[0,1,2,3,4]
解释:
因为 time 等于 0 ,所以每一天都是适合打劫银行的日子,所以返回每一天。
```
示例 3:
```
输入:security = [1,2,3,4,5,6], time = 2
输出:[]
解释:
没有任何一天的前 2 天警卫数目是非递增的。
所以没有适合打劫银行的日子,返回空数组。
```
示例 4:
```
输入:security = [1], time = 5
输出:[]
解释:
没有日子前面和后面有 5 天时间。
所以没有适合打劫银行的日子,返回空数组。
```
提示:
* $1 <= security.length <= 10^5$
* $0 <= security[i], time <= 10^5$ | ### 前缀和
为了方便,我们令 $n$ 为 $security$ 长度。
根据题目对「适合打劫银行的日子」的定义,首先我们可以确定答案落在 $[time, n - time]$ 范围内,另外规定了「适合打劫银行的日子」左右侧需要满足「非递增」和「非递减」的性质。
首先我们可以预处理 `g` 数组,$g[i]$ 代表当前时间 $security[i]$ 与前一时间 $security[i - 1]$ 的大小关系,当 $security[i] > security[i - 1]$ 时有 $g[i] = 1$,当 $security[i] < security[i - 1]$ 时有 $g[i] = -1$,否则 $g[i] = 0$,另外我们特别的有 $g[0] = 0$ 的边界情况。
然后我们对 `g` 应用「前缀和」思想:使用 `a` 数组记录前缀 $1$ 的数量,使用 `b` 数组记录前缀 $-1$ 的数量。
最终,如果 $i$ 为「适合打劫银行的日子」,那么满足 $time <= i <= n - time$,且满足 $(i - time, i]$ 范围前缀 $1$ 数量为 $0$,$(i, i + time]$ 范围前缀 $-1$ 数量为 $0$。
代码:
```Java
class Solution {
public List<Integer> goodDaysToRobBank(int[] security, int time) {
int n = security.length;
int[] g = new int[n];
for (int i = 1; i < n; i++) {
if (security[i] == security[i - 1]) continue;
g[i] = security[i] > security[i - 1] ? 1 : -1;
}
int[] a = new int[n + 1], b = new int[n + 1];
for (int i = 1; i <= n; i++) a[i] = a[i - 1] + (g[i - 1] == 1 ? 1 : 0);
for (int i = 1; i <= n; i++) b[i] = b[i - 1] + (g[i - 1] == -1 ? 1 : 0);
List<Integer> ans = new ArrayList<>();
for (int i = time; i < n - time; i++) {
int c1 = a[i + 1] - a[i + 1 - time], c2 = b[i + 1 + time] - b[i + 1];
if (c1 == 0 && c2 == 0) ans.add(i);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.2100` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/21. 合并两个有序链表（简单）.md | 21. 合并两个有序链表 | https://leetcode-cn.com/problems/merge-two-sorted-lists/solution/shua-chuan-lc-shuang-zhi-zhen-jie-fa-sha-b22z/ | 简单 | [
"多路归并",
"链表"
] | 将两个升序链表合并为一个新的 升序 链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
```
输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]
```
示例 2:
```
输入:l1 = [], l2 = []
输出:[]
```
示例 3:
```
输入:l1 = [], l2 = [0]
输出:[0]
```
提示:
* 两个链表的节点数目范围是 $[0, 50]$
* $-100 <= Node.val <= 100$
* `l1` 和 `l2` 均按 非递减顺序 排列 | ### 多路归并(哨兵技巧)
哨兵技巧我们之前在「2. 两数相加」讲过啦,让三叶来帮你回忆一下:
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
由于两条链表本身就是有序的,只需要在遍历过程中进行比较即可:
代码:
```Java
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
if (l2 == null) return l1;
ListNode dummy = new ListNode(0);
ListNode cur = dummy;
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
cur.next = l1;
cur = cur.next;
l1 = l1.next;
} else {
cur.next = l2;
cur = cur.next;
l2 = l2.next;
}
}
while (l1 != null) {
cur.next = l1;
cur = cur.next;
l1 = l1.next;
}
while (l2 != null) {
cur.next = l2;
cur = cur.next;
l2 = l2.next;
}
return dummy.next;
}
}
```
* 时间复杂度:对两条链表扫描一遍。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.21` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/22. 括号生成（中等）.md | 22. 括号生成 | https://leetcode-cn.com/problems/generate-parentheses/solution/shua-chuan-lc-dfs-jie-fa-by-ac_oier-nknl/ | 中等 | [
"DFS",
"回溯算法"
] | 数字 $n$ 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。
示例 1:
```
输入:n = 3
输出:["((()))","(()())","(())()","()(())","()()()"]
```
示例 2:
```
输入:n = 1
输出:["()"]
```
提示:
* $1 <= n <= 8$ | ### DFS
既然题目是求所有的方案,那只能爆搜了,爆搜可以使用 `DFS` 来做。
从数据范围 `1 <= n <= 8` 来说,`DFS` 应该是稳稳的 AC。
这题的关键是我们要从题目中发掘一些性质:
1. 括号数为 `n`,那么一个合法的括号组合,应该包含 `n` 个左括号和 `n` 个右括号,组合总长度为 `2n`
2. 一对合法的括号,应该是先出现左括号,再出现右括号。那么意味着**任意一个右括号的左边,至少有一个左括号**
其中性质 2 是比较难想到的,我们可以用反证法来证明性质 2 总是成立:
假设某个右括号不满足「其左边至少有一个左括号」,即其左边没有左括号,那么这个右括号就找不到一个与之对应的左括号进行匹配。
这样的组合必然不是有效的括号组合。
使用我们「20. 有效的括号(简单)」的思路(栈)去验证的话,必然验证不通过。
掌握了这两个性质之后,我们可以设定一个初始值为 0 的得分值,令往组合添加一个 `(` 得分值 + 1,往组合添加一个 `)` 得分值 -1。
这样就有:
1. 一个合法的括号组合,最终得分必然为 0 (左括号和右括号的数量相等,对应了性质 1)
2. 整个 `DFS` 过程中,得分值范围在 `[0, n]`(得分不可能超过 `n` 意味着不可能添加数量超过 `n` 的左括号,对应了性质 1;得分不可能为负数,意味着每一个右括号必然有一个左括号进行匹配,对应性质 2)
代码:
```Java
class Solution {
public List<String> generateParenthesis(int n) {
List<String> ans = new ArrayList<>();
dfs(0, n * 2, 0, n, "", ans);
return ans;
}
/**
* i: 当前遍历到位置
* n: 字符总长度
* score: 当前得分,令 '(' 为 1, ')' 为 -1
* max: 最大得分值
* path: 当前的拼接结果
* ans: 最终结果集
*/
void dfs(int i, int n, int score, int max, String path, List<String> ans) {
if (i == n) {
if (score == 0) ans.add(path);
} else {
if (score + 1 <= max) dfs(i + 1, n, score + 1, max, path + "(", ans);
if (score - 1 >= 0) dfs(i + 1, n, score - 1, max, path + ")", ans);
}
}
}
```
* 时间复杂度:放置的左括号数量为 `n`,右括号的个数总是小于等于左括号的个数,典型的卡特兰数问题。复杂度为 $O(C_{2n}^n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.22` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/23. 合并K个升序链表（困难）.md | 23. 合并K个升序链表 | https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/shua-chuan-lc-you-xian-dui-lie-jie-fa-sh-3flb/ | 困难 | [
"优先队列(堆)",
"链表",
"多路归并"
] | 给你一个链表数组,每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中,返回合并后的链表。
示例 1:
```
输入:lists = [[1,4,5],[1,3,4],[2,6]]
输出:[1,1,2,3,4,4,5,6]
解释:链表数组如下:
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
```
示例 2:
```
输入:lists = []
输出:[]
```
示例 3:
```
输入:lists = [[]]
输出:[]
```
提示:
* $k == lists.length$
* $0 <= k <= 10^4$
* $0 <= lists[i].length <= 500$
* $-10^4 <= lists[i][j] <= 10^4$
* $lists[i]$ 按 升序 排列
* $lists[i].length$ 的总和不超过 $10^4$ | ### 多路归并 + 优先队列
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
由于所有链表本身满足「升序」,一个直观的做法是,我们比较每条链表的头结点,选取值最小的节点,添加到结果中,然后更新该链表的的头结点为该节点的 next 指针。循环比较,直到所有的节点都被加入结果中。
对应到代码的话,相当于我们需要准备一个「集合」,将所有链表的头结点放入「集合」,然后每次都从「集合」中挑出最小值,并将最小值的下一个节点添加进「集合」(如果有的话),循环这个过程,直到「集合」为空(说明所有节点都处理完,进过集合又从集合中出来)。
优先队列(堆)则是满足这样要求的数据结构,而整个过程其实就是「多路归并」过程。
代码:
```Java
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
ListNode dummy = new ListNode(-1), tail = dummy;
PriorityQueue<ListNode> q = new PriorityQueue<>((a,b)->a.val-b.val);
for (ListNode node : lists) {
if (node != null) q.add(node);
}
while (!q.isEmpty()) {
ListNode poll = q.poll();
tail.next = poll;
tail = tail.next;
if (poll.next != null) q.add(poll.next);
}
return dummy.next;
}
}
```
* 时间复杂度:假设共有 $k$ 条建表,共 $n$ 个节点,复杂度为 $O(n\log{k})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.23` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/24. 两两交换链表中的节点（中等）.md | 24. 两两交换链表中的节点 | https://leetcode-cn.com/problems/swap-nodes-in-pairs/solution/shua-chuan-lc-di-gui-die-dai-jie-fa-shao-70t3/ | 中等 | [
"递归",
"链表"
] | 给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
示例 1:
```
输入:head = [1,2,3,4]
输出:[2,1,4,3]
```
示例 2:
```
输入:head = []
输出:[]
```
示例 3:
```
输入:head = [1]
输出:[1]
```
提示:
* 链表中节点的数目在范围 $[0, 100]$ 内
* $0 <= Node.val <= 100$
进阶:你能在不修改链表节点值的情况下解决这个问题吗?(也就是说,仅修改节点本身。) | ### 递归解法(哨兵技巧)
哨兵技巧我们之前在前面的多道链表题讲过,让三叶来帮你回忆一下:
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
链表和树的题目天然适合使用递归来做。
我们可以设计一个递归函数,接受一个 `ListNode` 节点 root 作为参数,函数的作用是将 root 后面的两个节点进行交换,交换完成后再将下一个节点传入 ...
交换的前提条件:节点 root 后面至少有两个节点。同时别忘了应用我们的「哨兵技巧」。
代码:
```Java
class Solution {
public ListNode swapPairs(ListNode head) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
recursive(dummy);
return dummy.next;
}
void recursive(ListNode root) {
if (root.next != null && root.next.next != null) {
ListNode a = root.next, b = a.next;
root.next = b;
a.next = b.next;
b.next = a;
recursive(a);
}
}
}
```
* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$
* 空间复杂度:$O(1)$
---
### 迭代解法(哨兵技巧)
所有的递归都能转化为迭代。
代码:
```Java
class Solution {
public ListNode swapPairs(ListNode head) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
for (ListNode cur = dummy; cur.next != null && cur.next.next != null;) {
ListNode a = cur.next, b = a.next;
cur.next = b;
a.next = b.next;
b.next = a;
cur = a;
}
return dummy.next;
}
}
```
* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.22` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/25. K 个一组翻转链表（困难）.md | 25. K 个一组翻转链表 | https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/shua-chuan-lc-duo-tu-jiang-jie-di-gui-gu-6wr0/ | 困难 | [
"递归",
"迭代",
"链表"
] | 给你一个链表,每 `k` 个节点一组进行翻转,请你返回翻转后的链表。
`k` 是一个正整数,它的值小于或等于链表的长度。
如果节点总数不是 `k` 的整数倍,那么请将最后剩余的节点保持原有顺序。
进阶:
* 你可以设计一个只使用常数额外空间的算法来解决此问题吗?
* 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。
示例 1:
```
输入:head = [1,2,3,4,5], k = 2
输出:[2,1,4,3,5]
```
示例 2:
```
输入:head = [1,2,3,4,5], k = 3
输出:[3,2,1,4,5]
```
示例 3:
```
输入:head = [1,2,3,4,5], k = 1
输出:[1,2,3,4,5]
```
示例 4:
```
输入:head = [1], k = 1
输出:[1]
```
提示:
* 列表中节点的数量在范围 `sz` 内
* $1 <= sz <= 5000$
* $0 <= Node.val <= 1000$
* $1 <= k <= sz$ | ### 迭代(哨兵技巧)
哨兵技巧我们在前面的多道链表题讲过,让三叶来帮你回忆一下:
**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**
链表和树的题目天然适合使用递归来做。
但这次我们先将简单的「递归版本」放一放,先搞清楚迭代版本该如何实现。
我们可以设计一个翻转函数 `reverse` :
**传入节点 `root` 作为参数,函数的作用是将以 `root` 为起点的 $k$ 个节点进行翻转。**
**当以 `root` 为起点的长度为 $k$ 的一段翻转完成后,再将下一个起始节点传入,直到整条链表都被处理完成。**
**当然,在 `reverse` 函数真正执行翻转前,需要先确保节点 `root` 后面至少有 $k$ 个节点。**
我们可以结合图解再来体会一下这个过程:
假设当前样例为 `1->2->3->4->5->6->7` 和 `k = 3` :
然后我们调用 `reverse(cur, k)`,在 `reverse()` 方法内部,几个指针的指向如图所示,会通过先判断 `cur` 是否为空,从而确定是否有足够的节点进行翻转:
然后先通过 `while` 循环,将中间的数量为 `k - 1` 的 next 指针进行翻转:
.png)
最后再处理一下局部的头结点和尾结点,这样一次 `reverse(cur, k)` 执行就结束了:
.png)
回到主方法,将 `cur` 往前移动 `k` 步,再调用 `reverse(cur, k)` 实现 `k` 个一组翻转:
.png)
Java 代码:
```Java
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode cur = dummy;
while (cur != null) {
reverse(cur, k);
int u = k;
while (u-- > 0 && cur != null) cur = cur.next;
}
return dummy.next;
}
// reverse 的作用是将 root 后面的 k 个节点进行翻转
void reverse(ListNode root, int k) {
// 检查 root 后面是否有 k 个节点
int u = k;
ListNode cur = root;
while (u-- > 0 && cur != null) cur = cur.next;
if (cur == null) return;
// 进行翻转
ListNode tail = cur.next;
ListNode a = root.next, b = a.next;
// 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转
while (k-- > 1) {
ListNode c = b.next;
b.next = a;
a = b;
b = c;
}
root.next.next = tail;
root.next = a;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* dummy = new ListNode(-1);
dummy->next = head;
ListNode* cur = dummy;
while (cur != NULL) {
reverse(cur, k);
int u = k;
while (u-- > 0 && cur != NULL) cur = cur->next;
}
return dummy->next;
}
// reverse 的作用是将 root 后面的 k 个节点进行翻转
void reverse(ListNode* root, int k) {
// 检查 root 后面是否有 k 个节点
int u = k;
ListNode* cur = root;
while (u-- > 0 && cur != NULL) cur = cur->next;
if (cur == NULL) return;
// 进行翻转
ListNode* tail = cur->next;
ListNode* a = root->next, *b = a->next;
// 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转
while (k-- > 1) {
ListNode* c = b->next;
b->next = a;
a = b;
b = c;
}
root->next->next = tail;
root->next = a;
}
};
```
Python 代码:
```Python
class Solution:
def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
# reverse 的作用是将 root 后面的 k 个节点进行翻转
def reverse(root, k):
# 检查 root 后面是否有 k 个节点
u, cur = k, root
while u > 0 and cur:
cur = cur.next
u -= 1
if not cur: return
# 进行翻转
tail = cur.next
a, b = root.next, root.next.next
# 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转
while k > 1:
c, b.next = b.next, a
a, b = b, c
k -= 1
root.next.next = tail
root.next = a
dummy = ListNode(-1)
dummy.next = head
cur = dummy
while cur:
reverse(cur, k)
u = k
while u > 0 and cur:
cur = cur.next
u -= 1
return dummy.next
```
TypeScript 代码:
```TypeScript
function reverseKGroup(head: ListNode | null, k: number): ListNode | null {
// reverse 的作用是将 root 后面的 k 个节点进行翻转
const reverse = function(root: ListNode | null, k: number): void {
// 检查 root 后面是否有 k 个节点
let u = k, cur = root;
while (u-- > 0 && cur != null) cur = cur.next;
if (cur == null) return;
// 进行翻转
let tail = cur.next, a = root.next, b = a.next;
// 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转
while (k-- > 1) {
let c = b.next;
b.next = a;
a = b;
b = c;
}
root.next.next = tail;
root.next = a;
};
let dummy = new ListNode(-1);
dummy.next = head;
let cur = dummy;
while (cur != null) {
reverse(cur, k);
let u = k;
while (u-- > 0 && cur != null) cur = cur.next;
}
return dummy.next;
};
```
* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$
* 空间复杂度:$O(1)$
---
### 递归
搞懂了较难的「迭代哨兵」版本之后,常规的「递归无哨兵」版本写起来应该更加容易了。
需要注意的是,当我们不使用「哨兵」时,检查是否足够 $k$ 位,只需要检查是否有 $k - 1$ 个 $next$ 指针即可。
代码:
```Java
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
int u = k;
ListNode p = head;
while (p != null && u-- > 1) p = p.next;
if (p == null) return head;
ListNode tail = head;
ListNode prev = head, cur = prev.next;
u = k;
while (u-- > 1) {
ListNode tmp = cur.next;
cur.next = prev;
prev = cur;
cur = tmp;
}
tail.next = reverseKGroup(cur, k);
return prev;
}
}
```
C++ 代码:
```C++
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
int u = k;
ListNode* p = head;
while (p != NULL && u-- > 1) p = p->next;
if (p == NULL) return head;
ListNode* tail = head;
ListNode* prev = head, *cur = prev->next;
u = k;
while (u-- > 1) {
ListNode* tmp = cur->next;
cur->next = prev;
prev = cur;
cur = tmp;
}
tail->next = reverseKGroup(cur, k);
return prev;
}
};
```
Python 代码:
```Python
class Solution:
def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
u = k
p = head
while p and u > 1:
p = p.next
u -= 1
if not p: return head
tail = prev = head
cur = prev.next
u = k
while u > 1:
tmp = cur.next
cur.next = prev
prev, cur = cur, tmp
u -= 1
tail.next = self.reverseKGroup(cur, k)
return prev
```
TypeScript 代码:
```TypeScript
function reverseKGroup(head: ListNode | null, k: number): ListNode | null {
let u = k;
let p = head;
while (p != null && u-- > 1) p = p.next;
if (p == null) return head;
let tail = head, prev = head, cur = prev.next;
u = k;
while (u-- > 1) {
let tmp = cur.next;
cur.next = prev;
prev = cur;
cur = tmp;
}
tail.next = reverseKGroup(cur, k);
return prev;
};
```
* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$
* 空间复杂度:只有忽略递归带来的空间开销才是 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/26. 删除有序数组中的重复项（简单）.md | 26. 删除有序数组中的重复项 | https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/ | 简单 | [
"数组",
"双指针",
"数组移除元素问题"
] | 给你一个有序数组 `nums` ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。
不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 $O(1)$ 额外空间的条件下完成。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
```
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
```
示例 1:
```
输入:nums = [1,1,2]
输出:2, nums = [1,2]
解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
```
示例 2:
```
输入:nums = [0,0,1,1,1,2,2,3,3,4]
输出:5, nums = [0,1,2,3,4]
解释:函数应该返回新的长度 5 , 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
```
提示:
* $0 <= nums.length <= 3 \times 10^4$
* $-10^4 <= nums[i] <= 10^4$
* `nums` 已按升序排列 | ### 双指针
一个指针 `i` 进行数组遍历,另外一个指针 `j` 指向有效数组的最后一个位置。
只有当 `i` 所指向的值和 `j` 不一致(不重复),才将 `i` 的值添加到 `j` 的下一位置。
代码:
```Java
class Solution {
public int removeDuplicates(int[] nums) {
int n = nums.length;
int j = 0;
for (int i = 0; i < n; i++) {
if (nums[i] != nums[j]) {
nums[++j] = nums[i];
}
}
return j + 1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 通用解法
为了让解法更具有一般性,我们将原问题的「最多保留 1 位」修改为「最多保留 k 位」。
对于此类问题,我们应该进行如下考虑:
* 由于是保留 `k` 个相同数字,**对于前 `k` 个数字,我们可以直接保留。**
* 对于后面的任意数字,能够保留的前提是:**与当前写入的位置前面的第 `k` 个元素进行比较,不相同则保留。**
举个🌰,我们令 `k=1`,假设有样例:`[3,3,3,3,4,4,4,5,5,5]`
0. 设定变量 `idx`,指向待插入位置。`idx` 初始值为 `0`,目标数组为 `[]`
1. 首先我们先让第 `1` 位直接保留(性质 1)。`idx` 变为 `1`,目标数组为 `[3]`
2. 继续往后遍历,能够保留的前提是与 `idx` 的前面 `1` 位元素不同(性质 2),因此我们会跳过剩余的 `3`,将第一个 `4` 追加进去。`idx` 变为 `2`,目标数组为 `[3,4]`
3. 继续这个过程,跳过剩余的 `4`,将第一个 `5` 追加进去。`idx` 变为 `3`,目标数组为 `[3,4,5]`
4. 当整个数组被扫描完,最终我们得到了目标数组 `[3,4,5]` 和 答案 `idx` 为 `3`。
代码:
```Java
class Solution {
public int removeDuplicates(int[] nums) {
return process(nums, 1);
}
int process(int[] nums, int k) {
int idx = 0;
for (int x : nums) {
if (idx < k || nums[idx - k] != x) nums[idx++] = x;
}
return idx;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
基于上述解法我们还能做一点小剪枝:**利用目标数组的最后一个元素必然与原数组的最后一个元素相同进行剪枝,从而确保当数组有超过 `k` 个最大值时,数组不会被完整扫描。**
**但需要注意这种「剪枝」同时会让我们单次循环的常数变大,所以仅作为简单拓展。**
代码:
```Java
class Solution {
public int removeDuplicates(int[] nums) {
int n = nums.length;
if (n <= 1) return n;
return process(nums, 1, nums[n - 1]);
}
int process(int[] nums, int k, int max) {
int idx = 0;
for (int x : nums) {
if (idx < k || nums[idx - k] != x) nums[idx++] = x;
if (idx - k >= 0 && nums[idx - k] == max) break;
}
return idx;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.26` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/27. 移除元素（简单）.md | 27. 移除元素 | https://leetcode-cn.com/problems/remove-element/solution/shua-chuan-lc-shuang-bai-shuang-zhi-zhen-mzt8/ | 简单 | [
"数组",
"双指针",
"数组移除元素问题"
] | 给你一个数组 `nums` 和一个值 `val`,你需要「原地」移除所有数值等于 `val` 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 $O(1)$ 额外空间并「原地」修改输入数组。
元素的顺序可以改变。
你不需要考虑数组中超出新长度后面的元素。
**说明**:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
```
// nums 是以“引用”方式传递的。也就是说,不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
```
示例 1:
```
输入:nums = [3,2,2,3], val = 3
输出:2, nums = [2,2]
解释:函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如,函数返回的新长度为 2 ,而 nums = [2,2,3,3] 或 nums = [2,2,0,0],也会被视作正确答案。
```
示例 2:
```
输入:nums = [0,1,2,2,3,0,4,2], val = 2
输出:5, nums = [0,1,4,0,3]
解释:函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
```
提示:
* $0 <= nums.length <= 100$
* $0 <= nums[i] <= 50$
* $0 <= val <= 100$ | ### 双指针
本解法的思路与 [【题解】26. 删除排序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/) 中的「双指针解法」类似。
根据题意,我们可以将数组分成「前后」两段:
* 前半段是有效部分,存储的是不等于 `val` 的元素。
* 后半段是无效部分,存储的是等于 `val` 的元素。
最终答案返回有效部分的结尾下标。
代码:
```Java
class Solution {
public int removeElement(int[] nums, int val) {
int j = nums.length - 1;
for (int i = 0; i <= j; i++) {
if (nums[i] == val) {
swap(nums, i--, j--);
}
}
return j + 1;
}
void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 通用解法
本解法的思路与 [【题解】26. 删除排序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/) 中的「通用解法」类似。
先设定变量 `idx`,指向待插入位置。`idx` 初始值为 0
**然后从题目的「要求/保留逻辑」出发,来决定当遍历到任意元素 `x` 时,应该做何种决策:**
* 如果当前元素 `x` 与移除元素 `val` 相同,那么跳过该元素。
* 如果当前元素 `x` 与移除元素 `val` 不同,那么我们将其放到下标 `idx` 的位置,并让 `idx` 自增右移。
最终得到的 `idx` 即是答案。
代码:
```Java
class Solution {
public int removeElement(int[] nums, int val) {
int idx = 0;
for (int x : nums) {
if (x != val) nums[idx++] = x;
}
return idx;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 总结
**对于诸如「相同元素最多保留 `k` 位元素」或者「移除特定元素」的问题,更好的做法是从题目本身性质出发,利用题目给定的要求提炼出具体的「保留逻辑」,将「保留逻辑」应用到我们的遍历到的每一个位置。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.27` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/28. 实现 strStr()（简单）.md | 28. 实现 strStr() | https://leetcode-cn.com/problems/implement-strstr/solution/shua-chuan-lc-shuang-bai-po-su-jie-fa-km-tb86/ | 简单 | [
"子串匹配",
"KMP"
] | 实现 `strStr()` 函数。
给你两个字符串 `haystack` 和 `needle` ,请你在 `haystack` 字符串中找出 `needle` 字符串出现的第一个位置(下标从 $0$ 开始)。
如果不存在,则返回 $-1$ 。
说明:
* 当 `needle` 是空字符串时,我们应当返回什么值呢?这是一个在面试中很好的问题。
* 对于本题而言,当 `needle` 是空字符串时我们应当返回 $0$ 。这与 C 语言的 `strstr()` 以及 Java 的 `indexOf()` 定义相符。
示例 1:
```
输入:haystack = "hello", needle = "ll"
输出:2
```
示例 2:
```
输入:haystack = "aaaaa", needle = "bba"
输出:-1
```
示例 3:
```
输入:haystack = "", needle = ""
输出:0
```
提示:
* $0 <= haystack.length, needle.length <= 5 \times 10^4$
* `haystack` 和 `needle` 仅由小写英文字符组成 | ### 朴素解法
直观的解法的是:枚举原串 `ss` 中的每个字符作为「发起点」,每次从原串的「发起点」和匹配串的「首位」开始尝试匹配:
* 匹配成功:返回本次匹配的原串「发起点」。
* 匹配失败:枚举原串的下一个「发起点」,重新尝试匹配。
代码:
```Java
class Solution {
public int strStr(String ss, String pp) {
int n = ss.length(), m = pp.length();
char[] s = ss.toCharArray(), p = pp.toCharArray();
// 枚举原串的「发起点」
for (int i = 0; i <= n - m; i++) {
// 从原串的「发起点」和匹配串的「首位」开始,尝试匹配
int a = i, b = 0;
while (b < m && s[a] == p[b]) {
a++;
b++;
}
// 如果能够完全匹配,返回原串的「发起点」下标
if (b == m) return i;
}
return -1;
}
}
```
* 时间复杂度:`n` 为原串的长度,`m` 为匹配串的长度。其中枚举的复杂度为 $O(n - m)$,构造和比较字符串的复杂度为 $O(m)$。整体复杂度为 $O((n - m) \times m)$。
* 空间复杂度:$O(1)$。
---
### KMP 解法
KMP 算法是一个快速查找匹配串的算法,它的作用其实就是本题问题:**如何快速在「原字符串」中找到「匹配字符串」。**
上述的朴素解法,不考虑剪枝的话复杂度是 $O(m \times n)$ 的,而 KMP 算法的复杂度为 $O(m + n)$。
**KMP 之所以能够在 $O(m + n)$ 复杂度内完成查找,是因为其能在「非完全匹配」的过程中提取到有效信息进行复用,以减少「重复匹配」的消耗。**
你可能不太理解,没关系,我们可以通过举 🌰 来理解 KMP。
#### 1. 匹配过程
在模拟 KMP 匹配过程之前,我们先建立两个概念:
* 前缀:对于字符串 `abcxxxxefg`,我们称 `abc` 属于 `abcxxxxefg` 的某个前缀。
* 后缀:对于字符串 `abcxxxxefg`,我们称 `efg` 属于 `abcxxxxefg` 的某个后缀。
然后我们假设原串为 `abeababeabf`,匹配串为 `abeabf`:
我们可以先看看如果不使用 KMP,会如何进行匹配(不使用 `substring` 函数的情况下)。
首先在「原串」和「匹配串」分别各自有一个指针指向当前匹配的位置。
首次匹配的「发起点」是第一个字符 `a`。显然,后面的 `abeab` 都是匹配的,两个指针会同时往右移动(黑标)。
在都能匹配上 `abeab` 的部分,「朴素匹配」和「KMP」并无不同。
直到出现第一个不同的位置(红标):
**接下来,正是「朴素匹配」和「KMP」出现不同的地方:**
* **先看下「朴素匹配」逻辑:**
**1. 将原串的指针移动至本次「发起点」的下一个位置(`b` 字符处);匹配串的指针移动至起始位置。**
**2. 尝试匹配,发现对不上,原串的指针会一直往后移动,直到能够与匹配串对上位置。**
如图:
也就是说,对于「朴素匹配」而言,一旦匹配失败,将会将原串指针调整至下一个「发起点」,匹配串的指针调整至起始位置,然后重新尝试匹配。
这也就不难理解为什么「朴素匹配」的复杂度是 $O(m \times n)$ 了。
* **然后我们再看看「KMP 匹配」过程:**
**首先匹配串会检查之前已经匹配成功的部分中里是否存在相同的「前缀」和「后缀」。如果存在,则跳转到「前缀」的下一个位置继续往下匹配:**
**跳转到下一匹配位置后,尝试匹配,发现两个指针的字符对不上,并且此时匹配串指针前面不存在相同的「前缀」和「后缀」,这时候只能回到匹配串的起始位置重新开始:**
**到这里,你应该清楚 KMP 为什么相比于朴素解法更快:**
* **因为 KMP 利用已匹配部分中相同的「前缀」和「后缀」来加速下一次的匹配。**
* **因为 KMP 的原串指针不会进行回溯(没有朴素匹配中回到下一个「发起点」的过程)。**
第一点很直观,也很好理解。
我们可以把重点放在第二点上,原串不回溯至「发起点」意味着什么?
**其实是意味着:随着匹配过程的进行,原串指针的不断右移,我们本质上是在不断地在否决一些「不可能」的方案。**
**当我们的原串指针从 `i` 位置后移到 `j` 位置,不仅仅代表着「原串」下标范围为 $[i,j)$ 的字符与「匹配串」匹配或者不匹配,更是在否决那些以「原串」下标范围为 $[i,j)$ 为「匹配发起点」的子集。**
#### 2. 分析实现
到这里,就结束了吗?要开始动手实现上述匹配过程了吗?
我们可以先分析一下复杂度。如果严格按照上述解法的话,最坏情况下我们需要扫描整个原串,复杂度为 $O(n)$。同时在每一次匹配失败时,去检查已匹配部分的相同「前缀」和「后缀」,跳转到相应的位置,如果不匹配则再检查前面部分是否有相同「前缀」和「后缀」,再跳转到相应的位置 ... 这部分的复杂度是 $O(m^2)$ ,因此整体的复杂度是 $O(n \times m^2)$,而我们的朴素解法是 $O(m \times n)$ 的。
说明还有一些性质我们没有利用到。
显然,扫描完整原串操作这一操作是不可避免的,我们可以优化的只能是「**检查已匹配部分的相同前缀和后缀**」这一过程。
再进一步,我们检查「前缀」和「后缀」的目的其实是「为了确定匹配串中的下一段开始匹配的位置」。
**同时我们发现,对于匹配串的任意一个位置而言,由该位置发起的下一个匹配点位置其实与原串无关。**
举个 🌰,对于匹配串 `abcabd` 的字符 `d` 而言,由它发起的下一个匹配点跳转必然是字符 `c` 的位置。因为字符 `d` 位置的相同「前缀」和「后缀」字符 `ab` 的下一位置就是字符 `c`。
**可见从匹配串某个位置跳转下一个匹配位置这一过程是与原串无关的,我们将这一过程称为找 `next` 点。**
**显然我们可以预处理出 `next` 数组,数组中每个位置的值就是该下标应该跳转的目标位置( `next` 点)。**
当我们进行了这一步优化之后,复杂度是多少呢?
预处理 `next` 数组的复杂度未知,匹配过程最多扫描完整个原串,复杂度为 $O(n)$。
因此如果我们希望整个 KMP 过程是 $O(m + n)$ 的话,那么我们需要在 $O(m)$ 的复杂度内预处理出 `next`数组。
**所以我们的重点在于如何在 $O(m)$ 复杂度内处理处 `next` 数组。**
#### 3. `next` 数组的构建
接下来,我们看看 `next` 数组是如何在 $O(m)$ 的复杂度内被预处理出来的。
假设有匹配串 `aaabbab`,我们来看看对应的 `next` 是如何被构建出来的。
这就是整个 `next` 数组的构建过程,时空复杂度均为 $O(m)$。
至此整个 KMP 匹配过程复杂度是 $O(m + n)$ 的。
#### 4. 代码实现
在实际编码时,通常我会往原串和匹配串头部追加一个空格(哨兵)。
目的是让 `j` 下标从 `0` 开始,省去 `j` 从 `-1` 开始的麻烦。
整个过程与上述分析完全一致,一些相关的注释我已经写到代码里。
代码:
```Java
class Solution {
// KMP 算法
// ss: 原串(string) pp: 匹配串(pattern)
public int strStr(String ss, String pp) {
if (pp.isEmpty()) return 0;
// 分别读取原串和匹配串的长度
int n = ss.length(), m = pp.length();
// 原串和匹配串前面都加空格,使其下标从 1 开始
ss = " " + ss;
pp = " " + pp;
char[] s = ss.toCharArray();
char[] p = pp.toCharArray();
// 构建 next 数组,数组长度为匹配串的长度(next 数组是和匹配串相关的)
int[] next = new int[m + 1];
// 构造过程 i = 2,j = 0 开始,i 小于等于匹配串长度 【构造 i 从 2 开始】
for (int i = 2, j = 0; i <= m; i++) {
// 匹配不成功的话,j = next(j)
while (j > 0 && p[i] != p[j + 1]) j = next[j];
// 匹配成功的话,先让 j++
if (p[i] == p[j + 1]) j++;
// 更新 next[i],结束本次循环,i++
next[i] = j;
}
// 匹配过程,i = 1,j = 0 开始,i 小于等于原串长度 【匹配 i 从 1 开始】
for (int i = 1, j = 0; i <= n; i++) {
// 匹配不成功 j = next(j)
while (j > 0 && s[i] != p[j + 1]) j = next[j];
// 匹配成功的话,先让 j++,结束本次循环后 i++
if (s[i] == p[j + 1]) j++;
// 整一段匹配成功,直接返回下标
if (j == m) return i - m;
}
return -1;
}
}
```
* 时间复杂度:`n` 为原串的长度,`m` 为匹配串的长度。复杂度为 $O(m + n)$。
* 空间复杂度:构建了 `next` 数组。复杂度为 $O(m)$。
---
### 总结
**KMP 算法的应用范围要比 Manacher 算法广,Manacher 算法只能应用于「回文串」问题,相对比较局限,而「子串匹配」问题还是十分常见的。**
**背过这样的算法的意义在于:相当于大脑里有了一个时间复杂度为 $O(n)$ 的 api 可以使用,这个 api 传入一个原串和匹配串,返回匹配串在原串的位置。**
因此,三叶十分建议大家在「理解 KMP」的基础上,对模板进行背过 ~ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.28` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/21-30/29. 两数相除（中等）.md | 29. 两数相除 | https://leetcode-cn.com/problems/divide-two-integers/solution/gong-shui-san-xie-dui-xian-zhi-tiao-jian-utb9/ | 中等 | [
"数学",
"二分"
] | 给定两个整数,被除数 `dividend` 和除数 `divisor`。
将两数相除,要求不使用乘法、除法和 `mod` 运算符。
返回被除数 `dividend` 除以除数 `divisor` 得到的商。
整数除法的结果应当截去(`truncate`)其小数部分,例如:`truncate(8.345) = 8` 以及 `truncate(-2.7335) = -2`
示例 1:
```
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
```
示例 2:
```
输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333..) = -2
```
提示:
* 被除数和除数均为 $32$ 位有符号整数。
* 除数不为 $0$。
* 假设我们的环境只能存储 32 位有符号整数,其数值范围是 [−$2^{31}$, $2^{31}$ − 1]。本题中,如果除法结果溢出,则返回 $2^{31}$ − 1。 | ### 基本分析
主要的歧义在于第三点限制「假设我们的环境只能存储 $32$ 位有符号整数,其数值范围是 $[−2^{31}, 2^{31} − 1]$。本题中,如果除法结果溢出,则返回 $2^{31} − 1$」的理解。
该限制有两种理解方式:
1. 不限制算法使用 `long`,只是解释为什么在溢出时,返回 $2^{31} − 1$;
2. 限制算法使用 `long`。
原始题解在 [这里](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/) 。
---
### 理解一(不限制 `long`)
当不限制使用 `long` 时,基本思路为:
* 首先,`dividend` 和 `divisor` 均有「正数」和「负数」两种可能,当且仅当其中一者为负数时,结果为负,为了方便,我们可以先记录最终结果的正负号,然后将 `dividend` 和 `divisor` 都当成正数来处理;
* 现在两者都满足 $x >= 0$,然后利用 `dividend` 和 `divisor` 均为 `int`,可以确定答案的绝对值落在 $[0, dividend]$ 范围内(当且仅当 `divisor` 是范围在 $[0, 1]$ 的浮点数时,答案会大于 `dividend`);
* 假设答案为 $x$,那么在以 $x$ 为分割点的整数数轴上,具有「二段性」,因此我们可以二分找到该分割点:
* 大于 $x$ 的数 $y$ 满足 $y * b > a$;
* 小于等于 $x$ 的数 $y$ 满足 $y * b <= a$;
* 根据「二段性」分析,我们发现二分的 `check` 实现需要用到乘法,因此我们需要实现一个「不用乘法符号」的乘法实现(这可以使用倍增思想来实现 `mul` 操作)。
代码:
```Java
class Solution {
int INF = Integer.MAX_VALUE;
public int divide(int _a, int _b) {
long a = _a, b = _b;
boolean flag = false;
if ((a < 0 && b > 0) || (a > 0 && b < 0)) flag = true;
if (a < 0) a = -a;
if (b < 0) b = -b;
long l = 0, r = a;
while (l < r) {
long mid = l + r + 1 >> 1;
if (mul(mid, b) <= a) l = mid;
else r = mid - 1;
}
r = flag ? -r : r;
if (r > INF || r < -INF - 1) return INF;
return (int)r;
}
long mul(long a, long k) {
long ans = 0;
while (k > 0) {
if ((k & 1) == 1) ans += a;
k >>= 1;
a += a;
}
return ans;
}
}
```
* 时间复杂度:在 $[0, a]$ 范围内二分操作,复杂度为$O(\log{a})$;倍增乘法的与操作数的二进制长度相关,复杂度为 $O(\log{b})$。整体复杂度为 $O(\log{a} \times \log{b})$
* 空间复杂度:$O(1)$
---
### 理解二(限制 `long`)
对于全程不使用 `long` 的做法,我们需要将所有数映射到负数进行处理(以 $0$ 为分割点,负数所能表示的范围更大)。
基本思路为:
* 起始先对边界情况进行特判;
* 记录最终结果的符号,并将两数都映射为负数;
* 可以预处理出倍增数组,或采取逐步增大 `dividend` 来逼近 `divisor` 的方式。
> 由于操作数都是负数,因此自倍增过程中,如果操作数小于 `INT_MIN` 的一半(`-1073741824`),则代表发生溢出。
代码:
```Java
class Solution {
int MIN = Integer.MIN_VALUE, MAX = Integer.MAX_VALUE;
int LIMIT = -1073741824; // MIN 的一半
public int divide(int a, int b) {
if (a == MIN && b == -1) return MAX;
boolean flag = false;
if ((a > 0 && b < 0) || (a < 0 && b > 0)) flag = true;
if (a > 0) a = -a;
if (b > 0) b = -b;
int ans = 0;
while (a <= b){
int c = b, d = -1;
while (c >= LIMIT && d >= LIMIT && c >= a - c){
c += c; d += d;
}
a -= c;
ans += d;
}
return flag ? ans : -ans;
}
}
```
* 时间复杂度:$O(\log{a} \times \log{b})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.29` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |