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/351-360/357. 统计各位数字都不同的数字个数（中等）.md | 357. 统计各位数字都不同的数字个数 | https://leetcode-cn.com/problems/count-numbers-with-unique-digits/solution/by-ac_oier-6tfl/ | 中等 | [
"数学",
"容斥原理",
"数位 DP"
] | 给你一个整数 $n$ ,统计并返回各位数字都不同的数字 $x$ 的个数,其中 $0 <= x < 10^n$ 。
示例 1:
```
输入:n = 2
输出:91
解释:答案应为除去 11、22、33、44、55、66、77、88、99 外,在 0 ≤ x < 100 范围内的所有数字。
```
示例 2:
```
输入:n = 0
输出:1
```
提示:
* $0 <= n <= 8$ | ### 乘法原理
对于 $n = 0$ 的情况较为特殊,特判一下,返回 $1$。
对于其他情况,由于不能含有前导 $0$,最高位可选择的数值个数为 $9$,而从次高位开始到最低位,可选的个数从 $9$ 开始逐一递减。
利用乘法原理,每位数可选的数值个数相乘即是长度为 $n$ 的数的可能方案数 $cur$,而所有长度 $[1, n]$ 的方案数累加即是答案。
代码:
```Java
class Solution {
public int countNumbersWithUniqueDigits(int n) {
if (n == 0) return 1;
int ans = 10;
for (int i = 2, last = 9; i <= n; i++) {
int cur = last * (10 - i + 1);
ans += cur; last = cur;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 数位 DP
一种更为进阶的做法,应当是可以回答任意区间 $[l, r]$ 内合法数的个数。
这需要运用「数位 DP」进行求解,假定我们存在函数 `int dp(int x)` 函数,能够返回区间 $[0, x]$ 内合法数的个数,那么配合「容斥原理」我们便能够回答任意区间合法数的查询:
$$
ans_{(l, r)} = dp(r) - dp(l - 1)
$$
然后考虑如何实现 `int dp(int x)` 函数,我们将组成 $[0, x]$ 的合法数分成三类:
* 位数和 $x$ 相同,且最高位比 $x$ 最高位要小的,这部分统计为 `res1`;
* 位数和 $x$ 相同,且最高位与 $x$ 最高位相同的,这部分统计为 `res2`;
* 位数比 $x$ 少,这部分统计为 `res3`。
其中 `res1` 和 `res3` 求解相对简单,重点落在如何求解 `res2` 上。
**对 $x$ 进行「从高到低」的处理(假定 $x$ 数位为 $n$),对于第 $k$ 位而言($k$ 不为最高位),假设在 $x$ 中第 $k$ 位为 $cur$,那么为了满足「大小限制」关系,我们只能在 $[0, cur - 1]$ 范围内取数,同时为了满足「相同数字只能使用一次」的限制,我们需要使用一个 `int` 变量 $s$ 来记录使用情况(用 $s$ 的低十位来代指数字 $[0, 9]$ 是否被使用),统计 $[0, cur - 1]$ 范围内同时符合两个限制条件的数的个数,记为 $cnt$。**
**当第 $k$ 位有 $cnt$ 种合法选择之后,后面的位数可以在满足「相同数字只能使用一次」的限制条件下任意选择(因为大小关系已经由第 $k$ 位保证),为了快速知道剩下的 $n - k$ 位有多少种方案,我们还需要预处理乘积数组,其中 $f[l][r]$ 代表 $l * (l + 1) * ... * (j - 1) * j$ 的乘积之和。**
> 上述讲解若是觉得抽象,我们可以举个 🌰,假设 $x = 678$,我们该如何求解 `res2`:由于限定了 `res2` 为「位数和 $x$ 相同,且最高位与 $x$ 最高位相同的」的合法数个数,因此最高位没有选,只能是 $6$,然后考虑处理次高位,次高位在 $x$ 中为 $7$,为了满足大小关系,我们只能在 $[0, 6]$ 范围内做限制,同时由于 $6$ 已用过,因此次高位实际只有 $[0, 5]$,共 $6$ 种选择,当确定次高位后,后面的位数任意取,由于前面已经填充了 $p = 2$ 位(即消耗了 $p$ 个不同数字),因此从后面的位数开始应该是 $a = 10 - p$ 开始往后自减累乘到 $b = (10 - p) - (n - p) + 1$ 为止,即此时方案数为 $cnt * f[b][a]$(当前位不是最低位)或者 $cnt$(当前位是最低位)。按照此逻辑循环处理所有位数即可,直到遇到重复数值或正常结束。
需要说明的是,上述的举例部分只是为方便大家理解过程,看懂了举例部分不代表理解了数位 DP 做法成立的内在条件,阅读的重点还是要放在前面加粗字体部分,只会使用样例理解算法永远不是科学的做法。
其他细节:乘积数组的预处理与样例无关,我们可以使用 `static` 进行打表优化,同时可以将 `res1` 和 `res2` 两种情况进行合并。
代码:
```Java
class Solution {
// f[l][r] 代表 i * (i + 1) * ... * (j - 1) * j
static int[][] f = new int[10][10];
static {
for (int i = 1; i < 10; i++) {
for (int j = i; j < 10; j++) {
int cur = 1;
for (int k = i; k <= j; k++) cur *= k;
f[i][j] = cur;
}
}
}
int dp(int x) {
int t = x;
List<Integer> nums = new ArrayList<>();
while (t != 0) {
nums.add(t % 10);
t /= 10;
}
int n = nums.size();
if (n <= 1) return x + 1; // [0, 9]
// 位数和 x 相同(res1 + res2)
int ans = 0;
for (int i = n - 1, p = 1, s = 0; i >= 0; i--, p++) {
int cur = nums.get(i), cnt = 0;
for (int j = cur - 1; j >= 0; j--) {
if (i == n - 1 && j == 0) continue;
if (((s >> j) & 1) == 0) cnt++;
}
int a = 10 - p, b = a - (n - p) + 1;
ans += b <= a ? cnt * f[b][a] : cnt;
if (((s >> cur) & 1) == 1) break;
s |= (1 << cur);
if (i == 0) ans++;
}
// 位数比 x 少(res3)
ans += 10;
for (int i = 2, last = 9; i < n; i++) {
int cur = last * (10 - i + 1);
ans += cur; last = cur;
}
return ans;
}
public int countNumbersWithUniqueDigits(int n) {
return dp((int)Math.pow(10, n) - 1);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.357` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/361-370/363. 矩形区域不超过 K 的最大数值和（困难）.md | 363. 矩形区域不超过 K 的最大数值和 | https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-dh8s/ | 困难 | [
"二分",
"前缀和"
] | 给你一个 `m x n` 的矩阵 `matrix` 和一个整数 $k$ ,找出并返回矩阵内部矩形区域的不超过 $k$ 的最大数值和。
题目数据保证总会存在一个数值和不超过 $k$ 的矩形区域。
示例 1:
```
输入:matrix = [[1,0,1],[0,-2,3]], k = 2
输出:2
解释:蓝色边框圈出来的矩形区域 [[0, 1], [-2, 3]] 的数值和是 2,且 2 是不超过 k 的最大数字(k = 2)。
```
示例 2:
```
输入:matrix = [[2,2,-1]], k = 3
输出:3
```
提示:
* $m == matrix.length$
* $n == matrix[i].length$
* $1 <= m, n <= 100$
* $-100 <= matrix[i][j] <= 100$
* -$10^5 <= k <= 10^5$ | ### 朴素二维前缀和
从题面来看显然是一道「二维前缀和」的题目,如果你还不了解「二维前缀和」,可以看看 [(题解)304. 二维区域和检索 - 矩阵不可变](https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/)。本题预处理前缀和的复杂度为 $O(m * n)$。
搜索所有子矩阵需要枚举「矩形左上角」和「矩形右下角」,复杂度是 $O(m^2 * n^2)$。
因此,如果把本题当做二维前缀和模板题来做的话,整体复杂度是 $O(m^2 * n^2)$。
数据范围是 $10^2$,对应的计算量是 $10^8$,理论上会超时,但当我们枚举「矩形左上角」$(i,j)$ 的时候,我们只需要搜索位于 $(i,j)$ 的右下方的点 $(p,q)$ 作为「矩形右下角」,所以其实我们是取不满 $m^2 * n^2$ 的,但仍然具有超时风险(2021/04/20 Java 测试可通过,C++ 使用 `vector` 会 TLE)。
Java 代码:
```Java
class Solution {
public int maxSumSubmatrix(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
int[][] sum = new int[m + 1][n + 1];
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];
}
}
int ans = Integer.MIN_VALUE;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int p = i; p <= m; p++) {
for (int q = j; q <= n; q++) {
int cur = sum[p][q] - sum[i - 1][q] - sum[p][j - 1] + sum[i - 1][j - 1];
if (cur <= k) {
ans = Math.max(ans, cur);
}
}
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
int sum[110][110];
class Solution {
public:
int maxSumSubmatrix(vector<vector<int>>& mat, int k) {
int m = mat.size(), n = mat[0].size();
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];
}
}
int ans = INT_MIN;
for(int i = 1; i <= m; i++){
for(int j = 1; j <= n; j++){
for(int p = i; p <= m; p++){
for(int q = j; q <= n; q++){
int cur = sum[p][q] - sum[i - 1][q] - sum[p][j - 1] + sum[i - 1][j - 1];
if(cur <= k){
ans = max(ans,cur);
}
}
}
}
}
return ans;
}
};
```
* 时间复杂度:预处理前缀和数组复杂度为 $O(m * n)$,查找答案的复杂度为 $O(m^2 * n^2)$。整体复杂度为 $O(m^2 * n^2)$。
* 空间复杂度:$O(m * n)$
---
### 前缀和 & 二分(抽象一维)
我们来细想一下「朴素二维前缀和」解法是如何搜索答案(子矩阵):**通过枚举「左上角」&「右下角」来唯一确定某个矩阵**。
**换句话说是通过枚举 $(i,j)$ 和 $(p,q)$ 来唯一确定子矩阵的四条边,每个坐标点可以看作确定子矩阵的某条边。**
既然要确定的边有四条,我们可以如何降低复杂度呢?
简单的,我们先思考一下同样是枚举的 [1. 两数之和](https://leetcode-cn.com/problems/two-sum/) 问题。
在 [1. 两数之和](https://leetcode-cn.com/problems/two-sum/) 中可以暴力枚举两个数,也可以只枚举其中一个数,然后使用数据结构(哈希表)来加速找另一个数(这是一个通用的「降低枚举复杂度」思考方向)。
对应到本题,我们可以枚举其中三条边,然后使用数据结构来加速找第四条边。
当我们确定了三条边(红色)之后,形成的子矩阵就单纯取决于第四条边的位置(黄色):
于是问题转化为「**如何快速求得第四条边(黄色)的位置在哪**」。
我们可以进一步将问题缩小,考虑矩阵只有一行(一维)的情况:
这时候问题进一步转化为「**在一维数组中,求解和不超过 K 的最大连续子数组之和**」。
对于这个一维问题,我们可以先预处理出「前缀和」,然后枚举子数组的左端点,然后通过「二分」来求解其右端点的位置。
假定我们已经求得一维数组的前缀和数组 `sum`,即可得下标范围 $[i,j]$ 的和为:
$$areaSum(i, j) = sum[j] - sum[i - 1] \leqslant k$$
经过变形后得:
$$sum[j] \leqslant k + sum[i - 1]$$
我们有两种思路来最大化 $areaSum(i, j)$:
* 确定(枚举)左端点位置 `i`,求得符合条件的最大右端点 `sum[j]`
* 确定(枚举)右端点位置 `j`,求得符合条件的最小左端点 `sum[i]`
**对于没有负权值的一维数组,我们可以枚举左端点 `i`,同时利用前缀和的「单调递增」特性,通过「二分」找到符合 $sum[j] \leqslant k + sum[i - 1]$ 条件的最大值 `sum[j]`,从而求解出答案。**
**但是如果是含有负权值的话,前缀和将会丢失「单调递增」的特性,我们也就无法使用枚举 `i` 并结合「二分」查找 `j` 的做法。**
**这时候需要将过程反过来处理:我们从左到右枚举 `j`,并使用「有序集合」结构维护遍历过的位置,找到符合 $sum[j] - k \leqslant sum[i]$ 条件的最小值 `sum[i]`,从而求解出答案。**
基于上述分析,解决这样的一维数组问题复杂度是 $O(n\log{n})$ 的。
将这样的思路应用到二维需要一点点抽象能力。
同时,将一维思路应用到本题(二维),复杂度要么是 $O(m^2 * n\log{n})$ 要么是 $O(n^2 * m\log{m})$。
我们先不考虑「最大化二分收益」问题,先假设我们是固定枚举「上下行」和「右边列」,这时候唯一能够确定一个子矩阵则是取决于「左边列」:
**重点是如何与「一维」问题进行关联:显然「目标子矩阵的和」等于「子矩阵的右边列 与 原矩阵的左边列 形成的子矩阵和」-「子矩阵左边列 与 原矩阵左边列 形成的子矩阵和」**
我们可以使用 `area[r]` 代表「**子矩阵的右边列 与 原矩阵的左边列 形成的子矩阵和**」,使用 `area[l - 1]` 代表「**子矩阵的左边列 与 原矩阵的左边列 形成的子矩阵和**」的话,则有:
$$
target = area[r] - area[l - 1] \leqslant k
$$
这与我们「一维问题」完全一致,同时由「上下行」&「右边列」可以直接确定 `area[r]` 的大小,通过「有序集合」存储我们遍历 `r` 过程中的所有的 `area[r]` 从而实现「二分」查找符合 $area[r] - k \leqslant area[l - 1]$ 条件的 **最小** 的 `area[l - 1]`。
至此,我们通过预处理前缀和 + 容斥原理彻底将题目转化为「一维问题」进行来求解。
Java 代码:
```Java
class Solution {
public int maxSumSubmatrix(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
// 预处理前缀和
int[][] sum = new int[m + 1][n + 1];
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];
}
}
int ans = Integer.MIN_VALUE;
// 遍历子矩阵的上边界
for (int top = 1; top <= m; top++) {
// 遍历子矩阵的下边界
for (int bot = top; bot <= m; bot++) {
// 使用「有序集合」维护所有遍历到的右边界
TreeSet<Integer> ts = new TreeSet<>();
ts.add(0);
// 遍历子矩阵的右边界
for (int r = 1; r <= n; r++) {
// 通过前缀和计算 right
int right = sum[bot][r] - sum[top - 1][r];
// 通过二分找 left
Integer left = ts.ceiling(right - k);
if (left != null) {
int cur = right - left;
ans = Math.max(ans, cur);
}
// 将遍历过的 right 加到有序集合
ts.add(right);
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxSumSubmatrix(vector<vector<int>>& mat, int k) {
int m = mat.size(), n = mat[0].size();
vector<vector<int>> sum(m + 1,vector<int>(n + 1,0));
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];
}
}
int ans = INT_MIN;
for(int top = 1; top <= m; top++){
for(int bot = top; bot <= m; bot++){
set<int> st;
st.insert(0);
for(int r = 1; r <= n; r++){
int right = sum[bot][r] - sum[top - 1][r];
auto left = st.lower_bound(right - k);
if(left != st.end()){
int cur = right - *left;
ans = max(ans,cur);
}
st.insert(right);
}
}
}
return ans;
}
};
```
* 时间复杂度:枚举上下边界复杂度为 $O(m^2)$;枚举右边界为 $O(n)$,使用 `TreeSet`(基于红黑树)存储和查找左边界复杂度为 $O(\log{n})$。整体复杂度为 $O(m^2 * n\log{n})$
* 空间复杂度:$O(m * n)$
---
### 最大化「二分」效益
上述解法中,我们先枚举的是「上下行」和「右边列」,然后通过 `TreeSet` 来「二分」出符合条件的「左边列」。
事实上,我们需要将「二分过程」应用到数值较大的行或者列之中,这样才能最大化我们查找的效率(同时也回答了本题的进阶部分)。
Java 代码:
```Java
class Solution {
public int maxSumSubmatrix(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
int[][] sum = new int[m + 1][n + 1];
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];
}
}
// 固定的是否为右边界
boolean isRight = n > m;
int ans = Integer.MIN_VALUE;
for (int i = 1; i <= (isRight ? m : n); i++) {
for (int j = i; j <= (isRight ? m : n); j++) {
TreeSet<Integer> ts = new TreeSet<>();
ts.add(0);
for (int fixed = 1; fixed <= (isRight ? n : m); fixed++) {
int a = isRight ? sum[j][fixed] - sum[i - 1][fixed] : sum[fixed][j] - sum[fixed][i - 1];
Integer b = ts.ceiling(a - k);
if (b != null) {
int cur = a - b;
ans = Math.max(ans, cur);
}
ts.add(a);
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxSumSubmatrix(vector<vector<int>>& mat, int k) {
int m = mat.size(), n = mat[0].size();
vector<vector<int>> sum(m + 1,vector<int>(n + 1,0));
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];
}
}
bool isRight = n > m;
int ans = INT_MIN;
for(int i = 1; i <= (isRight ? m : n); i++){
for(int j = i; j <= (isRight ? m : n); j++){
set<int> st;
st.insert(0);
for(int fixed = 1; fixed <= (isRight ? n : m); fixed++){
int a = isRight ? sum[j][fixed] - sum[i - 1][fixed] : sum[fixed][j] - sum[fixed][i - 1];
auto b = st.lower_bound(a - k);
if(b != st.end()){
int cur = a - *b;
ans = max(ans,cur);
}
st.insert(a);
}
}
}
return ans;
}
};
```
* 时间复杂度:预处理「每行」或「每列」的前缀和,复杂度为 $O(m * n)$;枚举子矩阵的「上下行」或「左右行」,复杂度为 $O(\min(m, n)^2)$;结合二维前缀和套用一维最大连续子数组解决方案,复杂度为$\max(m, n)\log{\max(m, n)}$。整体复杂度为 $O(\min(m, n)^2 * \max(m, n)\log{\max(m, n)})$
* 空间复杂度:$O(m * n)$
---
### 空间优化
不难发现,我们在原矩阵搜索目标子矩阵的过程是严格的「从上到下」&「从左到右」的。
因此我们可以将计算前缀和的逻辑下放到搜索子矩阵的循环里去做,从而将 $O(m * n)$ 的空间复杂度下降到 $O(\max(m,n))$。
Java 代码:
```Java
class Solution {
public int maxSumSubmatrix(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
boolean isRight = n > m;
int[] sum = isRight ? new int[n + 1] : new int[m + 1];
int ans = Integer.MIN_VALUE;
for (int i = 1; i <= (isRight ? m : n); i++) {
Arrays.fill(sum, 0);
for (int j = i; j <= (isRight ? m : n); j++) {
TreeSet<Integer> ts = new TreeSet<>();
ts.add(0);
int a = 0;
for (int fixed = 1; fixed <= (isRight ? n : m); fixed++) {
sum[fixed] += isRight ? mat[j - 1][fixed - 1] : mat[fixed - 1][j - 1] ;
a += sum[fixed];
Integer b = ts.ceiling(a - k);
if (b != null) {
int cur = a - b;
ans = Math.max(ans, cur);
}
ts.add(a);
}
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxSumSubmatrix(vector<vector<int>>& mat, int k) {
int m = mat.size(), n = mat[0].size();
bool isRight = n > m;
vector<int> sum((isRight ? n + 1 : m + 1), 0);
int ans = INT_MIN;
for(int i = 1; i <= (isRight ? m : n); i++){
fill(sum.begin(),sum.end(),0);
for(int j = i; j <= (isRight ? m : n); j++){
set<int> st;
st.insert(0);
int a = 0;
for(int fixed = 1; fixed <= (isRight ? n : m); fixed++){
sum[fixed] += isRight ? mat[j - 1][fixed - 1] : mat[fixed - 1][j - 1];
a += sum[fixed];
auto b = st.lower_bound(a - k);
if(b != st.end()){
int cur = a - *b;
ans = max(ans,cur);
}
st.insert(a);
}
}
}
return ans;
}
};
```
* 时间复杂度:预处理「每行」或「每列」的前缀和,复杂度为 $O(m * n)$;枚举子矩阵的「上下行」或「左右行」,复杂度为 $O(\min(m, n)^2)$;结合二维前缀和套用一维最大连续子数组解决方案,复杂度为$\max(m, n)\log{max(m, n)}$。整体复杂度为 $O(\min(m, n)^2 * \max(m, n)\log{\max(m, n)})$
* 空间复杂度:$O(\max(m, n))$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.363` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/361-370/367. 有效的完全平方数（简单）.md | 367. 有效的完全平方数 | https://leetcode-cn.com/problems/valid-perfect-square/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-g5el/ | 简单 | [
"二分",
"数学"
] | 给定一个 正整数 $num$ ,编写一个函数,如果 $num$ 是一个完全平方数,则返回 $true$ ,否则返回 $false$ 。
进阶:不要使用任何内置的库函数,如 `sqrt`。
示例 1:
```
输入:num = 16
输出:true
```
示例 2:
```
输入:num = 14
输出:false
```
提示:
* $1 <= num <= 2^{31} - 1$ | ### 二分
假如答案为 $ans$,那么以 $ans$ 为分割点的数轴上具有二段性:
* 小于 $ans$ 的一段 $x$ 必然不满足 $x * x \geq num$;
* 大于等于 $ans$ 的一段 $x$ 必然满足 $x * x \geq num$。
因此可以通过「二分」来找到分割点 $ans$。
代码:
```Java
class Solution {
public boolean isPerfectSquare(int num) {
long l = 0, r = num;
while (l < r) {
long mid = l + r + 1 >> 1;
if (mid * mid <= num) l = mid;
else r = mid - 1;
}
return r * r == num;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 数学
我们知道对于一个完全平方数而言,可以写成如下形式:
$$
num = n^2 = 1 + 3 + 5 + ... + (2 * n - 1)
$$
因此另外一种做法是对 $num$ 进行不断的奇数试减,如果最终能够减到 $0$,说明 $num$ 可展开成如 $1+3+5+...+(2*n-1)$ 的形式,$num$ 为完全平方数。
代码:
```Java
class Solution {
public boolean isPerfectSquare(int num) {
int x = 1;
while (num > 0) {
num -= x;
x += 2;
}
return num == 0;
}
}
```
* 时间复杂度:$O(\sqrt{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.367` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/361-370/368. 最大整除子集（中等）.md | 368. 最大整除子集 | https://leetcode-cn.com/problems/largest-divisible-subset/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-0a3jc/ | 中等 | [
"序列 DP"
] | 给你一个由 无重复 正整数组成的集合 nums ,请你找出并返回其中最大的整除子集 answer ,子集中每一元素对 (answer[i], answer[j]) 都应当满足:
* answer[i] % answer[j] == 0 ,或
* answer[j] % answer[i] == 0
如果存在多个有效解子集,返回其中任何一个均可。
示例 1:
```
输入:nums = [1,2,3]
输出:[1,2]
解释:[1,3] 也会被视为正确答案。
```
示例 2:
```
输入:nums = [1,2,4,8]
输出:[1,2,4,8]
```
提示:
* 1 <= nums.length <= 1000
* 1 <= nums[i] <= 2 * $10^9$
* nums 中的所有整数 互不相同 | ### 基本分析
根据题意:**对于符合要求的「整除子集」中的任意两个值,必然满足「较大数」是「较小数」的倍数。**
数据范围是 $10^3$,我们不可能采取获取所有子集,再检查子集是否合法的爆搜解法。
通常「递归」做不了,我们就往「递推」方向去考虑。
**由于存在「整除子集」中任意两个值必然存在倍数/约数关系的性质,我们自然会想到对 `nums` 进行排序,然后从集合 `nums` 中从大到小进行取数,每次取数只考虑当前决策的数是否与「整除子集」中的最后一个数成倍数关系即可。**
这时候你可能会想枚举每个数作为「整除子集」的起点,然后从前往后遍历一遍,每次都将符合「与当前子集最后一个元素成倍数」关系的数加入答案。
举个🌰,假设有原数组 `[1,2,4,8]`,“或许”我们期望的决策过程是:
1. 遍历到数字 `1`,此时「整除子集」为空,加到「整除子集」中;
2. 遍历到数字 `2`,与「整除子集」的最后一个元素(`1`)成倍数关系,加到「整除子集」中;
3. 遍历到数字 `4`,与「整除子集」的最后一个元素(`2`)成倍数关系,自然也与 `2` 之前的元素成倍数关系,加到「整除子集」中;
4. 遍历到数字 `8`,与「整除子集」的最后一个元素(`4`)成倍数关系,自然也与 `4` 之前的元素成倍数关系,加到「整除子集」中。
**但这样的做法只能够确保得到「合法解」,无法确保得到的是「最长整除子集」**。
当时担心本题数据太弱,上述错误的解法也能够通过,所以还特意实现了一下,还好被卡住了(🤣
同时也得到这个反例:`[9,18,54,90,108,180,360,540,720]`,如果按照我们上述逻辑,我们得到的是 `[9,18,54,108,540]` 答案(长度为 5),但事实上存在更长的「整除子集」: `[9,18,90,180,360,720]`(长度为 6)。
**其本质是因为同一个数的不同倍数之间不存在必然的「倍数/约数关系」,而只存在「具有公约数」的性质,这会导致我们「模拟解法」错过最优解。**
比如上述 🌰,`54` & `90` 和 `18` 存在倍数关系,但两者本身不存在倍数关系。
因此当我们决策到某一个数 `nums[i]` 时(`nums` 已排好序),我们无法直接将 `nums[i]` 直接接在符合「约数关系」的、最靠近位置 `i` 的数后面,而是要**检查位置 `i` 前面的所有符合「约数关系」的位置,找一个已经形成「整除子集」长度最大的数**。
**换句话说,当我们对 `nums` 排好序并从前往后处理时,在处理到 `nums[i]` 时,我们希望知道位置 `i` 之前的下标已经形成的「整除子集」长度是多少,然后从中选一个最长的「整除子集」,将 `nums[i]` 接在后面(前提是符合「倍数关系」)。**
---
### 动态规划
基于上述分析,我们不难发现这其实是一个序列 DP 问题:**某个状态的转移依赖于与前一个状态的关系。即 `nums[i]` 能否接在 `nums[j]` 后面,取决于是否满足 `nums[i] % nums[j] == 0` 条件。**
可看做是「最长上升子序列」问题的变形题。
**定义 $f[i]$ 为考虑前 `i` 个数字,且以第 `i` 个数为结尾的最长「整除子集」长度。**
我们不失一般性的考虑任意位置 `i`,存在两种情况:
* 如果在 `i` 之前找不到符合条件 `nums[i] % nums[j] == 0` 的位置 `j`,那么 `nums[i]` 不能接在位置 `i` 之前的任何数的后面,只能自己独立作为「整除子集」的第一个数,此时状态转移方程为 $f[i] = 1$;
* 如果在 `i` 之前能够找到符合条件的位置 `j`,则取所有符合条件的 `f[j]` 的最大值,代表如果希望找到以 `nums[i]` 为结尾的最长「整除子集」,需要将 `nums[i]` 接到符合条件的最长的 `nums[j]` 后面,此时状态转移方程为 $f[i] = f[j] + 1$。
同时由于我们需要输出具体方案,需要额外使用 `g[]` 数组来记录每个状态是由哪个状态转移而来。
**定义 $g[i]$ 为记录 $f[i]$ 是由哪个下标的状态转移而来,如果 $f[i] = f[j] + 1$, 则有 $g[i] = j$。**
对于求方案数的题目,多开一个数组来记录状态从何转移而来是最常见的手段。
当我们求得所有的状态值之后,可以对 `f[]` 数组进行遍历,取得具体的最长「整除子集」长度和对应下标,然后使用 `g[]` 数组进行回溯,取得答案。
代码:
```Java
class Solution {
public List<Integer> largestDivisibleSubset(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
int[] f = new int[n];
int[] g = new int[n];
for (int i = 0; i < n; i++) {
// 至少包含自身一个数,因此起始长度为 1,由自身转移而来
int len = 1, prev = i;
for (int j = 0; j < i; j++) {
if (nums[i] % nums[j] == 0) {
// 如果能接在更长的序列后面,则更新「最大长度」&「从何转移而来」
if (f[j] + 1 > len) {
len = f[j] + 1;
prev = j;
}
}
}
// 记录「最终长度」&「从何转移而来」
f[i] = len;
g[i] = prev;
}
// 遍历所有的 f[i],取得「最大长度」和「对应下标」
int max = -1, idx = -1;
for (int i = 0; i < n; i++) {
if (f[i] > max) {
idx = i;
max = f[i];
}
}
// 使用 g[] 数组回溯出具体方案
List<Integer> ans = new ArrayList<>();
while (ans.size() != max) {
ans.add(nums[idx]);
idx = g[idx];
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
---
### 证明
**之所以上述解法能够成立,问题能够转化为「最长上升子序列(LIS)」问题进行求解,本质是利用了「全序关系」中的「可传递性」。**
在 LIS 问题中,我们是利用了「关系运算符 $\geqslant$ 」的传递性,因此当我们某个数 `a` 能够接在 `b` 后面,只需要确保 $a \geqslant b$ 成立,即可确保 `a` 大于等于 `b` 之前的所有值。
那么同理,如果我们想要上述解法成立,我们还需要证明如下内容:
* #### 「倍数/约数关系」具有传递性
由于我们将 `nums[i]` 往某个数字后面接时(假设为 `nums[j]`),只检查了其与 `nums[j]` 的关系,并没有去检查 `nums[i]` 与 `nums[j]` 之前的数值是否具有「倍数/约数关系」。
换句话说,我们只确保了最终答案 `[a1, a2, a3, ..., an]` 相邻两数值之间具有「倍数/约数关系」,并不明确任意两值之间具有「倍数/约数关系」。
因此需要证得由 $a | b$ 和 $b | c$,可推导出 $a | c$ 的传递性:
由 $a | b$ 可得 $b = x * a$
由 $b | c$ 可得 $c = y * b$
最终有 $c = y * b = y * x * a$,由于 $x$ 和 $y$ 都是整数,因此可得 $a | c$。
得证「倍数/约数关系」具有传递性。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.368` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/371. 两整数之和（中等）.md | 371. 两整数之和 | https://leetcode-cn.com/problems/sum-of-two-integers/solution/gong-shui-san-xie-shi-yong-wei-yun-suan-4hpb7/ | 中等 | [
"位运算"
] | 给你两个整数 `a` 和 `b` ,不使用 运算符 `+` 和 `-`,计算并返回两整数之和。
示例 1:
```
输入:a = 1, b = 2
输出:3
```
示例 2:
```
输入:a = 2, b = 3
输出:5
```
提示:
* -1000 <= a, b <= 1000 | ### 位运算
一个朴素的做法是使用「位运算」,利用二进制的「逢二进一」和「`int` 二进制表示长度为 $32$」,我们可以从低位往高位进行处理,处理过程中使用变量 $t$ 记录进位信息。
然后对两数当前位进行分情况讨论:
* 两个当前位均为 $1$:此时当前位是什么取决于前一位的进位情况,即有 `ans |= (t << i)`,同时进位 $t = 1$;
* 两个当前位只有一位是 $1$:此时当前位是什么取决于前一位的进位情况(整理后可统一为 `ans |= ((1 ^ t) << i)`:
* 前一进位若为 $1$,结合该位为 $1$,则有当前位为 $0$,进位不变 $t = 1$;
* 前一进位若为 $0$,结合该位为 $1$,则有当前位为 $1$,进位不变 $t = 0$;
* 两个当前位为 $0$:此时当前位是什么取决于前一位的进位情况,则有 `ans |= (t << i)`,同时进位 $t = 0$。
代码:
```Java
class Solution {
public int getSum(int a, int b) {
int ans = 0;
for (int i = 0, t = 0; i < 32; i++) {
int u1 = (a >> i) & 1, u2 = (b >> i) & 1;
if (u1 == 1 && u2 == 1) {
ans |= (t << i);
t = 1;
} else if (u1 == 1 || u2 == 1) {
ans |= ((1 ^ t) << i);
} else {
ans |= (t << i);
t = 0;
}
}
return ans;
}
}
```
* 时间复杂度:$O(C)$,$C$ 为常数,固定为 $32$
* 空间复杂度:$O(1)$
---
### 递归
在彻底理解「解法一」后,不难发现「解法一」中本质是分别对两数的当前位进行“拆分”求解。
先计算原始的 $a$ 的和原始 $b$ 在不考虑进位的情况下的结果,结果为 `a ^ b`,然后在此基础上,考虑将进位累加进来,累加操作可以递归使用 `getSum` 来处理。
问题转化为如何求得 $a$ 和 $b$ 的进位值。
不难发现,当且仅当 $a$ 和 $b$ 的当前位均为 $1$,该位才存在进位,同时进位回应用到当前位的下一位(左边的一边,高一位),因此最终的进位结果为 `(a & b) << 1`。
因此,递归调用 `getSum(a ^ b, (a & b) << 1)` 我们可以得到最终答案。
最后还要考虑,该拆分过程何时结束。
由于在进位结果 `(a & b) << 1` 中存在左移操作,因此最多执行 $32$ 次的递归操作之后,该值会变为 $0$,而 $0$ 与任何值 $x$ 相加结果均为 $x$。
代码:
```Java
class Solution {
public int getSum(int a, int b) {
return b == 0 ? a : getSum(a ^ b, (a & b) << 1);
}
}
```
* 时间复杂度:令 $C$ 为常数,固定为 $32$,最多执行 $C$ 次的 `(a & b) << 1`,递归过程结束。复杂度为 $O(C)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.371` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/372. 超级次方（中等）.md | 372. 超级次方 | https://leetcode-cn.com/problems/super-pow/solution/gong-shui-san-xie-di-gui-kuai-su-mi-ying-yx1j/ | 中等 | [
"数学",
"快速幂"
] | 你的任务是计算 `ab` 对 $1337$ 取模,`a` 是一个正整数,`b` 是一个非常大的正整数且会以数组形式给出。
示例 1:
```
输入:a = 2, b = [3]
输出:8
```
示例 2:
```
输入:a = 2, b = [1,0]
输出:1024
```
示例 3:
```
输入:a = 1, b = [4,3,3,8,5,2]
输出:1
```
示例 4:
```
输入:a = 2147483647, b = [2,0,0]
输出:1198
```
提示:
* $1 <= a <= 2^{31} - 1$
* $1 <= b.length <= 2000$
* $0 <= b[i] <= 9$
* b 不含前导 0 | ### 递归 + 快速幂(可选)
根据题意,要我们求得的是 $a^b \bmod {1337}$ 的值,其中 $b$ 是以数组形式给出。
刚一看是一道快速幂的题目(事实上也确实可以使用快速幂,但不是必须),由于 $b$ 是数组形式,因此我们还需要对其进行分解。
假设 $b$ 所代表的数值为 $K$,则有:
$$
a^{K} = a^{(\left \lfloor \frac{K}{10} \right \rfloor * 10) + (K \bmod 10)} = a^{(\left \lfloor \frac{K}{10} \right \rfloor * 10)} * a^{(K \bmod 10)} = ({a^{\left \lfloor \frac{K}{10} \right \rfloor}) ^ {10}} * a^{(K \bmod 10)}
$$
也就是说,我们每次只需要计算 $b$ 数组的最后一位作为次方的值即可将问题规模缩小。
上述公式可能不好直接理解,举个🌰,设我们的 $a$ 为 $99$,要计算的 $b$ 数组所代表的数值为 $K = 2345$,那么其计算过程可以分解为:
0. $a^K = 99^{2345}$
1. $99^{2345} = 99^{234 * 10 + 5}$
2. $99^{234 * 10 + 5} = 99^{234 * 10} * 99^{5}$
3. $99^{234 * 10} * 99^{5} = {(99^{234})}^{10} * 99^{5}$
...
可见,真正涉及计算次方的操作,所用到的次方都是一个 $10$ 以内的数字,因此并非一定要使用快速幂。
代码($P2$ 为不使用快速幂):
```Java
class Solution {
int MOD = 1337;
public int superPow(int a, int[] b) {
return dfs(a, b, b.length - 1);
}
int dfs(int a, int[] b, int u) {
if (u == -1) return 1;
return qpow(dfs(a, b, u - 1), 10) * qpow(a, b[u]) % MOD;
}
int qpow(int a, int b) {
int ans = 1;
a %= MOD;
while (b != 0) {
if ((b & 1) != 0) ans = ans * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ans;
}
}
```
```Java
class Solution {
int MOD = 1337;
public int superPow(int a, int[] b) {
return dfs(a, b, b.length - 1);
}
int dfs(int a, int[] b, int u) {
if (u == -1) return 1;
return pow(dfs(a, b, u - 1), 10) * pow(a, b[u]) % MOD;
}
int pow(int a, int b) {
int ans = 1;
a %= MOD;
while (b-- > 0) ans = ans * a % MOD;
return ans;
}
}
```
* 时间复杂度:假设 $b$ 数组所代表的数字为 $K$,使用快速幂的复杂度为 $O(\log{K})$,或者说是 $O(n * \log{10})$,其中 $n$ 为数组 $b$ 的长度,数字 $10$ 所代表的含义是计算一个次方为 $10$ 以内的值;而不使用快速幂的复杂度为 $O(n * 10)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.372` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/373. 查找和最小的K对数字（中等）.md | 373. 查找和最小的K对数字 | https://leetcode-cn.com/problems/find-k-pairs-with-smallest-sums/solution/gong-shui-san-xie-duo-lu-gui-bing-yun-yo-pgw5/ | 中等 | [
"优先队列(堆)",
"二分",
"多路归并"
] | 给定两个以升序排列的整数数组 `nums1` 和 `nums2` , 以及一个整数 `k` 。
定义一对值 $(u,v)$,其中第一个元素来自 `nums1`,第二个元素来自 `nums2`。
请找到和最小的 `k` 个数对 $(u_1,v_1), (u_2,v_2) ... (u_k,v_k)$ 。
示例 1:
```
输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
输出: [1,2],[1,4],[1,6]
解释: 返回序列中的前 3 对数:
[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
```
示例 2:
```
输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2
输出: [1,1],[1,1]
解释: 返回序列中的前 2 对数:
[1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
```
示例 3:
```
输入: nums1 = [1,2], nums2 = [3], k = 3
输出: [1,3],[2,3]
解释: 也可能序列中所有的数对都被返回:[1,3],[2,3]
```
提示:
* $1 <= nums1.length, nums2.length <= 10^4$
* $-10^9 <= nums1[i], nums2[i] <= 10^9$
* $nums1, nums2 均为升序排列$
* $1 <= k <= 1000$ | ### 基本分析
这道题和 [(题解) 786. 第 K 个最小的素数分数](https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-8ymk/) 几乎是一模一样,先做哪一道都是一样的,难度上没有区别 🤣
最常规的做法是使用「多路归并」,还不熟悉「多路归并」的同学,建议先学习前置🧀:[多路归并入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490029&idx=1&sn=bba9ddff88d247db310406ee418d5a15&chksm=fd9cb2f2caeb3be4b1f84962677337dcb5884374e5b6b80340834eaff79298d11151da2dd5f7&token=252055586&lang=zh_CN#rd),里面讲述了如何从「朴素优先队列」往「多路归并」进行转换。
---
### 多路归并
令 $nums1$ 的长度为 $n$,$nums2$ 的长度为 $m$,所有的点对数量为 $n * m$。
其中每个 $nums1[i]$ 参与所组成的点序列为:
$$
[(nums1[0], nums2[0]), (nums1[0], nums2[1]), ..., (nums1[0], nums2[m - 1])]\\
[(nums1[1], nums2[0]), (nums1[1], nums2[1]), ..., (nums1[1], nums2[m - 1])]\\
...\\
[(nums1[n - 1], nums2[0]), (nums1[n - 1], nums2[1]), ..., (nums1[n - 1], nums2[m - 1])]\\
$$
由于 $nums1$ 和 $nums2$ 均已按升序排序,因此每个 $nums1[i]$ 参与构成的点序列也为升序排序,这引导我们使用「多路归并」来进行求解。
具体的,起始我们将这 $n$ 个序列的首位元素(点对)以二元组 $(i, j)$ 放入优先队列(小根堆),其中 $i$ 为该点对中 $nums1[i]$ 的下标,$j$ 为该点对中 $nums2[j]$ 的下标,这步操作的复杂度为 $O(n\log{n})$。这里也可以得出一个小优化是:我们始终确保 $nums1$ 为两数组中长度较少的那个,然后通过标识位来记录是否发生过交换,确保答案的点顺序的正确性。
每次从优先队列(堆)中取出堆顶元素(含义为当前未被加入到答案的所有点对中的最小值),加入答案,并将该点对所在序列的下一位(如果有)加入优先队列中。
举个 🌰,首次取出的二元组为 $(0, 0)$,即点对 $(nums1[0], nums2[0])$,取完后将序列的下一位点对 $(nums1[0], nums2[1])$ 以二元组 $(0, 1)$ 形式放入优先队列。
可通过「反证法」证明,每次这样的「取当前,放入下一位」的操作,可以确保当前未被加入答案的所有点对的最小值必然在优先队列(堆)中,即前 $k$ 个出堆的元素必然是所有点对的前 $k$ 小的值。
Java 代码:
```Java
class Solution {
boolean flag = true;
public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
List<List<Integer>> ans = new ArrayList<>();
int n = nums1.length, m = nums2.length;
if (n > m && !(flag = false)) return kSmallestPairs(nums2, nums1, k);
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->(nums1[a[0]]+nums2[a[1]])-(nums1[b[0]]+nums2[b[1]]));
for (int i = 0; i < Math.min(n, k); i++) q.add(new int[]{i, 0});
while (ans.size() < k && !q.isEmpty()) {
int[] poll = q.poll();
int a = poll[0], b = poll[1];
ans.add(new ArrayList<>(){{
add(flag ? nums1[a] : nums2[b]);
add(flag ? nums2[b] : nums1[a]);
}});
if (b + 1 < m) q.add(new int[]{a, b + 1});
}
return ans;
}
}
```
Python3 代码:
```Python3
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
flag, ans = (n := len(nums1)) > (m := len(nums2)), []
if flag:
n, m, nums1, nums2 = m, n, nums2, nums1
pq = []
for i in range(min(n, k)):
heapq.heappush(pq, (nums1[i] + nums2[0], i, 0))
while len(ans) < k and pq:
_, a, b = heapq.heappop(pq)
ans.append([nums2[b], nums1[a]] if flag else [nums1[a], nums2[b]])
if b + 1 < m:
heapq.heappush(pq, (nums1[a] + nums2[b + 1], a, b + 1))
return ans
```
Golang 代码:
```Golang
func kSmallestPairs(nums1 []int, nums2 []int, k int) [][]int {
n, m, ans := len(nums1), len(nums2), [][]int{}
flag := n > m
if flag {
n, m, nums1, nums2 = m, n, nums2, nums1
}
if n > k {
n = k
}
pq := make(hp, n)
for i := 0; i < n; i++ {
pq[i] = []int{nums1[i] + nums2[0], i, 0}
}
heap.Init(&pq)
for pq.Len() > 0 && len(ans) < k {
poll := heap.Pop(&pq).([]int)
a, b := poll[1], poll[2]
if flag{
ans = append(ans, []int{nums2[b], nums1[a]})
}else{
ans = append(ans, []int{nums1[a], nums2[b]})
}
if b < m - 1 {
heap.Push(&pq, []int{nums1[a] + nums2[b + 1], a, b + 1})
}
}
return ans
}
// 最小堆模板
type hp [][]int
func (h hp) Len() int { return len(h) }
func (h hp) Less(i, j int) bool { return h[i][0] < h[j][0] }
func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v interface{}) { *h = append(*h, v.([]int)) }
func (h *hp) Pop() interface{} { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
```
* 时间复杂度:令 $M$ 为 $n$、$m$ 和 $k$ 三者中的最小值,复杂度为 $O(M + k) \times \log{M})$
* 空间复杂度:$O(M)$
---
### 二分
我们还能够使用多次「二分」来做。
假设我们将所有「数对和」按照升序排序,两端的值分别为 $l = nums1[0] + nums2[0]$ 和 $r = nums1[n - 1] + nums2[m - 1]$。
因此我们可以在值域 $[l, r]$ 上进行二分,找到第一个满足「点对和小于等于 $x$ 的,且数量超过 $k$ 的值 $x$」。
之所以能够二分,是因为 $x$ 所在的点对和数轴上具有二段性:
* 点对和小于 $x$ 的点对数量少于 $k$ 个;
* 点对和大于等于 $x$ 的点对数量大于等于 $k$ 个。
判定小于等于 $x$ 的点对数量是否大于等于 $k$ 个这一步可直接使用循环来做,由于二分是从中间值开始,这一步不会出现跑满两层循环的情况。
当二分出第 $k$ 小的值为 $x$ 后,由于存在不同点对的点对和值相等,我们需要先将所有点对和小于等于 $x$ 的值加入答案,然后酌情把值等于 $x$ 的点对加入答案,知道满足答案数量为 $k$。
找值为 $x$ 的所有点对这一步,可以通过枚举 $nums1[i]$,然后在 $nums2$ 上二分目标值 $x - nums1[i]$ 的左右端点来做。
最后,在所有处理过程中,我们都可以利用答案数组的大小与 $k$ 的关系做剪枝。
Java 代码:
```Java
class Solution {
int[] nums1, nums2;
int n, m;
public List<List<Integer>> kSmallestPairs(int[] n1, int[] n2, int k) {
nums1 = n1; nums2 = n2;
n = nums1.length; m = nums2.length;
List<List<Integer>> ans = new ArrayList<>();
int l = nums1[0] + nums2[0], r = nums1[n - 1] + nums2[m - 1];
while (l < r) {
int mid = (int)(0L + l + r >> 1);
if (check(mid, k)) r = mid;
else l = mid + 1;
}
int x = r;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (nums1[i] + nums2[j] < x) {
List<Integer> temp = new ArrayList<>();
temp.add(nums1[i]); temp.add(nums2[j]);
ans.add(temp);
} else break;
}
}
for (int i = 0; i < n && ans.size() < k; i++) {
int a = nums1[i], b = x - a;
int c = -1, d = -1;
l = 0; r = m - 1;
while (l < r) {
int mid = (int)(0L + l + r >> 1);
if (nums2[mid] >= b) r = mid;
else l = mid + 1;
}
if (nums2[r] != b) continue;
c = r;
l = 0; r = m - 1;
while (l < r) {
int mid = (int)(0L + l + r + 1) >> 1;
if (nums2[mid] <= b) l = mid;
else r = mid - 1;
}
d = r;
for (int p = c; p <= d && ans.size() < k; p++) {
List<Integer> temp = new ArrayList<>();
temp.add(a); temp.add(b);
ans.add(temp);
}
}
return ans;
}
boolean check(int x, int k) {
int ans = 0;
for (int i = 0; i < n && ans < k; i++) {
for (int j = 0; j < m && ans < k; j++) {
if (nums1[i] + nums2[j] <= x) ans++;
else break;
}
}
return ans >= k;
}
}
```
* 时间复杂度:假设点对和的值域大小范围为 $M$,第一次二分的复杂度为 $O((n \times m) \times \log{M})$;统计点对和值小于目标值 $x$ 的复杂度为 $O(n \times m)$;统计所有点对和等于目标值的复杂度为 $O(\max(n \times \log{m}, k))$(整个处理过程中利用了大小关系做了剪枝,大多循环都不会跑满,实际计算量会比理论分析的要低)
* 空间复杂度:$O(k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.373` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/374. 猜数字大小（简单）.md | 374. 猜数字大小 | https://leetcode-cn.com/problems/guess-number-higher-or-lower/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-tocm/ | 简单 | [
"二分"
] | 猜数字游戏的规则如下:
* 每轮游戏,我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
* 如果你猜错了,我会告诉你,你猜测的数字比我选出的数字是大了还是小了。
你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果,返回值一共有 3 种可能的情况(-1,1 或 0):
* -1:我选出的数字比你猜的数字小 pick < num
* 1:我选出的数字比你猜的数字大 pick > num
* 0:我选出的数字和你猜的数字一样。恭喜!你猜对了!pick == num
返回我选出的数字。
示例 1:
```
输入:n = 10, pick = 6
输出:6
```
示例 2:
```
输入:n = 1, pick = 1
输出:1
```
示例 3:
```
输入:n = 2, pick = 1
输出:1
```
示例 4:
```
输入:n = 2, pick = 2
输出:2
```
提示:
* 1 <= n <= $2^{31}$ - 1
* 1 <= pick <= n | ### 二分
端午安康呀 🍭🍭🍭
今天的题目表达不太好 🤣,还是逐字阅读才明白是啥意思 🤣
就当做是因为题目本身要比 [278. 第一个错误的版本](https://leetcode-cn.com/problems/first-bad-version/) 简单(不需要考虑完全相同,没有二段性的情况),所以在阅读上增加了难度吧 🤣
一道交互题,根据题意可知,是尽可能少调用 `guess` 方法来找到分割点。
直接使用 `guess` 当做 `check` 函数进行二分即可。
另外根据数据范围需要注意计算 `mid` 时的爆 `int` 问题,可以通过使用类似 `l + (r - l) / 2` 的做法解决,也可以通过一个临时 `long` 来解决。
代码:
```Java
public class Solution extends GuessGame {
public int guessNumber(int n) {
int l = 1, r = n;
while (l < r) {
long tmp = (long)l + r >> 1;
int mid = (int)tmp;
if (guess(mid) <= 0) {
r = mid;
} else {
l = mid + 1;
}
}
return r;
}
}
```
```Java
public class Solution extends GuessGame {
public int guessNumber(int n) {
int l = 1, r = n;
while (l < r) {
long tmp = (long)l + r + 1 >> 1;
int mid = (int)tmp;
if (guess(mid) >= 0) {
l = mid;
} else {
r = mid - 1;
}
}
return r;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 其他「二分」相关题解
* 二分模板
[29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)
* 二分模板题
[278. 第一个错误的版本](https://leetcode-cn.com/problems/first-bad-version/) : [使用交互函数充当 check 进行二分](https://leetcode-cn.com/problems/first-bad-version/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-8hpv/)
[374. 猜数字大小](https://leetcode-cn.com/problems/guess-number-higher-or-lower/) : [使用交互函数充当 check 进行二分](https://leetcode-cn.com/problems/guess-number-higher-or-lower/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-tocm/)
* 二分本质 & 恢复二段性处理
[33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)
[81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)
[153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)
[154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)
* 二分 check 函数如何确定
[34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.374` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/375. 猜数字大小 II（中等）.md | 375. 猜数字大小 II | https://leetcode-cn.com/problems/guess-number-higher-or-lower-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-92e5/ | 中等 | [
"博弈论",
"区间 DP",
"记忆化搜索"
] | 我们正在玩一个猜数游戏,游戏规则如下:
1. 我从 `1` 到 `n` 之间选择一个数字。
2. 你来猜我选了哪个数字。
3. 如果你猜到正确的数字,就会 赢得游戏 。
4. 如果你猜错了,那么我会告诉你,我选的数字比你的 更大或者更小 ,并且你需要继续猜数。
5. 每当你猜了数字 `x` 并且猜错了的时候,你需要支付金额为 `x` 的现金。如果你花光了钱,就会 输掉游戏 。
给你一个特定的数字 `n` ,返回能够 确保你获胜 的最小现金数,不管我选择那个数字 。
示例 1:
```
输入:n = 10
输出:16
解释:制胜策略如下:
- 数字范围是 [1,10] 。你先猜测数字为 7 。
- 如果这是我选中的数字,你的总费用为 $0 。否则,你需要支付 $7 。
- 如果我的数字更大,则下一步需要猜测的数字范围是 [8,10] 。你可以猜测数字为 9 。
- 如果这是我选中的数字,你的总费用为 $7 。否则,你需要支付 $9 。
- 如果我的数字更大,那么这个数字一定是 10 。你猜测数字为 10 并赢得游戏,总费用为 $7 + $9 = $16 。
- 如果我的数字更小,那么这个数字一定是 8 。你猜测数字为 8 并赢得游戏,总费用为 $7 + $9 = $16 。
- 如果我的数字更小,则下一步需要猜测的数字范围是 [1,6] 。你可以猜测数字为 3 。
- 如果这是我选中的数字,你的总费用为 $7 。否则,你需要支付 $3 。
- 如果我的数字更大,则下一步需要猜测的数字范围是 [4,6] 。你可以猜测数字为 5 。
- 如果这是我选中的数字,你的总费用为 $7 + $3 = $10 。否则,你需要支付 $5 。
- 如果我的数字更大,那么这个数字一定是 6 。你猜测数字为 6 并赢得游戏,总费用为 $7 + $3 + $5 = $15 。
- 如果我的数字更小,那么这个数字一定是 4 。你猜测数字为 4 并赢得游戏,总费用为 $7 + $3 + $5 = $15 。
- 如果我的数字更小,则下一步需要猜测的数字范围是 [1,2] 。你可以猜测数字为 1 。
- 如果这是我选中的数字,你的总费用为 $7 + $3 = $10 。否则,你需要支付 $1 。
- 如果我的数字更大,那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏,总费用为 $7 + $3 + $1 = $11 。
在最糟糕的情况下,你需要支付 $16 。因此,你只需要 $16 就可以确保自己赢得游戏。
```
示例 2:
```
输入:n = 1
输出:0
解释:只有一个可能的数字,所以你可以直接猜 1 并赢得游戏,无需支付任何费用。
```
示例 3:
```
输入:n = 2
输出:1
解释:有两个可能的数字 1 和 2 。
- 你可以先猜 1 。
- 如果这是我选中的数字,你的总费用为 $0 。否则,你需要支付 $1 。
- 如果我的数字更大,那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏,总费用为 $1 。
最糟糕的情况下,你需要支付 $1 。
```
提示:
* 1 <= n <= 200 | ### 基本分析
这不是一道可通过「二分」求解的题目,主要原因为每次惩罚的金额不固定,最小惩罚次数不等同于猜中数字的最小成本。
---
### 记忆化搜索
比较容易想到的做法为使用「递归」进行求解。
设计递归函数为 `int dfs(int l, int r)` 传入参数 `l` 和 `r` 代表在范围 $[l, r]$ 内进行猜数,返回值为在 $[l, r]$ 内猜中数字至少需要多少钱。
**我们可决策的部分为「选择猜哪个数 $x$」,而不可决策的是「选择某个数 $x$ 之后(假设没有猜中),真实值会落在哪边」。**
因此为求得「最坏情况下最好」的结果,我们应当取所有的 $x$ 中的最小值。
最后,为减少重复计算,我们需要在「递归」基础上加入记忆化搜索。并且当我们使用 `static` 修饰 $cache$ 时,可以确保每个区间的计算在所有样例中只会发生一次。
代码:
```Java
class Solution {
static int N = 210;
static int[][] cache = new int[N][N];
public int getMoneyAmount(int n) {
return dfs(1, n);
}
int dfs(int l, int r) {
if (l >= r) return 0;
if (cache[l][r] != 0) return cache[l][r];
int ans = 0x3f3f3f3f;
for (int x = l; x <= r; x++) {
// 当选择的数位 x 时,至少需要 cur 才能猜中数字
int cur = Math.max(dfs(l, x - 1), dfs(x + 1, r)) + x;
// 在所有我们可以决策的数值之间取最优
ans = Math.min(ans, cur);
}
cache[l][r] = ans;
return ans;
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(n^2)$
---
### 区间 DP
同样能够通过「递推」来进行求解。
**通过「记忆化搜索」的递归过程,我们发现,在求解 $[l, r]$ 的最小成本时,需要依赖于 $[l, i - 1]$ 和 $[i + 1, r]$ 这样的比 $[l, r]$ 更小的区间。**
这引导我们使用「区间 DP」进行求解,对「区间 DP」不了解的同学可以先看 [「区间 DP」入门题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489400&idx=1&sn=0b629d3669329a6bf4f6ec71c2571ce7&chksm=fd9cbc67caeb357132fe0a1ca6240e2183748d94039100f539193d3eeb1dc223e0ddd4aa9584&token=2094656911&lang=zh_CN#rd) 。
**定义 $f[l][r]$ 为考虑在 $[l, r]$ 范围内进行猜数的最小成本。**
不失一般性的考虑 $f[l][r]$ 该如何计算。**同样的,我们可决策的部分为「选择猜哪个数 $x$」,而不可决策的是「选择某个数 $x$ 之后(假设没有猜中),真实值在落在哪边」。**
我们对本次选择哪个数进行讨论,假设本次选择的数值为 $x$ ( $l <= x <= r$ ),则有 $cur = \max(f[l][x - 1], f[x + 1][r]) + x$
最终的 $f[l][r]$ 为所有可选的数值 $x$ 中的最小值。
代码:
```Java
class Solution {
public int getMoneyAmount(int n) {
int[][] f = new int[n + 10][n + 10];
for (int len = 2; len <= n; len++) {
for (int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
f[l][r] = 0x3f3f3f3f;
for (int x = l; x <= r; x++) {
int cur = Math.max(f[l][x - 1], f[x + 1][r]) + x;
f[l][r] = Math.min(f[l][r], cur);
}
}
}
return f[1][n];
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n^2)$
---
### 打表
由于任意的 $[l,r]$ 对应结果均为定值,可以进行打表预处理。
代码:
```Java
class Solution {
static int N = 200;
static int[][] f = new int[N + 10][N + 10];
static {
for (int len = 2; len <= N; len++) {
for (int l = 1; l + len - 1 <= N; l++) {
int r = l + len - 1;
f[l][r] = 0x3f3f3f3f;
for (int x = l; x <= r; x++) {
int cur = Math.max(f[l][x - 1], f[x + 1][r]) + x;
f[l][r] = Math.min(f[l][r], cur);
}
}
}
}
public int getMoneyAmount(int n) {
return f[1][n];
}
}
```
* 时间复杂度:$O(C^3)$
* 空间复杂度:$O(C^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.375` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/371-380/380. O(1) 时间插入、删除和获取随机元素（中等）.md | 380. O(1) 时间插入、删除和获取随机元素 | https://leetcode-cn.com/problems/insert-delete-getrandom-o1/solution/by-ac_oier-tpex/ | 中等 | [
"数据结构",
"哈希表"
] | 实现 `RandomizedSet` 类:
* `RandomizedSet()` 初始化 `RandomizedSet` 对象
* `bool insert(int val)` 当元素 `val` 不存在时,向集合中插入该项,并返回 `true`;否则,返回 `false`。
* `bool remove(int val)` 当元素 `val` 存在时,从集合中移除该项,并返回 `true`;否则,返回 `false`。
* `int getRandom()` 随机返回现有集合中的一项(测试用例保证调用此方法时集合中至少存在一个元素)。每个元素应该有 相同的概率 被返回。
你必须实现类的所有函数,并满足每个函数的 平均 时间复杂度为 $O(1)$ 。
示例:
```
输入
["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
[[], [1], [2], [2], [], [1], [2], []]
输出
[null, true, false, true, 2, true, false, 2]
解释
RandomizedSet randomizedSet = new RandomizedSet();
randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomizedSet.remove(2); // 返回 false ,表示集合中不存在 2 。
randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
randomizedSet.remove(1); // 从集合中移除 1 ,返回 true 。集合现在包含 [2] 。
randomizedSet.insert(2); // 2 已在集合中,所以返回 false 。
randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字,getRandom 总是返回 2 。
```
提示:
* $-2^{31} <= val <= 2^{31} - 1$
* 最多调用 `insert`、`remove` 和 `getRandom` 函数 $2 * 10^5$ 次
* 在调用 `getRandom` 方法时,数据结构中 至少存在一个 元素。 | ### 哈希表 + 删除交换
对于 `insert` 和 `remove` 操作容易想到使用「哈希表」来实现 $O(1)$ 复杂度,但对于 `getRandom` 操作,比较理想的情况是能够在一个数组内随机下标进行返回。
将两者结合,我们可以将哈希表设计为:以入参 `val` 为键,数组下标 `loc` 为值。
**为了确保严格 $O(1)$,我们不能「使用拒绝采样」和「在数组非结尾位置添加/删除元素」。**
因此我们需要申请一个足够大的数组 `nums`(利用数据范围为 $2* 10^5$),并使用变量 `idx` 记录当前使用到哪一位(即下标在 $[0, idx]$ 范围内均是存活值)。
对于几类操作逻辑:
* `insert` 操作:使用哈希表判断 `val` 是否存在,存在的话返回 `false`,否则将其添加到 `nums`,更新 `idx`,同时更新哈希表;
* `remove` 操作:使用哈希表判断 `val` 是否存在,不存在的话返回 `false`,否则从哈希表中将 `val` 删除,同时取出其所在 `nums` 的下标 `loc`,然后将 `nums[idx]` 赋值到 `loc` 位置,并更新 `idx`(含义为将原本处于 `loc` 位置的元素删除),同时更新原本位于 `idx` 位置的数在哈希表中的值为 `loc`(若 `loc` 与 `idx` 相等,说明删除的是最后一个元素,这一步可跳过);
* `getRandom` 操作:由于我们人为确保了 $[0, idx]$ 均为存活值,因此直接在 $[0, idx + 1)$ 范围内进行随机即可。
代码:
```Java
class RandomizedSet {
static int[] nums = new int[200010];
Random random = new Random();
Map<Integer, Integer> map = new HashMap<>();
int idx = -1;
public boolean insert(int val) {
if (map.containsKey(val)) return false;
nums[++idx] = val;
map.put(val, idx);
return true;
}
public boolean remove(int val) {
if (!map.containsKey(val)) return false;
int loc = map.remove(val);
if (loc != idx) map.put(nums[idx], loc);
nums[loc] = nums[idx--];
return true;
}
public int getRandom() {
return nums[random.nextInt(idx + 1)];
}
}
```
* 时间复杂度:所有操作均为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.380` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/382. 链表随机节点（中等）.md | 382. 链表随机节点 | https://leetcode-cn.com/problems/linked-list-random-node/solution/gong-shui-san-xie-xu-shui-chi-chou-yang-1lp9d/ | 中等 | [
"链表",
"模拟",
"蓄水池抽样"
] | 给你一个单链表,随机选择链表的一个节点,并返回相应的节点值。每个节点 **被选中的概率一样** 。
实现 `Solution` 类:
* `Solution(ListNode head)` 使用整数数组初始化对象。
* `int getRandom()` 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。
示例:
```
输入
["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"]
[[[1, 2, 3]], [], [], [], [], []]
输出
[null, 1, 3, 2, 2, 3]
解释
Solution solution = new Solution([1, 2, 3]);
solution.getRandom(); // 返回 1
solution.getRandom(); // 返回 3
solution.getRandom(); // 返回 2
solution.getRandom(); // 返回 2
solution.getRandom(); // 返回 3
// getRandom() 方法应随机返回 1、2、3中的一个,每个元素被返回的概率相等。
```
提示:
* $链表中的节点数在范围 [1, 10^4] 内$
* $-10^4 <= Node.val <= 10^4$
* 至多调用 `getRandom` 方法 $10^4$ 次
进阶:
* 如果链表非常大且长度未知,该怎么处理?
* 你能否在不使用额外空间的情况下解决此问题? | ### 模拟
由于链表长度只有 $10^4$,因此可以在初始化时遍历整条链表,将所有的链表值预处理到一个数组内。
在查询时随机一个下标,并将数组中对应下标内容返回出去。
**代码(感谢 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**
```Java
class Solution {
List<Integer> list = new ArrayList<>();
Random random = new Random(20220116);
public Solution(ListNode head) {
while (head != null) {
list.add(head.val);
head = head.next;
}
}
public int getRandom() {
int idx = random.nextInt(list.size());
return list.get(idx);
}
}
```
-
```Python3
class Solution:
def __init__(self, head: Optional[ListNode]):
self.nodes = []
while head:
self.nodes.append(head)
head = head.next
def getRandom(self) -> int:
return self.nodes[randint(0, len(self.nodes) - 1)].val
```
-
```Golang
type Solution struct {
Nodes []int
}
func Constructor(head *ListNode) Solution {
nodes := make([]int, 0)
for head != nil {
nodes = append(nodes, head.Val)
head = head.Next
}
return Solution{nodes}
}
func (this *Solution) GetRandom() int {
return this.Nodes[rand.Intn(len(this.Nodes))]
}
```
* 时间复杂度:令 $n$ 为链表长度,预处理数组的复杂度为 $O(n)$;随机获取某个值的复杂度为 $O(1)$
* 空间复杂度:$O(n)$
---
### 蓄水池抽样
整理题意:总的样本数量未知,从所有样本中抽取若干个,要求每个样本被抽到的概率相等。
具体做法为:**从前往后处理每个样本,每个样本成为答案的概率为 $\frac{1}{i}$,其中 $i$ 为样本编号(编号从 $1$ 开始),最终可以确保每个样本成为答案的概率均为 $\frac{1}{n}$(其中 $n$ 为样本总数)。**
容易证明该做法的正确性,假设最终成为答案的样本编号为 $k$,那么 $k$ 成为答案的充要条件为「在遍历到 $k$ 时被选中」并且「遍历大于 $k$ 的所有元素时,均没有被选择(没有覆盖 $k$)」。
对应事件概率为:
$$
P = \frac{1}{k} * (1 - \frac{1}{k + 1}) * (1 - \frac{1}{k + 2}) * ... * (1 - \frac{1}{n})
$$
首项 $\frac{1}{k}$ 为选中 $k$ 的概率,后面每项分别为编号为 $[k + 1, n]$ 的样本 **不被选中** 的概率。
化简得:
$$
P = \frac{1}{k} * \frac{k}{k + 1} * \frac{k + 1}{k + 2} * ... * \frac{n - 1}{n}
$$
进一步抵消化简后,可得:
$$
P = \frac{1}{n}
$$
因此,在每一次 `getRandom` 时,从前往后处理每个节点,同时记录当前节点的编号,当处理到节点 $k$ 时,在 $[0, k)$ 范围内进行随机,若随机到结果为 $0$(发生概率为 $\frac{1}{k}$),则将节点 $k$ 的值存入答案,最后一次覆盖答案的节点即为本次抽样结果。
**代码(感谢 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**
```Java
class Solution {
ListNode head;
Random random = new Random(20220116);
public Solution(ListNode _head) {
head = _head;
}
public int getRandom() {
int ans = 0, idx = 0;
ListNode t = head;
while (t != null && ++idx >= 0) {
if (random.nextInt(idx) == 0) ans = t.val;
t = t.next;
}
return ans;
}
}
```
-
```Python3
class Solution:
def __init__(self, head: Optional[ListNode]):
self.root = head
def getRandom(self) -> int:
node, ans, i = self.root, None, 0
while node:
if not randint(0, i):
ans = node.val
node, i = node.next, i + 1
return ans
```
-
```Golang
type Solution struct {
Root *ListNode
}
func Constructor(head *ListNode) Solution {
return Solution{head}
}
func (this *Solution) GetRandom() (ans int) {
for node, idx := this.Root, 1;node != nil; idx++ {
if rand.Intn(idx) == 0{
ans = node.Val
}
node = node.Next
}
return
}
```
* 时间复杂度:令 $n$ 为链表长度,随机获取某个值的复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.382` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/383. 赎金信（简单）.md | 383. 赎金信 | https://leetcode-cn.com/problems/ransom-note/solution/gong-shui-san-xie-jian-dan-ji-shu-mo-ni-udpzn/ | 简单 | [
"模拟"
] | 为了不在赎金信中暴露字迹,从杂志上搜索各个需要的字母,组成单词来表达意思。
给你一个赎金信 (`ransomNote`) 字符串和一个杂志(`magazine`)字符串,判断` ransomNote` 能不能由 `magazines` 里面的字符构成。
如果可以构成,返回 `true` ;否则返回 `false` 。
`magazine` 中的每个字符只能在 `ransomNote` 中使用一次。
示例 1:
```
输入:ransomNote = "a", magazine = "b"
输出:false
```
示例 2:
```
输入:ransomNote = "aa", magazine = "ab"
输出:false
```
示例 3:
```
输入:ransomNote = "aa", magazine = "aab"
输出:true
```
提示:
* $1 <= ransomNote.length, magazine.length <= 10^5$
* `ransomNote` 和 `magazine` 由小写英文字母组成 | ### 计数模拟
根据题意并利用两字符串只包含小写字母,先使用大小为字符集大小的数组(充当哈希表)对 $magazine$ 进行词频统计,然后在遍历 $ransomNote$ 时对计数数组进行抵消操作。
若处理过程中出现词频数量为负数,则说明 $magazine$ 不能凑出 $ransomNote$。
代码:
```Java
class Solution {
public boolean canConstruct(String a, String b) {
int[] cnt = new int[26];
for (char c : b.toCharArray()) cnt[c - 'a']++;
for (char c : a.toCharArray()) if (--cnt[c - 'a'] < 0) return false;
return true;
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别为两字符串的长度,复杂度为 $O(n + m)$
* 空间复杂度:令字符集大小为 $C = 26$。偷懒使用 `toCharArray` 操作的话,复杂度为 $O(n + m + C)$;使用 `charAt` 代替的话,复杂度为 $O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.383` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/384. 打乱数组（中等）.md | 384. 打乱数组 | https://leetcode-cn.com/problems/shuffle-an-array/solution/gong-shui-san-xie-xi-pai-suan-fa-yun-yon-0qmy/ | 中等 | [
"洗牌算法"
] | 给你一个整数数组 `nums`,设计算法来打乱一个没有重复元素的数组。
实现 `Solution class`:
* `Solution(int[] nums)` 使用整数数组 `nums` 初始化对象
* `int[] reset()` 重设数组到它的初始状态并返回
* `int[] shuffle()` 返回数组随机打乱后的结果
示例:
```
输入
["Solution", "shuffle", "reset", "shuffle"]
[[[1, 2, 3]], [], [], []]
输出
[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
解释
Solution solution = new Solution([1, 2, 3]);
solution.shuffle(); // 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。例如,返回 [3, 1, 2]
solution.reset(); // 重设数组到它的初始状态 [1, 2, 3] 。返回 [1, 2, 3]
solution.shuffle(); // 随机返回数组 [1, 2, 3] 打乱后的结果。例如,返回 [1, 3, 2]
```
提示:
* $1 <= nums.length <= 200$
* $-10^6 <= nums[i] <= 10^6$
* `nums` 中的所有元素都是 唯一的
* 最多可以调用 $5 \times 10^4$ 次 `reset` 和 `shuffle` | ### 洗牌算法
共有 $n$ 个不同的数,根据每个位置能够选择什么数,共有 $n!$ 种组合。
题目要求每次调用 `shuffle` 时等概率返回某个方案,或者说每个元素都够等概率出现在每个位置中。
我们可以使用 $Knuth$ 洗牌算法,在 $O(n)$ 复杂度内等概率返回某个方案。
具体的,我们从前往后尝试填充 $[0, n - 1]$ 该填入什么数时,通过随机当前下标与(剩余的)哪个下标进行值交换来实现。
对于下标 $x$ 而言,我们从 $[x, n - 1]$ 中随机出一个位置与 $x$ 进行值交换,当所有位置都进行这样的处理后,我们便得到了一个公平的洗牌方案。
> 对于下标为 $0$ 位置,从 $[0, n - 1]$ 随机一个位置进行交换,共有 $n$ 种选择;下标为 $1$ 的位置,从 $[1, n - 1]$ 随机一个位置进行交换,共有 $n - 1$ 种选择 ... 且每个位置的随机位置交换过程相互独立。
Java 代码:
```Java
class Solution {
int[] nums;
int n;
Random random = new Random();
public Solution(int[] _nums) {
nums = _nums;
n = nums.length;
}
public int[] reset() {
return nums;
}
public int[] shuffle() {
int[] ans = nums.clone();
for (int i = 0; i < n; i++) {
swap(ans, i, i + random.nextInt(n - i));
}
return ans;
}
void swap(int[] arr, int i, int j) {
int c = arr[i];
arr[i] = arr[j];
arr[j] = c;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> nums;
int n;
Solution(vector<int>& _nums) : nums(_nums), n(_nums.size()) {}
vector<int> reset() {
return nums;
}
vector<int> shuffle() {
vector<int> ans = nums;
for (int i = 0; i < n; i++) {
swap(ans[i], ans[i + rand() % (n - i)]);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def __init__(self, nums: List[int]):
self.nums = nums
self.n = len(nums)
def reset(self) -> List[int]:
return self.nums
def shuffle(self) -> List[int]:
ans = self.nums[:]
for i in range(self.n):
j = i + random.randint(0, self.n - i - 1)
ans[i], ans[j] = ans[j], ans[i]
return ans
```
TypeScript 代码:
```TypeScript
class Solution {
private nums: number[];
private n: number;
constructor(nums: number[]) {
this.nums = nums;
this.n = nums.length;
}
reset(): number[] {
return this.nums.slice();
}
shuffle(): number[] {
const ans: number[] = this.nums.slice();
for (let i = 0; i < this.n; i++) {
const j = i + Math.floor(Math.random() * (this.n - i));
[ans[i], ans[j]] = [ans[j], ans[i]];
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.384` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/385. 迷你语法分析器（中等）.md | 385. 迷你语法分析器 | https://leetcode-cn.com/problems/mini-parser/solution/by-ac_oier-zuy6/ | 中等 | [
"栈",
"模拟"
] | 给定一个字符串 `s` 表示一个整数嵌套列表,实现一个解析它的语法分析器并返回解析的结果 `NestedInteger` 。
列表中的每个元素只可能是整数或整数嵌套列表
示例 1:
```
输入:s = "324",
输出:324
解释:你应该返回一个 NestedInteger 对象,其中只包含整数值 324。
```
示例 2:
```
输入:s = "[123,[456,[789]]]",
输出:[123,[456,[789]]]
解释:返回一个 NestedInteger 对象包含一个有两个元素的嵌套列表:
1. 一个 integer 包含值 123
2. 一个包含两个元素的嵌套列表:
i. 一个 integer 包含值 456
ii. 一个包含一个元素的嵌套列表
a. 一个 integer 包含值 789
```
提示:
* $1 <= s.length <= 5 * 10^4$
* `s` 由数字、方括号 `"[]"`、负号 `'-'` 、逗号 `','`组成
* 用例保证 `s` 是可解析的 `NestedInteger`
* 输入中的所有值的范围是 $[-10^6, 10^6]$ | ### 栈
每个 `[` 的出现意味着存在一个嵌套类型的 `NestedInteger` 实例,同时每个 `NestedInteger` 实例(无论是嵌套类型还是数值类型)都归属于其最近一个左边的嵌套类型的 `NestedInteger` 实例(即其左边最近一个 `[`),因此我们可以使用栈来处理。
对出现的几类字符进行简单分情况讨论:
* `,`:跳过即可;
* `-` 或 `数字`:将连续段代表数值的字符串取出,创建数值型的 `NestedInteger` 实例并压入栈中;
* `[`:创建一个嵌套类型的 `NestedInteger` 实例并压入栈中,同时为了方便,同时压入一个起「标识」作用的 `NestedInteger` 对象;
* `]`:从栈中取出元素,直到遇到起「标识」作用的 `NestedInteger` 对象(说明找到与当前 `]` 成对的 `[`),将 `[` 和 `]` 之间的所有元素添加到 `[` 所代指的嵌套 `NestedInteger` 实例中,然后将 `[` 所代指的嵌套 `NestedInteger` 实例重新放入栈中。
按照上述逻辑处理完整个 `s`,最终栈顶元素即是答案。
代码:
```Java
class Solution {
static NestedInteger ph = new NestedInteger(0);
public NestedInteger deserialize(String s) {
Deque<NestedInteger> d = new ArrayDeque<>();
char[] cs = s.toCharArray();
int n = cs.length, i = 0;
while (i < n) {
if (cs[i] == ',' && ++i >= 0) continue;
if (cs[i] == '-' || (cs[i] >= '0' && cs[i] <= '9')) {
int j = cs[i] == '-' ? i + 1 : i, num = 0;
while (j < n && (cs[j] >= '0' && cs[j] <= '9')) num = num * 10 + (cs[j++] - '0');
d.addLast(new NestedInteger(cs[i] == '-' ? -num : num));
i = j;
} else if (cs[i] == '[') {
d.addLast(new NestedInteger());
d.addLast(ph);
i++;
} else {
List<NestedInteger> list = new ArrayList<>();
while (!d.isEmpty()) {
NestedInteger poll = d.pollLast();
if (poll == ph) break;
list.add(poll);
}
for (int j = list.size() - 1; j >= 0; j--) d.peekLast().add(list.get(j));
i++;
}
}
return d.peekLast();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.385` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/386. 字典序排数（中等）.md | 386. 字典序排数 | https://leetcode-cn.com/problems/lexicographical-numbers/solution/by-ac_oier-ktn7/ | 中等 | [
"DFS",
"递归",
"迭代"
] | 给你一个整数 `n` ,按字典序返回范围 $[1, n]$ 内所有整数。
你必须设计一个时间复杂度为 $O(n)$ 且使用 $O(1)$ 额外空间的算法。
示例 1:
```
输入:n = 13
输出:[1,10,11,12,13,2,3,4,5,6,7,8,9]
```
示例 2:
```
输入:n = 2
输出:[1,2]
```
提示:
* $1 <= n <= 5 * 10^4$ | ### 递归
首先容易想到使用「递归」来实现 `DFS`。
将 $[1, n]$ 的数按照字典序添加到答案,本质上是对一颗节点数量为 $n$,形态类似字典树的多阶树进行遍历,根节点为 $0$,需要被跳过,因此我们可以从树的第二层开始搜索。
树中每个节点的值为其搜索路径所代表的数字,且每个节点有 $[0, 9]$ 共 $10$ 个子节点。
代码:
```Java
class Solution {
List<Integer> ans = new ArrayList<>();
public List<Integer> lexicalOrder(int n) {
for (int i = 1; i <= 9; i++) dfs(i, n);
return ans;
}
void dfs(int cur, int limit) {
if (cur > limit) return ;
ans.add(cur);
for (int i = 0; i <= 9; i++) dfs(cur * 10 + i, limit);
}
}
```
* 时间复杂度:本质上在搜索一棵节点数量为 $n$ 的多阶树(形态类似于字典树),复杂度为 $O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 迭代
递归具有额外的空间开销,为了实现严格的 $O(1)$ 空间,我们需要使用「迭代」来实现 `DFS`。
共有 $n$ 个数需要被处理,假设当前处理到的数为 $j$,根据字典序规则,在满足条件的前提下,我们优先在 $j$ 的后面添加 $0$(即 $j * 10 < n$ 满足),否则我们考虑将上一位回退并进行加一操作。
代码:
```Java
class Solution {
public List<Integer> lexicalOrder(int n) {
List<Integer> ans = new ArrayList<>();
for (int i = 0, j = 1; i < n; i++) {
ans.add(j);
if (j * 10 <= n) {
j *= 10;
} else {
while (j % 10 == 9 || j + 1 > n) j /= 10;
j++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.386` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/388. 文件的最长绝对路径（中等）.md | 388. 文件的最长绝对路径 | https://leetcode-cn.com/problems/longest-absolute-file-path/solution/by-ac_oier-c55t/ | 中等 | [
"模拟",
"哈希表"
] | 假设有一个同时存储文件和目录的文件系统。下图展示了文件系统的一个示例:
这里将 `dir` 作为根目录中的唯一目录。`dir` 包含两个子目录 `subdir1` 和 `subdir2` 。
`subdir1` 包含文件 `file1.ext` 和子目录 `subsubdir1`;`subdir2` 包含子目录 `subsubdir2`,该子目录下包含文件 `file2.ext`。
在文本格式中,如下所示(⟶表示制表符):
```
dir
⟶ subdir1
⟶ ⟶ file1.ext
⟶ ⟶ subsubdir1
⟶ subdir2
⟶ ⟶ subsubdir2
⟶ ⟶ ⟶ file2.ext
```
如果是代码表示,上面的文件系统可以写为 `"dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext"` 。`'\n'` 和 `'\t'` 分别是换行符和制表符。
文件系统中的每个文件和文件夹都有一个唯一的 绝对路径 ,即必须打开才能到达文件/目录所在位置的目录顺序,所有路径用 '/' 连接。上面例子中,指向 `file2.ext` 的 绝对路径 是 `"dir/subdir2/subsubdir2/file2.ext"` 。每个目录名由字母、数字和/或空格组成,每个文件名遵循 `name.extension` 的格式,其中 `name` 和 `extension` 由字母、数字和/或空格组成。
给定一个以上述格式表示文件系统的字符串 `input` ,返回文件系统中 指向 文件 的 最长绝对路径 的长度 。 如果系统中没有文件,返回 $0$。
示例 1:
```
输入:input = "dir\n\tsubdir1\n\tsubdir2\n\t\tfile.ext"
输出:20
解释:只有一个文件,绝对路径为 "dir/subdir2/file.ext" ,路径长度 20
```
示例 2:
```
输入:input = "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext"
输出:32
解释:存在两个文件:
"dir/subdir1/file1.ext" ,路径长度 21
"dir/subdir2/subsubdir2/file2.ext" ,路径长度 32
返回 32 ,因为这是最长的路径
```
示例 3:
```
输入:input = "a"
输出:0
解释:不存在任何文件
```
示例 4:
```
输入:input = "file1.txt\nfile2.txt\nlongfile.txt"
输出:12
解释:根目录下有 3 个文件。
因为根目录中任何东西的绝对路径只是名称本身,所以答案是 "longfile.txt" ,路径长度为 12
```
提示:
* $1 <= input.length <= 10^4$
* `input` 可能包含小写或大写的英文字母,一个换行符 `'\n'`,一个制表符 `'\t'`,一个点 `'.'`,一个空格 `' '`,和数字。 | ### 模拟 + 哈希表
为了方便,我们将 `input` 替换为 `s`。
对于每一个文件或文件夹而言,我们可以通过访问到结尾(`\n`)的方式取得,记为 `cur`,然后根据 `cur` 前面有多少个 `\t` 得知其所在的层级,假设当前其所在层级为 `level`,那么它自然归属到最新一个层级为 `level - 1` 的文件夹中,因此我们可以使用哈希表记录每个层级最新的文件夹路径,通过字符串拼接的方式得到 `cur` 所在的完整路径 `path`,并在处理整个 `s` 过程中,统计长度最大的文件路径。
代码:
```Java
class Solution {
public int lengthLongestPath(String s) {
Map<Integer, String> map = new HashMap<>();
int n = s.length();
String ans = null;
for (int i = 0; i < n; ) {
int level = 0;
while (i < n && s.charAt(i) == '\t' && ++level >= 0) i++;
int j = i;
boolean isDir = true;
while (j < n && s.charAt(j) != '\n') {
if (s.charAt(j++) == '.') isDir = false;
}
String cur = s.substring(i, j);
String prev = map.getOrDefault(level - 1, null);
String path = prev == null ? cur : prev + "/" + cur;
if (isDir) map.put(level, path);
else if (ans == null || path.length() > ans.length()) ans = path;
i = j + 1;
}
return ans == null ? 0 : ans.length();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 优化
上述做法只是为了方便我们输出具体方案。
实际上,我们只关心最终的路径长度,而不关心具体路径,因此容易将解法一修改为只记录长度,而不记录路径的做法,从而避免掉字符串拼接带来的消耗,同时利用 `s` 的长度数据范围,使用数组来替代常数较大的哈希表。
代码:
```Java
class Solution {
static int[] hash = new int[10010];
public int lengthLongestPath(String s) {
Arrays.fill(hash, -1);
int n = s.length(), ans = 0;
for (int i = 0; i < n; ) {
int level = 0;
while (i < n && s.charAt(i) == '\t' && ++level >= 0) i++;
int j = i;
boolean isDir = true;
while (j < n && s.charAt(j) != '\n') {
if (s.charAt(j++) == '.') isDir = false;
}
Integer cur = j - i;
Integer prev = level - 1 >= 0 ? hash[level - 1] : -1;
Integer path = prev + 1 + cur;
if (isDir) hash[level] = path;
else if (path > ans) ans = path;
i = j + 1;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.388` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/381-390/390. 消除游戏（中等）.md | 390. 消除游戏 | https://leetcode-cn.com/problems/elimination-game/solution/gong-shui-san-xie-yue-se-fu-huan-yun-yon-x60m/ | 中等 | [
"动态规划",
"数学",
"约瑟夫环"
] | 列表 `arr` 由在范围 `[1, n]` 中的所有整数组成,并按严格递增排序。
请你对 `arr` 应用下述算法:
* 从左到右,删除第一个数字,然后每隔一个数字删除一个,直到到达列表末尾。
* 重复上面的步骤,但这次是从右到左。也就是,删除最右侧的数字,然后剩下的数字每隔一个删除一个。
* 不断重复这两步,从左到右和从右到左交替进行,直到只剩下一个数字。
给你整数 `n`,返回 `arr` 最后剩下的数字。
示例 1:
```
输入:n = 9
输出:6
解释:
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
arr = [2, 4, 6, 8]
arr = [2, 6]
arr = [6]
```
示例 2:
```
输入:n = 1
输出:1
```
提示:
* $1 <= n <= 10^9$ | ### 约瑟夫环
与求解约瑟夫环类似,本题也可以通常找规律,分析出公式之后进行递推求解。
对于本题,定义 $f[i]$ 为在 **连续序列** $[1, i]$ 中进行「起始先从左到右,再从右往左」的轮流换向间隔删除,最终左边剩余的编号;定义 $f'[i]$ 为在 **连续序列** $[1, i]$ 中进行「起始先从右到左,再从左往右」的轮流换向间隔删除,最终右边剩余的编号。
**由于「从左往右」和「从右往左」分别为「从左端点发起,间隔删除」和「从右端点发起,间隔删除」,因此整个删除过程在连续序列中 $[1, i]$ 中具有对称性,两者最终剩余的编号在连续序列中也具有对称性。**
即可得出第一个公式:
$$
f[i] + f'[i] = i + 1
$$
考虑题目规定的「左右轮流进行发起删除」的操作如何进行。
由于我们对 $f[i]$ 和 $f'[i]$ 的定义都是「连续序列」,因此如果我们希望使用 $f[i]$ 和 $f'[i]$ 得出最终答案,我们需要在每次消除后对序列进行「重新编号」,确保能够使用 $f[i]$ 和 $f'[i]$ 作为合法状态值,在计算出「重新编号」后的,需要将答案(编号)映射回去重新编号前的值。
起始时,我们对连续序列 $[1, 2, 3, ... , i]$ 执行了一次「从左往右」的消除之后,得到的序列为 $[2, 4, 6, ..., x]$(其中 $x$ 根据 $i$ 的奇偶性不同,可能为 $i$ 或 $i - 1$)。新序列的长度为 $\left \lfloor \frac{i}{2} \right \rfloor$。
考虑对得到的序列进行重新编号,使其继续保有「连续序列」的定义,即变为 $[1, 2, 3, ... , \left \lfloor \frac{i}{2} \right \rfloor]$,然后执行「从右往左」的间隔删除,最终得到 $f'[\left \lfloor \frac{i}{2} \right \rfloor]$,之后考虑将答案编号映射回「重新编号」前的值。
此时可得到第二个公式:
$$
f[i] = f'[\left \lfloor \frac{i}{2} \right \rfloor] * 2
$$
通过上述两个公式,我们可以将 $f'[i]$ 进行消除,得到最终的 $f[i]$ 关系式:
$$
f[i] = 2 * (\left \lfloor \frac{i}{2} \right \rfloor + 1 - f[\left \lfloor \frac{i}{2} \right \rfloor])
$$
我们知道需要实现的函数 `lastRemaining` 其实就是 $f[i]$,因此该递推过程我们可以使用递归进行实现(注意的出口条件 $f[1] = 1$)。
代码:
```Java
class Solution {
public int lastRemaining(int n) {
return n == 1 ? 1 : 2 * (n / 2 + 1 - lastRemaining(n / 2));
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.390` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/391. 完美矩形（困难）.md | 391. 完美矩形 | https://leetcode-cn.com/problems/perfect-rectangle/solution/gong-shui-san-xie-chang-gui-sao-miao-xia-p4q4/ | 困难 | [
"扫描线"
] | 给你一个数组 `rectangles`,其中 $rectangles[i] = [x_i, y_i, a_i, b_i]$ 表示一个坐标轴平行的矩形。这个矩形的左下顶点是 $(x_i, y_i)$ ,右上顶点是 $(a_i, b_i)$ 。
如果所有矩形一起精确覆盖了某个矩形区域,则返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]
输出:true
解释:5 个矩形一起可以精确地覆盖一个矩形区域。
```
示例 2:
```
输入:rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]
输出:false
解释:两个矩形之间有间隔,无法覆盖成一个矩形。
```
示例 3:
```
输入:rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[3,2,4,4]]
输出:false
解释:图形顶端留有空缺,无法覆盖成一个矩形。
```
示例 4:
```
输入:rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]
输出:false
解释:因为中间有相交区域,虽然形成了矩形,但不是精确覆盖。
```
提示:
* $1 <= rectangles.length <= 2 \times 10^4$
* $rectangles[i].length = 4$
* $-10^5 <= x_i, y_i, a_i, b_i <= 10^5$ | ### 扫描线
将每个矩形 $rectangles[i]$ 看做两条竖直方向的边,使用 $(x, y1, y2)$ 的形式进行存储(其中 $y1$ 代表该竖边的下端点,$y2$ 代表竖边的上端点),同时为了区分是矩形的左边还是右边,再引入一个标识位,即以四元组 $(x, y1, y2, flag)$ 的形式进行存储。
一个完美矩形的充要条件为:**对于完美矩形的每一条非边缘的竖边,都「成对」出现(存在两条完全相同的左边和右边重叠在一起);对于完美矩形的两条边缘竖边,均独立为一条连续的(不重叠)的竖边。**
如图(红色框的为「完美矩形的边缘竖边」,绿框的为「完美矩形的非边缘竖边」):
* 绿色:非边缘竖边必然有成对的左右两条完全相同的竖边重叠在一起;
* 红色:边缘竖边由于只有单边,必然不重叠,且连接成一条完成的竖边。
代码:
```Java
class Solution {
public boolean isRectangleCover(int[][] rectangles) {
int n = rectangles.length;
int[][] rs = new int[n * 2][4];
for (int i = 0, idx = 0; i < n; i++) {
int[] re = rectangles[i];
rs[idx++] = new int[]{re[0], re[1], re[3], 1};
rs[idx++] = new int[]{re[2], re[1], re[3], -1};
}
Arrays.sort(rs, (a,b)->{
if (a[0] != b[0]) return a[0] - b[0];
return a[1] - b[1];
});
n *= 2;
// 分别存储相同的横坐标下「左边的线段」和「右边的线段」 (y1, y2)
List<int[]> l1 = new ArrayList<>(), l2 = new ArrayList<>();
for (int l = 0; l < n; ) {
int r = l;
l1.clear(); l2.clear();
// 找到横坐标相同部分
while (r < n && rs[r][0] == rs[l][0]) r++;
for (int i = l; i < r; i++) {
int[] cur = new int[]{rs[i][1], rs[i][2]};
List<int[]> list = rs[i][3] == 1 ? l1 : l2;
if (list.isEmpty()) {
list.add(cur);
} else {
int[] prev = list.get(list.size() - 1);
if (cur[0] < prev[1]) return false; // 存在重叠
else if (cur[0] == prev[1]) prev[1] = cur[1]; // 首尾相连
else list.add(cur);
}
}
if (l > 0 && r < n) {
// 若不是完美矩形的边缘竖边,检查是否成对出现
if (l1.size() != l2.size()) return false;
for (int i = 0; i < l1.size(); i++) {
if (l1.get(i)[0] == l2.get(i)[0] && l1.get(i)[1] == l2.get(i)[1]) continue;
return false;
}
} else {
// 若是完美矩形的边缘竖边,检查是否形成完整一段
if (l1.size() + l2.size() != 1) return false;
}
l = r;
}
return true;
}
}
```
* 时间复杂度:将 `rectangles` 划分成边集的复杂度为 $O(n)$;对边集进行排序的复杂度为 $O(n\log{n})$,对排序好的边集进行遍历检查,每条边会被扫描线性次,复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.391` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/393. UTF-8 编码验证（中等）.md | 393. UTF-8 编码验证 | https://leetcode-cn.com/problems/utf-8-validation/solution/by-ac_oier-zvoy/ | 中等 | [
"模拟"
] | 给定一个表示数据的整数数组 `data` ,返回它是否为有效的 $UTF-8$ 编码。
`UTF-8` 中的一个字符可能的长度为 $1$ 到 $4$ 字节,遵循以下的规则:
1. 对于 $1$ 字节 的字符,字节的第一位设为 $0$ ,后面 $7$ 位为这个符号的 `unicode` 码。
2. 对于 $n$ 字节 的字符 ($n > 1$),第一个字节的前 $n$ 位都设为 $1$,第 $n+1$ 位设为 $0$ ,后面字节的前两位一律设为 $10$ 。剩下的没有提及的二进制位,全部为这个符号的 `unicode` 码。
这是 UTF-8 编码的工作方式:
```
Char. number range | UTF-8 octet sequence
(hexadecimal) | (binary)
--------------------+---------------------------------------------
0000 0000-0000 007F | 0xxxxxxx
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
```
注意:输入是整数数组。只有每个整数的 最低 8 个有效位 用来存储数据。这意味着每个整数只表示 1 字节的数据。
示例 1:
```
输入:data = [197,130,1]
输出:true
解释:数据表示字节序列:11000101 10000010 00000001。
这是有效的 utf-8 编码,为一个 2 字节字符,跟着一个 1 字节字符。
```
示例 2:
```
输入:data = [235,140,4]
输出:false
解释:数据表示 8 位的序列: 11101011 10001100 00000100.
前 3 位都是 1 ,第 4 位为 0 表示它是一个 3 字节字符。
下一个字节是开头为 10 的延续字节,这是正确的。
但第二个延续字节不以 10 开头,所以是不符合规则的。
```
提示:
* $1 <= data.length <= 2 \times 10^4$
* $0 <= data[i] <= 255$ | ### 模拟
根据题意进行模拟即可。
从前往后处理每个 $data[i]$,先统计 $data[i]$ 从第 $7$ 位开始往后有多少位连续的 $1$,代表这是一个几字节的字符,记为 $cnt$ :
* 如果 $cnt$ 为 $1$ 或者大于 $4$ 均违反编码规则(与字符长度为 $1$ 时的编码规则 和 字符长度只能是 $1$ 到 $4$ 冲突),返回 `False`;
* 如果位置 $i$ 后面不足 $cnt - 1$ 也返回 `False`;
* 否则检查下标范围为 $[i + 1, i + cnt - 1]$ 的数是否满足前两位为 $10$ 的要求,若不满足返回 `False`。
如果上述过程满足要求,跳到下一个检查点进行检查,整个 `data` 都没有冲突则返回 `True`。
代码:
```Java
class Solution {
public boolean validUtf8(int[] data) {
int n = data.length;
for (int i = 0; i < n; ) {
int t = data[i], j = 7;
while (j >= 0 && (((t >> j) & 1) == 1)) j--;
int cnt = 7 - j;
if (cnt == 1 || cnt > 4) return false;
if (i + cnt - 1 >= n) return false;
for (int k = i + 1; k < i + cnt; k++) {
if ((((data[k] >> 7) & 1) == 1) && (((data[k] >> 6) & 1) == 0)) continue;
return false;
}
i += cnt == 0 ? 1 : cnt;
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.393` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/395. 至少有 K 个重复字符的最长子串（中等）.md | 395. 至少有 K 个重复字符的最长子串 | https://leetcode-cn.com/problems/longest-substring-with-at-least-k-repeating-characters/solution/xiang-jie-mei-ju-shuang-zhi-zhen-jie-fa-50ri1/ | 中等 | [
"双指针",
"枚举"
] | 给你一个字符串 s 和一个整数 k ,请你找出 s 中的最长子串, 要求该子串中的每一字符出现次数都不少于 k 。返回这一子串的长度。
示例 1:
```
输入:s = "aaabb", k = 3
输出:3
解释:最长子串为 "aaa" ,其中 'a' 重复了 3 次。
```
示例 2:
```
输入:s = "ababbc", k = 2
输出:5
解释:最长子串为 "ababb" ,其中 'a' 重复了 2 次, 'b' 重复了 3 次。
```
提示:
* 1 <= s.length <= $10^4$
* s 仅由小写英文字母组成
* 1 <= k <= $10^5$ | ### 枚举 + 双指针
其实看到这道题,我第一反应是「二分」,直接「二分」答案。
但是往下分析就能发现「二分」不可行,因为不具有二段性质。
也就是假设有长度 `t` 的一段区间满足要求的话,`t + 1` 长度的区间是否「一定满足」或者「一定不满足」呢?
显然并不一定,是否满足取决于 `t + 1` 个位置出现的字符在不在原有区间内。
举个🌰吧,假设我们已经画出来一段长度为 `t` 的区间满足要求(且此时 k > 1),那么当我们将长度扩成 `t + 1` 的时候(无论是往左扩还是往右扩):
* 如果新位置的字符在原有区间**出现过**,那必然还是满足出现次数大于 k,这时候 **`t + 1` 的长度满足要求**
* 如果新位置的字符在原有区间**没出现过**,那新字符的出现次数只有一次,这时候 **`t + 1` 的长度不满足要求**
因此我们无法是使用「二分」,相应的也无法直接使用「滑动窗口」思路的双指针。
因为双指针其实也是利用了二段性质,当一个指针确定在某个位置,另外一个指针能够落在某个明确的分割点,使得左半部分满足,右半部分不满足。
**那么还有什么性质可以利用呢?这时候要留意数据范围「数值小」的内容。**
题目说明了只包含小写字母(26 个,为有限数据),**我们可以枚举最大长度所包含的字符类型数量,答案必然是 [1, 26],即最少包含 1 个字母,最多包含 26 个字母。**
你会发现,**当确定了长度所包含的字符种类数量时,区间重新具有了二段性质。**
当我们使用双指针的时候:
1. 右端点往右移动必然会导致字符类型数量增加(或不变)
2. 左端点往右移动必然会导致字符类型数量减少(或不变)
当然,我们还需要记录有多少字符符合要求(出现次数不少于 k),当区间内所有字符都符合时更新答案。
代码:
```Java
class Solution {
public int longestSubstring(String s, int k) {
int ans = 0;
int n = s.length();
char[] cs = s.toCharArray();
int[] cnt = new int[26];
for (int p = 1; p <= 26; p++) {
Arrays.fill(cnt, 0);
// tot 代表 [j, i] 区间所有的字符种类数量;sum 代表满足「出现次数不少于 k」的字符种类数量
for (int i = 0, j = 0, tot = 0, sum = 0; i < n; i++) {
int u = cs[i] - 'a';
cnt[u]++;
// 如果添加到 cnt 之后为 1,说明字符总数 +1
if (cnt[u] == 1) tot++;
// 如果添加到 cnt 之后等于 k,说明该字符从不达标变为达标,达标数量 + 1
if (cnt[u] == k) sum++;
// 当区间所包含的字符种类数量 tot 超过了当前限定的数量 p,那么我们要删除掉一些字母,即「左指针」右移
while (tot > p) {
int t = cs[j++] - 'a';
cnt[t]--;
// 如果添加到 cnt 之后为 0,说明字符总数-1
if (cnt[t] == 0) tot--;
// 如果添加到 cnt 之后等于 k - 1,说明该字符从达标变为不达标,达标数量 - 1
if (cnt[t] == k - 1) sum--;
}
// 当所有字符都符合要求,更新答案
if (tot == sum) ans = Math.max(ans, i - j + 1);
}
}
return ans;
}
}
```
* 时间复杂度:枚举 26 种可能性,每种可能性会扫描一遍数组。复杂度为 $O(n)$
* 空间复杂度:$O(n)$
***
### 总结 & 补充
【总结】:
「当确定了窗口内所包含的字符数量时,区间重新具有了二段性质」。这是本题的滑动窗口解法和迄今为止做的滑动窗口题目的最大不同,本题需要手动增加限制,即限制窗口内字符种类。
【补充】这里解释一下「为什么需要先枚举 26 种可能性」:
首先我们知道「**答案子串的左边界左侧的字符以及右边界右侧的字符一定不会出现在子串中,否则就不会是最优解**」。
但**如果我们只从该性质出发的话,朴素解法应该是使用一个滑动窗口,不断的调整滑动窗口的左右边界,使其满足「左边界左侧的字符以及右边界右侧的字符一定不会出现在窗口中」**,这实际上就是双指针解法,但是如果不先敲定(枚举)出答案所包含的字符数量的话,**这里的双指针是不具有单调性的**。
换句话说,只利用这一性质是没法完成逻辑的。
这时候我们面临的问题是:**性质是正确的,但是还无法直接利用**。
因此我们需要**先利用字符数量有限性(可枚举)作为切入点,使得「答案子串的左边界左侧的字符以及右边界右侧的字符一定不会出现在子串中」这一性质在双指针的实现下具有单调性**。也就是题解说的「让区间重新具有二段性质」。
然后遍历 26 种可能性(答案所包含的字符种类数量),**对每种可能性应用滑动窗口(由上述性质确保正确),可以得到每种可能性的最大值(局部最优),由所有可能性的最大值可以得出答案(全局最优)**。
***
### 点评
这道题的突破口分析其实和 [1178. 猜字谜](https://leetcode-cn.com/problems/number-of-valid-words-for-each-puzzle/solution/xiang-jin-zhu-shi-xiang-jie-po-su-wei-yu-3cr2/) 类似。
解决思路:当我们采用常规的分析思路发现无法进行时,**要去关注一下数据范围中「数值小」的值。因为数值小其实是代表了「可枚举」,往往是解题或者降低复杂度的一个重要(甚至是唯一)的突破口。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.395` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/396. 旋转函数（中等）.md | 396. 旋转函数 | https://leetcode-cn.com/problems/rotate-function/solution/by-ac_oier-sxbi/ | 中等 | [
"前缀和",
"滑动窗口"
] | 给定一个长度为 $n$ 的整数数组 $nums$ 。
假设 $arr_k$ 是数组 $nums$ 顺时针旋转 $k$ 个位置后的数组,我们定义 $nums$ 的 旋转函数 `F` 为:
* `F(k) = 0 * arrk[0] + 1 * arrk[1] + ... + (n - 1) * arrk[n - 1]`
返回 `F(0), F(1), ..., F(n-1)` 中的最大值 。
生成的测试用例让答案符合 $32$ 位 整数。
示例 1:
```
输入: nums = [4,3,2,6]
输出: 26
解释:
F(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 + 3 + 4 + 18 = 25
F(1) = (0 * 6) + (1 * 4) + (2 * 3) + (3 * 2) = 0 + 4 + 6 + 6 = 16
F(2) = (0 * 2) + (1 * 6) + (2 * 4) + (3 * 3) = 0 + 6 + 8 + 9 = 23
F(3) = (0 * 3) + (1 * 2) + (2 * 6) + (3 * 4) = 0 + 2 + 12 + 12 = 26
所以 F(0), F(1), F(2), F(3) 中的最大值是 F(3) = 26 。
```
示例 2:
```
输入: nums = [100]
输出: 0
```
提示:
* $n = nums.length$
* $1 <= n <= 10^5$
* $-100 <= nums[i] <= 100$ | ### 前缀和 + 滑动窗口
为了方便,我们将 $nums$ 的长度记为 $n$。
题目要对「旋转数组」做逻辑,容易想到将 $nums$ 进行复制拼接,得到长度为 $2 \times n$ 的新数组,在新数组上任意一个长度为 $n$ 的滑动窗口都对应了一个旋转数组。
然后考虑在窗口的滑动过程中,计算结果会如何变化,假设当前我们处理到下标为 $[i, i + n - 1]$ 的滑动窗口,根据题意,当前结果为:
$$
cur = nums[i] \times 0 + nums[i + 1] \times 1 + ... + nums[i + n - 1] \times (n - 1)
$$
当窗口往后移动一位,也就是窗口的右端点来到 $i + n$ 的位置,左端点来到 $i + 1$ 的位置。
我们需要增加「新右端点」的值,即增加 $nums[i + n] \times (n - 1)$,同时减去「旧左端点」的值,即减少 $nums[i] \times 0$(固定为 $0$),然后更新新旧窗口的公共部分 $[i + 1, i + n - 1]$。
不难发现,随着窗口的逐步右移,每一位公共部分的权值系数都会进行减一。
$$
nums[i + 1] \times 1 + nums[i + 2] \times 2 + ... + nums[i + n - 1] \times (n - 1)
$$
变为
$$
nums[i + 1] \times 0 + nums[i + 2] \times 1 + ... + nums[i + n - 1] \times (n - 2)
$$
因此,公共部分的差值为 $\sum_{idx = i + 1}^{i + n - 1}nums[idx]$,这引导我们可以使用前缀和进行优化。
至此,我们从旧窗口到新窗口的过渡,都是 $O(1)$,整体复杂度为 $O(n)$。
> 实现上,我们并不需要真正对 $nums$ 进行复制拼接,而只需要在计算前缀和数组 $sum$ 进行简单的下标处理即可。
代码:
```Java
class Solution {
public int maxRotateFunction(int[] nums) {
int n = nums.length;
int[] sum = new int[n * 2 + 10];
for (int i = 1; i <= 2 * n; i++) sum[i] = sum[i - 1] + nums[(i - 1) % n];
int ans = 0;
for (int i = 1; i <= n; i++) ans += nums[i - 1] * (i - 1);
for (int i = n + 1, cur = ans; i < 2 * n; i++) {
cur += nums[(i - 1) % n] * (n - 1);
cur -= sum[i - 1] - sum[i - n];
if (cur > ans) ans = cur;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.396` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/397. 整数替换（中等）.md | 397. 整数替换 | https://leetcode-cn.com/problems/integer-replacement/solution/gong-shui-san-xie-yi-ti-san-jie-dfsbfs-t-373h/ | 中等 | [
"DFS",
"BFS",
"贪心"
] | 给定一个正整数 `n` ,你可以做如下操作:
1. 如果 `n` 是偶数,则用 `n / 2` 替换 `n` 。
2. 如果 `n` 是奇数,则可以用 `n + 1` 或 `n - 1` 替换 `n` 。
`n` 变为 $1$ 所需的最小替换次数是多少?
示例 1:
```
输入:n = 8
输出:3
解释:8 -> 4 -> 2 -> 1
```
示例 2:
```
输入:n = 7
输出:4
解释:7 -> 8 -> 4 -> 2 -> 1
或 7 -> 6 -> 3 -> 2 -> 1
```
示例 3:
```
输入:n = 4
输出:2
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### DFS
运用 `DFS` 进行求解。为防止重复处理某些数值,可以使用「哈希表」进行记忆化。
代码:
```Java
class Solution {
Map<Long, Integer> map = new HashMap<>();
public int integerReplacement(int n) {
return dfs(n * 1L);
}
int dfs(long n) {
if (n == 1) return 0;
if (map.containsKey(n)) return map.get(n);
int ans = n % 2 == 0 ? dfs(n / 2) : Math.min(dfs(n + 1), dfs(n - 1));
map.put(n, ++ans);
return ans;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(\log{n})$
---
### BFS
同理,也可以使用 `BFS` 进行求解。同样使用「哈希表」记录步数,进行防止重复处理。
代码:
```Java
class Solution {
public int integerReplacement(int n) {
if (n == 1) return 0;
Map<Long, Integer> map = new HashMap<>();
Deque<Long> d = new ArrayDeque<>();
d.addLast(n * 1L);
map.put(n * 1L, 0);
while (!d.isEmpty()) {
long t = d.pollFirst();
int step = map.get(t);
long[] ns = t % 2 == 0 ? new long[]{t / 2} : new long[]{t + 1, t - 1};
for (long x : ns) {
if (x == 1) return step + 1;
if (!map.containsKey(x)) {
map.put(x, step + 1);
d.addLast(x);
}
}
}
return -1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(\log{n})$
---
### 贪心(位运算)
上述两种做法,我们不可避免地在每个回合枚举了所有我们可以做的决策:主要体现在对 $x$ 为奇数时的处理,我们总是处理 $x + 1$ 和 $x - 1$ 两种情况。
我们可以从二进制的角度进行分析:**给定起始值 $n$,求解将其变为 $(000...0001)_2$ 的最小步数。**
* 对于偶数(二进制最低位为 $0$)而言,我们只能进行一种操作,其作用是将当前值 $x$ 其进行一个单位的右移;
* 对于奇数(二进制最低位为 $1$)而言,我们能够进行 `+1` 或 `-1` 操作,分析两种操作为 $x$ 产生的影响:
* 对于 `+1` 操作而言:最低位必然为 $1$,此时如果次低位为 $0$ 的话, `+1` 相当于将最低位和次低位交换;如果次低位为 $1$ 的话,`+1` 操作将将「从最低位开始,连续一段的 $1$」进行消除(置零),并在连续一段的高一位添加一个 $1$;
* 对于 `-1` 操作而言:最低位必然为 $1$,其作用是将最低位的 $1$ 进行消除。
因此,对于 $x$ 为奇数所能执行的两种操作,`+1` 能够消除连续一段的 $1$,只要次低位为 $1$(存在连续段),应当优先使用 `+1` 操作,但需要注意边界 $x = 3$ 时的情况(此时选择 `-1` 操作)。
代码:
```Java
class Solution {
public int integerReplacement(int _n) {
long n = _n;
int ans = 0;
while (n != 1) {
if (n % 2 == 0) {
n >>= 1;
} else {
if (n != 3 && ((n >> 1) & 1) == 1) n++;
else n--;
}
ans++;
}
return ans;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.397` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/398. 随机数索引（中等）.md | 398. 随机数索引 | https://leetcode-cn.com/problems/random-pick-index/solution/by-ac_oier-zhml/ | 中等 | [
"哈希表",
"模拟",
"随机化",
"蓄水池抽样"
] | 给定一个可能含有重复元素的整数数组,要求随机输出给定的数字的索引。 您可以假设给定的数字一定存在于数组中。
注意:
数组大小可能非常大。 使用太多额外空间的解决方案将不会通过测试。
示例:
```
int[] nums = new int[] {1,2,3,3,3};
Solution solution = new Solution(nums);
// pick(3) 应该返回索引 2,3 或者 4。每个索引的返回概率应该相等。
solution.pick(3);
// pick(1) 应该返回 0。因为只有nums[0]等于1。
solution.pick(1);
```
提示:
* $1 <= nums.length <= 2 * 10^4$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* `target` 确保存在于 `nums` 中
* 最多调用 $10^4$ 次的 `pick` | ### 哈希表 预处理(定长数据流)
切换英文补全一下数据范围:
* $1 <= nums.length <= 2 * 10^4$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* `target` 确保存在于 `nums` 中
* 最多调用 $10^4$ 次的 `pick`
为了方便,我们令 `nums` 的长度为 $n$,利用 $n$ 的数据范围为 $2 * 10^4$,且完整的数组为初始化时已给出,我们可以通过使用「哈希表 + 预处理」的方式进行求解。
具体的,在构造函数传入 `nums` 时,遍历 `nums` 并存储每个 $nums[i]$ 对应的下标集合,即使用哈希表以 $nums[i]$ 为键,下标集合 `List` 作为值进行存储。
在 `pick` 操作时,通过 $O(1)$ 的复杂度取出所有 $nums[i] = target$ 的集合下标,再随机一个下标进行返回。
代码:
```Java
class Solution {
Random random = new Random();
Map<Integer, List<Integer>> map = new HashMap<>();
public Solution(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
List<Integer> list = map.getOrDefault(nums[i], new ArrayList<>());
list.add(i);
map.put(nums[i], list);
}
}
public int pick(int target) {
List<Integer> list = map.get(target);
return list.get(random.nextInt(list.size()));
}
}
```
* 时间复杂度:初始化的复杂度为 $O(n)$;`pick` 操作的复杂度为 $O(1)$
* 空间复杂度:$O(n)$
---
### 蓄水池抽样(不定长数据流)
若 `nums` 并不是在初始化时完全给出,而是持续以「流」的形式给出,且数据流的很长,不便进行预处理的话,我们只能使用「蓄水池抽样」的方式求解。
**不了解「蓄水池抽样」的同学可以看前置 🧀 : [多语言入门「蓄水池抽样」知识点](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490892&idx=1&sn=c1fe373edc88142cbabd383ef3c0669b)**
具体的,我们在每次 `pick` 时对流进行遍历,由于数据流很大,我们不能在遍历过程中使用诸如数组的容器存储所有满足条件的下标,只能对于每个 $nums[i] = target$ 执行「是否要将 $i$ 作为最新答案候选」的操作。
假设共有 $m$ 个下标满足 $nums[i] = target$,我们需要做到以 $\frac{1}{m}$ 概率返回任一坐标。
我们规定当遇到第 $k$ 个满足 $nums[i] = target$ 的下标时,执行一次 $[0, k)$ 的随机操作,当随机结果为 $0$ 时(发生概率为 $\frac{1}{k}$),我们将该坐标作为最新的答案候选。
当对每一个 $nums[i] = target$ 的下标都进行上述操作后,容易证明每一位下标返回的概率均为 $\frac{1}{m}$。
假设最后返回的是第 $k$ 个满足条件的下标,发生概率为 = 第 $k$ 个下标被候选的概率 $\times$ 后面 $k + 1$ 到 $m$ 个下标不被候选的概率 = $\frac{1}{k} \times (1 - \frac{1}{k + 1}) \times ... \times (1 - \frac{1}{m})$ = $\frac{1}{m}$ 。
代码:
```Java
class Solution {
Random random = new Random();
int[] nums;
public Solution(int[] _nums) {
nums = _nums;
}
public int pick(int target) {
int n = nums.length, ans = 0;
for (int i = 0, cnt = 0; i < n; i++) {
if (nums[i] == target) {
cnt++;
if (random.nextInt(cnt) == 0) ans = i;
}
}
return ans;
}
}
```
* 时间复杂度:初始化的复杂度为 $O(1)$;`pick` 操作的复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.398` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/391-400/400. 第 N 位数字（中等）.md | 400. 第 N 位数字 | https://leetcode-cn.com/problems/nth-digit/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-w5wl/ | 中等 | [
"数学",
"模拟"
] | 给你一个整数 $n$ ,请你在无限的整数序列 `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]` 中找出并返回第 $n$ 位数字。
示例 1:
```
输入:n = 3
输出:3
```
示例 2:
```
输入:n = 11
输出:0
解释:第 11 位数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是 0 ,它是 10 的一部分。
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 模拟
我们知道,对于长度为 $len$ 的数字的范围为 $[10^{len - 1}, 10^{len} - 1]$(共 $9 * 10^{len - 1}$ 个),总长度为:
$$
L = len * 9 * 10^{len - 1}
$$
因此我们可以先对 $n$ 进行不断试减(更新 $n$),确定下来目标数字 $x$ 的长度为多少,假设为 $len$。
然后直接计算出长度 $len$ 的最小值为 $s = 10^{len - 1}$,由于范围内的数长度都是 $len$,因此我们可以直接定位到目标数字 $x$ 为何值。
根据目标值 $x$ 必然满足关系式:
$$
(x - s + 1) * len \geq n
$$
变形可得:
$$
x \geq \left \lfloor \frac{n}{len} \right \rfloor - 1 + s
$$
对 $n$ 进行最后一次的试减(更新 $n$),若恰好有 $n = 0$,说明答案为 $x$ 的最后一位,可由 `x % 10` 取得;若大于 $0$,说明答案是 $x + 1$ 的第 $n$ 位(十进制表示,从左往右数),可由 `(x + 1) / (int) (Math.pow(10, len - n)) % 10` 取得。
代码:
```Java
class Solution {
public int findNthDigit(int n) {
int len = 1;
while (len * 9 * Math.pow(10, len - 1) < n) {
n -= len * 9 * Math.pow(10, len - 1);
len++;
}
long s = (long) Math.pow(10, len - 1);
long x = n / len - 1 + s;
n -= (x - s + 1) * len;
return n == 0 ? (int) (x % 10) : (int) ((x + 1) / Math.pow(10, len - n) % 10);
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 补充
看到评论区,不少小伙伴对上述推导理解感到困难。我们可以换个思路,从更加纯粹直接的角度进行分析。
首先和上述解法一样,我们还是需要先对 $n$ 进行第一阶段的试减(更新 $n$),得到目标数字所在的数值的长度 $len$ 是多少。
然后根据 $len$ 我们可以算得起点值 $s = 10^{len - 1}$(例如 $len = 2$ 时,$s = 10$;$len = 3$ 时,$s = 100$)。
由于每个数长度都是 $len$,因此我们可以用剩余的数 $n$ 除 $len$,得到从起点的偏移量是多少(并将偏移量累加更新到 $s$),然后对 $n$ 做第二阶段的试减,减去的值就是 $\left \lfloor \frac{n}{len} \right \rfloor * len$。
如果试减后结果恰好为 $0$,那么答案为当前 $s$ 的最后一个数字;否则(试减结果大于 $0$),则是 $x + 1$ 中(十进制表示,从左往右数)的第 $n$ 个数字。
代码:
```Java
class Solution {
public int findNthDigit(int n) {
int len = 1;
while (len * 9 * Math.pow(10, len - 1) < n) {
n -= len * 9 * Math.pow(10, len - 1);
len++;
}
long s = (long) Math.pow(10, len - 1);
s += n / len - 1;
n -= len * (n / len);
return n == 0 ? (int) (s % 10) : (int) ((s + 1) / Math.pow(10, len - n) % 10);
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
**最终你会发现,两种做法是完全等价的,只是对应了不同的角度描述而已。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.400` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/401. 二进制手表（简单）.md | 401. 二进制手表 | https://leetcode-cn.com/problems/binary-watch/solution/gong-shui-san-xie-jian-dan-ti-xue-da-bia-gwn2/ | 简单 | [
"打表",
"二进制"
] | 二进制手表顶部有 4 个 LED 代表 小时(0-11),底部的 6 个 LED 代表 分钟(0-59)。每个 LED 代表一个 0 或 1,最低位在右侧。
例如,下面的二进制手表读取 "3:25" 。
(图源:WikiMedia - Binary clock samui moon.jpg ,许可协议:Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) )
给你一个整数 turnedOn ,表示当前亮着的 LED 的数量,返回二进制手表可以表示的所有可能时间。你可以 按任意顺序 返回答案。
小时不会以零开头:
例如,"01:00" 是无效的时间,正确的写法应该是 "1:00" 。
分钟必须由两位数组成,可能会以零开头:
例如,"10:2" 是无效的时间,正确的写法应该是 "10:02" 。
示例 1:
输入:turnedOn = 1
输出:["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]
示例 2:
输入:turnedOn = 9
输出:[]
提示:
* 0 <= turnedOn <= 10 | ### 打表
具体的,我们可以创建一个 `静态数据结构` 来存储打表信息(需确保全局唯一,即使存在多组测试数据只生成一次打表数据)。
然后在返回数据的时候直接 $O(1)$ 查表返回。
PS. 如果打表逻辑计算量接近 $10^7$ 上限,可以考虑放到本地去做,这里数据量较少,直接放到 `static` 代码块去做即可。
代码:
```Java
class Solution {
// 打表逻辑,也可以放到本地做
// 注意使用 static 修饰,确保打表数据只会被生成一次
static Map<Integer, List<String>> map = new HashMap<>();
static {
for (int h = 0; h <= 11; h++) {
for (int m = 0; m <= 59; m++) {
int tot = getCnt(h) + getCnt(m);
List<String> list = map.getOrDefault(tot, new ArrayList<String>());
list.add(h + ":" + (m <= 9 ? "0" + m : m));
map.put(tot, list);
}
}
}
static int getCnt(int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans++;
return ans;
}
static int lowbit(int x) {
return x & -x;
}
public List<String> readBinaryWatch(int t) {
return map.getOrDefault(t, new ArrayList<>());
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.401` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/403. 青蛙过河（困难）.md | 403. 青蛙过河 | https://leetcode-cn.com/problems/frog-jump/solution/gong-shui-san-xie-yi-ti-duo-jie-jiang-di-74fw/ | 困难 | [
"DFS",
"BFS",
"记忆化搜索",
"线性 DP"
] | 一只青蛙想要过河。 假定河流被等分为若干个单元格,并且在每一个单元格内都有可能放有一块石子(也有可能没有)。 青蛙可以跳上石子,但是不可以跳入水中。
给你石子的位置列表 stones(用单元格序号 升序 表示), 请判定青蛙能否成功过河(即能否在最后一步跳至最后一块石子上)。
开始时, 青蛙默认已站在第一块石子上,并可以假定它第一步只能跳跃一个单位(即只能从单元格 1 跳至单元格 2 )。
如果青蛙上一步跳跃了 k 个单位,那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1 个单位。 另请注意,青蛙只能向前方(终点的方向)跳跃。
示例 1:
```
输入:stones = [0,1,3,5,6,8,12,17]
输出:true
解释:青蛙可以成功过河,按照如下方案跳跃:跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, 接着 跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, 最后,跳 5 个单位到第 8 个石子(即最后一块石子)。
```
示例 2:
```
输入:stones = [0,1,2,3,4,8,9,11]
输出:false
解释:这是因为第 5 和第 6 个石子之间的间距太大,没有可选的方案供青蛙跳跃过去。
```
提示:
* 2 <= stones.length <= 2000
* 0 <= stones[i] <= $2^{31}$ - 1
* stones[0] == 0 | ### DFS(TLE)
根据题意,我们可以使用 `DFS` 来模拟/爆搜一遍,检查所有的可能性中是否有能到达最后一块石子的。
通常设计 `DFS` 函数时,我们只需要不失一般性的考虑完成第 $i$ 块石子的跳跃需要些什么信息即可:
* 需要知道当前所在位置在哪,也就是需要知道当前石子所在列表中的下标 $u$。
* 需要知道当前所在位置是经过多少步而来的,也就是需要知道上一步的跳跃步长 $k$。
代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
public boolean canCross(int[] ss) {
int n = ss.length;
// 将石子信息存入哈希表
// 为了快速判断是否存在某块石子,以及快速查找某块石子所在下标
for (int i = 0; i < n; i++) {
map.put(ss[i], i);
}
// check first step
// 根据题意,第一步是固定经过步长 1 到达第一块石子(下标为 1)
if (!map.containsKey(1)) return false;
return dfs(ss, ss.length, 1, 1);
}
/**
* 判定是否能够跳到最后一块石子
* @param ss 石子列表【不变】
* @param n 石子列表长度【不变】
* @param u 当前所在的石子的下标
* @param k 上一次是经过多少步跳到当前位置的
* @return 是否能跳到最后一块石子
*/
boolean dfs(int[] ss, int n, int u, int k) {
if (u == n - 1) return true;
for (int i = -1; i <= 1; i++) {
// 如果是原地踏步的话,直接跳过
if (k + i == 0) continue;
// 下一步的石子理论编号
int next = ss[u] + k + i;
// 如果存在下一步的石子,则跳转到下一步石子,并 DFS 下去
if (map.containsKey(next)) {
boolean cur = dfs(ss, n, map.get(next), k + i);
if (cur) return true;
}
}
return false;
}
}
```
* 时间复杂度:$O(3^n)$
* 空间复杂度:$O(3^n)$
但数据范围为 $10^3$,直接使用 DFS 肯定会超时。
**我们需要考虑加入「记忆化」功能,或者改为使用带标记的 `BFS`。**
---
### 记忆化搜索
**在考虑加入「记忆化」时,我们只需要将 `DFS` 方法签名中的【可变】参数作为维度,`DFS` 方法中的返回值作为存储值即可。**
通常我们会使用「数组」来作为我们缓存中间结果的容器,
对应到本题,就是需要一个 `boolean[石子列表下标][跳跃步数]` 这样的数组,但使用布尔数组作为记忆化容器往往无法区分「状态尚未计算」和「状态已经计算,并且结果为 `false`」两种情况。
因此我们需要转为使用 `int[石子列表下标][跳跃步数]`,默认值 $0$ 代表状态尚未计算,$-1$ 代表计算状态为 `false`,$1$ 代表计算状态为 `true`。
接下来需要估算数组的容量,可以从「数据范围」入手分析。
根据 `2 <= stones.length <= 2000`,我们可以确定第一维(数组下标)的长度为 $2009$,而另外一维(跳跃步数)是与跳转过程相关的,无法直接确定一个精确边界,但是一个显而易见的事实是,跳到最后一块石子之后的位置是没有意义的,因此我们不会有「跳跃步长」大于「石子列表长度」的情况,因此也可以定为 $2009$(这里是利用了由下标为 $i$ 的位置发起的跳跃不会超过 $i + 1$ 的性质)。
至此,我们定下来了记忆化容器为 `int[][] cache = new int[2009][2009]`。
但是可以看出,上述确定容器大小的过程还是需要一点点分析 & 经验的。
那么是否有思维难度再低点的方法呢?
答案是有的,直接使用「哈希表」作为记忆化容器。「哈希表」本身属于非定长容器集合,我们不需要分析两个维度的上限到底是多少。
**另外,当容器维度较多且上界较大时(例如上述的 `int[2009][2009]`),直接使用「哈希表」可以有效降低「爆空间/时间」的风险(不需要每跑一个样例都创建一个百万级的数组)。**
代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
// int[][] cache = new int[2009][2009];
Map<String, Boolean> cache = new HashMap<>();
public boolean canCross(int[] ss) {
int n = ss.length;
for (int i = 0; i < n; i++) {
map.put(ss[i], i);
}
// check first step
if (!map.containsKey(1)) return false;
return dfs(ss, ss.length, 1, 1);
}
boolean dfs(int[] ss, int n, int u, int k) {
String key = u + "_" + k;
// if (cache[u][k] != 0) return cache[u][k] == 1;
if (cache.containsKey(key)) return cache.get(key);
if (u == n - 1) return true;
for (int i = -1; i <= 1; i++) {
if (k + i == 0) continue;
int next = ss[u] + k + i;
if (map.containsKey(next)) {
boolean cur = dfs(ss, n, map.get(next), k + i);
// cache[u][k] = cur ? 1 : -1;
cache.put(key, cur);
if (cur) return true;
}
}
// cache[u][k] = -1;
cache.put(key, false);
return false;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### 动态规划
有了「记忆化搜索」的基础,要写写出来动态规划就变得相对简单了。
**我们可以从 `DFS` 函数出发,写出「动态规划」解法。**
我们的 `DFS` 函数签名为:
```Java
boolean dfs(int[] ss, int n, int u, int k);
```
其中前两个参数为不变参数,后两个为可变参数,返回值是我们的答案。
因此可以设定为 $f[][]$ 作为动规数组:
1. 第一维为可变参数 $u$,代表石子列表的下标,范围为数组 `stones` 长度;
2. 第二维为可变参数 $k$,代表上一步的的跳跃步长,前面也分析过了,最多不超过数组 `stones` 长度。
**这样的「状态定义」所代表的含义:当前在第 $i$ 个位置,并且是以步长 $k$ 跳到位置 $i$ 时,是否到达最后一块石子。**
那么对于 $f[i][k]$ 是否为真,则取决于上一位置 $j$ 的状态值,结合每次步长的变化为 `[-1,0,1]` 可知:
* 可从 $f[j][k - 1]$ 状态而来:先是经过 $k - 1$ 的跳跃到达位置 $j$,再在原步长的基础上 `+1`,跳到了位置 $i$。
* 可从 $f[j][k]$ 状态而来:先是经过 $k$ 的跳跃到达位置 $j$,维持原步长不变,跳到了位置 $i$。
* 可从 $f[j][k + 1]$ 状态而来:先是经过 $k + 1$ 的跳跃到达位置 $j$,再在原步长的基础上 `-1`,跳到了位置 $i$。
只要上述三种情况其中一种为真,则 $f[i][j]$ 为真。
至此,我们解决了动态规划的「状态定义」&「状态转移方程」部分。
但这就结束了吗?还没有。
我们还缺少可让状态递推下去的「有效值」,或者说缺少初始化环节。
因为我们的 $f[i][k]$ 依赖于之前的状态进行“或运算”而来,转移方程本身不会产生 $true$ 值。因此为了让整个「递推」过程可滚动,我们需要先有一个为 $true$ 的状态值。
这时候再回看我们的状态定义:**当前在第 $i$ 个位置,并且是以步长 $k$ 跳到位置 $i$ 时,是否到达最后一块石子。**
显然,我们事先是不可能知道经过「多大的步长」跳到「哪些位置」,最终可以到达最后一块石子。
**这时候需要利用「对偶性」将跳跃过程「翻转」过来分析:**
**我们知道起始状态是「经过步长为 1」的跳跃到达「位置 1」,如果从起始状态出发,存在一种方案到达最后一块石子的话,那么必然存在一条反向路径,它是以从「最后一块石子」开始,并以「某个步长 $k$」开始跳跃,最终以回到位置 1。**
因此我们可以设 $f[1][1] = true$,作为我们的起始值。
**这里本质是利用「路径可逆」的性质,将问题进行了「等效对偶」。表面上我们是进行「正向递推」,但事实上我们是在验证是否存在某条「反向路径」到达位置 $1$。**
建议大家加强理解 ~
代码:
```Java
class Solution {
public boolean canCross(int[] ss) {
int n = ss.length;
// check first step
if (ss[1] != 1) return false;
boolean[][] f = new boolean[n + 1][n + 1];
f[1][1] = true;
for (int i = 2; i < n; i++) {
for (int j = 1; j < i; j++) {
int k = ss[i] - ss[j];
// 我们知道从位置 j 到位置 i 是需要步长为 k 的跳跃
// 而从位置 j 发起的跳跃最多不超过 j + 1
// 因为每次跳跃,下标至少增加 1,而步长最多增加 1
if (k <= j + 1) {
f[i][k] = f[j][k - 1] || f[j][k] || f[j][k + 1];
}
}
}
for (int i = 1; i < n; i++) {
if (f[n - 1][i]) return true;
}
return false;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$
---
### BFS
事实上,前面我们也说到,解决超时 `DFS` 问题,除了增加「记忆化」功能以外,还能使用带标记的 `BFS`。
**因为两者都能解决 `DFS` 的超时原因:大量的重复计算。**
但为了「记忆化搜索」&「动态规划」能够更好的衔接,所以我把 `BFS` 放到最后。
如果你能够看到这里,那么这里的 `BFS` 应该看起来会相对轻松。
它更多是作为「记忆化搜索」的另外一种实现形式。
代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
public boolean canCross(int[] ss) {
int n = ss.length;
for (int i = 0; i < n; i++) {
map.put(ss[i], i);
}
// check first step
if (!map.containsKey(1)) return false;
boolean[][] vis = new boolean[n][n];
Deque<int[]> d = new ArrayDeque<>();
vis[1][1] = true;
d.addLast(new int[]{1, 1});
while (!d.isEmpty()) {
int[] poll = d.pollFirst();
int idx = poll[0], k = poll[1];
if (idx == n - 1) return true;
for (int i = -1; i <= 1; i++) {
if (k + i == 0) continue;
int next = ss[idx] + k + i;
if (map.containsKey(next)) {
int nIdx = map.get(next), nK = k + i;
if (nIdx == n - 1) return true;
if (!vis[nIdx][nK]) {
vis[nIdx][nK] = true;
d.addLast(new int[]{nIdx, nK});
}
}
}
}
return false;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.403` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/405. 数字转换为十六进制数（简单）.md | 405. 数字转换为十六进制数 | https://leetcode-cn.com/problems/convert-a-number-to-hexadecimal/solution/gong-shui-san-xie-yi-ti-shuang-jie-jin-z-d93o/ | 简单 | [
"位运算",
"模拟"
] | 给定一个整数,编写一个算法将这个数转换为十六进制数。对于负整数,我们通常使用 补码运算 方法。
注意:
1. 十六进制中所有字母(a-f)都必须是小写。
2. 十六进制字符串中不能包含多余的前导零。如果要转化的数为0,那么以单个字符'0'来表示;对于其他情况,十六进制字符串中的第一个字符将不会是0字符。
3. 给定的数确保在32位有符号整数范围内。
4. 不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。
示例 1:
```
输入:26
输出:"1a"
```
示例 2:
```
输入:-1
输出:"ffffffff"
``` | ### 模拟 + 进制转换
首先,我们可以利用通用的进制转换思路来做,不断循环 `num % k` 和 `num / k` 的操作来构造出 $k$ 进制每一位。
但需要处理「补码」问题:对于负数的 $num$,我们需要先在 $num$ 基础上加上 $2^{32}$ 的偏移量,再进行进制转换。
代码:
```Java
class Solution {
public String toHex(int _num) {
if (_num == 0) return "0";
long num = _num;
StringBuilder sb = new StringBuilder();
if(num < 0) num = (long)(Math.pow(2, 32) + num);
while (num != 0) {
long u = num % 16;
char c = (char)(u + '0');
if (u >= 10) c = (char)(u - 10 + 'a');
sb.append(c);
num /= 16;
}
return sb.reverse().toString();
}
}
```
* 时间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$
* 空间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$
---
### 位运算 + 分组换算
将长度为 $32$ 的二进制转换为 $16$ 进制数,本质是对长度为 $32$ 的二进制数进行分组,每 $4$ 个一组(二进制 $(1111)_2$ 表示 $15$,则使用长度为 $4$ 的二进制可以表示 `0-15`)。
同时,由于我们是直接对长度为 $32$ 的二进制进行分组转算($4$ 个为一组,共 $8$ 组),而长度为 $32$ 的二进制本身就是使用补码规则来表示的,因此我们无须额外处理「补码」问题。
具体的,我们将 $num$ 与 $15$ = $(1111)_2$ 进行 `&` 运算,然后对 $num$ 进行无符号右移 $4$ 位来实现每 $4$ 位处理。
代码:
```Java
class Solution {
public String toHex(int num) {
if (num == 0) return "0";
StringBuilder sb = new StringBuilder();
while (num != 0) {
int u = num & 15;
char c = (char)(u + '0');
if (u >= 10) c = (char)(u - 10 + 'a');
sb.append(c);
num >>>= 4;
}
return sb.reverse().toString();
}
}
```
* 时间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$
* 空间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.405` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/406. 根据身高重建队列（中等）.md | 406. 根据身高重建队列 | https://leetcode.cn/problems/queue-reconstruction-by-height/solution/by-ac_oier-fda2/ | 中等 | [
"排序",
"构造",
"二分",
"树状数组"
] | 假设有打乱顺序的一群人站成一个队列,数组 `people` 表示队列中一些人的属性(不一定按顺序)。每个 $people[i] = [h_i, k_i]$ 表示第 $i$ 个人的身高为 $h_i$ ,前面 正好 有 $k_i$ 个身高大于或等于 $h_i$ 的人。
请你重新构造并返回输入数组 `people` 所表示的队列。返回的队列应该格式化为数组 `queue` ,其中 $queue[j] = [h_j, k_j]$ 是队列中第 $j$ 个人的属性($queue[0]$ 是排在队列前面的人)。
示例 1:
```
输入:people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出:[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释:
编号为 0 的人身高为 5 ,没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ,没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ,有 2 个身高更高或者相同的人排在他前面,即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ,有 1 个身高更高或者相同的人排在他前面,即编号为 1 的人。
编号为 4 的人身高为 4 ,有 4 个身高更高或者相同的人排在他前面,即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ,有 1 个身高更高或者相同的人排在他前面,即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。
```
示例 2:
```
输入:people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
输出:[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]
```
提示:
* $1 <= people.length <= 2000$
* $0 <= h_i <= 10^6$
* $0 <= k_i < people.length$
* 题目数据确保队列可以被重建 | ### 构造 + 二分 + 树状数组
这是一道非常综合的题目。
首先根据双关键字排序:当「高度(第一维)」不同,根据高度排升序,对于高度相同的情况,则根据「编号(第二维)」排降序。
采取这样的排序规则的好处在于:**在从前往后处理某个 $people[i]$ 时,我们可以直接将其放置在「当前空位序列(从左往后统计的,不算已被放置的位置)」中的 $people[i][1] + 1$ 位(预留了前面的 $people[i][1]$ 个位置给后面的数)。**
关于「空位序列」如图所示(黄色代表已被占用,白色代表尚未占用):
具体的,我们按照构造的合理性来解释双关键字排序的合理性,假设当前处理的是 $people[i]$:
根据「高度」排升序,根据「编号」排降序:由于首先是根据「高度」排升序,因此当 $people[i]$ 被放置在「当前空位序列」的第 $people[i][1] + 1$ 之后,无论后面的 $people[j]$ 如何放置,都不会影响 $people[i]$ 的合法性:后面的数的高度都不低于 $people[i][0]$,无论放在 $people[i][1] + 1$ 前面还是后面都不会影响 $people[i]$ 的合法性。
同时对于高度(第一维)相同,编号(第二维)不同的情况,我们进行了「降序」处理,因此「每次将 $people[i]$ 放置在空白序列的 $people[i][1] + 1$ 位置的」的逻辑能够沿用:
**对于「高度」相同「编号」不同的情况,会被按照「从右到左」依次放置,导致了每个 $people[i]$ 被放置时,都不会受到「高度」相同的其他 $people[j]$ 所影响。换句话说,当 $people[i]$ 放置时,其左边必然不存在其他高度为 $people[i][0]$ 的成员。**
剩下的在于,如何快速找到「空白序列中的第 $k$ 个位置」,这可以通过「二分 + 树状数组」来做:
对于已被使用的位置标记为 $1$,未使用的位置为 $0$,那么第一个满足「$0$ 的个数大于等于 $k + 1$」的位置即是目标位置,在长度明确的情况下,求 $0$ 的个数和求 $1$ 的个数等同,对于位置 $x$ 而言(下标从 $1$ 开始,总个数为 $x$),如果在 $[1, x]$ 范围内有 $k + 1$ 个 $0$,等价于有 $x - (k + 1)$ 个 $1$。
求解 $[1, x]$ 范围内 $1$ 的个数等价于求前缀和,即「区间查询」,同时我们每次使用一个新的位置后 ,需要对其进行标记,涉及「单点修改」,因此使用「树状数组」进行求解。
代码:
```Java
class Solution {
int n;
int[] tr;
int lowbit(int x) {
return x & -x;
}
void add(int x, int v) {
for (int i = x; i <= n; 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[][] reconstructQueue(int[][] ps) {
Arrays.sort(ps, (a, b)->{
if (a[0] != b[0]) return a[0] - b[0];
return b[1] - a[1];
});
n = ps.length;
tr = new int[n + 1];
int[][] ans = new int[n][2];
for (int[] p : ps) {
int h = p[0], k = p[1];
int l = 1, r = n;
while (l < r) {
int mid = l + r >> 1;
if (mid - query(mid) >= k + 1) r = mid;
else l = mid + 1;
}
ans[r - 1] = p;
add(r, 1);
}
return ans;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$;共要处理 $n$ 个 $people[i]$,每次处理需要二分,复杂度为 $O(\log{n})$;每次二分和找到答案后需要操作树状数组,复杂度为 $O(\log{n})$。整体复杂度为 $O(n \times \log{n} \times \log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.406` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/401-410/407. 接雨水 II（困难）.md | 407. 接雨水 II | https://leetcode-cn.com/problems/trapping-rain-water-ii/solution/gong-shui-san-xie-jing-dian-dijkstra-yun-13ik/ | 困难 | [
"最短路",
"优先队列(堆)"
] | 给你一个 $m x n$ 的矩阵,其中的值均为非负整数,代表二维高度图每个单元的高度,请计算图中形状最多能接多少体积的雨水。
示例 1:
```
输入: heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]
输出: 4
解释: 下雨后,雨水将会被上图蓝色的方块中。总的接雨水量为1+2+1=4。
```
示例 2:
```
输入: heightMap = [[3,3,3,3,3],[3,2,2,2,3],[3,2,1,2,3],[3,2,2,2,3],[3,3,3,3,3]]
输出: 10
```
提示:
* m == heightMap.length
* n == heightMap[i].length
* 1 <= m, n <= 200
* $0 <= heightMap[i][j] <= 2 * 10^4$ | ### Dijkstra 变形 + 优先队列(堆)
首先,最外层的一圈(边界)是不会接到任何雨水的(会从边界流出)。
我们定义从点 $(x, y)$ 到边界的路径中出现的最大高度为「路径高度」,路径高度 $h$ 必然满足 $h >= heightMap[x][y]$。
**问题的本质是求「从点 $(x, y)$ 到边界的所有路径高度的最小值为多少」,这个路径高度的最小值与 $(x, y)$ 本身的高度 $heightMap[x][y]$ 之间的差值,即是该点能接到的雨水数量。**
> PS. 对此觉得不好理解的同学,可以尝试从现实角度出发进行考虑:假如该位置是出水口(能够源源不断的出水并往各个方向蔓延),那么该位置最终承载多少水,取决于所有路径高度中的最小值(水流最终会被该路径高度的最小值所拦截),即出水口最终形成的水量为「路径高度最小值」与「出水口起始高度」之间的差值。
我们考虑如何计算某个位置 $(x, y)$ 的所有路径高度中的最小值。
如果是求从 $(x, y)$ 出发的所有路径中,路径总和的最小值,那么可以直接使用 Dijkstra 等单源最短路算法来进行求解。
本题求的是所有路径中,路径高度的最小值,需要对 Dijkstra 进行变形。
首先「从 $(x, y)$ 出发到达边界的路径」也可看作「从边界到达点 $(x, y)$ 的路径」,经过转换操作后,直接计算边界到点 $(x, y)$ 的路径是一个多源点问题。
我们可以考虑引入「超级源点」进行简化:超级源点与所有的边界格子连有一条权值为 $0$ 的边,从而进一步将问题转化为「求从超级源点出发到达 $(x, y)$ 的路径高度的最小值」。
与求最短路的 Dijkstra 类似,我们可以将「使用出队元素更新邻点的松弛操作」等价「使用出队元素更新相邻格子的雨水量」。
**如果我们能够保证被出队元素所更新的高度为最终高度(或者说出队元素的高度为最终高度),那么该做法的正确性就能被 Dijkstra 的正确性所保证。**
我们知道,对于边界格子而言,由于其不能接到任何雨水(即最终高度为起始高度),因此它们可以先进行入队。
然后考虑如何出队并更新邻点可以确保正确性。
对于某个位置 $(x, y)$ 而言,根据「木桶原理」,其最终高度取决于四个方向的邻点的最终高度的最小值。
这引导我们使用优先队列(堆)来做:建立一个小根堆,存储 $(x, y, h)$ 三元组信息( $h$ 为 位置 $(x, y)$ 的最终高度),每次使用出队元素来更新邻点,由于是小根堆,可以确保出队元素是被更新的元素的最小高度的邻点,并且被更新元素会被更新为最终高度,然后将被更新元素进行入队,重复此过程,直到所有位置均被更新。
> 实现上,我们不需要真将超级源点建立出来,只需要起始将所有边界点放入优先队列即可。同时由于每个点只有被第一个出队元素所更新的高度为最终高度,我们还需要使用 $vis$ 数组来避免重复更新。
代码:
```Java
class Solution {
public int trapRainWater(int[][] heightMap) {
int m = heightMap.length, n = heightMap[0].length;
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[2]-b[2]);
boolean[][] vis = new boolean[m][n];
for (int i = 0; i < n; i++) {
q.add(new int[]{0, i, heightMap[0][i]});
q.add(new int[]{m - 1, i, heightMap[m - 1][i]});
vis[0][i] = vis[m - 1][i] = true;
}
for (int i = 1; i < m - 1; i++) {
q.add(new int[]{i, 0, heightMap[i][0]});
q.add(new int[]{i, n - 1, heightMap[i][n - 1]});
vis[i][0] = vis[i][n - 1] = true;
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
int ans = 0;
while (!q.isEmpty()) {
int[] poll = q.poll();
int x = poll[0], y = poll[1], h = poll[2];
for (int[] d : dirs) {
int nx = x + d[0], ny = y + d[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (vis[nx][ny]) continue;
if (h > heightMap[nx][ny]) ans += h - heightMap[nx][ny];
q.add(new int[]{nx, ny, Math.max(heightMap[nx][ny], h)});
vis[nx][ny] = true;
}
}
return ans;
}
}
```
* 时间复杂度:所有的点均进出一次优先队列(堆),复杂度为 $O((m * n)\log{(m * n)})$
* 空间复杂度:$O(m * n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.407` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/41. 缺失的第一个正数（困难）.md | 41. 缺失的第一个正数 | https://leetcode-cn.com/problems/first-missing-positive/solution/yan-ge-on-de-tong-pai-xu-si-lu-yi-ji-wei-wm8d/ | 困难 | [
"桶排序",
"原地哈希"
] | 给你一个未排序的整数数组 `nums` ,请你找出其中没有出现的最小的正整数。
**进阶**:你可以实现时间复杂度为 $O(n)$ 并且只使用常数级别额外空间的解决方案吗?
示例 1:
```
输入:nums = [1,2,0]
输出:3
```
示例 2:
```
输入:nums = [3,4,-1,1]
输出:2
```
示例 3:
```
输入:nums = [7,8,9,11,12]
输出:1
```
提示:
* $0 <= nums.length <= 300$
* $-2^{31} <= nums[i] <= 2^{31} - 1$ | ### 桶排序(原地哈希)
令数组长度为 `n`,那么答案必然在 `[1, n + 1]` 范围内。
**因此我们可以使用「桶排序」的思路,将每个数放在其应该出现的位置上。**
基本思路为:
1. 按照桶排序思路进行预处理:保证 1 出现在 `nums[0]` 的位置上,2 出现在 `nums[1]` 的位置上,...,`n` 出现在 `nums[n - 1]` 的位置上。不在 `[1, n]` 范围内的数不用动。
例如样例中 `[3,4,-1,1]` 将会被预处理成 `[1,-1,3,4]`。
2. 遍历 `nums`,找到第一个不在应在位置上的 `[1, n]` 的数。如果没有找到,说明数据连续,答案为 `n + 1`
例如样例预处理后的数组 `[1,-1,3,4]` 中第一个 `nums[i] != i + 1` 的是数字 2(i = 1)。
代码:
```Java
class Solution {
public int firstMissingPositive(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
while (nums[i] >= 1 && nums[i] <= n && nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {
swap(nums, i, nums[i] - 1);
}
}
for (int i = 0; i < n; i++) {
if (nums[i] != i + 1) return i + 1;
}
return n + 1;
}
void swap(int[] nums, int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
}
```
* 时间复杂度:每个数字应该被挪动的数都会被一次性移动到目标位置。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.41` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/42. 接雨水（困难）.md | 42. 接雨水 | https://leetcode-cn.com/problems/trapping-rain-water/solution/po-su-jie-fa-on2-cha-zhao-you-hua-on-dan-iu44/ | 困难 | [
"模拟",
"单调栈",
"数学"
] | 给定 `n` 个非负整数表示每个宽度为 `1` 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。
示例 1:
```
输入:height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出:6
解释:上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图,在这种情况下,可以接 6 个单位的雨水(蓝色部分表示雨水)。
```
示例 2:
```
输入:height = [4,2,0,3,2,5]
输出:9
```
提示:
* $n = height.length$
* $0 <= n <= 2 \times 10^4$
* $0 <= height[i] <= 10^5$ | ### 模拟
对每根柱子而言,我们先找出其「左边最高的柱子」和「右边最高的柱子」。
对左右最高柱子取较小值,再和当前柱子高度做比较,即可得出当前位置可以接下的雨水。
同时,边缘的柱子不可能接到雨水(某一侧没有柱子)。
最后注意:该解法计算量会去到 $n^2 = 4 \times 10^8$,一旦计算量上界接近 $10^7$,我们就需要考虑 `TLE`(超时)问题,在 LeetCode 上该解法 `C++` 无法通过,其他语言目前还能通过。
Java 代码:
```Java
class Solution {
public int trap(int[] height) {
int n = height.length;
int ans = 0;
for (int i = 1; i < n - 1; i++) {
int cur = height[i];
// 获取当前位置的左边最大值
int l = Integer.MIN_VALUE;
for (int j = i - 1; j >= 0; j--) l = Math.max(l, height[j]);
if (l <= cur) continue;
// 获取当前位置的右边边最大值
int r = Integer.MIN_VALUE;
for (int j = i + 1; j < n; j++) r = Math.max(r, height[j]);
if (r <= cur) continue;
// 计算当前位置可接的雨水
ans += Math.min(l, r) - cur;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int trap(vector<int>& height) {
int n = height.size();
int ans = 0;
for (int i = 1; i < n - 1; i++) {
int cur = height[i];
// 获取当前位置的左边最大值
int l = INT_MIN;
for (int j = i - 1; j >= 0; j--) l = max(l, height[j]);
if (l <= cur) continue;
// 获取当前位置的右边边最大值
int r = INT_MIN;
for (int j = i + 1; j < n; j++) r = max(r, height[j]);
if (r <= cur) continue;
// 计算当前位置可接的雨水
ans += min(l, r) - cur;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def trap(self, height: List[int]) -> int:
n = len(height)
ans = 0
for i in range(1, n - 1):
cur = height[i]
# 获取当前位置的左边最大值
l = max(height[:i])
if l <= cur: continue
# 获取当前位置的右边最大值
r = max(height[i + 1:])
if r <= cur: continue
# 计算当前位置可接的雨水
ans += min(l, r) - cur
return ans
```
TypeScript 代码:
```TypeScript
function trap(height: number[]): number {
const n = height.length;
let ans = 0;
for (let i = 1; i < n - 1; i++) {
const cur = height[i];
// 获取当前位置的左边最大值
const l = Math.max(...height.slice(0, i));
if (l <= cur) continue;
// 获取当前位置的右边最大值
const r = Math.max(...height.slice(i + 1));
if (r <= cur) continue;
// 计算当前位置可接的雨水
ans += Math.min(l, r) - cur;
}
return ans;
};
```
* 时间复杂度:需要处理所有非边缘的柱子,复杂度为 $O(n)$;对于每根柱子而言,需要往两边扫描分别找到最大值,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(1)$
---
### 预处理最值
朴素解法的思路有了,我们想想怎么优化。
事实上,任何的优化无非都是「减少重复」。
想想在朴素思路中有哪些环节比较耗时,耗时环节中又有哪些地方是重复的,可以优化的。
首先对每根柱子进行遍历,求解每根柱子可以接下多少雨水,这个 $O(n)$ 操作肯定省不了。
**但在求解某根柱子可以接下多少雨水时,需要对两边进行扫描,求两侧的最大值。每一根柱子都进行这样的扫描操作,导致每个位置都被扫描了 $n$ 次。这个过程显然是可优化的。**
换句话说:**我们希望通过不重复遍历的方式找到任意位置的两侧最大值。**
问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**
一个很直观的方案是:**直接将某个位置的两侧最大值存起来。**
我们可以先从两端分别出发,预处理每个位置的「左右最值」,这样可以将我们「查找左右最值」的复杂度降到 $O(1)$。
整体算法的复杂度也从 $O(n^2)$ 下降到 $O(n)$。
Java 代码:
```Java
class Solution {
public int trap(int[] height) {
int n = height.length;
int ans = 0;
// 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下
if (n == 0) return ans;
// 预处理每个位置左边的最值
int[] lm = new int[n];
lm[0] = height[0];
for (int i = 1; i < n; i++) lm[i] = Math.max(height[i], lm[i - 1]);
// 预处理每个位置右边的最值
int[] rm = new int[n];
rm[n - 1] = height[n - 1];
for (int i = n - 2; i >= 0; i--) rm[i] = Math.max(height[i], rm[i + 1]);
for (int i = 1; i < n - 1; i++) {
int cur = height[i], l = lm[i], r = rm[i];
if (l <= cur || r <= cur) continue;
ans += Math.min(l, r) - cur;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int trap(vector<int>& height) {
int n = height.size(), ans = 0;
// 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下
if (n == 0) return ans;
vector<int> lm(n, 0), rm(n, 0);
// 预处理每个位置左边的最值
lm[0] = height[0];
for (int i = 1; i < n; i++) lm[i] = max(height[i], lm[i - 1]);
// 预处理每个位置右边的最值
rm[n - 1] = height[n - 1];
for (int i = n - 2; i >= 0; i--) rm[i] = max(height[i], rm[i + 1]);
for (int i = 1; i < n - 1; i++) {
int cur = height[i], l = lm[i], r = rm[i];
if (l <= cur || r <= cur) continue;
ans += min(l, r) - cur;
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def trap(self, height: List[int]) -> int:
n, ans = len(height), 0
# 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下
if n == 0: return ans
lm, rm = [0] * n, [0] * n
# 预处理每个位置左边的最值
lm[0] = height[0]
for i in range(1, n):
lm[i] = max(height[i], lm[i - 1])
# 预处理每个位置右边的最值
rm[n - 1] = height[n - 1]
for i in range(n - 2, -1, -1):
rm[i] = max(height[i], rm[i + 1])
for i in range(1, n - 1):
cur, l, r = height[i], lm[i], rm[i]
if l <= cur or r <= cur: continue
ans += min(l, r) - cur
return ans
```
TypeScript 代码:
```TypeScript
function trap(height: number[]): number {
let n = height.length, ans = 0;
// 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下
if (n == 0) return ans;
const lm = new Array(n).fill(0), rm = new Array(n).fill(0);
// 预处理每个位置左边的最值
lm[0] = height[0];
for (let i = 1; i < n; i++) lm[i] = Math.max(height[i], lm[i - 1]);
// 预处理每个位置右边的最值
rm[n - 1] = height[n - 1];
for (let i = n - 2; i >= 0; i--) rm[i] = Math.max(height[i], rm[i + 1]);
for (let i = 1; i < n - 1; i++) {
const cur = height[i], l = lm[i], r = rm[i];
if (l <= cur || r <= cur) continue;
ans += Math.min(l, r) - cur;
}
return ans;
};
```
* 时间复杂度:预处理出两个最大值数组,复杂度为 $O(n)$;计算每根柱子可接的雨水量,复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:使用了数组存储两侧最大值。复杂度为 $O(n)$
---
### 单调栈
前面我们讲到,优化思路将问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**
但仔细一想,其实我们并不需要找两侧最大值,只需要找到两侧最近的比当前位置高的柱子就行了。
针对这一类找最近值的问题,有一个通用解法:**单调栈**。
**单调栈其实就是在栈的基础上,维持一个栈内元素单调。**
在这道题,由于需要找某个位置两侧比其高的柱子(只有两侧有比当前位置高的柱子,当前位置才能接下雨水),我们可以维持栈内元素的单调递减。
**PS. 找某侧最近一个比其大的值,使用单调栈维持栈内元素递减;找某侧最近一个比其小的值,使用单调栈维持栈内元素递增 ...**
当某个位置的元素弹出栈时,例如位置 `a` ,我们自然可以得到 `a` 位置两侧比 `a` 高的柱子:
* 一个是导致 `a` 位置元素弹出的柱子( `a` 右侧比 `a` 高的柱子)
* 一个是 `a` 弹栈后的栈顶元素(`a` 左侧比 `a` 高的柱子)
当有了 `a` 左右两侧比 `a` 高的柱子后,便可计算 `a` 位置可接下的雨水量。
Java 代码:
```Java
class Solution {
public int trap(int[] height) {
int n = height.length, ans = 0;
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && height[i] > height[d.peekLast()]) {
int cur = d.pollLast();
// 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过
if (d.isEmpty()) continue;
// 左右位置,并由左右位置得出「宽度」和「高度」
int l = d.peekLast(), r = i;
int w = r - l + 1 - 2, h = Math.min(height[l], height[r]) - height[cur];
ans += w * h;
}
d.addLast(i);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int trap(vector<int>& height) {
int n = height.size(), ans = 0;
deque<int> d;
for (int i = 0; i < n; i++) {
while (!d.empty() && height[i] > height[d.back()]) {
int cur = d.back();
d.pop_back();
// 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过
if (d.empty()) continue;
// 左右位置,并由左右位置得出「宽度」和「高度」
int l = d.back(), r = i;
int w = r - l + 1 - 2, h = min(height[l], height[r]) - height[cur];
ans += w * h;
}
d.push_back(i);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def trap(self, height: List[int]) -> int:
n, ans = len(height), 0
d = deque()
for i in range(n):
while d and height[i] > height[d[-1]]:
cur = d.pop()
# 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过
if not d: continue
# 左右位置,并由左右位置得出「宽度」和「高度」
l, r = d[-1], i
w, h = r - l + 1 - 2, min(height[l], height[r]) - height[cur]
ans += w * h
d.append(i)
return ans
```
TypeScript 代码:
```TypeScript
function trap(height: number[]): number {
let n = height.length, ans = 0;
const d = [];
for (let i = 0; i < n; i++) {
while (d.length && height[i] > height[d[d.length - 1]]) {
const cur = d.pop() as number;
// 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过
if (!d.length) continue;
// 左右位置,并由左右位置得出「宽度」和「高度」
const l = d[d.length - 1], r = i;
const w = r - l + 1 - 2, h = Math.min(height[l], height[r]) - height[cur];
ans += w * h;
}
d.push(i);
}
return ans;
};
```
* 时间复杂度:每个元素最多进栈和出栈一次。复杂度为 $O(n)$
* 空间复杂度:栈最多存储 $n$ 个元素。复杂度为 $O(n)$
---
### 面积差值
事实上,我们还能利用「面积差值」来进行求解。
我们先统计出「柱子面积」$sum$ 和「以柱子个数为宽、最高柱子高度为高的矩形面积」$full$。
然后分别「从左往右」和「从右往左」计算一次最大高度覆盖面积 $lSum$ 和 $rSum$。
**显然会出现重复面积,并且重复面积只会独立地出现在「山峰」的左边和右边。**
利用此特性,我们可以通过简单的等式关系求解出「雨水面积」:
Java 代码:
```Java
class Solution {
public int trap(int[] height) {
int n = height.length;
int sum = 0, max = 0;
for (int i = 0; i < n; i++) {
int cur = height[i];
sum += cur;
max = Math.max(max, cur);
}
int full = max * n;
int lSum = 0, lMax = 0;
for (int i = 0; i < n; i++) {
lMax = Math.max(lMax, height[i]);
lSum += lMax;
}
int rSum = 0, rMax = 0;
for (int i = n - 1; i >= 0; i--) {
rMax = Math.max(rMax, height[i]);
rSum += rMax;
}
return lSum + rSum - full - sum;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int trap(vector<int>& height) {
int n = height.size();
int sum = 0, maxv = 0;
for (int i = 0; i < n; i++) {
int cur = height[i] * 1L;
sum += cur;
maxv = max(maxv, cur);
}
int full = maxv * n;
int lSum = 0, lMax = 0;
for (int i = 0; i < n; i++) {
lMax = max(lMax, height[i]);
lSum += lMax;
}
int rSum = 0, rMax = 0;
for (int i = n - 1; i >= 0; i--) {
rMax = max(rMax, height[i]);
rSum += rMax;
}
return lSum - full - sum + rSum; // 考虑到 C++ 溢出报错, 先减后加
}
};
```
Python 代码:
```Python
class Solution:
def trap(self, height: List[int]) -> int:
n = len(height)
sum_val, max_val = 0, 0
for cur in height:
sum_val += cur
max_val = max(max_val, cur)
full = max_val * n
l_sum, l_max = 0, 0
for h in height:
l_max = max(l_max, h)
l_sum += l_max
r_sum, r_max = 0, 0
for i in range(n - 1, -1, -1):
r_max = max(r_max, height[i])
r_sum += r_max
return l_sum + r_sum - full - sum_val
```
TypeScript 代码:
```TypeScript
function trap(height: number[]): number {
const n = height.length;
let sum = 0, max = 0;
for (let i = 0; i < n; i++) {
const cur = height[i];
sum += cur;
max = Math.max(max, cur);
}
const full = max * n;
let lSum = 0, lMax = 0;
for (let i = 0; i < n; i++) {
lMax = Math.max(lMax, height[i]);
lSum += lMax;
}
let rSum = 0, rMax = 0;
for (let i = n - 1; i >= 0; i--) {
rMax = Math.max(rMax, height[i]);
rSum += rMax;
}
return lSum + rSum - full - sum;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.42` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/43. 字符串相乘（中等）.md | 43. 字符串相乘 | https://leetcode-cn.com/problems/multiply-strings/solution/zhi-yao-ni-hui-shou-suan-cheng-fa-zhe-ti-ainl/ | 中等 | [
"数学",
"模拟"
] | 给定两个以字符串形式表示的非负整数 `num1` 和 `num2`,返回 `num1` 和 `num2` 的乘积,它们的乘积也表示为字符串形式。
示例 1:
```
输入: num1 = "2", num2 = "3"
输出: "6"
```
示例 2:
```
输入: num1 = "123", num2 = "456"
输出: "56088"
```
说明:
* `num1` 和 `num2` 的长度小于 $110$。
* `num1` 和 `num2` 只包含数字 `0-9`。
* `num1` 和 `num2` 均不以零开头,除非是数字 `0` 本身。
* **不能使用任何标准库的大数类型(比如 BigInteger)或直接将输入转换为整数来处理。** | ### 模拟
本质上是道模拟题,模拟手算乘法的过程。
想要做出这道题,需要知道一个数学定理:
**两个长度分别为 `n` 和 `m` 的数相乘,长度不会超过 `n + m`。**
因此我们可以创建一个长度为 `n + m` 的数组 `res` 存储结果。
另外,最后拼接结果时需要注意忽略前导零。
Java 代码:
```Java
class Solution {
public String multiply(String n1, String n2) {
int n = n1.length(), m = n2.length();
int[] res = new int[n + m];
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
int a = n1.charAt(i) - '0', b = n2.charAt(j) - '0';
int r = a * b;
r += res[i + j + 1];
res[i + j + 1] = r % 10;
res[i + j] += r / 10;
}
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n + m; i++) {
if (sb.length() == 0 && res[i] == 0) continue;
sb.append(res[i]);
}
return sb.length() == 0 ? "0" : sb.toString();
}
}
```
C++ 代码:
```C++
class Solution {
public:
string multiply(string num1, string num2) {
int n = num1.length(), m = num2.length();
vector<int> res(n + m, 0);
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
int a = num1[i] - '0', b = num2[j] - '0';
int r = a * b;
r += res[i + j + 1];
res[i + j + 1] = r % 10;
res[i + j] += r / 10;
}
}
string result;
for (int i = 0; i < n + m; i++) {
if (result.empty() && res[i] == 0) continue;
result.push_back(res[i] + '0');
}
return result.empty() ? "0" : result;
}
};
```
Python 代码:
```Python
class Solution:
def multiply(self, num1: str, num2: str) -> str:
n, m = len(num1), len(num2)
res = [0] * (n + m)
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
a, b = int(num1[i]), int(num2[j])
r = a * b
r += res[i + j + 1]
res[i + j + 1] = r % 10
res[i + j] += r // 10
result = ''.join(str(x) for x in res).lstrip('0')
return result if result else '0'
```
TypeScript 代码:
```TypeScript
function multiply(num1: string, num2: string): string {
const n = num1.length, m = num2.length;
const res = new Array(n + m).fill(0);
for (let i = n - 1; i >= 0; i--) {
for (let j = m - 1; j >= 0; j--) {
const a = parseInt(num1[i]), b = parseInt(num2[j]);
let r = a * b;
r += res[i + j + 1];
res[i + j + 1] = r % 10;
res[i + j] += Math.floor(r / 10);
}
}
let result = "";
for (let i = 0; i < n + m; i++) {
if (result.length == 0 && res[i] == 0) continue;
result += res[i].toString();
}
return result.length == 0 ? "0" : result;
};
```
* 时间复杂度:使用 `n` 和 `m` 分别代表两个数的长度。复杂度为 $O(n \times m)$
* 空间复杂度:使用了长度为 `m + n` 的数组存储结果。复杂度为 $O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.43` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/44. 通配符匹配（困难）.md | 44. 通配符匹配 | https://leetcode-cn.com/problems/wildcard-matching/solution/gong-shui-san-xie-xiang-jie-dong-tai-gui-ifyx/ | 困难 | [
"动态规划",
"序列 DP"
] | 给定一个字符串 (`s`) 和一个字符模式 (`p`) ,实现一个支持 `'?'` 和 `'*'` 的通配符匹配。
* `'?'` 可以匹配任何单个字符。
* `'*'` 可以匹配任意字符串(包括空字符串)。
两个字符串完全匹配才算匹配成功。
说明:
* `s` 可能为空,且只包含从 `a-z` 的小写字母。
* `p` 可能为空,且只包含从 `a-z` 的小写字母,以及字符 `?` 和 `*`。
示例 1:
```
输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
```
示例 2:
```
输入:
s = "aa"
p = "*"
输出: true
解释: '*' 可以匹配任意字符串。
```
示例 3:
```
输入:
s = "cb"
p = "?a"
输出: false
解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
```
示例 4:
```
输入:
s = "adceb"
p = "*a*b"
输出: true
解释:
第一个 '*' 可以匹配空字符串,
第二个 '*' 可以匹配字符串 "dce".
```
示例 5:
```
输入:
s = "acdcb"
p = "a*c?b"
输出: false
``` | ### 动态规划
这道题与 [10. 正则表达式匹配](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247484130&idx=1&sn=af3517194634dde1652ec72eb5ea9ff2&chksm=fd9ca9fdcaeb20eb1fd7509e3adf8fee6f75d77b8afbd30067ac11a56bd77b5066b0f164eb49&token=840813710&lang=zh_CN#rd) 的分析思路是类似的。
但和第 10 题相比,本题要简单一些。
整理一下题意,对于字符串 `p` 而言,有三种字符:
* 普通字符:需要和 `s` 中同一位置的字符完全匹配
* `'?'`:能够匹配 `s` 中同一位置的任意字符
* `'*'`:能够匹配任意字符串
所以本题关键是分析当出现 `'*'` 这种字符时,是匹配 0 个字符、还是 1 个字符、还是 2 个字符 ...
本题可以使用动态规划进行求解:
* 状态定义:`f(i,j)` 代表考虑 `s` 中以 `i` 为结尾的子串和 `p` 中的 `j` 为结尾的子串是否匹配。最终我们要求的结果为 `f[n][m]` 。
* 状态转移:也就是我们要考虑 `f(i,j)` 如何求得,前面说到了 `p` 有三种字符,所以这里的状态转移也要分三种情况讨论:
1. `p[j]` 为普通字符:匹配的条件是前面的字符匹配,同时 `s` 中的第 `i` 个字符和 `p` 中的第 `j` 位相同。
即 `f(i,j) = f(i - 1, j - 1) && s[i] == p[j]` 。
2. `p[j]` 为 `'?'`:匹配的条件是前面的字符匹配,`s` 中的第 `i` 个字符可以是任意字符。
即 `f(i,j) = f(i - 1, j - 1) && p[j] == '?'`。
3. `p[j]` 为 `'*'`:可匹配任意长度的字符,可以匹配 0 个字符、匹配 1 个字符、匹配 2 个字符
3.1. 当匹配为 0 个:`f(i,j) = f(i, j - 1)`
3.2. 当匹配为 1 个:`f(i,j) = f(i - 1, j - 1)`
3.3. 当匹配为 2 个:`f(i,j) = f(i - 2, j - 1)`
...
3.k. 当匹配为 k 个:`f(i,j) = f(i - k, j - 1)`
因此对于 `p[j] = '*'` 的情况,想要 `f(i, j) = true`,只需要其中一种情况为 `true` 即可。
也就是状态之间是「或」的关系:
$$
f[i][j] = f[i][j - 1] || f[i - 1][j - 1] || ... || f[i - k][j - 1] (i >= k)
$$
这意味着我们要对 `k` 种情况进行枚举检查吗?
其实并不用,对于这类问题,我们通常可以通过「代数」进简化,将 `i - 1` 代入上述的式子:
$$
f[i - 1][j] = f[i - 1][j - 1] || f[i - 2][j - 1] || ... || f[i - k][j - 1] (i >= k)
$$
可以发现,`f[i - 1][j]` 与 `f[i][j]` 中的 `f[i][j - 1]` 开始的后半部分是一样的。
因此有:
$$
f[i][j] = f[i][j - 1] || f[i - 1][j] (i >= 1)
$$
*PS. 其实类似的推导,我在 [10. 正则表达式匹配](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247484130&idx=1&sn=af3517194634dde1652ec72eb5ea9ff2&chksm=fd9ca9fdcaeb20eb1fd7509e3adf8fee6f75d77b8afbd30067ac11a56bd77b5066b0f164eb49&token=840813710&lang=zh_CN#rd) 也做过,第 10 题的推导过程还涉及等差概念,我十分推荐你去回顾一下。如果你能搞懂第 10 题整个过程,这题其实就是小 Case。*
编码细节:
1. 通过上述的推导过程,你会发现设计不少的「回退检查」操作(即遍历到 `i` 位,要回头检查 `i - 1` 等),因此我们可以将「哨兵技巧」应用到本题,往两个字符串的头部插入哨兵
2. 对于 `p[j] = '?'` 和 `p[j] = 普通字符` 的情况,想要为 `true`,其实有共同的条件 `f[i - 1][j - 1] == true`,因此可以合到一起来做
Java 代码:
```Java
class Solution {
public boolean isMatch(String s, String p) {
int n = s.length(), m = p.length();
// 技巧:往原字符头部插入空格,这样得到 char 数组是从 1 开始,而且可以使得 f[0][0] = true,可以将 true 这个结果滚动下去
s = " " + s; p = " " + p;
char[] ss = s.toCharArray(), pp = p.toCharArray();
// f(i,j) 代表考虑 s 中的 1~i 字符和 p 中的 1~j 字符 是否匹配
boolean[][] f = new boolean[n + 1][m + 1];
f[0][0] = true;
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (pp[j] == '*') {
f[i][j] = f[i][j - 1] || (i - 1 >= 0 && f[i - 1][j]);
} else {
f[i][j] = i - 1 >= 0 && f[i - 1][j - 1] && (ss[i] == pp[j] || pp[j] == '?');
}
}
}
return f[n][m];
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool isMatch(string s, string p) {
int n = s.length(), m = p.length();
s = " " + s; p = " " + p;
vector<vector<bool>> f(n + 1, vector<bool>(m + 1, false));
f[0][0] = true;
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (p[j] == '*') {
f[i][j] = f[i][j - 1] || (i - 1 >= 0 && f[i - 1][j]);
} else {
f[i][j] = i - 1 >= 0 && f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '?');
}
}
}
return f[n][m];
}
};
```
Python 代码:
```Python
class Solution:
def isMatch(self, s: str, p: str) -> bool:
n, m = len(s), len(p)
s = " " + s
p = " " + p
f = [[False] * (m + 1) for _ in range(n + 1)]
f[0][0] = True
for i in range(n + 1):
for j in range(1, m + 1):
if p[j] == '*':
f[i][j] = f[i][j - 1] or (i - 1 >= 0 and f[i - 1][j])
else:
f[i][j] = i - 1 >= 0 and f[i - 1][j - 1] and (s[i] == p[j] or p[j] == '?')
return f[n][m]
```
TypeScript 代码:
```TypeScript
function isMatch(s: string, p: string): boolean {
const n = s.length, m = p.length;
s = " " + s;
p = " " + p;
const f = new Array(n + 1).fill(false).map(() => new Array(m + 1).fill(false));
f[0][0] = true;
for (let i = 0; i <= n; i++) {
for (let j = 1; j <= m; j++) {
if (p[j] === '*') {
f[i][j] = f[i][j - 1] || (i - 1 >= 0 && f[i - 1][j]);
} else {
f[i][j] = i - 1 >= 0 && f[i - 1][j - 1] && (s[i] === p[j] || p[j] === '?');
}
}
}
return f[n][m];
};
```
* 时间复杂度:`n` 表示 `s` 的长度,`m` 表示 `p` 的长度,总共 $n \times m$ 个状态。复杂度为 $O(n \times m)$
* 空间复杂度:使用了二维数组记录结果。复杂度为 $O(n \times m)$
**再次强调,动态规划本质上是枚举(不重复的暴力枚举),因此其复杂度很好分析,有多少个状态就要被计算多少次,复杂度就为多少。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.44` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/41-50/45. 跳跃游戏 II（中等）.md | 45. 跳跃游戏 II | https://leetcode-cn.com/problems/jump-game-ii/solution/xiang-jie-dp-tan-xin-shuang-zhi-zhen-jie-roh4/ | 中等 | [
"贪心",
"线性 DP",
"双指针"
] | 给定一个非负整数数组,你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
假设你总是可以到达数组的最后一个位置。
示例 1:
```
输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。
```
示例 2:
```
输入: [2,3,0,1,4]
输出: 2
```
提示:
* 1 <= nums.length <= 1000
* 0 <= nums[i] <= $10^5$ | ### BFS
对于这一类问题,我们一般都是使用 BFS 进行求解。
本题的 BFS 解法的复杂度是 $O(n^2)$,数据范围为 $10^3$,可以过。
代码:
```Java
class Solution {
public int jump(int[] nums) {
int n = nums.length;
int ans = 0;
boolean[] st = new boolean[n];
Deque<Integer> d = new ArrayDeque<>();
st[0] = true;
d.addLast(0);
while (!d.isEmpty()) {
int size = d.size();
while (size-- > 0) {
int idx = d.pollFirst();
if (idx == n - 1) return ans;
for (int i = idx + 1; i <= idx + nums[idx] && i < n; i++) {
if (!st[i]) {
st[i] = true;
d.addLast(i);
}
}
}
ans++;
}
return ans;
}
}
```
* 时间复杂度:如果每个点跳跃的距离足够长的话,每次都会将当前点「后面的所有点」进行循环入队操作(由于 st 的存在,不一定都能入队,但是每个点都需要被循环一下)。复杂度为 $O(n^2)$
* 空间复杂度:队列中最多有 $n - 1$ 个元素。复杂度为 $O(n)$
---
### 双指针 + 贪心 + 动态规划
本题数据范围只有 $10^3$,所以 $O(n^2)$ 勉强能过。
*如果面试官要将数据范围出到 $10^6$,又该如何求解呢?*
*我们需要考虑 $O(n)$ 的做法。*
其实通过 $10^6$ 这个数据范围,就已经可以大概猜到是道 DP 题。
我们定义 $f[i]$ 为到达第 $i$ 个位置所需要的最少步数,那么答案是 $f[n - 1]$。
学习过 [路径 DP 专题](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzU4NDE3MTEyMA==&action=getalbum&album_id=1773144264147812354&scene=173&from_msgid=2247485565&from_itemidx=1&count=3&scene=21#wechat_redirect) 的同学应该知道,通常确定 DP 的「状态定义」有两种方法。
* 一种是根据经验猜一个状态定义,会结合题目给定的维度,和要求的答案去猜。
* 另外一种则是通过设计一个合理的 `DFS` 方法签名来确定状态定义。
这里我是采用第一种方法。
至于如何确定「状态定义」是否可靠,关键是看使用这个状态定义能否推导出合理的「状态转移方程」,来覆盖我们所有的状态。
不失一般性的考虑 $f[n - 1]$ 该如何转移:
我们知道最后一个点前面可能会有很多个点能够一步到达最后一个点。
也就是有 $f[n - 1] = min(f[n - k],...,f[n - 3],f[n - 2]) + 1$。
然后我们再来考虑集合 $f[n - k],...,f[n - 3],f[n - 2]$ 有何特性。
不然发现其实必然有 $f[n - k] <= ...<= f[n - 3] <= f[n - 2]$。
推而广之,不止是经过一步能够到达最后一个点的集合,其实任意连续的区间都有这个性质。
*举个🌰,比如我经过至少 5 步到达第 $i$ 个点,那么必然不可能出现使用步数少于 5 步就能达到第 $i + 1$ 个点的情况。到达第 $i + 1$ 个点的至少步数必然是 5 步或者 6 步。*
搞清楚性质之后,再回头看我们的状态定义:*$f[i]$ 为到达第 $i$ 个位置所需要的最少步数。*
因此当我们要求某一个 $f[i]$ 的时候,我们需要找到最早能够经过一步到达 $i$ 点的 $j$ 点。
即有状态转移方程:$f[i] = f[j] + 1$。
也就是我们每次都贪心的取离 $i$ 点最远的点 $j$ 来更新 $f[i]$。
而这个找 $j$ 的过程可以使用双指针来找。
因此这个思路其实是一个「双指针 + 贪心 + 动态规划」的一个解法。
代码:
```Java
class Solution {
public int jump(int[] nums) {
int n = nums.length;
int[] f = new int[n];
for (int i = 1, j = 0; i < n; i++) {
while (j + nums[j] < i) j++;
f[i] = f[j] + 1;
}
return f[n - 1];
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.45` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/412. Fizz Buzz（简单）.md | 412. Fizz Buzz | https://leetcode-cn.com/problems/fizz-buzz/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-jll0/ | 简单 | [
"模拟"
] | 写一个程序,输出从 `1` 到 `n` 数字的字符串表示。
1. 如果 `n` 是 `3` 的倍数,输出 `“Fizz”`;
2. 如果 `n` 是 `5` 的倍数,输出 `“Buzz”`;
3. 如果 `n` 同时是 `3` 和 `5` 的倍数,输出 `“FizzBuzz”`。
示例:
```
n = 15,
返回:
[
"1",
"2",
"Fizz",
"4",
"Buzz",
"Fizz",
"7",
"8",
"Fizz",
"Buzz",
"11",
"Fizz",
"13",
"14",
"FizzBuzz"
]
``` | ### 模拟
根据题意进行模拟。
代码:
```Java
class Solution {
public List<String> fizzBuzz(int n) {
List<String> ans = new ArrayList<>();
for (int i = 1; i <= n; i++) {
String cur = "";
if (i % 3 == 0) cur += "Fizz";
if (i % 5 == 0) cur += "Buzz";
if (cur.length() == 0) cur = i + "";
ans.add(cur);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.412` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/413. 等差数列划分（中等）.md | 413. 等差数列划分 | https://leetcode-cn.com/problems/arithmetic-slices/solution/gong-shui-san-xie-shuang-zhi-zhen-qiu-ji-ef1q/ | 中等 | [
"双指针",
"模拟",
"数学"
] | 如果一个数列 至少有三个元素 ,并且任意两个相邻元素之差相同,则称该数列为等差数列。
例如,[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
给你一个整数数组 nums ,返回数组 nums 中所有为等差数组的 子数组 个数。
子数组 是数组中的一个连续序列。
示例 1:
```
输入:nums = [1,2,3,4]
输出:3
解释:nums 中有三个子等差数组:[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。
```
示例 2:
```
输入:nums = [1]
输出:0
```
提示:
* $1 <= nums.length <= 5000$
* $-1000 <= nums[i] <= 1000$ | ### 双指针
具体的,我们可以枚举 $i$ 作为差值为 $d$ 的子数组的左端点,然后通过「双指针」的方式找到当前等差并最长的子数组的右端点 $j$,令区间 $[i, j]$ 长度为 $len$。
那么显然,符合条件的子数组的数量为:
$$
cnt = \sum_{k = 3}^{len}countWithArrayLength(k)
$$
函数 `int countWithArrayLength(int k)` 求的是长度为 $k$ 的子数组的数量。
不难发现,随着入参 $k$ 的逐步减小,函数返回值逐步增大。
因此上述结果 $cnt$ 其实是一个 **首项为 $1$,末项为 $len - 3 + 1$,公差为 $1$ 的等差数列的求和结果**。直接套用「等差数列求和」公式求解即可。
代码:
```Java
class Solution {
public int numberOfArithmeticSlices(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0; i < n - 2; ) {
int j = i, d = nums[i + 1] - nums[i];
while (j + 1 < n && nums[j + 1] - nums[j] == d) j++;
int len = j - i + 1;
// a1:长度为 len 的子数组数量;an:长度为 3 的子数组数量
int a1 = 1, an = len - 3 + 1;
// 符合条件(长度大于等于3)的子数组的数量为「差值数列求和」结果
int cnt = (a1 + an) * an / 2;
ans += cnt;
i = j;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.413` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/414. 第三大的数（简单）.md | 414. 第三大的数 | https://leetcode-cn.com/problems/third-maximum-number/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-pmln/ | 简单 | [
"排序",
"数组",
"模拟"
] | 给你一个非空数组,返回此数组中 第三大的数 。如果不存在,则返回数组中最大的数。
示例 1:
```
输入:[3, 2, 1]
输出:1
解释:第三大的数是 1 。
```
示例 2:
```
输入:[1, 2]
输出:2
解释:第三大的数不存在, 所以返回最大的数 2 。
```
示例 3:
```
输入:[2, 2, 3, 1]
输出:1
解释:注意,要求返回第三大的数,是指在所有不同数字中排第三大的数。
此例中存在两个值为 2 的数,它们都排第二。在所有不同数字中排第三大的数为 1 。
```
提示:
* 1 <= nums.length <= $10^4$
* $-2^{31}$ <= nums[i] <= $2^{31} - 1$
**进阶:你能设计一个时间复杂度 O(n) 的解决方案吗?** | ### Set 去重 + 排序
题目要求返回含重复元素的数组 $nums$ 中的第三大数。
一个朴素的做法是,先使用 `Set` 对重复元素进行去重,然后对去重后的元素进行排序,并返回第三大的元素。
代码:
```Java
class Solution {
public int thirdMax(int[] nums) {
Set<Integer> set = new HashSet<>();
for (int x : nums) set.add(x);
List<Integer> list = new ArrayList<>(set);
Collections.sort(list);
return list.size() < 3 ? list.get(list.size() - 1) : list.get(list.size() - 3);
}
}
```
* 时间复杂度:使用 `Set` 去重的复杂度为 $O(n)$;排序复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 有限变量 + 遍历
**经典的找数组次大值的做法是使用两个变量 `a` 和 `b` 分别存储遍历过程中的最大值和次大值。**
假设当前遍历到的元素为 $x$,当满足如下条件时,考虑更新 `a` 或者 `b`:
1. 当 $x > a$ 时,说明最大值被更新,同时原来的最大值沦为次大值。即有 $b = a; a = x;$
2. 在条件 $1$ 不满足,且有$x > b$ 时,此时可以根据是否有「严格次大值」的要求,而决定是否要增加 $x < a$ 的条件:
* 不要求为「严格次大值」:直接使用 $x$ 来更新 `b`,即有 $b = x$;
* 当要求为「严格次大值」: 此时需要满足 $x < a$ 的条件,才能更新 `b`。
回到本题,同理我们可以使用 `a`、`b` 和 `c` 三个变量来代指「最大值」、「严格次大值」和「严格第三大值」。
从前往后遍历 $nums$,假设当前元素为 $x$,对是否更新三者进行分情况讨论(判断优先级从上往下):
1. $x > a$,说明最大值被更新,将原本的「最大值」和「次大值」往后顺延为「次大值」和「第三大值」,并用 $x$ 更新 `a`;
2. $x < a$ 且 $x > b$,说明次大值被更新,将原本的「次大值」往后顺延为「第三大值」,并用 $x$ 更新 `b`;
3. $x < b$ 且 $x > c$,说明第三大值被更新,使用 $x$ 更新 `c`。
起始时,我们希望使用一个足够小的数来初始化 `a`、`b` 和 `c`,但由于 $num[i]$ 的范围为 $[-2^{31}, 2^{31} - 1]$,因此需要使用 `long` 来进行代替。
返回时,通过判断第三大值是否为初始化时的负无穷,来得知是否存在第三大值。
代码:
```Java
class Solution {
long INF = (long)-1e18;
public int thirdMax(int[] nums) {
long a = INF, b = INF, c = INF;
for (int x : nums) {
if (x > a) {
c = b; b = a; a = x;
} else if (x < a && x > b) {
c = b; b = x;
} else if (x < b && x > c) {
c = x;
}
}
return c != INF ? (int)c : (int)a;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.414` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/416. 分割等和子集(上)（中等）.md | 416. 分割等和子集(上) | https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/gong-shui-san-xie-bei-bao-wen-ti-shang-r-ln14/ | 中等 | [
"背包 DP"
] | 给你一个 只包含正整数 的 非空 数组 nums 。
请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。
示例 1:
```
输入:nums = [1,5,11,5]
输出:true
解释:数组可以分割成 [1, 5, 5] 和 [11] 。
```
示例 2:
```
输入:nums = [1,2,3,5]
输出:false
解释:数组不能分割成两个元素和相等的子集。
```
提示:
* 1 <= nums.length <= 200
* 1 <= nums[i] <= 100 | ### 前言
今天是我们讲解**动态规划专题**中的 *「背包问题」的第二天*。
在众多背包问题中「01 背包问题」是最为核心的,因此我建议你先精读过 [背包问题 第一讲](https://mp.weixin.qq.com/s/xmgK7SrTnFIM3Owpk-emmg) 之后再阅读本文。
**另外,我在文章结尾处列举了我所整理的关于背包问题的相关题目。**
背包问题我会按照编排好的顺序进行讲解(*每 2~3 天更新一篇,确保大家消化*)。
你也先可以尝试做做,也欢迎你向我留言补充,你觉得与背包相关的 DP 类型题目 ~
***
## 基本分析
**通常「背包问题」相关的题,都是在考察我们的「建模」能力,也就是将问题转换为「背包问题」的能力。**
由于本题是问我们能否将一个数组分成两个「等和」子集。
问题等效于**能否从数组中挑选若干个元素,使得元素总和等于所有元素总和的一半**。
这道题如果抽象成「背包问题」的话,应该是:
**我们背包容量为 $target=sum/2$,每个数组元素的「价值」与「成本」都是其数值大小,求我们能否装满背包。**
***
### 转换为 01 背包
由于每个数字(数组元素)只能被选一次,而且每个数字选择与否对应了「价值」和「成本」,求解的问题也与「最大价值」相关。
可以使用「01 背包」的模型来做。
当我们确定一个问题可以转化为「01 背包」之后,就可以直接套用「01 背包」的状态定义进行求解了。
**注意,我们积累 DP 模型的意义,就是在于我们可以快速得到可靠的「状态定义」。**
**在 [路径问题](https://mp.weixin.qq.com/s/flnaRo6VnvkeUQoRDkin9w) 中我教过你通用的 DP 技巧解法,但那是基于我们完全没见过那样的题型才去用的,而对于一些我们见过题型的 DP 题目,我们应该直接套用(或微调)该模型「状态定义」来做。**
我们直接套用「01 背包」的状态定义:
$f[i][j]$ 代表考虑前 $i$ 个数值,其选择数字总和不超过 $j$ 的最大价值。
当有了「状态定义」之后,结合我们的「最后一步分析法」,每个数字都有「选」和「不选」两种选择。
因此不难得出状态转移方程:
代码:
```java
class Solution {
public boolean canPartition(int[] nums) {
int n = nums.length;
//「等和子集」的和必然是总和的一半
int sum = 0;
for (int i : nums) sum += i;
int target = sum / 2;
// 对应了总和为奇数的情况,注定不能被分为两个「等和子集」
if (target * 2 != sum) return false;
int[][] f = new int[n][target + 1];
// 先处理考虑第 1 件物品的情况
for (int j = 0; j <= target; j++) {
f[0][j] = j >= nums[0] ? nums[0] : 0;
}
// 再处理考虑其余物品的情况
for (int i = 1; i < n; i++) {
int t = nums[i];
for (int j = 0; j <= target; j++) {
// 不选第 i 件物品
int no = f[i-1][j];
// 选第 i 件物品
int yes = j >= t ? f[i-1][j-t] + t : 0;
f[i][j] = Math.max(no, yes);
}
}
// 如果最大价值等于 target,说明可以拆分成两个「等和子集」
return f[n-1][target] == target;
}
}
```
* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$
* 空间复杂度:$O(n * target)$
***
### 「滚动数组」解法
在上一讲我们讲到过「01 背包」具有两种空间优化方式。
其中一种优化方式的编码实现十分固定,只需要固定的修改「物品维度」即可。
代码:
```java
class Solution {
public boolean canPartition(int[] nums) {
int n = nums.length;
//「等和子集」的和必然是总和的一半
int sum = 0;
for (int i : nums) sum += i;
int target = sum / 2;
if (target * 2 != sum) return false;
// 将「物品维度」修改为 2
int[][] f = new int[2][target + 1];
// 先处理考虑第 1 件物品的情况
for (int j = 0; j <= target; j++) {
f[0][j] = j >= nums[0] ? nums[0] : 0;
}
// 再处理考虑其余物品的情况
for (int i = 1; i < n; i++) {
int t = nums[i];
for (int j = 0; j <= target; j++) {
// 不选第 i 件物品,将物品维度的使用加上「&1」
int no = f[(i-1)&1][j];
// 选第 i 件物品,将物品维度的使用加上「&1」
int yes = j >= t ? f[(i-1)&1][j-t] + t : 0;
f[i&1][j] = Math.max(no, yes);
}
}
// 如果最大价值等于 target,说明可以拆分成两个「等和子集」
// 将物品维度的使用加上「&1」
return f[(n-1)&1][target] == target;
}
}
```
* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$
* 空间复杂度:$O(target)$
***
### 「一维空间优化」解法
事实上,我们还能继续进行空间优化:只保留代表「剩余容量」的维度,同时将容量遍历方向修改为「从大到小」。
代码:
```java
class Solution {
public boolean canPartition(int[] nums) {
int n = nums.length;
//「等和子集」的和必然是总和的一半
int sum = 0;
for (int i : nums) sum += i;
int target = sum / 2;
// 对应了总和为奇数的情况,注定不能被分为两个「等和子集」
if (target * 2 != sum) return false;
// 将「物品维度」取消
int[] f = new int[target + 1];
for (int i = 0; i < n; i++) {
int t = nums[i];
// 将「容量维度」改成从大到小遍历
for (int j = target; j >= 0; j--) {
// 不选第 i 件物品
int no = f[j];
// 选第 i 件物品
int yes = j >= t ? f[j-t] + t : 0;
f[j] = Math.max(no, yes);
}
}
// 如果最大价值等于 target,说明可以拆分成两个「等和子集」
return f[target] == target;
}
}
```
* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$
* 空间复杂度:$O(target)$
***
### 总结
今天我们对昨天学的「01 背包」进行了应用。
可以发现,本题的难点在于**对问题的抽象**,主要考察的是如何将原问题转换为一个「01 背包」问题。
事实上,无论是 DP 还是图论,对于特定问题,大多都有相应的模型或算法。
难是难在如何将问题转化为我们的模型。
至于如何培养自己的「问题抽象能力」?
*首先通常需要我们积累一定的刷题量,并对「转换问题的关键点」做总结。*
例如本题,一个转换「01 背包问题」的关键点是我们需要将「划分等和子集」的问题等效于「在某个数组中选若干个数,使得其总和为某个特定值」的问题。
***
### 拓展
但这道题到这里还有一个”小问题“。
就是我们最后是通过「判断」来取得答案的。
通过判断取得的最大价值是否等于 $target$ 来决定是否能划分出「等和子集」。
虽然说逻辑上完全成立,但总给我们一种「间接求解」的感觉。
*造成这种「间接求解」的感觉,主要是因为我们没有对「01 背包」的「状态定义」和「初始化」做任何改动。*
但事实上,我们是可以利用「01 背包」的思想进行「直接求解」的。
因此在下一讲,我们还会再做一遍这道题。
不过却是以「另外一个角度」的「01 背包」思维来解决。
敬请期待 ~ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.416` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/416. 分割等和子集(下)（中等）.md | 416. 分割等和子集(下) | https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/gong-shui-san-xie-bei-bao-wen-ti-xia-con-mr8a/ | 中等 | [
"背包 DP"
] | 给你一个 只包含正整数 的 非空 数组 nums 。
请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。
示例 1:
```
输入:nums = [1,5,11,5]
输出:true
解释:数组可以分割成 [1, 5, 5] 和 [11] 。
```
示例 2:
```
输入:nums = [1,2,3,5]
输出:false
解释:数组不能分割成两个元素和相等的子集。
```
提示:
* 1 <= nums.length <= 200
* 1 <= nums[i] <= 100 | ### 基本分析
基本的「将原问题抽象为 01 背包问题」的分析在 [上一讲](https://mp.weixin.qq.com/s/NnVbGs5Chm9BwAQeMOnJfg) 讲过啦 ~
本节要解决的问题是:**如何将「间接求解」的方式转为「直接求解」,并学习为什么能这么做,此类做法是否有共性 ...**
---
### 直接求解
我们先来回顾一下 [上一节](https://mp.weixin.qq.com/s/NnVbGs5Chm9BwAQeMOnJfg) 使用的「状态定义」和「转移方程」。
状态定义:
$f[i][j]$ 代表考虑前 $i$ 个数值,其选择数字总和不超过 $j$ 的最大价值。
转移方程:
但题目并不是问我们「最大价值是多少」,而是问「是否能凑出最大价值」。
因此我们可以对 01 背包的状态定义进行修改,使其直接与我们答案相关联:
$f[i][j]$ 代表考虑前 $i$ 个数值,其选择数字总和是否恰好为 $j$。
此时 $dp$ 数组中存储的是「布尔类型」的动规值。
相应的状态转移方程调整为:
$∨$ 代表逻辑「或」的意思。
新转移方程代表的意思为:**想要 $f[i][j]$ (考虑前 $i$ 个数值,选择的数字总和恰好为 $j$ ) 为真**。需要满足以下两种方案,至少一种为 $true$:
**1. $f[i-1][j]$ (不选第 $i$ 件物品,选择的数字总和恰好为 $j$ ) 为 $true$**
**2. $f[i-1][j-nums[i]]$ (选第 $i$ 件物品,选择的数字总和恰好为 $j$ ) 为 $true$**
至此,我们利用 01 背包的基本思想,修改了「状态定义」,使其与答案直接相关联,然后根据新的「状态定义」调整了我们的「转移方程」。
但还没结束。
**当我们与某个模型的「状态定义」进行了修改之后,除了考虑调整「转移方程」以外,还需要考虑修改「初始化」状态。**
试考虑,我们创建的 $dp$ 数组存储的是布尔类型,初始值都是 $false$,这意味着无论我们怎么转移下去,都不可能产生一个 $true$,最终所有的状态都仍然是 $false$。
换句话说,我们还需要一个有效值 $true$ 来帮助整个过程能递推下去。
**通常我们使用「首行」来初始化「有效值」。**
对于本题,显然我们可以通过「先处理第一个物品」来得到「有效值」,即令 $f[0][nums[0]] = true$。
$f[0][nums[0]] = true$ 代表只有容量为 $nums[0]$ 的背包才符合「恰好」的要求。
但我们无法确保 $nums[0]$ 不会超过我们的「最大背包」容量(也就是第一个物品过大,永远无法装入背包的情况)。
因此我们要通过处理下一行来得到有效值?或是先给物品排个序?
事实上,这里有一个技巧,就是我们增加一个「不考虑任何物品」的情况讨论。
之前我们的状态定义是 $f[i][j]$ 代表考虑下标为 $i$ 之前的所有物品。现在我们可以加入**不考虑任何物品**的情况,也就是*将「物品编号」从 0 开始调整为从 1 开始*。
举个🌰,原本我们的 $f[0][x]$ 代表只考虑第一件物品、$f[1][x]$ 代表考虑第一件和第二件物品;调整后我们的 $f[0][x]$ 代表不考虑任何物品、$f[1][x]$ 代表只考虑第一件物品 ...
这种技巧本质上还是利用了「哨兵」的思想。
有了以上的分析思路,和 [上一讲](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485658&idx=1&sn=f298abe76d9cc058805b6a18d2523db6&chksm=fd9ca3c5caeb2ad31f6faefd800471b339d21cf54988e123fc507ff07b1447ae31337d826b0e&token=1589043586&lang=zh_CN#rd) 的代码基础之后,我们可以很容易写出代码。
**虽然更换了状态定义和转移方程,但仍然有「常规解法」、「滚动数组优化」「一维空间优化」几种实现方法。我们快速过一下 ~**
***
### 常规解法
代码:
```java
class Solution {
public boolean canPartition(int[] nums) {
int n = nums.length;
//「等和子集」的和必然是总和的一半
int sum = 0;
for (int i : nums) sum += i;
int target = sum / 2;
// 对应了总和为奇数的情况,注定不能被分为两个「等和子集」
if (target * 2 != sum) return false;
// f[i][j] 代表考虑前 i 件物品,能否凑出价值「恰好」为 j 的方案
boolean[][] f = new boolean[n+1][target+1];
f[0][0] = true;
for (int i = 1; i <= n; i++) {
int t = nums[i-1];
for (int j = 0; j <= target; j++) {
// 不选该物品
boolean no = f[i-1][j];
// 选该物品
boolean yes = j >= t ? f[i-1][j-t] : false;
f[i][j] = no | yes;
}
}
return f[n][target];
}
}
```
* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$
* 空间复杂度:$O(n * target)$
***
### 「滚动数组」解法
代码:
```java
class Solution {
public boolean canPartition(int[] nums) {
int n = nums.length;
//「等和子集」的和必然是总和的一半
int sum = 0;
for (int i : nums) sum += i;
int target = sum / 2;
// 对应了总和为奇数的情况,注定不能被分为两个「等和子集」
if (target * 2 != sum) return false;
// f[i][j] 代表考虑前 i 件物品,能否凑出价值「恰好」为 j 的方案
// 修改「物品维度」为 2
boolean[][] f = new boolean[2][target+1];
f[0][0] = true;
for (int i = 1; i <= n; i++) {
int t = nums[i-1];
for (int j = 0; j <= target; j++) {
// 不选该物品
boolean no = f[(i-1)&1][j];
// 选该物品
boolean yes = j >= t ? f[(i-1)&1][j-t] : false;
f[i&1][j] = no | yes;
}
}
return f[n&1][target];
}
}
```
* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$
* 空间复杂度:$O(target)$
***
### 「一维空间优化」解法
代码:
```java
class Solution {
public boolean canPartition(int[] nums) {
int n = nums.length;
//「等和子集」的和必然是总和的一半
int sum = 0;
for (int i : nums) sum += i;
int target = sum / 2;
// 对应了总和为奇数的情况,注定不能被分为两个「等和子集」
if (target * 2 != sum) return false;
// 取消「物品维度」
boolean[] f = new boolean[target+1];
f[0] = true;
for (int i = 1; i <= n; i++) {
int t = nums[i-1];
for (int j = target; j >= 0; j--) {
// 不选该物品
boolean no = f[j];
// 选该物品
boolean yes = j >= t ? f[j-t] : false;
f[j] = no | yes;
}
}
return f[target];
}
}
```
* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$
* 空间复杂度:$O(target)$
***
### 总结
今天我们又做了一遍「416. 分割等和子集」,但却是以另外一个角度进行求解:
**通过修改 01 背包的「状态定义」和「转移方程」实现「直接求解」。**
但这样的做法属于特题特解吗?
其实不属于。反而这是「背包问题」中一个可推广的性质:
我们可以通过将一个背包问题的「状态定义」从**最多不超过 XX 容量**修改为**背包容量恰好为 XX**,同时再把「有效值构造」出来,也即是将**物品下标调整为从 1 开始,设置 $dp[0][0]$ 为初始值**。
这其实是另外一类「背包问题」,它不对应「价值最大化」,对应的是「能否取得最大/特定价值」。这样的「背包问题」同样具有普遍性。
需要大家进行掌握 ~ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.416` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/417. 太平洋大西洋水流问题（中等）.md | 417. 太平洋大西洋水流问题 | https://leetcode-cn.com/problems/pacific-atlantic-water-flow/solution/by-ac_oier-do7d/ | 中等 | [
"DFS",
"BFS",
"多源 BFS",
"并查集"
] | 有一个 `m × n` 的矩形岛屿,与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界,而 “大西洋” 处于大陆的右边界和下边界。
这个岛被分割成一个由若干方形单元格组成的网格。给定一个 `m x n` 的整数矩阵 `heights` , $heights[r][c]$ 表示坐标 $(r, c)$ 上单元格 高于海平面的高度 。
岛上雨水较多,如果相邻单元格的高度 小于或等于 当前单元格的高度,雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。
返回 网格坐标 `result` 的 2D 列表 ,其中 $result[i] = [r_i, c_i]$ 表示雨水可以从单元格 $(r_i, c_i)$ 流向 太平洋和大西洋 。
示例 1:
```
输入: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]
输出: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]
```
示例 2:
```
输入: heights = [[2,1],[1,2]]
输出: [[0,0],[0,1],[1,0],[1,1]]
```
提示:
* $m == heights.length$
* $n == heights[r].length$
* $1 <= m, n <= 200$
* $0 <= heights[r][c] <= 10^5$ | ### 基本分析
整理题意,需要我们统计能够同时流向两片海域的格子。
从源点(格子)流向汇点(海域)是按照高度从高到低(非严格)的规则,那么反过来从海域到格子则是按照从低到高(非严格)规则进行,同时本身处于边缘的格子与海域联通。
因此我们可以使用两遍 `DFS/BFS` 进行求解:分别从与当前海域直接相连的边缘格子出发,统计能够流向当前海域的格子集合,两片海域求得的集合交集即是答案。
---
### BFS(多源 BFS)
使用 `BFS` 进行求解:目的是构造出两个答案矩阵 $res_1$ 和 $res_2$,$res_k[i][j] = true$ 代表格子 $(i, j)$ 能够流向海域,起始将所有与海域相连的格子放入队列,然后跑一遍 `BFS` ,所有能够进入队列的格子均能够与海域联通。
最后统计所有满足 $res_1[i][j] = res_2[i][j] = true$ 的格子即是答案。
代码:
```Java
class Solution {
int n, m;
int[][] g;
public List<List<Integer>> pacificAtlantic(int[][] heights) {
g = heights;
m = g.length; n = g[0].length;
Deque<int[]> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
boolean[][] res1 = new boolean[m][n], res2 = new boolean[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i == 0 || j == 0) {
res1[i][j] = true;
d1.addLast(new int[]{i, j});
}
if (i == m - 1 || j == n - 1) {
res2[i][j] = true;
d2.addLast(new int[]{i, j});
}
}
}
bfs(d1, res1); bfs(d2, res2);
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (res1[i][j] && res2[i][j]) {
List<Integer> list = new ArrayList<>();
list.add(i); list.add(j);
ans.add(list);
}
}
}
return ans;
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
void bfs(Deque<int[]> d, boolean[][] res) {
while (!d.isEmpty()) {
int[] info = d.pollFirst();
int x = info[0], y = info[1], t = g[x][y];
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (res[nx][ny] || g[nx][ny] < t) continue;
d.addLast(new int[]{nx, ny});
res[nx][ny] = true;
}
}
}
}
```
* 时间复杂度:`BFS` 和统计答案的复杂度均为 $O(m \times n)$。整体复杂度为 $O(m \times n)$
* 空间复杂度:$O(m \times n)$
---
### DFS
同理,使用 `DFS` 进行求解。
代码:
```Java
class Solution {
int n, m;
int[][] g;
public List<List<Integer>> pacificAtlantic(int[][] heights) {
g = heights;
m = g.length; n = g[0].length;
boolean[][] res1 = new boolean[m][n], res2 = new boolean[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i == 0 || j == 0) {
if (!res1[i][j]) dfs(i, j, res1);
}
if (i == m - 1 || j == n - 1) {
if (!res2[i][j]) dfs(i, j, res2);
}
}
}
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (res1[i][j] && res2[i][j]) {
List<Integer> list = new ArrayList<>();
list.add(i); list.add(j);
ans.add(list);
}
}
}
return ans;
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
void dfs(int x, int y, boolean[][] res) {
res[x][y] = true;
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (res[nx][ny] || g[nx][ny] < g[x][y]) continue;
dfs(nx, ny, res);
}
}
}
```
* 时间复杂度:`DFS` 和统计答案的复杂度均为 $O(m \times n)$。整体复杂度为 $O(m \times n)$
* 空间复杂度:$O(m \times n)$
---
### 并查集
其中维护连通性部分可以使用「并查集」来做:起始将与海域 A 联通的边缘格子与 `S` 联通,将与海域 B 联通的边缘格子与 `T` 联通,然后跑一遍 `DFS/BFS`,最后将既和 `S` 联通又和 `T` 联通的格子加入答案。
代码:
```Java
class Solution {
int N = 200 * 200 + 10;
int[] p1 = new int[N], p2 = new int[N];
int n, m, tot, S, T;
int[][] g;
void union(int[] p, int a, int b) {
p[find(p, a)] = p[find(p, b)];
}
int find(int[] p, int x) {
if (p[x] != x) p[x] = find(p, p[x]);
return p[x];
}
boolean query(int[] p, int a, int b) {
return find(p, a) == find(p, b);
}
int getIdx(int x, int y) {
return x * n + y;
}
public List<List<Integer>> pacificAtlantic(int[][] _g) {
g = _g;
m = g.length; n = g[0].length; tot = m * n; S = tot + 1; T = tot + 2;
for (int i = 0; i <= T; i++) p1[i] = p2[i] = i;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int idx = getIdx(i, j);
if (i == 0 || j == 0) {
if (!query(p1, S, idx)) dfs(p1, S, i, j);
}
if (i == m - 1 || j == n - 1) {
if (!query(p2, T, idx)) dfs(p2, T, i, j);
}
}
}
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int idx = getIdx(i, j);
if (query(p1, S, idx) && query(p2, T, idx)) {
List<Integer> list = new ArrayList<>();
list.add(i); list.add(j);
ans.add(list);
}
}
}
return ans;
}
int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
void dfs(int[] p, int ori, int x, int y) {
union(p, ori, getIdx(x, y));
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (query(p, ori, getIdx(nx, ny)) || g[nx][ny] < g[x][y]) continue;
dfs(p, ori, nx, ny);
}
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n \times m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.417` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/419. 甲板上的战舰（中等）.md | 419. 甲板上的战舰 | https://leetcode-cn.com/problems/battleships-in-a-board/solution/gong-shui-san-xie-ji-chong-sao-miao-xian-trmc/ | 中等 | [
"脑筋急转弯"
] | 给你一个大小为 $m x n$ 的矩阵 $board$ 表示甲板,其中,每个单元格可以是一艘战舰 `'X'` 或者是一个空位 `'.'` ,返回在甲板 $board$ 上放置的 战舰 的数量。
战舰 只能水平或者垂直放置在 $board$ 上。换句话说,战舰只能按 $1 * k$($1$ 行,$k$ 列)或 $k * 1$($k$ 行,$1$ 列)的形状建造,其中 $k$ 可以是任意大小。
两艘战舰之间至少有一个水平或垂直的空位分隔 (即没有相邻的战舰)。
示例 1:
```
输入:board = [["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
输出:2
```
示例 2:
```
输入:board = [["."]]
输出:0
```
提示:
* $m == board.length$
* $n == board[i].length$
* $1 <= m, n <= 200$
* $board[i][j]$ 是 `'.'` 或 `'X'`
进阶:你可以实现一次扫描算法,并只使用 $O(1)$ 额外空间,并且不修改 `board` 的值来解决这个问题吗? | ### 脑筋急转弯
如果「允许扫描多次」或者「使用与输入同规模的空间」的话,做法都十分简单:
* 允许扫描多次,但空间只能 $O(1)$:每次遇到 `X` 的格子,则将 `X` 所在的战舰修改为 `-`,统计完答案后,再扫描一次,将 `-` 恢复为 `X` 即可;
* 扫描一次,但空间允许 $O(m * n)$:使用一个与矩阵同等大小的辅助数组 $vis$ 记录访问过的位置即可。
但题目要求「扫描一次」并且「空间 $O(1)$」,这就需要有点「脑筋急转弯」了。
> 注意这里的「扫描一次」是指使用一次遍历,而非要求每个单元格仅能访问一次,注意两者区别。
思考上述两种做法,我们本质 **都是在战舰的首个格子进行计数,并将该战舰的所有格子进行处理,同时使用去重手段(原数组标记 或 使用辅助数组)来防止该战舰在后面遍历中被重复计数。**
如果我们能够找到某种规律,直接判断出某个 `X` 格子是否为战舰开头,则不再需要其他去重手段。
当且仅当某个 `X` 格子的「上方」&「左方」不为 `X` 时,该格子为战舰首个格子,可以进行计数,同时需要注意当前当为 $0$(没有「上方」)和当前列为 $0$(没有「左方」)时的边界情况。
* 一次扫描 + $O(1)$ 代码:
```Java
class Solution {
public int countBattleships(char[][] board) {
int m = board.length, n = board[0].length;
int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i > 0 && board[i - 1][j] == 'X') continue;
if (j > 0 && board[i][j - 1] == 'X') continue;
if (board[i][j] == 'X') ans++;
}
}
return ans;
}
}
```
* 两次扫描 + $O(1)$ 代码:
```Java
class Solution {
public int countBattleships(char[][] board) {
int m = board.length, n = board[0].length;
int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (board[i][j] != 'X') continue;
board[i][j] = '-';
for (int k = i + 1; k < m && board[k][j] == 'X'; k++) board[k][j] = '-';
for (int k = j + 1; k < n && board[i][k] == 'X'; k++) board[i][k] = '-';
ans++;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (board[i][j] == '-') board[i][j] = 'X';
}
}
return ans;
}
}
```
* 一次扫描 + $O(m * n)$ 代码:
```Java
class Solution {
public int countBattleships(char[][] board) {
int m = board.length, n = board[0].length;
int ans = 0;
boolean[][] vis = new boolean[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (board[i][j] != 'X' || vis[i][j]) continue;
vis[i][j] = true;
for (int k = i + 1; k < m && board[k][j] == 'X'; k++) vis[k][j] = true;
for (int k = j + 1; k < n && board[i][k] == 'X'; k++) vis[i][k] = true;
ans++;
}
}
return ans;
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.419` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/411-420/420. 强密码检验器（困难）.md | 420. 强密码检验器 | https://leetcode-cn.com/problems/strong-password-checker/solution/by-ac_oier-unp5/ | 困难 | [
"模拟"
] | 如果一个密码满足下述所有条件,则认为这个密码是强密码:
* 由至少 $6$ 个,至多 $20$ 个字符组成。
* 至少包含一个小写字母,一个大写字母,和一个数字。
* 同一字符不能连续出现三次 (比如 `"...aaa..."` 是不允许的, 但是 `"...aa...a..."` 如果满足其他条件也可以算是强密码)。
给你一个字符串 `password`,返回将 `password` 修改到满足强密码条件需要的最少修改步数。如果 `password` 已经是强密码,则返回 $0$ 。
在一步修改操作中,你可以:
* 插入一个字符到 `password`,
* 从 `password` 中删除一个字符,或
* 用另一个字符来替换 `password` 中的某个字符。
示例 1:
```
输入:password = "a"
输出:5
```
示例 2:
```
输入:password = "aA1"
输出:3
```
示例 3:
```
输入:password = "1337C0d3"
输出:0
```
提示:
* $1 <= password.length <= 50$
* `password` 由字母、数字、点 `'.'` 或者感叹号 `'!'` | ### 模拟(分情况讨论)
这是一道麻烦而又没啥意义的题。
需要满足的条件有三个,根据 `password` 的长度 $n$,字符种类数量 $m$,以及相同字符连续长度不低于 $3$ 的情况 $g$(数组 $g$ 的长度为相同字符长度不低于 $3$ 的连续段个数,$g[i]$ 代表第 $i$ 个连续段的长度),进行分情况讨论:
* $n < 6$:长度过短,不满足要求,任何一次「删除」操作都需要额外搭配一个「增加」操作,而这两步操作可以使用「替换」来代替,结果不会变差;同时为了满足长度要求,我们必然要使用到「增加」操作。因此**需要用到「增加」和「替换」操作**,枚举所有的情况发现,最少操作次数最终可以归纳到 $\max(6 - n, 3 - m)$;
* $6 \leqslant n \leqslant 20$:任何的有效的「增加」操作目的只能是为了「破坏连续段长度不低于 $3$」或者「增加字符种类数量」,这两个目的都可以使用「替换」来做到;而任何有效的「删除」操作只能是为了「破坏连续段长度不低于 $3$」,这一目的也可以使用「替换」来做到。因此只**需要用到「替换」操作**,结果不会变差。对于某个 $g[i]$ 而言,我们需要使用 $\left \lfloor \frac{g[i]}{3} \right \rfloor$ 次「替换」操作来满足「连续段长度不能不低于 $3$」的要求,在此基础上再考虑字符种类的问题,最少操作次数最终可以归纳到 $\max(\sum_{i = 0}^{g.length - 1}\left \lfloor \frac{g[i]}{3} \right \rfloor, 3 - m)$;
* $n > 20$:长度过长,不满足要求,任何一次「增加」操作都需要额外搭配一个「删除」操作,**只需要用到「删除」和「替换」操作**,为了满足长度要求,必然用到的「删除」操作可能会影响到最终的「替换」操作,直觉上,应当优先删除那些「连续段长度不低于 $3$」的字符。由于连续段长度 $g[i]$ 与其消耗的「替换」次数的关系为 $\lfloor \frac{g[i]}{3} \rfloor$,在不考虑余数的情况下,每删除 $3$ 个字符,能够连带的减少一次「替换」操作。因此我们可以根据 $g[i]$ 对 $3$ 取模进行统计,得到 $cnts$ 数组($cnts$ 数组长度为 $3$,其中 $cnts[i] = x$ 含义为在所有「连续段长度不低于 $3$」的连续段中,长度余数为 $i$ 的数量有 $x$ 个),按照余数从小到大的优先级进行同步抵消,得到最终的「替换」操作数 $tot$($tot$ 起始值为 $\sum_{i = 0}^{g.length - 1}\left \lfloor \frac{g[i]}{3} \right \rfloor$)。除了可变的「替换」操作以外,我们不可避免还需要 $base = n - 20$ 的「删除」操作,最少操作次数可以归纳到 $base + \max(tot, 3 - m)$
实现上,我们并不需要真正处理出来 $g$ 数组,可以边统计「连续段长度不低于 $3$」边累加需要的「替换」次数。
代码:
```Java
class Solution {
public int strongPasswordChecker(String password) {
char[] cs = password.toCharArray();
int n = cs.length;
int A = 0, B = 0, C = 0;
for (char c : cs) {
if (c >= 'a' && c <= 'z') A = 1;
else if (c >= '0' && c <= '9') B = 1;
else if (c >= 'A' && c <= 'Z') C = 1;
}
int m = A + B + C;
if (n < 6) {
return Math.max(6 - n, 3 - m);
} else if (n <= 20) {
int tot = 0;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && cs[j] == cs[i]) j++;
int cnt = j - i;
if (cnt >= 3) tot += cnt / 3;
i = j;
}
return Math.max(tot, 3 - m);
} else {
int tot = 0;
int[] cnts = new int[3];
for (int i = 0; i < n; ) {
int j = i;
while (j < n && cs[j] == cs[i]) j++;
int cnt = j - i;
if (cnt >= 3) {
tot += cnt / 3; cnts[cnt % 3]++;
}
i = j;
}
int base = n - 20, cur = base;
for (int i = 0; i < 3; i++) {
if (i == 2) cnts[i] = tot;
if (cnts[i] != 0 && cur > 0) {
int t = Math.min(cnts[i] * (i + 1), cur);
cur -= t; tot -= t / (i + 1);
}
}
return base + Math.max(tot, 3 - m);
}
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.420` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/421. 数组中两个数的最大异或值（中等）.md | 421. 数组中两个数的最大异或值 | https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/ | 中等 | [
"字典树",
"贪心"
] | 给你一个整数数组 $nums$ ,返回 `nums[i] XOR nums[j]` 的最大运算结果,其中 $0 ≤ i ≤ j < n$ 。
**进阶**:你可以在 $O(n)$ 的时间解决这个问题吗?
示例 1:
```
输入:nums = [3,10,5,25,2,8]
输出:28
解释:最大运算结果是 5 XOR 25 = 28.
```
示例 2:
```
输入:nums = [0]
输出:0
```
示例 3:
```
输入:nums = [2,4]
输出:6
```
示例 4:
```
输入:nums = [8,10,2]
输出:10
```
示例 5:
```
输入:nums = [14,70,53,83,49,91,36,80,92,51,66,70]
输出:127
```
提示:
* $1 <= nums.length <= 2 \times 10^5$
* $0 <= nums[i] <= 2^{31} - 1$ | ### 基本分析
要求得数组 `nums` 中的「最大异或结果」,假定 $nums[i]$ 与 $nums[j]$ 异或可以取得最终结果。
**由于异或计算「每位相互独立」(又称为不进位加法),同时具有「相同值异或结果为 $0$,不同值异或结果为 $1$」的特性。**
因此对于 $nums[j]$ 而言,可以从其二进制表示中的最高位开始往低位找,尽量让每一位的异或结果为 $1$,这样找到的 $nums[i]$ 与 $nums[j]$ 的异或结果才是最大的。
具体的,我们需要先将 `nums` 中下标范围为 $[0, j]$ 的数(二进制表示)加入 $Trie$ 中,然后每次贪心的匹配每一位(优先匹配与之不同的二进制位)。
---
### 证明
由于我们会从前往后扫描 `nums` 数组,因此 $nums[j]$ 必然会被处理到,所以我们只需要证明,在选定 $nums[j]$ 的情况下,我们的算法能够在 $[0, j]$ 范围内找到 $nums[i]$ 即可。
假定我们算法找出来的数值与 $nums[j]$ 的异或结果为 $x$,而真实的最优异或结果为 $y$。
接下来需要证得 $x$ 和 $y$ 相等。
由于找的是「最大异或结果」, 而 $x$ 是一个合法值,因此我们天然有 $x \leq y$。
然后利用反证法证明 $x \geq y$,假设 $x \geq y$ 不成立,即有 $x < y$,那么从两者的二进制表示的高位开始找,必然能找到第一位不同:$y$ 的「不同位」的值为 $1$,而 $x$ 的「不同位」的值为 $0$。
那么对应到选择这一个「不同位」的逻辑:能够选择与 $nums[j]$ 该位不同的值,使得该位的异或结果为 $1$,但是我们的算法选择了与 $nums[j]$ 该位相同的值,使得该位的异或结果为 $0$。
这与我们的算法逻辑冲突,因此必然不存在这样的「不同位」。即 $x < y$ 不成立,反证 $x \geq y$ 成立。
得证 $x$ 与 $y$ 相等。
---
### Trie 数组实现
可以使用数组来实现 $Trie$,但由于 OJ 每跑一个样例都会创建一个新的对象,因此使用数组实现,相当于每跑一个数据都需要 `new` 一个百万级别的数组,会 TLE 。
因此这里使用数组实现必须要做的一个优化是:**使用 `static` 来修饰 $Trie$ 数组,然后在初始化时做相应的清理工作。**
担心有不熟 Java 的同学,在代码里添加了相应注释说明。
Java 代码:
```Java
class Solution {
// static 成员整个类独一份,只有在类首次加载时才会创建,因此只会被 new 一次
static int N = (int)2e5 * 31, idx = 0;
static int[][] tr = new int[N][2];
// 每跑一个数据,会被实例化一次,每次实例化的时候被调用,做清理工作
public Solution() {
for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);
idx = 0;
}
void add(int x) {
int p = 0;
for (int i = 31; i >= 0; i--) {
int u = (x >> i) & 1;
if (tr[p][u] == 0) tr[p][u] = ++idx;
p = tr[p][u];
}
}
int getVal(int x) {
int p = 0, ans = 0;
for (int i = 31; i >= 0; i--) {
int a = (x >> i) & 1, b = 1 - a;
if (tr[p][b] != 0) {
ans |= (b << i);
p = tr[p][b];
} else {
ans |= (a << i);
p = tr[p][a];
}
}
return ans;
}
public int findMaximumXOR(int[] nums) {
int ans = 0;
for (int i : nums) {
add(i);
int j = getVal(i);
ans = Math.max(ans, i ^ j);
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def findMaximumXOR(self, nums: List[int]) -> int:
N, idx = (len(nums) + 1) * 31, 0
tr = [[0, 0] for _ in range(N)]
def add(x):
nonlocal idx
p = 0
for i in range(31, -1, -1):
u = (x >> i) & 1
if tr[p][u] == 0:
idx += 1
tr[p][u] = idx
p = tr[p][u]
def getVal(x):
p, ans = 0, 0
for i in range(31, -1, -1):
a = (x >> i) & 1
b = 1 - a
if tr[p][b] != 0:
ans |= (b << i)
p = tr[p][b]
else:
ans |= (a << i)
p = tr[p][a]
return ans
ans = 0
for i in nums:
add(i)
j = getVal(i)
ans = max(ans, i ^ j)
return ans
```
C++ 代码:
```C++
class Solution {
public:
static const int N = 2e5 * 31;
int idx = 0;
int tr[N][2] = {0};
Solution() {
for (int i = 0; i <= idx; i++) tr[i][0] = tr[i][1] = 0;
idx = 0;
}
void add(int x) {
int p = 0;
for (int i = 31; i >= 0; i--) {
int u = (x >> i) & 1;
if (tr[p][u] == 0) {
tr[p][u] = ++idx;
}
p = tr[p][u];
}
}
int getVal(int x) {
int p = 0, ans = 0;
for (int i = 31; i >= 0; i--) {
int a = (x >> i) & 1;
int b = 1 - a;
if (tr[p][b] != 0) {
ans |= (b << i);
p = tr[p][b];
} else {
ans |= (a << i);
p = tr[p][a];
}
}
return ans;
}
int findMaximumXOR(vector<int>& nums) {
int ans = 0;
for (int i : nums) {
add(i);
int j = getVal(i);
ans = max(ans, i ^ j);
}
return ans;
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$
---
### Trie 类实现
相比于使用 `static` 来优化,一个更好的做法是使用类来实现 $Trie$,这样可以真正做到「按需分配」内存,缺点是会发生不确定次数的 `new`。
Java 代码:
```Java
class Solution {
class Node {
Node[] ns = new Node[2];
}
Node root = new Node();
void add(int x) {
Node p = root;
for (int i = 31; i >= 0; i--) {
int u = (x >> i) & 1;
if (p.ns[u] == null) p.ns[u] = new Node();
p = p.ns[u];
}
}
int getVal(int x) {
int ans = 0;
Node p = root;
for (int i = 31; i >= 0; i--) {
int a = (x >> i) & 1, b = 1 - a;
if (p.ns[b] != null) {
ans |= (b << i);
p = p.ns[b];
} else {
ans |= (a << i);
p = p.ns[a];
}
}
return ans;
}
public int findMaximumXOR(int[] nums) {
int ans = 0;
for (int i : nums) {
add(i);
int j = getVal(i);
ans = Math.max(ans, i ^ j);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
class Node {
public:
Node* ns[2];
Node() {
ns[0] = nullptr;
ns[1] = nullptr;
}
};
Node* root = new Node();
void add(int x) {
Node* p = root;
for (int i = 31; i >= 0; i--) {
int u = (x >> i) & 1;
if (!p->ns[u]) p->ns[u] = new Node();
p = p->ns[u];
}
}
int getVal(int x) {
int ans = 0;
Node* p = root;
for (int i = 31; i >= 0; i--) {
int a = (x >> i) & 1, b = 1 - a;
if (p->ns[b]) {
ans |= (b << i);
p = p->ns[b];
} else {
ans |= (a << i);
p = p->ns[a];
}
}
return ans;
}
int findMaximumXOR(vector<int>& nums) {
int ans = 0;
for (int i : nums) {
add(i);
int j = getVal(i);
ans = max(ans, i ^ j);
}
return ans;
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.421` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/423. 从英文中重建数字（中等）.md | 423. 从英文中重建数字 | https://leetcode-cn.com/problems/reconstruct-original-digits-from-english/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-m-vg7a/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 给你一个字符串 `s` ,其中包含字母顺序打乱的用英文单词表示的若干数字`(0-9)`。按 升序 返回原始的数字。
示例 1:
```
输入:s = "owoztneoer"
输出:"012"
```
示例 2:
```
输入:s = "fviefuro"
输出:"45"
```
提示:
* $1 <= s.length <= 10^5$
* `s[i]` 为 `["e","g","f","i","h","o","n","s","r","u","t","w","v","x","z"]` 这些字符之一
* `s` 保证是一个符合题目要求的字符串 | ### 模拟
题目要求我们将打乱的英文单词重建为数字。
我们可以先对 `s` 进行词频统计,然后根据「英文单词中的字符唯一性」确定构建的顺序,最后再对答案进行排序即可。
具体的,`zero` 中的 `z` 在其余所有单词中都没出现过,我们可以先统计 `zero` 的出现次数,并构建 $0$;然后观察剩余数字,其中 `eight` 中的 `g` 具有唯一性,构建 $8$;再发现 `six` 中的 `x` 具有唯一性,构建 $6$;发现 `three` 中的 `h` 具有唯一性(利用在此之前 `eight` 已经被删除干净,词频中仅存在 `three` 对应的 `h`),构建 $3$ ...
最终可以确定一个可行的构建序列为 `0, 8, 6, 3, 2, 7, 5, 9, 4, 1`。
代码:
```Java
class Solution {
static String[] ss = new String[]{"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
static int[] priority = new int[]{0, 8, 6, 3, 2, 7, 5, 9, 4, 1};
public String originalDigits(String s) {
int n = s.length();
int[] cnts = new int[26];
for (int i = 0; i < n; i++) cnts[s.charAt(i) - 'a']++;
StringBuilder sb = new StringBuilder();
for (int i : priority) {
int k = Integer.MAX_VALUE;
for (char c : ss[i].toCharArray()) k = Math.min(k, cnts[c - 'a']);
for (char c : ss[i].toCharArray()) cnts[c - 'a'] -= k;
while (k-- > 0) sb.append(i);
}
char[] cs = sb.toString().toCharArray();
Arrays.sort(cs);
return String.valueOf(cs);
}
}
```
* 时间复杂度:令 $m$ 为最终答案的长度,$L$ 为所有英文单词的字符总长度。构建答案的复杂度为 $O(L + m)$;对构建答案进行排序复杂度为 $O(m\log{m})$。整体复杂度为 $O(m\log{m})$
* 空间复杂度:$O(L + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.423` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/424. 替换后的最长重复字符（中等）.md | 424. 替换后的最长重复字符 | https://leetcode-cn.com/problems/longest-repeating-character-replacement/solution/ping-ping-wu-qi-shuang-zhi-zhen-da-bai-h-fgif/ | 中等 | [
"双指针",
"滑动窗口"
] | 给你一个仅由大写英文字母组成的字符串,你可以将任意位置上的字符替换成另外的字符,总共可最多替换 $k$ 次。
在执行上述操作后,找到包含重复字母的最长子串的长度。
注意:字符串长度 和 $k$ 不会超过 $10^4$。
示例 1:
```
输入:s = "ABAB", k = 2
输出:4
解释:用两个'A'替换为两个'B',反之亦然。
```
示例 2:
```
输入:s = "AABABBA", k = 1
输出:4
解释:
将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。
子串 "BBBB" 有最长重复字母, 答案为 4。
``` | ### 滑动窗口
令 `l` 为符合条件的子串的左端点,`r` 为符合条件的子串的右端点。
使用 `cnt` 统计 `[l,r]` 范围的子串中每个字符串出现的次数。
对于合法的子串而言,必然有 `sum(所有字符的出现次数) - max(出现次数最多的字符的出现次数)= other(其他字符的出现次数) <= k`。
当找到这样的性质之后,我们可以对 `s` 进行遍历,每次让 `r` 右移并计数,如果符合条件,更新最大值;如果不符合条件,让 `l` 右移,更新计数,直到符合条件。
代码:
```Java
class Solution {
public int characterReplacement(String s, int k) {
char[] cs = s.toCharArray();
int[] cnt = new int[26];
int ans = 0;
for (int l = 0, r = 0; r < s.length(); r++) {
cnt[cs[r] - 'A']++;
while (!check(cnt, k)) cnt[cs[l++] - 'A']--;
ans = Math.max(ans, r - l + 1);
}
return ans;
}
boolean check(int[] cnt, int k) {
int max = 0, sum = 0;
for (int i = 0; i < 26; i++) {
max = Math.max(max, cnt[i]);
sum += cnt[i];
}
return sum - max <= k;
}
}
```
* 时间复杂度:使用 `l` 和 `r` 指针对 `s` 进行单次扫描,复杂度为 $O(n)$;令 $C = 26$ 为字符集大小,`check` 方法复杂度为 $O(C)$。整体复杂度为 $O(n * C)$。
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.424` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/427. 建立四叉树（中等）.md | 427. 建立四叉树 | https://leetcode.cn/problems/construct-quad-tree/solution/by-ac_oier-maul/ | 中等 | [
"递归",
"前缀和"
] | 给你一个 $n \times n$ 矩阵 `grid` ,矩阵由若干 $0$ 和 $1$ 组成。请你用四叉树表示该矩阵 `grid` 。
你需要返回能表示矩阵的 四叉树 的根结点。
注意,当 `isLeaf` 为 `False` 时,你可以把 `True` 或者 `False` 赋值给节点,两种值都会被判题机制 接受 。
四叉树数据结构中,每个内部节点只有四个子节点。此外,每个节点都有两个属性:
* `val`:储存叶子结点所代表的区域的值。$1$ 对应 `True`,$0$ 对应 `False`;
* `isLeaf`: 当这个节点是一个叶子结点时为 `True`,如果它有 $4$ 个子节点则为 `False` 。
```Java
class Node {
public boolean val;
public boolean isLeaf;
public Node topLeft;
public Node topRight;
public Node bottomLeft;
public Node bottomRight;
}
```
我们可以按以下步骤为二维区域构建四叉树:
1. 如果当前网格的值相同(即,全为 $0$ 或者全为 $1$),将 `isLeaf` 设为 `True` ,将 `val` 设为网格相应的值,并将四个子节点都设为 `Null` 然后停止。
2. 如果当前网格的值不同,将 `isLeaf` 设为 `False`, 将 `val` 设为任意值,然后如下图所示,将当前网格划分为四个子网格。
3. 使用适当的子网格递归每个子节点。
四叉树格式:
输出为使用层序遍历后四叉树的序列化形式,其中 `null` 表示路径终止符,其下面不存在节点。
它与二叉树的序列化非常相似。唯一的区别是节点以列表形式表示 $[isLeaf, val]$ 。
如果 `isLeaf` 或者 `val` 的值为 `True` ,则表示它在列表 $[isLeaf, val]$ 中的值为 $1$ ;如果 `isLeaf` 或者 `val` 的值为 `False` ,则表示值为 $0$ 。
示例 1:
```
输入:grid = [[0,1],[1,0]]
输出:[[0,1],[1,0],[1,1],[1,1],[1,0]]
解释:请注意,在下面四叉树的图示中,0 表示 false,1 表示 True 。
```
示例 2:
```
输入:grid = [[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0]]
输出:[[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
解释:网格中的所有值都不相同。我们将网格划分为四个子网格。
topLeft,bottomLeft 和 bottomRight 均具有相同的值。
topRight 具有不同的值,因此我们将其再分为 4 个子网格,这样每个子网格都具有相同的值。
```
示例 3:
```
输入:grid = [[1,1],[1,1]]
输出:[[1,1]]
```
示例 4:
```
输入:grid = [[0]]
输出:[[1,0]]
```
示例 5:
```
输入:grid = [[1,1,0,0],[1,1,0,0],[0,0,1,1],[0,0,1,1]]
输出:[[0,1],[1,1],[1,0],[1,0],[1,1]]
```
提示:
* $n == grid.length == grid[i].length$
* $n == 2^x$ 其中 $0 <= x <= 6$ | ### 递归
假定我们存在函数 `Node dfs(int a, int b, int c, int d)`,其能够返回「以 $(a, b)$ 为左上角,$(c, d)$ 为右下角」所代表的矩阵的根节点。
那么最终答案为 `dfs(0, 0, n-1, n-1)`,不失一般性考虑「以 $(a, b)$ 为左上角,$(c, d)$ 为右下角」时如何计算:
* 判断该矩阵是否为全 $0$ 或全 $1$:
* 如果是则直接创建根节点(该节点四个子节点属性均为空)并进行返回;
* 如果不是则创建根节点,递归创建四个子节点并进行赋值,利用左上角 $(a,b)$ 和右下角 $(c, d)$ 可算的横纵坐标的长度为 $c - a + 1$ 和 $d - b + 1$,从而计算出将当前矩阵四等分所得到的子矩阵的左上角和右下角坐标。
由于矩阵大小最多为 $2^6 = 64$ ,因此判断某个子矩阵是否为全 $0$ 或全 $1$ 的操作用「前缀和」或者是「暴力」来做都可以。
代码:
```Java
class Solution {
int[][] g;
public Node construct(int[][] grid) {
g = grid;
return dfs(0, 0, g.length - 1, g.length - 1);
}
Node dfs(int a, int b, int c, int d) {
boolean ok = true;
int t = g[a][b];
for (int i = a; i <= c && ok; i++) {
for (int j = b; j <= d && ok; j++) {
if (g[i][j] != t) ok = false;
}
}
if (ok) return new Node(t == 1, true);
Node root = new Node(t == 1, false);
int dx = c - a + 1, dy = d - b + 1;
root.topLeft = dfs(a, b, a + dx / 2 - 1, b + dy / 2 - 1);
root.topRight = dfs(a, b + dy / 2, a + dx / 2 - 1, d);
root.bottomLeft = dfs(a + dx / 2, b, c, b + dy / 2 - 1);
root.bottomRight = dfs(a + dx / 2, b + dy / 2, c, d);
return root;
}
}
```
* 时间复杂度:递归的复杂度分析要根据主定理,假设矩阵大小为 $n \times n$,根据主定理 $T(n) = aT(\frac{n}{b}) + f(n)$,单次递归最多会产生 $4$ 个子问题(由大矩阵递归 $4$ 个小矩阵),因此问题递归子问题数量 $a = 4$,而子问题规模缩减系数 $b$ 为原本的一半(子矩阵的大小为 $\frac{n}{2} \times \frac{n}{2}$),剩余的 $f(n)$ 为判断全 $0$ 和 全 $1$ 的时间开销,不考虑标识位 $ok$ 带来的剪枝效果,每次判断全 $0$ 或全 $1$ 的复杂度与当前问题规模相等,即 $f(n) = O(n^2)$,但整个大小为 $n \times n$ 矩阵每次进行长宽减半的子矩阵拆分,最多会被拆分为 $\log{n}$ 次,因此这部分总的计算量为 $\log{n} \times n^2$ 。整体复杂度为 $O(n^2 + \log{n} \times n^2)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 递归(前缀和优化)
使用前缀和优化「判断全 $0$ 和全 $1$」的操作:对矩阵 `grid` 求前缀和数组 `sum`,对于一个「以左上角为 $(a, b)$,右下角为 $(c, d)$ 」的子矩阵而言,其所包含的格子总数为 $tot = (c - a + 1) * (d - b + 1)$ 个,当且仅当矩阵和为 $0$ 或 $tot$ 时,矩阵全 $0$ 或 $1$。
代码:
```Java
class Solution {
static int[][] sum = new int[70][70];
int[][] g;
public Node construct(int[][] grid) {
g = grid;
int n = grid.length;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + g[i - 1][j - 1];
}
}
return dfs(0, 0, n - 1, n - 1);
}
Node dfs(int a, int b, int c, int d) {
int cur = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b];
int dx = c - a + 1, dy = d - b + 1, tot = dx * dy;
if (cur == 0 || cur == tot) return new Node(g[a][b] == 1, true);
Node root = new Node(g[a][b] == 1, false);
root.topLeft = dfs(a, b, a + dx / 2 - 1, b + dy / 2 - 1);
root.topRight = dfs(a, b + dy / 2, a + dx / 2 - 1, d);
root.bottomLeft = dfs(a + dx / 2, b, c, b + dy / 2 - 1);
root.bottomRight = dfs(a + dx / 2, b + dy / 2, c, d);
return root;
}
}
```
* 时间复杂度:分析同理,但判断全 $0$ 和全 $1$ 的复杂度下降为 $O(1)$,整体复杂度为 $O(n^2 + \log{n})$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.427` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/429. N 叉树的层序遍历（中等）.md | 429. N 叉树的层序遍历 | https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/solution/by-ac_oier-yeye/ | 中等 | [
"BFS",
"树"
] | 给定一个 `N` 叉树,返回其节点值的层序遍历。(即从左到右,逐层遍历)。
树的序列化输入是用层序遍历,每组子节点都由 `null` 值分隔(参见示例)。
示例 1:
```
输入:root = [1,null,3,2,4,null,5,6]
输出:[[1],[3,2,4],[5,6]]
```
示例 2:
```
输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
```
提示:
* 树的高度不会超过 `1000`
* 树的节点总数在 $[0, 10^4]$ 之间 | ### BFS
根据题意进行 `BFS` 即可。
由于我们需要以「层」为单位构建答案,因此在单次 `BFS` 过程中也按层进行。
代码:
```Java
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> ans = new ArrayList<>();
Deque<Node> d = new ArrayDeque<>();
if (root != null) d.addLast(root);
while (!d.isEmpty()) {
int size = d.size();
List<Integer> list = new ArrayList<>();
while (size-- > 0) {
Node t = d.pollFirst();
for (Node node : t.children) d.addLast(node);
list.add(t.val);
}
ans.add(list);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.429` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/421-430/430. 扁平化多级双向链表（中等）.md | 430. 扁平化多级双向链表 | https://leetcode-cn.com/problems/flatten-a-multilevel-doubly-linked-list/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-9wfz/ | 中等 | [
"链表",
"迭代",
"递归"
] | 多级双向链表中,除了指向下一个节点和前一个节点指针之外,它还有一个子链表指针,可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项,依此类推,生成多级数据结构,如下面的示例所示。
给你位于列表第一级的头节点,请你扁平化列表,使所有结点出现在单级双链表中。
示例 1:
```
输入:head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
输出:[1,2,3,7,8,11,12,9,10,4,5,6]
解释:
```
输入的多级列表如下图所示:
扁平化后的链表如下图:
示例 2:
```
输入:head = [1,2,null,3]
输出:[1,3,2]
解释:
输入的多级列表如下图所示:
1---2---NULL
|
3---NULL
```
示例 3:
```
输入:head = []
输出:[]
``` | ### 递归
一道常规链表模拟题。
利用 `flatten` 函数本身的含义(将链表头为 $head$ 的链表进行扁平化,并将扁平化后的头结点进行返回),我们可以很容易写出递归版本。
为防止空节点等边界问题,起始时建立一个哨兵节点 $dummy$ 指向 $head$,然后利用 $head$ 指针从前往后处理链表:
* 当前节点 $head$ 没有 $child$ 节点:直接让指针后即可,即 $head = head.next$;
* 当前节点 $head$ 有 $child$ 节点:将 $head.child$ 传入 `flatten` 函数递归处理,拿到普遍化后的头结点 $chead$,然后将 $head$ 和 $chead$ 建立“相邻”关系(注意要先存起来原本的 $tmp = head.next$ 以及将 $head.child$ 置空),然后继续往后处理,直到扁平化的 $chead$ 链表的尾部,将其与 $tmp$ 建立“相邻”关系。
重复上述过程,直到整条链表被处理完。
代码:
```Java
class Solution {
public Node flatten(Node head) {
Node dummy = new Node(0);
dummy.next = head;
while (head != null) {
if (head.child == null) {
head = head.next;
} else {
Node tmp = head.next;
Node chead = flatten(head.child);
head.next = chead;
chead.prev = head;
head.child = null;
while (head.next != null) head = head.next;
head.next = tmp;
if (tmp != null) tmp.prev = head;
head = tmp;
}
}
return dummy.next;
}
}
```
* 时间复杂度:最坏情况下,每个节点会被访问 $h$ 次($h$ 为递归深度,最坏情况下 $h = n$)。整体复杂度为 $O(n^2)$
* 空间复杂度:最坏情况下所有节点都分布在 `child` 中,此时递归深度为 $n$。复杂度为 $O(n)$
---
### 递归(优化)
在上述解法中,由于我们直接使用 `flatten` 作为递归函数,导致递归处理 $head.child$ 后不得不再进行遍历来找当前层的“尾结点”,这导致算法复杂度为 $O(n^2)$。
一个可行的优化是,额外设计一个递归函数 `dfs` 用于返回扁平化后的链表“尾结点”,从而确保我们找尾结点的动作不会在每层发生。
代码:
```Java
class Solution {
public Node flatten(Node head) {
dfs(head);
return head;
}
Node dfs(Node head) {
Node last = head;
while (head != null) {
if (head.child == null) {
last = head;
head = head.next;
} else {
Node tmp = head.next;
Node childLast = dfs(head.child);
head.next = head.child;
head.child.prev = head;
head.child = null;
if (childLast != null) childLast.next = tmp;
if (tmp != null) tmp.prev = childLast;
last = head;
head = childLast;
}
}
return last;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:最坏情况下所有节点都分布在 `child` 中,此时递归深度为 $n$。复杂度为 $O(n)$
---
### 迭代
自然也能够使用迭代进行求解。
与「递归」不同的是,「迭代」是以“段”为单位进行扁平化,而「递归」是以深度(方向)进行扁平化,这就导致了两种方式对每个扁平节点的处理顺序不同。
已样例 $1$ 为 🌰。
递归的处理节点(新的 $next$ 指针的构建)顺序为:
迭代的处理节点(新的 $next$ 指针的构建)顺序为:
但由于链表本身不存在环,「迭代」的构建顺序发生调整,仍然可以确保每个节点被访问的次数为常数次。
代码:
```Java
class Solution {
public Node flatten(Node head) {
Node dummy = new Node(0);
dummy.next = head;
for (; head != null; ) {
if (head.child == null) {
head = head.next;
} else {
Node tmp = head.next;
Node child = head.child;
head.next = child;
child.prev = head;
head.child = null;
Node last = head;
while (last.next != null) last = last.next;
last.next = tmp;
if (tmp != null) tmp.prev = last;
head = head.next;
}
}
return dummy.next;
}
}
```
* 时间复杂度:可以发现,迭代写法的扁平化过程并不与遍历方向保持一致(以段为单位进行扁平化,而非像递归那样总是往遍历方向进行扁平化),但每个节点被访问的次数仍为常数次。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.430` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/432. 全 O(1) 的数据结构（困难）.md | 432. 全 O(1) 的数据结构 | https://leetcode-cn.com/problems/all-oone-data-structure/solution/by-ac_oier-t26d/ | 困难 | [
"双向链表",
"哈希表"
] | 请你设计一个用于存储字符串计数的数据结构,并能够返回计数最小和最大的字符串。
实现 `AllOne` 类:
* `AllOne()` 初始化数据结构的对象。
* `inc(String key)` 字符串 `key` 的计数增加 $1$ 。如果数据结构中尚不存在 `key` ,那么插入计数为 $1$ 的 `key` 。
* `dec(String key)` 字符串 `key` 的计数减少 $1$ 。如果 `key` 的计数在减少后为 $0$ ,那么需要将这个 `key` 从数据结构中删除。测试用例保证:在减少计数前,`key` 存在于数据结构中。
* `getMaxKey()` 返回任意一个计数最大的字符串。如果没有元素存在,返回一个空字符串 `""` 。
* `getMinKey()` 返回任意一个计数最小的字符串。如果没有元素存在,返回一个空字符串 `""` 。
示例:
```
输入
["AllOne", "inc", "inc", "getMaxKey", "getMinKey", "inc", "getMaxKey", "getMinKey"]
[[], ["hello"], ["hello"], [], [], ["leet"], [], []]
输出
[null, null, null, "hello", "hello", null, "hello", "leet"]
解释
AllOne allOne = new AllOne();
allOne.inc("hello");
allOne.inc("hello");
allOne.getMaxKey(); // 返回 "hello"
allOne.getMinKey(); // 返回 "hello"
allOne.inc("leet");
allOne.getMaxKey(); // 返回 "hello"
allOne.getMinKey(); // 返回 "leet"
```
提示:
* $1 <= key.length <= 10$
* `key` 由小写英文字母组成
* 测试用例保证:在每次调用 `dec` 时,数据结构中总存在 `key`
* 最多调用 `inc`、`dec`、`getMaxKey` 和 `getMinKey` 方法 $5 * 10^4$ 次 | ### 双向链表 + 哈希表
题目要求我们支持 $O(1)$ 的查询和修改,其中查询只需返回任意一个计数次数「最多」和「最少」的元素即可(如果有)。
虽然插入的字符串长度不超过 $10$(该数据范围的含义为字符串的哈希计算消耗可看作常数),但单纯的使用「哈希表」仅能做到 $O(1)$ 的计数,无法做到 $O(1)$ 查询。
**我们可以采取和 [实现一个 LRUCache](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486820&idx=1&sn=2055864e10848bce55afc4e2feda79a7&chksm=fd9ca67bcaeb2f6d2038706e32cafffd701d3d6b71b60c52a568ed6dc0e268d93f8a78498105&token=146288031&lang=zh_CN#rd) & [实现一个 LFUCache](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486856&idx=1&sn=59b2ed57e4a75eac0e63fc0cf08bed5d&chksm=fd9ca697caeb2f81f83cdc741375f9130c3fa40463edb4ae98d702354ca106378fdfe23735ad&token=146288031&lang=zh_CN#rd) 类似的思路,通过自定义节点并手写双链表来实现。**
定义一个节点类 `Node`,除了包含用于实现双向链表的 `left` 和 `right` 以外,还包含一个数值类型的变量 `cnt`, 用于记录该节点存储的是计数次数为多少的元素,以及一个 `Set` 类型的容器,用于支持 $O(1)$ 插入和删除元素,记作 `set`。
同时为了快速知道某个字符串属于哪个 `Node`,我们还需要开一个「哈希表」进行定位(以字符串为哈希表的键,字符串所在 `Node` 作为值),当定位到字符串对应的 `Node` 之后则可以利用双向链表的 $O(1)$ 增加/修改/删除。
在双向链表中,起始只有两个哨兵节点 `hh` 和 `tt` ,当进行若干 `inc/dec` 操作后的基本形态为:
对应几个操作:
`inc/dec` 操作:当对一个字符串 `key` 进行「增加计数」或「减少计数」时,先在哈希表中看 `key` 是否存在:
* 若存在:根据其所属的 `Node` 的计数 `cnt` 为多少,并结合当前是「增加计数」还是「减少计数」来决定是找 `Node` 的「右节点」还是「左节点」,同时检查相邻节点的计数值 `cnt` 是否为目标值,对应要检查数值是 $cnt + 1$ 和 $cnt - 1$:
* 若相邻节点的 `cnt` 为目标值:即目标节点存在,将 `key` 从原 `Node` 的 `set` 集合中移除,并添加到目标节点的集合中,更新哈希表;
* 若相邻节点的 `cnt` 不是目标值:则需要创建相应的目标节点,并构建双向链表关系,把 `key` 存入新创建的目标节点,更新哈希表。
* 若不存在(只能是 `inc` 操作):查找是否存在 $cnt = 1$ 的节点(也就是检查 `hh.right` 节点的计数值):
* 如果存在 $cnt = 1$ 的目标节点:将 `key` 添加到目标节点的 `set` 集合中,更新哈希表;
* 若不存在 $cnt = 1$ 的目标节点:创建相应的节点,并构建双向关系,并构建双向链表关系,把 `key` 存入新创建的目标节点,更新哈希表。
`getMaxKey/getMinKey` 操作:分别从 `tt.left` 和 `hh.right` 中尝试查找,如果存在非哨兵节点,则从节点的 `set` 集合中取任意元素进行返回,否则返回空串。
最后,为了确保 `getMaxKey/getMinKey` 操作能够严格 $O(1)$,我们在进行 `inc/dec` 操作时我们需要对一些 `set` 容量为 $0$ 的节点进行释放,即解除其所在双向链表的关系。
代码:
```Java
class AllOne {
class Node {
int cnt;
Set<String> set = new HashSet<>();
Node left, right;
Node(int _cnt) {
cnt = _cnt;
}
}
Node hh, tt;
Map<String, Node> map = new HashMap<>();
public AllOne() {
hh = new Node(-1000); tt = new Node(-1000);
hh.right = tt; tt.left = hh;
}
void clear(Node node) {
if (node.set.size() == 0) {
node.left.right = node.right;
node.right.left = node.left;
}
}
public void inc(String key) {
if (map.containsKey(key)) {
Node node = map.get(key);
node.set.remove(key);
int cnt = node.cnt;
Node next = null;
if (node.right.cnt == cnt + 1) {
next = node.right;
} else {
next = new Node(cnt + 1);
next.right = node.right;
next.left = node;
node.right.left = next;
node.right = next;
}
next.set.add(key);
map.put(key, next);
clear(node);
} else {
Node node = null;
if (hh.right.cnt == 1) {
node = hh.right;
} else {
node = new Node(1);
node.right = hh.right;
node.left = hh;
hh.right.left = node;
hh.right = node;
}
node.set.add(key);
map.put(key, node);
}
}
public void dec(String key) {
Node node = map.get(key);
node.set.remove(key);
int cnt = node.cnt;
if (cnt == 1) {
map.remove(key);
} else {
Node prev = null;
if (node.left.cnt == cnt - 1) {
prev = node.left;
} else {
prev = new Node(cnt - 1);
prev.right = node;
prev.left = node.left;
node.left.right = prev;
node.left = prev;
}
prev.set.add(key);
map.put(key, prev);
}
clear(node);
}
public String getMaxKey() {
Node node = tt.left;
for (String str : node.set) return str;
return "";
}
public String getMinKey() {
Node node = hh.right;
for (String str : node.set) return str;
return "";
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.432` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/433. 最小基因变化（中等）.md | 433. 最小基因变化 | https://leetcode-cn.com/problems/minimum-genetic-mutation/solution/by-ac_oier-74b4/ | 中等 | [
"BFS",
"双向 BFS",
"图论 DFS",
"AStar 算法",
"启发式搜索"
] | 基因序列可以表示为一条由 $8$ 个字符组成的字符串,其中每个字符都是 `'A'`、`'C'`、`'G'` 和 `'T'` 之一。
假设我们需要调查从基因序列 `start` 变为 `end` 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。
* 例如,`"AACCGGTT" --> "AACCGGTA"` 就是一次基因变化。
另有一个基因库 `bank` 记录了所有有效的基因变化,只有基因库中的基因才是有效的基因序列。
给你两个基因序列 `start` 和 `end` ,以及一个基因库 `bank` ,请你找出并返回能够使 `start` 变化为 `end` 所需的最少变化次数。如果无法完成此基因变化,返回 $-1$ 。
注意:起始基因序列 `start` 默认是有效的,但是它并不一定会出现在基因库中。
示例 1:
```
输入:start = "AACCGGTT", end = "AACCGGTA", bank = ["AACCGGTA"]
输出:1
```
示例 2:
```
输入:start = "AACCGGTT", end = "AAACGGTA", bank = ["AACCGGTA","AACCGCTA","AAACGGTA"]
输出:2
```
示例 3:
```
输入:start = "AAAAACCC", end = "AACCCCCC", bank = ["AAAACCCC","AAACCCCC","AACCCCCC"]
输出:3
```
提示:
* $start.length == 8$
* $end.length == 8$
* $0 <= bank.length <= 10$
* $bank[i].length == 8$
* `start`、`end` 和 `bank[i]` 仅由字符 `['A', 'C', 'G', 'T']` 组成 | ### BFS
为了方便,我们令 $S = start$、 $T = end$,将每个基因序列视为「状态」。
容易想到使用 `BFS` 进行求解,并使用「哈希表」记录到达某个状态所消耗的步数(同时为了快速判断某个状态是否合法,我们使用 `Set` 结构对 $bank[i]$ 进行转存)。
起始将 `S` 加入队列,并更新到达 `S` 所使用的步数为 $0$,然后进行常规的 `BFS` 过程:每次取出队头元素,尝试替换当前状态的某一位,来得到新的状态(限定新状态必须合法,即必须出现在 `Set` 中),如果新状态合法并且没有在记录步数的哈希表中出现过,则将新状态入队并更新得到新状态所用步数,否则丢弃新状态。
重复上述过程直到找到 `T`(返回具体步数) 或者队列为空(返回 $-1$)。
代码:
```Java
class Solution {
static char[] items = new char[]{'A', 'C', 'G', 'T'};
public int minMutation(String S, String T, String[] bank) {
Set<String> set = new HashSet<>();
for (String s : bank) set.add(s);
Deque<String> d = new ArrayDeque<>();
Map<String, Integer> map = new HashMap<>();
d.addLast(S);
map.put(S, 0);
while (!d.isEmpty()) {
int size = d.size();
while (size-- > 0) {
String s = d.pollFirst();
char[] cs = s.toCharArray();
int step = map.get(s);
for (int i = 0; i < 8; i++) {
for (char c : items) {
if (cs[i] == c) continue;
char[] clone = cs.clone();
clone[i] = c;
String sub = String.valueOf(clone);
if (!set.contains(sub)) continue;
if (map.containsKey(sub)) continue;
if (sub.equals(T)) return step + 1;
map.put(sub, step + 1);
d.addLast(sub);
}
}
}
}
return -1;
}
}
```
* 时间复杂度:令 $n$ 为 `bank` 的数组长度(合法状态数),将 `bank` 存入 `Set` 结构复杂度为 $O(n)$,每个状态经过一步操作最多拓展出 $C = 32$ 个新基因(共有 $8$ 个位置,每个位置有 $4$ 个选择),`BFS` 过程复杂度为 $O(C \times n)$。整体复杂度为 $O(C \times n)$
* 空间复杂度:$O(n)$
---
### 双向 BFS
同理,我们可以使用「双向 `BFS`」进行求解。
双向 `BFS` 与常规 `BFS` 相比,能够有效解决「搜索空间爆炸」的问题:
对双向 `BFS` 不熟悉的同学可以看前置🧀:[(题解) 127. 单词接龙](https://leetcode-cn.com/problems/word-ladder/solution/gong-shui-san-xie-ru-he-shi-yong-shuang-magjd/)。
代码:
```Java
class Solution {
static char[] items = new char[]{'A', 'C', 'G', 'T'};
Set<String> set = new HashSet<>();
public int minMutation(String S, String T, String[] bank) {
set.add(S);
for (String s : bank) set.add(s);
if (!set.contains(T)) return -1;
Deque<String> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
d1.addLast(S); d2.addLast(T);
Map<String, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
m1.put(S, 0); m2.put(T, 0);
while (!d1.isEmpty() && !d2.isEmpty()) {
int t = -1;
if (d1.size() <= d2.size()) t = update(d1, m1, m2);
else t = update(d2, m2, m1);
if (t != -1) return t;
}
return -1;
}
int update(Deque<String> d, Map<String, Integer> cur, Map<String, Integer> other) {
int m = d.size();
while (m-- > 0) {
String s = d.pollFirst();
char[] cs = s.toCharArray();
int step = cur.get(s);
for (int i = 0; i < 8; i++) {
for (char c : items) {
if (cs[i] == c) continue;
char[] clone = cs.clone();
clone[i] = c;
String sub = String.valueOf(clone);
if (!set.contains(sub) || cur.containsKey(sub)) continue;
if (other.containsKey(sub)) return other.get(sub) + step + 1;
d.addLast(sub);
cur.put(sub, step + 1);
}
}
}
return -1;
}
}
```
* 时间复杂度:令 $n$ 为 `bank` 的数组长度(合法状态数),将 `bank` 存入 `Set` 结构复杂度为 $O(n)$,每个状态经过一步操作最多拓展出 $C = 32$ 个新基因(共有 $8$ 个位置,每个位置有 $4$ 个选择),`BFS` 过程复杂度为 $O(C \times n)$。整体复杂度为 $O(C \times n)$
* 空间复杂度:$O(n)$
---
### AStar 算法
若不考虑 `bank` 的限制,对于一个特定状态而言,我们可以任意选择一位替换为 $4$ 类字符之一,因此对于任意状态 $x$ 而言,其与目标状态 $T$ 的「理论最小转换步数」为两者对应位置不同字符的数量,而由于存在 `bank` 限制,实际最小步数必然满足「大于等于」该理论最小转换步数。
基于此,我们可以计算当前状态到目标状态的「理论最小转换步数」作为启发式函数,进行启发式搜索。
具体的,我们使用优先队列(堆)维护所有的状态,每次优先「启发值 = 理论最小转换步数」的状态进行优先出队拓展。
对「AStar 算法」不了解的同学可以看前置 🧀:[发挥 A* 算法最大价值的关键点](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489588&idx=1&sn=479e4c0627247ab7e20af7909f2a8b64)。
代码:
```Java
class Solution {
class Node {
String s;
int val;
Node(String _s) {
s = _s;
for (int i = 0; i < 8; i++) {
if (s.charAt(i) != T.charAt(i)) val++;
}
}
}
static char[] items = new char[]{'A', 'C', 'G', 'T'};
String S, T;
public int minMutation(String start, String end, String[] bank) {
Set<String> set = new HashSet<>();
for (String s : bank) set.add(s);
S = start; T = end;
PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);
Map<String, Integer> map = new HashMap<>();
q.add(new Node(S));
map.put(S, 0);
while (!q.isEmpty()) {
Node node = q.poll();
char[] cs = node.s.toCharArray();
int step = map.get(node.s);
for (int i = 0; i < 8; i++) {
for (char c : items) {
if (cs[i] == c) continue;
char[] clone = cs.clone();
clone[i] = c;
String sub = String.valueOf(clone);
if (!set.contains(sub)) continue;
if (sub.equals(T)) return step + 1;
if (!map.containsKey(sub) || map.get(sub) > step + 1) {
map.put(sub, step + 1);
q.add(new Node(sub));
}
}
}
}
return -1;
}
}
```
* 时间复杂度:启发式搜索分析时空复杂度意义不大
* 空间复杂度:启发式搜索分析时空复杂度意义不大
---
### 建图 + DFS
**由 `S` 和 $bank[i]$ 组成合法点集,且点集中任意两点之间存在无向边的充要条件是:点 $u$ 和点 $v$ 所代表的字符中,仅有一个位置字符不同。**
因此我们可以将所有的点存入 `list` 中,假设 `list` 长度为 $n$。同时为了方便,我们人为确保 `S` 出现在头部(点编号为 $1$),`T` 出现在尾部(点编号为 $n$)。
遍历 `list` 进行建图(对于两字符串中仅有一位置不同的点进行连边操作),然后跑一遍从 $1$ 到 $n$ 的 `DFS`。
由于图中可能有环或无解,因此必须「设定一个最大搜索深度」并增加「最优解剪枝」,确保搜索过程结束。
最大搜索深度的设定可以利用反证法:如果 `S` 能够到达 `T`,那么最优路径中必然不存在环(否则可以把环去掉,得到一条更短的路径),即最优路径所经过的点的数量必然不超过 $n$。
代码:
```Java
class Solution {
int N = 15, M = 15 * 15 * 2 + 50, idx = 0, loc = 1;
int[] he = new int[N], e = new int[M], ne = new int[M];
int n, ans;
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
}
void dfs(int u, int fa, int depth) {
if (depth >= ans) return ; // 最优解剪枝
if (u == n) {
ans = depth;
return ;
}
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
dfs(j, u, depth + 1);
}
}
public int minMutation(String S, String T, String[] bank) {
List<String> list = new ArrayList<>();
list.add(S);
boolean ok = false;
for (String s : bank) {
if (s.equals(S)) continue;
if (s.equals(T)) {
ok = true;
continue;
}
list.add(s);
}
if (!ok) return -1;
list.add(T);
n = list.size();
ans = n;
Arrays.fill(he, -1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
int cnt = 0;
for (int k = 0; k < 8 && cnt <= 1; k++) {
if (list.get(i).charAt(k) != list.get(j).charAt(k)) cnt++;
}
if (cnt == 1) {
add(i + 1, j + 1); add(j + 1, i + 1);
}
}
}
dfs(1, -1, 0);
return ans == n ? -1 : ans;
}
}
```
* 时间复杂度:令 `bank` 的长度为 $n$(即点集的数量级为 $n$),预处理出 `list` 的复杂度为 $O(n)$;建图操作的复杂度为 $O(C \times n^2)$,其中 $C = 8$ 基因序列长度;`DFS` 过程由于设定了最大搜索深度,复杂度为 $O(n^2)$。整体复杂度为 $O(C \times n^2)$
* 空间复杂度:最坏情况下为完全图,复杂度为 $O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.433` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/434. 字符串中的单词数（简单）.md | 434. 字符串中的单词数 | https://leetcode-cn.com/problems/number-of-segments-in-a-string/solution/gong-shui-san-xie-jian-dan-zi-fu-mo-ni-t-0gx6/ | 简单 | [
"模拟"
] | 统计字符串中的单词个数,这里的单词指的是连续的不是空格的字符。
请注意,你可以假定字符串里不包括任何不可打印的字符。
示例:
```
输入: "Hello, my name is John"
输出: 5
解释: 这里的单词是指连续的不是空格的字符,所以 "Hello," 算作 1 个单词。
``` | ### 模拟
题目对于「单词」的定义为「连续的不是空格的字符」。
因此,我们可以从前往后处理字符串 `s` 并进行计数,对于是空格的字符进行跳过(不计数),而对于非空格字符,则在遍历完一个完整单词(连续一段)后进行一次计数。
代码:
```Java
class Solution {
public int countSegments(String s) {
int n = s.length();
int ans = 0;
for (int i = 0; i < n; ) {
if (s.charAt(i) == ' ' && i++ >= 0) continue;
while (i < n && s.charAt(i) != ' ') i++;
ans++;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.434` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/436. 寻找右区间（中等）.md | 436. 寻找右区间 | https://leetcode.cn/problems/find-right-interval/solution/by-ac_oier-sijp/ | 中等 | [
"排序",
"二分",
"双指针",
"莫队算法"
] | 给你一个区间数组 `intervals` ,其中 $intervals[i] = [start_i, end_i]$,且每个 $start_i$ 都 不同 。
区间 $i$ 的 右侧区间 可以记作区间 $j$ ,并满足 $start_j >= end_i$ ,且 $start_j$ 最小化 。
返回一个由每个区间 $i$ 的 右侧区间 的最小起始位置组成的数组。如果某个区间 $i$ 不存在对应的 右侧区间 ,则下标 $i$ 处的值设为 $-1$ 。
示例 1:
```
输入:intervals = [[1,2]]
输出:[-1]
解释:集合中只有一个区间,所以输出-1。
```
示例 2:
```
输入:intervals = [[3,4],[2,3],[1,2]]
输出:[-1,0,1]
解释:对于 [3,4] ,没有满足条件的“右侧”区间。
对于 [2,3] ,区间[3,4]具有最小的“右”起点;
对于 [1,2] ,区间[2,3]具有最小的“右”起点。
```
示例 3:
```
输入:intervals = [[1,4],[2,3],[3,4]]
输出:[-1,2,-1]
解释:对于区间 [1,4] 和 [3,4] ,没有满足条件的“右侧”区间。
对于 [2,3] ,区间 [3,4] 有最小的“右”起点。
```
提示:
* $1 <= intervals.length <= 2 \times 10^4$
* $intervals[i].length == 2$
* $-10^6 <= start_i <= end_i <= 10^6$
* 每个间隔的起点都 不相同 | ### 排序 + 二分
为了方便,我们称 $intervals$ 为 $its$。
对于每个 $its[i]$ 而言,我们需要在所有满足「$its[j][0] \geqslant its[i][1]$」中找到 $its[j][0]$ 值最小的下标 $j$,并将其记为 $ans[i]$。
对于一个特定的 $its[i]$ 而言,其右端点固定,并且我们只关心目标位置的左端点。
因此我们可以构造一个记录区间左端点的数组 $clone$,并将其进行排序,同时为了记录每个左端点来自于原序列中的那个下标,还需要额外记录原序列下标,即以 $(start, idx)$ 二元组的形式进行转存,并根据 $start$ 排序。
然后从前往后处理每个 $its[i]$,运用「二分」在 $clone$ 中找到第一个满足左端点 $start$ 大于等于 $its[i][1]$ 的成员 $clone[j]$,将其 $clone[j][1]$ 即是 $its[i]$ 的最右区间。
代码:
```Java
class Solution {
public int[] findRightInterval(int[][] its) {
int n = its.length;
int[][] clone = new int[n][2];
for (int i = 0; i < n; i++) clone[i] = new int[]{its[i][0], i};
Arrays.sort(clone, (a,b)->a[0]-b[0]);
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (clone[mid][0] >= its[i][1]) r = mid;
else l = mid + 1;
}
ans[i] = clone[r][0] >= its[i][1] ? clone[r][1] : -1;
}
return ans;
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;对于每个 $its[i]$ 找到最右区间需要进行二分,复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 双指针(莫队思想)
更进一步,在解法一中我们并没有对求解询问的顺序进行调整,这导致了我们不得不每次都在整个左端点序列中进行二分。
朴素处理询问的方式,需要每次对整个序列进行扫描,复杂度为 $O(n^2)$。
实际上,如果我们按照「右端点从小到大」的顺序处理询问,其每个询问对应的「最右区间的左端点」也具有单调特性。
因此,我们可以运用莫队思想:**通过调整询问的处理顺序,来减少扫描目标位置的指针移动次数。将其从「必然进行 $n^2$ 次移动」优化为「最多不超过 $n$ 次移动」,从而将 构造答案 的复杂度从 $O(n^2)$ 优化为 $O(n)$。**
最后,由于每个 $its[i]$ 只关心目标位置的「左端点」,因此我们无须对某一段进行分块,而直接使用双指针实现即可。
代码:
```Java
class Solution {
public int[] findRightInterval(int[][] its) {
int n = its.length;
int[][] ss = new int[n][2], es = new int[n][2];
for (int i = 0; i < n; i++) {
ss[i] = new int[]{its[i][0], i};
es[i] = new int[]{its[i][1], i};
}
Arrays.sort(ss, (a,b)->a[0]-b[0]);
Arrays.sort(es, (a,b)->a[0]-b[0]);
int[] ans = new int[n];
for (int i = 0, j = 0; i < n; i++) {
int[] cur = es[i];
int loc = cur[0], idx = cur[1];
while (j < n && ss[j][0] < loc) j++;
ans[idx] = j == n ? -1 : ss[j][1];
}
return ans;
}
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$;双指针构造答案的复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.436` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/437. 路径总和 III（中等）.md | 437. 路径总和 III | https://leetcode-cn.com/problems/path-sum-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-q-usa7/ | 中等 | [
"DFS",
"树的遍历",
"前缀和"
] | 给定一个二叉树的根节点 `root` ,和一个整数 `targetSum`,求该二叉树里节点值之和等于 `targetSum` 的 路径 的数目。
路径 不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。
示例 1:
```
输入:root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
输出:3
解释:和等于 8 的路径有 3 条,如图所示。
```
示例 2:
```
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:3
```
提示:
* 二叉树的节点个数的范围是 [0,1000]
* $-10^9 <= Node.val <= 10^9$
* $-1000 <= targetSum <= 1000$ | ### 树的遍历 + DFS
一个朴素的做法是搜索以每个节点为根的(往下的)所有路径,并对路径总和为 $targetSum$ 的路径进行累加统计。
使用 `dfs1` 来搜索所有节点,复杂度为 $O(n)$;在 `dfs1` 中对于每个当前节点,使用 `dfs2` 搜索以其为根的所有(往下的)路径,同时累加路径总和为 $targetSum$ 的所有路径,复杂度为 $O(n)$。
整体复杂度为 $O(n^2)$,数据范围为 $10^3$,可以过。
代码:
```Java
class Solution {
int ans, t;
public int pathSum(TreeNode root, int _t) {
t = _t;
dfs1(root);
return ans;
}
void dfs1(TreeNode root) {
if (root == null) return;
dfs2(root, root.val);
dfs1(root.left);
dfs1(root.right);
}
void dfs2(TreeNode root, long val) {
if (val == t) ans++;
if (root.left != null) dfs2(root.left, val + root.left.val);
if (root.right != null) dfs2(root.right, val + root.right.val);
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$
---
### 树的遍历 + 前缀和
在「解法一」中,我们统计的是以每个节点为根的(往下的)所有路径,也就是说统计的是以每个节点为「路径开头」的所有合法路径。
**本题的一个优化切入点为「路径只能往下」,因此如果我们转换一下,统计以每个节点为「路径结尾」的合法数量的话,配合原本就是「从上往下」进行的数的遍历(最完整的路径必然是从原始根节点到当前节点的唯一路径),相当于只需要在完整路径中找到有多少个节点到当前节点的路径总和为 $targetSum$。**
**于是这个树上问题彻底转换一维问题:求解从原始起点(根节点)到当前节点 $b$ 的路径中,有多少节点 $a$ 满足 $sum[a...b] = targetSum$,由于从原始起点(根节点)到当前节点的路径唯一,因此这其实是一个「一维前缀和」问题。**
具体的,我们可以在进行树的遍历时,记录下从原始根节点 $root$ 到当前节点 $cur$ 路径中,从 $root$ 到任意中间节点 $x$ 的路径总和,配合哈希表,快速找到满足以 $cur$ 为「路径结尾」的、使得路径总和为 $targetSum$ 的目标「路径起点」有多少个。
> 一些细节:由于我们只能统计往下的路径,但是树的遍历会同时搜索两个方向的子树。因此我们应当在搜索完以某个节点为根的左右子树之后,应当回溯地将路径总和从哈希表中删除,防止统计到跨越两个方向的路径。
代码:
```Java
class Solution {
Map<Long, Integer> map = new HashMap<>();
int ans, t;
public int pathSum(TreeNode root, int _t) {
if (root == null) return 0;
t = _t;
map.put(0L, 1);
dfs(root, root.val);
return ans;
}
void dfs(TreeNode root, long val) {
if (map.containsKey(val - t)) ans += map.get(val - t);
map.put(val, map.getOrDefault(val, 0) + 1);
if (root.left != null) dfs(root.left, val + root.left.val);
if (root.right != null) dfs(root.right, val + root.right.val);
map.put(val, map.getOrDefault(val, 0) - 1);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.437` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/438. 找到字符串中所有字母异位词（中等）.md | 438. 找到字符串中所有字母异位词 | https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/solution/gong-shui-san-xie-shuang-zhi-zhen-shi-xi-t5hc/ | 中等 | [
"双指针",
"滑动窗口"
] | 给定两个字符串 `s` 和 `p`,找到 `s` 中所有 `p` 的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。
**异位词** 指由相同字母重排列形成的字符串(包括相同的字符串)。
示例 1:
```
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
```
示例 2:
```
输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
```
提示:
* $1 <= s.length, p.length <= 3 * 10^4$
* `s` 和 `p` 仅包含小写字母 | ### 双指针(滑动窗口)
这是一道使用双指针实现滑动窗口的裸题。
具体的,我们可以先创建一个大小为 $26$ 的数组 $c2$ 来统计字符串 `p` 的词频,另外一个同等大小的数组 $c1$ 用来统计「滑动窗口」内的 `s` 的子串词频。
当两个数组所统计词频相等,说明找到了一个异位组,将窗口的左端点加入答案。
代码:
```Java
class Solution {
public List<Integer> findAnagrams(String s, String p) {
List<Integer> ans = new ArrayList<>();
int n = s.length(), m = p.length();
int[] c1 = new int[26], c2 = new int[26];
for (int i = 0; i < m; i++) c2[p.charAt(i) - 'a']++;
for (int l = 0, r = 0; r < n; r++) {
c1[s.charAt(r) - 'a']++;
if (r - l + 1 > m) c1[s.charAt(l++) - 'a']--;
if (check(c1, c2)) ans.add(l);
}
return ans;
}
boolean check(int[] c1, int[] c2) {
for (int i = 0; i < 26; i++) {
if (c1[i] != c2[i]) return false;
}
return true;
}
}
```
* 时间复杂度:令 `s` 和 `p` 的长度分别为 $n$ 和 $m$,$C = 26$ 为字符集大小。统计 `p` 词频(构建 $c2$ 数组)的复杂度为 $O(m)$;使用双指针检查 `s` 串的复杂度为 $O(C * n)$。整体复杂度为 $O(C*n + m)$
* 空间复杂度:$O(C)$
---
### 优化 check
解法一中每次对滑动窗口的检查都不可避免需要检查两个词频数组,复杂度为 $O(C)$。
事实上,我们只关心两个数组是否完全一致,因而我们能够只维护一个词频数组 $cnt$ 来实现。
起始处理 `p` 串时,只对 $cnt$ 进行词频字符自增操作。当处理 `s` 的滑动窗口子串时,尝试对 $cnt$ 中的词频进行「抵消/恢复」操作:
* 当滑动窗口的右端点右移时(增加字符),对 $cnt$ 执行右端点字符的「抵消」操作;
* 当滑动窗口的左端点右移时(减少字符),对 $cnt$ 执行左端点字符的「恢复」操作。
同时,使用变量 $a$ 统计 `p` 中不同字符的数量,使用变量 $b$ 统计滑动窗口(子串)内有多少个字符词频与 $p$ 相等。
当滑动窗口移动( 执行「抵消/恢复」)时,如果「抵消」后该字符词频为 $0$,说明本次右端点右移,多产生了一位词频相同的字符;如果「恢复」后该字符词频数量为 $1$,说明少了一个为词频相同的字符。当且仅当 $a = b$ 时,我们找到了一个新的异位组。
代码:
```Java
class Solution {
public List<Integer> findAnagrams(String s, String p) {
List<Integer> ans = new ArrayList<>();
int n = s.length(), m = p.length();
int[] cnt = new int[26];
for (int i = 0; i < m; i++) cnt[p.charAt(i) - 'a']++;
int a = 0;
for (int i = 0; i < 26; i++) if (cnt[i] != 0) a++;
for (int l = 0, r = 0, b = 0; r < n; r++) {
// 往窗口增加字符,进行词频的抵消操作,如果抵消后词频为 0,说明有一个新的字符词频与 p 完全相等
if (--cnt[s.charAt(r) - 'a'] == 0) b++;
// 若窗口长度超过规定,将窗口左端点右移,执行词频恢复操作,如果恢复后词频为 1(恢复前为 0),说明少了一个词频与 p 完全性相等的字符
if (r - l + 1 > m && ++cnt[s.charAt(l++) - 'a'] == 1) b--;
if (b == a) ans.add(l);
}
return ans;
}
}
```
* 时间复杂度:令 `s` 和 `p` 的长度分别为 $n$ 和 $m$,$C = 26$ 为字符集大小。构造 $cnt$ 的复杂度为 $O(m)$,统计 $p$ 中不同的字符数量为 $O(C)$,对 `s` 进行滑动窗口扫描得出答案的复杂度为 $O(n)$。整体复杂度为 $O(m + C + n)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.438` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/431-440/440. 字典序的第K小数字（困难）.md | 440. 字典序的第K小数字 | https://leetcode-cn.com/problems/k-th-smallest-in-lexicographical-order/solution/by-ac_oier-m3zl/ | 困难 | [
"数学",
"模拟",
"找规律",
"计数"
] | 给定整数 $n$ 和 $k$,返回 $[1, n]$ 中字典序第 $k$ 小的数字。
示例 1:
```
输入: n = 13, k = 2
输出: 10
解释: 字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9],所以第二小的数字是 10。
```
示例 2:
```
输入: n = 1, k = 1
输出: 1
```
提示:
* $1 <= k <= n <= 10^9$ | ### 计数模拟
寻找字典序第 $k$ 小的数。
我们可以将该过程分两步操作 :「确定前缀」和「从以某个前缀开始找目标值」。
假定我们存在某个函数 `int getCnt(int x, int limit)`,该函数实现了统计范围 $[1, limit]$ 内以 $x$ 为前缀的数的个数。
有了该函数之后,我们可以从最小的前缀 $1$ 开始枚举,假设当前枚举到前缀 $x$,根据 $cnt = getCnt(x, n)$ 与 $k$ 的大小关系进行分情况讨论:
* $cnt < k$:说明所有以 $x$ 为前缀的数组均可跳过,此时让 $x$ 自增,$k$ 减去 $cnt$。含义为从下一个「数值比 $x$ 大」的前缀中找目标值;
* $cnt \geqslant k$:说明目标值前缀必然为 $x$,此时我们需要在以 $x$ 为前缀的前提下找目标值。此时让 $x$ 乘 $10$,$k$ 减 $1$(代表跳过了 $x$ 本身)。含义为从下一个「字典序比 $x$ 大」的前缀中找目标值。
当 $k = 1$ 时,当前前缀 $x$ 即是答案(含义为以 $x$ 为前缀的所有数中,最小的数,也就是 $x$ 本身)。
然后重点看看 `int getCnt(int x, int limit)` 函数如何实现。
为了方便,记 $x$ 的位数为 $n$,$limit$ 位数为 $m$。
根据 `getCnt` 的函数定义,在范围 $[1, limit]$ 内,以 $x$ 为前缀的数值数量等于下面所有情况的数量之和:
* 位数为 $n$ 的数:仅有 $x$ 本身,共 $1$ 个;
* 位数为 $n + 1 < m$ 的数,有 `x0` 到 `x9`,共 $10$ 个;
* 位数为 $n + 2 < m$ 的数,有 `x00` 到 `x99`,共 $100$ 个;
* ...
* 位数为 $m$ 的数,此时根据「$limit$ 长度与 $x$ 等同的前缀 $u$」和「$x$」的大小关系,进一步分情况讨论(举个 🌰,当 $limit = 12456$,$x$ 为 $123$ 时,$u = 124$,两者位数相差 $k = 2$ 位):
* $u < x$:此时所有位数为 $m$ 的数均大于 $limit$,合法个数为 $0$;
* $u == x$:此时所有位数为 $m$ 的数中部分满足 $limit$ 限制,合法个数为 $limit - x * 10^k + 1$ 个(只有 $[x0...0, limit]$ 为合法数);
* $u > x$:此时所有位数为 $m$ 的数均小于 $limit$,合法个数为 $10^k$。
Java 代码:
```Java
class Solution {
public int findKthNumber(int n, int k) {
int ans = 1;
while (k > 1) {
int cnt = getCnt(ans, n);
if (cnt < k) {
k -= cnt; ans++;
} else {
k--; ans *= 10;
}
}
return ans;
}
int getCnt(int x, int limit) {
String a = String.valueOf(x), b = String.valueOf(limit);
int n = a.length(), m = b.length(), k = m - n;
int ans = 0, u = Integer.parseInt(b.substring(0, n));
for (int i = 0; i < k; i++) ans += Math.pow(10, i);
if (u > x) ans += Math.pow(10, k);
else if (u == x) ans += limit - x * Math.pow(10, k) + 1;
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int findKthNumber(int n, int k) {
int ans = 1;
while (k > 1) {
int cnt = getCnt(ans, n);
if (cnt < k) {
k -= cnt; ans++;
} else {
k--; ans *= 10;
}
}
return ans;
}
int getCnt(int x, int limit) {
string a = to_string(x), b = to_string(limit);
int n = a.length(), m = b.length(), k = m - n;
int ans = 0, u = stoi(b.substr(0, n));
for (int i = 0; i < k; i++) ans += pow(10, i);
if (u > x) ans += pow(10, k);
else if (u == x) ans += limit - x * pow(10, k) + 1;
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def findKthNumber(self, n: int, k: int) -> int:
def get_cnt(x, limit):
a, b = str(x), str(limit)
n, m = len(a), len(b)
k = m - n
ans = 0
u = int(b[:n])
for i in range(k):
ans += int(pow(10, i))
if u > x:
ans += int(pow(10, k))
elif u == x:
ans += limit - x * int(pow(10, k)) + 1
return ans
ans = 1
while k > 1:
cnt = get_cnt(ans, n)
if cnt < k:
k, ans = k - cnt, ans + 1
else:
k, ans = k - 1, ans * 10
return ans
```
TypeScript 代码:
```TypeScript
function findKthNumber(n: number, k: number): number {
const getCnt = function(x: number, limit: number): number {
const a = String(x), b = String(limit);
const n = a.length, m = b.length, k = m - n;
let ans = 0;
let u = parseInt(b.substring(0, n));
for (let i = 0; i < k; i++) ans += Math.pow(10, i);
if (u > x) ans += Math.pow(10, k);
else if (u == x) ans += limit - x * Math.pow(10, k) + 1;
return ans;
};
let ans = 1;
while (k > 1) {
let cnt = getCnt(ans, n);
if (cnt < k) {
k -= cnt; ans++;
} else {
k--; ans *= 10;
}
}
return ans;
};
```
* 时间复杂度:枚举前缀以及 `getCnt` 操作均与位数相关,复杂度均为 $O(\log{n})$。整体复杂度为 $O(\log{^2}{n})$
* 空间复杂度:忽略子串生成复杂度为 $O(1)$,否则为 $O(\log{^2}{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.440` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/441. 排列硬币（简单）.md | 441. 排列硬币 | https://leetcode-cn.com/problems/arranging-coins/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-x-sv9o/ | 简单 | [
"数学",
"二分"
] | 你总共有 `n` 枚硬币,并计划将它们按阶梯状排列。
对于一个由 `k` 行组成的阶梯,其第 `i` 行必须正好有 i 枚硬币。阶梯的最后一行**可能**是不完整的。
给你一个数字 `n` ,计算并返回可形成**完整阶梯行**的总行数。
示例 1:
```
输入:n = 5
输出:2
解释:因为第三行不完整,所以返回 2 。
```
示例 2:
```
输入:n = 8
输出:3
解释:因为第四行不完整,所以返回 3 。
```
提示:
* $1 <= n <= 2^{31} - 1$ | ### 数学
假设 $n$ 个硬币最多凑出 $x$ 行,根据等差数列求和公式 $S_n = n * a_1 + \frac{n * (n - 1)}{2} * d$(首项和公差均为 $1$),可得 $n$ 和 $x$ 的关系:
$$
\frac{x * (x + 1)}{2} <= n
$$
问题为求满足上式前提下,$x$ 的最大值为多少。
根据 [求解一元二次方程](https://baike.baidu.com/item/%E4%B8%80%E5%85%83%E4%BA%8C%E6%AC%A1%E6%96%B9%E7%A8%8B) 求根公式,可得:
$$
x <= \left \lfloor \frac{- 1 + \sqrt{1 + 8 * n}}{2} \right \rfloor
$$
代码:
```Java
class Solution {
public int arrangeCoins(int n) {
return (int)((Math.sqrt(1 + 8.0 * n) - 1) / 2);
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
---
### 二分
对于解方程不熟悉的同学,也可以使用「二分」来做。
对于 $n$ 个硬币而言,最多凑成的行数不会超过 $n$ 行,当且仅当 $n = 1$ 的时候可以取到。
假设最大能够凑成的行数为 $x$,那么以 $x$ 为分割点的数轴上具有二段性,使用 $n$ 个硬币如果能够凑成 $x$ 行,那么必然也能够凑成少于等于 $x$ 行的阶梯硬币,必然不能凑成大于 $x$ 行的阶梯硬币。
对于 $x$ 行阶梯硬币所需要的硬币数量,还是可以利用等差数列求和公式直接算出。
代码:
```Java
class Solution {
public int arrangeCoins(int n) {
long l = 1, r = n;
while (l < r) {
long mid = l + r + 1 >> 1;
if (mid * (mid + 1) / 2 <= n) l = mid;
else r = mid - 1;
}
return (int)r;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.441` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/442. 数组中重复的数据（中等）.md | 442. 数组中重复的数据 | https://leetcode-cn.com/problems/find-all-duplicates-in-an-array/solution/by-ac_oier-0m3c/ | 中等 | [
"原地哈希",
"数组"
] | 给你一个长度为 $n$ 的整数数组 `nums`,其中 `nums` 的所有整数都在范围 $[1, n]$ 内,且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数,并以数组形式返回。
你必须设计并实现一个时间复杂度为 $O(n)$ 且仅使用常量额外空间的算法解决此问题。
示例 1:
```
输入:nums = [4,3,2,7,8,2,3,1]
输出:[2,3]
```
示例 2:
```
输入:nums = [1,1,2]
输出:[1]
```
示例 3:
```
输入:nums = [1]
输出:[]
```
提示:
* $n == nums.length$
* $1 <= n <= 10^5$
* $1 <= nums[i] <= n$
* `nums` 中的每个元素出现 一次 或 两次 | ### 原地哈希
给定数组长度为 $n$,且所有数范围在 $[1, n]$,找出出现次数超过一次的所有数字。
利用值域与数字下标空间大小的等同关系,我们可以构造一种对应“关系”,使得每个数出现在它应该出现的位置:对于值为 $k$ 的数字,我们将其应该出现在的位置定为 $k - 1$。
基于此,我们从前往后遍历 $nums$,并尝试将当前处理到的 $nums[i]$ 放到目标位置 $nums[i] - 1$ 处。如果一个数在尝试移动到它应该出现的位置时,发现 $nums[nums[i] - 1] = nums[i] (nums[i] - 1 \neq i)$,则说明该数字出现了超过一次。此时我们将 $nums[i]$ 加入答案,由于此时没有发生交换,而 $nums[i]$ 占用的仍是其他数字的目标位置,为了防止 $nums[i]$ 与其他数字发生交换后,再次被检验并重复加入答案,我们将 $nums[i]$ 置为负数,并在遍历过程中跳过负数。
代码:
```Java
class Solution {
public List<Integer> findDuplicates(int[] nums) {
List<Integer> ans = new ArrayList<>();
int n = nums.length;
for (int i = 0; i < n; i++) {
int t = nums[i];
if (t < 0 || t - 1 == i) continue;
if (nums[t - 1] == t) {
ans.add(t);
nums[i] *= -1;
} else {
int c = nums[t - 1];
nums[t - 1] = t;
nums[i--] = c;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.442` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/443. 压缩字符串（中等）.md | 443. 压缩字符串 | https://leetcode-cn.com/problems/string-compression/solution/gong-shui-san-xie-shuang-zhi-zhen-yuan-d-bppu/ | 中等 | [
"模拟",
"双指针",
"字符串"
] | 给你一个字符数组 chars ,请使用下述算法压缩:
从一个空字符串 s 开始。对于 chars 中的每组 连续重复字符 :
* 如果这一组长度为 1 ,则将字符追加到 s 中。
* 否则,需要向 s 追加字符,后跟这一组的长度。
压缩后得到的字符串 s 不应该直接返回 ,需要转储到字符数组 chars 中。需要注意的是,如果组长度为 10 或 10 以上,则在 chars 数组中会被拆分为多个字符。
请在** 修改完输入数组后**,返回该数组的新长度。
你必须设计并实现一个只使用常量额外空间的算法来解决此问题。
示例 1:
```
输入:chars = ["a","a","b","b","c","c","c"]
输出:返回 6 ,输入数组的前 6 个字符应该是:["a","2","b","2","c","3"]
解释:
"aa" 被 "a2" 替代。"bb" 被 "b2" 替代。"ccc" 被 "c3" 替代。
```
示例 2:
```
输入:chars = ["a"]
输出:返回 1 ,输入数组的前 1 个字符应该是:["a"]
解释:
没有任何字符串被替代。
```
示例 3:
```
输入:chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
输出:返回 4 ,输入数组的前 4 个字符应该是:["a","b","1","2"]。
解释:
由于字符 "a" 不重复,所以不会被压缩。"bbbbbbbbbbbb" 被 “b12” 替代。
注意每个数字在数组中都有它自己的位置。
```
提示:
* 1 <= chars.length <= 2000
* chars[i] 可以是小写英文字母、大写英文字母、数字或符号 | ### 双指针
令输入数组 `cs` 长度为 $n$。
使用两个指针 `i` 和 `j` 分别指向「当前处理到的位置」和「答案待插入的位置」:
1. `i` 指针一直往后处理,每次找到字符相同的连续一段 $[i, idx)$,令长度为 $cnt$;
2. 将当前字符插入到答案,并让 `j` 指针后移:`cs[j++] = cs[i]`;
3. 检查长度 $cnt$ 是否大于 $1$,如果大于 $1$,需要将数字拆分存储。由于简单的实现中,我们只能从个位开始处理 $cnt$,因此需要使用 `start` 和 `end` 记录下存储数字的部分,再处理完 $cnt$ 后,将 $[start, end)$ 部分进行翻转,并更新 `j` 指针;
4. 更新 `i` 为 `idx`,代表循环处理下一字符。
代码:
```Java
class Solution {
public int compress(char[] cs) {
int n = cs.length;
int i = 0, j = 0;
while (i < n) {
int idx = i;
while (idx < n && cs[idx] == cs[i]) idx++;
int cnt = idx - i;
cs[j++] = cs[i];
if (cnt > 1) {
int start = j, end = start;
while (cnt != 0) {
cs[end++] = (char)((cnt % 10) + '0');
cnt /= 10;
}
reverse(cs, start, end - 1);
j = end;
}
i = idx;
}
return j;
}
void reverse(char[] cs, int start, int end) {
while (start < end) {
char t = cs[start];
cs[start] = cs[end];
cs[end] = t;
start++; end--;
}
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/446. 等差数列划分 II - 子序列（困难）.md | 446. 等差数列划分 II - 子序列 | https://leetcode-cn.com/problems/arithmetic-slices-ii-subsequence/solution/gong-shui-san-xie-xiang-jie-ru-he-fen-xi-ykvk/ | 困难 | [
"动态规划",
"序列 DP",
"容斥原理",
"数学"
] | 给你一个整数数组 nums ,返回 nums 中所有 等差子序列 的数目。
如果一个序列中 至少有三个元素 ,并且任意两个相邻元素之差相同,则称该序列为等差序列。
* 例如,[1, 3, 5, 7, 9]、[7, 7, 7, 7] 和 [3, -1, -5, -9] 都是等差序列。
* 再例如,[1, 1, 2, 5, 7] 不是等差序列。
数组中的子序列是从数组中删除一些元素(也可能不删除)得到的一个序列。
* 例如,[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。
题目数据保证答案是一个 32-bit 整数。
示例 1:
```
输入:nums = [2,4,6,8,10]
输出:7
解释:所有的等差子序列为:
[2,4,6]
[4,6,8]
[6,8,10]
[2,4,6,8]
[4,6,8,10]
[2,4,6,8,10]
[2,6,10]
```
示例 2:
```
输入:nums = [7,7,7,7,7]
输出:16
解释:数组中的任意子序列都是等差子序列。
```
提示:
* 1 <= nums.length <= 1000
* -$2^{31}$ <= nums[i] <= $2^{31}$ - 1 | ### 基本分析
从题目描述来看,我们可以确定这是一个「序列 DP」问题,通常「序列 DP」需要 $O(n^2)$ 的时间复杂度,而某些具有特殊性质的「序列 DP」问题,例如 LIS 问题,能够配合贪心思路 + 二分做到 $O(n\log{n})$ 复杂度。再看一眼数据范围为 $10^3$,基本可以确定这是一道复杂度为 $O(n^2)$ 的「序列 DP」问题。
---
### 动态规划 + 容斥原理
**既然分析出是序列 DP 问题,我们可以先猜想一个基本的状态定义,看是否能够「不重不漏」的将状态通过转移计算出来。如果不行,我们再考虑引入更多的维度来进行求解。**
先从最朴素的猜想出发,定义 $f[i]$ 为考虑下标不超过 $i$ 的所有数,并且以 $nums[i]$ 为结尾的等差序列的个数。
不失一般性的 $f[i]$ 该如何转移,不难发现我们需要枚举 $[0, i - 1]$ 范围内的所有数,假设当前我们枚举到 $[0, i - 1]$ 中的位置 $j$,我们可以直接算出两个位置的差值 $d = nums[i] - nums[j]$,但我们不知道 $f[j]$ 存储的子序列数量是差值为多少的。
同时,根据题目我们要求的是所有的等差序列的个数,而不是求差值为某个具体值 $x$ 的等差序列的个数。换句话说,我们需要记录下所有差值的子序列个数,并求和才是答案。
**因此我们的 $f[i]$ 不能是一个数,而应该是一个「集合」,该集合记录下了所有以 $nums[i]$ 为结尾,差值为所有情况的子序列的个数。**
我们可以设置 $f[i] = g$,其中 $g$ 为一个「集合」数据结构,我们期望在 $O(1)$ 的复杂度内查的某个差值 $d$ 的子序列个数是多少。
**这样 $f[i][j]$ 就代表了以 $nums[i]$ 为结尾,并且差值为 $j$ 的子序列个数是多少。**
当我们多引入一维进行这样的状态定义后,我们再分析一下能否「不重不漏」的通过转移计算出所有的动规值。
不失一般性的考虑 $f[i][j]$ 该如何转移,显然序列 DP 问题我们还是要枚举区间 $[0, i - 1]$ 的所有数。
**和其他的「序列 DP」问题一样,枚举当前位置前面的所有位置的目的,是为了找到当前位置的数,能够接在哪一个位置的后面,形成序列。**
**对于本题,枚举区间 $[0, i - 1]$ 的所有数的含义是:枚举以 $nums[i]$ 为子序列结尾时,它的前一个值是什么,也就是 $nums[i]$ 接在哪个数的后面,形成等差子序列。**
这样必然是可以「不重不漏」的处理到所有以 $nums[i]$ 为子序列结尾的情况的。
至于具体的状态转移方程,我们令差值 $d = nums[i] - nums[j]$,显然有(先不考虑长度至少为 $3$ 的限制):
$$
f[i][d] = \sum_{j = 0}^{i - 1} (f[j][d] + 1)
$$
含义为:**在原本以 $nums[j]$ 为结尾的,且差值为 $d$ 的子序列的基础上接上 $nums[i]$,再加上新的子序列 $(nums[j], nums[i])$,共 $f[j][d] + 1$ 个子序列。**
**最后对所有的哈希表的「值」对进行累加计数,就是以任意位置为结尾,长度大于 $1$ 的等差子序列的数量 $ans$。**
这时候再看一眼数据范围 $-2^{31} <= nums[i] <= 2^{31}-1$,如果从数据范围出发,使用「数组」充当集合的话,我们需要将数组开得很大,必然会爆内存。
但同时有 $1 <= nums.length <= 1000$,也就是说「最小差值」和「最大差值」之间可能相差很大,但是差值的数量是有限的,不会超过 $n^2$ 个。
为了不引入复杂的「离散化」操作,我们可以直接使用「哈希表」来充当「集合」。
每一个 $f[i]$ 为一个哈希表,哈希表的以 `{d:cnt}` 的形式进行存储,`d` 为子序列差值,`cnt` 为子序列数量。
虽然相比使用数组,哈希表常数更大,但是经过上述分析,我们的复杂度为 $O(n^2)$,计算量为 $10^6$,距离计算量上界 $10^7$ 还保有一段距离,因此直接使用哈希表十分安全。
到这里,我们解决了不考虑「长度为至少为 $3$」限制的原问题。
那么需要考虑「长度为至少为 $3$」限制怎么办?
**显然,我们计算的 $ans$ 为统计所有的「长度大于 $1$」的等差子序列数量,由于长度必然为正整数,也就是统计的是「长度大于等于 $2$」的等差子序列的数量。**
**因此,如果我们能够求出长度为 $2$ 的子序列的个数的话,从 $ans$ 中减去,得到的就是「长度为至少为 $3$」子序列的数量。**
长度为 $2$ 的等差子序列,由于没有第三个数的差值限制,因此任意的数对 $(j, i)$ 都是一个合法的长度为 $2$ 的等差子序列。
而求长度为 $n$ 的数组的所有数对,其实就是求 **首项为 $0$,末项为 $n - 1$,公差为 $1$,长度为 $n$ 的等差数列之和**,直接使用「等差数列求和」公式求解即可。
代码:
```Java
class Solution {
public int numberOfArithmeticSlices(int[] nums) {
int n = nums.length;
// 每个 f[i] 均为哈希表,哈希表键值对为 {d : cnt}
// d : 子序列差值
// cnt : 以 nums[i] 为结尾,且差值为 d 的子序列数量
List<Map<Long, Integer>> f = new ArrayList<>();
for (int i = 0; i < n; i++) {
Map<Long, Integer> cur = new HashMap<>();
for (int j = 0; j < i; j++) {
Long d = nums[i] * 1L - nums[j];
Map<Long, Integer> prev = f.get(j);
int cnt = cur.getOrDefault(d, 0);
cnt += prev.getOrDefault(d, 0);
cnt ++;
cur.put(d, cnt);
}
f.add(cur);
}
int ans = 0;
for (int i = 0; i < n; i++) {
Map<Long, Integer> cur = f.get(i);
for (Long key : cur.keySet()) ans += cur.get(key);
}
int a1 = 0, an = n - 1;
int cnt = (a1 + an) * n / 2;
return ans - cnt;
}
}
```
* 时间复杂度:DP 过程的复杂度为 $O(n^2)$,遍历所有的哈希表的复杂度上界不会超过 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:所有哈希表存储的复杂度上界不会超过 $O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/447. 回旋镖的数量（中等）.md | 447. 回旋镖的数量 | https://leetcode-cn.com/problems/number-of-boomerangs/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-evu2/ | 中等 | [
"哈希表",
"模拟"
] | 给定平面上 `n` 对 互不相同 的点 `points`,其中 `points[i] = [xi, yi]` 。回旋镖 是由点 `(i, j, k)` 表示的元组 ,其中 `i` 和 `j` 之间的距离和 `i` 和 `k` 之间的距离相等(需要考虑元组的顺序)。
返回平面上所有回旋镖的数量。
示例 1:
```
输入:points = [[0,0],[1,0],[2,0]]
输出:2
解释:两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
```
示例 2:
```
输入:points = [[1,1],[2,2],[3,3]]
输出:2
```
示例 3:
```
输入:points = [[1,1]]
输出:0
```
提示:
* $n == points.length$
* $1 <= n <= 500$
* $points[i].length == 2$
* -$10^4 <= x_i, y_i <= 10^4$
* 所有点都 互不相同 | ### 哈希表
数据范围为 $500$,三层循环的朴素做法显然会 TLE。
对于每个回旋镖三元组而言,本质上我们在统计给定 $i$ 的情况下,与 $i$ 距离相等的 $(j, k)$ 组合个数为多少。
我们可以使用哈希表进行预处理,在统计以 $i$ 为三元组第一位的回旋镖个数前,先计算出 $i$ 和其余点的距离,并以 `{ 距离 : 个数 }` 的形式进行存储,然后分别对所有的距离进行累加计数。
在计算距离时为了避免使用 `sqrt`,我们直接使用 $x^2 + y^2$ 来代指两点间的距离。
代码:
```Java
class Solution {
public int numberOfBoomerangs(int[][] points) {
int n = points.length;
int ans = 0;
for (int i = 0; i < n; i++) {
Map<Integer, Integer> map = new HashMap<>();
for (int j = 0; j < n; j++) {
if (i == j) continue;
int x = points[i][0] - points[j][0], y = points[i][1] - points[j][1];
int dist = x * x + y * y;
map.put(dist, map.getOrDefault(dist, 0) + 1);
}
for (int dist : map.keySet()) {
int cnt = map.get(dist);
ans += cnt * (cnt - 1);
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.447` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/448. 找到所有数组中消失的数字（简单）.md | 448. 找到所有数组中消失的数字 | https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array/solution/li-yong-tong-pai-xu-de-si-lu-ni-huan-ke-e3t4w/ | 简单 | [
"排序",
"原地哈希"
] | 给定一个范围在 $1 ≤ a[i] ≤ n$ ( $n$ = 数组大小 ) 的 整型数组,数组中的元素一些出现了两次,另一些只出现一次。
找到所有在 $[1, n]$ 范围之间没有出现在数组中的数字。
您能在不使用额外空间且时间复杂度为 $O(n)$ 的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。
示例:
```
输入:
[4,3,2,7,8,2,3,1]
输出:
[5,6]
``` | ### 桶排序(原地哈希)
题目规定了 $1 ≤ a[i] ≤ n$,因此我们可以使用「桶排序」的思路,将每个数放在其应该出现的位置上。
基本思路为:
按照桶排序思路进行预处理:保证 $1$ 出现在 $nums[0]$ 的位置上,$2$ 出现在 $nums[1]$ 的位置上,...,$n$ 出现在 $nums[n - 1]$ 的位置上。不在 $[1, n]$ 范围内的数不用动。
例如样例中 $[4,3,2,7,8,2,3,1]$ 将会被预处理成 $[1,2,3,4,3,2,7,8]$。
遍历 $nums$,将不符合 `nums[i] != i + 1` 的数字加入结果集 ~
代码:
```Java
class Solution {
public List<Integer> findDisappearedNumbers(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) swap(nums, i, nums[i] - 1);
}
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (nums[i] != i + 1) ans.add(i + 1);
}
return ans;
}
void swap(int[] nums, int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
}
```
* 时间复杂度:每个数字最多挪动一次。复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.448` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/449. 序列化和反序列化二叉搜索树（中等）.md | 449. 序列化和反序列化二叉搜索树 | https://leetcode.cn/problems/serialize-and-deserialize-bst/solution/by-ac_oier-ncwn/ | 中等 | [
"前序遍历",
"BST",
"二分"
] | 序列化是将数据结构或对象转换为一系列位的过程,以便它可以存储在文件或内存缓冲区中,或通过网络连接链路传输,以便稍后在同一个或另一个计算机环境中重建。
设计一个算法来序列化和反序列化 二叉搜索树 。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串,并且可以将该字符串反序列化为最初的二叉搜索树。
编码的字符串应尽可能紧凑。
示例 1:
```
输入:root = [2,1,3]
输出:[2,1,3]
```
示例 2:
```
输入:root = []
输出:[]
```
提示:
* 树中节点数范围是 $[0, 10^4]$
* $0 <= Node.val <= 10^4$
* 题目数据 保证 输入的树是一棵二叉搜索树。 | ### BST 特性(前序遍历)
实现上,我们可以忽略「BST」这一条件,使用「BFS」或者「直接充当满二叉树」来序列化和反序列化。
但由于点的数量是 $1e4$,最坏情况下是当 BST 成链时,会有较大的空间浪费。
因此,一种较为紧凑的序列化/反序列化的方式是利用「前序遍历 + BST 特性」:
* 序列化:对 BST 进行「前序遍历」,并跳过空节点,节点值通过 `,` 进行分割,假设最终序列化出来的字符串是 `s`。
之所以使用「前序遍历」是为了方便反序列化:首先对于某个子树而言,其必然是连续存储,也就是必然能够使用 $s[l,r]$ 所表示处理,同时首位元素必然是该子树的头结点;
* 反序列化:将 `s` 根据分隔符 `,` 进行分割,假设分割后数组 `ss` 长度为 $n$,那么 $ss[0, n - 1]$ 代表完整的子树,我们可以利用「二叉树」特性递归构建,设计递归函数 `TreeNode dfs2(int l, int r, Sring[] ss)`,其含义为利用 $ss[l, r]$ 连续段构造二叉树,并返回头结点:
1. $ss[l]$ 为头结点,其值为 $t$,在 $[l, r]$ 范围内找到第一个比 $t$ 大的位置 $j$:
2. $ss[l]$ 的左子树的所有值均比 $t$ 小,且在 `s` 中连续存储,我们可以递归处理 $[l + 1, j - 1]$ 构建左子树;
3. $ss[l]$ 的右子树的所有值均比 $t$ 大,且在 `s` 中连续存储,我们可以递归处理 $[j, r]$ 构建右子树。
代码:
```Java
public class Codec {
public String serialize(TreeNode root) {
if (root == null) return null;
List<String> list = new ArrayList<>();
dfs1(root, list);
int n = list.size();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) {
sb.append(list.get(i));
if (i != n - 1) sb.append(",");
}
return sb.toString();
}
void dfs1(TreeNode root, List<String> list) {
if (root == null) return ;
list.add(String.valueOf(root.val));
dfs1(root.left, list);
dfs1(root.right, list);
}
public TreeNode deserialize(String s) {
if (s == null) return null;
String[] ss = s.split(",");
return dfs2(0, ss.length - 1, ss);
}
TreeNode dfs2(int l, int r, String[] ss) {
if (l > r) return null;
int j = l + 1, t = Integer.parseInt(ss[l]);
TreeNode ans = new TreeNode(t);
while (j <= r && Integer.parseInt(ss[j]) <= t) j++;
ans.left = dfs2(l + 1, j - 1, ss);
ans.right = dfs2(j, r, ss);
return ans;
}
}
```
* 时间复杂度:令节点数量为 $n$,序列化的复杂度为 $O(n)$;反序列时由于存在「找第一个比头结点值大的位置」操作,每个节点可能被扫描多次,扫描次数与当前节点所在的深度相关,最坏情况下为一条往左下方的链,复杂度为 $O(n^2)$
* 空间复杂度:$O(n)$
---
### 二分优化
在解法一中的「反序列操作」操作的瓶颈在于需要「找第一个比头结点值大的位置」。
假设连续段 $s[l, r]$ 代表某棵子树的话,由于我们是采用「前序遍历」的方式生成 `s`,因此头结点必然是 $s[l]$,而对于头结点的左右子树,必然是连续两段(先左再右)的形式存储在 $[l + 1, r]$ 中,同时由于该子树是 BST,因此这连续两段必然满足「前一段(左子树)小于 $t$」和「后一段(右子树)大于 $t$」。
即具有「二段性」,因此「找第一个比头结点值大的位置」可用「二分」实现。
代码:
```Java
public class Codec {
public String serialize(TreeNode root) {
if (root == null) return null;
List<String> list = new ArrayList<>();
dfs1(root, list);
int n = list.size();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) {
sb.append(list.get(i));
if (i != n - 1) sb.append(",");
}
return sb.toString();
}
void dfs1(TreeNode root, List<String> list) {
if (root == null) return ;
list.add(String.valueOf(root.val));
dfs1(root.left, list);
dfs1(root.right, list);
}
public TreeNode deserialize(String s) {
if (s == null) return null;
String[] ss = s.split(",");
return dfs2(0, ss.length - 1, ss);
}
TreeNode dfs2(int l, int r, String[] ss) {
if (l > r) return null;
int ll = l + 1, rr = r, t = Integer.parseInt(ss[l]);
while (ll < rr) {
int mid = ll + rr >> 1;
if (Integer.parseInt(ss[mid]) > t) rr = mid;
else ll = mid + 1;
}
if (Integer.parseInt(ss[rr]) <= t) rr++;
TreeNode ans = new TreeNode(t);
ans.left = dfs2(l + 1, rr - 1, ss);
ans.right = dfs2(rr, r, ss);
return ans;
}
}
```
* 时间复杂度:令节点数量为 $n$,序列化的复杂度为 $O(n)$;反序列时由于存在「找第一个比头结点值大的位置」操作,最坏情况下为一条往左下方的链,该操作采用「二分」,复杂度为 $O(\log{n})$,整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.449` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/441-450/450. 删除二叉搜索树中的节点（中等）.md | 450. 删除二叉搜索树中的节点 | https://leetcode.cn/problems/delete-node-in-a-bst/solution/by-ac_oier-s60a/ | 中等 | [
"递归",
"BST",
"二叉树"
] | 给定一个二叉搜索树的根节点 `root` 和一个值 `key`,删除二叉搜索树中的 `key` 对应的节点,并保证二叉搜索树的性质不变。返回二叉搜索树(有可能被更新)的根节点的引用。
一般来说,删除节点可分为两个步骤:
* 首先找到需要删除的节点;
* 如果找到了,删除它。
示例 1:
```
输入:root = [5,3,6,2,4,null,7], key = 3
输出:[5,4,6,2,null,null,7]
解释:给定需要删除的节点值是 3,所以我们首先找到 3 这个节点,然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
```
```
另一个正确答案是 [5,2,6,null,4,null,7]。
```
示例 2:
```
输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点
```
示例 3:
```
输入: root = [], key = 0
输出: []
```
提示:
* 节点数的范围 $[0, 10^4]$
* $-10^5 <= Node.val <= 10^5$
* 节点值唯一
* root 是合法的二叉搜索树
* $-10^5 <= key <= 10^5$
进阶: 要求算法时间复杂度为 $O(h)$,$h$ 为树的高度。 | ### 递归
利用题目本身的函数签名的含义,也就是「**在以 `root` 为根的子树中,删除值为 `key` 的节点,并返回删除节点后的树的根节点**」,我们可以用「递归」来做。
起始先对边界情况进行处理,当 `root` 为空(可能起始传入的 `root` 为空,也可能是递归过程中没有找到值为 `key` 的节点时,导致的 `root` 为空),我们无须进行任何删除,直接返回 `null` 即可。
根据当前 `root.val` 与 `key` 的大小关系,进行分情况讨论:
1. 若有 $root.val < key$,说明待删除的节点必然不是当前节点,以及不在当前节点的左子树中,我们将删除动作「递归」到当前节点的右子树,并将删除(可能进行)之后的新的右子树根节点,重新赋值给 `root.right`,即有 `root.right = deleteNode(root.right, key)`;
2. 若有 $root.val > key$,说明待删除的节点必然不是当前节点,以及不在当前节点的右子树,我们将删除节点「递归」到当前节点的左子树,并将删除(可能进行)之后的新的左子树根节点,重新赋值给 `root.left`,即有 `root.left = deleteNode(root.left, key)`;
3. 若有 $root.val = key$,此时找到了待删除的节点,我们根据左右子树的情况,进行进一步分情况讨论:
* 若左/右子树为空,我们直接返回右/左子树节点即可(含义为直接将右/左子树节点搬到当前节点的位置)如图所示:
* 若左右子树均不为空,我们有两种选择:
* 从「当前节点的左子树」中选择「值最大」的节点替代 `root` 的位置,确保替代后仍满足 `BST` 特性;
* 从「当前节点的右子树」中选择「值最小」的节点替代 `root` 的位置,确保替代后仍满足 `BST` 特性;
我们以「从当前节点的左子树中选择值最大的节点」为例子,我们通过树的遍历,找到其位于「最右边」的节点,记为 $t$($t$ 作为最右节点,必然有 `t.right = null`),利用原本的 `root` 也是合法 `BST`,原本的 `root.right` 子树的所有及节点,必然满足大于 `t.val`,我们可以直接将 `root.right` 接在 `t.right` 上,并返回我们重接后的根节点,也就是 `root.left`。
而「从当前节点的右子树中选择值最小的节点」,同理(代码见 $P2$)。
代码:
```Java
class Solution {
public TreeNode deleteNode(TreeNode root, int key) {
if (root == null) return null;
if (root.val == key) {
if (root.left == null) return root.right;
if (root.right == null) return root.left;
TreeNode t = root.left;
while (t.right != null) t = t.right;
t.right = root.right;
return root.left;
} else if (root.val < key) root.right = deleteNode(root.right, key);
else root.left = deleteNode(root.left, key);
return root;
}
}
```
-
```Java
class Solution {
public TreeNode deleteNode(TreeNode root, int key) {
if (root == null) return null;
if (root.val == key) {
if (root.left == null) return root.right;
if (root.right == null) return root.left;
TreeNode t = root.right;
while (t.left != null) t = t.left;
t.left = root.left;
return root.right;
} else if (root.val < key) root.right = deleteNode(root.right, key);
else root.left = deleteNode(root.left, key);
return root;
}
}
```
* 时间复杂度:$O(h)$,其中 $h$ 为树的深度
* 空间复杂度:忽略递归带来的额外空间消耗,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.450` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/451. 根据字符出现频率排序（中等）.md | 451. 根据字符出现频率排序 | https://leetcode-cn.com/problems/sort-characters-by-frequency/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-gst9/ | 中等 | [
"模拟",
"桶排序",
"哈希表",
"数组",
"优先队列(堆)"
] | 给定一个字符串,请将字符串里的字符按照出现的频率降序排列。
示例 1:
```
输入:
"tree"
输出:
"eert"
解释:
'e'出现两次,'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外,"eetr"也是一个有效的答案。
```
示例 2:
```
输入:
"cccaaa"
输出:
"cccaaa"
解释:
'c'和'a'都出现三次。此外,"aaaccc"也是有效的答案。
注意"cacaca"是不正确的,因为相同的字母必须放在一起。
```
示例 3:
```
输入:
"Aabb"
输出:
"bbAa"
解释:
此外,"bbaA"也是一个有效的答案,但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。
```
提示:
* $1 <= s.length <= 5 \times 10^5$
* `s` 由大小写英文字母和数字组成 | ### 数据结构 + 模拟
这是一道考察数据结构运用的模拟题。
具体做法如下:
1. 先使用「哈希表」对词频进行统计;
2. 遍历统计好词频的哈希表,将每个键值对以 `{字符,词频}` 的形式存储到「优先队列(堆)」中。并规定「优先队列(堆)」排序逻辑为:
* 如果 `词频` 不同,则按照 `词频` 倒序;
* 如果 `词频` 相同,则根据 `字符字典序` 升序(由于本题采用 Special Judge 机制,这个排序策略随意调整也可以。但通常为了确保排序逻辑满足「全序关系」,这个地方可以写正写反,但理论上不能不写,否则不能确保每次排序结果相同);
3. 从「优先队列(堆)」依次弹出,构造答案。
代码:
```Java
class Solution {
public String frequencySort(String s) {
char[] cs = s.toCharArray();
Map<Character, Integer> map = new HashMap<>();
for (char c : cs) map.put(c, map.getOrDefault(c, 0) + 1);
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{
return a[1] != b[1] ? b[1] - a[1] : a[0] - b[0];
});
for (char c : map.keySet()) q.add(new int[]{c, map.get(c)});
StringBuilder sb = new StringBuilder();
while (!q.isEmpty()) {
int[] poll = q.poll();
int c = poll[0], k = poll[1];
while (k-- > 0) sb.append((char)(c));
}
return sb.toString();
}
}
```
* 时间复杂度:令字符集的大小为 $C$。使用「哈希表」统计词频的复杂度为 $O(n)$;最坏情况下字符集中的所有字符都有出现,最多有 $C$ 个节点要添加到「优先队列(堆)」中,复杂度为 $O(C\log{C})$;构造答案需要从「优先队列(堆)」中取出元素并拼接,复杂度为 $O(n)$。整体复杂度为 $O(\max(n, C\log{C}))$
* 空间复杂度:$O(n)$
---
### 数组实现 + 模拟
基本思路不变,将上述过程所用到的数据结构使用数组替代。
具体的,利用 ASCII 字符集共 $128$ 位,预先建立一个大小为 $128$ 的数组,利用「桶排序」的思路替代「哈希表」和「优先队列(堆)」的作用。
代码:
```Java
class Solution {
public String frequencySort(String s) {
int[][] cnts = new int[128][2];
char[] cs = s.toCharArray();
for (int i = 0; i < 128; i++) cnts[i][0] = i;
for (char c : cs) cnts[c][1]++;
Arrays.sort(cnts, (a, b)->{
return a[1] != b[1] ? b[1] - a[1] : a[0] - b[0];
});
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 128; i++) {
char c = (char)cnts[i][0];
int k = cnts[i][1];
while (k-- > 0) sb.append(c);
}
return sb.toString();
}
}
```
* 时间复杂度:令字符集的大小为 $C$,复杂度为 $O(\max(n, C\log{C}))$
* 空间复杂度:$O(n + C + \log{C})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.451` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/453. 最小操作次数使数组元素相等（简单）.md | 453. 最小操作次数使数组元素相等 | https://leetcode-cn.com/problems/minimum-moves-to-equal-array-elements/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-tt3zu/ | 简单 | [
"数学"
] | 给你一个长度为 `n` 的整数数组,每次操作将会使 `n - 1` 个元素增加 `1` 。
返回让数组所有元素相等的最小操作次数。
示例 1:
```
输入:nums = [1,2,3]
输出:3
解释:
只需要3次操作(注意每次操作会增加两个元素的值):
[1,2,3] => [2,3,3] => [3,4,3] => [4,4,4]
```
示例 2:
```
输入:nums = [1,1,1]
输出:0
```
提示:
* n == nums.length
* $1 <= nums.length <= 10^5$
* $-10^9 <= nums[i] <= 10^9$
* 答案保证符合 32-bit 整数 | ### 数学
为了方便,令原数组 $num$ 的总和为 $sum$,最小值为 $min$,最大值为 $max$,长度为 $n$,真实最小操作次数为 $ans$。
由于每次只能将 $n - 1$ 个元素整体加一,因此在最终的相等状态,整体元素的大小值 $t$ 满足关系 $t \geqslant max$。
我们考虑是否必然可以取到关系式中的等号?
答案是不一定,当且仅当 $num$ 本身有 $n - 1$ 个元素与 $max$ 差值相等,才能取得关系式中的等号。
同时我们知道,$ans$ 与 $t$ 存在一一对应关系:
$$
ans = \frac{t * n - sum}{n - 1}
$$
要取得最小的 $ans$,其实等价于取得最小的 $t$,但仅靠 $t \geqslant max$ 关系,我们无法直接求得 $ans$。
事实上,我们可以通过值变化来进行分析,凭直觉我们会觉得:**在配平整个数组的过程中,当前数组中的最小值会参与到自增过程中。**
我们通过「反证法」来证明该猜想的正确性。
假设在配平数组的过程,某次自增操作中,「当前最小值」没有参与到自增当中,那么此时自增的对象是除「当前最小值」以外的其余元素,这时候「当前最小值」与其他元素的差值将会增加 $1$,此时如果将操作换成「包含当前最小值自增」的话,我们是可以将最终值 $t$ 减一的,如果最终值 $t$ 变小的话,那么 $ans$ 也会变小,结果会更好。
**因此,如果我们某次自增操作中没有包含「当前最小值」对应的元素的话,我们可以通过调整 $t$ 的大小(减一),来将操作调整为「包含当前最小值进行自增」,同时结果会变好。**
到这里就结束了吗?
还没有,因为到这里我们还不能直接与原始最小值 $min$ 结合起来。
我们还需要证明 **原始的相对最小值 $min$ 在匹配过程中,可以一直保持自身是当前数组中的「相对最小值」**。
这可以通过「归纳法」来证明:
**如果在每次自增操作中,都包含「当前最小值」,那么意味着原始最小值与其他元素的「相对大小」关系不会发生改变(因为原始最小值会一直作为「相对最小值」参与到每一次自增当中)得证成立。**
至此,我们可以得到 $t$ 和 $min$ 的关系式:
$$
t = min + ans
$$
代入之前我们得到的关系式可得:
$$
ans = \frac{(min + ans) * n - sum}{n - 1}
$$
变形整理后可得:
$$
ans = sum - min * n
$$
代码:
```Java
class Solution {
public int minMoves(int[] nums) {
int n = nums.length;
long min = nums[0], sum = 0;
for (int i : nums) {
min = Math.min(min, i);
sum += i;
}
return (int)(sum - min * n);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.453` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/456. 132 模式（中等）.md | 456. 132 模式 | https://leetcode-cn.com/problems/132-pattern/solution/xiang-xin-ke-xue-xi-lie-xiang-jie-wei-he-95gt/ | 中等 | [
"单调栈"
] | 给你一个整数数组 `nums`,数组中共有 `n` 个整数。`132` 模式的子序列 由三个整数 `nums[i]`、`nums[j]` 和 `nums[k]` 组成,并同时满足:$i < j < k$ 和 $nums[i] < nums[k] < nums[j]$ 。
如果 `nums` 中存在 `132` 模式的子序列 ,返回 `true`;否则,返回 `false`。
进阶:很容易想到时间复杂度为 $O(n^2)$ 的解决方案,你可以设计一个时间复杂度为 $O(n \log{n})$ 或$ O(n)$ 的解决方案吗?
示例 1:
```
输入:nums = [1,2,3,4]
输出:false
解释:序列中不存在 132 模式的子序列。
```
示例 2:
```
输入:nums = [3,1,4,2]
输出:true
解释:序列中有 1 个 132 模式的子序列: [1, 4, 2] 。
```
示例 3:
```
输入:nums = [-1,3,2,0]
输出:true
解释:序列中有 3 个 132 模式的的子序列:[-1, 3, 2]、[-1, 3, 0] 和 [-1, 2, 0] 。
```
提示:
* $n = nums.length$
* $1 <= n <= 10^4$
* $-10^9 <= nums[i] <= 10^9$ | ### 基本思路
朴素的做法是分别对三个数进行枚举,这样的做法是 $O(n^3)$ 的,数据范围是 $10^4$,稳稳超时。
事实上,这样的数据范围甚至不足以我们枚举其中两个数,然后优化找第三个数的 $O(n^2)$ 做法。
**这时候根据数据范围会联想到树状数组,使用树状数组的复杂度是 $O(n\log{n})$ 的,可以过。但是代码量会较多一点,还需要理解离散化等前置知识**。题解也不太好写。
因此,我们可以从 132 的大小特性去分析,如果在确定一个数之后,如何快速找到另外两个数(我们使用 `ijk` 来代指 132 结构):
1. 枚举 `i`:由于 `i` 是 132 结构中最小的数,那么相当于我们要从 i 后面,找到一个对数 `(j,k)`,使得 `(j,k)` 都满足比 `i` 大,同时 `j` 和 `k` 之间存在 `j > k` 的关系。由于我们的遍历是单向的,因此我们可以将问题转化为找 `k`,首先 `k` 需要比 `i` 大,同时在 `[i, k]` 之间存在比 `k` 大的数即可。
2. 枚举 `j`:由于 `j` 是 132 结构里最大的数,因此我们需要在 `j` 的右边中比 `j` 小的「最大」的数,在 `j` 的左边找比 `j` 小的「最小」的数。这很容易联想到单调栈,但是朴素的单调栈是帮助我们找到左边或者右边「最近」的数,无法直接满足我们「最大」和「最小」的要求,需要引入额外逻辑。
3. 枚举 `k`:由于 `k` 是 132 结构中的中间值,这里的分析逻辑和「枚举 i」类似,因为遍历是单向的,我们需要找到 `k` 左边的 `i`,同时确保 `[i,k]` 之间存在比 `i` 和 `k` 大的数字。
以上三种分析方法都是可行的,但「枚举 i」的做法是最简单的。
**因为如果存在 `(j,k)` 满足要求的话,我们只需要找到一个最大的满足条件的 `k`,通过与 `i` 的比较即可。**
也许你还不理解是什么意思。没关系,我们一边证明一边说。
---
### 过程 & 证明
先说处理过程吧,我们从后往前做,维护一个「单调递减」的栈,同时使用 `k` 记录所有出栈元素的最大值(`k` 代表满足 132 结构中的 2)。
那么当我们遍历到 `i`,只要满足发现满足 `nums[i] < k`,说明我们找到了符合条件的 `i j k`。
举个🌰,对于样例数据 `[3, 1, 4, 2]`,我们知道满足 132 结构的子序列是 `[1, 4, 2]`,其处理逻辑是(遍历从后往前):
1. 枚举到 2:栈内元素为 [2],`k` = INF
2. 枚举到 4:不满足「单调递减」,2 出栈更新 `k`,4 入栈。栈内元素为 [4],`k` = 2
3. 枚举到 1:满足 `nums[i] < k`,说明对于 `i` 而言,后面有一个比其大的元素(满足 `i < k` 的条件),同时这个 `k` 的来源又是因为维护「单调递减」而弹出导致被更新的(满足 `i` 和 `k` 之间,有比 `k` 要大的元素)。因此我们找到了满足 132 结构的组合。
**这样做的本质是:我们通过维护「单调递减」来确保已经找到了有效的 `(j,k)`。换句话说如果 `k` 有值的话,那么必然是因为有 `j > k`,导致的有值。也就是 132 结构中,我们找到了 32,剩下的 `i` (也就是 132 结构中的 1)则是通过遍历过程中与 `k` 的比较来找到。这样做的复杂度是 $O(n)$ 的,比树状数组还要快。**
从过程上分析,是没有问题的。
搞清楚了处理过程,证明也变得十分简单。
我们不失一般性的考虑任意数组 `nums`,假如真实存在 `ijk` 符合 132 的结构(这里的 `ijk` 特指所有满足 132 结构要求的组合中 `k` 最大的那个组合)。
由于我们的比较逻辑只针对 `i` 和 `k`,而 `i` 是从后往前的处理的,必然会被遍历到;漏掉 `ijk` 的情况只能是:在遍历到 `i` 的时候,我们没有将 `k` 更新到变量中:
1. 这时候变量的值要比真实情况下的 `k` 要小,说明 `k` 还在栈中,而遍历位置已经到达了 `i`,说明 `j` 和 `k` 同时在栈中,与「单调递减」的性质冲突。
2. 这时候变量的值要比真实情况下的 `k` 要大,说明在 `k` 出栈之后,有比 `k` 更大的数值出栈了(同时必然有比变量更大的值在栈中),这时候要么与我们假设 `ijk` 是 `k` 最大的组合冲突;要么与我们遍历到的位置为 `i` 冲突。
**综上,由于「单调递减」的性质,我们至少能找到「遍历过程中」所有符合条件的 `ijk` 中 `k` 最大的那个组合。**
Java 代码:
```Java
class Solution {
public boolean find132pattern(int[] nums) {
int n = nums.length;
Deque<Integer> d = new ArrayDeque<>();
int k = Integer.MIN_VALUE;
for (int i = n - 1; i >= 0; i--) {
if (nums[i] < k) return true;
while (!d.isEmpty() && d.peekLast() < nums[i]) {
// 事实上,k 的变化也具有单调性,直接使用 k = pollLast() 也是可以的
k = Math.max(k, d.pollLast());
}
d.addLast(nums[i]);
}
return false;
}
}
```
Python3 代码:
```Python3
class Solution:
def find132pattern(self, nums: List[int]) -> bool:
stack = []
k = -(10 ** 9 + 7)
for i in range(len(nums) - 1,-1,-1):
if nums[i] < k:
return True
while stack and stack[-1] < nums[i]:
k = max(k,stack.pop())
stack.append(nums[i])
return False
```
C++ 代码:
```C++
class Solution {
public:
bool find132pattern(vector<int>& nums) {
stack<int> st;
int n = nums.size(), k = INT_MIN;
for(int i = n - 1; i >= 0; i--){
if(nums[i] < k) return true;
while(!st.empty() and st.top() < nums[i]) {
k = max(k,st.top()); st.pop();
}
st.push(nums[i]);
}
return false;
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.456` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/457. 环形数组是否存在循环（中等）.md | 457. 环形数组是否存在循环 | https://leetcode-cn.com/problems/circular-array-loop/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-ag05/ | 中等 | [
"图",
"模拟"
] | 存在一个不含 $0$ 的 环形 数组 $nums$ ,每个 $nums[i]$ 都表示位于下标 $i$ 的角色应该向前或向后移动的下标个数:
* 如果 $nums[i]$ 是正数,向前 移动 $nums[i]$ 步
* 如果 $nums[i]$ 是负数,向后 移动 $nums[i]$ 步
因为数组是**环形**的,所以可以假设从最后一个元素向前移动一步会到达第一个元素,而第一个元素向后移动一步会到达最后一个元素。
数组中的 循环 由长度为 $k$ 的下标序列 $seq$ :
* 遵循上述移动规则将导致重复下标序列 `seq[0] -> seq[1] -> ... -> seq[k - 1] -> seq[0] -> ...`
* 所有 $nums[seq[j]]$ 应当不是 全正 就是 全负
* $k > 1$
如果 $nums$ 中存在循环,返回 $true$ ;否则,返回 $false$。
示例 1:
```
输入:nums = [2,-1,1,2,2]
输出:true
解释:存在循环,按下标 0 -> 2 -> 3 -> 0 。循环长度为 3 。
```
示例 2:
```
输入:nums = [-1,2]
输出:false
解释:按下标 1 -> 1 -> 1 ... 的运动无法构成循环,因为循环的长度为 1 。根据定义,循环的长度必须大于 1 。
```
示例 3:
```
输入:nums = [-2,1,-1,-2,-2]
输出:false
解释:按下标 1 -> 2 -> 1 -> ... 的运动无法构成循环,因为 nums[1] 是正数,而 nums[2] 是负数。
所有 nums[seq[j]] 应当不是全正就是全负。
```
提示:
* 1 <= nums.length <= 5000
* -1000 <= nums[i] <= 1000
* nums[i] != 0
进阶:你能设计一个时间复杂度为 O(n) 且额外空间复杂度为 O(1) 的算法吗? | ### 模拟
根据题意,我们可以从每个下标 $i$ 进行出发检查,如果以某个下标 $i$ 为出发点发现了「循环」,返回 `True`,否则返回 `False`。
唯一需要注意的细节是,当我们处理到的下标为 $cur$,计算下一个跳转点 $next = cur + nums[cur]$ 时,对于越过数组的情况进行处理:
1. 如果 $next$ 为负数:在 $next$ 的基础上增加 $n * \left \lceil next / n \right \rceil$,将其映射回正值;
2. 如果 $next$ 为正数:将 $next$ 模数组长度 $n$,确保不会越界。
整理一下,我们可以统一写成 `next = ((cur + nums[cur]) % n + n ) % n`。
在 `check` 内部,当以下任一条件出现,则可以结束检查(令 $k$ 为记录过程中扫描过的下标数量):
1. 如果在检查过程中,找到了与起点相同的下标,且 $k > 1$,说明存在符合条件的「循环」,返回 `True`;
2. 如果检查过程中扫描的数量 $k$ 超过了数组长度 $n$,那么根据「[鸽笼原理](https://baike.baidu.com/item/%E6%8A%BD%E5%B1%89%E5%8E%9F%E7%90%86/233776)」,必然有数被重复处理了,同时条件一并不符合,因此再处理下去,也不会到达与起点相同的下标,返回 `False`;
3. 处理过程中发现不全是正数或者负数,返回 `False`。
代码:
```Java
class Solution {
int n;
int[] nums;
public boolean circularArrayLoop(int[] _nums) {
nums = _nums;
n = nums.length;
for (int i = 0; i < n; i++) {
if (check(i)) return true;
}
return false;
}
boolean check(int start) {
int cur = start;
boolean flag = nums[start] > 0;
int k = 1;
while (true) {
if (k > n) return false;
int next = ((cur + nums[cur]) % n + n ) % n;
if (flag && nums[next] < 0) return false;
if (!flag && nums[next] > 0) return false;
if (next == start) return k > 1;
cur = next;
k++;
}
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(1)$
---
### 图的遍历标记(使用新数组标记)
**这是一种补充做法,更多的作为「解法一」和「解法三」之间的过渡,建议在充分理解本解法之后,再学习解法三。**
从「解法一」我们发现,我们会对很多重复的路径进行重复检查。
假如从位置 $a$ 到位置 $d$ 存在一条无环通路 $a-b-c-d$,根据「解法一」我们会在对 $a$ 进行通路是否有环的检查之后,再对 $b$ 、$c$ 和 $d$ 进行路径是否有环的检查。
事实上,由于每个点只有一个出度(某个位置能跳到的下一个位置是唯一确定的),因此我们可以使用 `vis` 数组记录那些下标被检查过了,从而避免相同的路径被重复检查。
**同时,我们可以扩充 `vis` 数组的功能,使其不仅仅能用于判断某个位置是否被检查过,还能记录下某个位置是在哪一轮被检查过。具体的,我们令 $vis[i] = idx$ 代表位置 $i$ 在第 $idx$ 轮被标记。**
如此一来,当我们检查某个位置 $start$ 的通路时,如果遇到一个跳点 $next$,发现 $vis[next]$ 不为 $0$(代表被被记过),可通过将 $vis[next]$ 与当前轮次编号做对比,来得知该位置是否在本轮被标记。
代码:
```Java
class Solution {
public boolean circularArrayLoop(int[] nums) {
int n = nums.length;
// 使用 vis 数组对每个下标进行标记
// 如果下标为 i 的位置在第 idx 轮被标记,则有 vis[i] = idx
int[] vis = new int[n];
for (int start = 0, idx = 1; start < n; start++, idx++) {
if (vis[start] != 0) continue;
int cur = start;
boolean flag = nums[cur] > 0;
while (true) {
int next = ((cur + nums[cur]) % n + n) % n;
if (next == cur) break;
if (vis[next] != 0) {
// 如果 next 点已经被标记过,并且不是在本轮被标记,那么往后的通路必然都被标记,且无环,跳出
if (vis[next] != idx) break;
// 如果 next 点已被标记,并且是本来被标记,说明找到了环
else return true;
}
if (flag && nums[next] < 0) break;
if (!flag && nums[next] > 0) break;
vis[next] = idx;
cur = next;
}
}
return false;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 图的遍历标记(使用原数组标记)
**根据题意,我们将每个下标看做“点”,「当前点」和「当前点所能到达的下一个点」看作“边”。**
**从而将问题转换为经典的「图论寻环」问题,同时又因为每个点出度固定为 $1$,并且规定「循环」必然是「同向」才合法,因此如果我们在遍历过程中发现存在反向,就停止检查。**
另外,为实现 $O(1)$ 的空间,我们需要在原数组上进行标记,我们设立一个足够大的数 `OFFSET`,对于由下标 $i$ 发起的寻环操作,我们将扫描的数标记为 `OFFSET + i`。如果在扫描完由 $i$ 发起的寻环后,没法发现自环,说明找到了「循环」,输出 `True`。
代码:
```Java
class Solution {
int OFFSET = 100010;
public boolean circularArrayLoop(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
if (nums[i] >= OFFSET) continue;
int cur = i, tag = OFFSET + i, last = -1;
boolean flag = nums[cur] > 0;
while (true) {
int next = ((cur + nums[cur]) % n + n ) % n;
last = nums[cur];
nums[cur] = tag;
cur = next;
if (cur == i) break;
if (nums[cur] >= OFFSET) break;
if (flag && nums[cur] < 0) break;
if (!flag && nums[cur] > 0) break;
}
if (last % n != 0 && nums[cur] == tag) return true;
}
return false;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.457` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/458. 可怜的小猪（困难）.md | 458. 可怜的小猪 | https://leetcode-cn.com/problems/poor-pigs/solution/gong-shui-san-xie-jin-zhi-cai-xiang-xian-69fl/ | 困难 | [
"数学"
] | 有 `buckets` 桶液体,其中 正好 有一桶含有毒药,其余装的都是水。它们从外观看起来都一样。
为了弄清楚哪只水桶含有毒药,你可以喂一些猪喝,通过观察猪是否会死进行判断。不幸的是,你只有 `minutesToTest` 分钟时间来确定哪桶液体是有毒的。
喂猪的规则如下:
1. 选择若干活猪进行喂养
2. 可以允许小猪同时饮用任意数量的桶中的水,并且该过程不需要时间。
3. 小猪喝完水后,必须有 `minutesToDie` 分钟的冷却时间。在这段时间里,你只能观察,而不允许继续喂猪。
4. 过了 `minutesToDie` 分钟后,所有喝到毒药的猪都会死去,其他所有猪都会活下来。
5. 重复这一过程,直到时间用完。
给你桶的数目 `buckets` ,`minutesToDie` 和 `minutesToTest` ,返回在规定时间内判断哪个桶有毒所需的 最小 猪数。
示例 1:
```
输入:buckets = 1000, minutesToDie = 15, minutesToTest = 60
输出:5
```
示例 2:
```
输入:buckets = 4, minutesToDie = 15, minutesToTest = 15
输出:2
```
示例 3:
```
输入:buckets = 4, minutesToDie = 15, minutesToTest = 30
输出:2
```
提示:
* $1 <= buckets <= 1000$
* $1 <= minutesToDie <= minutesToTest <= 100$ | ### 数学
我们用实验对象来代指题干的小动物。同时为了方便,我们使用 $n$ 代指有多少桶水,$d$ 为实验对象的反应时间,$t$ 为测试总时间。
根据题意,最大测试次数为 $k = \left \lfloor \frac{t}{d} \right \rfloor$。
我们可以先考虑 $k = 1$ 的情况,最简单的情况是,我们使用与水同等数量的实验对象数量来进行测试。
此时哪个实验对象有反应,则可以推断出哪一桶水有问题。
但这样的测试方式,每个实验动物承载的信息量是很低的,每个实验对象仅承载了某一桶水是否有问题。
**为减少实验对象数量,我们需要增大每个实验对象承载的信息量(让每个实验对象同时测试多桶水),然后从最终所有实验对象的状态(是否有所反应)来反推哪一桶水有问题。**
用最小单位表示最大信息量,这引导我们使用「进制表示」相关方式。由于我们只有 $1$ 次测试机会,因此我们可以使用二进制的方式进行测试。
当 $k = 1$,使用二进制的方式测试哪桶水有问题,我们至少需要 $m$ 个实验对象(其中 $m$ 为 $n$ 的二进制表示的长度),然后让编号为 $x$($0 <= x < m$)的实验对象喝掉二进制表示中第 $x$ 位为 $1$ 的水。
最终这 $m$ 个实验对象会对应一个结果序列:如果编号 $x_1$ 的实验对象没有反应,说明有问题的水的二进制表示中第 $x_1$ 位为 $0$,如果编号为 $x_2$ 的实验对象有反应,则说明有问题的水的二进制表示中第 $x_2$ 为 $1$。即根据最终每个实验对象的状态,我们可以完整地反推回有问题的水的编号是多少。
当 $k > 1$ 时,相当于在原问题基础上,多考虑一层「轮数」维度,即不仅考虑某个实验对象是否有所反应,还需要考虑是在哪一轮有所反应。
我们还是使用「进制表示」的方式来最大化每个单位所能承载的最大信息量。
具体的,我们先使用 $k + 1$ 进制对所有水进行编号,此时每桶水都有唯一的进制表示编码。然后我们考虑「什么时候」将水喂给「哪个实验对象」。
其中一种可行的测试方式是:设定需要的实验对象数量 $m$ 为 $k + 1$ 进制数的长度,若某桶水的 $k + 1$ 进制中的第 $x$ 位为 $i$($0 <= i <= k$),则代表将该水在第 $i$ 轮喂给编号为 $x$ 的实验对象。
同理,利用最终的结果矩阵,我们可以反推回是哪一桶水是有问题的。
**上述做法,只是阐述了我们存在这样的可行解,需要证明这样的做法是最优解。**
利用 [香农熵](https://baike.baidu.com/item/香农熵),我们可以计算明确熵值,公式为:
$$
H(X) = - \sum_{x}^{} P(x) \log_2[P(x)]
$$
其中 $P(x)$ 代表随机事件 $x$ 的发生概率。
对于本题,记随机事件 $A$ 为 $n$ 桶水中哪一个桶有问题,概率为 $\frac{1}{n}$。
记随机事件 $B$ 为在测试轮数为 $k$ 时,所有实验对象的最终状态,每个实验对象的状态共有 $k + 1$ 种,即共有 $C = (k + 1)^m$ 种最终结果,可近似看做等概率 $\frac{1}{C}$。
我们需要求得在满足 $H(A) <= H(B)$ 前提下的最小 $m$ 值。
代入公式可得:
$$
-(\log_2{\frac{1}{n}}) <= - \sum_{result = 0}^{(k + 1)^m} \frac{1}{(k + 1)^m} \log_2{\frac{1}{(k + 1)^m}} = m \log_2(k + 1)
$$
移项化简得:
$$
\frac{\log_2{n}}{\log_2{(k + 1)}} <= m
$$
代码:
```Java
class Solution {
public int poorPigs(int n, int d, int t) {
int k = t / d;
return (int) Math.ceil(Math.log(n) / Math.log(k + 1));
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.458` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/451-460/460. LFU 缓存（困难）.md | 460. LFU 缓存 | https://leetcode-cn.com/problems/lfu-cache/solution/gong-shui-san-xie-yun-yong-tong-pai-xu-s-53m3/ | 困难 | [
"链表",
"双向链表",
"设计"
] | 请你为 **最不经常使用(LFU)** 缓存算法设计并实现数据结构。
实现 `LFUCache` 类:
* `LFUCache(int capacity)` - 用数据结构的容量 `capacity` 初始化对象
* `int get(int key)` - 如果键存在于缓存中,则获取键的值,否则返回 -1。
* `void put(int key, int value)` - 如果键已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量时,则应该在插入新项之前,使最不经常使用的项无效。在此问题中,当存在平局(即两个或更多个键具有相同使用频率)时,应该去除 **最近最久未使用** 的键。
注意「项的使用次数」就是自插入该项以来对其调用 `get` 和 `put` 函数的次数之和。使用次数会在对应项被移除后置为 0 。
为了确定最不常使用的键,可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。
当一个键首次插入到缓存中时,它的使用计数器被设置为 1 (由于 `put` 操作)。对缓存中的键执行 `get` 或 `put` 操作,使用计数器的值将会递增。
示例:
```
输入:
["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]
输出:
[null, null, null, 1, null, -1, 3, null, -1, 3, 4]
解释:
// cnt(x) = 键 x 的使用计数
// cache=[] 将显示最后一次使用的顺序(最左边的元素是最近的)
LFUCache lFUCache = new LFUCache(2);
lFUCache.put(1, 1); // cache=[1,_], cnt(1)=1
lFUCache.put(2, 2); // cache=[2,1], cnt(2)=1, cnt(1)=1
lFUCache.get(1); // 返回 1
// cache=[1,2], cnt(2)=1, cnt(1)=2
lFUCache.put(3, 3); // 去除键 2 ,因为 cnt(2)=1 ,使用计数最小
// cache=[3,1], cnt(3)=1, cnt(1)=2
lFUCache.get(2); // 返回 -1(未找到)
lFUCache.get(3); // 返回 3
// cache=[3,1], cnt(3)=2, cnt(1)=2
lFUCache.put(4, 4); // 去除键 1 ,1 和 3 的 cnt 相同,但 1 最久未使用
// cache=[4,3], cnt(4)=1, cnt(3)=2
lFUCache.get(1); // 返回 -1(未找到)
lFUCache.get(3); // 返回 3
// cache=[3,4], cnt(4)=1, cnt(3)=3
lFUCache.get(4); // 返回 4
// cache=[3,4], cnt(4)=2, cnt(3)=3
```
提示:
* 0 <= capacity, key, value <= $10^4$
* 最多调用 $10^5$ 次 `get` 和 `put` 方法
进阶:你可以为这两种操作设计时间复杂度为 $O(1)$ 的实现吗? | ### 基本分析
前两天我们刚讲过 [146. LRU 缓存机制](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486820&idx=1&sn=2055864e10848bce55afc4e2feda79a7&chksm=fd9ca67bcaeb2f6d2038706e32cafffd701d3d6b71b60c52a568ed6dc0e268d93f8a78498105&token=672687058&lang=zh_CN#rd) ,简单理解 LRU 就是「移除最久不被使用的元素」。
因此对于 LRU 我们只需要在使用「哈希表」的同时,维护一个「双向链表」即可:
* 每次发生 `get` 或 `put` 的时候就将元素存放双向链表头部
* 当需要移除元素时,则从双向链表尾部开始移除
LFU 简单理解则是指「移除使用次数最少的元素」,如果存在多个使用次数最小的元素,则移除「最近不被使用的那个」(LRU 规则)。同样的 `get` 和 `put` 都算作一次使用。
因此,我们需要记录下每个元素的使用次数,并且在 $O(1)$ 的复杂度内「修改某个元素的使用次数」和「找到使用次数最小的元素」。
---
### 桶排序 + 双向链表
**我们可以使用「桶排序」的思路,搭配「双向链表」实现 $O(1)$ 操作。**
**在 `LFUCache` 中,我们维护一个由 `Bucket` 作为节点的双向链表,每个 `Bucket` 都有一个 `idx` 编号,代表当前桶存放的是「使用了多少次」的键值对**(`idx = 1` 的桶存放使用一次的键值对;`idx = 2` 的桶存放的是使用两次的键值对 ... )。
同时 `LFUCache` 持有一个「哈希表」,用来记录哪些 `key` 在哪个桶内。
**在 `Bucket` 内部则是维护了一条以 `Item` 作为节点的双向链表,`Item` 是用作存放真实键值对的。**
同样的,`Bucket` 也持有一个「哈希表」,用来记录 `key` 与 `Item` 的映射关系。
因此 `LFUCache` 其实是一个「链表套链表」的数据结构:
对应到 `LFUCache` 的几种操作:
* `get` :先通过 `LFUCache` 持有的哈希表进行查找,如果不存在返回 $-1$,如果存在找到键值对所在的桶 `cur`:
* 调用对应的 `cur` 的 `remove` 操作,得到键值对对应的 `item`(移除代表当前键值对使用次数加一了,不会在存在于原来的桶中)。
* 将 `item` 放到 `idx` 为 $cur.idx + 1$ 的桶 `target` 中(代表代表当前键值对使用次数加一,应该放到新的目标桶中)。
* 如果目标桶 `target` 不存在,则创建;如果原来桶 `cur` 移除键值对后为空,则销毁。
* 更新 `LFUCache` 中哈希表的信息。
* `put` : 先通过 `LFUCache` 持有的哈希表进行查找:
* 如果存在:找到键值对所在的桶 `cur`,调用 `cur` 的 `put` 操作,更新键值对,然后调用 `LFUCache` 的 `get` 操作实现使用次数加一。
* 如果不存在:先检查容量是否达到数量:
* 容量达到数量的话需要调用「编号最小的桶」的 `clear` 操作,在 `clear` 操作内部,会从 `item` 双向链表的尾部开始移除元素。完成后再执行插入操作。
* 插入操作:将键值对添加到 $idx = 1$ 的桶中(代表当前键值对使用次数为 $1$),如果桶不存在则创建。
代码:
```Java
class LFUCache {
class Item {
Item l, r;
int k, v;
public Item(int _k, int _v) {
k = _k;
v = _v;
}
}
class Bucket {
Bucket l, r;
int idx;
Item head, tail;
Map<Integer, Item> map = new HashMap<>();
public Bucket(int _idx) {
idx = _idx;
head = new Item(-1, -1);
tail = new Item(-1, -1);
head.r = tail;
tail.l = head;
}
void put(int key, int value) {
Item item = null;
if (map.containsKey(key)) {
item = map.get(key);
// 更新值
item.v = value;
// 在原来的双向链表位置中移除
item.l.r = item.r;
item.r.l = item.l;
} else {
item = new Item(key, value);
// 添加到哈希表中
map.put(key, item);
}
// 增加到双向链表头部
item.r = head.r;
item.l = head;
head.r.l = item;
head.r = item;
}
Item remove(int key) {
if (map.containsKey(key)) {
Item item = map.get(key);
// 从双向链表中移除
item.l.r = item.r;
item.r.l = item.l;
// 从哈希表中移除
map.remove(key);
return item;
}
return null; // never
}
Item clear() {
// 从双向链表尾部找到待删除的节点
Item item = tail.l;
item.l.r = item.r;
item.r.l = item.l;
// 从哈希表中移除
map.remove(item.k);
return item;
}
boolean isEmpty() {
return map.size() == 0;
}
}
Map<Integer, Bucket> map = new HashMap<>();
Bucket head, tail;
int n;
int cnt;
public LFUCache(int capacity) {
n = capacity;
cnt = 0;
head = new Bucket(-1);
tail = new Bucket(-1);
head.r = tail;
tail.l = head;
}
public int get(int key) {
if (map.containsKey(key)) {
Bucket cur = map.get(key);
Bucket target = null;
if (cur.r.idx != cur.idx + 1) {
// 目标桶空缺
target = new Bucket(cur.idx + 1);
target.r = cur.r;
target.l = cur;
cur.r.l = target;
cur.r = target;
} else {
target = cur.r;
}
// 将当前键值对从当前桶移除,并加入新的桶
Item remove = cur.remove(key);
target.put(remove.k, remove.v);
// 更新当前键值对所在桶信息
map.put(key, target);
// 如果在移除掉当前键值对后,当前桶为空,则将当前桶删除(确保空间是 O(n) 的)
// 也确保调用编号最小的桶的 clear 方法,能够有效移除掉一个元素
deleteIfEmpty(cur);
return remove.v;
}
return -1;
}
public void put(int key, int value) {
if (n == 0) return;
if (map.containsKey(key)) {
// 元素已存在,修改一下值
Bucket cur = map.get(key);
cur.put(key, value);
// 调用一下 get 实现「使用次数」+ 1
get(key);
} else {
// 容器已满,需要先删除元素
if (cnt == n) {
// 从第一个桶(编号最小、使用次数最小)中进行清除
Bucket cur = head.r;
Item clear = cur.clear();
map.remove(clear.k);
cnt--;
// 如果在移除掉键值对后,当前桶为空,则将当前桶删除(确保空间是 O(n) 的)
// 也确保调用编号最小的桶的 clear 方法,能够有效移除掉一个元素
deleteIfEmpty(cur);
}
// 需要将当前键值对增加到 1 号桶
Bucket first = null;
// 如果 1 号桶不存在则创建
if (head.r.idx != 1) {
first = new Bucket(1);
first.r = head.r;
first.l = head;
head.r.l = first;
head.r = first;
} else {
first = head.r;
}
// 将键值对添加到 1 号桶
first.put(key, value);
// 更新键值对所在桶信息
map.put(key, first);
// 计数器加一
cnt++;
}
}
void deleteIfEmpty(Bucket cur) {
if (cur.isEmpty()) {
cur.l.r = cur.r;
cur.r.l = cur.l;
cur = null; // help GC
}
}
}
```
* 时间复杂度:各操作均为 $O(1)$
* 时间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.460` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/461. 汉明距离（简单）.md | 461. 汉明距离 | https://leetcode-cn.com/problems/hamming-distance/solution/gong-shui-san-xie-tong-ji-liang-shu-er-j-987a/ | 简单 | [
"位运算"
] | 两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
给出两个整数 x 和 y,计算它们之间的汉明距离。
注意:
0 ≤ x, y < 231.
示例:
```
输入: x = 1, y = 4
输出: 2
解释:
1 (0 0 0 1)
4 (0 1 0 0)
↑ ↑
上面的箭头指出了对应二进制位不同的位置。
``` | ### 逐位比较
本身不改变 $x$ 和 $y$,每次取不同的偏移位进行比较,不同则加一。
循环固定取满 $32$ 。
代码:
```Java
class Solution {
public int hammingDistance(int x, int y) {
int ans = 0;
for (int i = 0; i < 32; i++) {
int a = (x >> i) & 1 , b = (y >> i) & 1;
ans += a != b ? 1 : 0;
}
return ans;
}
}
```
* 时间复杂度:$O(C)$,$C$ 固定为 $32$
* 空间复杂度:$O(1)$
---
### 右移统计
每次都统计当前 $x$ 和 $y$ 的最后一位,统计完则将 $x$ 和 $y$ 右移一位。
当 $x$ 和 $y$ 的最高一位 $1$ 都被统计过之后,循环结束。
代码:
```Java
class Solution {
public int hammingDistance(int x, int y) {
int ans = 0;
while ((x | y) != 0) {
int a = x & 1, b = y & 1;
ans += a ^ b;
x >>= 1; y >>= 1;
}
return ans;
}
}
```
* 时间复杂度:$O(C)$,$C$ 最多为 $32$
* 空间复杂度:$O(1)$
---
### lowbit
熟悉树状数组的同学都知道,`lowbit` 可以快速求得 $x$ 二进制表示中最低位 $1$ 表示的值。
因此我们可以先将 $x$ 和 $y$ 进行异或,再统计异或结果中 $1$ 的个数。
代码:
```Java
class Solution {
int lowbit(int x) {
return x & -x;
}
public int hammingDistance(int x, int y) {
int ans = 0;
for (int i = x ^ y; i > 0; i -= lowbit(i)) ans++;
return ans;
}
}
```
* 时间复杂度:$O(C)$,$C$ 最多为 $32$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.461` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/462. 最少移动次数使数组元素相等 II（中等）.md | 462. 最少移动次数使数组元素相等 II | https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii/solution/by-ac_oier-db44/ | 中等 | [
"数学"
] | 给你一个长度为 $n$ 的整数数组 $nums$,返回使所有数组元素相等需要的最少移动数。
在一步操作中,你可以使数组中的一个元素加 $1$ 或者减 $1$ 。
示例 1:
```
输入:nums = [1,2,3]
输出:2
解释:
只需要两步操作(每步操作指南使一个元素加 1 或减 1):
[1,2,3] => [2,2,3] => [2,2,2]
```
示例 2:
```
输入:nums = [1,10,2,9]
输出:16
```
提示:
* $n == nums.length$
* $1 <= nums.length <= 10^5$
* $-10^9 <= nums[i] <= 10^9$ | ### 数学
假定所有的 $nums[i]$ 均位于数轴上的 $nums[i]$ 的位置,题目要求我们在数轴上找出一个点 $t$,使得所有 $nums[i]$ 到 $t$ 的距离之和最小。
**首先,容易证明 $t$ 不可能位于最小的 $nums[i]$ 的左侧,也不可能位于最大的 $nums[i]$ 的右侧,否则我们「至少」能够将目标点调整为 最小的 $nums[i]$ 或 最大的 $nums[i]$ 来得到更小的距离总和。**
> 其实由上述这一点进行推广,已经可以证明最优点必然是在中间点($nums$ 数量为奇数时)或者中间两点形成的闭区间中的任意点($nums$ 数量为偶数时)。
但为了证明更加直观,我们仍从「反证法」的角度进行证明。
我们根据每个 $nums[i]$ 位于 $t$ 的左侧还是右侧进行划分:假设位于 $t$ 左侧的 $nums[i]$ 对答案的贡献为 $A$,位于 $t$ 右侧的 $nums[i]$ 对答案的贡献为 $B$,最终目的是为了让 $A + B$ 最小。
我们猜想当 $t$ 取中位数时,$A + B$ 取得最小值,并通过「反证法」进行证明:
* 假设真实最优解 $t'$ 位于中位数 $t$ 的 左侧:假设调整距离为 $d$,导致变化的点数为 $x$,则有左边总和为 $A - xd$,右边总和为 $B + (n - x)d$,总和为 $A + B - 2xd + nd$,如果要使得结果更好,需要满足 $nd - 2xd < 0$,即满足 $x > \frac{n}{2}$,这与我们本身 $t$ 为中位数,即左右两边数的个数均为 $\frac{n}{2}$ 冲突(特别地,当 $nums$ 为偶数时,且目标点位于中间两点中的任一点时,左右数的个数并非为 $\frac{n}{2}$,但距离总和情况与 $t$ 位于两点间的其余点的情况一致);
* 假设真实最优解 $t'$ 位于中位数 $t$ 的 右侧:同理。
代码:
```Java
class Solution {
public int minMoves2(int[] nums) {
Arrays.sort(nums);
int n = nums.length, t = nums[(n - 1) / 2], ans = 0;
for (int i : nums) ans += Math.abs(t - i);
return ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.462` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/464. 我能赢吗（中等）.md | 464. 我能赢吗 | https://leetcode.cn/problems/can-i-win/solution/by-ac_oier-0ed9/ | 中等 | [
"博弈论 DP",
"记忆化搜索",
"状态压缩"
] | 在 "100 game" 这个游戏中,两名玩家轮流选择从 $1$ 到 $10$ 的任意整数,累计整数和,先使得累计整数和 达到或超过 $100$ 的玩家,即为胜者。
如果我们将游戏规则改为 “玩家 不能 重复使用整数” 呢?
例如,两个玩家可以轮流从公共整数池中抽取从 $1$ 到 $15$ 的整数(不放回),直到累计整数和 >= $100$。
给定两个整数 `maxChoosableInteger` (整数池中可选择的最大数)和 `desiredTotal`(累计和),若先出手的玩家是否能稳赢则返回 `true` ,否则返回 `false` 。假设两位玩家游戏时都表现 最佳 。
示例 1:
```
输入:maxChoosableInteger = 10, desiredTotal = 11
输出:false
解释:
无论第一个玩家选择哪个整数,他都会失败。
第一个玩家可以选择从 1 到 10 的整数。
如果第一个玩家选择 1,那么第二个玩家只能选择从 2 到 10 的整数。
第二个玩家可以通过选择整数 10(那么累积和为 11 >= desiredTotal),从而取得胜利.
同样地,第一个玩家选择任意其他整数,第二个玩家都会赢。
```
示例 2:
```
输入:maxChoosableInteger = 10, desiredTotal = 0
输出:true
```
示例 3:
```
输入:maxChoosableInteger = 10, desiredTotal = 1
输出:true
```
提示:
* $1 <= maxChoosableInteger <= 20$
* $0 <= desiredTotal <= 300$ | ### 二维博弈论 DP(TLE)
这是一道博弈论 DP 的题,为了方便,我们使用 $n$ 来表示 $maxChoosableInteger$,使用 $t$ 来表示 $desiredTotal$。
由于 $n$ 数据范围为 $20$,且每个数只能选一次,我们可以使用一个二进制数 $state$ 来表示 $[1, n]$ 范围内的被选择的数的情况:二进制表示中 $1$ 的位置代表数已被选择,否则代表尚未选择。
首先朴素二维状态表示相对容易想到:**定义 $f[statue][k]$ 为当前已被选择的数为 $state$,轮数为 $k$ 时,「原始回合的先手」能否获胜($1$ 代表能,$-1$ 代表不能),其中 $k$ 从 $0$ 开始,通过 $k$ 的奇偶性可知是原始回合的先手还是后手。**
设计递归函数来实现「记忆化搜索」,函数 `int dfs(int state, int tot, int k)` 表示当前状态为 $state$,$tot$ 对应累计和,$k$ 代表轮数,最终答案通过判断 `dfs(0, 0, 0)` 是否为 $1$ 来得知。
**转移过程中,如果发现当前回合的决策,能够直接使得累积和超过 $t$,说明当前回合玩家获胜;或者如果当前决策能够导致下一回合的玩家失败的话,当前回合玩家也获胜,否则当前玩家失败。**
代码:
```Java
class Solution {
int n, t;
int[][] f = new int[1 << 20][2];
// 1 true / -1 false
int dfs(int state, int tot, int k) {
if (state == ((1 << n) - 1) && tot < t) return -1;
if (f[state][k % 2] != 0) return f[state][k % 2];
int hope = k % 2 == 0 ? 1 : -1;
for (int i = 0; i < n; i++) {
if (((state >> i) & 1) == 1) continue;
if (tot + i + 1 >= t) return f[state][k % 2] = hope;
if (dfs(state | (1 << i), tot + i + 1, k + 1) == hope) return f[state][k % 2] = hope;
}
return f[state][k % 2] = -hope;
}
public boolean canIWin(int _n, int _t) {
n = _n; t = _t;
if (t == 0) return true;
return dfs(0, 0, 0) == 1;
}
}
```
* 时间复杂度:共有 $2^{n} \times 2$ 个状态,每个状态转移需要 $O(n)$ 复杂度,整体复杂度为 $O(2^{n + 1} \times n)$
* 空间复杂度:$O(2^{n + 1})$
---
### 优化状态表示
进一步发现,若能优化轮数维度,可以有效减少一半的计算量,我们调整状态定义为:**定义 $f[state]$ 为当前状态为 $state$,「当前先手」能否获胜($1$ 代表能,$-1$ 代表不能)。**
同时调整递归函数为 $int dfs(int state, int tot)$,最终答案通过判断 `dfs(0, 0)` 是否为 $1$ 来得知。
注意这里调整的重点在于:将记录「原始回合的先后手发起 和 原始回合的先后手获胜情况」调整为「当前回合发起 和 当前回合获胜情况」。
代码:
```Java
class Solution {
int n, t;
int[] f = new int[1 << 20];
// 1 true / -1 false
int dfs(int state, int tot) {
if (f[state] != 0) return f[state];
for (int i = 0; i < n; i++) {
if (((state >> i) & 1) == 1) continue;
if (tot + i + 1 >= t) return f[state] = 1;
if (dfs(state | (1 << i), tot + i + 1) == -1) return f[state] = 1;
}
return f[state] = -1;
}
public boolean canIWin(int _n, int _t) {
n = _n; t = _t;
if (n * (n + 1) / 2 < t) return false;
if (t == 0) return true;
return dfs(0, 0) == 1;
}
}
```
* 时间复杂度:共有 $2^{n}$ 个状态,每个状态转移需要 $O(n)$ 复杂度,整体复杂度为 $O(2^{n} \times n)$
* 空间复杂度:$O(2^{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.464` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/467. 环绕字符串中唯一的子字符串（中等）.md | 467. 环绕字符串中唯一的子字符串 | https://leetcode.cn/problems/unique-substrings-in-wraparound-string/solution/by-ac_oier-qteu/ | 中等 | [
"线性 DP",
"树状数组"
] | 把字符串 `s` 看作是 `“abcdefghijklmnopqrstuvwxyz”` 的无限环绕字符串,所以 `s` 看起来是这样的:
`"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd...."` .
现在给定另一个字符串 `p` 。返回 `s` 中 唯一 的 `p` 的 非空子串 的数量 。
示例 1:
```
输入: p = "a"
输出: 1
解释: 字符串 s 中只有一个"a"子字符。
```
示例 2:
```
输入: p = "cac"
输出: 2
解释: 字符串 s 中的字符串“cac”只有两个子串“a”、“c”。.
```
示例 3:
```
输入: p = "zab"
输出: 6
解释: 在字符串 s 中有六个子串“z”、“a”、“b”、“za”、“ab”、“zab”。
```
提示:
* $1 <= p.length <= 10^5$
* `p` 由小写英文字母构成 | ### 线性 DP + 树状数组 + 同字符最大长度计数
> ~~早上起来没睡醒~~ 老了,脑袋不行了,第一反应是用「线性 DP + 树状数组」来做,估了一下时间复杂度没问题就写了。
该做法有一点点思维难度,因此可能不是这道中等题的标准解法。
**定义 $f[i]$ 为以 $s[i]$ 为结尾的最大有效子串的长度。**
从该状态定义容易得到如下的状态转移方程:
* 存在 $s[i - 1]$ 并且 $s[i]$ 能够接在 $s[i - 1]$ 后面(除了 $s[i]$ 为 $s[i - 1]$ 的下一字母以外,还特别包括 $s[i - 1] = z$ 同时 $s[i] = a$ 的情况),则我们有 $f[i] = f[i - 1] + 1$;
* 不存在 $s[i - 1]$ 或者 $s[i]$ 不能接在 $s[i - 1]$ 后面,则有 $f[i] = 1$,含义为 $s[i]$ 只能自身组成子串。
**与此同时,我们知道当结尾元素固定,子串长度固定,对应子串唯一确定。**
当不考虑子串重复问题时,若 $f[i] = k$,则以 $s[i]$ 为结尾的有效子串数量为 $k$ 个(对应以 $s[i]$ 为结尾,长度范围为 $[1, k]$ 的子数组)。
但实际上,我们不能统计相同的子串,因此我们需要考虑该如何去重。
不失一般性地,假设我们当前处理到字符串 `p` 中的第 $i$ 位,以 $s[i]$ 为结尾的最大子串长度为 $f[i]$:
* 此前如果 **出现过** 以 $s[i]$ 为结尾,长度「大于等于」$f[i]$ 的子串的话,那么以 $s[i]$ 为结尾长度为 $f[i]$ 的子串必然已被统计,需要跳过。因此我们可以使用一个长度为 $26$ 的数组 `max`,记录以每个字符 $s[i]$ 结尾的,出现过的最大子串长度为多少(当 `max[s[i]] >= f[i]` 时,跳过计数);
* 此前如果 **出现过** 以 $s[i]$ 为结尾,长度「小于」$f[i]$ 的子串的话,我们也不能直接统计累加 $f[i]$ 到答案上,这会导致那些以 $s[i]$ 为结尾,长度小于 $f[i]$ 的子串被重复计数,此时我们 **需要知道在以 $s[i]$ 为结尾,长度为 $[1, f[i]]$ 范围内还有多少个子串尚未被统计**,这可以使用「树状数组」解决:在 $[1, f[i]]$ 中总个数为 $a = f[i]$,使用树状数组维护在 $[1, f[i]]$ 中已被统计的数的个数 $b$,那么 $cnt = a - b$ 即是本次可增加的计数,计数完成后我们还需要在树状数组中的 $f[i]$ 位置增加 $cnt$,确保下次查询相同字符结尾长度不小于 $f[i]$ 的已覆盖子串数量时不会出错。
至此,我们通过「树状数组」+「记录同字符最大长度」的方式来分别解决「长度比 $f[i]$ 小」和「长度比 $f[i]$ 大」的重复子串统计问题。
代码:
```Java
class Solution {
int N = 100010;
int[][] trs = new int[26][N];
int[] f = new int[N], max = new int[26];
int n, ans;
int lowbit(int x) {
return x & -x;
}
void add(int[] tr, int x, int v) {
for (int i = x; i <= n + 1; i += lowbit(i)) tr[i] += v;
}
int query(int[] tr, int x) {
int ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];
return ans;
}
public int findSubstringInWraproundString(String _p) {
char[] cs = _p.toCharArray();
n = cs.length;
for (int i = 0; i < n; i++) {
int c = cs[i] - 'a';
if (i == 0) {
f[i] = 1;
} else {
int p = cs[i - 1] - 'a';
if ((c == 0 && p == 25) || p + 1 == c) f[i] = f[i - 1] + 1;
else f[i] = 1;
}
if (max[c] >= f[i]) continue;
int cnt = f[i] - query(trs[c], f[i]);
if (cnt == 0) continue;
ans += cnt;
add(trs[c], f[i], cnt);
max[c] = f[i];
}
return ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(C \times n)$,其中 $C = 26$ 为字符串 `p` 的字符集大小
---
### 线性 DP
对于相同的结尾字符 $c$ 而言,如果在整个动规过程中的最大长度为 $len$,那么以 $c$ 为结尾字符对答案的贡献为 $len$。
基于此,我们只需保留解法一中的 `max` 数组即可,同时利用 $f[i]$ 只依赖于 $f[i - 1]$ 进行更新,因此动规数组也可以使用一个变量来代替。
代码:
```Java
class Solution {
public int findSubstringInWraproundString(String _p) {
char[] cs = _p.toCharArray();
int n = cs.length, ans = 0;
int[] max = new int[26];
max[cs[0] - 'a']++;
for (int i = 1, j = 1; i < n; i++) {
int c = cs[i] - 'a', p = cs[i - 1] - 'a';
if ((p == 25 && c == 0) || p + 1 == c) j++;
else j = 1;
max[c] = Math.max(max[c], j);
}
for (int i = 0; i < 26; i++) ans += max[i];
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符串 `p` 的字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.467` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/468. 验证IP地址（中等）.md | 468. 验证IP地址 | https://leetcode.cn/problems/validate-ip-address/solution/by-ac_oier-s217/ | 中等 | [
"模拟",
"双指针"
] | 给定一个字符串 `queryIP`。如果是有效的 `IPv4` 地址,返回 `"IPv4"` ;如果是有效的 `IPv6` 地址,返回 `"IPv6"` ;如果不是上述类型的 `IP` 地址,返回 `"Neither"` 。
有效的 `IPv4` 地址 是 `“x1.x2.x3.x4”` 形式的 `IP` 地址。 其中$ 0 <= x_i <= 255$ 且 $x_i$ 不能包含 前导零。
例如: `“192.168.1.1”` 、 `“192.168.1.0”` 为有效 `IPv4` 地址, `“192.168.01.1”` 为无效 `IPv4` 地址; `“192.168.1.00”` 、 `“[email protected]”` 为无效 `IPv4` 地址。
一个有效的 `IPv6` 地址 是一个格式为 `“x1:x2:x3:x4:x5:x6:x7:x8”` 的 `IP` 地址,其中:
* $1 <= x_i.length <= 4$
* $x_i$ 是一个 十六进制字符串 ,可以包含数字、小写英文字母( `'a'` 到 `'f'` )和大写英文字母( `'A'` 到 `'F'` )。
* 在 $x_i$ 中允许前导零。
例如 `"2001:0db8:85a3:0000:0000:8a2e:0370:7334"` 和 `"2001:db8:85a3:0:0:8A2E:0370:7334"` 是有效的 `IPv6` 地址,而 `"2001:0db8:85a3::8A2E:037j:7334"` 和 `"02001:0db8:85a3:0000:0000:8a2e:0370:7334"` 是无效的 `IPv6` 地址。
示例 1:
```
输入:queryIP = "172.16.254.1"
输出:"IPv4"
解释:有效的 IPv4 地址,返回 "IPv4"
```
示例 2:
```
输入:queryIP = "2001:0db8:85a3:0:0:8A2E:0370:7334"
输出:"IPv6"
解释:有效的 IPv6 地址,返回 "IPv6"
```
示例 3:
```
输入:queryIP = "256.256.256.256"
输出:"Neither"
解释:既不是 IPv4 地址,又不是 IPv6 地址
```
提示:
* `queryIP` 仅由英文字母,数字,字符 `'.'` 和 `':'` 组成。 | ### 模拟
为了方便,我们称合法 `IPv4`/`IPv6` 中由 `.`/`:` 分割的部分称为 `item`。
无论是 `IPv4` 还是 `IPv6`,我们都只需将连续段的 `item` 取出,并结合题意判断即可,一个较为简单的方式使用 `split` 操作来得到所有的 `item`,考虑到某些语言并不内置 `split`,这里采取双指针的方式来做。
为方便大家理解,今天将题解文字说明写到注释中。
代码:
```Java
class Solution {
public String validIPAddress(String ip) {
if (ip.indexOf(".") >= 0 && check4(ip)) return "IPv4";
if (ip.indexOf(":") >= 0 && check6(ip)) return "IPv6";
return "Neither";
}
boolean check4(String ip) {
int n = ip.length(), cnt = 0;
char[] cs = ip.toCharArray();
for (int i = 0; i < n && cnt <= 3; ) {
// 找到连续数字段,以 x 存取
int j = i, x = 0;
while (j < n && cs[j] >= '0' && cs[j] <= '9' && x <= 255) x = x * 10 + (cs[j++] - '0');
// 非 item 字符之间没有 item
if (i == j) return false;
// 含前导零 或 数值大于 255
if ((j - i > 1 && cs[i] == '0') || (x > 255)) return false;
i = j + 1;
if (j == n) continue;
// 存在除 . 以外的其他非数字字符
if (cs[j] != '.') return false;
cnt++;
}
// 恰好存在 3 个不位于两端的 .
return cnt == 3 && cs[0] != '.' && cs[n - 1] != '.';
}
boolean check6(String ip) {
int n = ip.length(), cnt = 0;
char[] cs = ip.toCharArray();
for (int i = 0; i < n && cnt <= 7; ) {
int j = i;
while (j < n && ((cs[j] >= 'a' && cs[j] <= 'f') || (cs[j] >= 'A' && cs[j] <= 'F') || (cs[j] >= '0' && cs[j] <= '9'))) j++;
// 非 item 字符之间没有 item 或 长度超过 4
if (i == j || j - i > 4) return false;
i = j + 1;
if (j == n) continue;
// 存在除 : 以外的其他非数字字符
if (cs[j] != ':') return false;
cnt++;
}
// 恰好存在 7 个不位于两段的 :
return cnt == 7 && cs[0] != ':' && cs[n - 1] != ':';
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用 `toCharArray` 操作会产生新数组,复杂度为 $O(n)$,使用 `charAt` 操作代替复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.468` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/461-470/470. 用 Rand7() 实现 Rand10()（中等）.md | 470. 用 Rand7() 实现 Rand10() | https://leetcode-cn.com/problems/implement-rand10-using-rand7/solution/gong-shui-san-xie-k-jin-zhi-zhu-wei-shen-zmd4/ | 中等 | [
"位运算",
"数学"
] | 已有方法 rand7 可生成 1 到 7 范围内的均匀随机整数,试写一个方法 rand10 生成 1 到 10 范围内的均匀随机整数。
不要使用系统的 Math.random() 方法。
示例 1:
```
输入: 1
输出: [7]
```
示例 2:
```
输入: 2
输出: [8,4]
```
示例 3:
```
输入: 3
输出: [8,1,10]
```
提示:
1. rand7 已定义。
2. 传入参数: n 表示 rand10 的调用次数。
进阶:
* rand7()调用次数的 期望值 是多少 ?
* 你能否尽量少调用 rand7() ? | ### 基本分析
给定一个随机生成 $1$ ~ $7$ 的函数,要求实现等概率返回 $1$ ~ $10$ 的函数。
首先需要知道,在输出域上进行定量整体偏移,仍然满足等概率,即要实现 $0$ ~ $6$ 随机器,只需要在 `rand7` 的返回值上进行 $-1$ 操作即可。
但输出域的 拼接/叠加 并不满足等概率。例如 `rand7() + rand7()` 会产生 $[2, 14]$ 范围内的数,但每个数并非等概率:
* 产生 $2$ 的概率为:$\frac{1}{7} * \frac{1}{7} = \frac{1}{49}$
* 产生 $4$ 的概率为:$\frac{1}{7} * \frac{1}{7} + \frac{1}{7} * \frac{1}{7} + \frac{1}{7} * \frac{1}{7} = \frac{3}{49}$
在 $[2, 14]$ 这 $13$ 个数里面,等概率的数值不足 $10$ 个。
**因此,你应该知道「执行两次 `rand7()` 相加,将 $[1, 10]$ 范围内的数进行返回,否则一直重试」的做法是错误的。**
---
### $k$ 进制诸位生成 + 拒绝采样
上述做法出现概率分布不均的情况,是因为两次随机值的不同组合「相加」的会出现相同的结果($(1, 3)$、$(2, 2)$、$(3, 1)$ 最终结果均为 $4$)。
结合每次执行 `rand7` 都可以看作一次独立事件。我们可以将两次 `rand7` 的结果看作生成 $7$ 进制的两位。**从而实现每个数值都唯一对应了一种随机值的组合(等概率),反之亦然。**
举个🌰,设随机执行两次 `rand7` 得到的结果分别是 $4$(第一次)、$7$(第二次),由于我们是要 $7$ 进制的数,因此可以先对 `rand7` 的执行结果进行 $-1$ 操作,将输出域偏移到 $[0, 6]$(仍为等概率),即得到 $3$(第一次)和 $6$(第二次),最终得到的是数值 $(63)_7$,数值 $(63)_7$ 唯一对应了我们的随机值组合方案,反过来随机值组合方案也唯一对应一个 $7$ 进制的数值。
**那么根据「进制转换」的相关知识,如果我们存在一个 `randK` 的函数,对其执行 $n$ 次,我们能够等概率产生 $[0, K^n - 1]$ 范围内的数值。**
回到本题,执行一次 `rand7` 只能产生 $[0, 6]$ 范围内的数值,不足 $10$ 个;而执行 $2$ 次 `rand7` 的话则能产生 $[0, 48]$ 范围内的数值,足够 $10$ 个,且等概率。
我们只需要判定生成的值是否为题意的 $[1, 10]$ 即可,如果是的话直接返回,否则一直重试。
代码:
```Java
class Solution extends SolBase {
public int rand10() {
while (true) {
int ans = (rand7() - 1) * 7 + (rand7() - 1); // 进制转换
if (1 <= ans && ans <= 10) return ans;
}
}
}
```
* 时间复杂度:期望复杂度为 $O(1)$,最坏情况下为 $O(\infty)$
* 空间复杂度:$O(1)$
---
### 进阶
1. 降低对 `rand7` 的调用次数
我们发现,在上述解法中,范围 $[0, 48]$ 中,只有 $[1, 10]$ 范围内的数据会被接受返回,其余情况均被拒绝重试。
为了尽可能少的调用 `rand7` 方法,我们可以从 $[0, 48]$ 中取与 $[1, 10]$ 成倍数关系的数,来进行转换。
我们可以取 $[0, 48]$ 中的 $[1, 40]$ 范围内的数来代指 $[1, 10]$。
首先在 $[0, 48]$ 中取 $[1, 40]$ 仍为等概率,其次形如 $x1$ 的数值有 $4$ 个($1$、$11$、$21$、$31$),形如 $x2$ 的数值有 $4$ 个($2$、$12$、$22$、$32$)... 因此最终结果仍为等概率。
代码:
```Java
class Solution extends SolBase {
public int rand10() {
while (true) {
int ans = (rand7() - 1) * 7 + (rand7() - 1); // 进制转换
if (1 <= ans && ans <= 40) return ans % 10 + 1;
}
}
}
```
* 时间复杂度:期望复杂度为 $O(1)$,最坏情况下为 $O(\infty)$
* 空间复杂度:$O(1)$
2. 计算 `rand7` 的期望调用次数
在 $[0, 48]$ 中我们采纳了 $[1, 40]$ 范围内的数值,即以调用两次为基本单位的话,有 $\frac{40}{49}$ 的概率被接受返回(成功)。
成功的概率为 $\frac{40}{49}$,那么需要触发成功所需次数(期望次数)为其倒数 $\frac{49}{40} = 1.225$,每次会调用两次 `rand7`,因而总的期望调用次数为 $1.225 * 2 = 2.45$ 。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.470` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/472. 连接词（困难）.md | 472. 连接词 | https://leetcode-cn.com/problems/concatenated-words/solution/gong-shui-san-xie-xu-lie-dpzi-fu-chuan-h-p7no/ | 困难 | [
"字符串哈希",
"序列 DP"
] | 给你一个 不含重复 单词的字符串数组 `words` ,请你找出并返回 `words` 中的所有 连接词 。
连接词 定义为:一个完全由给定数组中的至少两个较短单词组成的字符串。
示例 1:
```
输入:words = ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]
输出:["catsdogcats","dogcatsdog","ratcatdogcat"]
解释:"catsdogcats" 由 "cats", "dog" 和 "cats" 组成;
"dogcatsdog" 由 "dog", "cats" 和 "dog" 组成;
"ratcatdogcat" 由 "rat", "cat", "dog" 和 "cat" 组成。
```
示例 2:
```
输入:words = ["cat","dog","catdog"]
输出:["catdog"]
```
提示:
* $1 <= words.length <= 10^4$
* $0 <= words[i].length <= 1000$
* $words[i]$ 仅由小写字母组成
* $0 <= sum(words[i].length) <= 10^5$ | ### 序列 DP + 字符串哈希
给定数组 $words$,先考虑如何判断某个 $s = words[i]$ 是否为「连接词」。
为了方便,我们称组成 `s` 的每个连接部分为 `item`。
举个 🌰,例如 `s = abc`,其可能的 `item` 组合为 `a` 和 `bc`。
判断单个字符串是否为连接词可使用动态规划求解:**定义 $f[i]$ 为考虑 `s` 的前 $i$ 个字符(令下标从 $1$ 开始),能够切分出的最大 `item` 数的个数。**
这里之所以采用「记录 $f[i]$ 为最大分割 `item` 数(`int` 类型动规数组)」,而不是「记录 $f[i]$ 为是否可由多个 `item` 组成(`bool` 类型动规数组)」,是因为每个 $s = words[i]$ 至少可由自身组成,采用 `bool` 记录状态的话,最终 $f[n]$ 必然为 `True`,需要额外处理最后一个状态,干脆记录最大分割数量好了。此时如果 `s` 为「连接词」必然有 $f[n] > 1$。
不失一般性的考虑 $f[i]$ 该如何转移:**假设 $f[i]$ 可由 $f[j]$ 转移而来(其中 $j < i$),那么能够转移的充要条件为 $f[j] != 0$ 且子串 $s[(j + 1)..i]$ 在 $words$ 出现过**。
其中枚举 $i$ 和 $j$ 的复杂度已经去到 $O(n^2)$ 了,如果常规通过 `HashMap` 等数据结构判断某个字符串是否存在,执行哈希函数时需要对字符进行遍历,整体复杂度去到了 $O(n^3)$,会 `TLE`。
**我们通过「字符串哈希」方式来优化判断某个子串是否存在于 $words$ 中。**
具体的,在判断每个 $s = words[i]$ 是否为为连接词前,先对 $words$ 进行遍历,预处理每个 $words[i]$ 的哈希值,并存入 `HashSet` 中,这样我们将「判断某个子串是否存在于 $words$」的问题转化为「判断某个数值是否存在于 `Set` 当中」。
又由于 **我们在计算某个子串 `s` 的哈希值时,是从前往后处理每一位的 $s[i]$,因此在转移 $f[i]$ 时,我们期望能够从前往后处理子串,这是常规的从 $[0, i - 1]$ 范围内找可转移点 $f[j]$ 无法做到的**。
所以 **我们调整转移逻辑为:从 $f[i]$ 出发,枚举范围 $[i + 1, n]$,找到可由 $f[i]$ 所能更新的状态 $f[j]$,并尝试使用 $f[i]$ 来更新 $f[j]$。转移方程为:**
$$
f[j] = \max(f[j], f[i] + 1)
$$
当然,能够转移的前提条件为 $f[i]$ 为有效值,且子串 $s[(i + 1), j]$ 在 $words$ 出现过。
> 一些细节:为了方便,我们定义 $f[i] = -1$ 为无效状态;
另外由于字符串哈希会产生哈希碰撞,这里在计算哈希值的时候,修改了一下哈希计算方式(额外增加了一个 `OFFSET`),当时的目的是想在电脑没电前 `AC`,而另一个更加稳妥的方式是使用双哈希,或是干脆记录某个哈希值对应了哪些字符串。
代码:
```Java
class Solution {
Set<Long> set = new HashSet<>();
int P = 131, OFFSET = 128;
public List<String> findAllConcatenatedWordsInADict(String[] words) {
for (String s : words) {
long hash = 0;
for (char c : s.toCharArray()) hash = hash * P + (c - 'a') + OFFSET;
set.add(hash);
}
List<String> ans = new ArrayList<>();
for (String s : words) {
if (check(s)) ans.add(s);
}
return ans;
}
boolean check(String s) {
int n = s.length();
int[] f = new int[n + 1];
Arrays.fill(f, -1);
f[0] = 0;
for (int i = 0; i <= n; i++) {
if (f[i] == -1) continue;
long cur = 0;
for (int j = i + 1; j <= n; j++) {
cur = cur * P + (s.charAt(j - 1) - 'a') + OFFSET;
if (set.contains(cur)) f[j] = Math.max(f[j], f[i] + 1);
}
if (f[n] > 1) return true;
}
return false;
}
}
```
* 时间复杂度:令 $n$ 为 $words$ 数组长度,$N = \sum_{i = 0}^{n - 1}words[i].length$,根据数据范围 $N$ 最大为 $1e5$。预处理出 `Set` 的复杂度为 $O(N)$;会对所有 $words[i]$ 执行 `check` 操作,复杂度为 $O((words[i].length)^2)$,总的计算量最大值为 $O(N^2)$,由于存在剪枝,实际上达不到该计算量
* 空间复杂度:$O(n + \max(words[i].length))$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.472` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/473. 火柴拼正方形（中等）.md | 473. 火柴拼正方形 | https://leetcode.cn/problems/matchsticks-to-square/solution/by-ac_oier-k8i7/ | 中等 | [
"剪枝",
"DFS",
"爆搜",
"模拟退火",
"启发式搜索",
"随机化"
] | 你将得到一个整数数组 `matchsticks`,其中 $matchsticks[i]$ 是第 `i` 个火柴棒的长度。你要用 所有的火柴棍 拼成一个正方形。
你 不能折断 任何一根火柴棒,但你可以把它们连在一起,而且每根火柴棒必须 使用一次 。
如果你能使这个正方形,则返回 `true`,否则返回 `false`。
示例 1:
```
输入: matchsticks = [1,1,2,2,2]
输出: true
解释: 能拼成一个边长为2的正方形,每边两根火柴。
```
示例 2:
```
输入: matchsticks = [3,3,3,3,4]
输出: false
解释: 不能用所有火柴拼成一个正方形。
```
提示:
* $1 <= matchsticks.length <= 15$
* $1 <= matchsticks[i] <= 10^8$ | > 祝大家儿童节快乐,永葆童心,一直善良 😊 ~
### DFS 剪枝
为了方便,我们称 `matchsticks` 为 `ms`。
数据范围为 $n = 15$,朴素的 `DFS` 爆搜(搜索过程中维护一个大小为 $4$ 的数组 `cur`,数组中的每一位代表正方形一条边长所使用到的火柴总长度,若最终数组中每一位均等于 $t = \frac{\sum_{i = 0}^{n - 1}ms[i]}{4}$,代表存在合法方案)复杂度为 $4^n$,会 `TLE`。
我们考虑如何进行「剪枝」。
首先一个较为明显的剪枝操作是进行「可行性剪枝」:我们在决策 $ms[idx]$ 时,如果将其累加到某个 $cur[i]$ 之后,会导致 $cur[i] > t$,则说明必然不会是合法方案,该分支不再往后搜索。
另外一个较为 trick 的剪枝是通过「调整搜索顺序/检查当前桶的总长度」来进行「重复性剪枝」:我们可以先对 `ms` 排倒序,进行「从大到小」的爆搜。本质上,我们是将一些小火柴重复放到某几个桶的搜索路径(其实对应的是相同的分配方案),放到了最后处理;同时,当我们要放置 $ms[idx]$ 的火柴时,如果存在多个桶总长度相等,例如 $cur[i] = cur[j]$,将 $ms[idx]$ 放置在 $cur[i]$ 或 $cur[j]$ 也是等价的。
代码:
```Java
class Solution {
int[] ms;
int t;
public boolean makesquare(int[] _ms) {
ms = _ms;
int sum = 0;
for (int i : ms) sum += i;
t = sum / 4;
if (t * 4 != sum) return false;
Arrays.sort(ms);
return dfs(ms.length - 1, new int[4]);
}
boolean dfs(int idx, int[] cur) {
if (idx == -1) return true;
out:for (int i = 0; i < 4; i++) {
for (int j = 0; j < i; j++) {
if (cur[j] == cur[i]) continue out;
}
int u = ms[idx];
if (cur[i] + u > t) continue;
cur[i] += u;
if (dfs(idx - 1, cur)) return true;
cur[i] -= u;
}
return false;
}
}
```
* 时间复杂度:$O(4^n)$
* 空间复杂度:排序的复杂度为 $O(\log{n})$,忽略递归带来的额外空间开销,复杂度为 $O(\log{n})$
---
### 模拟退火
事实上,这道题还能使用「模拟退火」进行求解。
**因为将 $n$ 个数划分为 $4$ 份,等效于用 $n$ 个数构造出一个「特定排列」,然后对「特定排列」进行固定模式的构造逻辑,就能实现「答案」与「最优排列」的对应关系。**
基于此,我们可以使用「模拟退火」进行求解。
单次迭代的基本流程:
1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」
2. 如果温度下降(交换后的序列更优),进入下一次迭代
3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)
值得一提的是,这道题造数据的人十分有水平,在最后一个样例中放了个卡 `SA` 的数据:
```
[403,636,824,973,815,318,881,506,863,21,834,211,316,772,803]
```
但我不知道为什么 LC 的提交结果会这么奇怪,已通过 `184/183` 样例?是总样例数哪个地方更新漏了,还是缓存没刷新:
这个数据点优秀在于起始排序可以导致我们固定的 `calc` 逻辑最终落入局部最优。针对这种情况,也很好解决,只需要在执行 `SA` 之前,先对原数组进行一次随机化打乱即可。
代码(`2022/06/01` 可通过):
```Java
class Solution {
int[] ms;
int n, k;
Random random = new Random(20220601);
double hi = 1e9, lo = 1e-4, fa = 0.95;
int N = 400;
boolean ans = false;
int calc() {
int diff = 0;
for (int i = 0, j = 0; i < 4; i++) {
int cnt = 0;
while (j < n && cnt < k) cnt += ms[j++];
diff += Math.abs(k - cnt);
}
if (diff == 0) ans = true;
return diff;
}
void sa() {
shuffle(ms);
for (double t = hi; t > lo && !ans; t *= fa) {
int a = random.nextInt(n), b = random.nextInt(n);
if (a == b) continue;
int prev = calc();
swap(ms, a, b);
int cur = calc();
int diff = cur - prev;
if (Math.log(diff / t) > random.nextDouble()) swap(ms, a, b);
}
}
public boolean makesquare(int[] _ms) {
ms = _ms;
n = ms.length;
int sum = 0;
for (int i : ms) sum += i;
k = sum / 4;
if (k * 4 != sum) return false;
while (!ans && N-- > 0) sa();
return ans;
}
void shuffle(int[] nums) {
for (int i = n; i > 0; i--) {
int idx = random.nextInt(i);
swap(nums, idx, i - 1);
}
}
void swap(int[] nums, int a, int b) {
int c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}
}
```
---
### 我猜你问
**Q0. 模拟退火有何风险?**
随机算法,会面临 `WA` 和 `TLE` 风险。
**Q1. 模拟退火中的参数如何敲定的?**
根据经验猜的,然后提交。根据结果是 `WA` 还是 `TLE` 来决定之后的调参方向。如果是 `WA` 说明部分数据落到了「局部最优」或者尚未达到「全局最优」。
**Q2. 参数如何调整?**
如果是 `WA` 了,一般我是优先调大 fa 参数,使降温变慢,来变相增加迭代次数;如果是 `TLE` 了,一般是优先调小 fa 参数,使降温变快,减小迭代次数。总迭代参数 `N` 也是同理。
可以简单理解调大 fa 代表将「大步」改为「baby step」,防止越过全局最优,同时增加总执行步数。
**Q3. 关于「模拟退火」正确性?**
随机种子不变,测试数据不变,迭代参数不变,那么退火的过程就是恒定的,必然都能找到这些测试样例的「全局最优」。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.472` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/474. 一和零（中等）.md | 474. 一和零 | https://leetcode-cn.com/problems/ones-and-zeroes/solution/gong-shui-san-xie-xiang-jie-ru-he-zhuan-174wv/ | 中等 | [
"01 背包",
"背包问题",
"多维背包",
"动态规划"
] | 给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的大小,该子集中 最多 有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素,集合 x 是集合 y 的 子集 。
示例 1:
```
输入:strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出:4
解释:最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ,因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意,因为它含 4 个 1 ,大于 n 的值 3 。
```
示例 2:
```
输入:strs = ["10", "0", "1"], m = 1, n = 1
输出:2
解释:最大的子集是 {"0", "1"} ,所以答案是 2 。
```
提示:
* 1 <= strs.length <= 600
* 1 <= strs[i].length <= 100
* strs[i] 仅由 '0' 和 '1' 组成
* 1 <= m, n <= 100 | ### (多维)01 背包
通常与「背包问题」相关的题考察的是 **将原问题转换为「背包问题」的能力**。
要将原问题转换为「背包问题」,往往需要从题目中抽象出「价值」与「成本」的概念。
这道题如果抽象成「背包问题」的话,应该是:
**每个字符串的价值都是 1(对答案的贡献都是 1),选择的成本是该字符串中 1 的数量和 0 的数量。**
问我们在 1 的数量不超过 $m$,0 的数量不超过 $n$ 的条件下,最大价值是多少。
由于每个字符串只能被选一次,且每个字符串的选与否对应了「价值」和「成本」,求解的问题也是「最大价值」是多少。
因此可以直接套用 01 背包的「状态定义」来做:
**$f[k][i][j]$ 代表考虑前 k 件物品,在数字 1 容量不超过 $i$,数字 0 容量不超过 $j$ 的条件下的「最大价值」(每个字符串的价值均为 1)。**
有了「状态定义」之后,「转移方程」也很好推导:
$$f[k][i][j] = \max(f[k - 1][i][j], f[k - 1][i - cnt[k][0]][j - cnt[k][1]] + 1)$$
其中 $cnt$ 数组记录的是字符串中出现的 $01$ 数量。
代码(为了方便理解,$P1$ 将第一件物品的处理单独抽了出来,也可以不抽出来,只需要将让物品下标从 $1$ 开始即可,见 $P2$):
```Java
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int len = strs.length;
// 预处理每一个字符包含 0 和 1 的数量
int[][] cnt = new int[len][2];
for (int i = 0; i < len; i++) {
String str = strs[i];
int zero = 0, one = 0;
for (char c : str.toCharArray()) {
if (c == '0') {
zero++;
} else {
one++;
}
}
cnt[i] = new int[]{zero, one};
}
// 处理只考虑第一件物品的情况
int[][][] f = new int[len][m + 1][n + 1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
f[0][i][j] = (i >= cnt[0][0] && j >= cnt[0][1]) ? 1 : 0;
}
}
// 处理考虑其余物品的情况
for (int k = 1; k < len; k++) {
int zero = cnt[k][0], one = cnt[k][1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
// 不选择第 k 件物品
int a = f[k-1][i][j];
// 选择第 k 件物品(前提是有足够的 m 和 n 额度可使用)
int b = (i >= zero && j >= one) ? f[k-1][i-zero][j-one] + 1 : 0;
f[k][i][j] = Math.max(a, b);
}
}
}
return f[len-1][m][n];
}
}
```
```Java
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int len = strs.length;
int[][] cnt = new int[len][2];
for (int i = 0; i < len; i++) {
String str = strs[i];
int zero = 0, one = 0;
for (char c : str.toCharArray()) {
if (c == '0') zero++;
else one++;
}
cnt[i] = new int[]{zero, one};
}
int[][][] f = new int[len + 1][m + 1][n + 1];
for (int k = 1; k <= len; k++) {
int zero = cnt[k - 1][0], one = cnt[k - 1][1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
int a = f[k - 1][i][j];
int b = (i >= zero && j >= one) ? f[k - 1][i - zero][j - one] + 1 : 0;
f[k][i][j] = Math.max(a, b);
}
}
}
return f[len][m][n];
}
}
```
* 时间复杂度:预处理字符串的复杂度为 $O(\sum_{i = 0}^{k - 1}len(strs[i]))$,处理状态转移的 $O(k * m * n)$。整体复杂度为:$O(k * m * n + \sum_{i = 0}^{k - 1}len(strs[i]))$
* 空间复杂度:$O(k * m * n)$
---
### 滚动数组
根据「状态转移」可知,更新某个物品的状态时,只依赖于上一个物品的状态。
因此,可以使用「滚动数组」的方式进行空间优化。
代码(为了方便理解,$P1$ 将第一件物品的处理单独抽了出来,也可以不抽出来,只需要将让物品下标从 $1$ 开始即可,见 $P2$):
```Java
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int len = strs.length;
// 预处理每一个字符包含 0 和 1 的数量
int[][] cnt = new int[len][2];
for (int i = 0; i < len; i++) {
String str = strs[i];
int zero = 0, one = 0;
for (char c : str.toCharArray()) {
if (c == '0') {
zero++;
} else {
one++;
}
}
cnt[i] = new int[]{zero, one};
}
// 处理只考虑第一件物品的情况
// 「物品维度」修改为 2
int[][][] f = new int[2][m + 1][n + 1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
f[0][i][j] = (i >= cnt[0][0] && j >= cnt[0][1]) ? 1 : 0;
}
}
// 处理考虑其余物品的情况
for (int k = 1; k < len; k++) {
int zero = cnt[k][0], one = cnt[k][1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
// 不选择第 k 件物品
// 将 k-1 修改为 (k-1)&1
int a = f[(k-1)&1][i][j];
// 选择第 k 件物品(前提是有足够的 m 和 n 额度可使用)
// 将 k-1 修改为 (k-1)&1
int b = (i >= zero && j >= one) ? f[(k-1)&1][i-zero][j-one] + 1 : 0;
f[k&1][i][j] = Math.max(a, b);
}
}
}
// 将 len-1 修改为 (len-1)&1
return f[(len-1)&1][m][n];
}
}
```
```Java
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int len = strs.length;
int[][] cnt = new int[len][2];
for (int i = 0; i < len; i++) {
String str = strs[i];
int zero = 0, one = 0;
for (char c : str.toCharArray()) {
if (c == '0') zero++;
else one++;
}
cnt[i] = new int[]{zero, one};
}
int[][][] f = new int[2][m + 1][n + 1];
for (int k = 1; k <= len; k++) {
int zero = cnt[k - 1][0], one = cnt[k - 1][1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
int a = f[(k-1) & 1][i][j];
int b = (i >= zero && j >= one) ? f[(k-1) & 1][i - zero][j - one] + 1 : 0;
f[k&1][i][j] = Math.max(a, b);
}
}
}
return f[len&1][m][n];
}
}
```
* 时间复杂度:预处理字符串的复杂度为 $O(\sum_{i = 0}^{k - 1}len(strs[i]))$,处理状态转移的 $O(k * m * n)$。整体复杂度为:$O(k * m * n + \sum_{i = 0}^{k - 1}len(strs[i]))$
* 空间复杂度:$O(m * n)$
---
### 一维空间优化
事实上,我们还能继续进行空间优化。
再次观察我们的「状态转移方程」发现:**$f[k][i][j]$ 不仅仅依赖于上一行,还明确依赖于比 $i$ 小和比 $j$ 小的状态。**
即可只依赖于「上一行」中「正上方」的格子,和「正上方左边」的格子。
对应到「朴素的 01 背包问题」依赖关系如图:
因此可直接参考「01 背包的空间优化」方式:取消掉「物品维度」,然后调整容量的遍历顺序。
代码:
```Java
class Solution {
public int findMaxForm(String[] strs, int m, int n) {
int len = strs.length;
int[][] cnt = new int[len][2];
for (int i = 0; i < len; i++) {
int zero = 0, one = 0;
for (char c : strs[i].toCharArray()) {
if (c == '0') zero++;
else one++;
}
cnt[i] = new int[]{zero, one};
}
int[][] f = new int[m + 1][n + 1];
for (int k = 0; k < len; k++) {
int zero = cnt[k][0], one = cnt[k][1];
for (int i = m; i >= zero; i--) {
for (int j = n; j >= one; j--) {
f[i][j] = Math.max(f[i][j], f[i - zero][j - one] + 1);
}
}
}
return f[m][n];
}
}
```
* 时间复杂度:预处理字符串的复杂度为 $O(\sum_{i = 0}^{k - 1}len(strs[i]))$,处理状态转移的 $O(k * m * n)$。整体复杂度为:$O(k * m * n + \sum_{i = 0}^{k - 1}len(strs[i]))$
* 空间复杂度:$O(m * n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.474` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/475. 供暖器（中等）.md | 475. 供暖器 | https://leetcode-cn.com/problems/heaters/solution/gong-shui-san-xie-er-fen-shuang-zhi-zhen-mys4/ | 中等 | [
"排序",
"二分",
"双指针"
] | 冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
在加热器的加热半径范围内的每个房屋都可以获得供暖。
现在,给出位于一条水平线上的房屋 `houses` 和供暖器 `heaters` 的位置,请你找出并返回可以覆盖所有房屋的最小加热半径。
说明:所有供暖器都遵循你的半径标准,加热的半径也一样。
示例 1:
```
输入: houses = [1,2,3], heaters = [2]
输出: 1
解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1,那么所有房屋就都能得到供暖。
```
示例 2:
```
输入: houses = [1,2,3,4], heaters = [1,4]
输出: 1
解释: 在位置1, 4上有两个供暖器。我们需要将加热半径设为1,这样所有房屋就都能得到供暖。
```
示例 3:
```
输入:houses = [1,5], heaters = [2]
输出:3
```
提示:
* $1 <= houses.length, heaters.length <= 3 \times 10^4$
* $1 <= houses[i], heaters[i] <= 10^9$ | ### 二分 + 双指针
需要求得最小加热半径 $ans$,使得所有的 $houses[i]$ 均被覆盖。
在以 $ans$ 为分割点的数轴上具有「二段性」:
* 数值小于 $ans$ 的半径无法覆盖所有的房子;
* 数值大于等于 $ans$ 的半径可以覆盖所有房子。
因此可直接「二分答案」,考虑应该在什么范围内进行「二分」。
可以从数据范围入手,使用 $1e9$ 为二分上界,该做法能确保答案在二分范围内。
考虑如何实现 `check` 函数。
先对 $houses$ 和 $heaters$ 进行排序,使用 $i$ 指向当前处理到的 $houses[i]$;$j$ 指向 **可能** 覆盖到 $houses[i]$ 的最小下标 $heaters[j]$;$x$ 代表当前需要 `check` 的半径。
当且仅当 $heaters[j] + x < houses[i]$ 时,$houses[i]$ 必然不能被 $heaters[j]$ 所覆盖,此时让 $j$ 自增。
找到合适的 $j$ 之后,再检查 $heaters[j] - x <= houses[i] <= heaters[j] + x$ 是否满足,即可知道 $houses[i]$ 的覆盖情况。
代码:
```Java
class Solution {
public int findRadius(int[] houses, int[] heaters) {
Arrays.sort(houses);
Arrays.sort(heaters);
int l = 0, r = (int) 1e9;
while (l < r) {
int mid = l + r >> 1;
if (check(houses, heaters, mid)) r = mid;
else l = mid + 1;
}
return r;
}
boolean check(int[] houses, int[] heaters, int x) {
int n = houses.length, m = heaters.length;
for (int i = 0, j = 0; i < n; i++) {
while (j < m && houses[i] > heaters[j] + x) j++;
if (j < m && heaters[j] - x <= houses[i] && houses[i] <= heaters[j] + x) continue;
return false;
}
return true;
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别为 `houses` 和 `heaters` 长度,$L = 1e9$ 为最大长度,对其进行排序复杂度为 $O(n\log{n} + m\log{m})$,在 $[0, L]$ 范围进行二分,单次 `check` 会使用「双指针」判断是否每个 $houses[i]$ 是否被覆盖,复杂度为 $O(\max(n, m) \times \log{L})$。整体复杂度为 $O(\max(n, m) \times \log{L})$
* 空间复杂度:排序所需要消耗的空间。复杂度为 $O(\log{n} + \log{m})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.475` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/476. 数字的补数（简单）.md | 476. 数字的补数 | https://leetcode-cn.com/problems/number-complement/solution/gong-shui-san-xie-yi-ti-shuang-jie-bian-wjl0y/ | 简单 | [
"模拟",
"位运算"
] | 对整数的二进制表示取反(`0` 变 `1` ,`1` 变 `0`)后,再转换为十进制表示,可以得到这个整数的补数。
* 例如,整数 `5` 的二进制表示是 `"101"` ,取反后得到 `"010"` ,再转回十进制表示得到补数 2 。
给你一个整数 `num`,输出它的补数。
示例 1:
```
输入:num = 5
输出:2
解释:5 的二进制表示为 101(没有前导零位),其补数为 010。所以你需要输出 2 。
```
示例 2:
```
输入:num = 1
输出:0
解释:1 的二进制表示为 1(没有前导零位),其补数为 0。所以你需要输出 0 。
```
提示:
* $1 <= num < 2^{31}$ | ### 模拟(遍历)
返回对 $num$ 的二进制表示取反的数,注意 $num$ 的二进制表示是不包含前导零的。
因此主要问题求得 $num$ 最高位 $1$ 的位置。
一个简单的做法是:先对 $num$ 进行「从高到低」的检查,找到最高位 $1$ 的位置 $s$,然后再对 $num$ 进行遍历,将低位到 $s$ 位的位置执行逐位取反操作。
代码:
```Java
class Solution {
public int findComplement(int num) {
int s = -1;
for (int i = 31; i >= 0; i--) {
if (((num >> i) & 1) != 0) {
s = i;
break;
}
}
int ans = 0;
for (int i = 0; i < s; i++) {
if (((num >> i) & 1) == 0) ans |= (1 << i);
}
return ans;
}
}
```
* 时间复杂度:$O(\log{num})$
* 空间复杂度:$O(1)$
---
### 模拟(lowbit)
通过解法一我们发现,如果 $num$ 的二进制表示中最高位 $1$ 的位置为 $s$ 的话,那么实际上我们只需要对 $num$ 的前 $s - 1$ 位进行取反即是答案(第 $s$ 位的取反结果始终为 $0$)。
因此我们可以先使用 `lowbit` 操作来得到 $num$ 二进制表示中最高位 $1$ 的位置为 $1$,其余位为 $0$ 时所代表的数字 $x$。
然后 $x - 1$ 即是二进制表示中前 $s - 1$ 位均为 $1$,其余位为 $0$ 的数字,将其与 $num$ 的取反数执行「按位与」操作,即可达到「仅对 $num$ 的前 $s - 1$ 位进行取反」的效果。
代码:
```Java
class Solution {
public int findComplement(int num) {
int x = 0;
for (int i = num; i != 0; i -= i & -i) x = i;
return ~num & (x - 1);
}
}
```
* 时间复杂度:$O(\log{num})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.476` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/477. 汉明距离总和（中等）.md | 477. 汉明距离总和 | https://leetcode-cn.com/problems/total-hamming-distance/solution/gong-shui-san-xie-ying-yong-cheng-fa-yua-g21t/ | 中等 | [
"位运算",
"数学"
] | 两个整数的 汉明距离 指的是这两个数字的二进制数对应位不同的数量。
给你一个整数数组 nums,请你计算并返回 nums 中任意两个数之间汉明距离的总和。
示例 1:
```
输入:nums = [4,14,2]
输出:6
解释:在二进制表示中,4 表示为 0100 ,14 表示为 1110 ,2表示为 0010 。(这样表示是为了体现后四位之间关系)
所以答案为:
HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6
```
示例 2:
```
输入:nums = [4,14,4]
输出:4
```
提示:
```
1 <= nums.length <= $10^5$
0 <= nums[i] <= $10^9$
``` | ### 按位统计
我们知道,汉明距离为两数二进制表示中不同位的个数,同时每位的统计是相互独立的。
即最终的答案为 $\sum_{x = 0}^{31} calc(x)$,其中 $calc$ 函数为求得所有数二进制表示中的某一位 $x$ 所产生的不同位的个数。
我们考虑某个 $cacl(x)$ 如何求得:
事实上,对于某个 `nums[i]` 我们只关心在 `nums` 中有多少数的第 $x$ 位的与其不同,而不关心具体是哪些数与其不同,同时二进制表示中非 $0$ 即 $1$。
**这指导我们可以建立两个集合 $s0$ 和 $s1$,分别统计出 `nums` 中所有数的第 $x$ 位中 $0$ 的个数和 $1$ 的个数,集合中的每次计数代表了 `nums` 中的某一元素,根据所在集合的不同代表了其第 $x$ 位的值。那么要找到在 `nums` 中有多少数与某一个数的第 $x$ 位不同,只需要读取另外一个集合的元素个数即可,变成了 $O(1)$ 操作。那么要求得「第 $x$ 位所有不同数」的对数的个数,只需要应用乘法原理,将两者元素个数相乘即可。**
前面说到每位的统计是相对独立的,因此只要对「每一位」都应用上述操作,并把「每一位」的结果累加即是最终答案。
代码:
```Java
class Solution {
public int totalHammingDistance(int[] nums) {
int ans = 0;
for (int x = 31; x >= 0; x--) {
int s0 = 0, s1 = 0;
for (int u : nums) {
if (((u >> x) & 1) == 1) {
s1++;
} else {
s0++;
}
}
ans += s0 * s1;
}
return ans;
}
}
```
* 时间复杂度:$O(C * n)$,$C$ 固定为 $32$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.477` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/478. 在圆内随机生成点（中等）.md | 478. 在圆内随机生成点 | https://leetcode.cn/problems/generate-random-point-in-a-circle/solution/by-ac_oier-btkm/ | 中等 | [
"数学",
"随机化"
] | 给定圆的半径和圆心的位置,实现函数 `randPoint`,在圆中产生均匀随机点。
实现 `Solution` 类:
* `Solution(double radius, double x_center, double y_center)` 用圆的半径 `radius` 和圆心的位置 $(x_center, y_center)$ 初始化对象
* `randPoint()` 返回圆内的一个随机点。圆周上的一点被认为在圆内。答案作为数组返回 $[x, y]$ 。
示例 1:
```
输入:
["Solution","randPoint","randPoint","randPoint"]
[[1.0, 0.0, 0.0], [], [], []]
输出: [null, [-0.02493, -0.38077], [0.82314, 0.38945], [0.36572, 0.17248]]
解释:
Solution solution = new Solution(1.0, 0.0, 0.0);
solution.randPoint ();//返回[-0.02493,-0.38077]
solution.randPoint ();//返回[0.82314,0.38945]
solution.randPoint ();//返回[0.36572,0.17248
```
提示:
* $0 < radius <= 10^8$
* $-10^7 <= x_center, y_center <= 10^7$
* `randPoint` 最多被调用 $3 \times 10^4$ 次 | ### 等概率随机采样
为了方便,我们称圆心为 $(x, y)$,半径为 $r$。
对给定圆内的点进行等概率随机采样,容易想到随机化两个信息:一个是距离圆心的距离 `len`(在范围 $[0, r]$ 中进行随机),另外一个是夹角 `ang`(在范围 $[0, 2\pi]$ 中随机,随便找个参考线即可,例如以往 $x$ 轴正方向的射线为参考)。
然后根据 `len` 和 `ang` 直接计算对应的点的坐标,这样 **可以确保随机出来的点一定在圆内,但并非「等概率」。**
在不考虑夹角的情况下,我们本质是在 $[0, r]$ 范围内随机,这在「一维」上「等概率」是成立的,因为满足「任意连续段中点被抽到的次数与总次数的比例」与「该连续段长度与总长度的比例」。
但在圆中并非如此,不考虑夹角时,「任意连续段 `len` 与总长度 `r` 的比例」和「`len` 对应面积与总面积比例」并不相等。例如 `len` 有 $\frac{1}{2}$ 的概率取到小于等于 $\frac{r}{2}$ 的值,而半径为 $\frac{r}{2}$ 扫过的面积仅为总面积的 $\frac{1}{4}$,因此我们的 `len` 不能直接在 $[0, r]$ 范围内随机,为了消除这种一维转圆导致的「等概率」失效,我们可以从 $[0, r^2]$ 内随机再开平方,从而确保距离与面积比例一致。
代码:
```Java
class Solution {
double r, x, y;
Random random = new Random();
public Solution(double _r, double _x, double _y) {
r = _r; x = _x; y = _y;
}
public double[] randPoint() {
double len = Math.sqrt(random.nextDouble(r * r)), ang = random.nextDouble(2 * Math.PI);
double nx = x + len * Math.cos(ang), ny = y + len * Math.sin(ang);
return new double[]{nx, ny};
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.478` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/479. 最大回文数乘积（困难）.md | 479. 最大回文数乘积 | https://leetcode-cn.com/problems/largest-palindrome-product/solution/by-ac_oier-t8j7/ | 困难 | [
"枚举",
"数学"
] | 给定一个整数 $n$ ,返回 可表示为两个 $n$ 位整数乘积的 最大回文整数 。
因为答案可能非常大,所以返回它对 $1337$ 取余 。
示例 1:
```
输入:n = 2
输出:987
解释:99 x 91 = 9009, 9009 % 1337 = 987
```
示例 2:
```
输入: n = 1
输出: 9
```
提示:
* $1 <= n <= 8$ | ### 枚举 + 数学
对于数位为 $n$ 的两个数而言,其乘积的位数要么是 $2 * n$,要么是 $2 * n - 1$。
当数位 $n > 1$ 时,我们总能在数位为 $2 * n$ 中找到答案。
利用回文串的特性,我们只需枚举回文串的前半部分即可(后半部分唯一确定),我们只要在枚举前半部分时按照「从大到小」进行,即可确保找到的第一个合法值为最大数,对于一个数位为 $n$ 的最大数为 $10^n - 1$。
具体的,当枚举到回文串的前半部分 $i$ 时,我们利用回文串特性构造出具实际的回文数值 $nums$,随后检查 $nums$ 能否分解成数位为 $n$ 的数对 $(a, b)$,利用乘法具有交换律,我们只需要枚举数对中的较大数即可。
代码:
```Java
class Solution {
public int largestPalindrome(int n) {
if (n == 1) return 9;
int max = (int) Math.pow(10, n) - 1;
for (int i = max; i >= 0; i--) {
long num = i, t = i;
while (t != 0) {
num = num * 10 + (t % 10);
t /= 10;
}
for (long j = max; j * j >= num; j--) {
if (num % j == 0) return (int)(num % 1337);
}
}
return -1;
}
}
```
* 时间复杂度:枚举回文串的前半部分复杂度为 $O(10^n)$;检查回文串能否被分解复杂度为 $O(10^n)$。整体复杂度为 $O(10^{2n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.479` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/471-480/480. 滑动窗口中位数（困难）.md | 480. 滑动窗口中位数 | https://leetcode-cn.com/problems/sliding-window-median/solution/xiang-jie-po-su-jie-fa-you-xian-dui-lie-mo397/ | 困难 | [
"滑动窗口",
"优先队列(堆)"
] | 中位数是有序序列最中间的那个数。如果序列的长度是偶数,则没有最中间的数;此时中位数是最中间的两个数的平均数。
例如:
* $[2,3,4]$,中位数是 $3$
* $[2,3]$,中位数是 $(2 + 3) / 2 = 2.5$
给你一个数组 $nums$,有一个长度为 $k$ 的窗口从最左端滑动到最右端。
窗口中有 $k$ 个数,每次窗口向右移动 $1$ 位。
你的任务是找出每次窗口移动后得到的新窗口中元素的中位数,并输出由它们组成的数组。
示例:
```
给出 nums = [1,3,-1,-3,5,3,6,7],以及 k = 3。
窗口位置 中位数
--------------- -----
[1 3 -1] -3 5 3 6 7 1
1 [3 -1 -3] 5 3 6 7 -1
1 3 [-1 -3 5] 3 6 7 -1
1 3 -1 [-3 5 3] 6 7 3
1 3 -1 -3 [5 3 6] 7 5
1 3 -1 -3 5 [3 6 7] 6
因此,返回该滑动窗口的中位数数组 [1,-1,-1,3,5,6]。
```
提示:
* 你可以假设 $k$ 始终有效,即:$k$ 始终小于等于输入的非空数组的元素个数。
* 与真实值误差在 $10 ^ {-5}$ 以内的答案将被视作正确答案。 | ### 朴素解法
一个直观的做法是:对每个滑动窗口的数进行排序,获取排序好的数组中的第 $\frac{k}{2}$ 和 $\frac{k - 1}{2}$ 个数(避免奇偶数讨论),计算中位数。
我们大概分析就知道这个做法至少 $O(n * k)$ 的,算上排序的话应该是 $O(n * (k + k\log{k}))$。
比较无奈的是,这道题的中文说明中没有给出数据范围。我们无法根据判断这样的做法会不会超时。
朴素做法通常是优化的开始,所以还是提供一下朴素做法的代码。
代码:
```Java
class Solution {
public double[] medianSlidingWindow(int[] nums, int k) {
int n = nums.length;
int cnt = n - k + 1;
double[] ans = new double[cnt];
int[] t = new int[k];
for (int l = 0, r = l + k - 1; r < n; l++, r++) {
for (int i = l; i <= r; i++) t[i - l] = nums[i];
Arrays.sort(t);
ans[l] = (t[k / 2] / 2.0) + (t[(k - 1) / 2] / 2.0);
}
return ans;
}
}
```
* 时间复杂度:最多有 `n` 个窗口需要滑动计算。每个窗口,需要先插入数据,复杂度为 $O(k)$,插入后需要排序,复杂度为 $O(k\log{k})$。整体复杂度为 $O(n * (k + k\log{k}))$
* 空间复杂度:使用了长度为 `k` 的临时数组。复杂度为 $O(k)$
---
### 优先队列(堆)
从朴素解法中我们可以发现,其实我们需要的就是滑动窗口中的第 $\frac{k}{2}$ 小的值和第 $\frac{k - 1}{2}$ 小的值。
我们知道滑动窗口求最值的问题,可以使用优先队列来做。
但这里我们求的是第 $k$ 小的数,而且是需要两个值。还能不能使用优先队列来做呢?
我们可以维护两个堆:
* 一个大根堆维护着滑动窗口中一半较小的值(此时堆顶元素为滑动窗口中的第 $\frac{k - 1}{2}$ 小的值)
* 一个小根堆维护着滑动窗口中一半较大的值(此时堆顶元素为滑动窗口中的第 $\frac{k}{2}$ 小的值)
滑动窗口的中位数就是两个堆的堆顶元素的平均值。
实现细节:
1. 初始化时,先让 `k` 个元素直接入 `right`,再从 `right` 中倒出 $\frac{k}{2}$ 个到 `left` 中。这时候可以根据 `left` 和 `right` 得到第一个滑动窗口的中位值。
2. 开始滑动窗口,每次滑动都有一个待添加和待移除的数:
2.1 根据与右堆的堆顶元素比较,决定是插入哪个堆和从哪个堆移除
2.2 之后调整两堆的大小(确保只会出现 `left.size() == right.size()` 或 `right.size() - left.size() == 1`,对应了窗口长度为偶数或者奇数的情况)
2.3 根据 `left` 堆 和 `right` 堆得到当前滑动窗口的中位值
代码:
```Java
class Solution {
public double[] medianSlidingWindow(int[] nums, int k) {
int n = nums.length;
int cnt = n - k + 1;
double[] ans = new double[cnt];
// 如果是奇数滑动窗口,让 right 的数量比 left 多一个
PriorityQueue<Integer> left = new PriorityQueue<>((a,b)->Integer.compare(b,a)); // 滑动窗口的左半部分
PriorityQueue<Integer> right = new PriorityQueue<>((a,b)->Integer.compare(a,b)); // 滑动窗口的右半部分
for (int i = 0; i < k; i++) right.add(nums[i]);
for (int i = 0; i < k / 2; i++) left.add(right.poll());
ans[0] = getMid(left, right);
for (int i = k; i < n; i++) {
// 人为确保了 right 会比 left 多,因此,删除和添加都与 right 比较(left 可能为空)
int add = nums[i], del = nums[i - k];
if (add >= right.peek()) {
right.add(add);
} else {
left.add(add);
}
if (del >= right.peek()) {
right.remove(del);
} else {
left.remove(del);
}
adjust(left, right);
ans[i - k + 1] = getMid(left, right);
}
return ans;
}
void adjust(PriorityQueue<Integer> left, PriorityQueue<Integer> right) {
while (left.size() > right.size()) right.add(left.poll());
while (right.size() - left.size() > 1) left.add(right.poll());
}
double getMid(PriorityQueue<Integer> left, PriorityQueue<Integer> right) {
if (left.size() == right.size()) {
return (left.peek() / 2.0) + (right.peek() / 2.0);
} else {
return right.peek() * 1.0;
}
}
}
```
* 时间复杂度:调整过程中堆大小最大为 `k`,堆操作中的指定元素删除复杂度为 $O(k)$;窗口数量最多为 `n`。整体复杂度为 $O(n * k)$
* 空间复杂度:最多有 `n` 个元素在堆内。复杂度为 $O(n)$
---
### 答疑
以下是针对一些具有代表性的问题进行的集中答疑:
* 为什么 `new PriorityQueue<>((x,y)->(y-x))` 的写法会有某些案例无法通过?和 `new PriorityQueue<>((x,y)->Integer.compare(y,x))` 写法有何区别?
`(x,y)->(y-x)` 的写法逻辑没有错,AC 不了是因为 int 溢出。
在 Java 中 Integer.compare 的实现是 `(x < y) ? -1 : ((x == y) ? 0 : 1)`。只是单纯的比较,不涉及运算,所以不存在溢出风险。
而直接使用 `y - x`,当 `y = Integer.MAX_VALUE`, `x = Integer.MIN_VALUE` 时,到导致溢出,返回的是 **负数** ,而不是逻辑期望的 **正数**
同样具有溢出问题的还有计算第 $\frac{k}{2}$ 小的数和第 $\frac{k - 1}{2}$ 小的数的平均值时。
因此题解中使用的是 `(a / 2.0) + (b / 2.0)` 的形式,而不是采用 `(a + b) / 2.0` 的形式。后者有相加溢出的风险。
---
### 复杂度说明
JDK 中 `PriorityQueue` 的 `remove(Object o)` 实现是先调用 `indexOf(Object o)` 方法进行线性扫描找到下标(复杂度为 $O(n)$),之后再调用 `removeAt(int i)` 进行删除(复杂度为 $O(\log{n})$)。
对于本题而言,如果需要实现 $O(\log{n})$ 的 `remove(Object o)`, 只能通过引入其他数据结构(如哈希表)来实现快速查找元素在对堆数组中的下标。
对于本题,可以使用元素在原数组中的下标作为 key,在堆数组中的真实下标作为 val。
通过哈希表可以 $O(1)$ 的复杂度找到下标,之后的删除只需要算堆调整的复杂度即可(最多 down 一遍,up 一遍,复杂度为 $O(\log{n})$)。
至于 JDK 没有这样做的原因,猜测是因为基本类型的包装类型存在小数缓存机制,导致无法很好的使用哈希表来对应一个插入元素的下标。
举个🌰,我们调用三次 `add(10)`, 会有 $3$ 个 $10$ 在堆内,但是由于小数(默认范围为 $[-128,127]$)包装类型存在缓存机制,使用哈希表继续记录的话,只会有 { Integer.valueOf(10) : 移动过程中最后一次访问的数组下标 } 这样一条记录(`add` 进去的 $10$ 均为同一对象)。这时候删除一个 $10$ 之后,哈希表无法正确指导我们找到下一个 $10$ 的位置。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.480` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/481. 神奇字符串（中等）.md | 481. 神奇字符串 | https://leetcode.cn/problems/magical-string/solution/by-ac_oier-7wjo/ | 中等 | [
"模拟",
"构造",
"双指针",
"打表"
] | 神奇字符串 `s` 仅由 `'1'` 和 `'2'` 组成,并需要遵守下面的规则:
* 神奇字符串 `s` 的神奇之处在于,串联字符串中 `'1'` 和 `'2'` 的连续出现次数可以生成该字符串。
`s` 的前几个元素是 `s = "1221121221221121122......"` 。如果将 `s` 中连续的若干 `1` 和 `2` 进行分组,可以得到 `"1 22 11 2 1 22 1 22 11 2 11 22 ......"` 。
每组中 `1` 或者 `2` 的出现次数分别是 `"1 2 2 1 1 2 1 2 2 1 2 2 ......"` 。上面的出现次数正是 `s` 自身。
给你一个整数 `n` ,返回在神奇字符串 `s` 的前 `n` 个数字中 `1` 的数目。
示例 1:
```
输入:n = 6
输出:3
解释:神奇字符串 s 的前 6 个元素是 “122112”,它包含三个 1,因此返回 3 。
```
示例 2:
```
输入:n = 1
输出:1
```
提示:
* $1 <= n <= 10^5$ | ### 双指针 + 构造 + 打表
我们将相关的字符串分为三类:**题目描述的神奇字符串 `s` 称为“原串”,对 `s` 进行连续段划分所得的串叫“划分串”,对划分串进行计数的串叫“计数串”**。
解题的核心思路:**由于划分串是对原串的划分,同时计数串又与原串相同,因此可得三类串均只有 `1` 和 `2` 两种数值。即可知划分串的每段长度只能是「长度为 `1`」或「长度为 `2`」,利用划分串的每段构造长度有限,我们可以通过「简单分情况讨论」的方式进行构造**。
具体的,我们需要利用「原串和计数串的相同的性质」对 `s` 进行构造:不难发现计数串总是不长于原串,因此我们可以使用变量 `i` 来记录当前构造到原串位置,使用变量 `j` 来记录计数串对应到的实际位置。
不失一般性假设当前构造到 `s` 中的某一位为 `last`,而计数串对应的实际位置为 `t`,由于两者均只有 `1` 和 `2` 两种可能,我们可以对其进行简单的分情况讨论(可见代码注释)。
> 一些细节:由于神奇字符串起始字符固定,构造逻辑固定,因此神奇字符串唯一固定。
我们可以采取 `static` 代码块的方式进行打表预处理(`Java` 中的 `static` 代码块只会在类加载的过程执行一次,而 `LC` 的测评机制是实例化多个 `Solution` 对象来跑多个样例,但 `Solution` 类仍只会被加载一次,即 `static` 在多个样例测评中只会被执行一次。
Java 代码:
```Java
class Solution {
static int N = 100010;
static int[] f = new int[N];
static {
StringBuilder sb = new StringBuilder();
sb.append("01"); // 首位多加一个 0 作为哨兵
for (int i = 1, j = 1, cnt = 0; i < N; j++) {
int last = sb.charAt(sb.length() - 1) - '0', t = sb.charAt(j) - '0';
if (last == 1) {
if (t == 1) {
// 当原串当前字符是 1,而计数串当前字符为 1
// 往后构造形成的原串只能是 12,原串指针后移一位
sb.append("2");
f[i] = ++cnt; i++;
} else {
// 当原串当前字符是 1,而计数串当前字符为 2
// 往后构造形成的原串只能是 112,此时同步更新 f[i + 1],原串指针后移两位
sb.append("12");
f[i] = ++cnt; f[i + 1] = ++cnt; i += 2;
}
} else {
if (t == 1) {
// 当原串当前字符是 2,而计数串当前字符为 1
// 往后构造形成的原串只能是 21,原串指针后移一位
sb.append("1");
f[i] = cnt; i++;
} else {
// 当原串当前字符是 2,而计数串当前字符为 2
// 往后构造形成的原串只能是 221,原串指针后移两位
sb.append("21");
f[i] = f[i + 1] = cnt; i += 2;
}
}
}
}
public int magicalString(int n) {
return f[n];
}
}
```
C++ 代码:
```C++
class Solution {
public:
static const int N = 100010;
static vector<int> f;
Solution() {
if(!f.empty()) return;
f.resize(N);
string sb = "01"; // 首位多加一个 0 作为哨兵
for (int i = 1, j = 1, cnt = 0; i < N; j++) {
int last = sb[sb.size() - 1] - '0', t = sb[j] - '0';
if (last == 1) {
if (t == 1) {
sb += '2';
f[i++] = ++cnt;
} else {
sb += "12";
f[i++] = ++cnt; f[i++] = ++cnt;
}
} else {
if (t == 1) {
sb += '1';
f[i++] = cnt;
} else {
sb += "21";
f[i++] = f[i++] = cnt;
}
}
}
}
int magicalString(int n) {
return f[n];
}
};
vector<int> Solution::f = {};
```
Python 代码:
```Python
class Solution:
def magicalString(self, n: int) -> int:
ss = '01' # 首位多加一个 0 作为哨兵
i, j, cnt = 1, 1, 0
f = [0] * (n + 10)
while i <= n:
last, t = ss[i], ss[j]
if last == '1':
if t == '1':
# 当原串当前字符是 1,而计数串当前字符为 1
# 往后构造形成的原串只能是 12,原串指针后移一位
ss += '2'
f[i], cnt, i = cnt + 1, cnt + 1, i + 1
else:
# 当原串当前字符是 1,而计数串当前字符为 2
# 往后构造形成的原串只能是 112,此时同步更新 f[i + 1],原串指针后移两位
ss += '12'
f[i], f[i + 1], cnt, i = cnt + 1, cnt + 2, cnt + 2, i + 2
else:
if t == '1':
# 当原串当前字符是 2,而计数串当前字符为 1
# 往后构造形成的原串只能是 21,原串指针后移一位
ss += '1'
f[i], i = cnt, i + 1
else:
# 当原串当前字符是 2,而计数串当前字符为 2
# 往后构造形成的原串只能是 221,原串指针后移两位
ss += '21'
f[i], f[i + 1], i = cnt, cnt, i + 2
j += 1
return f[n]
```
TypeScript 代码:
```TypeScript
function magicalString(n: number): number {
let str = '01' // 首位多加一个 0 作为哨兵
const f = new Array<number>(n + 10).fill(0)
for (let i = 1, j = 1, cnt = 0; i <= n; j++) {
const last = str[str.length - 1], t = str[j]
if (last == '1') {
if (t == '1') {
// 当原串当前字符是 1,而计数串当前字符为 1
// 往后构造形成的原串只能是 12,原串指针后移一位
str += '2'
f[i] = ++cnt; i++
} else {
// 当原串当前字符是 1,而计数串当前字符为 2
// 往后构造形成的原串只能是 112,此时同步更新 f[i + 1],原串指针后移两位
str += '12'
f[i] = ++cnt; f[i + 1] = ++cnt; i += 2
}
} else {
if (t == '1') {
// 当原串当前字符是 2,而计数串当前字符为 1
// 往后构造形成的原串只能是 21,原串指针后移一位
str += '1'
f[i] = cnt; i++
} else {
// 当原串当前字符是 2,而计数串当前字符为 2
// 往后构造形成的原串只能是 221,原串指针后移两位
str += '21'
f[i] = f[i + 1] = cnt; i += 2
}
}
}
return f[n]
}
```
* 时间复杂度:$O(n)$,若将 `static` 打表逻辑放到本地进行,能够减少构造的计算量,但仍会有创建答案数组的 $O(n)$ 开销,因此为均摊 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.481` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/482. 密钥格式化（简单）.md | 482. 密钥格式化 | https://leetcode-cn.com/problems/license-key-formatting/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-piya/ | 简单 | [
"模拟"
] | 有一个密钥字符串 `S`,只包含字母,数字以及 `'-'`(破折号)。其中,`N` 个 `'-'` 将字符串分成了 `N+1` 组。
给你一个数字 `K`,请你重新格式化字符串,使每个分组恰好包含 `K` 个字符。特别地,第一个分组包含的字符个数必须小于等于 `K`,但至少要包含 `1` 个字符。两个分组之间需要用 `'-'`(破折号)隔开,并且将所有的小写字母转换为大写字母。
给定非空字符串 `S` 和数字 `K`,按照上面描述的规则进行格式化。
示例 1:
```
输入:S = "5F3Z-2e-9-w", K = 4
输出:"5F3Z-2E9W"
解释:字符串 S 被分成了两个部分,每部分 4 个字符;
注意,两个额外的破折号需要删掉。
```
示例 2:
```
输入:S = "2-5g-3-J", K = 2
输出:"2-5G-3J"
解释:字符串 S 被分成了 3 个部分,按照前面的规则描述,第一部分的字符可以少于给定的数量,其余部分皆为 2 个字符。
```
提示:
* S 的长度可能很长,请按需分配大小。K 为正整数。
* S 只包含字母数字(a-z,A-Z,0-9)以及破折号'-'
* S 非空 | ### 模拟
简单字符串模拟,从后往前处理,避免对首个分区的分情况讨论和取余操作。
代码:
```Java
class Solution {
public String licenseKeyFormatting(String s, int k) {
StringBuilder sb = new StringBuilder();
for (int i = s.length() - 1, cnt = 0; i >= 0; i--) {
if (s.charAt(i) == '-') continue;
if (cnt == k && (cnt = 0) >= 0) sb.append("-");
sb.append(s.charAt(i));
cnt++;
}
return sb.reverse().toString().toUpperCase();
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.482` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/483. 最小好进制（困难）.md | 483. 最小好进制 | https://leetcode-cn.com/problems/smallest-good-base/solution/gong-shui-san-xie-xiang-jie-ru-he-fen-xi-r94g/ | 困难 | [
"数学",
"推公式"
] | 对于给定的整数 n, 如果n的k(k>=2)进制数的所有数位全为1,则称 k(k>=2)是 n 的一个好进制。
以字符串的形式给出 n, 以字符串的形式返回 n 的最小好进制。
示例 1:
```
输入:"13"
输出:"3"
解释:13 的 3 进制是 111。
```
示例 2:
```
输入:"4681"
输出:"8"
解释:4681 的 8 进制是 11111。
```
示例 3:
```
输入:"1000000000000000000"
输出:"999999999999999999"
解释:1000000000000000000 的 999999999999999999 进制是 11。
```
提示:
* n的取值范围是 [3, $10^{18}$]。
* 输入总是有效且没有前导 0。 | ### 基本分析
设 $(n)_{10}$ 的 $k$ 进制表示共有 $Len$ 位,那么根据「进制转换」相关知识,必然有如下等式:
$$
(n)_{10} = (11...11)_{k} = k^0 + k^1 + k^2 + ... + k^{Len - 1}
$$
当 $n$ 给定的情况下,$k$ 随着 $Len$ 减小而增大,由此我们可以分析出 $k$ 的上界:
* 当 $Len$ 取 $1$ 的时候:$k^0 = n$,即 $n = 1$,与题目给定的数据范围冲突,不可取;
* 当 $Len$ 取 $2$ 的时候:$k^0 + k^1 = n$,即 $k = n - 1$,为合法值。
**因此 $k$ 的上界为 $n - 1$,同时我们知道长度 $Len$ 满足等式 $Len \geq 2$。**
然后我们再分析一下 $Len$ 的上界。
**根据 $k$ 与 $Len$ 大小变化关系,同时已知 $k \geq 2$,不难分析当 $k$ 取最小值 $2$ 的时候,$Len$ 可得最大值(同时 $n$ 的最大值为 $10^{18}$),可分析出 $Len \leq \lceil \log_2{n} \rceil$,$\log_2{10^{18}}$ 不超过 $60$。**
因此可以采取枚举 $Len$ 的做法。
---
### 枚举 $Len$
根据分析,我们可以在 $[2, 60]$ 范围内从大到小枚举 $Len$,当取得第一位合法的 $Len$ 时,$k$ 为最小合法值。
剩下的问题在于如何在给定 $Len$ 的情况下,求得 $k$ 为多少。
前面分析到 $Len \geq 2$,令 $s = Len - 1$,再根据 [二项式定理](https://baike.baidu.com/item/%E4%BA%8C%E9%A1%B9%E5%BC%8F%E5%AE%9A%E7%90%86) 可得:
$$
n = k^0 + k^1 + k^2 + ... + k^s < C_{s}^{0} * k^0 + C_{s}^{1} * k^1 + ... + C_{s}^{s} * k^s = (k + 1)^{s}
$$
同时结合 $n > k^ s$,可得 $k^s < n < (k + 1)^s$,整理后可得:
$$
k < n^{\frac{1}{s}} < k + 1
$$
因此,对于任意的 $s = Len - 1$ 都有唯一的解为 $n^{\frac{1}{s}}$(正整数),我们只需要验证 $n^{\frac{1}{s}}$ 是否为正整数即可。
一些细节:实现上为了方便,不处理 $k = n - 1$ 的边界问题,我们可以调整枚举下界为 $3$,当枚举不出合法 $k$ 时,直接返回 $n - 1$ 作为答案。
代码:
```Java
class Solution {
public String smallestGoodBase(String n) {
long m = Long.parseLong(n);
int max = (int)(Math.log(m) / Math.log(2) + 1);
for (int len = max; len >= 3; len--) {
long k = (long)Math.pow(m, 1.0 / (len - 1));
long res = 0;
for (int i = 0; i < len; i++) res = res * k + 1;
if (res == m) return String.valueOf(k);
}
return String.valueOf(m - 1);
}
}
```
* 时间复杂度:$O(\log^2{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.483` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/485. 最大连续 1 的个数（简单）.md | 485. 最大连续 1 的个数 | https://leetcode-cn.com/problems/max-consecutive-ones/solution/you-shi-yi-tian-gao-pin-jian-dan-ti-ni-d-avj1/ | 简单 | [
"双指针"
] | 给定一个二进制数组, 计算其中最大连续 1 的个数。
示例:
```
输入:[1,1,0,1,1,1]
输出:3
解释:开头的两位和最后的三位都是连续 1 ,所以最大连续 1 的个数是 3.
```
提示:
* 输入的数组只包含 0 和 1 。
* 输入数组的长度是正整数,且不超过 10,000。 | ### 双指针解法
使用 `i` 和 `j` 分别代表连续 1 的左右边界。
起始状态 `i == j`,当 `i` 到达第一个 1 的位置时,让 `j` 不断右移直到右边界。
更新 `ans`
```java
class Solution {
public int findMaxConsecutiveOnes(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0, j = 0; i < n; j = i) {
if (nums[i] == 1) {
while (j + 1 < n && nums[j + 1] == 1) j++;
ans = Math.max(ans, j - i + 1);
i = j + 1;
} else {
i++;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.485` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/481-490/488. 祖玛游戏（困难）.md | 488. 祖玛游戏 | https://leetcode-cn.com/problems/zuma-game/solution/gong-shui-san-xie-yi-ti-shuang-jie-sou-s-3ftb/ | 困难 | [
"DFS",
"搜索",
"启发式搜索",
"AStar 算法"
] | 你正在参与祖玛游戏的一个变种。
在这个祖玛游戏变体中,桌面上有 一排 彩球,每个球的颜色可能是:红色 `'R'`、黄色 `'Y'`、蓝色 `'B'`、绿色 `'G'` 或白色 `'W'` 。你的手中也有一些彩球。
你的目标是 清空 桌面上所有的球。每一回合:
* 从你手上的彩球中选出 任意一颗 ,然后将其插入桌面上那一排球中:两球之间或这一排球的任一端。
* 接着,如果有出现 三个或者三个以上 且 颜色相同 的球相连的话,就把它们移除掉。
* 如果这种移除操作同样导致出现三个或者三个以上且颜色相同的球相连,则可以继续移除这些球,直到不再满足移除条件。
* 如果桌面上所有球都被移除,则认为你赢得本场游戏。
* 重复这个过程,直到你赢了游戏或者手中没有更多的球。
给你一个字符串 board ,表示桌面上最开始的那排球。另给你一个字符串 hand ,表示手里的彩球。请你按上述操作步骤移除掉桌上所有球,计算并返回所需的 最少 球数。如果不能移除桌上所有的球,返回 -1 。
示例 1:
```
输入:board = "WRRBBW", hand = "RB"
输出:-1
解释:无法移除桌面上的所有球。可以得到的最好局面是:
- 插入一个 'R' ,使桌面变为 WRRRBBW 。WRRRBBW -> WBBW
- 插入一个 'B' ,使桌面变为 WBBBW 。WBBBW -> WW
桌面上还剩着球,没有其他球可以插入。
```
示例 2:
```
输入:board = "WWRRBBWW", hand = "WRBRW"
输出:2
解释:要想清空桌面上的球,可以按下述步骤:
- 插入一个 'R' ,使桌面变为 WWRRRBBWW 。WWRRRBBWW -> WWBBWW
- 插入一个 'B' ,使桌面变为 WWBBBWW 。WWBBBWW -> WWWW -> empty
只需从手中出 2 个球就可以清空桌面。
```
示例 3:
```
输入:board = "G", hand = "GGGGG"
输出:2
解释:要想清空桌面上的球,可以按下述步骤:
- 插入一个 'G' ,使桌面变为 GG 。
- 插入一个 'G' ,使桌面变为 GGG 。GGG -> empty
只需从手中出 2 个球就可以清空桌面。
```
示例 4:
```
输入:board = "RBYYBBRRB", hand = "YRBGB"
输出:3
解释:要想清空桌面上的球,可以按下述步骤:
- 插入一个 'Y' ,使桌面变为 RBYYYBBRRB 。RBYYYBBRRB -> RBBBRRB -> RRRB -> B
- 插入一个 'B' ,使桌面变为 BB 。
- 插入一个 'B' ,使桌面变为 BBB 。BBB -> empty
只需从手中出 3 个球就可以清空桌面。
```
提示:
* 1 <= board.length <= 16
* 1 <= hand.length <= 5
* board 和 hand 由字符 `'R'`、`'Y'`、`'B'`、`'G'` 和 `'W'` 组成
* 桌面上一开始的球中,不会有三个及三个以上颜色相同且连着的球 | ### 搜索 + 剪枝
数据范围 $1 <= board.length <= 16$ 和 $1 <= hand.length <= 5$。
为了方便,我们使用 $a$ 和 $b$ 来代指 $board$ 和 $hand$。
但在爆搜过程中同时维持两个字符串构造会超时,考虑使用一个 `int` 来记录 $hand$ 的使用情况。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
String b;
int m;
Map<String, Integer> map = new HashMap<>();
public int findMinStep(String a, String _b) {
b = _b;
m = b.length();
int ans = dfs(a, 1 << m);
return ans == INF ? -1 : ans;
}
int dfs(String a, int cur) {
if (a.length() == 0) return 0;
String hashKey = a + "_" + cur;
if (map.containsKey(hashKey)) return map.get(hashKey);
int ans = INF;
int n = a.length();
for (int i = 0; i < m; i++) {
if (((cur >> i) & 1) == 1) continue;
int next = (1 << i) | cur;
for (int j = 0; j <= n; j++) {
boolean ok = false;
if (j > 0 && j < n && a.charAt(j) == a.charAt(j - 1) && a.charAt(j - 1) != b.charAt(i)) ok = true;
if (j < n && a.charAt(j) == b.charAt(i)) ok = true;
if (!ok) continue;
StringBuilder sb = new StringBuilder();
sb.append(a.substring(0, j)).append(b.substring(i, i + 1));
if (j != n) sb.append(a.substring(j));
int k = j;
while (0 <= k && k < sb.length()) {
char c = sb.charAt(k);
int l = k, r = k;
while (l >= 0 && sb.charAt(l) == c) l--;
while (r < sb.length() && sb.charAt(r) == c) r++;
if (r - l - 1 >= 3) {
sb.delete(l + 1, r);
k = l >= 0 ? l : r;
} else {
break;
}
}
ans = Math.min(ans, dfs(sb.toString(), next) + 1);
}
}
map.put(hashKey, ans);
return ans;
}
}
```
* 时间复杂度:略。「爆搜」同时还得考虑「剪枝」的复杂度分析意义不大。
* 空间复杂度:略
---
### AStar 算法
我们建立一个类 `Node` 来代指当前搜索局面。
```Java
class Node {
// 当前的棋盘状况
String a;
// cur 代表当前 hand 的使用情况(若 cur 二进制表示中的第 k 位为 1,代表 hand 的第 k 个彩球已被使用)
// val 代表「当前棋盘为 a」和「hand 使用情况为 cur」的情况下,至少还需要多少步才能将 a 全部消掉(启发式估算值)
// step 代表当前局面是经过多少步而来
int cur, val, step;
Node (String _a, int _c, int _v, int _s) {
a = _a;
cur = _c; val = _v; step = _s;
}
}
```
显然,直接对此进行 `BFS`,会 TLE。
我们考虑将优化 `BFS` 中使用到的队列改为优先队列:**更接近答案的局面先出队进行局面延展。**
然后我们考虑如何设计 AStar 的启发式函数。
**首先,一个合格的 AStar 启发式函数应当能够确保「估值不会小于理论最小距离」。同时由于启发式的估值函数是针对于最终状态进行估算,因此只确保最终状态的第一次出队时为最短路,其余中间状态的首次出队不一定是最短路,为此我们需要使用哈希表来记录中间状态的距离变化,如果某个局面的最短距离被更新,我们应当将其再次入队。**
基于此,我们设计如下的 AStar 的启发式函数:使用哈希表来统计「当前的棋盘 $a$ 的彩球数量」&「当前手上拥有的彩球数量」,对「无解情况」和「理论最小次数」进行分析:
* 对于某个彩球 $c$ 而言,如果当前棋盘的数量 + 手上的数量 都不足 $3$ 个,那么该局面往下搜索也必然无解,该局面无须入队;
* 对于某个彩球 $c$ 而言,如果当前棋盘数量少于 $3$ 个,那么至少需要补充至 $3$ 个才能被消除,而缺少的个数则是「从手上彩球放入棋盘内」的次数,即对于彩球 $c$,我们理论上至少需要消耗 $3 - cnt$ 次($cnt$ 为当前棋盘拥有的彩球 $c$ 的数量)。
需要注意的是:对于某个局面 $node$ 而言,最终的距离是由「已确定距离」+「估值距离」两部分组成,我们应当根据这两部分之和进行出队,才能确保算法的正确性。
代码:
```Java
class Solution {
class Node {
String a;
int cur, val, step;
Node (String _a, int _c, int _v, int _s) {
a = _a;
cur = _c; val = _v; step = _s;
}
}
int f(String a, int k) {
Map<Character, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();
for (int i = 0; i < a.length(); i++) {
m1.put(a.charAt(i), m1.getOrDefault(a.charAt(i), 0) + 1);
}
for (int i = 0; i < m; i++) {
if (((k >> i) & 1) == 0) m2.put(b.charAt(i), m2.getOrDefault(b.charAt(i), 0) + 1);
}
int ans = 0;
for (char c : m1.keySet()) {
int c1 = m1.get(c), c2 = m2.getOrDefault(c, 0);
if (c1 + c2 < 3) return INF;
if (c1 < 3) ans += (3 - c1);
}
return ans;
}
int INF = 0x3f3f3f3f;
String b;
int m;
Map<String, Integer> map = new HashMap<>();
public int findMinStep(String _a, String _b) {
b = _b;
m = b.length();
PriorityQueue<Node> q = new PriorityQueue<>((o1,o2)->(o1.val+o1.step)-(o2.val+o2.step));
q.add(new Node(_a, 1 << m, f(_a, 1 << m), 0));
map.put(_a + "_" + (1 << m), 0);
while (!q.isEmpty()) {
Node poll = q.poll();
String a = poll.a;
int cur = poll.cur;
int step = poll.step;
int n = a.length();
for (int i = 0; i < m; i++) {
if (((cur >> i) & 1) == 1) continue;
int next = (1 << i) | cur;
for (int j = 0; j <= n; j++) {
boolean ok = false;
if (j > 0 && j < n && a.charAt(j) == a.charAt(j - 1) && a.charAt(j - 1) != b.charAt(i)) ok = true;
if (j < n && a.charAt(j) == b.charAt(i)) ok = true;
if (!ok) continue;
StringBuilder sb = new StringBuilder();
sb.append(a.substring(0, j)).append(b.substring(i, i + 1));
if (j != n) sb.append(a.substring(j));
int k = j;
while (0 <= k && k < sb.length()) {
char c = sb.charAt(k);
int l = k, r = k;
while (l >= 0 && sb.charAt(l) == c) l--;
while (r < sb.length() && sb.charAt(r) == c) r++;
if (r - l - 1 >= 3) {
sb.delete(l + 1, r);
k = l >= 0 ? l : r;
} else {
break;
}
}
String nextStr = sb.toString();
if (nextStr.length() == 0) return step + 1;
if (f(nextStr, next) == INF) continue;
String hashKey = nextStr + "_" + next;
if (!map.containsKey(hashKey) || map.get(hashKey) > step + 1) {
map.put(hashKey, step + 1);
q.add(new Node(nextStr, next, f(nextStr, next), step + 1));
}
}
}
}
return -1;
}
}
```
* 时间复杂度:略。「爆搜」同时还得考虑「启发式加速」的复杂度分析意义不大。
* 空间复杂度:略 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.488` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/492. 构造矩形（简单）.md | 492. 构造矩形 | https://leetcode-cn.com/problems/construct-the-rectangle/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-7ser/ | 简单 | [
"模拟"
] | 作为一位web开发者, 懂得怎样去规划一个页面的尺寸是很重要的。 现给定一个具体的矩形页面面积,你的任务是设计一个长度为 L 和宽度为 W 且满足以下要求的矩形的页面。要求:
1. 你设计的矩形页面必须等于给定的目标面积。
2. 宽度 W 不应大于长度 L,换言之,要求 L >= W 。
3. 长度 L 和宽度 W 之间的差距应当尽可能小。
你需要按顺序输出你设计的页面的长度 L 和宽度 W。
示例:
```
输入: 4
输出: [2, 2]
解释: 目标面积是 4, 所有可能的构造方案有 [1,4], [2,2], [4,1]。
但是根据要求2,[1,4] 不符合要求; 根据要求3,[2,2] 比 [4,1] 更能符合要求. 所以输出长度 L 为 2, 宽度 W 为 2。
```
说明:
1. 给定的面积不大于 10,000,000 且为正整数。
2. 你设计的页面的长度和宽度必须都是正整数。 | ### 模拟
根据题意,从 $\sqrt{area}$ 开始往后模拟,遇到第一个能够被整除的数值,则返回该答案。
代码:
```Java
class Solution {
public int[] constructRectangle(int area) {
for (int i = (int)(Math.sqrt(area)); ;i--) {
if (area % i == 0) return new int[]{area / i, i};
}
}
}
```
* 时间复杂度:$O(\sqrt{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.492` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/494. 目标和（中等）.md | 494. 目标和 | https://leetcode-cn.com/problems/target-sum/solution/gong-shui-san-xie-yi-ti-si-jie-dfs-ji-yi-et5b/ | 中等 | [
"DFS",
"记忆化搜索",
"背包 DP",
"01 背包"
] | 给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 '+' 或 '-' ,然后串联起所有整数,可以构造一个 表达式 :
* 例如,nums = [2, 1] ,可以在 2 之前添加 '+' ,在 1 之前添加 '-' ,然后串联起来得到表达式 "+2-1" 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
示例 1:
```
输入:nums = [1,1,1,1,1], target = 3
输出:5
解释:一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
```
示例 2:
```
输入:nums = [1], target = 1
输出:1
```
提示:
* 1 <= nums.length <= 20
* 0 <= nums[i] <= 1000
* 0 <= sum(nums[i]) <= 100
* -1000 <= target <= 100 | ### DFS
数据范围只有 $20$,而且每个数据只有 $+/-$ 两种选择,因此可以直接使用 DFS 进行「爆搜」。
而 DFS 有「使用全局变量维护」和「接收返回值处理」两种形式。
代码:
```Java
class Solution {
public int findTargetSumWays(int[] nums, int t) {
return dfs(nums, t, 0, 0);
}
int dfs(int[] nums, int t, int u, int cur) {
if (u == nums.length) {
return cur == t ? 1 : 0;
}
int left = dfs(nums, t, u + 1, cur + nums[u]);
int right = dfs(nums, t, u + 1, cur - nums[u]);
return left + right;
}
}
```
```Java
class Solution {
int ans = 0;
public int findTargetSumWays(int[] nums, int t) {
dfs(nums, t, 0, 0);
return ans;
}
void dfs(int[] nums, int t, int u, int cur) {
if (u == nums.length) {
ans += cur == t ? 1 : 0;
return;
}
dfs(nums, t, u + 1, cur + nums[u]);
dfs(nums, t, u + 1, cur - nums[u]);
}
}
```
* 时间复杂度:$O(2^n)$
* 空间复杂度:忽略递归带来的额外空间消耗。复杂度为 $O(1)$
---
### 记忆化搜索
不难发现,在 DFS 的函数签名中只有「数值下标 `u`」和「当前结算结果 `cur`」为可变参数,考虑将其作为记忆化容器的两个维度,返回值作为记忆化容器的记录值。
由于 `cur` 存在负权值,为了方便,我们这里不设计成静态数组,而是使用「哈希表」进行记录。
以上分析都在 [(题解)403. 青蛙过河](https://leetcode-cn.com/problems/frog-jump/solution/gong-shui-san-xie-yi-ti-duo-jie-jiang-di-74fw/) 完整讲过。
代码:
```Java
class Solution {
public int findTargetSumWays(int[] nums, int t) {
return dfs(nums, t, 0, 0);
}
Map<String, Integer> cache = new HashMap<>();
int dfs(int[] nums, int t, int u, int cur) {
String key = u + "_" + cur;
if (cache.containsKey(key)) return cache.get(key);
if (u == nums.length) {
cache.put(key, cur == t ? 1 : 0);
return cache.get(key);
}
int left = dfs(nums, t, u + 1, cur + nums[u]);
int right = dfs(nums, t, u + 1, cur - nums[u]);
cache.put(key, left + right);
return cache.get(key);
}
}
```
* 时间复杂度:$O(n * \sum_{i = 0}^{n - 1} abs(nums[i]))$
* 空间复杂度:忽略递归带来的额外空间消耗。复杂度为 $O(n * \sum_{i = 0}^{n - 1} abs(nums[i]))$
---
### 动态规划
能够以「递归」的形式实现动态规划(记忆化搜索),自然也能使用「递推」的方式进行实现。
根据记忆化搜索的分析,我们可以定义:
**$f[i][j]$ 代表考虑前 $i$ 个数,当前计算结果为 $j$ 的方案数,令 `nums` 下标从 $1$ 开始。**
那么 $f[n][target]$ 为最终答案,$f[0][0] = 1$ 为初始条件:代表不考虑任何数,凑出计算结果为 $0$ 的方案数为 $1$ 种。
根据每个数值只能搭配 $+/-$ 使用,可得状态转移方程:
$$f[i][j] = f[i - 1][j - nums[i - 1]] + f[i - 1][j + nums[i - 1]]$$
到这里,既有了「状态定义」和「转移方程」,又有了可以滚动下去的「有效值」(起始条件)。
距离我们完成所有分析还差最后一步。
当使用递推形式时,我们通常会使用「静态数组」来存储动规值,因此还需要考虑维度范围的:
* 第一维为物品数量:范围为 `nums` 数组长度
* 第二维为中间结果:令 `s` 为所有 `nums` 元素的总和(题目给定了 `nums[i]` 为非负数的条件,否则需要对 `nums[i]` 取绝对值再累加),那么中间结果的范围为 $[-s, s]$
因此,我们可以确定动规数组的大小。**同时在转移时,对第二维度的使用做一个 `s` 的右偏移,以确保「负权值」也能够被合理计算/存储。**
代码:
```Java
class Solution {
public int findTargetSumWays(int[] nums, int t) {
int n = nums.length;
int s = 0;
for (int i : nums) s += Math.abs(i);
if (Math.abs(t) > s) return 0;
int[][] f = new int[n + 1][2 * s + 1];
f[0][0 + s] = 1;
for (int i = 1; i <= n; i++) {
int x = nums[i - 1];
for (int j = -s; j <= s; j++) {
if ((j - x) + s >= 0) f[i][j + s] += f[i - 1][(j - x) + s];
if ((j + x) + s <= 2 * s) f[i][j + s] += f[i - 1][(j + x) + s];
}
}
return f[n][t + s];
}
}
```
* 时间复杂度:$O(n * \sum_{i = 0}^{n - 1} abs(nums[i]))$
* 空间复杂度:$O(n * \sum_{i = 0}^{n - 1} abs(nums[i]))$
---
### 动态规划(优化)
**在上述「动态规划」分析中,我们总是尝试将所有的状态值都计算出来,当中包含很多对「目标状态」不可达的“额外”状态值。**
即达成某些状态后,不可能再回到我们的「目标状态」。
例如当我们的 $target$ 不为 $-s$ 和 $s$ 时,$-s$ 和 $s$ 就是两个对「目标状态」不可达的“额外”状态值,到达 $-s$ 或 $s$ 已经使用所有数值,对 $target$ 不可达。
那么我们如何规避掉这些“额外”状态值呢?
我们可以从哪些数值使用哪种符号来分析,即划分为「负值部分」&「非负值部分」,令「负值部分」的绝对值总和为 $m$,即可得:
$$(s - m) - m = s - 2 * m = target$$
变形得:
$$m = \frac{s - target}{2}$$
问题转换为:**只使用 $+$ 运算符,从 `nums` 凑出 $m$ 的方案数。**
**这样「原问题的具体方案」和「转换问题的具体方案」具有一一对应关系:「转换问题」中凑出来的数值部分在实际计算中应用 $-$,剩余部分应用 $+$,从而实现凑出来原问题的 $target$ 值。**
另外,由于 `nums` 均为非负整数,因此我们需要确保 $s - target$ 能够被 $2$ 整除。
同时,由于问题转换为 **从 `nums` 中凑出 $m$ 的方案数,因此「状态定义」和「状态转移」都需要进行调整(01 背包求方案数):**
**定义 $f[i][j]$ 为从 `nums` 凑出总和「恰好」为 $j$ 的方案数。**
最终答案为 $f[n][m]$,$f[0][0] = 1$ 为起始条件:代表不考虑任何数,凑出计算结果为 $0$ 的方案数为 $1$ 种。
每个数值有「选」和「不选」两种决策,转移方程为:
$$f[i][j] = f[i - 1][j] + f[i - 1][j - nums[i - 1]]$$
代码:
```Java
class Solution {
public int findTargetSumWays(int[] nums, int t) {
int n = nums.length;
int s = 0;
for (int i : nums) s += Math.abs(i);
if (t > s || (s - t) % 2 != 0) return 0;
int m = (s - t) / 2;
int[][] f = new int[n + 1][m + 1];
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
int x = nums[i - 1];
for (int j = 0; j <= m; j++) {
f[i][j] += f[i - 1][j];
if (j >= x) f[i][j] += f[i - 1][j - x];
}
}
return f[n][m];
}
}
```
* 时间复杂度:$O(n * (\sum_{i = 0}^{n - 1} abs(nums[i]) - target))$
* 空间复杂度:$O(n * (\sum_{i = 0}^{n - 1} abs(nums[i]) - target))$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.494` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/495. 提莫攻击（简单）.md | 495. 提莫攻击 | https://leetcode-cn.com/problems/teemo-attacking/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-gteh/ | 简单 | [
"模拟"
] | 在《英雄联盟》的世界中,有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希(编者注:寒冰射手)进入中毒状态。
当提莫攻击艾希,艾希的中毒状态正好持续 `duration` 秒。
正式地讲,提莫在 `t` 发起发起攻击意味着艾希在时间区间 `[t, t + duration - 1]`(含 `t` 和 `t + duration - 1`)处于中毒状态。如果提莫在中毒影响结束 前 再次攻击,中毒状态计时器将会 重置 ,在新的攻击之后,中毒影响将会在 `duration` 秒后结束。
给你一个 非递减 的整数数组 `timeSeries`,其中 `timeSeries[i]` 表示提莫在 `timeSeries[i]` 秒时对艾希发起攻击,以及一个表示中毒持续时间的整数 `duration`。
返回艾希处于中毒状态的 **总** 秒数。
示例 1:
```
输入:timeSeries = [1,4], duration = 2
输出:4
解释:提莫攻击对艾希的影响如下:
- 第 1 秒,提莫攻击艾希并使其立即中毒。中毒状态会维持 2 秒,即第 1 秒和第 2 秒。
- 第 4 秒,提莫再次攻击艾希,艾希中毒状态又持续 2 秒,即第 4 秒和第 5 秒。
艾希在第 1、2、4、5 秒处于中毒状态,所以总中毒秒数是 4 。
```
示例 2:
```
输入:timeSeries = [1,2], duration = 2
输出:3
解释:提莫攻击对艾希的影响如下:
- 第 1 秒,提莫攻击艾希并使其立即中毒。中毒状态会维持 2 秒,即第 1 秒和第 2 秒。
- 第 2 秒,提莫再次攻击艾希,并重置中毒计时器,艾希中毒状态需要持续 2 秒,即第 2 秒和第 3 秒。
艾希在第 1、2、3 秒处于中毒状态,所以总中毒秒数是 3 。
```
提示:
* $1 <= timeSeries.length <= 10^4$
* $0 <= timeSeries[i], duration <= 10^7$
* timeSeries 按 非递减 顺序排列 | ### 模拟
题目已确保 $timeSeries$ 为非递减排序,按照顺序进行遍历处理即可。
我们使用 $ans$ 统计答案,使用 $last$ 记录上一次攻击的结束点,对于任意的 $timeSeries[i]$ 而言,假设其发起点为 $s = timeSeries[i]$,结束点为 $e = s + duration - 1$,针对 $last$ 和 $s$ 进行分情况讨论即可:
* $last < s$ :两次攻击不重合,则有 $ans += duration; last = e;$
* $last >= s$ :两次攻击重合,则有 $ans += e - last; last = e$
>注意:$last$ 作为上次的结束点,在处理 $timeSeries[i]$ 时,$last$ 是一个「已被统计」的存在,因此我们需要将其初始化为 $-1$(使用一个比 $0$ 小的数值作为哨兵),以确保当 $timeSeries[0] = 0$ 时,第 $0$ 秒能够被计数。
代码:
```Java
class Solution {
public int findPoisonedDuration(int[] timeSeries, int duration) {
int ans = 0, last = -1;
for (int s : timeSeries) {
int e = s + duration - 1;
ans += last < s ? duration : e - last;
last = e;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.495` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/496. 下一个更大元素 I（简单）.md | 496. 下一个更大元素 I | https://leetcode-cn.com/problems/next-greater-element-i/solution/gong-shui-san-xie-yi-ti-shuang-jie-bian-n6nwz/ | 简单 | [
"模拟",
"单调栈",
"哈希表"
] | 给你两个 没有重复元素 的数组 `nums1` 和 `nums2`,其中 `nums1` 是 `nums2` 的子集。
请你找出 `nums1` 中每个元素在 `nums2` 中的下一个比其大的值。
`nums1` 中数字 `x` 的下一个更大元素是指 `x` 在 `nums2` 中对应位置的右边的第一个比 `x` 大的元素。如果不存在,对应位置输出 $-1$ 。
示例 1:
```
输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
对于 num1 中的数字 4 ,你无法在第二个数组中找到下一个更大的数字,因此输出 -1 。
对于 num1 中的数字 1 ,第二个数组中数字1右边的下一个较大数字是 3 。
对于 num1 中的数字 2 ,第二个数组中没有下一个更大的数字,因此输出 -1 。
```
示例 2:
```
输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
对于 num1 中的数字 2 ,第二个数组中的下一个较大数字是 3 。
对于 num1 中的数字 4 ,第二个数组中没有下一个更大的数字,因此输出 -1 。
```
提示:
* 1 <= nums1.length <= nums2.length <= 1000
* 0 <= nums1[i], nums2[i] <= $10^4$
* nums1和nums2中所有整数 互不相同
* nums1 中的所有整数同样出现在 nums2 中 | ### 模拟
一个朴素的做法是直接根据题意进行模拟,对于每个 $ans[i]$ 而言,先找到 $nums1[i]$ 在 $nums2$ 的位置 $j$,然后接着往后找到最近一个比其大的数,如果 $j$ 走到结尾尚未出现合法的 $ans[i]$,则是 $-1$。
代码:
```Java
class Solution {
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
int j = 0;
while (j < m && nums1[i] != nums2[j]) j++;
while (j < m && nums1[i] >= nums2[j]) j++;
ans[i] = j < m ? nums2[j] : -1;
}
return ans;
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(n)$
---
### 单调栈
当题目出现「找到最近一个比其大的元素」的字眼时,自然会想到「单调栈」。
具体的,由于我们目标是找到某个数其在 $nums2$ 的右边中第一个比其大的数,因此我们可以对 $nums2$ 进行逆序遍历。
我们在遍历 $nums2$ 时,实时维护一个单调栈,当我们遍历到元素 $nums2[i]$ 时,可以先将栈顶中比 $nums2[i]$ 小的元素出栈,最终结果有两种可能:
1. 栈为空,说明 $nums2[i]$ 之前(右边)没有比其大的数;
2. 栈不为空, 此时栈顶元素为 $nums2[i]$ 在 $nums2$ 中(右边)最近的比其大的数。
再利用数组中数值各不相同,在遍历 $nums2$ 的同时,使用哈希表记录每个 $nums2[i]$ 对应目标值是多少即可。
代码:
```Java
class Solution {
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
Deque<Integer> d = new ArrayDeque<>();
Map<Integer, Integer> map = new HashMap<>();
for (int i = m - 1; i >= 0; i--) {
int x = nums2[i];
while (!d.isEmpty() && d.peekLast() <= x) d.pollLast();
map.put(x, d.isEmpty() ? -1 : d.peekLast());
d.addLast(x);
}
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = map.get(nums1[i]);
return ans;
}
}
```
* 时间复杂度:维护单调栈,每个元素最多入栈出栈一次,复杂度为 $O(m)$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n + m)$
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.496` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/497. 非重叠矩形中的随机点（中等）.md | 497. 非重叠矩形中的随机点 | https://leetcode.cn/problems/random-point-in-non-overlapping-rectangles/solution/by-ac_oier-mhi6/ | 中等 | [
"前缀和",
"二分",
"随机化"
] | 给定一个由非重叠的轴对齐矩形的数组 `rects`,其中 $rects[i] = [a_i, b_i, x_i, y_i]$ 表示 $(a_i, b_i)$ 是第 $i$ 个矩形的左下角点,$(x_i, y_i)$ 是第 $i$ 个矩形的右上角点。
设计一个算法来随机挑选一个被某一矩形覆盖的整数点。矩形周长上的点也算做是被矩形覆盖。所有满足要求的点必须等概率被返回。
在给定的矩形覆盖的空间内的任何整数点都有可能被返回。
请注意 ,整数点是具有整数坐标的点。
实现 `Solution` 类:
* `Solution(int[][] rects)` 用给定的矩形数组 `rects` 初始化对象。
* `int[] pick()` 返回一个随机的整数点 $[u, v]$ 在给定的矩形所覆盖的空间内。
示例 1:
```
输入:
["Solution", "pick", "pick", "pick", "pick", "pick"]
[[[[-2, -2, 1, 1], [2, 2, 4, 6]]], [], [], [], [], []]
输出:
[null, [1, -2], [1, -1], [-1, -2], [-2, -2], [0, 0]]
解释:
Solution solution = new Solution([[-2, -2, 1, 1], [2, 2, 4, 6]]);
solution.pick(); // 返回 [1, -2]
solution.pick(); // 返回 [1, -1]
solution.pick(); // 返回 [-1, -2]
solution.pick(); // 返回 [-2, -2]
solution.pick(); // 返回 [0, 0]
```
提示:
* $1 <= rects.length <= 100$
* $rects[i].length == 4$
* $-10^9 <= a_i < x_i <= 10^9$
* $-10^9 <= b_i < y_i <= 10^9$
* $x_i - a_i <= 2000$
* $y_i - b_i <= 2000$
* 所有的矩形不重叠。
* `pick` 最多被调用 $10^4$ 次。 | ### 前缀和 + 二分
为了方便,我们使用 `rs` 来代指 `rects`,定义某个矩阵内整数点的数量为「面积」。
一个朴素的想法是「先随机使用哪个矩形,再随机该矩形内的点」,其中后者是极其容易的,根据矩形特质,只需在该矩形的 `XY` 坐标范围内随机即可确保等概率,而前者(随机使用哪个矩形)为了确保是等概率,我们不能简单随机坐标,而需要结合面积来做。
具体的,我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),其中 $sum[i]$ 代表前 $i$ 个矩形的面积之和(即下标范围 $[0, i - 1]$ 的面积总和),最终 $sum[n]$ 为所有矩形的总面积,我们可以在 $[1, sum[n]]$ 范围内随机,假定随机到的值为 $val$,然后利用 `sum` 数组的具有单调性,进行「二分」,找到 $val$ 所在的矩形(每个矩形均会贡献面积,可看做是每个矩形在数轴 $[1, sum[n]]$ 内贡献一段长度为面积的连续段,我们二分是为了找到点 $val$ 所在的连续段是由哪个矩形所贡献),然后在该矩形中进行随机,得到最终的随机点。
代码:
```Java
class Solution {
int[][] rs;
int[] sum;
int n;
Random random = new Random();
public Solution(int[][] rects) {
rs = rects;
n = rs.length;
sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (rs[i - 1][2] - rs[i - 1][0] + 1) * (rs[i - 1][3] - rs[i - 1][1] + 1);
}
public int[] pick() {
int val = random.nextInt(sum[n]) + 1;
int l = 0, r = n;
while (l < r) {
int mid = l + r >> 1;
if (sum[mid] >= val) r = mid;
else l = mid + 1;
}
int[] cur = rs[r - 1];
int x = random.nextInt(cur[2] - cur[0] + 1) + cur[0], y = random.nextInt(cur[3] - cur[1] + 1) + cur[1];
return new int[]{x, y};
}
}
```
* 时间复杂度:令 $n$ 为给定的 `rs` 数组长度。初始化 `Solution` 时需要预处理前缀和数组,复杂度为 $O(n)$;每次 `pick` 时需要在矩形个数 $n$ 范围内进行二分,复杂度为 $O(\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.497` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/498. 对角线遍历（中等）.md | 498. 对角线遍历 | https://leetcode.cn/problems/diagonal-traverse/solution/by-ac_oier-yw5x/ | 中等 | [
"模拟"
] | 给你一个大小为 `m x n` 的矩阵 `mat`,请以对角线遍历的顺序,用一个数组返回这个矩阵中的所有元素。
示例 1:
```
输入:mat = [[1,2,3],[4,5,6],[7,8,9]]
输出:[1,2,4,7,5,3,6,8,9]
```
示例 2:
```
输入:mat = [[1,2],[3,4]]
输出:[1,2,3,4]
```
提示:
* $m == mat.length$
* $n == mat[i].length$
* $1 <= m, n <= 10^4$
* $1 <= m \times n <= 10^4$
* $-10^5 <= mat[i][j] <= 10^5$ | ### 模拟
根据题意进行模拟即可。
为了方便,令 `mat` 为 `g`,记 `g` 的行和宽分别为 $n$ 和 $m$。当前所在位置为 $(x, y)$,遍历方向使用 $dir$ 代指(当 $dir = 1$ 代表往右上方进行遍历,当 $dir = -1$ 代表往左下方进行遍历),使用 $idx$ 记录当前处理到的答案下标。
每次除了将当前格子放入答案(`ans[idx++]=g[x][y]`)以外,还需要结合 $dir$ 找到当前位置的右上方格子 $(x - 1, y + 1)$ 或是左下方格子 $(x + 1, y - 1)$,若下一目标位置「越界」并且还没搜索完整个矩阵,我们需要根据优先级来找「下一个发起点」的位置,并且翻转遍历方向。
具体的找「下一个发起点」的优先级为:
* 若当前遍历方向为往右上角,即 $dir = 1$,优先找 $(x, y + 1)$ 作为下一发起点,若越界,则找 $(x + 1, y)$ 作为下一发起点;
* 若当前遍历方向为往左下角,即 $dir = -1$,优先找 $(x + 1, y)$ 作为下一发起点,若越界,则找 $(x, y + 1)$ 作为下一发起点。
代码:
```Java
class Solution {
public int[] findDiagonalOrder(int[][] g) {
int n = g.length, m = g[0].length, cnt = n * m;
int[] ans = new int[cnt];
int x = 0, y = 0, dir = 1, idx = 0;
while (idx != cnt) {
ans[idx++] = g[x][y];
int nx = x, ny = y;
if (dir == 1) {
nx = x - 1; ny = y + 1;
} else {
nx = x + 1; ny = y - 1;
}
if (idx < cnt && (nx < 0 || nx >= n || ny < 0 || ny >= m)) {
if (dir == 1) {
nx = y + 1 < m ? x : x + 1;
ny = y + 1 < m ? y + 1 : y;
} else {
nx = x + 1 < n ? x + 1 : x;
ny = x + 1 < n ? y : y + 1;
}
dir *= -1;
}
x = nx; y = ny;
}
return ans;
}
}
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.498` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/491-500/500. 键盘行（简单）.md | 500. 键盘行 | https://leetcode-cn.com/problems/keyboard-row/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-zx6b/ | 简单 | [
"模拟",
"哈希表"
] | 给你一个字符串数组 `words`,只返回可以使用在 美式键盘 同一行的字母打印出来的单词。键盘如下图所示。
美式键盘 中:
* 第一行由字符 `"qwertyuiop"` 组成。
* 第二行由字符 `"asdfghjkl"` 组成。
* 第三行由字符 `"zxcvbnm"` 组成。
示例 1:
```
输入:words = ["Hello","Alaska","Dad","Peace"]
输出:["Alaska","Dad"]
```
示例 2:
```
输入:words = ["omk"]
输出:[]
```
示例 3:
```
输入:words = ["adsdf","sfd"]
输出:["adsdf","sfd"]
```
提示:
* 1 <= words.length <= 20
* 1 <= words[i].length <= 100
* words[i] 由英文字母(小写和大写字母)组成 | ### 模拟
根据题意,进行模拟即可。
先将键盘上的三行字母进行打表分类,依次检查 $words$ 中的单词中的每个字符是否都属于同一编号,若属于同一编号,则将其单词加入答案。
代码:
```Java
class Solution {
static String[] ss = new String[]{"qwertyuiop", "asdfghjkl", "zxcvbnm"};
static int[] hash = new int[26];
static {
for (int i = 0; i < ss.length; i++) {
for (char c : ss[i].toCharArray()) hash[c - 'a'] = i;
}
}
public String[] findWords(String[] words) {
List<String> list = new ArrayList<>();
out:for (String w : words) {
int t = -1;
for (char c : w.toCharArray()) {
c = Character.toLowerCase(c);
if (t == -1) t = hash[c - 'a'];
else if (t != hash[c - 'a']) continue out;
}
list.add(w);
}
return list.toArray(new String[list.size()]);
}
}
```
* 时间复杂度:$O(\sum_{i = 0}^{n - 1} words[i].length)$
* 空间复杂度:`toCharArray` 会拷贝新数组,不使用 `toCharArray`,使用 `charAt` 的话,复杂度为 $O(C)$,$C$ 为常数,固定为 $26$;否则复杂度为 $O(\sum_{i = 0}^{n - 1} words[i].length)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.500` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/502. IPO（困难）.md | 502. IPO | https://leetcode-cn.com/problems/next-greater-element-ii/solution/cong-po-su-jie-fa-de-jiao-du-qu-li-jie-d-trht/ | 困难 | [
"贪心",
"优先队列(堆)"
] | 假设 力扣(LeetCode)即将开始 IPO 。
为了以更高的价格将股票卖给风险投资公司,力扣 希望在 IPO 之前开展一些项目以增加其资本。
由于资源有限,它只能在 IPO 之前完成最多 k 个不同的项目。
帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。
给你 n 个项目。对于每个项目 i ,它都有一个纯利润 profits[i] ,和启动该项目需要的最小资本 capital[i] 。
最初,你的资本为 w 。当你完成一个项目时,你将获得纯利润,且利润将被添加到你的总资本中。
总而言之,从给定项目中选择 最多 k 个不同项目的列表,以 最大化最终资本 ,并输出最终可获得的最多资本。
答案保证在 32 位有符号整数范围内。
示例 1:
```
输入:k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]
输出:4
解释:
由于你的初始资本为 0,你仅可以从 0 号项目开始。
在完成后,你将获得 1 的利润,你的总资本将变为 1。
此时你可以选择开始 1 号或 2 号项目。
由于你最多可以选择两个项目,所以你需要完成 2 号项目以获得最大的资本。
因此,输出最后最大化的资本,为 0 + 1 + 3 = 4。
```
示例 2:
```
输入:k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]
输出:6
```
提示:
* 1 <= k <= $10^5$
* 0 <= w <= $10^9$
* n == profits.length
* n == capital.length
* 1 <= n <= $10^5$
* 0 <= profits[i] <= $10^4$
* 0 <= capital[i] <= $10^9$ | ### 贪心 + 优先队列(堆)
由于每完成一个任务都会使得总资金 `w` 增加或不变。因此对于所选的第 $i$ 个任务而言,应该在所有「未被选择」且启动资金不超过 `w` 的所有任务里面选利润最大的。
**可通过「归纳法」证明每次都在所有候选中选择利润最大的任务,可使得总资金最大。**
对于第 $i$ 次选择而言(当前所有的资金为 $w$),如果选择的任务利润为 $cur$,而实际可选的最大任务利润为 $max$( $cur <= max$ )。
将「选择 $cur$」调整为「选择 $max$」,结果不会变差:
1. 根据传递性,由 $cur <= max$ 可得 $w + cur <= w + max$,可推导出调整后的总资金不会变少;
2. 利用推论 $1$,由于总资金相比调整前没有变少,因此后面可选择的任务集合也不会变少。这意味着 **至少可以维持** 第 $i$ 次选择之后的所有原有选择。
至此,我们证明了将每次的选择调整为选择最大利润的任务,结果不会变差。
**当知道了「每次都应该在所有可选择的任务里选利润最大」的推论之后,再看看算法的具体流程。**
由于每完成一个任务总资金都会 增大/不变,因此所能覆盖的任务集合数量也随之 增加/不变 。
因此算法核心为「**每次决策前,将启动资金不超过当前总资金的任务加入集合,再在里面取利润最大的任务**」。
**「取最大」的过程可以使用优先队列(根据利润排序的大根堆),而「将启动资金不超过当前总资金的任务加入集合」的操作,可以利用总资金在整个处理过程递增,而先对所有任务进行预处理排序来实现。**
具体的,我们可以按照如下流程求解:
1. 根据 `profits` 和 `capital` 预处理出总的任务集合二元组,并根据「启动资金」进行升序排序;
2. 每次决策前,将所有的启动资金不超过 $w$ 的任务加入优先队列(根据利润排序的大根堆),然后从优先队列(根据利润排序的大根堆),将利润累加到 $w$;
3. 循环步骤 $2$,直到达到 $k$ 个任务,或者队列为空(当前资金不足以选任何任务)。
代码:
```Java
class Solution {
public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
int n = profits.length;
List<int[]> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
list.add(new int[]{capital[i], profits[i]});
}
Collections.sort(list, (a,b)->a[0]-b[0]);
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
int i = 0;
while (k-- > 0) {
while (i < n && list.get(i)[0] <= w) q.add(list.get(i++)[1]);
if (q.isEmpty()) break;
w += q.poll();
}
return w;
}
}
```
* 时间复杂度:构造出二元组数组并排序的复杂度为 $O(n\log{n})$;大根堆最多有 $n$ 个元素,使用大根堆计算答案的复杂度为 $O(k\log{n})$。整体复杂度为 $O(\max(n\log{n}, k\log{n}))$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.502` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/503. 下一个更大元素 II（中等）.md | 503. 下一个更大元素 II | https://leetcode-cn.com/problems/next-greater-element-ii/solution/cong-po-su-jie-fa-de-jiao-du-qu-li-jie-d-trht/ | 中等 | [
"单调栈"
] | 给定一个循环数组(最后一个元素的下一个元素是数组的第一个元素),输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序,这个数字之后的第一个比它更大的数,这意味着你应该循环地搜索它的下一个更大的数。如果不存在,则输出 -1。
示例 1:
```
输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2;
数字 2 找不到下一个更大的数;
第二个 1 的下一个最大的数需要循环搜索,结果也是 2。
``` | ### 单调栈解法
对于「找最近一个比当前值大/小」的问题,都可以使用单调栈来解决。
单调栈就是在栈的基础上维护一个栈内元素单调。
在理解单调栈之前,我们先回想一下「朴素解法」是如何解决这个问题的。
对于每个数而言,我们需要遍历其右边的数,直到找到比自身大的数,这是一个 $O(n^2)$ 的做法。
**之所以是 $O(n^2)$,是因为每次找下一个最大值,我们是通过「主动」遍历来实现的。**
而如果使用的是单调栈的话,可以做到 $O(n)$ 的复杂度,我们**将当前还没得到答案的下标暂存于栈内,从而实现「被动」更新答案。**
也就是说,栈内存放的永远是还没更新答案的下标。
具体的做法是:
每次将当前遍历到的下标存入栈内,**将当前下标存入栈内前,检查一下当前值是否能够作为栈内位置的答案(即成为栈内位置的「下一个更大的元素」),如果可以,则将栈内下标弹出。**
如此一来,我们便实现了「被动」更新答案,同时由于我们的弹栈和出栈逻辑,决定了我们**整个过程中栈内元素单调**。
还有一些编码细节,由于我们要找每一个元素的下一个更大的值,因此我们需要对原数组遍历两次,对遍历下标进行取余转换。
以及因为栈内存放的是还没更新答案的下标,可能会有位置会一直留在栈内(最大值的位置),因此我们要在处理前预设答案为 -1。而从实现那些没有下一个更大元素(不出栈)的位置的答案是 -1。
代码:
```java
class Solution {
public int[] nextGreaterElements(int[] nums) {
int n = nums.length;
int[] ans = new int[n];
Arrays.fill(ans, -1);
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n * 2; i++) {
while (!d.isEmpty() && nums[i % n] > nums[d.peekLast()]) {
int u = d.pollLast();
ans[u] = nums[i % n];
}
d.addLast(i % n);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 卡常小技巧
本题不需要用到这个技巧,但是还是介绍一下,可作为拓展。
我们可以使用静态数组来模拟栈,这样我们的代码将会更快一点:
```java
class Solution {
public int[] nextGreaterElements(int[] nums) {
int n = nums.length;
int[] ans = new int[n];
Arrays.fill(ans, -1);
// 使用数组模拟栈,hh 代表栈底,tt 代表栈顶
int[] d = new int[n * 2];
int hh = 0, tt = -1;
for (int i = 0; i < n * 2; i++) {
while (hh <= tt && nums[i % n] > nums[d[tt]]) {
int u = d[tt--];
ans[u] = nums[i % n];
}
d[++tt] = i % n;
}
return ans;
}
}
```
***
### 总结
要从逻辑上去理解为什么能用「单调栈」解决问题:
1. 我们希望将 $O(n^2)$ 算法优化为 $O(n)$ 算法,因此需要将「主动」获取答案转换为「被动」更新
2. 我们需要使用数据结构保持那些「尚未更新」的位置下标,由于题目要求的是找「下一个更大的元素」,因此使用栈来保存
3. 「被动」更新答案的逻辑导致了我们栈内元素单调 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.501` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/504. 七进制数（简单）.md | 504. 七进制数 | https://leetcode-cn.com/problems/base-7/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-2759/ | 简单 | [
"模拟"
] | 给定一个整数 `num`,将其转化为 $7$ 进制,并以字符串形式输出。
示例 1:
```
输入: num = 100
输出: "202"
```
示例 2:
```
输入: num = -7
输出: "-10"
```
提示:
* $-10^7 <= num <= 10^7$ | ### 模拟
今天是个特别的日子,可惜是个简单题 QWQ
按照通用的进制转换方式进行模拟即可。
代码:
```Java
class Solution {
public String convertToBase7(int n) {
boolean flag = n < 0;
if (flag) n = -n;
StringBuilder sb = new StringBuilder();
do {
sb.append(n % 7);
n /= 7;
} while (n != 0);
sb.reverse();
return flag ? "-" + sb.toString() : sb.toString();
}
}
```
* 时间复杂度:$O(\log{|n|})$
* 空间复杂度:$O(\log{|n|})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.504` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/501-510/506. 相对名次（简单）.md | 506. 相对名次 | https://leetcode-cn.com/problems/relative-ranks/solution/gong-shui-san-xie-jian-dan-pai-xu-mo-ni-cmuzj/ | 简单 | [
"排序",
"模拟"
] | 给你一个长度为 `n` 的整数数组 `score`,其中 `score[i]` 是第 $i$ 位运动员在比赛中的得分。所有得分都**互不相同**。
运动员将根据得分**决定名次**,其中名次第 `1` 的运动员得分最高,名次第 `2` 的运动员得分第 `2` 高,依此类推。运动员的名次决定了他们的获奖情况:
* 名次第 `1` 的运动员获金牌 `"Gold Medal"` 。
* 名次第 `2` 的运动员获银牌 `"Silver Medal"`。
* 名次第 `3` 的运动员获铜牌 `"Bronze Medal"`。
* 从名次第 `4` 到第 `n` 的运动员,只能获得他们的名次编号(即,名次第 x 的运动员获得编号 `"x"`)。
使用长度为 `n` 的数组 `answer` 返回获奖,其中 `answer[i]` 是第 `i` 位运动员的获奖情况。
示例 1:
```
输入:score = [5,4,3,2,1]
输出:["Gold Medal","Silver Medal","Bronze Medal","4","5"]
解释:名次为 [1st, 2nd, 3rd, 4th, 5th] 。
```
示例 2:
```
输入:score = [10,3,8,9,4]
输出:["Gold Medal","5","Bronze Medal","Silver Medal","4"]
解释:名次为 [1st, 5th, 3rd, 2nd, 4th] 。
```
提示:
* $n == score.length$
* $1 <= n <= 10^4$
* $0 <= score[i] <= 10^6$
* $score$ 中的所有值 互不相同 | ### 模拟
根据题意,我们可以先对 `score` 数组进行拷贝并排序,利用分数各不相同,对排序数组中分值进行名次编号(存入哈希表),再利用名次编号构造答案。
代码:
```Java
class Solution {
String[] ss = new String[]{"Gold Medal", "Silver Medal", "Bronze Medal"};
public String[] findRelativeRanks(int[] score) {
int n = score.length;
String[] ans = new String[n];
int[] clone = score.clone();
Arrays.sort(clone);
Map<Integer, Integer> map = new HashMap<>();
for (int i = n - 1; i >= 0; i--) map.put(clone[i], n - 1 - i);
for (int i = 0; i < n; i++) {
int rank = map.get(score[i]);
ans[i] = rank < 3 ? ss[rank] : String.valueOf(rank + 1);
}
return ans;
}
}
```
* 时间复杂度:拷贝 `score` 数组的复杂度为 $O(n)$;对拷贝数组进行排序的复杂度为 $O(n\log{n})$;构造哈希表的复杂度为 $O(n)$;利用哈希表构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.506` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |