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/1331-1340/1332. 删除回文子序列（简单）.md | 1332. 删除回文子序列 | https://leetcode-cn.com/problems/the-k-weakest-rows-in-a-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-7okx/ | 简单 | [
"双指针",
"模拟"
] | 给你一个字符串 `s`,它仅由字母 `'a'` 和 `'b'` 组成。每一次删除操作都可以从 `s` 中删除一个回文 **子序列**。
返回删除给定字符串中所有字符(字符串为空)的最小删除次数。
「子序列」定义:如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到,那么这个字符串就是原字符串的一个子序列。
「回文」定义:如果一个字符串向后和向前读是一致的,那么这个字符串就是一个回文。
示例 1:
```
输入:s = "ababa"
输出:1
解释:字符串本身就是回文序列,只需要删除一次。
```
示例 2:
```
输入:s = "abb"
输出:2
解释:"abb" -> "bb" -> "".
先删除回文子序列 "a",然后再删除 "bb"。
```
示例 3:
```
输入:s = "baabb"
输出:2
解释:"baabb" -> "b" -> "".
先删除回文子序列 "baab",然后再删除 "b"。
```
提示:
* $1 <= s.length <= 1000$
* `s` 仅包含字母 `'a'` 和 `'b'` | ### 双指针
由于 `s` 只有字母 `a` 和 `b`,并且删除的是「子序列」,因此最大的删除次数为 $2$(先删除所有的 `a`,再删除所有的 `b`)。
同时 `s` 本身不为空串(不存在删除次数为 $0$ 的情况),因此如果我们不能一次删除的话(`s` 本身为回文),只能通过 $2$ 次进行删除。
代码:
```Java
class Solution {
public int removePalindromeSub(String s) {
int n = s.length();
int i = 0, j = n - 1;
while (i < j) {
if (s.charAt(i) != s.charAt(j)) return 2;
i++; j--;
}
return 1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1332` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1331-1340/1334. 阈值距离内邻居最少的城市（中等）.md | 1334. 阈值距离内邻居最少的城市 | https://leetcode.cn/problems/find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance/solutions/2526052/gong-shui-san-xie-han-gai-suo-you-cun-tu-svq7/ | 中等 | [
"最短路",
"图"
] | 有 $n$ 个城市,按从 $0$ 到 $n-1$ 编号。
给你一个边数组 `edges`,其中 $edges[i] = [from_{i}, to_{i}, weight_{i}]$ 代表 $from_{i}$ 和 $to_{i}$ 两个城市之间的双向加权边,距离阈值是一个整数 `distanceThreshold`。
返回能通过某些路径到达其他城市数目最少、且路径距离最大为 `distanceThreshold` 的城市。如果有多个这样的城市,则返回编号最大的城市。
注意,连接城市 $i$ 和 $j$ 的路径的距离等于沿该路径的所有边的权重之和。
示例 1:
```
输入:n = 4, edges = [[0,1,3],[1,2,1],[1,3,4],[2,3,1]], distanceThreshold = 4
输出:3
解释:城市分布图如上。
每个城市阈值距离 distanceThreshold = 4 内的邻居城市分别是:
城市 0 -> [城市 1, 城市 2]
城市 1 -> [城市 0, 城市 2, 城市 3]
城市 2 -> [城市 0, 城市 1, 城市 3]
城市 3 -> [城市 1, 城市 2]
城市 0 和 3 在阈值距离 4 以内都有 2 个邻居城市,但是我们必须返回城市 3,因为它的编号最大。
```
示例 2:
```
输入:n = 5, edges = [[0,1,2],[0,4,8],[1,2,3],[1,4,2],[2,3,1],[3,4,1]], distanceThreshold = 2
输出:0
解释:城市分布图如上。
每个城市阈值距离 distanceThreshold = 2 内的邻居城市分别是:
城市 0 -> [城市 1]
城市 1 -> [城市 0, 城市 4]
城市 2 -> [城市 3, 城市 4]
城市 3 -> [城市 2, 城市 4]
城市 4 -> [城市 1, 城市 2, 城市 3]
城市 0 在阈值距离 2 以内只有 1 个邻居城市。
```
提示:
* $2 <= n <= 100$
* $1 <= edges.length <= \frac{n \times (n - 1)}{2}$
* $edges[i].length = 3$
* $0 <= from_{i} < to_{i} < n$
* $1 <= weight_{i}, distanceThreshold <= 10^4$
* 所有 $(from_{i}, to_{i})$ 都是不同的。 | ### 基本分析
若能预处理图中任意两点 $i$ 和 $j$ 的最短距离 `dist`,那么统计每个点 $i$ 在图中有多少满足 $dist[j] \leq distanceThreshold$ 的点 $j$ 即为答案。
于是问题转换为:**如何求解给定图中,任意两点的最短距离**。
---
### 存图
在学习最短路之前,我们先搞懂众多图论问题的前置 🧀 :存图。
为了方便,我们约定 $n$ 为点数,$m$ 为边数。
根据点和边的数量级关系,可以将图分成如下两类:
* 稠密图:边数较多,边数接近于点数的平方,即 $m \approx n^2$
* 稀疏图:边数较少,边数接近于点数,即 $m \approx n$
同时,根据「稠密图」还是「稀疏图」,我们有如下几种存图方式:
##### 1. 邻接矩阵(稠密图)
这是一种使用二维矩阵来进行存图的方式。
```Java
// w[a][b] = c 代表从 a 到 b 有权重为 c 的边
int[][] g = new int[N][N];
// 加边操作
void add(int a, int b, int c) {
g[a][b] = c;
}
```
##### 2. 邻接表(稀疏图)
邻接表又叫**链式前向星**,是另一种常见的存图方式,实现代码与「使用数组存储单链表」一致(头插法)。
```Java
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
// 加边操作
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
```
首先 `idx` 是用来对边进行编号的,然后对存图用到的几个数组作简单解释:
* `he` 数组:存储是某个节点所对应的边的集合(链表)的头结点;
* `e` 数组:由于访问某一条边指向的节点;
* `ne` 数组:由于是以链表的形式进行存边,该数组就是用于找到下一条边;
* `w` 数组:用于记录某条边的权重为多少。
当我们想要遍历所有由 `a` 点发出的边时,可以使用如下方式:
```Java
for (int i = he[a]; i != -1; i = ne[i]) {
int b = e[i], c = w[i]; // 存在由 a 指向 b 的边,权重为 c
}
```
##### 3. 类
这是最简单,但使用频率最低的存图方式。
只有当我们需要确保某个操作复杂度为严格 $O(m)$ 时,才会考虑使用。
具体的,建立一个类来记录有向边信息:
```Java
class Edge {
// 代表从 a 到 b 有一条权重为 c 的边
int a, b, c;
Edge(int _a, int _b, int _c) {
a = _a; b = _b; c = _c;
}
}
```
随后,使用诸如 `List` 的容器,存起所有边对象。在需要遍历所有边时,对容器进行进行遍历:
```Java
List<Edge> es = new ArrayList<>();
...
for (Edge e : es) {
...
}
```
综上,第 $3$ 种方式,往往是 `OJ` 给我们边信息的方式,我们自己几乎不会用这种方式建图。
实际运用中,熟练掌握「如何根据点和边的数量级关系,来决定使用邻接矩阵(稠密图)还是邻接表(稀疏图)」即可。
---
### Floyd(邻接矩阵)
`Floyd` 算法作为「多源汇最短路」算法,对于本题尤其适合。
`Floyd` 算法基于「动态规划」,其原始三维状态定义为 $dist[p][i][j]$,表示「所有从点 $i$ 到点 $j$,且允许经过点集 $(1, ... , p)$ 的路径」中的最短距离。
状态转移方程:
$$
dist[p][i][j] = \min(dist[p - 1][i][j], dist[p - 1][i][p] + dist[p - 1][p][j])
$$
$dist[p - 1][i][j]$ 代表从 $i$ 到 $j$ 但必然不经过点 $p$ 的路径,$dist[p - 1][i][p] + dist[p - 1][p][j]$ 代表必然经过点 $p$ 的路径,两者中取较小值更新 $dist[p][i][j]$。
不难发现任意的 $dist[p][X][Y]$ 依赖于 $dist[p - 1][X][Y]$,可采用「滚动数组」的方式进行优化。
将 `dist` 声明为二维数组,$dist[i][j]$ 代表从点 $i$ 到点 $j$ 的最短距离,并采取 [枚举中转点 - 枚举起点 - 枚举终点] 三层循环的方式更新 $dist[i][j]$。
如此一来,跑一遍 `Floyd` 算法便可得出任意两点的最短距离。
通过上述推导,不难发现,我们并没提及边权的正负问题,因此 `Floyd` 算法对边权的正负没有限制要求(可处理正负权边的图),且能利用 `Floyd` 算法可能够对图中负环进行判定。
Java 代码:
```Java
class Solution {
public int findTheCity(int n, int[][] edges, int distanceThreshold) {
int[][] g = new int[n][n];
// 初始化邻接矩阵
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = i == j ? 0 : 0x3f3f3f3f;
}
}
// 存图
for (int[] e : edges) {
int a = e[0], b = e[1], c = e[2];
g[a][b] = g[b][a] = Math.min(g[a][b], c);
}
// 最短路
floyd(g);
// 统计答案
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
int cur = 0;
for (int j = 0; j < n; j++) {
if (i != j && g[i][j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
void floyd(int[][] g) {
int n = g.length;
// floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作
for (int p = 0; p < n; p++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = Math.min(g[i][j], g[i][p] + g[p][j]);
}
}
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
vector<vector<int>> g(n, vector<int>(n, 0x3f3f3f3f));
// 初始化邻接矩阵
for (int i = 0; i < n; i++) g[i][i] = 0;
// 存图
for (const auto& e : edges) {
int a = e[0], b = e[1], c = e[2];
g[a][b] = g[b][a] = min(g[a][b], c);
}
// 最短路
floyd(g);
// 统计答案
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
int cur = 0;
for (int j = 0; j < n; j++) {
if (i != j && g[i][j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
void floyd(vector<vector<int>>& g) {
int n = g.size();
// floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作
for (int p = 0; p < n; p++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = min(g[i][j], g[i][p] + g[p][j]);
}
}
}
}
};
```
Python 代码:
```Python
class Solution:
def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:
def floyd(g: List[List[int]]) -> None:
n = len(g)
# floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作
for p in range(n):
for i in range(n):
for j in range(n):
g[i][j] = min(g[i][j], g[i][p] + g[p][j])
g = [[float('inf')] * n for _ in range(n)]
# 初始化邻接矩阵
for i in range(n):
g[i][i] = 0
# 存图
for a, b, c in edges:
g[a][b] = g[b][a] = min(g[a][b], c)
# 最短路
floyd(g)
# 统计答案
ans, cnt = -1, n + 10
for i in range(n):
cur = sum(1 for j in range(n) if i != j and g[i][j] <= distanceThreshold)
if cur <= cnt:
cnt, ans = cur, i
return ans
```
TypeScript 代码:
```TypeScript
function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
const floyd = function (g: number[][]): void {
const n = g.length;
// floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作
for (let p = 0; p < n; p++) {
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
g[i][j] = Math.min(g[i][j], g[i][p] + g[p][j]);
}
}
}
}
const g = Array.from({ length: n }, () => Array(n).fill(0x3f3f3f3f));
// 初始化邻接矩阵
for (let i = 0; i < n; i++) g[i][i] = 0;
// 存图
for (const [a, b, c] of edges) g[a][b] = g[b][a] = Math.min(g[a][b], c);
// 最短路
floyd(g);
// 统计答案
let ans = -1, cnt = n + 10;
for (let i = 0; i < n; i++) {
let cur = 0;
for (let j = 0; j < n; j++) {
if (i !== j && g[i][j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
};
```
* 时间复杂度:初始化邻接矩阵和建图复杂度为 $O(n^2 + m)$;`floyd` 算法复杂度为 $O(n^3)$;统计答案复杂度为 $O(n^2)$;整体复杂度为 $O(n^3 + m)$
* 空间复杂度:$O(n^2)$
---
### 朴素 Dijkstra(邻接矩阵)
最为经典的「单源最短路」算法,通常搭配「邻接矩阵」使用,应用在边数较多的“稠密图”上。
朴素 `Dijkstra` 算法基于「贪心」,通过维护一维的距离数组 `dist` 实现,$dist[i]$ 表示从源点出发到点 $i$ 的最短距离。
朴素 `Dijkstra` 算法在每一次迭代中,都选择 `dist` 中值最小的点进行松弛操作,逐渐扩展最短路径范围。
Java 代码:
```Java
class Solution {
public int findTheCity(int n, int[][] edges, int distanceThreshold) {
int[][] g = new int[n][n];
// 初始化邻接矩阵
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g[i][j] = i == j ? 0 : 0x3f3f3f3f;
}
}
// 存图
for (int[] e : edges) {
int a = e[0], b = e[1], c = e[2];
g[a][b] = g[b][a] = Math.min(g[a][b], c);
}
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
// 单源最短路
int[] dist = dijkstra(g, i);
int cur = 0;
for (int j = 0; j < n; j++) {
if (i != j && dist[j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
int[] dijkstra(int[][] g, int x) {
int n = g.length;
// 起始先将所有的点标记为「未更新」和「距离为正无穷」
boolean[] vis = new boolean[n];
int[] dist = new int[n];
Arrays.fill(dist, 0x3f3f3f3f);
// 只有起点最短距离为 0
dist[x] = 0;
// 有多少个点就迭代多少次
for (int k = 0; k < n; k++) {
// 每次找到「最短距离最小」且「未被更新」的点 t
int t = -1;
for (int i = 0; i < n; i++) {
if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;
}
// 标记点 t 为已更新
vis[t] = true;
// 用点 t 的「最小距离」更新其他点
for (int i = 0; i < n; i++) dist[i] = Math.min(dist[i], dist[t] + g[t][i]);
}
return dist;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
vector<vector<int>> g(n, vector<int>(n, 0x3f3f3f3f));
// 初始化邻接矩阵
for (int i = 0; i < n; i++) g[i][i] = 0;
// 存图
for (const auto& e : edges) {
int a = e[0], b = e[1], c = e[2];
g[a][b] = g[b][a] = min(g[a][b], c);
}
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
// 单源最短路
vector<int> dist = dijkstra(g, i);
int cur = count_if(dist.begin(), dist.end(), [distanceThreshold](int d) { return d <= distanceThreshold; });
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
vector<int> dijkstra(const vector<vector<int>>& g, int x) {
int n = g.size();
vector<bool> vis(n, false);
vector<int> dist(n, 0x3f3f3f3f);
// 只有起点最短距离为 0
dist[x] = 0;
// 有多少个点就迭代多少次
for (int k = 0; k < n; k++) {
// 每次找到「最短距离最小」且「未被更新」的点 t
int t = -1;
for (int i = 0; i < n; i++) {
if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;
}
// 标记点 t 为已更新
vis[t] = true;
// 用点 t 的「最小距离」更新其他点
for (int i = 0; i < n; i++) dist[i] = min(dist[i], dist[t] + g[t][i]);
}
return dist;
}
};
```
Python 代码:
```Python
class Solution:
def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:
def dijkstra(g, x):
n = len(g)
vis = [False] * n
dist = [float('inf')] * n
# 只有起点最短距离为 0
dist[x] = 0
# 有多少个点就迭代多少次
for k in range(n):
# 每次找到「最短距离最小」且「未被更新」的点 t
t = min((i for i in range(n) if not vis[i]), key=lambda i: dist[i])
# 标记点 t 为已更新
vis[t] = True
# 用点 t 的「最小距离」更新其他点
for i in range(n):
dist[i] = min(dist[i], dist[t] + g[t][i])
return dist
g = [[float('inf')] * n for _ in range(n)]
# 初始化邻接矩阵
for i in range(n):
g[i][i] = 0
# 存图
for a, b, c in edges:
g[a][b] = g[b][a] = min(g[a][b], c)
ans, cnt = -1, n + 10
for i in range(n):
# 单源最短路
dist = dijkstra(g, i)
cur = sum(1 for j in range(n) if i != j and dist[j] <= distanceThreshold)
if cur <= cnt:
cnt, ans = cur, i
return ans
```
TypeScript 代码:
```TypeScript
function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
const dijkstra = function (g: number[][], x: number): number[] {
const n = g.length;
const vis = Array(n).fill(false), dist = Array(n).fill(0x3f3f3f3f);
// 只有起点最短距离为 0
dist[x] = 0;
// 有多少个点就迭代多少次
for (let k = 0; k < n; k++) {
// 每次找到「最短距离最小」且「未被更新」的点 t
let t = -1;
for (let i = 0; i < n; i++) {
if (!vis[i] && (t === -1 || dist[i] < dist[t])) t = i;
}
// 标记点 t 为已更新
vis[t] = true;
// 用点 t 的「最小距离」更新其他点
for (let i = 0; i < n; i++) dist[i] = Math.min(dist[i], dist[t] + g[t][i]);
}
return dist;
}
const g = Array.from({ length: n }, () => Array(n).fill(0x3f3f3f3f));
// 初始化邻接矩阵
for (let i = 0; i < n; i++) g[i][i] = 0;
// 存图
for (const [a, b, c] of edges) g[a][b] = g[b][a] = Math.min(g[a][b], c);
let ans = -1, cnt = n + 10;
for (let i = 0; i < n; i++) {
// 单源最短路
const dist = dijkstra(g, i);
const cur = dist.filter(d => d <= distanceThreshold).length;
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
};
```
* 时间复杂度:初始化邻接矩阵和建图复杂度为 $O(n^2 + m)$;统计答案时,共执行 $n$ 次朴素 `dijkstra` 算法,朴素 `dijkstra` 复杂度为 $O(n^2)$,总复杂度为 $O(n^3)$。整体复杂度为 $O(n^3 + m)$
* 空间复杂度:$O(n^2)$
---
### 堆优化 Dijkstra(邻接表)
堆优化 `Dijkstra` 算法与朴素 `Dijkstra` 算法都是「单源最短路」算法。
堆优化 `Dijkstra` 算法通过数据结构「优先队列(堆)」来优化朴素 `Dijkstra` 中的“找 `dist` 中值最小的点”的过程。
相比于复杂度与边数无关的 $O(n^2)$ 朴素 `Dijkstra` 算法,复杂度与边数相关的 $O(m\log{n})$ 堆优化 `Dijkstra` 算法更适合边较少的“稀疏图”。
Java 代码:
```Java
class Solution {
int N = 110, M = N * N, INF = 0x3f3f3f3f, idx, n;
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
public int findTheCity(int _n, int[][] edges, int distanceThreshold) {
n = _n;
// 初始化链表头
Arrays.fill(he, -1);
// 存图
for (int[] e : edges) {
int a = e[0], b = e[1], c = e[2];
add(a, b, c); add(b, a, c);
}
// 统计答案
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
// 单源最短路
int[] dist = dijkstra(i);
int cur = 0;
for (int j = 0; j < n; j++) {
if (i != j && dist[j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
int[] dijkstra(int x) {
// 起始先将所有的点标记为「未更新」和「距离为正无穷」
int[] dist = new int[n];
Arrays.fill(dist, 0x3f3f3f3f);
boolean[] vis = new boolean[n];
dist[x] = 0;
// 使用「优先队列」存储所有可用于更新的点
// 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);
q.add(new int[]{x, 0});
while (!q.isEmpty()) {
// 每次从「优先队列」中弹出
int[] poll = q.poll();
int u = poll[0], step = poll[1];
// 如果弹出的点被标记「已更新」,则跳过
if (vis[u]) continue;
// 标记该点「已更新」,并使用该点更新其他点的「最短距离」
vis[u] = true;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] <= dist[u] + w[i]) continue;
dist[j] = dist[u] + w[i];
q.add(new int[]{j, dist[j]});
}
}
return dist;
}
}
```
C++ 代码:
```C++
class Solution {
public:
static const int N = 110, M = N * N;
int he[N], e[M], ne[M], w[M], idx, n, INF = 0x3f3f3f3f;
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
int findTheCity(int _n, vector<vector<int>>& edges, int distanceThreshold) {
n = _n;
// 初始化链表头
fill(he, he + n, -1);
// 存图
for (const auto& e : edges) {
int a = e[0], b = e[1], c = e[2];
add(a, b, c); add(b, a, c);
}
// 统计答案
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
// 单源最短路
vector<int> dist = dijkstra(i);
int cur = count_if(dist.begin(), dist.end(), [distanceThreshold](int d) { return d <= distanceThreshold; });
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
vector<int> dijkstra(int x) {
// 起始先将所有的点标记为「未更新」和「距离为正无穷」
vector<int> dist(n, INF);
vector<bool> vis(n, false);
dist[x] = 0;
// 使用「优先队列」存储所有可用于更新的点
// 以 (到起点的距离, 点编号) 进行存储,优先弹出「最短距离」较小的点
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
q.push({0, x});
while (!q.empty()) {
// 每次从「优先队列」中弹出
auto [step, u] = q.top();
q.pop();
// 如果弹出的点被标记「已更新」,则跳过
if (vis[u]) continue;
// 标记该点「已更新」,并使用该点更新其他点的「最短距离」
vis[u] = true;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] <= dist[u] + w[i]) continue;
dist[j] = dist[u] + w[i];
q.push({dist[j], j});
}
}
return dist;
}
};
```
Python 代码:
```Python
import heapq
class Solution:
def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:
N, M, INF, idx = 110, 110 * 110, float('inf'), 0
he, e, ne, w = [-1] * N, [0] * M, [0] * M, [0] * M
def add(a, b, c):
nonlocal idx
e[idx] = b
ne[idx] = he[a]
w[idx] = c
he[a] = idx
idx += 1
def dijkstra(x):
# 起始先将所有的点标记为「未更新」和「距离为正无穷」
dist = [float('inf')] * n
vis = [False] * n
dist[x] = 0
# 使用「优先队列」存储所有可用于更新的点
# 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点
q = [(0, x)]
heapq.heapify(q)
while q:
# 每次从「优先队列」中弹出
step, u = heapq.heappop(q)
# 如果弹出的点被标记「已更新」,则跳过
if vis[u]: continue
# 标记该点「已更新」,并使用该点更新其他点的「最短距离」
vis[u] = True
i = he[u]
while i != -1:
j, c = e[i], w[i]
i = ne[i]
if dist[j] <= dist[u] + c: continue
dist[j] = dist[u] + c
heapq.heappush(q, (dist[j], j))
return dist
# 初始化链表头
he = [-1] * N
# 存图
for a, b, c in edges:
add(a, b, c)
add(b, a, c)
# 统计答案
ans, cnt = -1, n + 10
for i in range(n):
# 单源最短路
dist = dijkstra(i)
cur = sum(1 for j in range(n) if i != j and dist[j] <= distanceThreshold)
if cur <= cnt:
cnt, ans = cur, i
return ans
```
* 时间复杂度:初始化邻接表和建图复杂度为 $O(n + m)$;统计答案时,共执行 $n$ 次堆优化 `dijkstra` 算法,堆优化 `dijkstra` 复杂度为 $O(m\log{n})$,总复杂度为 $O(nm\log{n})$。整体复杂度为 $O(nm\log{n})$
* 空间复杂度:$O(n + m)$
---
### Bellman Ford(类)
虽然题目规定了不存在「负权边」,但我们仍然可以使用可以在「负权图中求最短路」的 `Bellman Ford` 进行求解,该算法也是「单源最短路」算法,复杂度为 $O(n \times m)$。
通常为了确保 $O(n \times m)$,可以单独建一个类代表边,将所有边存入集合中,在 $n$ 次松弛操作中直接对边集合进行遍历。
由于本题边数量级为 $n^2$,共对 $n$ 个点执行 `Bellman Ford` 算法,因此整体会去到 $O(n^4)$,有 `TLE` 风险。
Java 代码:
```Java
class Solution {
int n;
public int findTheCity(int _n, int[][] edges, int distanceThreshold) {
n = _n;
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
int[] dist = bf(edges, i);
int cur = 0;
for (int j = 0; j < n; j++) {
if (i != j && dist[j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
int[] bf(int[][] edges, int x) {
int[] dist = new int[n];
// 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0
Arrays.fill(dist, 0x3f3f3f3f);
dist[x] = 0;
// 有多少个点就迭代多少次
for (int k = 0; k < n; k++) {
// 每次都使用上一次迭代的结果,执行松弛操作
int[] prev = dist.clone();
for (int[] e : edges) {
int a = e[0], b = e[1], c = e[2];
dist[b] = Math.min(dist[b], prev[a] + c);
dist[a] = Math.min(dist[a], prev[b] + c);
}
}
return dist;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
vector<int> dist = bf(edges, i, n);
int cur = 0;
for (int j = 0; j < n; j++) {
if (i != j && dist[j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
vector<int> bf(vector<vector<int>>& edges, int x, int n) {
// 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0
vector<int> dist(n, 0x3f3f3f3f);
dist[x] = 0;
// 有多少个点就迭代多少次
for (int k = 0; k < n; k++) {
// 每次都使用上一次迭代的结果,执行松弛操作
vector<int> prev = dist;
for (const auto& e : edges) {
int a = e[0], b = e[1], c = e[2];
dist[b] = min(dist[b], prev[a] + c);
dist[a] = min(dist[a], prev[b] + c);
}
}
return dist;
}
};
```
Python 代码:
```Python
class Solution:
def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:
def bf(edges: List[List[int]], x: int, n: int) -> List[int]:
# 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0
dist = [float('inf')] * n
dist[x] = 0
# 有多少个点就迭代多少次
for k in range(n):
# 每次都使用上一次迭代的结果,执行松弛操作
prev = dist.copy()
for a, b, c in edges:
dist[b] = min(dist[b], prev[a] + c)
dist[a] = min(dist[a], prev[b] + c)
return dist
ans, cnt = -1, n + 10
for i in range(n):
dist = bf(edges, i, n)
cur = sum(1 for j in range(n) if i != j and dist[j] <= distanceThreshold)
if cur <= cnt:
cnt, ans = cur, i
return ans
```
TypeScript 代码:
```TypeScript
function findTheCity(n: number, edges: number[][], distanceThreshold: number): number {
const bf = function(x: number): number[] {
// 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0
const dist = new Array(n).fill(0x3f3f3f3f);
dist[x] = 0;
// 有多少个点就迭代多少次
for (let k = 0; k < n; k++) {
// 每次都使用上一次迭代的结果,执行松弛操作
const prev = dist.slice();
for (const e of edges) {
const a = e[0], b = e[1], c = e[2];
dist[b] = Math.min(dist[b], prev[a] + c);
dist[a] = Math.min(dist[a], prev[b] + c);
}
}
return dist;
}
let ans = -1, cnt = n + 10;
for (let i = 0; i < n; i++) {
const dist = bf(i);
let cur = 0;
for (let j = 0; j < n; j++) {
if (i !== j && dist[j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
};
```
* 时间复杂度:统计答案时,共执行 $n$ 次 `Bellman Ford` 算法, `Bellman Ford` 复杂度为 $O(nm)$,总复杂度为 $O(n^2 \times m)$。整体复杂度为 $O(n^2 \times m)$
* 空间复杂度:$O(n + m)$
---
### SPFA(邻接表)
`SPFA` 也是一类能够处理「负权边」的单源最短路算法。
最坏情况下,复杂度为 $O(n \times m)$,在特定情况下,其效率优于 `Dijkstra` 算法,近似 $O(m)$。
基本执行流程如下:
1. 用双端队列来维护待更新节点,初始将源点放入队列
2. 每次从队列头中取出一个节点,对其所有相邻节点执行松弛操作
1. 若某个相邻节点的最短距离发生了更新,且该节点不在队列中,将它加入队列中
3. 重复以上步骤,直到队列为空
Java 代码:
```Java
class Solution {
int N = 110, M = N * N, INF = 0x3f3f3f3f, idx, n;
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
public int findTheCity(int _n, int[][] edges, int distanceThreshold) {
n = _n;
// 初始化链表头
Arrays.fill(he, -1);
// 存图
for (int[] e : edges) {
int a = e[0], b = e[1], c = e[2];
add(a, b, c); add(b, a, c);
}
// 统计答案
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
// 单源最短路
int[] dist = spfa(i);
int cur = 0;
for (int j = 0; j < n; j++) {
if (i != j && dist[j] <= distanceThreshold) cur++;
}
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
int[] spfa(int x) {
int[] dist = new int[n];
boolean[] vis = new boolean[n];
// 起始先将所有的点标记为「未入队」和「距离为正无穷」
Arrays.fill(dist, INF);
// 只有起点最短距离为 0
dist[x] = 0;
// 使用「双端队列」存储,存储的是点编号
Deque<Integer> d = new ArrayDeque<>();
// 将「源点/起点」进行入队,并标记「已入队」
d.addLast(x);
vis[x] = true;
while (!d.isEmpty()) {
// 每次从「双端队列」中取出,并标记「未入队」
int u = d.pollFirst();
vis[u] = false;
// 尝试使用该点,更新其他点的最短距离
// 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] <= dist[u] + w[i]) continue;
dist[j] = dist[u] + w[i];
if (vis[j]) continue;
d.addLast(j);
vis[j] = true;
}
}
return dist;
}
}
```
C++ 代码:
```C++
class Solution {
public:
static const int N = 110, M = N * N;
int he[N], e[M], ne[M], w[M], idx, n, INF = 0x3f3f3f3f;
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
int findTheCity(int _n, vector<vector<int>>& edges, int distanceThreshold) {
n = _n;
fill(he, he + N, -1);
for (const auto& e : edges) {
int a = e[0], b = e[1], c = e[2];
add(a, b, c); add(b, a, c);
}
int ans = -1, cnt = n + 10;
for (int i = 0; i < n; i++) {
vector<int> dist = spfa(i);
int cur = count_if(dist.begin(), dist.end(), [&](int d) { return d != INF && d <= distanceThreshold; });
if (cur <= cnt) {
cnt = cur; ans = i;
}
}
return ans;
}
vector<int> spfa(int x) {
// 起始先将所有的点标记为「未入队」和「距离为正无穷」
vector<int> dist(n, INF);
vector<bool> vis(n, false);
// 只有起点最短距离为 0
dist[x] = 0;
// 使用「双端队列」存储,存储的是点编号
deque<int> d;
// 将「源点/起点」进行入队,并标记「已入队」
d.push_back(x);
vis[x] = true;
while (!d.empty()) {
// 每次从「双端队列」中取出,并标记「未入队」
int u = d.front();
d.pop_front();
vis[u] = false;
// 尝试使用该点,更新其他点的最短距离
// 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (dist[j] <= dist[u] + w[i]) continue;
dist[j] = dist[u] + w[i];
if (vis[j]) continue;
d.push_back(j);
vis[j] = true;
}
}
return dist;
}
};
```
Python 代码:
```Python
class Solution:
def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:
m, INF, idx = n * n, 0x3f3f3f3f, 0
he, e, ne, w = [-1] * n, [0] * m, [0] * m, [0] * m
def add(a: int, b: int, c: int):
nonlocal idx
e[idx] = b
ne[idx] = he[a]
w[idx] = c
he[a] = idx
idx += 1
def spfa(x: int) -> List[int]:
# 起始先将所有的点标记为「未入队」和「距离为正无穷」
dist = [INF] * n
vis = [False] * n
# 只有起点最短距离为 0
dist[x] = 0
# 使用「双端队列」存储,存储的是点编号
d = deque()
# 将「源点/起点」进行入队,并标记「已入队」
d.append(x)
vis[x] = True
while d:
# 每次从「双端队列」中取出,并标记「未入队」
u = d.popleft()
vis[u] = False
i = he[u]
# 尝试使用该点,更新其他点的最短距离
# 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」
while i != -1:
j, c = e[i], w[i]
i = ne[i]
if dist[j] <= dist[u] + c: continue
dist[j] = dist[u] + c
if vis[j]: continue
d.append(j)
vis[j] = True
return dist
for a, b, c in edges:
add(a, b, c)
add(b, a, c)
ans, cnt = -1, n + 10
for i in range(n):
dist = spfa(i)
cur = sum(1 for d in dist if d != INF and d <= distanceThreshold)
if cur <= cnt:
cnt, ans = cur, i
return ans
```
* 时间复杂度:统计答案时,共执行 $n$ 次 `spfa` 算法, `spfa` 复杂度为 $O(nm)$,总复杂度为 $O(n^2 \times m)$。整体复杂度为 $O(n^2 \times m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1334` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1331-1340/1337. 矩阵中战斗力最弱的 K 行（简单）.md | 1337. 矩阵中战斗力最弱的 K 行 | https://leetcode-cn.com/problems/the-k-weakest-rows-in-a-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-7okx/ | 简单 | [
"优先队列(堆)",
"二分"
] | 给你一个大小为 $m * n$ 的矩阵 $mat$,矩阵由若干军人和平民组成,分别用 $1$ 和 $0$ 表示。
请你返回矩阵中战斗力最弱的 $k$ 行的索引,按从最弱到最强排序。
如果第 $i$ 行的军人数量少于第 $j$ 行,或者两行军人数量相同但 $i$ 小于 $j$,那么我们认为第 $i$ 行的战斗力比第 $j$ 行弱。
军人 总是 排在一行中的靠前位置,也就是说 $1$ 总是出现在 $0$ 之前。
示例 1:
```
输入:mat =
[[1,1,0,0,0],
[1,1,1,1,0],
[1,0,0,0,0],
[1,1,0,0,0],
[1,1,1,1,1]],
k = 3
输出:[2,0,3]
解释:
每行中的军人数目:
行 0 -> 2
行 1 -> 4
行 2 -> 1
行 3 -> 2
行 4 -> 5
从最弱到最强对这些行排序后得到 [2,0,3,1,4]
```
示例 2:
```
输入:mat =
[[1,0,0,0],
[1,1,1,1],
[1,0,0,0],
[1,0,0,0]],
k = 2
输出:[0,2]
解释:
每行中的军人数目:
行 0 -> 1
行 1 -> 4
行 2 -> 1
行 3 -> 1
从最弱到最强对这些行排序后得到 [0,2,3,1]
```
提示:
* m == mat.length
* n == mat[i].length
* 2 <= n, m <= 100
* 1 <= k <= m
* matrix[i][j] 不是 0 就是 1 | ### 朴素解法
一个朴素的做法是对矩阵进行遍历,统计每一行的军人数量,并以二元组 $(cnt_i, idx_i)$ 的形式进行存储。
然后对所有行的战力进行排序,选出战力最小的 $k$ 个下标即是答案。
代码:
```Java
class Solution {
public int[] kWeakestRows(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
int[][] all = new int[m][1];
for (int i = 0; i < m; i++) {
int cur = 0;
for (int j = 0; j < n; j++) cur += mat[i][j];
all[i] = new int[]{cur, i};
}
Arrays.sort(all, (a, b)->{
if (a[0] != b[0]) return a[0] - b[0];
return a[1] - b[1];
});
int[] ans = new int[k];
for (int i = 0; i < k; i++) ans[i] = all[i][1];
return ans;
}
}
```
* 时间复杂度:遍历矩阵的复杂度为 $O(m * n)$;排序复杂度为 $O(m\log{m})$;构造答案复杂度为 $O(k)$。整体复杂度为 $O(\max(m * n, m\log{m}))$
* 空间复杂度:$O(m)$ 空间用于存储所有的行战力;$O(\log{m})$ 空间用于排序。整体复杂度为 $O(m + \log{m})$
---
### 二分 + 优先队列(堆)
根据「军人总是排在靠前位置」的特性,我们可以通过「二分」找到每一行最后一个军人的位置,从而在 $O(\log{n})$ 的复杂度内统计出每行的军人数量(战力情况)。
同时由于我们只需要「战力最弱」的 $k$ 行数据,这引导我们可以建立一个「战力大根堆」来做,「战力大根堆」存放着数量最多为 $k$ 的战力二元组 $(cnt_i, idx_i)$,堆顶元素为战力最大的数对。
每次通过「二分」得到当前行的战力值后,判断当前战力值与堆顶元素的战力大小关系:
* 如果当前战力值比堆顶的元素要大:直接丢弃当前战力值(不可能属于在第 $k$ 小的集合中);
* 如果当前战力值比堆顶的元素要小:将堆顶元素弹出,将当前行放入堆中。
> 一些细节:每次写二分都有同学会问,`check` 函数怎么写,可以重点看看 [34 题题解](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/)。由于考虑某行没有军人的情况,我们需要二分完检查一下分割点是否符合 `check` 来决定军人数量。
另外,从堆弹出和往堆存入,需要与当前堆元素的数量有所关联。
代码:
```Java
class Solution {
public int[] kWeakestRows(int[][] mat, int k) {
int m = mat.length, n = mat[0].length;
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{
if (a[0] != b[0]) return b[0] - a[0];
return b[1] - a[1];
});
for (int i = 0; i < m; i++) {
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (mat[i][mid] >= 1) l = mid;
else r = mid - 1;
}
int cur = mat[i][r] >= 1 ? r + 1 : r;
if (q.size() == k && q.peek()[0] > cur) q.poll();
if (q.size() < k) q.add(new int[]{cur, i});
}
int[] ans = new int[k];
int idx = k - 1;
while (!q.isEmpty()) ans[idx--] = q.poll()[1];
return ans;
}
}
```
* 时间复杂度:二分得到每行的战力情况,复杂度为 $O(m\log{n})$;堆中最多有 $k$ 个元素,将行信息存入堆中复杂度为 $O(m\log{k});$构造答案复杂度为 $O(k\log{k})$。整体复杂度为 $O(m * (\log{n} + \log{k}))$
* 空间复杂度:$O(k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1337` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1341-1350/1342. 将数字变成 0 的操作次数（简单）.md | 1342. 将数字变成 0 的操作次数 | https://leetcode-cn.com/problems/number-of-steps-to-reduce-a-number-to-zero/solution/gong-shui-san-xie-note-bie-pian-yi-ti-sh-85fb/ | 简单 | [
"模拟",
"数学"
] | 给你一个非负整数 `num` ,请你返回将它变成 $0$ 所需要的步数。 如果当前数字是偶数,你需要把它除以 $2$ ;否则,减去 $1$ 。
示例 1:
```
输入:num = 14
输出:6
解释:
步骤 1) 14 是偶数,除以 2 得到 7 。
步骤 2) 7 是奇数,减 1 得到 6 。
步骤 3) 6 是偶数,除以 2 得到 3 。
步骤 4) 3 是奇数,减 1 得到 2 。
步骤 5) 2 是偶数,除以 2 得到 1 。
步骤 6) 1 是奇数,减 1 得到 0 。
```
示例 2:
```
输入:num = 8
输出:4
解释:
步骤 1) 8 是偶数,除以 2 得到 4 。
步骤 2) 4 是偶数,除以 2 得到 2 。
步骤 3) 2 是偶数,除以 2 得到 1 。
步骤 4) 1 是奇数,减 1 得到 0 。
```
示例 3:
```
输入:num = 123
输出:12
```
提示:
* $0 <= num <= 10^6$ | ### 模拟
根据题意进行模拟:**根据当前 $num$ 的奇偶性进行对应操作,直到 $num$ 为 $0$,返回操作次数。**
代码:
```Java
class Solution {
public int numberOfSteps(int num) {
int ans = 0;
while (num != 0 && ++ans >= 0) num = num % 2 == 0 ? num / 2 : num - 1;
return ans;
}
}
```
* 时间复杂度:$O(\log{num})$
* 空间复杂度:$O(1)$
---
### 数学(二进制性质)
目的是使得最终结果的二进制表示均为 $0$,两种操作对二进制数的影响分别为「整体右移」和「消减最低位的 $1$」。
因此整个模拟过程其实是:**如果当前的 $num$ 最低位不为 $1$(偶数),则不断进行右移,直到最低位为 $1$(奇数),然后再对最低位的 $1$ 进行消减,直到二进制表示中的所有 $1$ 均被消减完(结果为 $0$),模拟过程结束。**
换句话说,总的操作次数为 = 右移次数 + 消减次数 :
* 右移次数:$num$ 中最高位 $1$ 的所在的位置;
* 消减次数:$num$ 中 $1$ 的个数。
代码:
```Java
class Solution {
public int numberOfSteps(int num) {
return Math.max(getLoc(num) + getCnt(num) - 1, 0);
}
int getLoc(int x) {
for (int i = 31; i >= 0; i--) {
if (((x >> i) & 1) == 1) return i + 1;
}
return -1; // never
}
int getCnt(int x) {
int ans = 0;
for (int i = 31; i >= 0; i--) {
if (((x >> i) & 1) == 1) ans++;
}
return ans;
}
}
```
-
```Java
class Solution {
public int numberOfSteps(int num) {
return Math.max(getLoc(num) + getCnt(num) - 1, 0);
}
int getLoc(int x) {
for (int i = 31; i >= 0; i--) {
if (((x >> i) & 1) == 1) return i + 1;
}
return -1; // never
}
int getCnt(int x) {
int ans = 0;
while (x != 0 && ++ans >= 0) x -= (x & -x); // lowbit
return ans;
}
}
```
* 时间复杂度:令 $C$ 为 $int$ 二进制表示中的最大长度,复杂度为 $O(C)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1341-1350/1345. 跳跃游戏 IV（困难）.md | 1345. 跳跃游戏 IV | https://leetcode-cn.com/problems/jump-game-iv/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-q9tb1/ | 困难 | [
"图论 BFS",
"双向 BFS"
] | 给你一个整数数组 `arr` ,你一开始在数组的第一个元素处(下标为 `0`)。
每一步,你可以从下标 i 跳到下标:
* `i + 1` 满足:`i + 1 < arr.length`
* `i - 1` 满足:`i - 1 >= 0`
* `j` 满足:`arr[i] == arr[j]` 且 `i != j`
请你返回到达数组最后一个元素的下标处所需的 **最少操作次数** 。
注意:任何时候你都不能跳到数组外面。
示例 1:
```
输入:arr = [100,-23,-23,404,100,23,23,23,3,404]
输出:3
解释:那你需要跳跃 3 次,下标依次为 0 --> 4 --> 3 --> 9 。下标 9 为数组的最后一个元素的下标。
```
示例 2:
```
输入:arr = [7]
输出:0
解释:一开始就在最后一个元素处,所以你不需要跳跃。
```
示例 3:
```
输入:arr = [7,6,9,6,9,6,9,7]
输出:1
解释:你可以直接从下标 0 处跳到下标 7 处,也就是数组的最后一个元素处。
```
示例 4:
```
输入:arr = [6,1,9]
输出:2
```
示例 5:
```
输入:arr = [11,22,7,7,7,7,7,7,7,22,13]
输出:3
```
提示:
* $1 <= arr.length <= 5 * 10^4$
* $-10^8 <= arr[i] <= 10^8$ | ### 单向 BFS
根据跳跃规则,我们能够进行「前后跳」和「等值跳」,问题为到达结尾位置的最少步数,容易想到 `BFS`。
为了方便进行「等值跳」,我们可以先使用「哈希表」记录某个值有哪些下标。
在进行 `BFS` 时,假如当前走到的位置为 $t$,我们尝试将 $t - 1$、$t + 1$ 和与 $arr[t]$ 等值的位置进行入队,为了防止重复同队,我们可以使用 $dist$ 数组记录到达某个位置的最小步数(初始化为 `INF`),只有 $dist[ne]$ 为 `INF` 时,该点没有被遍历过,可以入队并更新最小步数。
但光使用 $dist$ 还不能确保复杂度为 $O(n)$,因为每次都需要遍历与 $arr[t]$ 等值的下标,为确保等值下标的遍历只会发生一次,我们需要在将等值下标添加到队列后,将 $arr[t]$ 从哈希表中移除。
容易证明每次将于 $arr[t]$ 的等值元素添加到队列后,将 $arr[t]$ 从哈希表中移除的正确性:
首次检索到 $arr[t]$ 值时,必然是最小步数,记为 $step$,此时 `BFS` 做法将其他等值下标距离更新为 $step + 1$:
* 若 $arr[t]$ 与结尾元素值相等,且 $t$ 为 $n - 1$,此时 $step$ 即是答案;
* 若 $arr[t]$ 与结尾元素值相等,但 $t$ 不为 $n - 1$,此时会再跳一步到达结尾位置,即 $step + 1$ 为答案。那么是否可能存在使用比 $step + 1$ 更小的步数,也能到达结尾的位置呢?
答案是:**可能存在,但如果最后是通过「等值跳」到达结尾位置的话,不可能存在比 $step + 1$ 更小的步数。**
由于我们每次加入等值时都会进行哈希表的移除,因此到达 $t$ 的方式不可能是「等值跳」,而只能是「前后跳」。
* 假设是通过前跳到达位置 $t$,即点分布如图,步数满足等于 $step + 1$:
* 假设是通过后跳到达位置 $t$,即点分布如图,步数满足「如果是等值跳到达结尾,步数为 $step + 1$」:
**综上,如果 $n - 1$ 是经过「等值跳」加入队列的话,起所能达到的最小步数必然为发起点 $t$ 的最小步数 $+1$。**
**也就是说,即使首次等值跳,加入队列后会将其从哈希表中进行移除,正确性也是可以保证的。**
基于此,我们可以额外增加一个 trick,就是在构建哈希表的时候,使用「倒序」的形式构建等值下标列表,这样可以确保如果最后位置是通过「等值跳」而来是,能够优先出队。
**代码(感谢 [@Benhao](/u/himymben/) 和 [@🍭可乐可乐吗](/u/littletime_cc/) 同学提供的其他语言版本):**
```Java
class Solution {
int INF = 0x3f3f3f3f;
public int minJumps(int[] arr) {
int n = arr.length;
Map<Integer, List<Integer>> map = new HashMap<>();
// 倒序插入 list,相当于给 deque 增加一个同层「下标越大,优先出队」的作用
for (int i = n - 1; i >= 0; i--) {
List<Integer> list = map.getOrDefault(arr[i], new ArrayList<>());
list.add(i);
map.put(arr[i], list);
}
int[] dist = new int[n];
Arrays.fill(dist, INF);
Deque<Integer> d = new ArrayDeque<>();
d.addLast(0);
dist[0] = 0;
while (!d.isEmpty()) {
int t = d.pollFirst(), step = dist[t];
if (t == n - 1) return step;
if (t + 1 < n && dist[t + 1] == INF) {
d.addLast(t + 1);
dist[t + 1] = step + 1;
}
if (t - 1 >= 0 && dist[t - 1] == INF) {
d.addLast(t - 1);
dist[t - 1] = step + 1;
}
List<Integer> list = map.getOrDefault(arr[t], new ArrayList<>());
for (int ne : list) {
if (dist[ne] == INF) {
d.addLast(ne);
dist[ne] = step + 1;
}
}
map.remove(arr[t]);
}
return -1; // never
}
}
```
-
```C++
class Solution {
public:
int minJumps(vector<int>& arr) {
const int inf = 0x3f3f3f3f;
int n = arr.size();
unordered_map<int, vector<int>> map;
for(int i = n - 1; ~i; i--) {
map[arr[i]].push_back(i);
}
vector<int> dist(n, inf);
queue<int> q;
q.push(0);
dist[0] = 0;
while(q.size()) {
auto t = q.front(), step = dist[t];
q.pop();
if(t == n - 1) return step;
if(t + 1 < n and dist[t + 1] == inf) {
q.push(t + 1);
dist[t + 1] = step + 1;
}
if(t - 1 >= 0 and dist[t - 1] == inf) {
q.push(t - 1);
dist[t - 1] = step + 1;
}
const auto& list = map[arr[t]];
for(auto ne :list) {
if(dist[ne] == inf) {
q.push(ne);
dist[ne] = step + 1;
}
}
map[arr[t]].clear(); //or map.erase(arr[t]);
}
return -1;
}
};
```
-
```python
class Solution:
def minJumps(self, arr: List[int]) -> int:
n = len(arr)
mp = defaultdict(list)
for i, num in enumerate(arr):
mp[num].append(i)
dist = [inf] * n
d = deque([0])
dist[0] = 0
while len(d) > 0:
t = d.popleft()
step = dist[t]
if t == n - 1:
return step
for ne in mp[arr[t]]:
if dist[ne] == inf:
d.append(ne)
dist[ne] = step + 1
mp.pop(arr[t])
if dist[t + 1] == inf:
d.append(t + 1)
dist[t + 1] = step + 1
if t and dist[t - 1] == inf:
d.append(t - 1)
dist[t - 1] = step + 1
return -1
```
-
```Go
const INF int = 0x3f3f3f3f
func minJumps(arr []int) int {
n := len(arr)
mp := map[int][]int{}
dist := make([]int, len(arr))
for i := 0; i < n; i++{
list := mp[arr[i]]
list = append(list, i)
mp[arr[i]] = list
dist[i] = INF
}
d := []int{0}
dist[0] = 0
for len(d) > 0{
t := d[0]
step := dist[t]
if t == n - 1{
return step
}
d = d[1:]
list := mp[arr[t]]
delete(mp, arr[t])
list = append(list, t + 1)
if t > 0 {
list = append(list, t - 1)
}
for _, ne := range list {
if dist[ne] == INF {
dist[ne] = step + 1
d = append(d, ne)
}
}
}
return -1
}
```
* 时间复杂度:预处理出 `map` 的复杂度为 $O(n)$;跑一遍 `BFS` 得到答案复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$
---
### 双向 BFS
自然也能够使用「双向 `BFS`」进行求解。
不了解「双向 `BFS`」的同学,可以先看前置🧀:[【图论搜索专题】如何使用「双向 BFS」解决搜索空间爆炸问题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=1446568490&lang=zh_CN#rd) & [【图论搜索专题】双向 BFS 模板题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489502&idx=1&sn=dc863d4bc71c4739a4799b9a4558bd01&chksm=fd9cbcc1caeb35d749d0d72f485485527482c27b608c8f4062c29a997ede97a09ce598b58c7f&token=1446568490&lang=zh_CN#rd) 。
双向 `BFS` 能够有效解决搜索空间爆炸问题,本题使用双向 `BFS` 的话,可以不进行哈希表的 `remove` 操作。
代码:
```Java
class Solution {
int[] arr;
int INF = 0x3f3f3f3f;
int n;
Map<Integer, List<Integer>> map = new HashMap<>();
public int minJumps(int[] _arr) {
arr = _arr;
n = arr.length;
if (n == 1) return 0;
for (int i = n - 1; i >= 0; i--) {
List<Integer> list = map.getOrDefault(arr[i], new ArrayList<>());
list.add(i);
map.put(arr[i], list);
}
Deque<Integer> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
int[] dist1 = new int[n], dist2 = new int[n];
Arrays.fill(dist1, INF);
Arrays.fill(dist2, INF);
d1.addLast(0);
dist1[0] = 0;
d2.addLast(n - 1);
dist2[n - 1] = 0;
while (!d1.isEmpty() && !d2.isEmpty()) {
int t = -1;
if (d1.size() < d2.size()) t = update(d1, d2, dist1, dist2);
else t = update(d2, d1, dist2, dist1);
if (t != -1) return t;
}
return -1; // never
}
int update(Deque<Integer> d1, Deque<Integer> d2, int[] dist1, int[] dist2) {
int m = d1.size();
while (m-- > 0) {
int t = d1.pollFirst(), step = dist1[t];
if (t + 1 < n) {
if (dist2[t + 1] != INF) return step + 1 + dist2[t + 1];
if (dist1[t + 1] == INF) {
d1.addLast(t + 1);
dist1[t + 1] = step + 1;
}
}
if (t - 1 >= 0) {
if (dist2[t - 1] != INF) return step + 1 + dist2[t - 1];
if (dist1[t - 1] == INF) {
d1.addLast(t - 1);
dist1[t - 1] = step + 1;
}
}
List<Integer> list = map.getOrDefault(arr[t], new ArrayList<>());
for (int ne : list) {
if (dist2[ne] != INF) return step + 1 + dist2[ne];
if (dist1[ne] == INF) {
d1.addLast(ne);
dist1[ne] = step + 1;
}
}
map.remove(arr[t]);
}
return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 其他「图论搜索 / 模拟」内容
题太简单?不如来学习热乎的 [简单图论搜索题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490011&idx=1&sn=4c8cbd5ad858f571291d47fcef75e75b&chksm=fd9cb2c4caeb3bd2ac442b2d4d1417e8eb6d65b1feca8399179951ebfa132e8a97a3935e7498&token=252055586&lang=zh_CN#rd) 🍭🍭🍭
* [常规 BFS(二维转一维)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489621&idx=1&sn=5d43fb97bc167a50a7aeb4ae2068571c&chksm=fd9cb34acaeb3a5c7e1e2e2a88d460ae2418a3cef615e1abf017b5d58aa1e7f490856d67f800&token=2136593799&lang=zh_CN#rd)
* [常规 BFS/迭代加深(结合二叉树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489746&idx=2&sn=9e80b33c12e96369c7a770382a97adbb&chksm=fd9cb3cdcaeb3adb35c708e548851e419b00e41801c98cae146ba29f5bdc49370a43cddf668d&token=252055586&lang=zh_CN#rd)
* [多源 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&scene=178&cur_album_id=1917113998693449732#rd)
* [双向 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489502&idx=1&sn=dc863d4bc71c4739a4799b9a4558bd01&chksm=fd9cbcc1caeb35d749d0d72f485485527482c27b608c8f4062c29a997ede97a09ce598b58c7f&scene=178&cur_album_id=1917113998693449732#rd)
* [双向 BFS II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&scene=178&cur_album_id=1917113998693449732#rd)
* [双向 BFS III(结合并查集)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489671&idx=1&sn=c0f64de1a5e4613675f73d2ae43d0708&chksm=fd9cb398caeb3a8eae334c89dee17711fca43a00d93cf63a623792f3aac0c8bf586b4be9cc47&token=2074150457&lang=zh_CN#rd)
* [灵活运用多种搜索方式(启发式)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489560&idx=2&sn=bb966d868c18d656620a20d31a425b23&chksm=fd9cb307caeb3a11424428f0a88e7f0cb86bb53b3e5a2b9e28683a24bcb3ac151655d2b6419e&scene=178&cur_album_id=1917113998693449732#rd)
* [灵活运用多种搜索方式 II(启发式)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489588&idx=1&sn=479e4c0627247ab7e20af7909f2a8b64&chksm=fd9cb32bcaeb3a3d4f0bd73f023a92a165edabf212af1db9672a55bed1af7d4e32e8af9964c3&scene=178&cur_album_id=1917113998693449732#rd)
* [灵活运用多种搜索方式 III(启发式 结合状态压缩)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489985&idx=1&sn=e503ce6ece048062f1d9ebee2572838a&chksm=fd9cb2decaeb3bc8c635c4a6cf0e78d5973723bb6c89a64875828435dc5b90ef07874ef7a6ae&token=252055586&lang=zh_CN#rd) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1345` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1371-1380/1374. 生成每种字符都是奇数个的字符串（简单）.md | 1374. 生成每种字符都是奇数个的字符串 | https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts/solution/by-ac_oier-i74n/ | 简单 | [
"模拟"
] | 给你一个整数 `n`,请你返回一个含 `n` 个字符的字符串,其中每种字符在该字符串中都恰好出现 奇数次 。
返回的字符串必须只含小写英文字母。如果存在多个满足题目要求的字符串,则返回其中任意一个即可。
示例 1:
```
输入:n = 4
输出:"pppz"
解释:"pppz" 是一个满足题目要求的字符串,因为 'p' 出现 3 次,且 'z' 出现 1 次。当然,还有很多其他字符串也满足题目要求,比如:"ohhh" 和 "love"。
```
示例 2:
```
输入:n = 2
输出:"xy"
解释:"xy" 是一个满足题目要求的字符串,因为 'x' 和 'y' 各出现 1 次。当然,还有很多其他字符串也满足题目要求,比如:"ag" 和 "ur"。
```
示例 3:
```
输入:n = 7
输出:"holasss"
```
提示:
* $1 <= n <= 500$ | ### 模拟
题目仅规定所用到的字符出现次数均为奇数,并无规定单个字符的最大使用次数。
因此直接根据 $n$ 的奇偶性来做即可,若 $n$ 为奇数,则构造出由 $n$ 个 `b` 拼接的字符串;若 $n$ 为偶数,则构造出由 $1$ 个 `a` 和 $n - 1$ 个 `b` 的拼接字符串。
Java 代码:
```Java
class Solution {
public String generateTheString(int n) {
StringBuilder sb = new StringBuilder();
if (n % 2 == 0 && --n >= 0) sb.append('a');
while (n-- > 0) sb.append('b');
return sb.toString();
}
}
```
TypeScript 代码:
```TypeScript
function generateTheString(n: number): string {
let ans = ""
if (n % 2 == 0 && --n >= 0) ans += "a"
while (n-- > 0) ans += "b"
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1374` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1371-1380/1380. 矩阵中的幸运数（简单）.md | 1380. 矩阵中的幸运数 | https://leetcode-cn.com/problems/lucky-numbers-in-a-matrix/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-9xwg/ | 简单 | [
"模拟"
] | 给你一个 $m * n$ 的矩阵,矩阵中的数字 **各不相同** 。请你按 **任意** 顺序返回矩阵中的所有幸运数。
幸运数是指矩阵中满足同时下列两个条件的元素:
* 在同一行的所有元素中最小
* 在同一列的所有元素中最大
示例 1:
```
输入:matrix = [[3,7,8],[9,11,13],[15,16,17]]
输出:[15]
解释:15 是唯一的幸运数,因为它是其所在行中的最小值,也是所在列中的最大值。
```
示例 2:
```
输入:matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]
输出:[12]
解释:12 是唯一的幸运数,因为它是其所在行中的最小值,也是所在列中的最大值。
```
示例 3:
```
输入:matrix = [[7,8],[1,2]]
输出:[7]
```
提示:
* $m == mat.length$
* $n == mat[i].length$
* $1 <= n, m <= 50$
* $1 <= matrix[i][j] <= 10^5$
* 矩阵中的所有元素都是不同的 | ### 模拟
根据题意进行模拟即可。
具体的,创建两个数组 `row` 和 `col` 用于进行预处理,$row[x]$ 含义为第 $x$ 行的最小值,$col[y]$ 为第 $y$ 列的最大值。
然后扫描棋盘取得符合条件的幸运值即可。
代码:
```Java
class Solution {
int N = 55;
int[] row = new int[N], col = new int[N];
public List<Integer> luckyNumbers (int[][] mat) {
int n = mat.length, m = mat[0].length;
for (int i = 0; i < n; i++) {
row[i] = 100001;
for (int j = 0; j < m; j++) {
row[i] = Math.min(row[i], mat[i][j]);
col[j] = Math.max(col[j], mat[i][j]);
}
}
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int t = mat[i][j];
if (t == row[i] && t == col[j]) ans.add(t);
}
}
return ans;
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(n * m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1380` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1391-1400/1395. 统计作战单位数（中等）.md | 1395. 统计作战单位数 | https://leetcode.cn/problems/count-number-of-teams/solution/by-ac_oier-qm3a/ | 中等 | [
"树状数组",
"容斥原理"
] | `n` 名士兵站成一排。每个士兵都有一个 独一无二 的评分 `rating` 。
每 $3$ 个士兵可以组成一个作战单位,分组规则如下:
* 从队伍中选出下标分别为 `i`、`j`、`k` 的 $3$ 名士兵,他们的评分分别为 $rating[i]$、$rating[j]$、$rating[k]$
* 作战单位需满足: $rating[i] < rating[j] < rating[k]$ 或者 $rating[i] > rating[j] > rating[k]$ ,其中 $0 <= i < j < k < n$
请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。
示例 1:
```
输入:rating = [2,5,3,4,1]
输出:3
解释:我们可以组建三个作战单位 (2,3,4)、(5,4,1)、(5,3,1) 。
```
示例 2:
```
输入:rating = [2,1,3]
输出:0
解释:根据题目条件,我们无法组建作战单位。
```
示例 3:
```
输入:rating = [1,2,3,4]
输出:4
```
提示:
* $n == rating.length$
* $3 <= n <= 1000$
* $1 <= rating[i] <= 10^5$
* `rating` 中的元素都是唯一的 | ### 基本分析
为了方便,我们记 `rating` 为 `rs`。
题目本质是要我们统计所有满足「递增」或「递减」的三元组。换句话说,对于每个 $t = rs[i]$ 而言,我们需要统计比其 $t$ 大或比 $t$ 小的数的个数。
问题涉及「单点修改(更新数值 $t$ 的出现次数)」以及「区间查询(查询某段范围内数的个数)」,使用「树状数组」求解较为合适。
---
### 树状数组 - 枚举两端
一个朴素的想法是,对于三元组 $(i, j, k)$,我们枚举其两端 $i$ 和 $k$,根据 $rs[i]$ 和 $rs[k]$ 的大小关系,查询范围 $[i + 1, k - 1]$ 之间合法的数的个数。
在确定左端点 $i$ 时,我们从 $i + 1$ 开始「从小到大」枚举右端点 $k$,并将遍历过程中经过的 $rs[k]$ 添加到树状数组进行计数。
处理过程中根据 $a = rs[i]$ 和 $b = rs[k]$ 的大小关系进行分情况讨论:
* 当 $a < b$ 时,我们需要在范围 $[i + 1, k - 1]$ 中找「大于 $a$」同时「小于 $b$」的数的个数,即 `query(b - 1) - query(a)`
* 当 $a > b$ 时,我们需要在范围 $[i + 1, k - 1]$ 中找「小于 $a$」同时「大于 $b$」的数的个数,即 `query(a - 1) - query(b)`
一些细节:显然我们需要在枚举每个左端点 $i$ 时清空树状数组,但注意不能使用诸如 `Arrays.fill(tr, 0)` 的方式进行清空。
因为在没有离散化的情况下,树状数组的大小为 $m = 1e5$,即执行 `Arrays.fill` 操作的复杂度为 $O(m)$,这会导致我们计算量为至少为 $n \times m = 1e8$,会有 `TLE` 风险。
因此一个合适做法是:在 $[i + 1, n - 1]$ 范围内枚举完 $k$ 后(进行的是 `+1` 计数),再枚举一次 $[i + 1, n - 1]$ 进行一次 `-1` 的计数进行抵消。
代码:
```Java
class Solution {
static int N = (int)1e5 + 10;
static int[] tr = new int[N];
int lowbit(int x) {
return x & -x;
}
void update(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 numTeams(int[] rs) {
int n = rs.length, ans = 0;
for (int i = 0; i < n; i++) {
int a = rs[i];
for (int j = i + 1; j < n; j++) {
int b = rs[j];
if (a < b) ans += query(b - 1) - query(a);
else ans += query(a - 1) - query(b);
update(b, 1);
}
for (int j = i + 1; j < n; j++) update(rs[j], -1);
}
return ans;
}
}
```
* 时间复杂度:令 $m = 1e5$ 为值域大小,整体复杂度为 $O(n^2\log{m})$
* 空间复杂度:$O(m)$
---
### 双树状数组优化 - 枚举中点
我们考虑将 $n$ 的数据范围提升到 $1e4$ 该如何做。
上述解法的瓶颈在于我们枚举三元组中的左右端点,复杂度为 $O(n^2)$,而实际上利用三元组必然递增或递减的特性,我们可以调整为枚举终点 $j$,从而将「枚举点对」调整为「枚举中点」,复杂度为 $O(n)$。
假设当前枚举到的点为 $rs[i]$,问题转换为在 $[0, i - 1]$ 有多少比 $rs[i]$ 小/大 的数,在 $[i + 1, n - 1]$ 有多少比 $rs[i]$ 大/小 的数,然后集合「乘法」原理即可知道 $rs[i]$ 作为三元组中点的合法方案数。
统计 $rs[i]$ 左边的比 $rs[i]$ 大/小 的数很好做,只需要在「从小到大」枚举 $i$ 的过程中,将 $rs[i]$ 添加到树状数组 `tr1` 即可。
对于统计 $rs[i]$ 右边比 $rs[i]$ 小/大 的数,则需要通过「抵消计数」来做,起始我们先将所有 $rs[idx]$ 加入到另外一个树状数组 `tr2` 中(进行 `+1` 计数),然后在从前往后处理每个 $rs[i]$ 的时候,在 `tr2` 中进行 `-1` 抵消,从而确保我们处理每个 $rs[i]$ 时,`tr1` 存储左边的数,`tr2` 存储右边的数。
代码:
```Java
class Solution {
static int N = (int)1e5 + 10;
static int[] tr1 = new int[N], tr2 = new int[N];
int lowbit(int x) {
return x & -x;
}
void update(int[] tr, int x, int v) {
for (int i = x; i < N; 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 numTeams(int[] rs) {
int n = rs.length, ans = 0;
Arrays.fill(tr1, 0);
Arrays.fill(tr2, 0);
for (int i : rs) update(tr2, i, 1);
for (int i = 0; i < n; i++) {
int t = rs[i];
update(tr2, t, -1);
ans += query(tr1, t - 1) * (query(tr2, N - 1) - query(tr2, t));
ans += (query(tr1, N - 1) - query(tr1, t)) * query(tr2, t - 1);
update(tr1, t, 1);
}
return ans;
}
}
```
* 时间复杂度:令 $m = 1e5$ 为值域大小,整体复杂度为 $O(n\log{m})$
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1395` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1403. 非递增顺序的最小子序列（简单）.md | 1403. 非递增顺序的最小子序列 | https://leetcode.cn/problems/minimum-subsequence-in-non-increasing-order/solution/by-ac_oier-766t/ | 简单 | [
"贪心"
] | 给你一个数组 `nums`,请你从中抽取一个子序列,满足该子序列的元素之和严格大于未包含在该子序列中的各元素之和。
如果存在多个解决方案,只需返回长度最小的子序列。如果仍然有多个解决方案,则返回元素之和最大的子序列。
与子数组不同的地方在于,「数组的子序列」不强调元素在原数组中的连续性,也就是说,它可以通过从数组中分离一些(也可能不分离)元素得到。
注意,题目数据保证满足所有约束条件的解决方案是唯一的。同时,返回的答案应当按非递增顺序排列。
示例 1:
```
输入:nums = [4,3,10,9,8]
输出:[10,9]
解释:子序列 [10,9] 和 [10,8] 是最小的、满足元素之和大于其他各元素之和的子序列。但是 [10,9] 的元素之和最大。
```
示例 2:
```
输入:nums = [4,4,7,6,7]
输出:[7,7,6]
解释:子序列 [7,7] 的和为 14 ,不严格大于剩下的其他元素之和(14 = 4 + 4 + 6)。因此,[7,6,7] 是满足题意的最小子序列。注意,元素按非递增顺序返回。
```
示例 3:
```
输入:nums = [6]
输出:[6]
```
提示:
* $1 <= nums.length <= 500$
* $1 <= nums[i] <= 100$ | ### 贪心
根据题意,我们可以先对 `nums` 进行排序(升序),然后从后往前开始选择,当首次满足「选择元素之和 严格大于 未选择元素之和」时,必然满足所选元素个数最少,若存在其他同样个数的合法方案,也满足所选方案为元素和最大方案,同时满足答案输出按照非升序要求。
Java 代码:
```Java
class Solution {
public List<Integer> minSubsequence(int[] nums) {
Arrays.sort(nums);
int sum = 0, cur = 0, idx = nums.length - 1;
for (int i : nums) sum += i;
List<Integer> ans = new ArrayList<>();
while (cur <= sum) {
sum -= nums[idx];
cur += nums[idx];
ans.add(nums[idx--]);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function minSubsequence(nums: number[]): number[] {
nums = nums.sort((a,b)=>a-b)
let sum = 0, cur = 0, idx = nums.length - 1
for (const i of nums) sum += i
const ans = new Array<number>()
while (cur <= sum) {
sum -= nums[idx]
cur += nums[idx]
ans.push(nums[idx--])
}
return ans
};
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1403` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1405. 最长快乐字符串（中等）.md | 1405. 最长快乐字符串 | https://leetcode-cn.com/problems/longest-happy-string/solution/gong-shui-san-xie-jie-he-you-xian-dui-li-q6fd/ | 中等 | [
"优先队列(堆)",
"贪心"
] | 如果字符串中不含有任何 `'aaa'`,`'bbb'` 或 `'ccc'` 这样的字符串作为子串,那么该字符串就是一个「快乐字符串」。
给你三个整数 `a`,`b` ,`c`,请你返回 任意一个 满足下列全部条件的字符串 `s`:
* `s` 是一个尽可能长的快乐字符串。
* `s` 中 最多 有 `a` 个字母 `'a'`、`b` 个字母 `'b'`、`c` 个字母 `'c'` 。
* `s` 中只含有 `'a'`、`'b'` 、`'c'` 三种字母。
如果不存在这样的字符串 `s` ,请返回一个空字符串 `""`。
示例 1:
```
输入:a = 1, b = 1, c = 7
输出:"ccaccbcc"
解释:"ccbccacc" 也是一种正确答案。
```
示例 2:
```
输入:a = 2, b = 2, c = 1
输出:"aabbc"
```
示例 3:
```
输入:a = 7, b = 1, c = 0
输出:"aabaa"
解释:这是该测试用例的唯一正确答案。
```
提示:
* $0 <= a, b, c <= 100$
* $a + b + c > 0$ | ### 贪心
容易想到:**每次都取当前剩余次数最多的字符来进行构造(前提是满足「不出现形如 `aaa` 字符串」的要求)**。
具体的,可以使用「优先队列(堆)」来实现上述过程,以 `(字符编号, 字符剩余数量)` 的二元组形式进行存储,构建以 `字符剩余数量` 排倒序的「大根堆」:
1. 起始先将 $(0, a)$、$(1, b)$ 和 $(2, c)$ 进行入堆(其中 $123$ 为字符编号,代指 `abc`,同时规定只有剩余数量大于 $0$ 才能入堆);
2. 每次取出堆顶元素(剩余数量最多的字符),尝试参与答案的构造:
1. 不违反连续三个字符相同:则说明当前字符能够追加到当前答案尾部,若追加后还有字符剩余,则更新剩余数量重新入堆;
2. 违反连续三个字符相同:说明该字符无法追加到当前答案尾部,此时尝试从堆中取出剩余次数次大的字符(若当前堆为空,说明没有任何合法字符能够追加,直接 break),若次大字符追加后还有字符剩余,则更新剩余数量重新入堆,同时将此前取的最大字符元祖也重新入堆;
3. 重复步骤 $2$,直到所有字符均被消耗,或循环提前结束。
该做法的正确性:**当 $a = b = c$ 时能够确保所有字符轮流参与构建,得到长度最大的快乐字符串,而该贪心策略(每次尽可能地进行大数消减)可以确保能够尽可能的凑成 $a = b = c$ 的局面,并且凑成该局面过程中不会从有解变为无解。**
代码:
```Java
class Solution {
public String longestDiverseString(int a, int b, int c) {
StringBuilder sb = new StringBuilder();
PriorityQueue<int[]> q = new PriorityQueue<>((x,y)->y[1]-x[1]);
if (a > 0) q.add(new int[]{0, a});
if (b > 0) q.add(new int[]{1, b});
if (c > 0) q.add(new int[]{2, c});
while (!q.isEmpty()) {
int[] cur = q.poll();
int n = sb.length();
if (n >= 2 && sb.charAt(n - 1) - 'a' == cur[0] && sb.charAt(n - 2) - 'a' == cur[0]) {
if (q.isEmpty()) break;
int[] next = q.poll();
sb.append((char)(next[0] + 'a'));
next[1]--;
if (next[1] != 0) q.add(next);
q.add(cur);
} else {
sb.append((char)(cur[0] + 'a'));
cur[1]--;
if (cur[1] != 0) q.add(cur);
}
}
return sb.toString();
}
}
```
* 时间复杂度:令答案最大长度为 $n = a + b + c$,优先队列中最多有 $C = 3$ 个元素,复杂度为 $O(n * k * \log{C})$,其中 $k$ 为构造答案字符串中每个字符所需要的平均「出队 + 入队」次数,$k$ 为一个范围在 $[2,4]$ 的数字
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1405` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1408. 数组中的字符串匹配（简单）.md | 1408. 数组中的字符串匹配 | https://leetcode.cn/problems/string-matching-in-an-array/solution/by-ac_oier-k03v/ | 简单 | [
"模拟"
] | 给你一个字符串数组 `words`,数组中的每个字符串都可以看作是一个单词。
请你按任意顺序返回 `words` 中是其他单词的子字符串的所有单词。
如果你可以删除 `words[j]` 最左侧和/或最右侧的若干字符得到 `word[i]`,那么字符串 `words[i]` 就是 `words[j]` 的一个子字符串。
示例 1:
```
输入:words = ["mass","as","hero","superhero"]
输出:["as","hero"]
解释:"as" 是 "mass" 的子字符串,"hero" 是 "superhero" 的子字符串。
["hero","as"] 也是有效的答案。
```
示例 2:
```
输入:words = ["leetcode","et","code"]
输出:["et","code"]
解释:"et" 和 "code" 都是 "leetcode" 的子字符串。
```
示例 3:
```
输入:words = ["blue","green","bu"]
输出:[]
```
提示:
* $1 <= words.length <= 100$
* $1 <= words[i].length <= 30$
* `words[i]` 仅包含小写英文字母。
* 题目数据保证每个 `words[i]` 都是独一无二的。 | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public List<String> stringMatching(String[] ss) {
List<String> ans = new ArrayList<>();
int n = ss.length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (ss[j].indexOf(ss[i]) >= 0) {
ans.add(ss[i]);
break;
}
}
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function stringMatching(ss: string[]): string[] {
const ans = new Array<string>()
const n = ss.length
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (i == j) continue
if (ss[j].indexOf(ss[i]) >= 0) {
ans.push(ss[i])
break
}
}
}
return ans
};
```
* 时间复杂度:$O(n^2 \times m^2)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1408` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1401-1410/1410. HTML 实体解析器（中等）.md | 1410. HTML 实体解析器 | https://leetcode.cn/problems/html-entity-parser/solutions/2538217/gong-shui-san-xie-jing-dian-zi-fu-chuan-rvdh3/ | 中等 | [
"模拟",
"哈希表"
] | 「HTML 实体解析器」 是一种特殊的解析器,它将 HTML 代码作为输入,并用字符本身替换掉所有这些特殊的字符实体。
HTML 里这些特殊字符和它们对应的字符实体包括:
* 双引号:字符实体为 `"`,对应的字符是 `"`。
* 单引号:字符实体为 `'`,对应的字符是 `'` 。
* 与符号:字符实体为 `&`,对应对的字符是 `&` 。
* 大于号:字符实体为 `>`,对应的字符是 `>`。
* 小于号:字符实体为 `<`,对应的字符是 `<`。
* 斜线号:字符实体为 `⁄`,对应的字符是 `/`。
给你输入字符串 `text`,请你实现一个 HTML 实体解析器,返回解析器解析后的结果。
示例 1:
```
输入:text = "& is an HTML entity but &ambassador; is not."
输出:"& is an HTML entity but &ambassador; is not."
解释:解析器把字符实体 & 用 & 替换
```
示例 2:
```
输入:text = "and I quote: "...""
输出:"and I quote: \"...\""
```
示例 3:
```
输入:text = "Stay home! Practice on Leetcode :)"
输出:"Stay home! Practice on Leetcode :)"
```
示例 4:
```
输入:text = "x > y && x < y is always false"
输出:"x > y && x < y is always false"
```
示例 5:
```
输入:text = "leetcode.com⁄problemset⁄all"
输出:"leetcode.com/problemset/all"
```
提示:
* $1 <= text.length <= 10^5$
* 字符串可能包含 $256$ 个`ASCII` 字符中的任意字符。 | ### 模拟
每个特殊字符均以 `&` 开头,最长一个特殊字符为 `⁄`。
从前往后处理 `text`,若遇到 `&` 则往后读取最多 $6$ 个字符(中途遇到结束字符 `;` 则终止),若读取子串为特殊字符,将使用替换字符进行拼接,否则使用原字符进行拼接。
Java 代码:
```Java
class Solution {
public String entityParser(String text) {
Map<String, String> map = new HashMap<>(){{
put(""", "\"");
put("'", "'");
put("&", "&");
put(">", ">");
put("<", "<");
put("⁄", "/");
}};
int n = text.length();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ) {
if (text.charAt(i) == '&') {
int j = i + 1;
while (j < n && j - i < 6 && text.charAt(j) != ';') j++;
String sub = text.substring(i, Math.min(j + 1, n));
if (map.containsKey(sub)) {
sb.append(map.get(sub));
i = j + 1;
continue;
}
}
sb.append(text.charAt(i++));
}
return sb.toString();
}
}
```
C++ 代码:
```C++
class Solution {
public:
string entityParser(string text) {
unordered_map<string, string> entityMap = {
{""", "\""},
{"'", "'"},
{"&", "&"},
{">", ">"},
{"<", "<"},
{"⁄", "/"}
};
int n = text.length();
string ans = "";
for (int i = 0; i < n; ) {
if (text[i] == '&') {
int j = i + 1;
while (j < n && j - i < 6 && text[j] != ';') j++;
string sub = text.substr(i, min(j + 1, n) - i);
if (entityMap.find(sub) != entityMap.end()) {
ans += entityMap[sub];
i = j + 1;
continue;
}
}
ans += text[i++];
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def entityParser(self, text: str) -> str:
entity_map = {
""": "\"",
"'": "'",
"&": "&",
">": ">",
"<": "<",
"⁄": "/"
}
i, n = 0, len(text)
ans = ""
while i < n:
if text[i] == '&':
j = i + 1
while j < n and j - i < 6 and text[j] != ';':
j += 1
sub = text[i:min(j + 1, n)]
if sub in entity_map:
ans += entity_map[sub]
i = j + 1
continue
ans += text[i]
i += 1
return ans
```
TypeScript 代码:
```TypeScript
function entityParser(text: string): string {
const entityMap: { [key: string]: string } = {
""": "\"",
"'": "'",
"&": "&",
">": ">",
"<": "<",
"⁄": "/"
};
const n = text.length;
let ans = "";
for (let i = 0; i < n; ) {
if (text[i] == '&') {
let j = i + 1;
while (j < n && j - i < 6 && text[j] != ';') j++;
const sub = text.substring(i, Math.min(j + 1, n));
if (entityMap[sub]) {
ans += entityMap[sub];
i = j + 1;
continue;
}
}
ans += text[i++];
}
return ans;
};
```
* 时间复杂度:$O(n \times K)$,其中 $K = 6$ 为最大特殊字符长度
* 空间复杂度:$O(C)$,一个固定大小的哈希表 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1410` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/141. 环形链表（简单）.md | 141. 环形链表 | https://leetcode.cn/problems/linked-list-cycle/solution/by-ac_oier-lfgr/ | 简单 | [
"链表",
"快慢指针",
"双指针"
] | 给你一个链表的头节点 `head`,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪 `next` 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置(索引从 $0$ 开始)。注意:`pos` 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ,则返回 true 。 否则,返回 false 。
示例 1:
```
输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。
```
示例 2:
```
输入:head = [1,2], pos = 0
输出:true
解释:链表中有一个环,其尾部连接到第一个节点。
```
示例 3:
```
输入:head = [1], pos = -1
输出:false
解释:链表中没有环。
```
提示:
* 链表中节点的数目范围是 $[0, 10^4]$
* $-10^5 <= Node.val <= 10^5$
* `pos` 为 `-1` 或者链表中的一个 有效索引 。
进阶:你能用 $O(1)$(即,常量)内存解决此问题吗? | ### 快慢指针
这是一道「快慢指针」的模板题。
使用两变量 `slow` 和 `fast` 分别代表快慢指针,`slow` 每次往后走一步,而 `fast` 每次往后两步,两者初始化均为 `head`。
若链表无环,则 `fast` 必然会先走到结尾,算法正常结束;若链表有环,当 `slow` 来到环入口时,`fast` 必然已经在环中的某个位置,此时再继续进行,由于存在速度差,发生相遇必不可能是 `slow` 追上 `fast`,而只能是 `fast` 从后方追上 `slow`,由于速度差为 $1$,因此最多会消耗不超过环节点个数的回合,两者即会相遇。
代码:
```Java
public class Solution {
public boolean hasCycle(ListNode head) {
ListNode slow = head, fast = head;
while (fast != null && fast.next != null) {
slow = slow.next; fast = fast.next.next;
if (slow == fast) return true;
}
return false;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.141` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/142. 环形链表 II（中等）.md | 142. 环形链表 II | https://leetcode.cn/problems/linked-list-cycle-ii/solution/by-ac_oier-xw16/ | 中等 | [
"链表",
"快慢指针",
"双指针"
] | 给定一个链表的头节点 `head`,返回链表开始入环的第一个节点。 如果链表无环,则返回 `null`。
如果链表中有某个节点,可以通过连续跟踪 `next` 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置(索引从 `0` 开始)。如果 `pos` 是 `-1`,则在该链表中没有环。
注意:`pos` 不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1:
```
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。
```
示例 2:
```
输入:head = [1,2], pos = 0
输出:返回索引为 0 的链表节点
解释:链表中有一个环,其尾部连接到第一个节点。
```
示例 3:
```
输入:head = [1], pos = -1
输出:返回 null
解释:链表中没有环。
```
提示:
* 链表中节点的数目范围在范围 $[0, 10^4]$ 内
* $-10^5 <= Node.val <= 10^5$
* `pos` 的值为 `-1` 或者链表中的一个有效索引
进阶:你是否可以使用 $O(1)$ 空间解决此题? | ### 快慢指针
起始使用 `slow` 和 `fast` 作为慢快指针(`slow` 每次走一步,`fast` 每次走两步),起始均为 `head`。
若 `fast` 顺利走到结尾,说明链表无环,直接返回 `null`;
若两者成功相遇,说明链表有环。我们定义链表起点到环入口距离为 `x`,环内节点数量为 `y`。那么从链表起点到环入口的任意路径都能归纳成 $x + k \times y$(其中 $k$ 为大于等于 $0$ 的任意值)。
当两者首次相遇时,假设 `slow` 走的距离为 `d1`,而 `fast` 走的距离为 `d2`,根据速度差定义可知 $d2 = d1 \times 2$。同时根据 [141. 环形链表](https://leetcode.cn/problems/linked-list-cycle/solution/by-ac_oier-lfgr/) 结论,两者必然在环中相遇,且必然是 `fast` 在环内从后面追上 `slow`,因此 `d2` 相比于 `d1` 必然是多了 `y` 的整数倍,即有 $d2 = d1 + m \times y$(其中 $m$ 为圈数),即可推导出 $d1 = m \times y$。
同时根据链表起点到环入口的任意路径均表示为 $x + k \times y$,我们知道如果 `slow` 再走 `x` 步会到达环入口,同时链表起点到环入口也是 `x` 步,因此我们可以复用 `fast`,将其复位到链表起点,和 `slow` 一起每次往前一步,当两者再次相遇,必然是同时位于环入口。
同时该做法容易拓展成求 `x` 和求 `y` 等问题。
代码:
```Java
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode base = head;
ListNode slow = head, fast = head;
boolean ok = false;
while (!ok && fast != null && fast.next != null) {
slow = slow.next; fast = fast.next.next;
if (slow == fast) ok = true;
}
if (!ok) return null;
fast = head;
while (slow != fast) {
slow = slow.next; fast = fast.next;
}
return slow;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.142` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/146. LRU 缓存机制（中等）.md | 146. LRU 缓存机制 | https://leetcode-cn.com/problems/lru-cache/solution/gong-shui-san-xie-she-ji-shu-ju-jie-gou-68hv2/ | 中等 | [
"设计",
"链表",
"哈希表"
] | 运用你所掌握的数据结构,设计和实现一个 `LRU` (最近最少使用) 缓存机制 。
实现 `LRUCache` 类:
* `LRUCache(int capacity)` 以正整数作为容量 `capacity` 初始化 `LRU` 缓存
* `int get(int key)` 如果关键字 `key` 存在于缓存中,则返回关键字的值,否则返回 $-1$
* `void put(int key, int value)` 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。
进阶:你是否可以在 $O(1)$ 时间复杂度内完成这两种操作?
示例:
```
输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
```
提示:
* $1 <= capacity <= 3000$
* $0 <= key <= 3000$
* $0 <= value <= 10^4$
* 最多调用 $3 * 10^4$ 次 `get` 和 `put` | ### 基本分析
LRU 是一种十分常见的页面置换算法。
将 LRU 翻译成大白话就是:**当不得不淘汰某些数据时(通常是容量已满),选择最久未被使用的数据进行淘汰。**
**题目让我们实现一个容量固定的 `LRUCache` 。如果插入数据时,发现容器已满时,则先按照 LRU 规则淘汰一个数据,再将新数据插入,其中「插入」和「查询」都算作一次“使用”。**
可以通过 🌰 来理解,假设我们有容量为 $2$ 的 `LRUCache` 和 测试键值对 `[1-1,2-2,3-3]` ,将其按照顺序进行插入 & 查询:
* 插入 `1-1`,此时最新的使用数据为 `1-1`
* 插入 `2-2`,此时最新使用数据变为 `2-2`
* 查询 `1-1`,此时最新使用数据为 `1-1`
* 插入 `3-3`,由于容器已经达到容量,需要先淘汰已有数据才能插入,这时候会淘汰 `2-2`,`3-3` 成为最新使用数据
键值对存储方面,我们可以使用「哈希表」来确保插入和查询的复杂度为 $O(1)$。
另外我们还需要额外维护一个「使用顺序」序列。
我们期望当「新数据被插入」或「发生键值对查询」时,能够将当前键值对放到序列头部,这样当触发 LRU 淘汰时,只需要从序列尾部进行数据删除即可。
**期望在 $O(1)$ 复杂度内调整某个节点在序列中的位置,很自然想到双向链表。**
----
### 双向链表
具体的,我们使用哈希表来存储「键值对」,键值对的键作为哈希表的 Key,而哈希表的 Value 则使用我们自己封装的 `Node` 类,`Node` 同时作为双向链表的节点。
* 插入:检查当前键值对是否已经存在于哈希表:
* 如果存在,则更新键值对,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)
* 如果不存在,则检查哈希表容量是否已经达到容量:
* 没达到容量:插入哈希表,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)
* 已达到容量:先从链表尾部找到待删除元素进行删除(`delete` 操作),然后再插入哈希表,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)
* 查询:如果没在哈希表中找到该 Key,直接返回 $-1$;如果存在该 Key,则将对应的值返回,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)
一些细节: 为了减少双向链表左右节点的「判空」操作,我们预先建立两个「哨兵」节点 `head` 和 `tail`。
代码:
```Java
class LRUCache {
class Node {
int k, v;
Node l, r;
Node(int _k, int _v) {
k = _k;
v = _v;
}
}
int n;
Node head, tail;
Map<Integer, Node> map;
public LRUCache(int capacity) {
n = capacity;
map = new HashMap<>();
head = new Node(-1, -1);
tail = new Node(-1, -1);
head.r = tail;
tail.l = head;
}
public int get(int key) {
if (map.containsKey(key)) {
Node node = map.get(key);
refresh(node);
return node.v;
}
return -1;
}
public void put(int key, int value) {
Node node = null;
if (map.containsKey(key)) {
node = map.get(key);
node.v = value;
} else {
if (map.size() == n) {
Node del = tail.l;
map.remove(del.k);
delete(del);
}
node = new Node(key, value);
map.put(key, node);
}
refresh(node);
}
// refresh 操作分两步:
// 1. 先将当前节点从双向链表中删除(如果该节点本身存在于双向链表中的话)
// 2. 将当前节点添加到双向链表头部
void refresh(Node node) {
delete(node);
node.r = head.r;
node.l = head;
head.r.l = node;
head.r = node;
}
// delete 操作:将当前节点从双向链表中移除
// 由于我们预先建立 head 和 tail 两位哨兵,因此如果 node.l 不为空,则代表了 node 本身存在于双向链表(不是新节点)
void delete(Node node) {
if (node.l != null) {
Node left = node.l;
left.r = node.r;
node.r.l = left;
}
}
}
```
* 时间复杂度:各操作均为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.146` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/149. 直线上最多的点数（困难）.md | 149. 直线上最多的点数 | https://leetcode-cn.com/problems/max-points-on-a-line/solution/gong-shui-san-xie-liang-chong-mei-ju-zhi-u44s/ | 困难 | [
"数学",
"枚举",
"哈希表"
] | 给你一个数组 `points`,其中 $points[i] = [x_i, y_i]$ 表示 `X-Y` 平面上的一个点。求最多有多少个点在同一条直线上。
示例 1:
```
输入:points = [[1,1],[2,2],[3,3]]
输出:3
```
示例 2:
```
输入:points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出:4
```
提示:
* $1 <= points.length <= 300$
* $points[i].length == 2$
* $-10^4 <= x_i, y_i <= 10^4$
* `points` 中的所有点 互不相同 | ### 枚举直线 + 枚举统计
我们知道,两点可以确定一条线。
一个朴素的做法是先枚举两点(确定一条线),然后检查其余点是否落在该线中。
为避免除法精度问题,当我们枚举两个点 $x$ 和 $y$ 时,不直接计算其对应直线的 `斜率`和 `截距`。
而是通过判断 $x$ 和 $y$ 与第三个点 $p$ 形成的两条直线斜率是否相等,来得知点 $p$ 是否落在该直线上。
斜率相等的两条直线要么平行,要么重合。
平行需要 $4$ 个点来唯一确定,我们只有 $3$ 个点,因此直接判定两条直线是否重合即可。
详细说,当给定两个点 $(x_1, y_1)$ 和 $(x_2, y_2)$ 时,对应斜率 $\frac{y_2 - y_1}{x_2 - x_1}$。
为避免计算机除法的精度问题,我们将「判定 $\frac{a_y - b_y}{a_x - b_x} = \frac{b_y - c_y}{b_x - c_x}$ 是否成立」改为「判定 $(a_y - b_y) \times (b_x - c_x) = (a_x - b_x) \times (b_y - c_y)$ 是否成立」。
将存在精度问题的「除法判定」巧妙转为「乘法判定」。
Java 代码:
```Java
class Solution {
public int maxPoints(int[][] points) {
int n = points.length, ans = 1;
for (int i = 0; i < n; i++) {
int[] x = points[i];
for (int j = i + 1; j < n; j++) {
int[] y = points[j];
// 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上
int cnt = 2;
for (int k = j + 1; k < n; k++) {
int[] p = points[k];
int s1 = (y[1] - x[1]) * (p[0] - y[0]);
int s2 = (p[1] - y[1]) * (y[0] - x[0]);
if (s1 == s2) cnt++;
}
ans = Math.max(ans, cnt);
}
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxPoints(vector<vector<int>>& points) {
int n = points.size(), ans = 1;
for (int i = 0; i < n; i++) {
vector<int> x = points[i];
for (int j = i + 1; j < n; j++) {
vector<int> y = points[j];
// 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上
int cnt = 2;
for (int k = j + 1; k < n; k++) {
vector<int> p = points[k];
int s1 = (y[1] - x[1]) * (p[0] - y[0]);
int s2 = (p[1] - y[1]) * (y[0] - x[0]);
if (s1 == s2) cnt++;
}
ans = max(ans, cnt);
}
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maxPoints(self, points: List[List[int]]) -> int:
n, ans = len(points), 1
for i, x in enumerate(points):
for j in range(i + 1, n):
y = points[j]
# 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上
cnt = 2
for k in range(j + 1, n):
p = points[k]
s1 = (y[1] - x[1]) * (p[0] - y[0])
s2 = (p[1] - y[1]) * (y[0] - x[0])
if s1 == s2: cnt += 1
ans = max(ans, cnt)
return ans
```
TypeScript 代码:
```TypeScript
function maxPoints(points: number[][]): number {
let n = points.length, ans = 1;
for (let i = 0; i < n; i++) {
let x = points[i];
for (let j = i + 1; j < n; j++) {
// 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上
let y = points[j], cnt = 2;
for (let k = j + 1; k < n; k++) {
let p = points[k];
let s1 = (y[1] - x[1]) * (p[0] - y[0]);
let s2 = (p[1] - y[1]) * (y[0] - x[0]);
if (s1 == s2) cnt++;
}
ans = Math.max(ans, cnt);
}
}
return ans;
};
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(1)$
---
### 枚举直线 + 哈希表统计
根据「朴素解法」的思路,枚举所有直线的过程不可避免,但统计点数的过程可以优化。
具体的,我们可以先枚举所有可能出现的 `直线斜率`(根据两点确定一条直线,即枚举所有的「点对」),使用「哈希表」统计所有 `斜率` 对应的点的数量,在所有值中取个 $max$ 即是答案。
一些细节:在使用「哈希表」进行保存时,为了避免精度问题,我们直接使用字符串进行保存,同时需要将 `斜率` 约干净。
Java 代码:
```Java
class Solution {
public int maxPoints(int[][] points) {
int n = points.length, ans = 1;
for (int i = 0; i < n; i++) {
Map<String, Integer> map = new HashMap<>();
// 由当前点 i 发出的直线所经过的最多点数量
int max = 0;
for (int j = i + 1; j < n; j++) {
int x1 = points[i][0], y1 = points[i][1], x2 = points[j][0], y2 = points[j][1];
int a = x1 - x2, b = y1 - y2;
int k = gcd(a, b);
String key = (a / k) + "_" + (b / k);
map.put(key, map.getOrDefault(key, 0) + 1);
max = Math.max(max, map.get(key));
}
ans = Math.max(ans, max + 1);
}
return ans;
}
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxPoints(vector<vector<int>>& points) {
int n = points.size(), ans = 1;
for (int i = 0; i < n; i++) {
map<string, int> map;
int maxv = 0;
for (int j = i + 1; j < n; j++) {
int x1 = points[i][0], y1 = points[i][1], x2 = points[j][0], y2 = points[j][1];
int a = x1 - x2, b = y1 - y2;
int k = gcd(a, b);
string key = to_string(a / k) + "_" + to_string(b / k);
map[key]++;
maxv = max(maxv, map[key]);
}
ans = max(ans, maxv + 1);
}
return ans;
}
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
};
```
Python 代码:
```Python
class Solution:
def maxPoints(self, points):
def gcd(a, b):
return a if b == 0 else gcd(b, a % b)
n, ans = len(points), 1
for i in range(n):
mapping = {}
maxv = 0
for j in range(i + 1, n):
x1, y1 = points[i]
x2, y2 = points[j]
a, b = x1 - x2, y1 - y2
k = gcd(a, b)
key = str(a // k) + "_" + str(b // k)
mapping[key] = mapping.get(key, 0) + 1
maxv = max(maxv, mapping[key])
ans = max(ans, maxv + 1)
return ans
```
TypeScript 代码:
```TypeScript
function maxPoints(points: number[][]): number {
const gcd = function(a: number, b: number): number {
return b == 0 ? a : gcd(b, a % b);
}
let n = points.length, ans = 1;
for (let i = 0; i < n; i++) {
let mapping = {}, maxv = 0;
for (let j = i + 1; j < n; j++) {
let x1 = points[i][0], y1 = points[i][1], x2 = points[j][0], y2 = points[j][1];
let a = x1 - x2, b = y1 - y2;
let k = gcd(a, b);
let key = `${a / k}_${b / k}`;
mapping[key] = mapping[key] ? mapping[key] + 1 : 1;
maxv = Math.max(maxv, mapping[key]);
}
ans = Math.max(ans, maxv + 1);
}
return ans;
};
```
* 时间复杂度:枚举所有直线的复杂度为 $O(n^2)$;令坐标值的最大差值为 $m$,`gcd` 复杂度为 $O(\log{m})$。整体复杂度为 $O(n^2 \times \log{m})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.149` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/141-150/150. 逆波兰表达式求值（中等）.md | 150. 逆波兰表达式求值 | https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/solution/yi-ti-shuang-jie-xi-tong-zhan-shu-zu-mo-i1eq3/ | 中等 | [
"表达式计算"
] | 根据 逆波兰表示法,求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。
说明:
* 整数除法只保留整数部分。
* 给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1:
```
输入:tokens = ["2","1","+","3","*"]
输出:9
解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9
```
示例 2:
```
输入:tokens = ["4","13","5","/","+"]
输出:6
解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6
```
示例 3:
```
输入:tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出:22
解释:
该算式转化为常见的中缀算术表达式为:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
```
提示:
* 1 <= tokens.length <= $10^4$
* tokens[i] 要么是一个算符("+"、"-"、"*" 或 "/"),要么是一个在范围 [-200, 200] 内的整数
逆波兰表达式:
逆波兰表达式是一种后缀表达式,所谓后缀就是指算符写在后面。
* 平常使用的算式则是一种中缀表达式,如 ( 1 + 2 ) * ( 3 + 4 ) 。
* 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点:
* 去掉括号后表达式无歧义,上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
* 适合用栈操作运算:遇到数字则入栈;遇到算符则取出栈顶两个数字进行计算,并将结果压入栈中。 | ### 基本思路
这是一道关于「表达式计算」的题目。
所有的「表达式计算」问题都离不开「栈」。
对于本题,我们可以建立一个「数字栈」,存放所有的数字,当遇到运算符时,从栈中取出两个数进行运算,并将结果放回栈内,整个过程结束后,栈顶元素就是最终结果。
而栈的实现通常有两种:使用数组继续模拟 & 使用系统自带的栈结构
***
### 数组模拟栈解法
代码:
```java []
class Solution {
public int evalRPN(String[] ts) {
int[] d = new int[ts.length];
int hh = 0, tt = -1;
for (String s : ts) {
if ("+-*/".contains(s)) {
int b = d[tt--], a = d[tt--];
d[++tt] = calc(a, b, s);
} else {
d[++tt] = Integer.parseInt(s);
}
}
return d[tt];
}
int calc(int a, int b, String op) {
if (op.equals("+")) return a + b;
else if (op.equals("-")) return a - b;
else if (op.equals("*")) return a * b;
else if (op.equals("/")) return a / b;
else return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 自带栈解法
代码:
```java
class Solution {
public int evalRPN(String[] ts) {
Deque<Integer> d = new ArrayDeque<>();
for (String s : ts) {
if ("+-*/".contains(s)) {
int b = d.pollLast(), a = d.pollLast();
d.addLast(calc(a, b, s));
} else {
d.addLast(Integer.parseInt(s));
}
}
return d.pollLast();
}
int calc(int a, int b, String op) {
if (op.equals("+")) return a + b;
else if (op.equals("-")) return a - b;
else if (op.equals("*")) return a * b;
else if (op.equals("/")) return a / b;
else return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
***
### 其他
关于「表达式计算」,类似的题目在上周的「每日一题」也出现过:
* [224. 基本计算器](https://leetcode-cn.com/problems/basic-calculator/solution/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/):包含符号 `+ - ( )`
* [227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) :包含符号 `+ - * /`
* [772. 基本计算器 III](https://leetcode-cn.com/problems/basic-calculator-iii/) :有锁题,包含符号 `+ - * / ( )`
* [770. 基本计算器 IV](https://leetcode-cn.com/problems/basic-calculator-iv/) : 包含自定义函数符号 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.150` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1413. 逐步求和得到正数的最小值（简单）.md | 1413. 逐步求和得到正数的最小值 | https://leetcode.cn/problems/minimum-value-to-get-positive-step-by-step-sum/solution/by-ac_oier-qo4e/ | 简单 | [
"模拟"
] | 给你一个整数数组 `nums`。你可以选定任意的正数 `startValue` 作为初始值。
你需要从左到右遍历 `nums` 数组,并将 `startValue` 依次累加上 `nums` 数组中的值。
请你在确保累加和始终大于等于 $1$ 的前提下,选出一个最小的 正数 作为 `startValue`。
示例 1:
```
输入:nums = [-3,2,-3,4,2]
输出:5
解释:如果你选择 startValue = 4,在第三次累加时,和小于 1 。
累加求和
startValue = 4 | startValue = 5 | nums
(4 -3 ) = 1 | (5 -3 ) = 2 | -3
(1 +2 ) = 3 | (2 +2 ) = 4 | 2
(3 -3 ) = 0 | (4 -3 ) = 1 | -3
(0 +4 ) = 4 | (1 +4 ) = 5 | 4
(4 +2 ) = 6 | (5 +2 ) = 7 | 2
```
示例 2:
```
输入:nums = [1,2]
输出:1
解释:最小的 startValue 需要是正数。
```
示例 3:
```
输入:nums = [1,-2,-3]
输出:5
```
提示:
* $1 <= nums.length <= 100$
* $-100 <= nums[i] <= 100$ | ### 模拟
由于 `startValue` 可设定的最小值为 $1$,我们可以先统计当 `startValue = 1` 时,累加过程中的最小值 `min`。
根据 `min` 是否符合规定(大于等于 $1$)来决定如何调整:
* 若 `min` 满足大于等于 $1$,则 `startValue` 可取最小值 $1$;
* 若 `min` 不满足大于等于 $1$,计算将 `min` 调整到 $1$ 所需要的值(即 `1 - min`),将其累加到起始值上,即得答案 `2 - min`。
Java 代码:
```Java
class Solution {
public int minStartValue(int[] nums) {
int n = nums.length, min = 0x3f3f3f3f;
for (int i = 0, j = 1; i < n; i++) {
j = j + nums[i];
min = Math.min(min, j);
}
return min < 1 ? 2 - min : 1;
}
}
```
TypeScript 代码:
```TypeScript
function minStartValue(nums: number[]): number {
let n = nums.length, min = 0x3f3f3f3f
for (let i = 0, j = 1; i < n; i++) {
j = j + nums[i]
min = Math.min(min, j)
}
return min < 1 ? 2 - min : 1
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1413` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1414. 和为 K 的最少斐波那契数字数目（中等）.md | 1414. 和为 K 的最少斐波那契数字数目 | https://leetcode-cn.com/problems/find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-rgty8/ | 中等 | [
"数学",
"二分",
"贪心"
] | 给你数字 `k` ,请你返回和为 `k` 的斐波那契数字的最少数目,其中,每个斐波那契数字都可以被使用多次。
斐波那契数字定义为:
* F1 = 1
* F2 = 1
* Fn = Fn-1 + Fn-2 , 其中 n > 2 。
数据保证对于给定的 `k` ,一定能找到可行解。
示例 1:
```
输入:k = 7
输出:2
解释:斐波那契数字为:1,1,2,3,5,8,13,......
对于 k = 7 ,我们可以得到 2 + 5 = 7 。
```
示例 2:
```
输入:k = 10
输出:2
解释:对于 k = 10 ,我们可以得到 2 + 8 = 10 。
```
示例 3:
```
输入:k = 19
输出:3
解释:对于 k = 19 ,我们可以得到 1 + 5 + 13 = 19 。
```
提示:
* $1 <= k <= 10^9$ | ### 打表 + 贪心 + 二分
利用 `k` 的数据范围为 $1 <= k <= 10^9$,可以先使用 `static` 进行打表,预处理出值不超过 $10^9$ 的斐波那契数,存入数组 `list` 中。
然后考虑如何使用 `list` 中的数字(可重复)凑成 `k`。
一个直观的想法是:**每次从 `list` 中找到不超过 `k` 的最大数,用于进行对 `k` 的消减,直到 `k` 被消减到 $0$ 为止,消减的次数即是答案。**
而「从 `list` 中找到不超过 `k` 的最大数」这一操作,可使用「二分」。
下面证明该做法的正确性:
假定该做法所得到的可行解序列为 `A`(序列长度为 $ans$),真实最优解序列为 `B`(序列长度为 $min$)。
假设两者长度不等(只能是 $ans > min$),这意味着我们将 `A` 和 `B` 之间的相同的元素去掉后,剩余元素序列有如下结论:
* 「`A` 序列剩余元素之和」等于「`B` 序列剩余元素之和」;
* 「`A` 序列剩余元素个数」大于「`B` 序列剩余元素个数」。
`A'` 为 `A` 的剩余元素序列,`B'` 为 `B` 的剩余元素序列。
我们知道 `A'` 中的最大数必然大于 `B'` 中的最大数。不可能是等于关系(相等元素均被去掉),也不可能是小于关系,否则在构造 `A` 序列的时候就会按照生成 `B` 序列的方向进行构造。
**但要只靠该性质,要证明不存在满足上述结论的斐波那契数组合仍是困难。**
**我们可以从「斐波那契数」性质出发,挖掘可行解 `A` 的某些性质,然后证明不存在不满足该性质的方案比 `A` 更优即可。**
对于可行解 `A` 而言,由于我们「每次都选择不超过当前 `k` 的最大数」,因此必然**可行解中必然不存在两项相邻的斐波那契数**,否则会在选择 $f_i$ 和 $f_{i+1}$ 之前先因为「每次都选择不超过当前 `k` 的最大数」而先选择 $f_{i+2}$。
同时,由于 $f_i=f_{i-1}+f_{i-2}$、$f_{i+1}=f_{i}+f_{i-1}$ 和 $f_{i+2}=f_{i+1}+f_{i}$ 可得 $2 * f_{i}=f_{i+1}+f_{i-2}$。
也就是说**可行解 `A` 中必然不会出现相同值**,否则会在选择 $f_i$ 之前先因为「每次都选择不超过当前 `k` 的最大数」而先选择 $f_{i+1}$。
该推理对于边界特殊值 $1$ 同样成立,如果可行解 `A` 中存在多个 $1$,则必然会先因为「每次都选择不超过当前 `k` 的最大数」选择 $f_3=2$。
**再根据「斐波那契数奇偶数项求和」可知:$a_1 + a_3 + ... + a_{2n - 1} = a_{2n}$ 和 $a_2 + a_4 + ... + a_{2n} = a_{2n+1} - 1$。**
**综上,可以证明不存在比可行解 `A` 更短的最优解。**
代码:
```Java
class Solution {
static List<Integer> list = new ArrayList<>();
static {
list.add(1);
int a = 1, b = 1;
while (b <= (int)1e9) {
int c = a + b;
a = b; b = c;
list.add(c);
}
}
public int findMinFibonacciNumbers(int k) {
int ans = 0;
while (k != 0) {
int l = 0, r = list.size() - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (list.get(mid) <= k) l = mid;
else r = mid - 1;
}
k -= list.get(r);
ans++;
}
return ans;
}
}
```
* 时间复杂度:令值不超过 $10^9$ 的斐波那契数的数量为 `C`,复杂度为 $O(\log{k} * \log{C})$
* 空间复杂度:$O(C)$
---
### 贪心
上述做法,由于预处理了所有值不超过 $10^9$ 的斐波那契数,导致无法直接取得「值不超过 `k` 的最大数」,需要再套一层「二分」。
不采用预处理的方式,利用斐波那契数列的递推性质,以及凑成 `k` 的最优解中不包含重复数字的结论,我们可以做到 $O(\log{k})$ 时间复杂度和 $O(1)$ 空间复杂度。
代码:
```Java
class Solution {
public int findMinFibonacciNumbers(int k) {
int a = 1, b = 1;
while (b <= k) {
int c = a + b;
a = b; b = c;
}
int ans = 0;
while (k != 0) {
if (k >= b) {
k -= b; ans++;
}
int c = b - a;
b = a; a = c;
}
return ans;
}
}
```
* 时间复杂度:$O(\log{k})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1414` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1417. 重新格式化字符串（简单）.md | 1417. 重新格式化字符串 | https://leetcode.cn/problems/reformat-the-string/solution/by-ac_oier-uk8z/ | 简单 | [
"模拟",
"双指针"
] | 给你一个混合了数字和字母的字符串 `s`,其中的字母均为小写英文字母。
请你将该字符串重新格式化,使得任意两个相邻字符的类型都不同。也就是说,字母后面应该跟着数字,而数字后面应该跟着字母。
请你返回重新格式化后的字符串;如果无法按要求重新格式化,则返回一个空字符串。
示例 1:
```
输入:s = "a0b1c2"
输出:"0a1b2c"
解释:"0a1b2c" 中任意两个相邻字符的类型都不同。 "a0b1c2", "0a1b2c", "0c2a1b" 也是满足题目要求的答案。
```
示例 2:
```
输入:s = "leetcode"
输出:""
解释:"leetcode" 中只有字母,所以无法满足重新格式化的条件。
```
示例 3:
```
输入:s = "1229857369"
输出:""
解释:"1229857369" 中只有数字,所以无法满足重新格式化的条件。
```
示例 4:
```
输入:s = "covid2019"
输出:"c2o0v1i9d"
```
示例 5:
```
输入:s = "ab123"
输出:"1a2b3"
```
提示:
* $1 <= s.length <= 500$
* `s` 仅由小写英文字母和/或数字组成。 | ### 模拟
起始先对字符串 `s` 进行遍历,将其分成字母串和数字串,若两者长度差值超过 $1$,说明无法构造成间隔字符串(返回空串),否则对两字符串使用双指针算法进行构造。
Java 代码:
```Java
class Solution {
public String reformat(String s) {
StringBuilder a = new StringBuilder(), b = new StringBuilder();
for (char c : s.toCharArray()) {
if (c >= 'a') a.append(c);
else b.append(c);
}
int n = a.length(), m = b.length(), tot = n + m;
if (Math.abs(n - m) > 1) return "";
StringBuilder sb = new StringBuilder();
while (sb.length() != tot) {
if (n > m) sb.append(a.charAt(--n));
else if (n < m) sb.append(b.charAt(--m));
else {
if (!sb.isEmpty() && sb.charAt(sb.length() - 1) >= 'a') sb.append(b.charAt(--m));
else sb.append(a.charAt(--n));
}
}
return sb.toString();
}
}
```
TypeScript 代码:
```TypeScript
function reformat(s: string): string {
let a = "", b = ""
for (let i = 0; i < s.length; i++) {
if (s[i] >= 'a') a += s[i]
else b += s[i]
}
let n = a.length, m = b.length, tot = n + m
if (Math.abs(n - m) > 1) return ""
let ans = ""
while (ans.length < tot) {
if (n < m) ans += b[--m]
else if (n > m) ans += a[--n]
else {
if (ans.length != 0 && ans[ans.length - 1] >= 'a') ans += b[--m]
else ans += a[--n]
}
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1417` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1411-1420/1418. 点菜展示表（中等）.md | 1418. 点菜展示表 | https://leetcode-cn.com/problems/display-table-of-food-orders-in-a-restaurant/solution/gong-shui-san-xie-ha-xi-biao-yu-hong-hei-jmli/ | 中等 | [
"数据结构",
"哈希表",
"红黑树"
] | 给你一个数组 orders,表示客户在餐厅中完成的订单,确切地说, `orders[i]=[customerNamei,tableNumberi,foodItemi] `,其中 `customerNamei `是客户的姓名,`tableNumberi `是客户所在餐桌的桌号,而 `foodItemi `是客户点的餐品名称。
请你返回该餐厅的 点菜展示表 。在这张表中,表中第一行为标题,其第一列为餐桌桌号 “Table” ,后面每一列都是按字母顺序排列的餐品名称。接下来每一行中的项则表示每张餐桌订购的相应餐品数量,第一列应当填对应的桌号,后面依次填写下单的餐品数量。
注意:客户姓名不是点菜展示表的一部分。此外,表中的数据行应该按餐桌桌号升序排列。
示例 1:
```
输入:orders = [["David","3","Ceviche"],["Corina","10","Beef Burrito"],["David","3","Fried Chicken"],["Carla","5","Water"],["Carla","5","Ceviche"],["Rous","3","Ceviche"]]
输出:[["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]]
解释:
点菜展示表如下所示:
Table,Beef Burrito,Ceviche,Fried Chicken,Water
3 ,0 ,2 ,1 ,0
5 ,0 ,1 ,0 ,1
10 ,1 ,0 ,0 ,0
对于餐桌 3:David 点了 "Ceviche" 和 "Fried Chicken",而 Rous 点了 "Ceviche"
而餐桌 5:Carla 点了 "Water" 和 "Ceviche"
餐桌 10:Corina 点了 "Beef Burrito"
```
示例 2:
```
输入:orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"],["Adam","1","Canadian Waffles"],["Brianna","1","Canadian Waffles"]]
输出:[["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]]
解释:
对于餐桌 1:Adam 和 Brianna 都点了 "Canadian Waffles"
而餐桌 12:James, Ratesh 和 Amadeus 都点了 "Fried Chicken"
```
示例 3:
```
输入:orders = [["Laura","2","Bean Burrito"],["Jhon","2","Beef Burrito"],["Melissa","2","Soda"]]
输出:[["Table","Bean Burrito","Beef Burrito","Soda"],["2","1","1","1"]]
```
提示:
* 1 <= orders.length <= 5 * $10^4$
* orders[i].length == 3
* 1 <= customerNamei.length, foodItemi.length <= 20
* customerNamei 和 foodItemi 由大小写英文字母及空格字符 ' ' 组成。
* tableNumberi 是 1 到 500 范围内的整数。 | ### 基本分析
这是一道考虑「数据结构运用」与「简单设计」的模拟题。
我们可以根据最终的 “结果” 反推数据结构存储格式。
最终 “结果” 包含两部分:
1. `title` : 由 **"Table" + 排序去重的餐品** 组成
2. 内容 : 由 **桌号 + 每件餐品对应的数量** 组成
基于此,不难设计出使用 `Set` 存储 `title` 相关内容,使用 `Map` 存储内容相关部分。
去重 `Map` 的部分 `Key` 为桌号,同时为了快速索引当前桌号「某个餐品的数量」,需要再套一层 `Map`。即最终存储格式为 `桌号 : {餐品 : 个数}`。
---
### HashSet & HashMap
有了基本分析,我们可以使用最常规的 `HashSet` 和 `HashMap` 进行实现。
由于 `HashSet` 是基于 `HashMap`,而 `HashMap` 的底层数据结构实现是 **哈希表**,因此我们需要在构造答案时手动排个序。
代码:
```Java
class Solution {
public List<List<String>> displayTable(List<List<String>> os) {
List<List<String>> ans = new ArrayList<>();
// 桌号 : {餐品 : 个数}(用于构造内容)
Map<Integer, Map<String, Integer>> tm = new HashMap<>();
// 餐品(用于构造 title)
Set<String> ts = new HashSet<>();
for (List<String> o : os) {
String c = o.get(0), t = o.get(1), f = o.get(2);
Integer tidx = Integer.parseInt(t);
ts.add(f);
Map<String, Integer> map = tm.getOrDefault(tidx, new HashMap<>());
map.put(f, map.getOrDefault(f, 0) + 1);
tm.put(tidx, map);
}
int n = tm.size() + 1, m = ts.size() + 1;
// 构造 title & 手动排序
List<String> foods = new ArrayList<>(ts);
Collections.sort(foods);
List<String> title = new ArrayList<>();
title.add("Table");
title.addAll(foods);
ans.add(title);
// 构造内容 & 手动排序
List<Integer> tables = new ArrayList<>(tm.keySet());
Collections.sort(tables);
for (int tidx : tables) {
Map<String, Integer> map = tm.get(tidx);
List<String> cur = new ArrayList<>();
cur.add(tidx + "");
for (String food : foods) {
cur.add(map.getOrDefault(food, 0) + "");
}
ans.add(cur);
}
return ans;
}
}
```
* 时间复杂度:`HashSet` 和 `HashMap` 的基本操作都是 $O(1)$。预处理所有的订单复杂度为 $O(n)$;去重后的桌数为 $r$,餐品数量为 $c$,对两者排序的复杂度分别为 $O(r\log{r})$ 和 $O(c\log{c})$;构造答案复杂度为 $O(r * c)$;最终复杂度为 $O(\max(n, r\log{r}, c\log{c}, r * c))$
* 空间复杂度:$O(r + c + r * c)$
---
### TreeSet & TreeMap
与 `HashSet` 和 `HashMap` 的关系类似,`TreeSet` 是基于 `TreeMap` 实现的,而 `TreeMap` 底层数据结构实现是 **红黑树**。
**得益于 Java 的「面向接口编程(IOP)」设计,我们可以毫不费力的将解法一中的 `HashSet` 替换成 `TreeSet`、将 `HashMap` 替换成 `TreeMap`,并删除手动排序相关代码,得到我们的解法二。**
利用 `TreeMap` 的默认排序规则(数值升序、非数值字典序升序)来简化我们的实现。
但需要注意的是,利用 `TreeMap` 的内部有序特性,调整操作可能会发生在每一次插入操作中,而解法一则是利用 `Collections.sort` 进行一次性的排序,对于非自定义类 `Collections.sort` 是基于 `Arrays.sort` 实现的,会根据「数组大小」、「数组本身是否大致有序」等因素综合决定最终的排序方案,在数据完全随机的情况下,执行效率很大程度要优于 `TreeMap` 的多次调整,但两者复杂度都是 $O(n\log{n})$。
因此在所有数据都提前给定的「离线」情况下,其实更推荐使用解法一。
代码:
```Java
class Solution {
public List<List<String>> displayTable(List<List<String>> os) {
List<List<String>> ans = new ArrayList<>();
// 桌号 : {餐品 : 个数}(用于构造内容)
Map<Integer, Map<String, Integer>> tm = new TreeMap<>();
// 餐品(用于构造 title)
Set<String> ts = new TreeSet<>();
for (List<String> o : os) {
String c = o.get(0), t = o.get(1), f = o.get(2);
Integer tidx = Integer.parseInt(t);
ts.add(f);
Map<String, Integer> map = tm.getOrDefault(tidx, new HashMap<>());
map.put(f, map.getOrDefault(f, 0) + 1);
tm.put(tidx, map);
}
int n = tm.size() + 1, m = ts.size() + 1;
// 构造 title
List<String> title = new ArrayList<>();
title.add("Table");
title.addAll(ts);
ans.add(title);
// 构造内容
for (int tidx : tm.keySet()) {
Map<String, Integer> map = tm.get(tidx);
List<String> cur = new ArrayList<>();
cur.add(tidx + "");
for (String food : ts) {
cur.add(map.getOrDefault(food, 0) + "");
}
ans.add(cur);
}
return ans;
}
}
```
* 时间复杂度:`TreeSet` 和 `TreeMap` 的基本操作都是 $O(log{k})$。预处理所有的订单复杂度为 $O(n\log{n})$;去重后的桌数为 $r$,餐品数量为 $c$,构造答案复杂度为 $O(r\log{r} * c\log{c})$;最终复杂度为 $O(\max(n\log{n}, r\log{r} * c\log{c}))$
* 空间复杂度:$O(r + c + r * c)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1418` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1421-1430/1422. 分割字符串的最大得分（简单）.md | 1422. 分割字符串的最大得分 | https://leetcode.cn/problems/maximum-score-after-splitting-a-string/solution/by-ac_oier-3wua/ | 简单 | [
"前缀和",
"模拟"
] | 给你一个由若干 `0` 和 `1` 组成的字符串 `s` ,请你计算并返回将该字符串分割成两个非空子字符串(即左子字符串和右子字符串)所能获得的最大得分。
「分割字符串的得分」为左子字符串中 `0` 的数量加上右子字符串中 `1` 的数量。
示例 1:
```
输入:s = "011101"
输出:5
解释:
将字符串 s 划分为两个非空子字符串的可行方案有:
左子字符串 = "0" 且 右子字符串 = "11101",得分 = 1 + 4 = 5
左子字符串 = "01" 且 右子字符串 = "1101",得分 = 1 + 3 = 4
左子字符串 = "011" 且 右子字符串 = "101",得分 = 1 + 2 = 3
左子字符串 = "0111" 且 右子字符串 = "01",得分 = 1 + 1 = 2
左子字符串 = "01110" 且 右子字符串 = "1",得分 = 2 + 1 = 3
```
示例 2:
```
输入:s = "00111"
输出:5
解释:当 左子字符串 = "00" 且 右子字符串 = "111" 时,我们得到最大得分 = 2 + 3 = 5
```
示例 3:
```
输入:s = "1111"
输出:3
```
提示:
* $2 <= s.length <= 500$
* 字符串 `s` 仅由字符 `'0'` 和 `'1'` 组成。 | ### 前缀和
构建前缀和数组来记录每个前缀中 $1$ 个个数,复杂度为 $O(n)$,枚举每个分割点,搭配前缀和数组计算左串中 $0$ 的数量和右串中 $1$ 的数量,取所有得分的最大值即是答案。
Java 代码:
```Java
class Solution {
public int maxScore(String s) {
int n = s.length(), ans = 0;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (s.charAt(i - 1) - '0');
for (int i = 1; i <= n - 1; i++) {
int a = i - sum[i], b = sum[n] - sum[i];
ans = Math.max(ans, a + b);
}
return ans;
}
}
```
Typescript 代码:
```Typescript
function maxScore(s: string): number {
let n = s.length, ans = 0
const sum = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + (s[i - 1] == '1' ? 1 : 0)
for (let i = 1; i <= n - 1; i++) {
const a = i - sum[i], b = sum[n] - sum[i]
ans = Math.max(ans, a + b)
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 模拟
更进一步,利用 `s` 中有只有 $0$ 和 $1$,我们可以遍遍历 `s` 边计算得分(而无须预处理前缀和数组),起始分割点为 `s[0]`,此时得分为 `s[0]` 中 $0$ 的个数加上 `s[1...(n-1)]` 中 $1$ 的个数。
然后继续往后处理 `s`,当 $s[i] = 0$,说明有一个 $0$ 从右串中移到了左串,并且 $0$ 在右串中不得分,在左串中得分,因此总得分加一;而当 $s[i] = 1$,说明有一个 $1$ 从右串中移到了左串,而 $1$ 在右串中得分,在左串中不得分,因此总得分减一。在所有得分中取最大值即是答案。
Java 代码:
```Java
class Solution {
public int maxScore(String s) {
int n = s.length(), cur = s.charAt(0) == '0' ? 1 : 0;
for (int i = 1; i < n; i++) cur += s.charAt(i) - '0';
int ans = cur;
for (int i = 1; i < n - 1; i++) {
cur += s.charAt(i) == '0' ? 1 : -1;
ans = Math.max(ans, cur);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function maxScore(s: string): number {
let n = s.length, cur = s[0] == '0' ? 1 : 0
for (let i = 1; i < n; i++) cur += s[i] == '1' ? 1 : 0
let ans = cur
for (let i = 1; i < n - 1; i++) {
cur += s[i] == '0' ? 1 : -1
ans = Math.max(ans, cur)
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1422` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1421-1430/1423. 可获得的最大点数（中等）.md | 1423. 可获得的最大点数 | https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards/solutions/2551466/gong-shui-san-xie-zhuan-huan-wei-gu-ding-pbvd/ | 中等 | [
"滑动窗口"
] | 几张卡牌排成一行,每张卡牌都有一个对应的点数,点数由整数数组 `cardPoints` 给出。
每次行动,你可以从行的开头或者末尾拿一张卡牌,最终你必须正好拿 `k` 张卡牌。
你的点数就是你拿到手中的所有卡牌的点数之和。
给你一个整数数组 `cardPoints` 和整数 `k`,请你返回可以获得的最大点数。
示例 1:
```
输入:cardPoints = [1,2,3,4,5,6,1], k = 3
输出:12
解释:第一次行动,不管拿哪张牌,你的点数总是 1 。但是,先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌,最终点数为 1 + 6 + 5 = 12 。
```
示例 2:
```
输入:cardPoints = [2,2,2], k = 2
输出:4
解释:无论你拿起哪两张卡牌,可获得的点数总是 4 。
```
示例 3:
```
输入:cardPoints = [9,7,7,9,7,7,9], k = 7
输出:55
解释:你必须拿起所有卡牌,可以获得的点数为所有卡牌的点数之和。
```
示例 4:
```
输入:cardPoints = [1,1000,1], k = 1
输出:1
解释:你无法拿到中间那张卡牌,所以可以获得的最大点数为 1 。
```
示例 5:
```
输入:cardPoints = [1,79,80,1,1,1,200,1], k = 3
输出:202
```
提示:
* $1 <= cardPoints.length <= 10^5$
* $1 <= cardPoints[i] <= 10^4$
* $1 <= k <= cardPoints.length$ | ### 滑动窗口
从两边选卡片,选 `k` 张,卡片总数量为 `n` 张,即有 `n - k` 张不被选择。
所有卡片总和 `sum` 固定,要使选择的 `k` 张的总和最大,反过来就是要让不被选择的 `n - k` 张总和最小。
原问题等价为:**从 `cardPoints` 中找长度为 `n - k` 的连续段,使其总和最小。**
具体的,用变量 `sum` 代指 `cardPoints` 总和,`cur` 代表长度固定为 `n - k` 的当前窗口总和,`minv` 代表所有长度为 `n - k` 的窗口中总和最小的值。
起始先将滑动窗口压满,取得第一个滑动窗口的目标值 `cur`(同时更新为 `minv`),随后往后继续处理 `cardPoints`,每往前滑动一位,需要删除一个和添加一个元素,并不断更新 `minv`,最终 `sum - minv` 即是答案。
Java 代码:
```Java
class Solution {
public int maxScore(int[] cardPoints, int k) {
int n = cardPoints.length, len = n - k;
int sum = 0, cur = 0;
for (int i = 0; i < n; i++) sum += cardPoints[i];
for (int i = 0; i < len; i++) cur += cardPoints[i];
int minv = cur;
for (int i = len; i < n; i++) {
cur = cur + cardPoints[i] - cardPoints[i - len];
minv = Math.min(minv, cur);
}
return sum - minv;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxScore(vector<int>& cardPoints, int k) {
int n = cardPoints.size(), len = n - k;
int sum = 0, cur = 0;
for (int i = 0; i < n; i++) sum += cardPoints[i];
for (int i = 0; i < len; i++) cur += cardPoints[i];
int minv = cur;
for (int i = len; i < n; i++) {
cur = cur + cardPoints[i] - cardPoints[i - len];
minv = min(minv, cur);
}
return sum - minv;
}
};
```
Python 代码:
```Python
class Solution:
def maxScore(self, cardPoints: List[int], k: int) -> int:
n, m = len(cardPoints), len(cardPoints) - k
total, cur = sum(cardPoints), sum(cardPoints[:m])
minv = cur
for i in range(m, n):
cur = cur + cardPoints[i] - cardPoints[i - m]
minv = min(minv, cur)
return total - minv
```
TypeScript 代码:
```TypeScript
function maxScore(cardPoints: number[], k: number): number {
const n = cardPoints.length, m = n - k;
let tot = 0, cur = 0;
for (let i = 0; i < n; i++) tot += cardPoints[i];
for (let i = 0; i < m; i++) cur += cardPoints[i];
let minv = cur;
for (let i = m; i < n; i++) {
cur = cur + cardPoints[i] - cardPoints[i - m];
minv = Math.min(minv, cur);
}
return tot - minv;
};
```
* 时间复杂度:每个元素最多滑入和滑出窗口一次,复杂度为 $O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1423` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1431-1440/1436. 旅行终点站（简单）.md | 1436. 旅行终点站 | https://leetcode-cn.com/problems/destination-city/solution/gong-shui-san-xie-jian-dan-fang-jia-mo-n-y47c/ | 简单 | [
"哈希表",
"模拟"
] | 给你一份旅游线路图,该线路图中的旅行线路用数组 paths 表示,其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站,即没有任何可以通往其他城市的线路的城市。
题目数据保证线路图会形成一条不存在循环的线路,因此恰有一个旅行终点站。
示例 1:
```
输入:paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
输出:"Sao Paulo"
解释:从 "London" 出发,最后抵达终点站 "Sao Paulo" 。本次旅行的路线是 "London" -> "New York" -> "Lima" -> "Sao Paulo" 。
```
示例 2:
```
输入:paths = [["B","C"],["D","B"],["C","A"]]
输出:"A"
解释:所有可能的线路是:
"D" -> "B" -> "C" -> "A".
"B" -> "C" -> "A".
"C" -> "A".
"A".
显然,旅行终点站是 "A" 。
```
示例 3:
```
输入:paths = [["A","Z"]]
输出:"Z"
```
提示:
* 1 <= paths.length <= 100
* paths[i].length == 2
* 1 <= cityAi.length, cityBi.length <= 10
* cityAi != cityBi
* 所有字符串均由大小写英文字母和空格字符组成。 | ### 模拟 + 哈希表
根据题意,我们可以取一个任意城市作为起点,然后使用 $paths$ 中的路线信息开始搜索,直到当前城市无法到达下一个城市,即是答案。
实现上,为了可以快速找到某个城市所能到达的城市,可以先使用哈希表对 $paths$ 中的路线信息进行预处理。
代码:
```Java
class Solution {
public String destCity(List<List<String>> ps) {
Map<String, String> map = new HashMap<>();
for (List<String> p : ps) map.put(p.get(0), p.get(1));
String ans = ps.get(0).get(0);
while (map.containsKey(ans)) ans = map.get(ans);
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1436` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1431-1440/1438. 绝对差不超过限制的最长连续子数组（中等）.md | 1438. 绝对差不超过限制的最长连续子数组 | https://leetcode-cn.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/solution/xiang-jie-er-fen-hua-dong-chuang-kou-dan-41g1/ | 中等 | [
"滑动窗口",
"单调队列",
"二分"
] | 给你一个整数数组 nums ,和一个表示限制的整数 limit,请你返回最长连续子数组的长度,该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。
如果不存在满足条件的子数组,则返回 0 。
示例 1:
```
输入:nums = [8,2,4,7], limit = 4
输出:2
解释:所有子数组如下:
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4.
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 |2-4| = 2 <= 4.
[2,4,7] 最大绝对差 |2-7| = 5 > 4.
[4] 最大绝对差 |4-4| = 0 <= 4.
[4,7] 最大绝对差 |4-7| = 3 <= 4.
[7] 最大绝对差 |7-7| = 0 <= 4.
因此,满足题意的最长子数组的长度为 2 。
```
示例 2:
```
输入:nums = [10,1,2,4,7,2], limit = 5
输出:4
解释:满足题意的最长子数组是 [2,4,7,2],其最大绝对差 |2-7| = 5 <= 5 。
```
示例 3:
```
输入:nums = [4,2,2,2,4,4,2,2], limit = 0
输出:3
```
提示:
* 1 <= nums.length <= $10^5$
* 1 <= nums[i] <= $10^9$
* 0 <= limit <= $10^9$ | ### 二分 + 滑动窗口
数据范围是 $10^5$,因此只能考虑「对数解法」和「线性解法」。
对数解法很容易想到「二分」。
在给定 `limit` 的情况下,倘若有「恰好」满足条件的区间长度为 `len`,必然存在满足条件且长度小于等于 `len` 的区间,同时必然不存在长度大于 `len` 且满足条件的区间。
因此长度 `len` 在数轴中具有「二段性」。
**问题转化为「如何判断 `nums` 中是否有长度 `len` 的区间满足绝对值不超过 `limit`」**
我们可以枚举区间的右端点 `r`,那么对应的左端点为 `r - len + 1`,然后使用「单调队列」来保存区间的最大值和最小值。
```java
class Solution {
public int longestSubarray(int[] nums, int limit) {
int n = nums.length;
int l = 1, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
if (check(nums, mid, limit)) {
l = mid;
} else {
r = mid - 1;
}
}
return r;
}
boolean check(int[] nums, int len, int limit) {
int n = nums.length;
Deque<Integer> max = new ArrayDeque<>(), min = new ArrayDeque<>();
for (int r = 0, l = r - len + 1; r < n; r++, l = r - len + 1) {
if (!max.isEmpty() && max.peekFirst() < l) max.pollFirst();
while (!max.isEmpty() && nums[r] >= nums[max.peekLast()]) max.pollLast();
max.addLast(r);
if (!min.isEmpty() && min.peekFirst() < l) min.pollFirst();
while (!min.isEmpty() && nums[r] <= nums[min.peekLast()]) min.pollLast();
min.addLast(r);
if (l >= 0 && Math.abs(nums[max.peekFirst()] - nums[min.peekFirst()]) <= limit) return true;
}
return false;
}
}
```
* 时间复杂度:枚举长度的复杂度为 $O(\log{n})$,对于每次 `check` 而言,每个元素最多入队和出队常数次,复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
***
### 双指针
上述解法我们是在对 `len` 进行二分,而事实上我们可以直接使用「双指针」解法找到最大值。
始终让右端点 `r` 右移,当不满足条件时让 `l` 进行右移。
同时,还是使用「单调队列」保存我们的区间最值,这样我们只需要对数组进行一次扫描即可得到答案。
```Java
class Solution {
public int longestSubarray(int[] nums, int limit) {
int n = nums.length;
int ans = 0;
Deque<Integer> max = new ArrayDeque<>(), min = new ArrayDeque<>();
for (int r = 0, l = 0; r < n; r++) {
while (!max.isEmpty() && nums[r] >= nums[max.peekLast()]) max.pollLast();
while (!min.isEmpty() && nums[r] <= nums[min.peekLast()]) min.pollLast();
max.addLast(r);
min.addLast(r);
while (Math.abs(nums[max.peekFirst()] - nums[min.peekFirst()]) > limit) {
l++;
if (max.peekFirst() < l) max.pollFirst();
if (min.peekFirst() < l) min.pollFirst();
}
ans = Math.max(ans, r - l + 1);
}
return ans;
}
}
```
* 时间复杂度:每个元素最多入队和出队常数次,复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1438` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1441. 用栈操作构建数组（中等）.md | 1441. 用栈操作构建数组 | https://leetcode.cn/problems/build-an-array-with-stack-operations/solution/by-ac_oier-q37s/ | 中等 | [
"模拟",
"构造"
] | 给你一个数组 `target` 和一个整数 `n`。
每次迭代,需要从 `list = { 1 , 2 , 3 ..., n }` 中依次读取一个数字。
请使用下述操作来构建目标数组 `target` :
* `"Push"`:从 `list` 中读取一个新元素, 并将其推入数组中。
* `"Pop"`:删除数组中的最后一个元素。
如果目标数组构建完成,就停止读取更多元素。
题目数据保证目标数组严格递增,并且只包含 `1` 到 `n` 之间的数字。
请返回构建目标数组所用的操作序列。如果存在多个可行方案,返回任一即可。
示例 1:
```
输入:target = [1,3], n = 3
输出:["Push","Push","Pop","Push"]
解释:
读取 1 并自动推入数组 -> [1]
读取 2 并自动推入数组,然后删除它 -> [1]
读取 3 并自动推入数组 -> [1,3]
```
示例 2:
```
输入:target = [1,2,3], n = 3
输出:["Push","Push","Push"]
```
示例 3:
```
输入:target = [1,2], n = 4
输出:["Push","Push"]
解释:只需要读取前 2 个数字就可以停止。
```
提示:
* $1 <= target.length <= 100$
* $1 <= n <= 100$
* $1 <= target[i] <= n$
* `target` 严格递增 | ### 模拟
根据题意进行模拟即可。
每次我们将当前处理到 `i` 压入栈中(往答案添加一个 `Push`),然后判断当前处理到的 `i` 是否最新的栈顶元素 $target[j]$ 是否相同。
若不相同则丢弃元素(往答案添加一个 `Pop`),若存在则将指针 `j` 后移,直到构建出目标答案。
Java 代码:
```Java
class Solution {
public List<String> buildArray(int[] target, int n) {
List<String> ans = new ArrayList<>();
int m = target.length;
for (int i = 1, j = 0; i <= n && j < m; i++) {
ans.add("Push");
if (target[j] != i) ans.add("Pop");
else j++;
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<string> buildArray(vector<int>& target, int n) {
int m = target.size();
vector<string> ans;
for (int i = 1, j = 0; i <= n && j < m; i++) {
ans.push_back("Push");
if (target[j] != i) ans.push_back("Pop");
else j++;
}
return ans;
}
};
```
Python3 代码:
```Python
class Solution:
def buildArray(self, target: List[int], n: int) -> List[str]:
ans = []
m, i, j = len(target), 1, 0
while i <= n and j < m:
ans.append("Push")
if target[j] != i:
ans.append("Pop")
else:
j += 1
i += 1
return ans
```
TypeScript 代码:
```TypeScript
function buildArray(target: number[], n: number): string[] {
const ans = new Array<string>()
const m = target.length
for (let i = 1, j = 0; i <= n && j < m; i++) {
ans.push("Push")
if (target[j] != i) ans.push("Pop")
else j++
}
return ans
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1441` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1442. 形成两个异或相等数组的三元组数目（中等）.md | 1442. 形成两个异或相等数组的三元组数目 | https://leetcode-cn.com/problems/count-triplets-that-can-form-two-arrays-of-equal-xor/solution/gong-shui-san-xie-xiang-jie-shi-yong-qia-7gzm/ | 中等 | [
"数学",
"前缀和"
] | 给你一个整数数组 arr 。
现需要从数组中取三个下标 i、j 和 k ,其中 (0 <= i < j <= k < arr.length) 。
a 和 b 定义如下:
* a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]
* b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k]
注意:^ 表示 按位异或 操作。
请返回能够令 a == b 成立的三元组 (i, j , k) 的数目。
示例 1:
```
输入:arr = [2,3,1,6,7]
输出:4
解释:满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)
```
示例 2:
```
输入:arr = [1,1,1,1,1]
输出:10
```
示例 3:
```
输入:arr = [2,3]
输出:0
```
示例 4:
```
输入:arr = [1,3,5,7,9]
输出:3
```
示例 5:
```
输入:arr = [7,11,12,9,5,2,7,17,22]
输出:8
```
提示:
* 1 <= arr.length <= 300
* 1 <= arr[i] <= $10^8$ | ### 基本分析
数据范围是 $10^2$,三元组包含 $i$、$j$ 和 $k$ 三个下标,因此通过「枚举下标」并「每次循环计算异或结果」的 $O(n^4)$ 朴素做法不用考虑了。
相信做过 [1310. 子数组异或查询](https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/) 的同学不难想到可以使用「树状数组」或者「前缀异或」来优化我们「每次循环计算异或结果」的过程。
由于不涉及修改操作,我们优先使用「前缀异或」。经过这样优化之后的复杂度是 $O(n^3)$,可以过。
---
### 前缀异或
预处理出「前缀异或」数组,并枚举三元组的下标。
**本质上是利用集合(区间结果)的容斥原理。只不过前缀和需要利用「减法(逆运算)」做容斥,而前缀异或是利用「相同数值进行异或结果为 $0$(偶数次的异或结果为 $0$)」的特性实现容斥。**
代码:
```Java
class Solution {
public int countTriplets(int[] arr) {
int n = arr.length;
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] ^ arr[i - 1];
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
for (int k = j; k <= n; k++) {
int a = sum[j - 1] ^ sum[i - 1];
int b = sum[k] ^ sum[j - 1];
if (a == b) ans++;
}
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^3)$
* 空间复杂度:$O(n)$
---
### 前缀异或 & 哈希表
我们重新审视一下这道题。
题目其实是要我们 **取得连续的一段区间 $[i, k]$,并在这一段中找到分割点 $j$,使得区间内分割点左边的异或结果为 $a$,分割点右边的异或结果为 $b$。并最终让 $a$ 和 $b$ 相等。**
由 $a$ 与 $b$ 相等,我们可以推导出 $a ⊕ b = 0$,再结合 $a$ 和 $b$ 的由来,**可以推导出 $[i, k]$ 连续一段的异或结果为 $0$**。
再结合我们预处理的「前缀异或」数组,可得:
$$Xor(i, k) = sum[k] ⊕ sum[i - 1] = 0$$
根据公式和「相同数值异或结果为 $0$」特性,我们可以知道 $sum[k]$ 和 $sum[i - 1]$ 数值相等,因此我们可以使用「哈希表」记录每个出现过的异或结果对应的下标集合,从而实现在确定 $k$ 的情况下,通过 $O(1)$ 的复杂度找到所有符合条件的 $i$。
需要注意的是,因为我们「前缀异或」数组的下标是从 $1$ 开始,所以我们需要先往「哈希表」存入一个哨兵 $0$ 作为边界,当然这一步不需要特殊操作,只需要让 $k$ 从 $0$ 开始执行循环即可(利用「前缀异或」数组中下标 $0$ 的值本身为 $0$)。
代码:
```Java
class Solution {
public int countTriplets(int[] arr) {
int n = arr.length;
// 预处理前缀异或数组
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] ^ arr[i - 1];
int ans = 0;
// 记录出现过的异或结果,存储格式:{ 异或结果 : [下标1, 下标2 ...] }
Map<Integer, List<Integer>> map = new HashMap<>();
for (int k = 0; k <= n; k++) {
List<Integer> list = map.getOrDefault(sum[k], new ArrayList<>());
for (int idx : list) {
int i = idx + 1;
ans += k - i;
}
list.add(k);
map.put(sum[k], list);
}
return ans;
}
}
```
```Java
class Solution {
public int countTriplets(int[] arr) {
int n = arr.length;
// 事实上,甚至可以不预处理「前缀异或数组」,使用一个变量 xor 边遍历边计算即可
int xor = 0, ans = 0;
Map<Integer, List<Integer>> map = new HashMap<>();
for (int k = 0; k <= n; k++) {
if (k >= 1) xor ^= arr[k - 1];
List<Integer> list = map.getOrDefault(xor, new ArrayList<>());
for (int idx : list) {
int i = idx + 1;
ans += k - i;
}
list.add(k);
map.put(xor, list);
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1442` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1446. 连续字符（简单）.md | 1446. 连续字符 | https://leetcode-cn.com/problems/consecutive-characters/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-xtv6/ | 简单 | [
"双指针",
"模拟"
] | 给你一个字符串 `s` ,字符串的「能量」定义为:只包含一种字符的最长非空子字符串的长度。
请你返回字符串的能量。
示例 1:
```
输入:s = "leetcode"
输出:2
解释:子字符串 "ee" 长度为 2 ,只包含字符 'e' 。
```
示例 2:
```
输入:s = "abbcccddddeeeeedcba"
输出:5
解释:子字符串 "eeeee" 长度为 5 ,只包含字符 'e' 。
```
示例 3:
```
输入:s = "triplepillooooow"
输出:5
```
示例 4:
```
输入:s = "hooraaaaaaaaaaay"
输出:11
```
示例 5:
```
输入:s = "tourist"
输出:1
```
提示:
* $1 <= s.length <= 500$
* $s$ 只包含小写英文字母。 | ### 双指针
根据题意,使用「双指针」进行扫描计数即可。
代码:
```Java
class Solution {
public int maxPower(String s) {
int n = s.length(), ans = 1;
for (int i = 0; i < n; ) {
int j = i;
while (j < n && s.charAt(j) == s.charAt(i)) j++;
ans = Math.max(ans, j - i);
i = j;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1447. 最简分数（中等）.md | 1447. 最简分数 | https://leetcode-cn.com/problems/simplified-fractions/solution/gong-shui-san-xie-jian-dan-shu-lun-yun-y-wma5/ | 中等 | [
"数学",
"最大公约数"
] | 给你一个整数 `n` ,请你返回所有 $0$ 到 $1$ 之间(不包括 $0$ 和 $1$)满足分母小于等于 `n` 的 最简 分数 。分数可以以 **任意** 顺序返回。
示例 1:
```
输入:n = 2
输出:["1/2"]
解释:"1/2" 是唯一一个分母小于等于 2 的最简分数。
```
示例 2:
```
输入:n = 3
输出:["1/2","1/3","2/3"]
```
示例 3:
```
输入:n = 4
输出:["1/2","1/3","1/4","2/3","3/4"]
解释:"2/4" 不是最简分数,因为它可以化简为 "1/2" 。
```
示例 4:
```
输入:n = 1
输出:[]
```
提示:
* $1 <= n <= 100$ | ### 数论
数据范围为 $100$ 且数值大小在 $(0, 1)$ 之间,因此枚举「分子 + 分母」的 $O(n^2)$ 做法是可接受的。
于是问题转化为:**如何快速判断两个数组成的分数是否为最简(即判断两个数的最大公约数是否为 $1$)。**
快速求得 $a$ 和 $b$ 的最大公约数的主要方式有两种 :「更相减损法」和「欧几里得算法」,其中「欧几里得算法」的递归实现最为好写,复杂度为 $O(\log{(a + b)})$,在绝大多数的情况下适用,只有在需要实现高精度时,才会考虑使用「更相减损法」。
而 stein 算法则是没有必要掌握的。
代码:
```Java
class Solution {
int gcd(int a, int b) { // 欧几里得算法
return b == 0 ? a : gcd(b, a % b);
}
public List<String> simplifiedFractions(int n) {
List<String> ans = new ArrayList<>();
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if (gcd(i, j) == 1) ans.add(i + "/" + j);
}
}
return ans;
}
}
```
-
```Java
class Solution {
int gcd(int a, int b) { // 更相减损法
while (true) {
if (a > b) a -= b;
else if (a < b) b -= a;
else return a;
}
}
public List<String> simplifiedFractions(int n) {
List<String> ans = new ArrayList<>();
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if (gcd(i, j) == 1) ans.add(i + "/" + j);
}
}
return ans;
}
}
```
-
```Java
class Solution {
int gcd(int a, int b) { // stein
if (a == 0 || b == 0) return Math.max(a, b);
if (a % 2 == 0 && b % 2 == 0) return 2 * gcd(a >> 1, b >> 1);
else if (a % 2 == 0) return gcd(a >> 1, b);
else if (b % 2 == 0) return gcd(a, b >> 1);
else return gcd(Math.abs(a - b), Math.min(a, b));
}
public List<String> simplifiedFractions(int n) {
List<String> ans = new ArrayList<>();
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if (gcd(i, j) == 1) ans.add(i + "/" + j);
}
}
return ans;
}
}
```
* 时间复杂度:枚举分子分母的复杂度为 $O(n^2)$;判断两数是否能凑成最简分数复杂度为 $O(\log{n})$。整体复杂度为 $O(n^2 * \log{n})$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1447` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1449. 数位成本和为目标值的最大数字（困难）.md | 1449. 数位成本和为目标值的最大数字 | https://leetcode-cn.com/problems/form-largest-integer-with-digits-that-add-up-to-target/solution/gong-shui-san-xie-fen-liang-bu-kao-lu-we-uy4y/ | 困难 | [
"完全背包",
"背包问题",
"动态规划"
] | 给你一个整数数组 cost 和一个整数 target 。请你返回满足如下规则可以得到的 最大 整数:
给当前结果添加一个数位(i + 1)的成本为 cost[i] (cost 数组下标从 0 开始)。
总成本必须恰好等于 target 。
添加的数位中没有数字 0 。
由于答案可能会很大,请你以字符串形式返回。
如果按照上述要求无法得到任何整数,请你返回 "0" 。
示例 1:
```
输入:cost = [4,3,2,5,6,7,2,5,5], target = 9
输出:"7772"
解释:添加数位 '7' 的成本为 2 ,添加数位 '2' 的成本为 3 。所以 "7772" 的代价为 2*3+ 3*1 = 9 。 "977" 也是满足要求的数字,但 "7772" 是较大的数字。
数字 成本
1 -> 4
2 -> 3
3 -> 2
4 -> 5
5 -> 6
6 -> 7
7 -> 2
8 -> 5
9 -> 5
```
示例 2:
```
输入:cost = [7,6,5,5,5,6,8,7,8], target = 12
输出:"85"
解释:添加数位 '8' 的成本是 7 ,添加数位 '5' 的成本是 5 。"85" 的成本为 7 + 5 = 12 。
```
示例 3:
```
输入:cost = [2,4,6,2,4,6,4,4,4], target = 5
输出:"0"
解释:总成本是 target 的条件下,无法生成任何整数。
```
示例 4:
```
输入:cost = [6,10,15,40,40,40,40,40,40], target = 47
输出:"32211"
```
提示:
* cost.length == 9
* 1 <= cost[i] <= 5000
* 1 <= target <= 5000 | ### 基本分析
根据题意:给定 $1$~$9$ 几个数字,每个数字都有选择成本,求给定费用情况下,凑成的最大数字是多少。
通常我们会如何比较两数大小关系?
首先我们 **根据长度进行比较,长度较长数字较大**;再者,对于长度相等的数值,**从高度往低位进行比较,找到第一位不同,不同位值大的数值较大。**
其中规则一的比较优先级要高于规则二。
基于此,我们可以将构造分两步进行。
---
### 动态规划 + 贪心
具体的,先考虑「数值长度」问题,每个数字有相应选择成本,所能提供的长度均为 $1$。
问题转换为:**有若干物品,求给定费用的前提下,花光所有费用所能选择的最大价值(物品个数)为多少。**
每个数字可以被选择多次,属于完全背包模型。
当求得最大「数值长度」后,考虑如何构造答案。
根据规则二,**应该尽可能让高位的数值越大越好**,因此我们可以从数值 $9$ 开始往数值 $1$ 遍历,如果状态能够由该数值转移而来,则选择该数值。
*PS. 写了几天两维版本了,大家应该都掌握了叭,今天赶着出门,直接写一维。*
代码:
```Java
class Solution {
public String largestNumber(int[] cost, int t) {
int[] f = new int[t + 1];
Arrays.fill(f, Integer.MIN_VALUE);
f[0] = 0;
for (int i = 1; i <= 9; i++) {
int u = cost[i - 1];
for (int j = u; j <= t; j++) {
f[j] = Math.max(f[j], f[j - u] + 1);
}
}
if (f[t] < 0) return "0";
String ans = "";
for (int i = 9, j = t; i >= 1; i--) {
int u = cost[i - 1];
while (j >= u && f[j] == f[j - u] + 1) {
ans += String.valueOf(i);
j -= u;
}
}
return ans;
}
}
```
* 时间复杂度:$O(n * t)$
* 空间复杂度:$O(t)$
---
### 思考 & 进阶
懂得分两步考虑的话,这道题还是挺简单。虽然是「DP」+「贪心」,但两部分都不难。
其实这道题改改条件/思路,也能衍生出几个版本:
0. **【思考】如何彻底转化为「01 背包」或者「多重背包」来处理?**
完全背包经过一维优化后时间复杂度为 $O(N * C)$。是否可以在不超过此复杂度的前提下,通过预处理物品将问题转换为另外两种传统背包?
* 对于「多重背包」答案是可以的。由于给定的最终费用 $t$,我们可以明确算出每个物品最多被选择的次数,可以在 $O(N)$ 的复杂度内预处理额外的 $s[]$ 数组。然后配合「单调队列优化」,做到 $O(N * C)$ 复杂度,整体复杂度不会因此变得更差。
但转换增加了「预处理」的计算量。为了让转换变成“更有意义”,我们可以在「预处理」时顺便做一个小优化:**对于相同成本的数字,只保留数值大的数字**。不难证明,当成本相同时,选择更大的数字不会让结果变差。
* 对于「01 背包」答案是不可以。原因与「多重背包」单纯转换为「01 背包」不会降低复杂度一致。因此本题转换成「01 背包」会使得 $N$ 发生非常数级别的增大。
1. **【进阶】不再是给定数值 $1$~$9$(取消 $cost$ 数组),转为给定 $nums$ 数组(代表所能选择的数字,不包含 $0$),和相应 $price$ 数组(长度与 $nums$ 一致,代表选择 $nums[i]$ 所消耗的成本为 $price[i]$)。现有做法是否会失效?**
此时 $nums$ 中不再是只有长度为 $1$ 的数值了。但我们「判断数值大小」的两条规则不变。因此「第一步」不需要做出调整,但在进行「第二步」开始前,我们要先对物品进行「自定义规则」的排序,确保「贪心」构造答案过程是正确的。规则与证明都不难请自行思考。
2. **【进阶】在进阶 $1$ 的前提下,允许 $nums$ 出现 $0$,且确保答案有解(不会返回答案 $0$),该如何求解?**
增加数值 $0$ 其实只会对最高位数字的决策产生影响。
我们可以**通过预处理转换为「分组 & 树形」背包问题**:将 $nums$ 中的非 $0$ 作为一组「主件」(分组背包部分:必须选择一个主件),所有数值作为「附属件」(树形背包部分:能选择若干个,选择附属件必须同时选择主件)。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1449` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1441-1450/1450. 在既定时间做作业的学生人数（简单）.md | 1450. 在既定时间做作业的学生人数 | https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time/solution/by-ac_oier-4ftz/ | 简单 | [
"区间求和问题",
"差分"
] | 给你两个整数数组 `startTime`(开始时间)和 `endTime`(结束时间),并指定一个整数 `queryTime` 作为查询时间。
已知,第 `i` 名学生在 `startTime[i]` 时开始写作业并于 `endTime[i]` 时完成作业。
请返回在查询时间 `queryTime` 时正在做作业的学生人数。形式上,返回能够使 `queryTime` 处于区间 `[startTime[i], endTime[i]]`(含)的学生人数。
示例 1:
```
输入:startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
输出:1
解释:一共有 3 名学生。
第一名学生在时间 1 开始写作业,并于时间 3 完成作业,在时间 4 没有处于做作业的状态。
第二名学生在时间 2 开始写作业,并于时间 2 完成作业,在时间 4 没有处于做作业的状态。
第三名学生在时间 3 开始写作业,预计于时间 7 完成作业,这是是唯一一名在时间 4 时正在做作业的学生。
```
示例 2:
```
输入:startTime = [4], endTime = [4], queryTime = 4
输出:1
解释:在查询时间只有一名学生在做作业。
```
示例 3:
```
输入:startTime = [4], endTime = [4], queryTime = 5
输出:0
```
示例 4:
```
输入:startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7
输出:0
```
示例 5:
```
输入:startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5
输出:5
```
提示:
* $startTime.length == endTime.length$
* $1 <= startTime.length <= 100$
* $1 <= startTime[i] <= endTime[i] <= 1000$
* $1 <= queryTime <= 1000$ | ### 差分
为了方便,我们令 `startTime` 为 `st`,令 `endTime` 为 `et`,令 `queryTime` 为 `t`。
问题涉及「区间修改」+「单点查询」,是一道关于「差分」的模板题。
> **对差分不熟悉的同学,可以查看前置 🧀 : [差分入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490329&idx=1&sn=6d448a53cd722bbd990fda82bd262857)**
利用时间点数据范围为 $1e3$,我们建立一个 $1e3$ 大小的差分数组 `c`,对于时间段 $[st[i], et[i]]$ 而言,我们只需在差分数组 $c[st[i]]$ 上进行自增,在 $c[et[i] + 1]$ 进行自减,即可实现 $O(1)$ 复杂度对范围 $[st[i], et[i]]$ 的标记。
当处理完后,只需要对 `c` 执行「前缀和」操作,即可查询每个时间点被标记的次数(由于我们只需要求时间点 `t` 的覆盖次数,因此我们只需求 $[0, t]$ 范围的前缀和即可)。
Java 代码:
```Java
class Solution {
public int busyStudent(int[] st, int[] et, int t) {
int[] c = new int[1010];
for (int i = 0; i < st.length; i++) {
c[st[i]]++; c[et[i] + 1]--;
}
for (int i = 1; i <= t; i++) c[i] += c[i - 1];
return c[t];
}
}
```
TypeScript 代码:
```TypeScript
function busyStudent(st: number[], et: number[], t: number): number {
const c = new Array<number>(1010).fill(0)
for (let i = 0; i < st.length; i++) {
c[st[i]]++; c[et[i] + 1]--;
}
for (let i = 1; i <= t; i++) c[i] += c[i - 1];
return c[t]
};
```
* 时间复杂度:创建差分数组复杂度为 $O(C)$,其中 $C = 1e3$ 为值域大小,随后使用差分数组进行区间标记,复杂度为 $O(n)$,构建前缀和数组用于查询复杂度为 $O(t)$,整体复杂度为 $O(C)$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1450` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1451-1460/1455. 检查单词是否为句中其他单词的前缀（简单）.md | 1455. 检查单词是否为句中其他单词的前缀 | https://leetcode.cn/problems/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/solution/by-ac_oier-cfsi/ | 简单 | [
"模拟",
"双指针"
] | 给你一个字符串 `sentence` 作为句子并指定检索词为 `searchWord`,其中句子由若干用 单个空格 分隔的单词组成。请你检查检索词 `searchWord` 是否为句子 `sentence` 中任意单词的前缀。
如果 `searchWord` 是某一个单词的前缀,则返回句子 `sentence` 中该单词所对应的下标(下标从 $1$ 开始)。如果 `searchWord` 是多个单词的前缀,则返回匹配的第一个单词的下标(最小下标)。如果 `searchWord` 不是任何单词的前缀,则返回 $-1$ 。
字符串 `s` 的前缀是 `s` 的任何前导连续子字符串。
示例 1:
```
输入:sentence = "i love eating burger", searchWord = "burg"
输出:4
解释:"burg" 是 "burger" 的前缀,而 "burger" 是句子中第 4 个单词。
```
示例 2:
```
输入:sentence = "this problem is an easy problem", searchWord = "pro"
输出:2
解释:"pro" 是 "problem" 的前缀,而 "problem" 是句子中第 2 个也是第 6 个单词,但是应该返回最小下标 2 。
```
示例 3:
```
输入:sentence = "i am tired", searchWord = "you"
输出:-1
解释:"you" 不是句子中任何单词的前缀。
```
提示:
* $1 <= sentence.length <= 100$
* $1 <= searchWord.length <= 10$
* `sentence` 由小写英文字母和空格组成。
* `searchWord` 由小写英文字母组成。 | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int isPrefixOfWord(String s, String t) {
String[] ss = s.split(" ");
int n = ss.length, m = t.length();
for (int i = 0; i < n; i++) {
if (ss[i].length() < m) continue;
boolean ok = true;
for (int j = 0; j < m && ok; j++) {
if (ss[i].charAt(j) != t.charAt(j)) ok = false;
}
if (ok) return i + 1;
}
return -1;
}
}
```
Typescript 代码:
```Typescript
function isPrefixOfWord(s: string, t: string): number {
const ss = s.split(" ")
const n = ss.length, m = t.length
for (let i = 0; i < n; i++) {
if (ss[i].length < m) continue
let ok = true
for (let j = 0; j < m && ok; j++) {
if (ss[i][j] != t[j]) ok = false
}
if (ok) return i + 1
}
return -1
};
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1455` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1451-1460/1457. 二叉树中的伪回文路径（中等）.md | 1457. 二叉树中的伪回文路径 | https://leetcode.cn/problems/pseudo-palindromic-paths-in-a-binary-tree/solutions/2540912/gong-shui-san-xie-gao-xiao-ji-jian-de-we-f2gb/ | 中等 | [
"DFS",
"位运算"
] | 给你一棵二叉树,每个节点的值为 `1` 到 `9` 。
我们称二叉树中的一条路径是 「伪回文」的,当它满足:路径经过的所有节点值的排列中,存在一个回文序列。
请你返回从根到叶子节点的所有路径中伪回文路径的数目。
示例 1:
```
输入:root = [2,3,1,3,1,null,1]
输出:2
解释:上图为给定的二叉树。总共有 3 条从根到叶子的路径:红色路径 [2,3,3] ,绿色路径 [2,1,1] 和路径 [2,3,1] 。
在这些路径中,只有红色和绿色的路径是伪回文路径,因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ,绿色路径 [2,1,1] 存在回文排列 [1,2,1] 。
```
示例 2:
```
输入:root = [2,1,1,1,3,null,null,null,null,null,1]
输出:1
解释:上图为给定二叉树。总共有 3 条从根到叶子的路径:绿色路径 [2,1,1] ,路径 [2,1,3,1] 和路径 [2,1] 。
这些路径中只有绿色路径是伪回文路径,因为 [2,1,1] 存在回文排列 [1,2,1] 。
```
示例 3:
```
输入:root = [9]
输出:1
```
提示:
* 给定二叉树的节点数目在范围 $[1, 10^5]$ 内
* $1 <= Node.val <= 9$ | ### DFS + 位运算
“伪回文”是指能够通过重新排列变成“真回文”,真正的回文串只有两种情况:
* 长度为偶数,即出现次数为奇数的字符个数为 $0$ 个
* 长度为奇数,即出现次数为奇数的字符个数为 $1$ 个(位于中间)
因此,**我们只关心路径中各个字符(数字 `0-9`)出现次数的奇偶性,若路径中所有字符出现次数均为偶数,或仅有一个字符出现次数为奇数,那么该路径满足要求**。
节点值范围为 $[1, 9]$,除了使用固定大小的数组进行词频统计以外,还可以使用一个 `int` 类型的变量 `cnt` 来统计各数值的出现次数奇偶性:若 $cnt$ 的第 $k$ 位为 $1$,说明数值 $k$ 的出现次数为奇数,否则说明数值 $k$ 出现次数为偶数或没出现过,两者是等价的。
例如 $cnt = (0001010)_2$ 代表数值 $1$ 和数值 $3$ 出现次数为奇数次,其余数值没出现过或出现次数为偶数次。
翻转一个二进制数字中的某一位可使用「异或」操作,具体操作位 `cnt ^= 1 << k`。
判断是否最多只有一个字符出现奇数次的操作,也就是判断一个二进制数字是为全为 $0$ 或仅有一位 $1$,可配合 `lowbit` 来做,若 `cnt` 与 `lowbit(cnt) = cnt & -cnt` 相等,说明满足要求。
考虑到对 `lowbit(x) = x & -x` 不熟悉的同学,这里再做简单介绍:*`lowbit(x)` 表示 `x` 的二进制表示中最低位的 $1$ 所在的位置对应的值*,即仅保留从最低位起的第一个 $1$,其余位均以 $0$ 填充:
* `x = 6`,其二进制表示为 $(110)_2$,那么 $lowbit(6) = (010)_2 = 2$
* `x = 12`,其二进制表示为 $(1100)_2$,那么 $lowbit(12) = (100)_2 = 4$
Java 代码:
```Java
class Solution {
int ans = 0;
public int pseudoPalindromicPaths (TreeNode root) {
dfs(root, 0);
return ans;
}
void dfs(TreeNode root, int cnt) {
if (root.left == null && root.right == null) {
cnt ^= 1 << root.val;
if (cnt == (cnt & -cnt)) ans++;
return ;
}
if (root.left != null) dfs(root.left, cnt ^ (1 << root.val));
if (root.right != null) dfs(root.right, cnt ^ (1 << root.val));
}
}
```
C++ 代码:
```C++
class Solution {
public:
int ans;
int pseudoPalindromicPaths(TreeNode* root) {
dfs(root, 0);
return ans;
}
void dfs(TreeNode* root, int cnt) {
if (!root->left && !root->right) {
cnt ^= 1 << root->val;
if (cnt == (cnt & -cnt)) ans++;
return;
}
if (root->left) dfs(root->left, cnt ^ (1 << root->val));
if (root->right) dfs(root->right, cnt ^ (1 << root->val));
}
};
```
Python 代码:
```Python
class Solution:
def pseudoPalindromicPaths (self, root: Optional[TreeNode]) -> int:
ans = 0
def dfs(root, cnt):
nonlocal ans
if not root.left and not root.right:
cnt ^= 1 << root.val
ans += 1 if cnt == (cnt & -cnt) else 0
return
if root.left:
dfs(root.left, cnt ^ (1 << root.val))
if root.right:
dfs(root.right, cnt ^ (1 << root.val))
dfs(root, 0)
return ans
```
TypeScript 代码:
```TypeScript
function pseudoPalindromicPaths (root: TreeNode | null): number {
let ans = 0;
const dfs = function (root: TreeNode, cnt: number): void {
if (root.left == null && root.right == null) {
cnt ^= 1 << root.val;
if (cnt == (cnt & -cnt)) ans++;
return ;
}
if (root.left) dfs(root.left, cnt ^ (1 << root.val));
if (root.right) dfs(root.right, cnt ^ (1 << root.val));
}
dfs(root, 0);
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1457` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1451-1460/1460. 通过翻转子数组使两个数组相等（简单）.md | 1460. 通过翻转子数组使两个数组相等 | https://leetcode.cn/problems/make-two-arrays-equal-by-reversing-sub-arrays/solution/by-ac_oier-pv38/ | 简单 | [
"模拟",
"计数"
] | 给你两个长度相同的整数数组 `target` 和 `arr` 。每一步中,你可以选择 `arr` 的任意 非空子数组 并将它翻转。你可以执行此过程任意次。
如果你能让 `arr` 变得与 `target` 相同,返回 `True`;否则,返回 `False` 。
示例 1:
```
输入:target = [1,2,3,4], arr = [2,4,1,3]
输出:true
解释:你可以按照如下步骤使 arr 变成 target:
1- 翻转子数组 [2,4,1] ,arr 变成 [1,4,2,3]
2- 翻转子数组 [4,2] ,arr 变成 [1,2,4,3]
3- 翻转子数组 [4,3] ,arr 变成 [1,2,3,4]
上述方法并不是唯一的,还存在多种将 arr 变成 target 的方法。
```
示例 2:
```
输入:target = [7], arr = [7]
输出:true
解释:arr 不需要做任何翻转已经与 target 相等。
```
示例 3:
```
输入:target = [3,7,9], arr = [3,7,11]
输出:false
解释:arr 没有数字 9 ,所以无论如何也无法变成 target 。
```
提示:
* $target.length = arr.length$
* $1 <= target.length <= 1000$
* $1 <= target[i] <= 1000$
* $1 <= arr[i] <= 1000$ | ### 模拟
当两数组词频相同,且翻转次数不受限制时,我们至少能通过「逐个调整」将一数组变为另一数组(以当前需要调整的位置作为待翻转子数组的左端点,目标数值所在位置作为右端点)。
Java 代码:
```Java
class Solution {
public boolean canBeEqual(int[] target, int[] arr) {
int n = arr.length, tot = 0;
int[] cnt = new int[1010];
for (int i = 0; i < n; i++) {
if (++cnt[target[i]] == 1) tot++;
if (--cnt[arr[i]] == 0) tot--;
}
return tot == 0;
}
}
```
TypeScript 代码:
```TypeScript
function canBeEqual(target: number[], arr: number[]): boolean {
let n = target.length, tot = 0
const cnt = new Array<number>(1010).fill(0)
for (let i = 0; i < n; i++) {
if (++cnt[target[i]] == 1) tot++
if (--cnt[arr[i]] == 0) tot--
}
return tot == 0
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$,其中 $C = 1010$ 为值域大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1460` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1464. 数组中两元素的最大乘积（简单）.md | 1464. 数组中两元素的最大乘积 | https://leetcode.cn/problems/maximum-product-of-two-elements-in-an-array/solution/by-ac_oier-t5p3/ | 简单 | [
"模拟"
] | 给你一个整数数组 `nums`,请你选择数组的两个不同下标 `i` 和 `j`,使 `(nums[i]-1)*(nums[j]-1)` 取得最大值。
请你计算并返回该式的最大值。
示例 1:
```
输入:nums = [3,4,5,2]
输出:12
解释:如果选择下标 i=1 和 j=2(下标从 0 开始),则可以获得最大值,(nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12 。
```
示例 2:
```
输入:nums = [1,5,4,5]
输出:16
解释:选择下标 i=1 和 j=3(下标从 0 开始),则可以获得最大值 (5-1)*(5-1) = 16 。
```
示例 3:
```
输入:nums = [3,7]
输出:12
```
提示:
* $2 <= nums.length <= 500$
* $1 <= nums[i] <= 10^3$ | ### 模拟
根据题意,使用两个变量 `a` 和 `b` 记录最大值和次大值。
Java 代码:
```Java
class Solution {
public int maxProduct(int[] nums) {
int a = -1, b = -1;
for (int x : nums) {
if (x > a) {
b = a; a = x;
} else if (x > b) {
b = x;
}
}
return (a - 1) * (b - 1);
}
}
```
TypeScript 代码:
```TypeScript
function maxProduct(nums: number[]): number {
let a = -1, b = -1
for (const x of nums) {
if (x > a) {
b = a; a = x
} else if (x > b) {
b = x
}
}
return (a - 1) * (b - 1)
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1464` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1465. 切割后面积最大的蛋糕（中等）.md | 1465. 切割后面积最大的蛋糕 | https://leetcode.cn/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/solutions/2500353/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ecnvl/ | 中等 | [
"贪心",
"模拟"
] | 矩形蛋糕的高度为 `h` 且宽度为 `w`,给你两个整数数组 `hs` 和 `vs`,其中:
* `hs[i]` 是从矩形蛋糕顶部到第 `i` 个水平切口的距离
* `vs[j]` 是从矩形蛋糕的左侧到第 `j` 个竖直切口的距离
请你按数组 `hs` 和 `vs` 中提供的水平和竖直位置切割后,请你找出**面积最大**的那份蛋糕,并返回其**面积**。
由于答案可能是一个很大的数字,因此需要将结果 对 $10^9 + 7$ 取余 后返回。
示例 1:
```
输入:h = 5, w = 4, hs = [1,2,4], vs = [1,3]
输出:4
解释:上图所示的矩阵蛋糕中,红色线表示水平和竖直方向上的切口。切割蛋糕后,绿色的那份蛋糕面积最大。
```
示例 2:
```
输入:h = 5, w = 4, hs = [3,1], vs = [1]
输出:6
解释:上图所示的矩阵蛋糕中,红色线表示水平和竖直方向上的切口。切割蛋糕后,绿色和黄色的两份蛋糕面积最大。
```
示例 3:
```
输入:h = 5, w = 4, hs = [3], vs = [3]
输出:9
```
提示:
* $2 <= h, w <= 10^9$
* $1 <= hs.length <= \min(h - 1, 10^5)$
* $1 <= vs.length <= \min(w - 1, 10^5)$
* $1 <= hs[i] < h$
* $1 <= vs[i] < w$
* 题目数据保证 `hs` 中的所有元素各不相同
* 题目数据保证 `vs` 中的所有元素各不相同 | ### 贪心
由于求是“最大”蛋糕面积,**水平/垂直方向的连续段必然由「同方向且相邻」的切割位置(或是蛋糕边界)所构成**。
这点可通过反证法证明:如果最终蛋糕的(左右或上下)边缘不是由「相邻」的切割位置(或是蛋糕边界)决定,而是由跨越某些切割点的位置所决定的话,那么这个蛋糕必不是“完整”一块。
用题面的示例 $1$ 来举个 🌰,我们仅分析水平方向(`hs = [1, 2, 4]`):
最终蛋糕的在该方向的连续段大小,只能是 `[上边缘, 切割点 1]`、`[切割点 1, 切割点 2]`、`[切割点 2, 切割点 4]` 和 `[切割点 4, 下边缘]` 四个之一,而不可能由非相邻切割点所组成,例如 `[切割点 1, 切割点 4]`(会被 `切割点 2` 所一分为二,不再完整)。
因此,我们可先对 `hs` 和 `vs` 进行排序,从而确保我们在遍历 `hs` 和 `vs` 过程中,处理到的均为「同反向且相邻」的切割位置。
随后,利用俩方向相互独立,分别求出俩方向连续段的最大长度,两者乘积即是答案。
Java 代码:
```Java
class Solution {
int MOD = (int)1e9+7;
public int maxArea(int h, int w, int[] hs, int[] vs) {
Arrays.sort(hs);
Arrays.sort(vs);
int n = hs.length, m = vs.length;
int mh = Math.max(hs[0], h - hs[n - 1]), mv = Math.max(vs[0], w - vs[m - 1]);
for (int i = 1; i < n; i++) mh = Math.max(mh, hs[i] - hs[i - 1]);
for (int i = 1; i < m; i++) mv = Math.max(mv, vs[i] - vs[i - 1]);
return (int)((mh * 1L * mv) % MOD);
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxArea(int h, int w, vector<int>& hs, vector<int>& vs) {
int MOD = 1e9+7;
sort(hs.begin(), hs.end());
sort(vs.begin(), vs.end());
int n = hs.size(), m = vs.size();
int mh = max(hs[0], h - hs[n - 1]), mv = max(vs[0], w - vs[m - 1]);
for (int i = 1; i < n; i++) mh = max(mh, hs[i] - hs[i - 1]);
for (int i = 1; i < m; i++) mv = max(mv, vs[i] - vs[i - 1]);
return (mh * 1L * mv) % MOD;
}
};
```
Python 代码:
```Python
class Solution:
def maxArea(self, h: int, w: int, hs: List[int], vs: List[int]) -> int:
MOD = 10 ** 9 + 7
hs.sort()
vs.sort()
n, m = len(hs), len(vs)
mh, mv = max(hs[0], h - hs[n - 1]), max(vs[0], w - vs[m - 1])
for i in range(1, n):
mh = max(mh, hs[i] - hs[i - 1])
for i in range(1, m):
mv = max(mv, vs[i] - vs[i - 1])
return (mh * mv) % MOD
```
TypeScript 代码:
```TypeScript
function maxArea(h: number, w: number, hs: number[], vs: number[]): number {
const MOD = BigInt(1e9 + 7);
hs.sort((a,b)=>a-b);
vs.sort((a,b)=>a-b);
const n = hs.length, m = vs.length;
let mh = Math.max(hs[0], h - hs[n - 1]), mv = Math.max(vs[0], w - vs[m - 1]);
for (let i = 1; i < n; i++) mh = Math.max(mh, hs[i] - hs[i - 1]);
for (let i = 1; i < m; i++) mv = Math.max(mv, vs[i] - vs[i - 1]);
return Number((BigInt(mh) * BigInt(mv)) % MOD);
};
```
* 时间复杂度:$O(m\log{m} + n\log{n})$
* 空间复杂度:$O(\max(\log{m}, \log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1465` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1466. 重新规划路线（中等）.md | 1466. 重新规划路线 | null | 中等 | [
"图",
"DFS"
] | `n` 座城市,从 `0` 到 `n-1` 编号,其间共有 `n-1` 条路线。
因此,要想在两座不同城市之间旅行只有唯一一条路线可供选择(路线网形成一颗树)。
去年,交通运输部决定重新规划路线,以改变交通拥堵的状况。
路线用 `connections` 表示,其中 $connections[i] = [a, b]$ 表示从城市 `a` 到 `b` 的一条有向路线。
今年,城市 `0` 将会举办一场大型比赛,很多游客都想前往城市 `0` 。
请你帮助重新规划路线方向,使每个城市都可以访问城市 `0`。返回需要变更方向的最小路线数。
题目数据保证每个城市在重新规划路线方向后都能到达城市 `0` 。
示例 1:
```
输入:n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]
输出:3
解释:更改以红色显示的路线的方向,使每个城市都可以到达城市 0 。
```
示例 2:
```
输入:n = 5, connections = [[1,0],[1,2],[3,2],[3,4]]
输出:2
解释:更改以红色显示的路线的方向,使每个城市都可以到达城市 0 。
```
示例 3:
```
输入:n = 3, connections = [[1,0],[2,0]]
输出:0
```
提示:
* $2 <= n <= 5 \times 10^4$
* $connections.length = n-1$
* $connections[i].length = 2$
* $0 <= connections[i][0], connections[i][1] <= n-1$
* $connections[i][0]$ `!=` $connections[i][1]$ | ### DFS
核心等价:原图上从所有点能够访问到 `0`,等价于反图中从 `0` 出发能到任何点。
因此,可用 `connections` 创建双向图(原边权重为 $1$,反向边权重为 $0$),然后从 `0` 出发访问整张图,统计访问过程中的权重之和,即是原图中需要反向的边的数量。
Java 代码:
```Java
class Solution {
int N = 50010, M = N * 2, idx = 0;
int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
public int minReorder(int n, int[][] connections) {
Arrays.fill(he, -1);
for (int[] info : connections) {
int a = info[0], b = info[1];
add(a, b, 1); add(b, a, 0);
}
return dfs(0, -1);
}
int dfs(int u, int fa) {
int ans = 0;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
ans += w[i] + dfs(j, u);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int N = 50010, M = N * 2, idx = 0;
int he[50010], e[100020], ne[100020], w[100020];
void add(int a, int b, int c) {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
}
int minReorder(int n, vector<vector<int>>& connections) {
memset(he, -1, sizeof(he));
for (auto& info : connections) {
int a = info[0], b = info[1];
add(a, b, 1); add(b, a, 0);
}
return dfs(0, -1);
}
int dfs(int u, int fa) {
int ans = 0;
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
ans += w[i] + dfs(j, u);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def minReorder(self, n: int, connections: List[List[int]]) -> int:
N, M, idx = n + 10, (n + 10) * 2, 0
he, e, ne, w = [-1] * N, [0] * M, [0] * M, [0] * M
def add(a, b, c):
nonlocal idx
e[idx], ne[idx], w[idx], he[a] = b, he[a], c, idx
idx += 1
def dfs(u, fa):
ans = 0
i = he[u]
while i != -1:
j, c = e[i], w[i]
i = ne[i]
if j == fa: continue
ans += c + dfs(j, u)
return ans
for a, b in connections:
add(a, b, 1)
add(b, a, 0)
return dfs(0, -1)
```
TypeScript 代码:
```TypeScript
function minReorder(n: number, connections: number[][]): number {
let N = n + 10, M = N * 2, idx = 0;
const he = Array(N).fill(-1), e = Array(M).fill(0), ne = Array(M).fill(0), w = Array(M).fill(0);
const add = function(a: number, b: number, c: number): void {
e[idx] = b;
ne[idx] = he[a];
w[idx] = c;
he[a] = idx++;
};
const dfs = function(u: number, fa: number): number {
let ans = 0;
for (let i = he[u]; i != -1; i = ne[i]) {
const j = e[i];
if (j == fa) continue;
ans += w[i] + dfs(j, u);
}
return ans;
};
for (let [a, b] of connections) {
add(a, b, 1); add(b, a, 0);
}
return dfs(0, -1);
};
```
* 时间复杂度:建图复杂度为 $O(n)$;从 `0` 点开始遍历,访问所有点并统计权重之和的复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1466` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1461-1470/1470. 重新排列数组（简单）.md | 1470. 重新排列数组 | https://leetcode.cn/problems/shuffle-the-array/solution/by-ac_oier-3lck/ | 简单 | [
"模拟"
] | 给你一个数组 `nums`,数组中有 `2n` 个元素,按 $[x_1,x_2,...,x_n,y_1,y_2,...,y_n]$ 的格式排列。
请你将数组按 $[x_1,y_1,x_2,y_2,...,x_n,y_n]$ 格式重新排列,返回重排后的数组。
示例 1:
```
输入:nums = [2,5,1,3,4,7], n = 3
输出:[2,3,5,4,1,7]
解释:由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ,所以答案为 [2,3,5,4,1,7]
```
示例 2:
```
输入:nums = [1,2,3,4,4,3,2,1], n = 4
输出:[1,4,2,3,3,2,4,1]
```
示例 3:
```
输入:nums = [1,1,2,2], n = 2
输出:[1,2,1,2]
```
提示:
* $1 <= n <= 500$
* $nums.length = 2 \times n$
* $1 <= nums[i] <= 10^3$ | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int[] shuffle(int[] nums, int n) {
int[] ans = new int[2 * n];
for (int i = 0, j = n, k = 0; k < 2 * n; k++) {
ans[k] = k % 2 == 0 ? nums[i++] : nums[j++];
}
return ans;
}
}
```
Typescript 代码:
```Typescript
function shuffle(nums: number[], n: number): number[] {
const ans = new Array<number>()
for (let i = 0, j = n, k = 0; k < 2 * n; k++) {
ans.push(k % 2 == 0 ? nums[i++] : nums[j++])
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 加餐
**加餐一道其他题目 [关于 RMQ 的若干解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493262&idx=1&sn=2d8e192a5767b49b9a13a6192ab3b833) 🎉🎉** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1470` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1471-1480/1473. 粉刷房子 III（困难）.md | 1473. 粉刷房子 III | https://leetcode-cn.com/problems/paint-house-iii/solution/gong-shui-san-xie-san-wei-dong-tai-gui-h-ud7m/ | 困难 | [
"动态规划",
"序列 DP"
] | 在一个小城市里,有 `m` 个房子排成一排,你需要给每个房子涂上 `n` 种颜色之一(颜色编号为 `1` 到 `n` )。
有的房子去年夏天已经涂过颜色了,所以这些房子不可以被重新涂色。
我们将连续相同颜色尽可能多的房子称为一个街区。
(比方说 `houses = [1,2,2,3,3,2,1,1]`,它包含 5 个街区 `[{1}, {2,2}, {3,3}, {2}, {1,1}]` 。)
给你一个数组 `houses`,一个 `m * n` 的矩阵 `cost` 和一个整数 `target`,其中:
* `houses[i]`:是第 `i` 个房子的颜色,`0` 表示这个房子还没有被涂色。
* `cost[i][j]`:是将第 `i` 个房子涂成颜色 `j + 1` 的花费。
请你返回房子涂色方案的最小总花费,使得每个房子都被涂色后,恰好组成 `target` 个街区。
如果没有可用的涂色方案,请返回 `-1` 。
示例 1:
```
输入:houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
输出:9
解释:房子涂色方案为 [1,2,2,1,1]
此方案包含 target = 3 个街区,分别是 [{1}, {2,2}, {1,1}]。
涂色的总花费为 (1 + 1 + 1 + 1 + 5) = 9。
```
示例 2:
```
输入:houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
输出:11
解释:有的房子已经被涂色了,在此基础上涂色方案为 [2,2,1,2,2]
此方案包含 target = 3 个街区,分别是 [{2,2}, {1}, {2,2}]。
给第一个和最后一个房子涂色的花费为 (10 + 1) = 11。
```
示例 3:
```
输入:houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5
输出:5
```
示例 4:
```
输入:houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3
输出:-1
解释:房子已经被涂色并组成了 4 个街区,分别是 [{3},{1},{2},{3}] ,无法形成 target = 3 个街区。
```
提示:
* $m = houses.length = cost.length$
* $n = cost[i].length$
* $1 <= m <= 100$
* $1 <= n <= 20$
* $1 <= target <= m$
* $0 <= houses[i] <= n$
* $1 <= cost[i][j] <= 10^4$ | ### 动态规划
**定义 $f[i][j][k]$ 为考虑前 $i$ 间房子,且第 $i$ 间房子的颜色编号为 $j$,前 $i$ 间房子形成的分区数量为 $k$ 的所有方案中的「最小上色成本」。**
我们不失一般性的考虑 $f[i][j][k]$ 该如何转移,由于某些房子本身就已经上色,上色的房子是不允许被粉刷的。
我们可以根据第 $i$ 间房子是否已经被上色,进行分情况讨论:
* 第 $i$ 间房子已经被上色,即 $houses[i] != 0$,此时只有满足 $j == houses[i]$ 的状态才是有意义的,其余状态均为 `INF`。
同时根据「第 $i$ 间房子的颜色 $j$」与「第 $i - 1$ 间房子的颜色 $p$」是否相同,会决定第 $i$ 间房子是否形成一个新的分区。这同样需要进行分情况讨论。
整理后的转移方程为:
$$
f[i][j][k]=\begin{cases}
min(f[i - 1][j][k], f[i - 1][p][k - 1]) &j == houses[i], p != j\\
INF & j != houses[i]
\end{cases}
$$
* 第 $i$ 间房子尚未被上色,即 $houses[i] == 0$,此时房子可以被粉刷成任意颜色。不会有无效状态的情况。
同样,根据「第 $i$ 间房子的颜色 $j$」与「第 $i - 1$ 间房子的颜色 $p$」是否相同,会决定第 $i$ 间房子是否形成一个新的分区。
转移方程为:
$$
f[i][j][k] = min(f[i - 1][j][k], f[i - 1][p][k - 1]) + cost[i][j - 1], p != j
$$
一些编码细节:
* 下标转换:这是个人习惯,无论做什么题,我都喜欢将下标转换为从 $1$ 开始,目的是为了「节省负值下标的分情况讨论」、「将无效状态限制在 $0$ 下标内」或者「充当哨兵」等等。
* 将 `0x3f3f3f3f` 作为 `INF`:因为目标是求最小值,我们应当使用一个较大值充当正无穷,来关联无效状态。同时为了确保不会出现「在正无穷基础上累加导致丢失正无穷含义」的歧义情况,我们可以使用一个有「累加空间」的值作为「正无穷」(这个问题刚好最近在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486435&idx=1&sn=2464b01e9c0fb8d81fcea6dd4ed0ec92&chksm=fd9ca0fccaeb29ea9947456290099143c5bc9bdea0ccfb2408f5fd63f5e0fc13fcd8060d4251&token=515378286&lang=zh_CN#rd) 专门讲过)。
Java 代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
public int minCost(int[] hs, int[][] cost, int m, int n, int t) {
int[][][] f = new int[m + 1][n + 1][t + 1];
// 不存在分区数量为 0 的状态
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
f[i][j][0] = INF;
}
}
for (int i = 1; i <= m; i++) {
int color = hs[i - 1];
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= t; k++) {
// 形成分区数量大于房子数量,状态无效
if (k > i) {
f[i][j][k] = INF;
continue;
}
// 第 i 间房间已经上色
if (color != 0) {
if (j == color) { // 只有与「本来的颜色」相同的状态才允许被转移
int tmp = INF;
// 先从所有「第 i 间房形成新分区」方案中选最优(即与上一房间颜色不同)
for (int p = 1; p <= n; p++) {
if (p != j) {
tmp = Math.min(tmp, f[i - 1][p][k - 1]);
}
}
// 再结合「第 i 间房不形成新分区」方案中选最优(即与上一房间颜色相同)
f[i][j][k] = Math.min(f[i - 1][j][k], tmp);
} else { // 其余状态无效
f[i][j][k] = INF;
}
// 第 i 间房间尚未上色
} else {
int u = cost[i - 1][j - 1];
int tmp = INF;
// 先从所有「第 i 间房形成新分区」方案中选最优(即与上一房间颜色不同)
for (int p = 1; p <= n; p++) {
if (p != j) {
tmp = Math.min(tmp, f[i - 1][p][k - 1]);
}
}
// 再结合「第 i 间房不形成新分区」方案中选最优(即与上一房间颜色相同)
// 并将「上色成本」添加进去
f[i][j][k] = Math.min(tmp, f[i - 1][j][k]) + u;
}
}
}
}
// 从「考虑所有房间,并且形成分区数量为 t」的所有方案中找答案
int ans = INF;
for (int i = 1; i <= n; i++) {
ans = Math.min(ans, f[m][i][t]);
}
return ans == INF ? -1 : ans;
}
}
```
* 时间复杂度:共有 $m \times n \times t$ 个状态需要被转移,每次转移需要枚举「所依赖的状态」的颜色,复杂度为 $O(n)$。整体复杂度为 $O(m \times n^2 \times t)$
* 空间复杂度:$O(m \times n \times t)$
---
### 状态定义的由来
对于有一定 DP 刷题量的同学来说,上述的「状态定义」应该很好理解。
**根据经验,我们可以很容易确定「房间编号维度 $i$」和「分区数量维度 $k$」需要纳入考虑,同时为了在转移过程中,我们能够清楚知道从哪些状态转移过来需要增加「分区数量」,哪些状态转移过来不需要增加,因此需要多引入「最后一间房间颜色 $j$」维度。**
至于对 DP 不熟悉的同学,可以从写「爆搜」开始入手。
**这里的“写”不一定真的要动手去实现一个完整的「爆搜」方案,只需要合理设计出来 `DFS` 函数签名即可。**
但为了更好理解,我写了一个完整版的供你参考。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
int ans = INF;
int[] hs;
int[][] cost;
int m, n, t;
public int minCost(int[] _hs, int[][] _cost, int _m, int _n, int _t) {
m = _m; n = _n; t = _t;
hs = _hs;
cost = _cost;
dfs(0, -1, 0, 0);
return ans == INF ? -1 : ans;
}
// u : 当前处理到的房间编号
// last : 当前处理的房间颜色
// cnt : 当前形成的分区数量
// sum : 当前的上色成本
void dfs(int u, int last, int cnt, int sum) {
if (sum >= ans || cnt > t) return;
if (u == m) {
if (cnt == t) {
ans = Math.min(ans, sum);
}
return;
}
int color = hs[u];
if (color == 0) {
for (int i = 1; i <= n; i++) {
int nCnt = u - 1 < 0 ? 1 : last == i ? cnt : cnt + 1;
dfs(u + 1, i, nCnt, sum + cost[u][i - 1]);
}
} else {
int nCnt = u - 1 < 0 ? 1 : last == color ? cnt : cnt + 1;
dfs(u + 1, color, nCnt, sum);
}
}
}
```
* 时间复杂度:`n` 为颜色数量,`m` 为房间数量。不考虑剪枝效果,每个房间都可以粉刷 `n` 种颜色,复杂度为指数级别的 $O(n^m)$
* 空间复杂度:忽略递归带来的额外空间开销。复杂度为 $O(1)$
可以发现,`DFS` 的可变参数有四个,其中 `sum` 是用于更新最终答案 `ans` 的,其应该作为动规值,其余三个参数,作为动规数组的三个维度。
至此,我们可以确定动态规划的「状态定义」,关于如何利用这种「技巧」来得到一个可靠的「状态定义」最早在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485319&idx=1&sn=95a3dc9c97ca57185de792ca70924afe&chksm=fd9cac98caeb258ebea466f59378670a90af1cb3015ae70922e1d04ac711a5b8d8d853ac5e7d&token=515378286&lang=zh_CN#rd) 讲过。
---
### 记忆化搜索
看到评论区有同学贴了「记忆化搜索」的版本,那么就作为补充增加到题解吧 ~
注意记忆化容器应当与我们的「动规数组」结构保存一致。
代码:
```Java
class Solution {
int INF = 0x3f3f3f3f;
int m, n, t;
int[] hs;
int[][] cost;
boolean[][][] vis;
int[][][] cache;
public int minCost(int[] _hs, int[][] _cost, int _m, int _n, int _t) {
m = _m; n = _n; t = _t;
hs = _hs;
cost = _cost;
vis = new boolean[m + 1][n + 1][t + 1];
cache = new int[m + 1][n + 1][t + 1];
int ans = dfs(0, 0, 0, 0);
return ans == INF ? -1 : ans;
}
int dfs(int u, int last, int cnt, int sum){
if(cnt > t) return INF;
if(vis[u][last][cnt]) return cache[u][last][cnt];
if (u == m) return cnt == t ? 0 : INF;
int ans = INF;
int color = hs[u];
if(color == 0){
for(int i = 1; i <= n; i++){
int nCnt = u == 0 ? 1 : last == i ? cnt : cnt + 1;
int cur = dfs(u + 1, i, nCnt, sum + cost[u][i - 1]);
ans = Math.min(ans, cur + cost[u][i - 1]);
}
} else{
int nCnt = u == 0 ? 1 : last == color ? cnt : cnt + 1;
int cur = dfs(u + 1, color, nCnt, sum);
ans = Math.min(ans, cur);
}
vis[u][last][cnt] = true;
cache[u][last][cnt] = ans;
return ans;
}
}
```
* 时间复杂度:共有 $m \times n \times t$ 个状态需要被转移,每次转移需要枚举「所依赖的状态」的颜色,复杂度为 $O(n)$。整体复杂度为 $O(m \times n^2 \times t)$
* 空间复杂度:$O(m \times n \times t)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1473` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1471-1480/1475. 商品折扣后的最终价格（简单）.md | 1475. 商品折扣后的最终价格 | https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop/solution/by-ac_oier-hw5b/ | 简单 | [
"模拟",
"单调栈"
] | 给你一个数组 `prices`,其中 `prices[i]` 是商店里第 `i` 件商品的价格。
商店里正在进行促销活动,如果你要买第 `i` 件商品,那么你可以得到与 `prices[j]` 相等的折扣,其中 `j` 是满足 `j > i` 且 `prices[j] <= prices[i]` 的 最小下标 ,如果没有满足条件的 `j` ,你将没有任何折扣。
请你返回一个数组,数组中第 `i` 个元素是折扣后你购买商品 `i` 最终需要支付的价格。
示例 1:
```
输入:prices = [8,4,6,2,3]
输出:[4,2,4,2,3]
解释:
商品 0 的价格为 price[0]=8 ,你将得到 prices[1]=4 的折扣,所以最终价格为 8 - 4 = 4 。
商品 1 的价格为 price[1]=4 ,你将得到 prices[3]=2 的折扣,所以最终价格为 4 - 2 = 2 。
商品 2 的价格为 price[2]=6 ,你将得到 prices[3]=2 的折扣,所以最终价格为 6 - 2 = 4 。
商品 3 和 4 都没有折扣。
```
示例 2:
```
输入:prices = [1,2,3,4,5]
输出:[1,2,3,4,5]
解释:在这个例子中,所有商品都没有折扣。
```
示例 3:
```
输入:prices = [10,1,1,6]
输出:[9,0,1,6]
```
提示:
* $1 <= prices.length <= 500$
* $1 <= prices[i] <= 10^3$ | ### 模拟
数据范围为 $10^3$,可直接模拟。
Java 代码:
```Java
class Solution {
public int[] finalPrices(int[] ps) {
int n = ps.length;
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
int k = 0;
for (int j = i + 1; j < n && k == 0; j++) {
if (ps[j] <= ps[i]) k = ps[j];
}
ans[i] = ps[i] - k;
}
return ans;
}
}
```
Typescript 代码:
```Typescript
function finalPrices(ps: number[]): number[] {
const n = ps.length
const ans = new Array<number>(n).fill(0)
for (let i = 0; i < n; i++) {
let k = 0
for (let j = i + 1; j < n && k == 0; j++) {
if (ps[j] <= ps[i]) k = ps[j]
}
ans[i] = ps[i] - k
}
return ans
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
---
### 单调栈
根据题意,我们知道若 $nums[i]$ 存在折扣,必然是被其右边最近一个满足「$nums[j] <= nums[i]$」的 $nums[j]$ 所更新。反过来说,给定一个 $nums[j]$,其所能更新的是其左边最近一个满足「$nums[i] >= nums[j]$」的 $nums[i]$。
因此我们可以使用「单调栈」来进行求解。
当然,我们也能不依靠经验,而从问题的本身出发,逐步分析出该做法。
具体的,我们可以从前往后处理所有的 $nums[i]$,使用某类容器装载我们所有的「待打折」的商品下标。假设当前处理到的是 $nums[i]$:
* 若其比容器内的任意商品价格要高,其必然不能更新任何一个待打折商品的价格,将其也加入容器尾部(此时我们发现,若有一个新的商品加入容器,其必然是当前所有待打折商品中的价格最高的,即容器内的商品价格单调递增);
* 若其价格不高于容器内的商品价格,其能够更新容器内待打折的商品价格,并且由于我们容器满足单调递增特性,我们必然能够从尾部开始取出待打折商品来进行更新,直到处理完成或遇到第一个无法更新价格的商品。
由于我们需要往尾部添加和取出元素,因此容器可使用「栈」。
**至此,我们分析了单调栈做法的两大重点:为何单调 & 为何用栈。若对「单调栈」仍不了解的同学,可以看前置 🧀 : [关于 RMQ 的若干解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493262&idx=1&sn=2d8e192a5767b49b9a13a6192ab3b833) 中的第四种解法 🎉🎉🎉。**
Java 代码:
```Java
class Solution {
public int[] finalPrices(int[] ps) {
int n = ps.length;
int[] ans = new int[n];
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && ps[d.peekLast()] >= ps[i]) {
int idx = d.pollLast();
ans[idx] = ps[idx] - ps[i];
}
d.addLast(i); ans[i] = ps[i];
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function finalPrices(ps: number[]): number[] {
let n = ps.length, he = 0, ta = 0
const ans = new Array<number>(n).fill(0)
const stk = new Array<number>(n).fill(0)
for (let i = 0; i < n; i++) {
while (he < ta && ps[stk[ta - 1]] >= ps[i]) {
const idx = stk[--ta]
ans[idx] = ps[idx] - ps[i]
}
stk[ta++] = i; ans[i] = ps[i]
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1475` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1471-1480/1480. 一维数组的动态和（简单）.md | 1480. 一维数组的动态和 | https://leetcode-cn.com/problems/running-sum-of-1d-array/solution/gong-shui-san-xie-yi-wei-qian-zhui-he-mo-g8hn/ | 简单 | [
"模拟",
"前缀和"
] | 给你一个数组 nums 。数组「动态和」的计算公式为:runningSum[i] = sum(nums[0]...nums[i]) 。
请返回 nums 的动态和。
示例 1:
```
输入:nums = [1,2,3,4]
输出:[1,3,6,10]
解释:动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
```
示例 2:
```
输入:nums = [1,1,1,1,1]
输出:[1,2,3,4,5]
解释:动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
```
示例 3:
```
输入:nums = [3,1,2,10,1]
输出:[3,4,6,16,17]
```
提示:
* 1 <= nums.length <= 1000
* -$10^6$ <= nums[i] <= $10^6$ | ### 一维前缀和
根据题意,创建答案数组,从头到尾模拟一遍,每次都将当前的前缀之和赋值给 $ans[i]$ 即可。
代码:
```Java
class Solution {
public int[] runningSum(int[] nums) {
int n = nums.length;
int[] ans = new int[n];
for (int i = 0, s = 0; i < n; i++) {
ans[i] = s = s + nums[i];
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1480` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1481-1490/1482. 制作 m 束花所需的最少天数（中等）.md | 1482. 制作 m 束花所需的最少天数 | https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/ | 中等 | [
"二分"
] | 给你一个整数数组 bloomDay,以及两个整数 m 和 k 。
现需要制作 m 束花。制作花束时,需要使用花园中 相邻的 k 朵花 。
花园中有 n 朵花,第 i 朵花会在 bloomDay[i] 时盛开,恰好 可以用于 一束 花中。
请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。
示例 1:
```
输入:bloomDay = [1,10,3,10,2], m = 3, k = 1
输出:3
解释:让我们一起观察这三天的花开过程,x 表示花开,而 _ 表示花还未开。
现在需要制作 3 束花,每束只需要 1 朵。
1 天后:[x, _, _, _, _] // 只能制作 1 束花
2 天后:[x, _, _, _, x] // 只能制作 2 束花
3 天后:[x, _, x, _, x] // 可以制作 3 束花,答案为 3
```
示例 2:
```
输入:bloomDay = [1,10,3,10,2], m = 3, k = 2
输出:-1
解释:要制作 3 束花,每束需要 2 朵花,也就是一共需要 6 朵花。而花园中只有 5 朵花,无法满足制作要求,返回 -1 。
```
示例 3:
```
输入:bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
输出:12
解释:要制作 2 束花,每束需要 3 朵。
花园在 7 天后和 12 天后的情况如下:
7 天后:[x, x, x, x, _, x, x]
可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花,因为它们不相邻。
12 天后:[x, x, x, x, x, x, x]
显然,我们可以用不同的方式制作两束花。
```
示例 4:
```
输入:bloomDay = [1000000000,1000000000], m = 1, k = 1
输出:1000000000
解释:需要等 1000000000 天才能采到花来制作花束
```
示例 5:
```
输入:bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
输出:9
```
提示:
* bloomDay.length == n
* 1 <= n <= $10^5$
* 1 <= bloomDay[i] <= $10^9$
* 1 <= m <= $10^6$
* 1 <= k <= n | ### 二分查找
题目需要求得「所需的最少天数」。
假设「所需的最少天数」为 `ans` ,那么以 `ans` 为分割点的数轴具有「二段性」:
* 天数范围落在 $[0, ans)$ 无法制作完成
* 天数范围在 $[ans, +∞)$ 可以制作完成
因此可以通过「二分」来找到分割点 `ans`。
接下来我们需要确定「二分范围」,一个及格的「二分范围」只需要确保答案落在范围即可。
显然范围的左边界为 $0$(代表尚未有花绽放),范围的右边界为 $max(bloomDay[i])$(最后一朵花的开放时间,代表所有花都开完)。
我们既可以通过遍历 $bloomDay[]$ 数组来取得「精确右边界」,也可以直接根据数据范围 `1 <= bloomDay[i] <= 10^9` 来确定「粗略右边界」。
由于二分查找本身具有“折半”效率,因此两者不会有太大效率差距,我这里采用「粗略右边界」的方式。
代码:
```Java
class Solution {
int n, m, k;
boolean[] fl;
public int minDays(int[] nums, int _m, int _k) {
n = nums.length;
m = _m; k = _k;
if (n < m * k) return -1;
fl = new boolean[n];
int l = 0, r = (int)1e9;
while (l < r) {
int mid = l + r >> 1;
if (check(nums, mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return check(nums, r) ? r : -1;
}
boolean check(int[] nums, int mid) {
for (int i = 0; i < n; i++) {
fl[i] = nums[i] <= mid;
}
int cnt = 0;
for (int i = 0; i < n && cnt < m; ) {
if (fl[i]) {
int cur = 1, j = i;
while (cur < k && j + 1 < n && fl[j + 1]) {
j++;
cur++;
}
if (cur == k) cnt++;
i = j + 1;
} else {
i++;
}
}
return cnt >= m;
}
}
```
* 时间复杂度:`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\log{1e9})$
* 空间复杂度:$O(n)$
---
### 优化 check 函数
不难发现,上述 `check` 函数每次都先将所有已开的花预处理出来。复杂度是严格 $O(n)$。
其实这个过程也能下放到统计逻辑去做,这样能够让 `check` 函数的复杂度从严格 $O(n)$ 变为最坏情况 $O(n)$,同时省去 $fl[]$ 数组,将空间优化至 $O(1)$。
代码:
```Java
class Solution {
int n, m, k;
public int minDays(int[] nums, int _m, int _k) {
n = nums.length;
m = _m; k = _k;
if (n < m * k) return -1;
int l = 0, r = (int)1e9;
while (l < r) {
int mid = l + r >> 1;
if (check(nums, mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return check(nums, r) ? r : -1;
}
boolean check(int[] nums, int mid) {
int cnt = 0;
for (int i = 0; i < n && cnt < m; ) {
int cur = nums[i] <= mid ? 1 : 0, j = i;
if (cur > 0) {
while (cur < k && j + 1 < n && nums[j + 1] <= mid) {
j++;
cur++;
}
if (cur == k) cnt++;
i = j + 1;
} else {
i++;
}
}
return cnt >= m;
}
}
```
* 时间复杂度:`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\log{1e9})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1482` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1481-1490/1486. 数组异或操作（简单）.md | 1486. 数组异或操作 | https://leetcode-cn.com/problems/xor-operation-in-an-array/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-dggg/ | 简单 | [
"数学",
"模拟"
] | 给你两个整数,n 和 start 。
数组 nums 定义为:nums[i] = start + 2*i(下标从 0 开始)且 n == nums.length 。
请返回 nums 中所有元素按位异或(XOR)后得到的结果。
示例 1:
```
输入:n = 5, start = 0
输出:8
解释:数组 nums 为 [0, 2, 4, 6, 8],其中 (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8 。
"^" 为按位异或 XOR 运算符。
```
示例 2:
```
输入:n = 4, start = 3
输出:8
解释:数组 nums 为 [3, 5, 7, 9],其中 (3 ^ 5 ^ 7 ^ 9) = 8.
```
示例 3:
```
输入:n = 1, start = 7
输出:7
```
示例 4:
```
输入:n = 10, start = 5
输出:2
```
提示:
* 1 <= n <= 1000
* 0 <= start <= 1000
* n == nums.length | ### 模拟
数据范围只有 $10^3$,按照题目要求从头模拟一遍即可。
代码:
```Java
class Solution {
public int xorOperation(int n, int start) {
int ans = start;
for (int i = 1; i < n; i++) {
int x = start + 2 * i;
ans ^= x;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 数学
上述解法数据范围出到 $10^8$ 大概率会发生 TLE。
如果数据范围出到 $10^8$ 的话,本题难度应该会归为「中等」或「困难」。
事实上,本题存在「数学规律」解法。
原式子为 $start ⊕ (start + 2) ⊕ (start + 4) ⊕ ... ⊕ (start + 2 * (n - 1))$ 。
我们发现原式子中只有数值 $2$ 是固定系数(由题目给定),考虑将其进行提出。
得到新式子 $s ⊕ (s + 1) ⊕ (s + 2) ⊕ ... ⊕ (s + (n - 1)) * 2$,其中 $s = start / 2$。
之所以进行这样的转换操作,是因为我们想要利用 $1 ⊕ 2 ⊕ 3 = 0$ 的异或性质。
**但是转换到了这一步,我们发现「新式子」与「原式子」其实并不相等。**
我们需要考虑两者之间的差值关系:
**不难发现,将「原式」转化成「新式」的集体除以 $2$ 的操作相当于将每个 $item$ 的进行「右移一位」,同时「异或运算」是每位独立计算的,因此「右移一位」不会影响移动部分的计算结果。**
**本质上,「原式」转化成「新式」是将最终答案 `ans` 进了「右移」一位的操作。因此如果要重新得到 `ans`,我们需要将其重新「左移」一位,将最后一位异或结果补回。**
即 `原式结果 = 新式结果 << 1 | e`,$e$ 为最后一位异或结果(只能是 $0$ 或者 $1$,其余高位为 $0$)。
我们重新观察「原式」发现式子中每个 $item$ 奇偶性相同,这意味着其二进制的最低位相同。
根据 `n` 和 `start` 的奇偶数搭配,不难得最后一位 `e = n & start & 1`。
剩下的问题在于如何在不遍历的情况下计算「新式」结果,前面说到转化的目的是为了利用 $1 ⊕ 2 ⊕ 3 = 0$ 异或特性。
事实上,这个式子存在一般性的推广结论:$4i ⊕ (4i + 1) ⊕ (4i + 2) ⊕ (4i + 3) = 0$。
因此只需要对最后一项进行 `%4` 讨论即可,这部分属于「结论」,详见代码的 `calc` 部分。
**总结一下,假设我们最终的答案为 `ans`。整个处理过程其实就是把原式中的每个 $item$ 右移一位(除以 $2$),计算 `ans` 中除了最低一位以外的结果;然后再将 `ans` 进行一位左移(重新乘以 $2$),将原本丢失的最后一位结果重新补上。补上则是利用了 `n` 和 `start` 的「奇偶性」的讨论。**
代码:
```Java
class Solution {
int calc(int x) {
if (x % 4 == 0) return x;
else if (x % 4 == 1) return 1;
else if (x % 4 == 2) return x + 1;
else return 0;
}
public int xorOperation(int n, int start) {
// 整体除以 2,利用 %4 结论计算 ans 中除「最低一位」的结果
int s = start >> 1;
int prefix = calc(s - 1) ^ calc(s + n - 1);
// 利用「奇偶性」计算 ans 中的「最低一位」结果
int last = n & start & 1;
int ans = prefix << 1 | last;
return ans;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1486` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1501-1510/1503. 所有蚂蚁掉下来前的最后一刻（中等）.md | 1503. 所有蚂蚁掉下来前的最后一刻 | https://leetcode.cn/problems/last-moment-before-all-ants-fall-out-of-a-plank/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-u77hy/ | 中等 | [
"模拟",
"脑筋急转弯"
] | 有一块木板,长度为 `n` 个 单位 。一些蚂蚁在木板上移动,每只蚂蚁都以每秒一个单位的速度移动。其中,一部分蚂蚁向左移动,其他蚂蚁向右移动。
当两只向 不同 方向移动的蚂蚁在某个点相遇时,它们会同时改变移动方向并继续移动。假设更改方向不会花费任何额外时间。
而当蚂蚁在某一时刻 `t` 到达木板的一端时,它立即从木板上掉下来。
给你一个整数 `n` 和两个整数数组 `left` 以及 `right`。两个数组分别标识向左或者向右移动的蚂蚁在 `t = 0` 时的位置。请你返回最后一只蚂蚁从木板上掉下来的时刻。
示例 1:
```
输入:n = 4, left = [4,3], right = [0,1]
输出:4
解释:如上图所示:
-下标 0 处的蚂蚁命名为 A 并向右移动。
-下标 1 处的蚂蚁命名为 B 并向右移动。
-下标 3 处的蚂蚁命名为 C 并向左移动。
-下标 4 处的蚂蚁命名为 D 并向左移动。
请注意,蚂蚁在木板上的最后时刻是 t = 4 秒,之后蚂蚁立即从木板上掉下来。(也就是说在 t = 4.0000000001 时,木板上没有蚂蚁)。
```
示例 2:
```
输入:n = 7, left = [], right = [0,1,2,3,4,5,6,7]
输出:7
解释:所有蚂蚁都向右移动,下标为 0 的蚂蚁需要 7 秒才能从木板上掉落。
```
示例 3:
```
输入:n = 7, left = [0,1,2,3,4,5,6,7], right = []
输出:7
解释:所有蚂蚁都向左移动,下标为 7 的蚂蚁需要 7 秒才能从木板上掉落。
```
提示:
* $1 <= n <= 10^4$
* $0 <= left.length <= n + 1$
* $0 <= left[i] <= n$
* $0 <= right.length <= n + 1$
* $0 <= right[i] <= n$
* $1 <= left.length + right.length <= n + 1$
* `left` 和 `right` 中的所有值都是唯一的,并且每个值 只能出现在二者之一 中。 | ### 模拟
当一只蚂蚁起始位置为 `x`,方向往左,且往左移动过程不受其他影响时,其到达左边界所需时间为 `x`;若方向往右,且往右移动过程不受其他影响时,其到达右边界所需时间为 `n - x`。
蚂蚁之间的相互影响实际上并不会影响它们到达木板边缘的时间。
两只相遇的蚂蚁只是简单地交换了彼此的移动方向,并没有影响到它们的移动步数,即两只蚂蚁相遇可视为身份互换。
因此,我们只需要分别计算每只蚂蚁单独掉落到木板边缘所需的时间,然后取最大值即可得到所有蚂蚁掉落的最后时刻。
Java 代码:
```Java
class Solution {
public int getLastMoment(int n, int[] left, int[] right) {
int ans = 0;
for (int x : left) ans = Math.max(ans, x);
for (int x : right) ans = Math.max(ans, n - x);
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int getLastMoment(int n, vector<int>& left, vector<int>& right) {
int ans = 0;
for (int x : left) ans = max(ans, x);
for (int x : right) ans = max(ans, n - x);
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def getLastMoment(self, n: int, left: List[int], right: List[int]) -> int:
return max(left + [n - x for x in right])
```
TypeScript 代码:
```TypeScript
function getLastMoment(n: number, left: number[], right: number[]): number {
let ans = 0;
for (const x of left) ans = Math.max(ans, x);
for (const x of right) ans = Math.max(ans, n - x);
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1503` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/153. 寻找旋转排序数组中的最小值（中等）.md | 153. 寻找旋转排序数组中的最小值 | https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/ | 中等 | [
"二分"
] | 已知一个长度为 n 的数组,预先按照升序排列,经由 1 到 n 次 旋转 后,得到输入数组。
例如,原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到:
* 若旋转 4 次,则可以得到 [4,5,6,7,0,1,2]
* 若旋转 7 次,则可以得到 [0,1,2,4,5,6,7]
注意,数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
给你一个元素值 互不相同 的数组 nums ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
示例 1:
```
输入:nums = [3,4,5,1,2]
输出:1
解释:原数组为 [1,2,3,4,5] ,旋转 3 次得到输入数组。
```
示例 2:
```
输入:nums = [4,5,6,7,0,1,2]
输出:0
解释:原数组为 [0,1,2,4,5,6,7] ,旋转 4 次得到输入数组。
```
示例 3:
```
输入:nums = [11,13,15,17]
输出:11
解释:原数组为 [11,13,15,17] ,旋转 4 次得到输入数组。
```
提示:
* n == nums.length
* 1 <= n <= 5000
* -5000 <= nums[i] <= 5000
* nums 中的所有整数 互不相同
* nums 原来是一个升序排序的数组,并进行了 1 至 n 次旋转 | ### 二分查找
今天这道题和昨天的 [81. 搜索旋转排序数组 II](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) 相比,有了限制条件「所有整数互不相同」。
因此我们不需要进行「恢复二段性」的预处理,是可以做到严格 $O(log{n})$ 的复杂度。
我们仍然从「二分」的本质「二段性」进行出发分析:
经过旋转的数组,显然前半段满足 `>= nums[0]`,而后半段不满足 `>= nums[0]`。我们可以以此作为依据,通过「二分」找到旋转点。然后通过旋转点找到全局最小值即可。
代码:
```java []
class Solution {
public int findMin(int[] nums) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] >= nums[0]) {
l = mid;
} else {
r = mid - 1;
}
}
return r + 1 < n ? nums[r + 1] : nums[0];
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
***
### 其他「二分」相关题解
* 二分模板
[29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)
* 二分本质 & 恢复二段性处理
[33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)
[81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)
[153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)
[154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)
* 二分 check 函数如何确定
[34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)
* 二分答案的题目
[1482. 制作 m 束花所需的最少天数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/) : [利用「二段性」找分割点,以及优化 check 函数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/)
[1011. 在 D 天内送达包裹的能力](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/) : [利用「二段性」找分割点,以及如何确定「二分范围」](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.153` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/154. 寻找旋转排序数组中的最小值 II（困难）.md | 154. 寻找旋转排序数组中的最小值 II | https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/ | 困难 | [
"二分"
] | 已知一个长度为 `n` 的数组,预先按照升序排列,经由 $1$ 到 $n$ 次 旋转 后,得到输入数组。
例如,原数组 `nums = [0,1,4,4,5,6,7]` 在变化后可能得到:
* 若旋转 $4$ 次,则可以得到 `[4,5,6,7,0,1,4]`
* 若旋转 $74 次,则可以得到 `[0,1,4,4,5,6,7]`
注意,数组 `[a[0], a[1], a[2], ..., a[n-1]]` 旋转一次 的结果为数组 `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]` 。
给你一个可能存在「重复」元素值的数组 `nums` ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。
请你找出并返回数组中的「最小元素」。
示例 1:
```
输入:nums = [1,3,5]
输出:1
```
示例 2:
```
输入:nums = [2,2,2,0,1]
输出:0
```
提示:
* $n == nums.length$
* $1 <= n <= 5000$
* $-5000 <= nums[i] <= 5000$
* `nums` 原来是一个升序排序的数组,并进行了 $1$ 至 $n$ 次旋转
进阶:
* 这道题是 寻找旋转排序数组中的最小值 的延伸题目。
* 允许重复会影响算法的时间复杂度吗?会如何影响,为什么? | ### 二分
根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。
但和 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/) 不同的是,本题元素并不唯一。
**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**
**因为「二分」的本质是二段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。**
如果你有看过我 [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/) 这篇题解,你应该很容易就理解上句话的意思。如果没有也没关系,我们可以先解决本题,在理解后你再去做 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/),我认为这两题都是一样的,不存在先后关系。
举个🌰,我们使用数据 [0,1,2,2,2,3,4,5] 来理解为什么不同的旋转点会导致「二段性丢失」:
Java 代码:
```java
class Solution {
public int minArray(int[] nums) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r && nums[0] == nums[r]) r--;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] >= nums[0]) l = mid;
else r = mid - 1;
}
return r + 1 < n ? nums[r + 1] : nums[0];
}
}
```
TypeScript 代码:
```TypeScript
function minArray(nums: number[]): number {
const n = nums.length
let l = 0, r = n - 1
while (l < r && nums[0] == nums[r]) r--
while (l < r) {
const mid = l + r + 1 >> 1
if (nums[mid] >= nums[0]) l = mid
else r = mid - 1
}
return r + 1 < n ? nums[r + 1] : nums[0]
};
```
* 时间复杂度:恢复二段性处理中,最坏的情况下(考虑整个数组都是同一个数)复杂度是 $O(n)$,而之后的找旋转点是「二分」,复杂度为 $O(\log{n})$。整体复杂度为 $O(n)$
* 空间复杂度:$O(1)$
---
### 进阶
如果真正理解「二分」的话,本题和 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) 区别不大。
建议大家在完成两题的基础上试试 [面试题 10.03. 搜索旋转数组](https://leetcode-cn.com/problems/search-rotate-array-lcci/) 。
---
### 其他「二分」相关题解
* 二分模板
[29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)
* 二分本质 & 恢复二段性处理
[33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)
[81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)
[153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)
[154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)
* 二分 check 函数如何确定
[34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)
* 二分答案的题目
[1482. 制作 m 束花所需的最少天数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/) : [利用「二段性」找分割点,以及优化 check 函数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/)
[1011. 在 D 天内送达包裹的能力](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/) : [利用「二段性」找分割点,以及如何确定「二分范围」](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.154` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/155. 最小栈（简单）.md | 155. 最小栈 | https://leetcode-cn.com/problems/min-stack/solution/tu-li-zhan-shi-shuang-zhan-shi-xian-zui-fcwj5/ | 简单 | [
"栈"
] | 设计一个支持 push ,pop ,top 操作,并能在常数时间内检索到最小元素的栈。
* push(x) —— 将元素 x 推入栈中。
* pop() —— 删除栈顶的元素。
* top() —— 获取栈顶元素。
* getMin() —— 检索栈中的最小元素。
示例:
```
输入:
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]
```
输出:
```
[null,null,null,null,-3,null,0,-2]
解释:
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
```
提示:
* pop、top 和 getMin 操作总是在 非空栈 上调用。 | ### 双栈解法
为了快速找到栈中最小的元素,我们可以使用一个辅助栈 help。
通过控制 help 的压栈逻辑来实现:*help 栈顶中始终存放着栈内元素的最小值。*
代码:
```java
class MinStack {
Deque<Integer> data = new ArrayDeque<>();
Deque<Integer> help = new ArrayDeque<>();
public void push(int val) {
data.addLast(val);
if (help.isEmpty() || help.peekLast() >= val) {
help.addLast(val);
} else {
help.addLast(help.peekLast());
}
}
public void pop() {
data.pollLast();
help.pollLast();
}
public int top() {
return data.peekLast();
}
public int getMin() {
return help.peekLast();
}
}
```
* 时间复杂度:所有的操作均为 $O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.155` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/151-160/160. 相交链表（简单）.md | 160. 相交链表 | https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/gong-shui-san-xie-zhao-liang-tiao-lian-b-h3bd/ | 简单 | [
"链表",
"栈"
] | 给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
图示两个链表在节点 c1 开始相交:
<img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png" style="zoom:50%;" />
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
示例 1:
<img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_1.png" style="zoom:50%;" />
```
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '8'
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。
在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
```
示例 2:
<img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_2.png" style="zoom: 67%;" />
```
输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出:Intersected at '2'
解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。
在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。
```
示例 3:
```
输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出:null
解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。
由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。
这两个链表不相交,因此返回 null 。
```
提示:
* listA 中节点数目为 m
* listB 中节点数目为 n
* 0 <= m, n <= 3 * $10^4$
* 1 <= Node.val <= $10^5$
* 0 <= skipA <= m
* 0 <= skipB <= n
* 如果 listA 和 listB 没有交点,intersectVal 为 0
* 如果 listA 和 listB 有交点,intersectVal == listA[skipA + 1] == listB[skipB + 1]
进阶:你能否设计一个时间复杂度 $O(n)$ 、仅用 $O(1)$ 内存的解决方案? | ### 朴素解法
一个朴素的做法是两层循环:当遇到第一个相同的节点时说明找到了;全都走完了还没遇到相同,说明不存在交点。
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
for (ListNode h1 = a; h1 != null ; h1 = h1.next) {
for (ListNode h2 = b; h2 != null ; h2 = h2.next) {
if (h1.equals(h2)) return h1;
}
}
return null;
}
}
```
* 时间复杂度:$O(n * m)$
* 空间复杂度:$O(1)$
---
### 栈解法
将两条链表分别压入两个栈中,然后循环比较两个栈的栈顶元素,同时记录上一位栈顶元素。
当遇到第一个不同的节点时,结束循环,上一位栈顶元素即是答案。
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
Deque<ListNode> d1 = new ArrayDeque(), d2 = new ArrayDeque();
while (a != null) {
d1.addLast(a);
a = a.next;
}
while (b != null) {
d2.addLast(b);
b = b.next;
}
ListNode ans = null;
while (!d1.isEmpty() && !d2.isEmpty() && d1.peekLast().equals(d2.peekLast())) {
ListNode c1 = d1.pollLast(), c2 = d2.pollLast();
ans = c1;
}
return ans;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$
---
### 差值解法
先对两条链表扫描一遍,取得两者长度,然后让长的链表先走「两者的长度差值」,然后再同时走,遇到第一个节点即是答案。
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
int c1 = 0, c2 = 0;
ListNode t1 = a, t2 = b;
while (t1 != null && ++c1 > 0) t1 = t1.next;
while (t2 != null && ++c2 > 0) t2 = t2.next;
int t = Math.abs(c1 - c2);
while (t-- > 0) {
if (c1 > c2) a = a.next;
else b = b.next;
}
while (a != null && b != null) {
if (a.equals(b)) {
return a;
} else {
a = a.next;
b = b.next;
}
}
return null;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.160` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1511-1520/1518. 换酒问题（简单）.md | 1518. 换酒问题 | https://leetcode-cn.com/problems/water-bottles/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-sh-7yyo/ | 简单 | [
"模拟",
"数学"
] | 小区便利店正在促销,用 `numExchange` 个空酒瓶可以兑换一瓶新酒。你购入了 `numBottles` 瓶酒。
如果喝掉了酒瓶中的酒,那么酒瓶就会变成空的。
请你计算**最多**能喝到多少瓶酒。
示例 1:
```
输入:numBottles = 9, numExchange = 3
输出:13
解释:你可以用 3 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 9 + 3 + 1 = 13 瓶酒。
```
示例 2:
```
输入:numBottles = 15, numExchange = 4
输出:19
解释:你可以用 4 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 15 + 3 + 1 = 19 瓶酒。
```
示例 3:
```
输入:numBottles = 5, numExchange = 5
输出:6
```
示例 4:
```
输入:numBottles = 2, numExchange = 3
输出:2
```
提示:
* $1 <= numBottles <= 100$
* $2 <= numExchange <= 100$ | ### 模拟
根据题意进行模拟即可,使用 $ans$ 统计答案,$n$ 为空瓶子个数。
起始有 $n$ 瓶酒,因此 $ans = n$,此时空瓶子个数为 $n$,当且仅当空瓶子个数 $n$ 大于等于兑换个数 $m$ 时,可以继续喝到酒(能够更新 $ans$),兑换后得到酒的个数为 $a = \left \lfloor \frac{n}{m} \right \rfloor$,剩余空瓶子个数等于「兑换酒的个数 $a$」和「兑换后剩余的酒瓶子个数 $b = n \pmod m$」之和。
代码:
```Java
class Solution {
public int numWaterBottles(int n, int m) {
int ans = n;
while (n >= m) {
int a = n / m, b = n % m;
ans += a;
n = a + b;
}
return ans;
}
}
```
* 时间复杂度:循环次数「不超过」能换新酒的数量,能够新酒的数量最多为 $\left \lfloor \frac{n}{m - 1}\right \rfloor$ 瓶。复杂度为 $O(\left \lfloor \frac{n}{m - 1}\right \rfloor)$。进一步,当 $m = 2$ 时,兑换酒的数量最多,此时复杂度为 $O(\log{n})$
* 空间复杂度:$O(1)$
---
### 数学
起始有 $n$ 瓶酒,使用 $m$ 个空酒瓶能够换得一瓶新酒(饮用数量加一,且新瓶子数量加一)。即对于每次交换而言,会损失掉 $m - 1$ 个瓶子。
利用每个回合损失的瓶子个数 $m - 1$ 为定值,可直接算出最大交换次数(额外饮用次数)$cnt = \left \lfloor \frac{n}{m - 1}\right \rfloor$,加上起始酒的个数即是答案。
注意边界条件:当 $n$ 为 $m - 1$ 的倍数时,最后一个回合不满足兑换条件。
代码:
```Java
class Solution {
public int numWaterBottles(int n, int m) {
int cnt = n / (m - 1);
return n % (m - 1) == 0 ? n + cnt - 1 : n + cnt;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1518` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1531-1540/1537. 最大得分（困难）.md | 1537. 最大得分 | https://leetcode.cn/problems/get-the-maximum-score/solution/by-ac_oier-ht78/ | 困难 | [
"前缀和",
"构造",
"双指针",
"序列 DP",
"动态规划"
] | 你有两个 有序 且数组内元素互不相同的数组 `nums1` 和 `nums2` 。
一条 合法路径 定义如下:
* 选择数组 `nums1` 或者 `nums2` 开始遍历(从下标 $0$ 处开始)。
* 从左到右遍历当前数组。
* 如果你遇到了 `nums1` 和 `nums2` 中都存在的值,那么你可以切换路径到另一个数组对应数字处继续遍历(但在合法路径中重复数字只会被统计一次)。
得分定义为合法路径中不同数字的和。
请你返回所有可能合法路径中的最大得分。
由于答案可能很大,请你将它对 $10^9 + 7$ 取余后返回。
示例 1:
```
输入:nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]
输出:30
解释:合法路径包括:
[2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],(从 nums1 开始遍历)
[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10] (从 nums2 开始遍历)
最大得分为上图中的绿色路径 [2,4,6,8,10] 。
```
示例 2:
```
输入:nums1 = [1,3,5,7,9], nums2 = [3,5,100]
输出:109
解释:最大得分由路径 [1,3,5,100] 得到。
```
示例 3:
```
输入:nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]
输出:40
解释:nums1 和 nums2 之间无相同数字。
最大得分由路径 [6,7,8,9,10] 得到。
```
示例 4:
```
输入:nums1 = [1,4,5,8,9,11,19], nums2 = [2,3,4,11,12]
输出:61
```
提示:
* $1 <= nums1.length <= 10^5$
* $1 <= nums2.length <= 10^5$
* $1 <= nums1[i], nums2[i] <= 10^7$
* `nums1` 和 `nums2` 都是严格递增的数组。 | ### 前缀和 + 构造(分段计算)
一个简单且正确的做法,是我们构造一种决策方案,使得能够直接计算出最大得分。
首先,在最佳路径中所有的公共点都必然会经过,因此我们可以将值相等的点进行合并,即看作同一个点。
利用两个数组均满足「单调递增」,我们可以通过 $O(n + m)$ 的复杂度统计出那些公共点,以二元组 $(i, j)$ 的形式存储到 `list` 数组(二元组含义为 $nums1[i] = nums2[j]$)。
对于 `list` 中的每对相邻元素(相邻公共点),假设为 $(a_i, b_i)$ 和 $(c_i, d_i)$,我们可以通过「前缀和」计算出 $nums1[a_i ... c_i]$ 以及 $nums2[b_i ... d_i]$ 的和,从而决策出在 $nums1[a_i]$(或者说是 $nums2[b_i]$,这两个是同一个点)时,我们应当走哪一段。
当计算完所有公共点之间的得分后,对于最佳路线的首位两端,也是结合「前缀和」做同样的逻辑处理即可。
代码:
```Java
class Solution {
int MOD = (int)1e9 + 7;
public int maxSum(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
long[] s1 = new long[n + 10], s2 = new long[m + 10];
for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] + nums1[i - 1];
for (int i = 1; i <= m; i++) s2[i] = s2[i - 1] + nums2[i - 1];
List<int[]> list = new ArrayList<>();
for (int i = 0, j = 0; i < n && j < m; ) {
if (nums1[i] == nums2[j]) list.add(new int[]{i, j});
if (nums1[i] < nums2[j]) i++;
else j++;
}
long ans = 0;
for (int i = 0, p1 = -1, p2 = -1; i <= list.size(); i++) {
int idx1 = 0, idx2 = 0;
if (i < list.size()) {
int[] info = list.get(i);
idx1 = info[0]; idx2 = info[1];
} else {
idx1 = n - 1; idx2 = m - 1;
}
long t1 = s1[idx1 + 1] - s1[p1 + 1], t2 = s2[idx2 + 1] - s2[p2 + 1];
ans += Math.max(t1, t2);
p1 = idx1; p2 = idx2;
}
return (int)(ans % MOD);
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$
---
### 序列 DP
另外一个较为常见的做法是「序列 DP」做法。
定义 $f[i]$ 代表在 `nums1` 上进行移动,到达 $nums1[i]$ 的最大得分;定义 $g[j]$ 代表在 `nums2` 上进行移动,到达 $nums[j]$ 的最大得分。
由于两者的分析是类似的,我们以 $f[i]$ 为例进行分析即可。
不失一般性考虑 $f[i]$ 如何转移,假设当前处理到的是 $nums1[i]$,根据 $nums1[i]$ 是否为公共点,进行分情况讨论:
* $nums1[i]$ 不为公共点,此时只能由 $nums[i - 1]$ 转移而来,即有 $f[i] = f[i - 1] + nums[i]$;
* $nums1[i]$ 为公共点(假设与 $nums2[j]$ 公共),此时能够从 $nums1[i - 1]$ 或 $nums2[j - 1]$ 转移而来,我们需要取 $f[i - 1]$ 和 $g[j - 1]$ 的最大值,即有 $f[i] = g[j] = \max(f[i - 1], g[j - 1]) + nums1[i]$。
更重要的是,我们需要确保计算 $f[i]$ 时,$g[j - 1]$ 已被计算完成。
由于最佳路线必然满足「单调递增」,因此我们可以使用「双指针」来对 $f[i]$ 和 $g[j]$ 同时进行转移,每次取值小的进行更新,从而确保更新过程也是单调的,即当需要计算 $f[i]$ 时,比 $nums1[i]$ 小的 $f[X]$ 和 $g[X]$ 均被转移完成。
代码:
```Java
class Solution {
int MOD = (int)1e9 + 7;
public int maxSum(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
long[] f = new long[n + 1], g = new long[m + 1];
int i = 1, j = 1;
while (i <= n || j <= m) {
if (i <= n && j <= m) {
if (nums1[i - 1] < nums2[j - 1]) {
f[i] = f[i - 1] + nums1[i - 1];
i++;
} else if (nums2[j - 1] < nums1[i - 1]) {
g[j] = g[j - 1] + nums2[j - 1];
j++;
} else {
f[i] = g[j] = Math.max(f[i - 1], g[j - 1]) + nums1[i - 1];
i++; j++;
}
} else if (i <= n) {
f[i] = f[i - 1] + nums1[i - 1];
i++;
} else {
g[j] = g[j - 1] + nums2[j - 1];
j++;
}
}
return (int) (Math.max(f[n], g[m]) % MOD);
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1537` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1571-1580/1576. 替换所有的问号（简单）.md | 1576. 替换所有的问号 | https://leetcode-cn.com/problems/replace-all-s-to-avoid-consecutive-repeating-characters/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-fa1u/ | 简单 | [
"模拟"
] | 给你一个仅包含小写英文字母和 `'?'` 字符的字符串 `s`,请你将所有的 `'?'` 转换为若干小写字母,使最终的字符串不包含任何 **连续重复** 的字符。
注意:你 不能 修改非 `'?'` 字符。
题目测试用例保证 除 `'?'` 字符 之外,不存在连续重复的字符。
在完成所有转换(可能无需转换)后返回最终的字符串。如果有多个解决方案,请返回其中任何一个。可以证明,在给定的约束条件下,答案总是存在的。
示例 1:
```
输入:s = "?zs"
输出:"azs"
解释:该示例共有 25 种解决方案,从 "azs" 到 "yzs" 都是符合题目要求的。只有 "z" 是无效的修改,因为字符串 "zzs" 中有连续重复的两个 'z' 。
```
示例 2:
```
输入:s = "ubv?w"
输出:"ubvaw"
解释:该示例共有 24 种解决方案,只有替换成 "v" 和 "w" 不符合题目要求。因为 "ubvvw" 和 "ubvww" 都包含连续重复的字符。
```
示例 3:
```
输入:s = "j?qg??b"
输出:"jaqgacb"
```
示例 4:
```
输入:s = "??yw?ipkj?"
输出:"acywaipkja"
```
提示:
* $1 <= s.length <= 100$
* `s` 仅包含小写英文字母和 `'?'` 字符 | ### 模拟
根据题意进行模拟,尝试对每个 $s[i]$ 进行替换,能够替换的前提是 $s[i]$ 为 `?`,且替换字符与前后字符(若存在)不同,由于只需要确保与前后字符不同,因此必然最多在 $3$ 个字符内找到可替换的值。
代码:
```Java
class Solution {
public String modifyString(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
for (int i = 0; i < n; i++) {
for (int c = 0; c < 3 && cs[i] == '?'; c++) {
boolean ok = true;
if (i - 1 >= 0 && cs[i - 1] == c + 'a') ok = false;
if (i + 1 < n && cs[i + 1] == c + 'a') ok = false;
if (ok) cs[i] = (char)(c + 'a');
}
}
return String.valueOf(cs);
}
}
```
* 时间复杂度:会处理 `s` 中的所有字符,若当前字符为 `?` 时,会检查与前后字符的关系,最多在 $3$ 个字符内找到可替换的字符,复杂度为 $O(n * C)$,其中 $C = 3$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1576` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1581-1590/1582. 二进制矩阵中的特殊位置（简单）.md | 1582. 二进制矩阵中的特殊位置 | https://leetcode.cn/problems/special-positions-in-a-binary-matrix/solution/by-ac_oier-61w0/ | 简单 | [
"模拟"
] | 给你一个大小为 `rows x cols` 的矩阵 `mat`,其中 `mat[i][j]` 是 `0` 或 `1`,请返回 矩阵 `mat` 中特殊位置的数目 。
特殊位置 定义:如果 `mat[i][j] = 1` 并且第 `i` 行和第 `j` 列中的所有其他元素均为 `0`(行和列的下标均 从 `0` 开始 ),则位置 `(i, j)` 被称为特殊位置。
示例 1:
```
输入:mat = [[1,0,0],
[0,0,1],
[1,0,0]]
输出:1
解释:(1,2) 是一个特殊位置,因为 mat[1][2] == 1 且所处的行和列上所有其他元素都是 0
```
示例 2:
```
输入:mat = [[1,0,0],
[0,1,0],
[0,0,1]]
输出:3
解释:(0,0), (1,1) 和 (2,2) 都是特殊位置
```
示例 3:
```
输入:mat = [[0,0,0,1],
[1,0,0,0],
[0,1,1,0],
[0,0,0,0]]
输出:2
```
示例 4:
```
输入:mat = [[0,0,0,0,0],
[1,0,0,0,0],
[0,1,0,0,0],
[0,0,1,0,0],
[0,0,0,1,1]]
输出:3
```
提示:
* $rows = mat.length$
* $cols = mat[i].length$
* $1 <= rows, cols <= 100$
* $mat[i][j]$ 是 `0` 或 `1` | ### 模拟
根据题意,使用数组 `r` 和 `c` 分别预处理除每行和每列所含 $1$ 的个数,复杂度为 $O(m \times n)$。
随后分别统计特殊位置的个数:满足 $mat[i][j] = 1$ 且 $r[i] = c[j] = 1$ 的位置。
Java 代码:
```Java
class Solution {
public int numSpecial(int[][] mat) {
int n = mat.length, m = mat[0].length, ans = 0;
int[] r = new int[n], c = new int[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
r[i] += mat[i][j]; c[j] += mat[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mat[i][j] == 1 && r[i] == 1 && c[j] == 1) ans++;
}
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function numSpecial(mat: number[][]): number {
let n = mat.length, m = mat[0].length, ans = 0
const r = new Array<number>(n).fill(0), c = new Array<number>(m).fill(0)
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
r[i] += mat[i][j]; c[j] += mat[i][j]
}
}
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (mat[i][j] == 1 && r[i] == 1 && c[j] == 1) ans++
}
}
return ans
};
```
* 时间复杂度:$O(m \times n)$
* 空间复杂度:$O(m + n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1582` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1581-1590/1583. 统计不开心的朋友（中等）.md | 1583. 统计不开心的朋友 | https://leetcode-cn.com/problems/count-unhappy-friends/solution/gong-shui-san-xie-ha-xi-biao-mo-ni-ti-by-2qy0/ | 中等 | [
"哈希表",
"模拟"
] | 给你一份 `n` 位朋友的亲近程度列表,其中 `n` 总是**偶数** 。
对每位朋友 `i`,`preferences[i]` 包含一份 按亲近程度从高到低排列 的朋友列表。
换句话说,排在列表前面的朋友与 `i` 的亲近程度比排在列表后面的朋友更高。每个列表中的朋友均以 `0` 到 `n-1` 之间的整数表示。
所有的朋友被分成几对,配对情况以列表 `pairs` 给出,其中 `pairs[i] = [xi, yi]` 表示 `xi` 与 `yi` 配对,且 `yi` 与 `xi` 配对。
但是,这样的配对情况可能会是其中部分朋友感到不开心。在 `x` 与 `y` 配对且 `u` 与 `v` 配对的情况下,如果同时满足下述两个条件,`x` 就会不开心:
* `x` 与 `u` 的亲近程度胜过 `x` 与 `y`,且
* `u` 与 `x` 的亲近程度胜过 `u` 与 `v`
返回 不开心的朋友的数目 。
示例 1:
```
输入:n = 4, preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], pairs = [[0, 1], [2, 3]]
输出:2
解释:
朋友 1 不开心,因为:
- 1 与 0 配对,但 1 与 3 的亲近程度比 1 与 0 高,且
- 3 与 1 的亲近程度比 3 与 2 高。
朋友 3 不开心,因为:
- 3 与 2 配对,但 3 与 1 的亲近程度比 3 与 2 高,且
- 1 与 3 的亲近程度比 1 与 0 高。
朋友 0 和 2 都是开心的。
```
示例 2:
```
输入:n = 2, preferences = [[1], [0]], pairs = [[1, 0]]
输出:0
解释:朋友 0 和 1 都开心。
```
示例 3:
```
输入:n = 4, preferences = [[1, 3, 2], [2, 3, 0], [1, 3, 0], [0, 2, 1]], pairs = [[1, 3], [0, 2]]
输出:4
```
提示:
* 2 <= n <= 500
* n 是偶数
* preferences.length == n
* preferences[i].length == n - 1
* 0 <= preferences[i][j] <= n - 1
* preferences[i] 不包含 i
* preferences[i] 中的所有值都是独一无二的
* pairs.length == n/2
* pairs[i].length == 2
* xi != yi
* 0 <= xi, yi <= n - 1
* 每位朋友都 恰好 被包含在一对中 | ### 模拟
模拟题,先将所有的 $preferences$ 使用「哈希表套哈希表」的形式进行存储,存储格式为 `{x : {y : score1}, {z : score12}, ... }`。
如果 $x$ 和 $y$ 的亲密度要比 $x$ 和 $z$ 的亲密度要高,则有 $score1 > score2$。利用原本 $preferences[i]$ 就是按照亲密度进行排序,我们可以对下标进行转换作为亲密数得分即可。
然后对所有的 $pairs$ 进行遍历,统计所有的答案,注意一个小朋友只能被统计一次。
> 当然利用 $n$ 的数据范围,直接使用二维数组充当哈希表也是可以的(见 $P2$)
代码:
```Java
class Solution {
Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
public int unhappyFriends(int n, int[][] preferences, int[][] pairs) {
int m = pairs.length;
for (int i = 0; i < n; i++) {
int[] p = preferences[i];
Map<Integer, Integer> cur = new HashMap<>();
for (int j = 0; j < n - 1; j++) cur.put(p[j], n - j);
map.put(i, cur);
}
int ans = 0;
for (int i = 0; i < m; i++) {
int x = pairs[i][0], y = pairs[i][1];
boolean xok = false, yok = false;
for (int j = 0; j < m; j++) {
if (i == j) continue;
int u = pairs[j][0], v = pairs[j][1];
if (!xok && check(x, y, u, v)) xok = true;
if (!yok && check(y, x, u, v)) yok = true;
if (xok && yok) break;
}
if (xok) ans++;
if (yok) ans++;
}
return ans;
}
boolean check(int x, int y, int u, int v) {
Map<Integer, Integer> xmap = map.get(x), ymap = map.get(y);
Map<Integer, Integer> umap = map.get(u), vmap = map.get(v);
if (xmap.get(u) > xmap.get(y) && umap.get(x) > umap.get(v)) return true;
if (xmap.get(v) > xmap.get(y) && vmap.get(x) > vmap.get(u)) return true;
return false;
}
}
```
代码:
```Java
class Solution {
int N = 510;
int[][] map = new int[N][N];
public int unhappyFriends(int n, int[][] preferences, int[][] pairs) {
int m = pairs.length;
for (int i = 0; i < n; i++) {
int[] p = preferences[i];
for (int j = 0; j < n - 1; j++) map[i][p[j]] = n - j;
}
int ans = 0;
for (int i = 0; i < m; i++) {
int x = pairs[i][0], y = pairs[i][1];
boolean xok = false, yok = false;
for (int j = 0; j < m; j++) {
if (i == j) continue;
int u = pairs[j][0], v = pairs[j][1];
if (!xok && check(x, y, u, v)) xok = true;
if (!yok && check(y, x, u, v)) yok = true;
if (xok && yok) break;
}
if (xok) ans++;
if (yok) ans++;
}
return ans;
}
boolean check(int x, int y, int u, int v) {
if (map[x][u] > map[x][y] && map[u][x] > map[u][v]) return true;
if (map[x][v] > map[x][y] && map[v][x] > map[v][u]) return true;
return false;
}
}
```
* 时间复杂度:预处理出 `map` 的复杂度为 $O(n^2)$;遍历统计答案的复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(n^2)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1583` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1581-1590/1588. 所有奇数长度子数组的和（简单）.md | 1588. 所有奇数长度子数组的和 | https://leetcode-cn.com/problems/sum-of-all-odd-length-subarrays/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-18jq3/ | 简单 | [
"前缀和",
"数学"
] | 给你一个正整数数组 `arr` ,请你计算所有可能的奇数长度子数组的和。
子数组 定义为原数组中的一个连续子序列。
请你返回 `arr` 中 所有奇数长度子数组的和 。
示例 1:
```
输入:arr = [1,4,2,5,3]
输出:58
解释:所有奇数长度子数组和它们的和为:
[1] = 1
[4] = 4
[2] = 2
[5] = 5
[3] = 3
[1,4,2] = 7
[4,2,5] = 11
[2,5,3] = 10
[1,4,2,5,3] = 15
我们将所有值求和得到 1 + 4 + 2 + 5 + 3 + 7 + 11 + 10 + 15 = 58
```
示例 2:
```
输入:arr = [1,2]
输出:3
解释:总共只有 2 个长度为奇数的子数组,[1] 和 [2]。它们的和为 3 。
```
示例 3:
```
输入:arr = [10,11,12]
输出:66
```
提示:
* 1 <= arr.length <= 100
* 1 <= arr[i] <= 1000 | ### 前缀和
枚举所有长度为奇数的子数组,我们可以通过「枚举长度 - 枚举左端点,并计算右端点」的两层循环来做。
而对于区间 $[l, r]$ 的和问题,可以直接再加一层循环来做,这样复杂度来到了 $O(n^3)$,但本题数据范围只有 $100$,也是可以过的。
对于此类区间求和问题,我们应当想到使用「前缀和」进行优化:使用 $O(n)$ 的复杂度预处理出前缀和数组,每次查询 $[l, r]$ 区间和可以在 $O(1)$ 返回。
代码:
```Java
class Solution {
public int sumOddLengthSubarrays(int[] arr) {
int n = arr.length;
int[] sum = new int[n + 1];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + arr[i - 1];
int ans = 0;
for (int len = 1; len <= n; len += 2) {
for (int l = 0; l + len - 1 < n; l++) {
int r = l + len - 1;
ans += sum[r + 1] - sum[l];
}
}
return ans;
}
}
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$
----
### 数学
事实上,我们可以统计任意值 $arr[i]$ 在奇数子数组的出现次数。
对于原数组的任意位置 $i$ 而言,其左边共有 $i$ 个数,右边共有 $n - i - 1$ 个数。
**$arr[i]$ 作为某个奇数子数组的成员的充要条件为:其所在奇数子数组左右两边元素个数奇偶性相同。**
于是问题转换为如何求得「$arr[i]$ 在原数组中两边连续一段元素个为奇数的方案数」和「$arr[i]$ 在原数组两边连续一段元素个数为偶数的方案数」。
由于我们已经知道 $arr[i]$ 左边共有 $i$ 个数,右边共有 $n - i - 1$ 个数,因此可以算得组合数:
* 位置 $i$ 左边奇数个数的方案数为 $(i + 1) / 2$,右边奇数个数的方案数为 $(n - i) / 2$;
* 位置 $i$ 左边偶数(非零)个数的方案数为 $i / 2$,右边偶数(非零)个数的方案数为 $(n - i - 1) / 2$;
* 考虑左右两边不选也属于合法的偶数个数方案数,因此在上述分析基础上对偶数方案数自增 $1$。
至此,我们得到了位置 $i$ 左右奇数和偶数的方案数个数,根据「如果 $arr[i]$ 位于奇数子数组中,其左右两边元素个数奇偶性相同」以及「乘法原理」,我们知道 $arr[i]$ 同出现在多少个奇数子数组中,再乘上 $arr[i]$ 即是 $arr[i]$ 对答案的贡献。
代码:
```Java
class Solution {
public int sumOddLengthSubarrays(int[] arr) {
int n = arr.length;
int ans = 0;
for (int i = 0; i < n; i++) {
int l1 = (i + 1) / 2, r1 = (n - i) / 2; // 奇数
int l2 = i / 2, r2 = (n - i - 1) / 2; // 偶数
l2++; r2++;
ans += (l1 * r1 + l2 * r2) * arr[i];
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1588` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1591-1600/1592. 重新排列单词间的空格（简单）.md | 1592. 重新排列单词间的空格 | https://leetcode.cn/problems/rearrange-spaces-between-words/solution/by-ac_oier-0f5h/ | 简单 | [
"模拟",
"双指针"
] | 给你一个字符串 `text`,该字符串由若干被空格包围的单词组成。每个单词由一个或者多个小写英文字母组成,并且两个单词之间至少存在一个空格。题目测试用例保证 `text` 至少包含一个单词 。
请你重新排列空格,使每对相邻单词之间的空格数目都 相等 ,并尽可能 最大化 该数目。如果不能重新平均分配所有空格,请 将多余的空格放置在字符串末尾 ,这也意味着返回的字符串应当与原 `text` 字符串的长度相等。
返回 重新排列空格后的字符串 。
示例 1:
```
输入:text = " this is a sentence "
输出:"this is a sentence"
解释:总共有 9 个空格和 4 个单词。可以将 9 个空格平均分配到相邻单词之间,相邻单词间空格数为:9 / (4-1) = 3 个。
```
示例 2:
```
输入:text = " practice makes perfect"
输出:"practice makes perfect "
解释:总共有 7 个空格和 3 个单词。7 / (3-1) = 3 个空格加上 1 个多余的空格。多余的空格需要放在字符串的末尾。
```
示例 3:
```
输入:text = "hello world"
输出:"hello world"
```
示例 4:
```
输入:text = " walks udp package into bar a"
输出:"walks udp package into bar a "
```
示例 5:
```
输入:text = "a"
输出:"a"
```
提示:
* $1 <= text.length <= 100$
* `text` 由小写英文字母和 `' '` 组成
* `text` 中至少包含一个单词 | ### 模拟
根据题意模拟即可:使用「双指针」统计空格数量和分割出所有单词。
Java 代码:
```Java
class Solution {
public String reorderSpaces(String s) {
int n = s.length(), cnt = 0;
List<String> list = new ArrayList<>();
for (int i = 0; i < n; ) {
if (s.charAt(i) == ' ' && ++i >= 0 && ++cnt >= 0) continue;
int j = i;
while (j < n && s.charAt(j) != ' ') j++;
list.add(s.substring(i, j));
i = j;
}
StringBuilder sb = new StringBuilder();
int m = list.size(), t = cnt / Math.max(m - 1, 1);
String k = "";
while (t-- > 0) k += " ";
for (int i = 0; i < m; i++) {
sb.append(list.get(i));
if (i != m - 1) sb.append(k);
}
while (sb.length() != n) sb.append(" ");
return sb.toString();
}
}
```
TypeScript 代码:
```TypeScript
function reorderSpaces(s: string): string {
let n = s.length, cnt = 0
const list = new Array<string>()
for (let i = 0; i < n; ) {
if (s[i] == ' ' && ++i >= 0 && ++cnt >= 0) continue
let j = i + 1
while (j < n && s[j] != ' ') j++
list.push(s.substring(i, j))
i = j
}
let ans = '', k = ''
let m = list.length, t = Math.floor(cnt / Math.max(m - 1, 1))
while (t-- > 0) k += ' '
for (let i = 0; i < m; i++) {
ans += list[i]
if (i != m - 1) ans += k
}
while (ans.length != n) ans += ' '
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1592` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1591-1600/1598. 文件夹操作日志搜集器（简单）.md | 1598. 文件夹操作日志搜集器 | https://leetcode.cn/problems/crawler-log-folder/solution/by-ac_oier-24xb/ | 简单 | [
"模拟",
"计数",
"栈"
] | 每当用户执行变更文件夹操作时,LeetCode 文件系统都会保存一条日志记录。
下面给出对变更操作的说明:
* `"../"` :移动到当前文件夹的父文件夹。如果已经在主文件夹下,则 继续停留在当前文件夹 。
* `"./"` :继续停留在当前文件夹。
* `"x/"` :移动到名为 `x` 的子文件夹中。题目数据 保证总是存在文件夹 x 。
给你一个字符串列表 `logs` ,其中 `logs[i]` 是用户在 `ith` 步执行的操作。
文件系统启动时位于主文件夹,然后执行 `logs` 中的操作。
执行完所有变更文件夹操作后,请你找出 返回主文件夹所需的最小步数 。
示例 1:
```
输入:logs = ["d1/","d2/","../","d21/","./"]
输出:2
解释:执行 "../" 操作变更文件夹 2 次,即可回到主文件夹
```
示例 2:
```
输入:logs = ["d1/","d2/","./","d3/","../","d31/"]
输出:3
```
示例 3:
```
输入:logs = ["d1/","../","../","../"]
输出:0
```
提示:
* $1 <= logs.length <= 10^3$
* $2 <= logs[i].length <= 10$
* `logs[i]` 包含小写英文字母,数字,`'.'` 和 `'/'`
* `logs[i]` 符合语句中描述的格式
* 文件夹名称由小写英文字母和数字组成 | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public int minOperations(String[] logs) {
int depth = 0;
for (String s : logs) {
if (s.equals("../")) depth = Math.max(0, depth - 1);
else if (!s.equals("./")) depth++;
}
return depth;
}
}
```
TypeScript 代码:
```TypeScript
function minOperations(logs: string[]): number {
let depth = 0
for (const s of logs) {
if (s == "../") depth = Math.max(0, depth - 1)
else if (s != "./") depth++
}
return depth
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1598` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1591-1600/1600. 皇位继承顺序（中等）.md | 1600. 皇位继承顺序 | https://leetcode-cn.com/problems/throne-inheritance/solution/gong-shui-san-xie-shi-yong-dan-xiang-lia-7t65/ | 中等 | [
"单链表",
"哈希表"
] | 一个王国里住着国王、他的孩子们、他的孙子们等等。每一个时间点,这个家庭里有人出生也有人死亡。
这个王国有一个明确规定的皇位继承顺序,第一继承人总是国王自己。我们定义递归函数 Successor(x, curOrder) ,给定一个人 x 和当前的继承顺序,该函数返回 x 的下一继承人。
```
Successor(x, curOrder):
如果 x 没有孩子或者所有 x 的孩子都在 curOrder 中:
如果 x 是国王,那么返回 null
否则,返回 Successor(x 的父亲, curOrder)
否则,返回 x 不在 curOrder 中最年长的孩子
```
比方说,假设王国由国王,他的孩子 Alice 和 Bob (Alice 比 Bob 年长)和 Alice 的孩子 Jack 组成。
1. 一开始, curOrder 为 ["king"].
2. 调用 Successor(king, curOrder) ,返回 Alice ,所以我们将 Alice 放入 curOrder 中,得到 ["king", "Alice"] 。
3. 调用 Successor(Alice, curOrder) ,返回 Jack ,所以我们将 Jack 放入 curOrder 中,得到 ["king", "Alice", "Jack"] 。
4. 调用 Successor(Jack, curOrder) ,返回 Bob ,所以我们将 Bob 放入 curOrder 中,得到 ["king", "Alice", "Jack", "Bob"] 。
5. 调用 Successor(Bob, curOrder) ,返回 null 。最终得到继承顺序为 ["king", "Alice", "Jack", "Bob"] 。
通过以上的函数,我们总是能得到一个唯一的继承顺序。
请你实现 ThroneInheritance 类:
* ThroneInheritance(string kingName) 初始化一个 ThroneInheritance 类的对象。国王的名字作为构造函数的参数传入。
* void birth(string parentName, string childName) 表示 parentName 新拥有了一个名为 childName 的孩子。
* void death(string name) 表示名为 name 的人死亡。一个人的死亡不会影响 Successor 函数,也不会影响当前的继承顺序。你可以只将这个人标记为死亡状态。
* string[] getInheritanceOrder() 返回 除去 死亡人员的当前继承顺序列表。
示例:
```
输入:
["ThroneInheritance", "birth", "birth", "birth", "birth", "birth", "birth", "getInheritanceOrder", "death", "getInheritanceOrder"]
[["king"], ["king", "andy"], ["king", "bob"], ["king", "catherine"], ["andy", "matthew"], ["bob", "alex"], ["bob", "asha"], [null], ["bob"], [null]]
输出:
[null, null, null, null, null, null, null, ["king", "andy", "matthew", "bob", "alex", "asha", "catherine"], null, ["king", "andy", "matthew", "alex", "asha", "catherine"]]
解释:
ThroneInheritance t= new ThroneInheritance("king"); // 继承顺序:king
t.birth("king", "andy"); // 继承顺序:king > andy
t.birth("king", "bob"); // 继承顺序:king > andy > bob
t.birth("king", "catherine"); // 继承顺序:king > andy > bob > catherine
t.birth("andy", "matthew"); // 继承顺序:king > andy > matthew > bob > catherine
t.birth("bob", "alex"); // 继承顺序:king > andy > matthew > bob > alex > catherine
t.birth("bob", "asha"); // 继承顺序:king > andy > matthew > bob > alex > asha > catherine
t.getInheritanceOrder(); // 返回 ["king", "andy", "matthew", "bob", "alex", "asha", "catherine"]
t.death("bob"); // 继承顺序:king > andy > matthew > bob(已经去世)> alex > asha > catherine
t.getInheritanceOrder(); // 返回 ["king", "andy", "matthew", "alex", "asha", "catherine"]
```
提示:
* 1 <= kingName.length, parentName.length, childName.length, name.length <= 15
* kingName,parentName, childName 和 name 仅包含小写英文字母。
* 所有的参数 childName 和 kingName 互不相同。
* 所有 death 函数中的死亡名字 name 要么是国王,要么是已经出生了的人员名字。
* 每次调用 birth(parentName, childName) 时,测试用例都保证 parentName 对应的人员是活着的。
* 最多调用 $10^5$ 次birth 和 death 。
* 最多调用 10 次 getInheritanceOrder 。 | ### 单向链表 & 标记删除
根据题意,我们需要将「新儿子」插入到「父亲」的「最后一个儿子」的「儿子们」的后面(**注意这是个递归过程**);如果该「父亲」还没有任何儿子,则直接插到「父亲」后面。
因此,我们需要在节点 `Node` 中使用一个 `last` 记录该节点的「最后一个儿子」,同时因为删除的时候,我们无法在 $O(1)$ 的复杂度内更新 `last` 信息,所以只能使用「标记删除」的方式。
代码:
```Java
class ThroneInheritance {
class Node {
String name;
Node next;
Node last; // 记录最后一个儿子
boolean isDeleted = false;
Node (String _name) {
name = _name;
}
}
Map<String, Node> map = new HashMap<>();
Node head = new Node(""), tail = new Node("");
public ThroneInheritance(String name) {
Node root = new Node(name);
root.next = tail;
head.next = root;
map.put(name, root);
}
public void birth(String pname, String cname) {
Node node = new Node(cname);
map.put(cname, node);
Node p = map.get(pname);
Node tmp = p;
while (tmp.last != null) tmp = tmp.last;
node.next = tmp.next;
tmp.next = node;
p.last = node;
}
public void death(String name) {
Node node = map.get(name);
node.isDeleted = true;
}
public List<String> getInheritanceOrder() {
List<String> ans = new ArrayList<>();
Node tmp = head.next;
while (tmp.next != null) {
if (!tmp.isDeleted) ans.add(tmp.name);
tmp = tmp.next;
}
return ans;
}
}
```
* 时间复杂度:`birth` 和 `getInheritanceOrder` 操作为 $O(n)$;其余操作为 $O(1)$
* 时间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1600` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1601. 最多可达成的换楼请求数目（困难）.md | 1601. 最多可达成的换楼请求数目 | https://leetcode-cn.com/problems/maximum-number-of-achievable-transfer-requests/solution/gong-shui-san-xie-er-jin-zhi-mei-ju-by-a-enef/ | 困难 | [
"二进制枚举"
] | 我们有 `n` 栋楼,编号从 `0` 到 `n - 1` 。每栋楼有若干员工。由于现在是换楼的季节,部分员工想要换一栋楼居住。
给你一个数组 $requests$ ,其中 $requests[i] = [from_i, to_i]$ ,表示一个员工请求从编号为 $from_i$ 的楼搬到编号为 $to_i$ 的楼。
一开始 所有楼都是满的,所以从请求列表中选出的若干个请求是可行的需要满足 每栋楼员工净变化为 $0$ 。意思是每栋楼 离开 的员工数目 等于 该楼 搬入 的员工数数目。比方说 $n = 3$ 且两个员工要离开楼 $0$ ,一个员工要离开楼 $1$ ,一个员工要离开楼 $2$ ,如果该请求列表可行,应该要有两个员工搬入楼 $0$ ,一个员工搬入楼 $1$ ,一个员工搬入楼 $2$ 。
请你从原请求列表中选出若干个请求,使得它们是一个可行的请求列表,并返回所有可行列表中最大请求数目。
示例 1:
```
输入:n = 5, requests = [[0,1],[1,0],[0,1],[1,2],[2,0],[3,4]]
输出:5
解释:请求列表如下:
从楼 0 离开的员工为 x 和 y ,且他们都想要搬到楼 1 。
从楼 1 离开的员工为 a 和 b ,且他们分别想要搬到楼 2 和 0 。
从楼 2 离开的员工为 z ,且他想要搬到楼 0 。
从楼 3 离开的员工为 c ,且他想要搬到楼 4 。
没有员工从楼 4 离开。
我们可以让 x 和 b 交换他们的楼,以满足他们的请求。
我们可以让 y,a 和 z 三人在三栋楼间交换位置,满足他们的要求。
所以最多可以满足 5 个请求。
```
示例 2:
```
输入:n = 3, requests = [[0,0],[1,2],[2,1]]
输出:3
解释:请求列表如下:
从楼 0 离开的员工为 x ,且他想要回到原来的楼 0 。
从楼 1 离开的员工为 y ,且他想要搬到楼 2 。
从楼 2 离开的员工为 z ,且他想要搬到楼 1 。
我们可以满足所有的请求。
```
示例 3:
```
输入:n = 4, requests = [[0,3],[3,1],[1,2],[2,0]]
输出:4
```
提示:
* $1 <= n <= 20$
* $1 <= requests.length <= 16$
* $requests[i].length == 2$
* $0 <= fromi, toi < n$ | ### 二进制枚举
为了方便,我们令 $requests$ 的长度为 $m$。
数据范围很小,$n$ 的范围为 $20$,而 $m$ 的范围为 $16$。
根据每个 $requests[i]$ 是否选择与否,共有 $2^m$ 种状态(不超过 $70000$ 种状态)。我们可以采用「二进制枚举」的思路来求解,使用二进制数 $state$ 来表示对 $requests[i]$ 的选择情况,当 $state$ 的第 $k$ 位为 $1$,代表 $requests[k]$ 被选择。
我们枚举所有的 $state$ 并进行合法性检查,从中选择出包含请求数的最多(二进制表示中包含 $1$ 个数最多)的合法 $state$,其包含的请求数量即是答案。
其中统计 $state$ 中 $1$ 的个数可以使用 `lowbit`,复杂度为 $O(m)$,判断合法性则直接模拟即可(统计每座建筑的进出数量,最后判定进出数不相等的建筑数量是为 $0$),复杂度为 $O(m)$,整体计算量为不超过 $2 \times 10^6$,可以过。
代码:
```Java
class Solution {
int[][] rs;
public int maximumRequests(int n, int[][] requests) {
rs = requests;
int m = rs.length, ans = 0;
for (int i = 0; i < (1 << m); i++) {
int cnt = getCnt(i);
if (cnt <= ans) continue;
if (check(i)) ans = cnt;
}
return ans;
}
boolean check(int s) {
int[] cnt = new int[20];
int sum = 0;
for (int i = 0; i < 16; i++) {
if (((s >> i) & 1) == 1) {
int a = rs[i][0], b = rs[i][1];
if (++cnt[a] == 1) sum++;
if (--cnt[b] == 0) sum--;
}
}
return sum == 0;
}
int getCnt(int s) {
int ans = 0;
for (int i = s; i > 0; i -= (i & -i)) ans++;
return ans;
}
}
```
* 时间复杂度:令 $m$ 为 $requests$ 长度,共有 $2^m$ 种选择状态,计算每个状态的所包含的问题数量复杂度为 $O(m)$,计算某个状态是否合法复杂度为 $O(m)$;整体复杂度为 $O(2^m \times m)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1601` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1603. 设计停车系统（简单）.md | 1603. 设计停车系统 | https://leetcode-cn.com/problems/design-parking-system/solution/yi-ti-san-jie-jian-dan-bian-liang-ha-xi-0gs72/ | 简单 | [
"位运算",
"哈希表"
] | 请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位:大,中和小,每种尺寸分别有固定数目的车位。
请你实现 ParkingSystem 类:
* ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 类,三个参数分别对应每种停车位的数目。
* bool addCar(int carType) 检查是否有 carType 对应的停车位。 carType 有三种类型:大,中,小,分别用数字 1, 2 和 3 表示。一辆车只能停在 carType 对应尺寸的停车位中。如果没有空车位,请返回 false ,否则将该车停入车位并返回 true 。
示例 1:
```
输入:
["ParkingSystem", "addCar", "addCar", "addCar", "addCar"]
[[1, 1, 0], [1], [2], [3], [1]]
输出:
[null, true, true, false, false]
解释:
ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);
parkingSystem.addCar(1); // 返回 true ,因为有 1 个空的大车位
parkingSystem.addCar(2); // 返回 true ,因为有 1 个空的中车位
parkingSystem.addCar(3); // 返回 false ,因为没有空的小车位
parkingSystem.addCar(1); // 返回 false ,因为没有空的大车位,唯一一个大车位已经被占据了
```
提示:
* 0 <= big, medium, small <= 1000
* carType 取值为 1, 2 或 3
* 最多会调用 addCar 函数 1000 次 | ### 简单变量
一个简单的做法是,直接使用几个成员变量来记录。
```Java
class ParkingSystem {
int big, medium, small;
public ParkingSystem(int _big, int _medium, int _small) {
big = _big;
medium = _medium;
small = _small;
}
public boolean addCar(int ct) {
if (ct == 1 && big > 0) return big-- > 0;
else if (ct == 2 && medium > 0) return medium-- > 0;
else if (ct == 3 && small > 0) return small-- > 0;
return false;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
***
### 哈希表
另外一个更好拓展的方法,使用哈希表来进行记录。
这样做的好处是,当增加车类型,只需要重载一个构造方法即可。
```Java
class ParkingSystem {
Map<Integer, Integer> map = new HashMap<>();
public ParkingSystem(int _big, int _medium, int _small) {
map.put(1, _big);
map.put(2, _medium);
map.put(3, _small);
}
public boolean addCar(int ct) {
if (map.get(ct) > 0) {
map.put(ct, map.get(ct) - 1);
return true;
}
return false;
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$
***
### 二进制分段
事实上,由于 $1000$ 的二进制表示只有 $10$ 位,而 $int$ 有 $32$ 位。
我们可以使用一个 $int$ 配合「位运算」来分段做。
使用 $[0,10)$ 代表 big,$[10,20)$ 表示 medium,$[20,30)$ 表示 small
*PS. 这样 $int$ 分段的做法,在工程源码上也有体现:`JDK` 中的 `ThreadPoolExecutor` 使用了一个 $ctl$ 变量 ($int$ 类型) 的前 $3$ 位记录线程池的状态,后 $29$ 位记录程池中线程个数。*
**这样的「二进制分段压缩存储」的主要目的,不是为了减少使用一个 $int$,而是为了让「非原子性操作」变为「原子性操作」。**
我们可以分析下为什么 `ThreadPoolExecutor` 要这么做。
当线程数量变化为某个特定值时,要修改的就不仅仅是「线程数量」,还需要修改「线程池的状态」。
由于并发环境下,如果要做到「原子性」地同时需要修改两个 $int$ 的话。只能上「重量级锁」,「重量级锁」就会涉及到「内核态」的系统调用,通常是耗时是「用户态」的上百倍。
但是如果我们将「线程数量」和「线程池的状态」合二为一之后,我们只需要修改一个 $int$,这时候只需要使用 CAS 做法(用户态)即可保证线程安全与原子性。
那么对应到该题,如果我们允许同时停入不同类型的车,在不引入重量级锁的前提下,想要真正做到「同时」修改两种类型的车的车位的话,只能采用这样的「二进制分段」做法 ~
```Java
class ParkingSystem {
int cnt; // [small medium big]
public ParkingSystem(int _big, int _medium, int _small) {
for (int i = 0; i < 30; i++) {
int cur = 0;
if (i < 10) {
cur = (_big >> i) & 1;
} else if (i < 20) {
cur = (_medium >> (i - 10)) & 1;
} else if (i < 30) {
cur = (_small >> (i - 20)) & 1;
}
cnt += cur == 1 ? (1 << i) : 0;
}
}
public boolean addCar(int ct) {
int cur = countOfType(ct);
if (cur > 0) {
setCount(ct, cur - 1);
return true;
}
return false;
}
int countOfType(int ct) {
int ans = 0;
int start = --ct * 10, end = start + 10;
for (int i = start; i < end; i++) {
if (((cnt >> i) & 1) == 1) {
ans += (1 << (i - start));
}
}
return ans;
}
void setCount(int ct, int pc) {
int start = --ct * 10, end = start + 10;
for (int i = start; i < end; i++) {
if (((pc >> (i - start)) & 1) == 1) {
cnt |= (1 << i);
} else {
cnt &= ~(1 << i);
}
}
}
}
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1603` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1606. 找到处理最多请求的服务器（困难）.md | 1606. 找到处理最多请求的服务器 | https://leetcode-cn.com/problems/find-servers-that-handled-most-number-of-requests/solution/by-ac_oier-zgm6/ | 困难 | [
"数据结构",
"优先队列(堆)",
"红黑树",
"二分"
] | 你有 $k$ 个服务器,编号为 $0$ 到 $k-1$ ,它们可以同时处理多个请求组。
每个服务器有无穷的计算能力但是不能同时处理超过一个请求。
请求分配到服务器的规则如下:
* 第 $i$(序号从 $0$ 开始)个请求到达。
* 如果所有服务器都已被占据,那么该请求被舍弃(完全不处理)。
* 如果第 ( `i % k` ) 个服务器空闲,那么对应服务器会处理该请求。
* 否则,将请求安排给下一个空闲的服务器(服务器构成一个环,必要的话可能从第 $0$ 个服务器开始继续找下一个空闲的服务器)。比方说,如果第 $i$ 个服务器在忙,那么会查看第 ( $i+1$ ) 个服务器,第 ( $i+2$ ) 个服务器等等。
* 给你一个严格递增的正整数数组 `arrival`,表示第 $i$ 个任务的到达时间,和另一个数组 `load` ,其中 $load[i]$ 表示第 $i$ 个请求的工作量(也就是服务器完成它所需要的时间)。你的任务是找到 最繁忙的服务器 。最繁忙定义为一个服务器处理的请求数是所有服务器里最多的。
请你返回包含所有最繁忙服务器序号的列表,你可以以任意顺序返回这个列表。
示例 1:
```
输入:k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3]
输出:[1]
解释:
所有服务器一开始都是空闲的。
前 3 个请求分别由前 3 台服务器依次处理。
请求 3 进来的时候,服务器 0 被占据,所以它呗安排到下一台空闲的服务器,也就是服务器 1 。
请求 4 进来的时候,由于所有服务器都被占据,该请求被舍弃。
服务器 0 和 2 分别都处理了一个请求,服务器 1 处理了两个请求。所以服务器 1 是最忙的服务器。
```
示例 2:
```
输入:k = 3, arrival = [1,2,3,4], load = [1,2,1,2]
输出:[0]
解释:
前 3 个请求分别被前 3 个服务器处理。
请求 3 进来,由于服务器 0 空闲,它被服务器 0 处理。
服务器 0 处理了两个请求,服务器 1 和 2 分别处理了一个请求。所以服务器 0 是最忙的服务器。
```
示例 3:
```
输入:k = 3, arrival = [1,2,3], load = [10,12,11]
输出:[0,1,2]
解释:每个服务器分别处理了一个请求,所以它们都是最忙的服务器。
```
示例 4:
```
输入:k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]
输出:[1]
```
示例 5:
```
输入:k = 1, arrival = [1], load = [1]
输出:[0]
```
提示:
* $1 <= k <= 10^5$
* $1 <= arrival.length, load.length <= 10^5$
* $arrival.length == load.length$
* $1 <= arrival[i], load[i] <= 10^9$
* `arrival` 保证严格递增。 | ### 数据结构
题目要统计处理任务数最多的机器,首先容易想到使用「哈希表」统计每个机台处理的任务数,利用机台数量 $k$ 最多不超过 $10^5$,我们可以开一个静态数组 `cnts` 来充当哈希表,同时维护一个当前处理的最大任务数量 `max`,最终所有满足 $cnst[i] = \max$ 的机台集合即是答案。
再根据「每个任务有对应的开始时间和持续时间」以及「任务分配规则」,容易想到使用优先队列(堆)和有序集合(红黑树)来进行维护。
具体的,利用「每个任务有对应的开始时间和持续时间」,我们使用优先队列(堆)维护二元组 $(idx, endTime)$,其中 $idx$ 为机器编号,$endTime$ 为当前机台所处理任务的结束时间(也就是该机台最早能够接受新任务的时刻),对于每个 $arrival[i]$ 而言(新任务),我们先从优先队列中取出所有 $endTime \leqslant arrival[i]$ 的机台 $idx$,加入「空闲池」,然后再按照「任务分配规则」从空闲池子中取机台,若取不到,则丢弃该任务。
由于「任务分配规则」是优先取大于等于 `i % k` 的最小值,若取不到,再取大于等于 $0$ 的最小值。因此我们的「空闲池」最好是支持「二分」的有序集合,容易想到基于「红黑树」的 `TreeSet` 结构。
Java 代码:
```Java
class Solution {
static int N = 100010;
static int[] cnts = new int[N];
public List<Integer> busiestServers(int k, int[] arrival, int[] load) {
Arrays.fill(cnts, 0);
int n = arrival.length, max = 0;
PriorityQueue<int[]> busy = new PriorityQueue<>((a,b)->a[1]-b[1]);
TreeSet<Integer> free = new TreeSet<>();
for (int i = 0; i < k; i++) free.add(i);
for (int i = 0; i < n; i++) {
int start = arrival[i], end = start + load[i];
while (!busy.isEmpty() && busy.peek()[1] <= start) free.add(busy.poll()[0]);
Integer u = free.ceiling(i % k);
if (u == null) u = free.ceiling(0);
if (u == null) continue;
free.remove(u);
busy.add(new int[]{u, end});
max = Math.max(max, ++cnts[u]);
}
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < k; i++) {
if (cnts[i] == max) ans.add(i);
}
return ans;
}
}
```
Python 代码:
```Python
from sortedcontainers import SortedList
class Solution:
def busiestServers(self, k: int, arrival: List[int], load: List[int]) -> List[int]:
cnts = [0] * k
n, m = len(arrival), 0
busy, free = [], SortedList(range(k))
for i in range(n):
start, end = arrival[i], arrival[i] + load[i]
while busy and busy[0][0] <= start:
free.add(busy[0][1])
heappop(busy)
if (idx := free.bisect_left(i % k)) == len(free) == (idx := free.bisect_left(0)):
continue
u = free[idx]
free.remove(u)
heappush(busy, (end, u))
cnts[u] += 1
m = max(m, cnts[u])
return [i for i in range(k) if cnts[i] == m]
```
* 时间复杂度:令任务数量为 $n$,机台数量为 $k$,起始将所有机台存入 `TreeSet`,复杂度为 $O(k\log{k})$;每次处理新的 $arrival[i]$ 时,先从优先队列取出可接受新任务的机台,存入 `TreeSet`,然后从 `TreeSet` 中取出最多一个的机台来完成任务,其中从 `TreeSet` 中取出机台最多调用两次的 `ceiling` 操作,复杂度为 $O(\log{k})$,这部分的整体复杂度为 $O(n\log{k})$;统计处理任务数达到 `max` 的机台集合复杂度为 $O(k)$;整体复杂度为 $O((k + n)\log{k})$
* 空间复杂度:$O(k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1606` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1608. 特殊数组的特征值（简单）.md | 1608. 特殊数组的特征值 | https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x/solution/by-ac_oier-z525/ | 简单 | [
"排序",
"二分",
"枚举",
"模拟",
"计数"
] | 给你一个非负整数数组 `nums`。如果存在一个数 `x` ,使得 `nums` 中恰好有 `x` 个元素 大于或者等于 `x` ,那么就称 `nums` 是一个 特殊数组 ,而 `x` 是该数组的 特征值 。
注意: `x` 不必 是 `nums` 的中的元素。
如果数组 `nums` 是一个 特殊数组 ,请返回它的特征值 `x` 。否则,返回 `-1` 。可以证明的是,如果 `nums` 是特殊数组,那么其特征值 `x` 是 唯一的 。
示例 1:
```
输入:nums = [3,5]
输出:2
解释:有 2 个元素(3 和 5)大于或等于 2 。
```
示例 2:
```
输入:nums = [0,0]
输出:-1
解释:没有满足题目要求的特殊数组,故而也不存在特征值 x 。
如果 x = 0,应该有 0 个元素 >= x,但实际有 2 个。
如果 x = 1,应该有 1 个元素 >= x,但实际有 0 个。
如果 x = 2,应该有 2 个元素 >= x,但实际有 0 个。
x 不能取更大的值,因为 nums 中只有两个元素。
```
示例 3:
```
输入:nums = [0,4,3,0,4]
输出:3
解释:有 3 个元素大于或等于 3 。
```
示例 4:
```
输入:nums = [3,6,7,7,0]
输出:-1
```
提示:
* $1 <= nums.length <= 100$
* $0 <= nums[i] <= 1000$ | ### 排序 + 枚举 + 二分
根据题意并结合 $nums[i]$ 的数据范围为 $1e3$,我们可以通过「枚举」的方式找到 `x`,而对于每个 `x` 的合法性检查,我们需要快速知道 `nums` 中比 `x` 大的数的个数,这可以通过「排序 + 二分」来做。
Java 代码:
```Java
class Solution {
public int specialArray(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
for (int x = 0; x < 1010; x++) {
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= x) r = mid;
else l = mid + 1;
}
if (nums[r] >= x && x == n - r) return x;
}
return -1;
}
}
```
TypeScript 代码:
```TypeScript
function specialArray(nums: number[]): number {
const n = nums.length
nums.sort((a,b)=>a-b)
for (let x = 0; x < 1010; x++) {
let l = 0, r = n - 1
while (l < r) {
const mid = l + r >> 1
if (nums[mid] >= x) r = mid
else l = mid + 1
}
if (nums[r] >= x && x == n - r) return x
}
return -1
};
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$;枚举找 `x` 的复杂度为 $O(C\log{n})$,其中 $C = 1e3$ 为 $nums[i]$ 的值域大小
* 空间复杂度:$O(\log{n})$
---
### 排序 + 二分
若不利用 $nums[i]$ 的值域偏小(即值域放大到 $1e9$),我们可以通过「排序 + 两次二分」的操作来做:第一次二分找分割点 `x`(二分范围为 $[0, 1e9]$);第二次则是在 `getCnt` 函数内部中使用二分来对 `x` 进行合法性检查。
我们知道若真实的特殊值为 `x`,那么在以 `x` 为分割点的数轴上具有「二段性」,假设当前值为 `k`:
* 小于真实特殊值 `x` 的 `k` 值满足「`nums` 中大于等于 `k` 的元素个数超过 `k` 个」
* 大于等于真实特殊值 `x` 的 `k` 值满足「`nums` 中大于等于 `k` 的元素个数不超过 `k` 个」
因此可以通过「二分」来找真实特殊值为 `x`,至于 `x` 的合法检查则和解法一相同,先通过排序确保数组有序,再通过二分的方式来统计大于等于 `x` 的数的个数。
Java 代码:
```Java
class Solution {
int[] nums;
public int specialArray(int[] _nums) {
nums = _nums;
Arrays.sort(nums);
int l = 0, r = (int) 1e9;
while (l < r) {
int mid = l + r >> 1;
if (getCnt(mid) <= mid) r = mid;
else l = mid + 1;
}
return getCnt(r) == r ? r : -1;
}
int getCnt(int x) {
int n = nums.length, l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= x) r = mid;
else l = mid + 1;
}
return nums[r] >= x ? n - r : 0;
}
}
```
TypeScript 代码:
```TypeScript
let nums: number[]
function specialArray(_nums: number[]): number {
nums = _nums
nums.sort((a,b)=>a-b)
let l = 0, r = 1e9
while (l < r) {
const mid = l + r >> 1
if (getCnt(mid) <= mid) r = mid
else l = mid + 1
}
return getCnt(r) == r ? r : -1
};
function getCnt(x: number): number {
let n = nums.length, l = 0, r = n - 1
while (l < r) {
const mid = l + r >> 1
if (nums[mid] >= x) r = mid
else l = mid + 1
}
return nums[r] >= x ? n - r : 0
}
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,二分找答案复杂度为 $O(\log{C} \times \log{n})$
* 空间复杂度:$O(\log{n})$
---
### 模拟(计数 + 枚举)
另外一种除非过大缩放 $nums$ 的长度 $n$,否则仅有代码量优势的做法是使用「计数 + 枚举」的模拟做法。
先使用静态数组对 $nums$ 进行词频统计,随后通过逆序枚举的方式找特殊值 `x`,同时使用 `tot` 统计遍历过的桶的总元素个数,当满足 `tot = x` 时,返回结果。
Java 代码:
```Java
class Solution {
public int specialArray(int[] nums) {
int[] cnts = new int[1010];
for (int x : nums) cnts[x]++;
for (int i = 1009, tot = 0; i >= 0; i--) {
tot += cnts[i];
if (i == tot) return i;
}
return -1;
}
}
```
TypeScript 代码:
```TypeScript
function specialArray(nums: number[]): number {
const cnts = new Array<number>(1010).fill(0)
for (let x of nums) cnts[x]++
for (let i = 1009, tot = 0; i >= 0; i--) {
tot += cnts[i]
if (tot == i) return i
}
return -1
};
```
* 时间复杂度:$O(n + C)$,其中 $C = 1e3$ 为 $nums[i]$ 的值域大小
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1608` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1609. 奇偶树（中等）.md | 1609. 奇偶树 | https://leetcode-cn.com/problems/even-odd-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-d-kuyi/ | 中等 | [
"层序遍历",
"BFS",
"DFS"
] | 如果一棵二叉树满足下述几个条件,则可以称为 **奇偶树** :
二叉树根节点所在层下标为 $0$ ,根的子节点所在层下标为 $1$ ,根的孙节点所在层下标为 $2$ ,依此类推。
* **偶数下标** 层上的所有节点的值都是 **奇** 整数,从左到右按顺序 **严格递增**
* **奇数下标** 层上的所有节点的值都是 **偶** 整数,从左到右按顺序 **严格递减**
给你二叉树的根节点,如果二叉树为 奇偶树 ,则返回 `true` ,否则返回 `false` 。
示例 1:
```
输入:root = [1,10,4,3,null,7,9,12,8,6,null,null,2]
输出:true
解释:每一层的节点值分别是:
0 层:[1]
1 层:[10,4]
2 层:[3,7,9]
3 层:[12,8,6,2]
由于 0 层和 2 层上的节点值都是奇数且严格递增,而 1 层和 3 层上的节点值都是偶数且严格递减,因此这是一棵奇偶树。
```
示例 2:
```
输入:root = [5,4,2,3,3,7]
输出:false
解释:每一层的节点值分别是:
0 层:[5]
1 层:[4,2]
2 层:[3,3,7]
2 层上的节点值不满足严格递增的条件,所以这不是一棵奇偶树。
```
示例 3:
```
输入:root = [5,9,1,3,5,7]
输出:false
解释:1 层上的节点值应为偶数。
```
示例 4:
```
输入:root = [1]
输出:true
```
示例 5:
```
输入:root = [11,8,6,1,3,9,11,30,20,18,16,12,10,4,2,17]
输出:true
```
提示:
* 树中节点数在范围 $[1, 10^5]$ 内
* $1 <= Node.val <= 10^6$ | ### BFS
考察「层序遍历」,在遍历过程中需要记录层下标,并根据层下标检查进行「节点值的奇偶性」和「是否满足递增/递减」。
额外使用一个布尔变量 `flag` 记录层序是否为偶数(判断节点值的奇偶性),使用 `prev` 记录当前层的上一节点的值(判断是否满足递增/递减)即可,`prev` 起始值可根据数据范围设置为哨兵值。
代码:
```Java
class Solution {
public boolean isEvenOddTree(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
boolean flag = true;
d.addLast(root);
while (!d.isEmpty()) {
int size = d.size(), prev = flag ? 0 : 0x3f3f3f3f;
while (size-- > 0) {
TreeNode node = d.pollFirst();
int cur = node.val;
if (flag && (cur % 2 == 0 || cur <= prev)) return false;
if (!flag && (cur % 2 != 0 || cur >= prev)) return false;
prev = cur;
if (node.left != null) d.addLast(node.left);
if (node.right != null) d.addLast(node.right);
}
flag = !flag;
}
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### DFS
同样的思路,自然也能够使用 `DFS` 进行求解。
由于 `DFS` 是深度优先,因此我们在 `DFS` 过程中除了要记录当前层编号(判断节点值的奇偶性),还要记录每层最后上一次遍历到的节点值为多少(判断是否满足递增/递减)。
代码:
```Java
class Solution {
Map<Integer, Integer> map = new HashMap<>();
public boolean isEvenOddTree(TreeNode root) {
return dfs(root, 0);
}
boolean dfs(TreeNode root, int idx) {
boolean flag = idx % 2 == 0;
int prev = map.getOrDefault(idx, flag ? 0 : 0x3f3f3f3f), cur = root.val;
if (flag && (cur % 2 == 0 || cur <= prev)) return false;
if (!flag && (cur % 2 != 0 || cur >= prev)) return false;
map.put(idx, root.val);
if (root.left != null && !dfs(root.left, idx + 1)) return false;
if (root.right != null && !dfs(root.right, idx + 1)) return false;
return true;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1609` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1601-1610/1610. 可见点的最大数目（困难）.md | 1610. 可见点的最大数目 | https://leetcode-cn.com/problems/maximum-number-of-visible-points/solution/gong-shui-san-xie-qiu-ji-jiao-ji-he-ti-b-0bid/ | 困难 | [
"数学",
"几何",
"排序",
"双指针",
"滑动窗口"
] | 给你一个点数组 `points` 和一个表示角度的整数 `angle` ,你的位置是 `location`,其中 $location = [pos_x, pos_y]$ 且 $points[i] = [x_i, y_i]$ 都表示 `X-Y` 平面上的整数坐标。
最开始,你面向东方进行观测。你 不能 进行移动改变位置,但可以通过 自转 调整观测角度。换句话说,$pos_x$ 和 $pos_y$ 不能改变。你的视野范围的角度用 `angle` 表示, 这决定了你观测任意方向时可以多宽。设 d 为你逆时针自转旋转的度数,那么你的视野就是角度范围 $[d - angle/2, d + angle/2]$ 所指示的那片区域。
对于每个点,如果由该点、你的位置以及从你的位置直接向东的方向形成的角度 位于你的视野中 ,那么你就可以看到它。
同一个坐标上可以有多个点。你所在的位置也可能存在一些点,但不管你的怎么旋转,总是可以看到这些点。同时,点不会阻碍你看到其他点。
返回你能看到的点的最大数目。
示例 1:
```
输入:points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]
输出:3
解释:阴影区域代表你的视野。在你的视野中,所有的点都清晰可见,尽管 [2,2] 和 [3,3]在同一条直线上,你仍然可以看到 [3,3] 。
```
示例 2:
```
输入:points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1]
输出:4
解释:在你的视野中,所有的点都清晰可见,包括你所在位置的那个点。
```
示例 3:
```
输入:points = [[1,0],[2,1]], angle = 13, location = [1,1]
输出:1
解释:如图所示,你只能看到两点之一。
```
提示:
* $1 <= points.length <= 10^5$
* $points[i].length == 2$
* $location.length == 2$
* $0 <= angle < 360$
* $0 <= posx, posy, xi, yi <= 100$ | ### 数学
这是一道思维难度不大,但细节繁多的题目。
题目要我们旋转出一个角度为 $angle$ 的、可无限延伸的覆盖面,使得该覆盖面所能覆盖 $points$ 中的点最多。
我们所在的位置为 $location = (x,y)$,我们可以将 $(x,y)$ 作为「极点」,求所有 $points[i]$ 的「极角」。
令 $points[i] =(a,b)$,与极点关系 $dx = a - x;dy = b - y$。
求极角的方式有两种:
1. 使用 $atan(\frac{dy}{dx})$:值域范围为 [-90°,90°],需要对 $dx$ 与 $dy$ 进行象限讨论,从而将值域范围转化为我们希望的 [0°,360°],同时需要注意 $dx = 0$ 的边界情况;
2. 使用 $atan2(dy, dx)$:值域范围为 [-180°,180°],与我们期望的 [0°,360°] 相差一个固定的值,可进行统一转换,也可以直接使用。
得到夹角数组 $list$ 后,对其进行排序,问题初步转换为:在夹角数组中找到连续一段 $[i, j]$,使得 $list[i]$ 和 $list[j]$ 的角度差不超过 $angle$。
但直接在原数组 $list$ 操作,会漏掉夹角横跨一四象限的情况:
因此,另外一个细节是,在求连续段长度时,先对夹角数组进行拷贝拼接,并对拼接部分增加偏移量(确保数组仍具有单调性)。
具体的,设夹角数组长度为 $n$,此时令 $list[n + i] = list[i] + 2 * PI$,从而将问题彻底转换为求连续段问题。
求解最长合法连续段 $[i,j]$ 可用「双指针」实现「滑动窗口」来做。
一些细节:题目规定了与 $location$ 重合的点在任意角度都能看到,因此我们需要对这些点进行特殊处理,
代码:
```Java
class Solution {
public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
int x = location.get(0), y = location.get(1);
List<Double> list = new ArrayList<>();
int cnt = 0;
double pi = Math.PI, t = angle * pi / 180;
for (List<Integer> p : points) {
int a = p.get(0), b = p.get(1);
if (a == x && b == y && ++cnt >= 0) continue;
list.add(Math.atan2(b - y, a - x) + pi);
}
Collections.sort(list);
int n = list.size(), max = 0;
for (int i = 0; i < n; i++) list.add(list.get(i) + 2 * pi);
for (int i = 0, j = 0; j < 2 * n; j++) {
while (i < j && list.get(j) - list.get(i) > t) i++;
max = Math.max(max, j - i + 1);
}
return cnt + max;
}
}
```
* 时间复杂度:令 $n$ 为 `points` 数组的长度,预处理出 `points` 的所有角度复杂度为 $O(n)$;对所有角度进行排序的复杂度为 $O(n\log{n})$;使用双指针实现滑动窗口得出最大合法子数组的复杂度为 $O(n)$;整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1610` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/162. 寻找峰值（中等）.md | 162. 寻找峰值 | https://leetcode-cn.com/problems/find-peak-element/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-qva7v/ | 中等 | [
"二分"
] | 峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 `nums`,找到峰值元素并返回其索引。数组可能包含多个峰值,在这种情况下,返回 任何一个峰值 所在位置即可。
你可以假设 `nums[-1] = nums[n] = -∞` 。
你必须实现时间复杂度为 $O(\log{n})$ 的算法来解决此问题。
示例 1:
```
输入:nums = [1,2,3,1]
输出:2
解释:3 是峰值元素,你的函数应该返回其索引 2。
```
示例 2:
```
输入:nums = [1,2,1,3,5,6,4]
输出:1 或 5
解释:你的函数可以返回索引 1,其峰值元素为 2;
或者返回索引 5, 其峰值元素为 6。
```
提示:
* $1 <= nums.length <= 1000$
* $-2^{31} <= nums[i] <= 2^{31} - 1$
* 对于所有有效的 `i` 都有 `nums[i] != nums[i + 1]` | ### 模拟
由于数据范围只有 $1000$,使用线性扫描找峰值的模拟做法也是没有问题。
代码:
```Java
class Solution {
public int findPeakElement(int[] nums) {
int n = nums.length;
for (int i = 0; i < n; i++) {
boolean ok = true;
if (i - 1 >= 0) {
if (nums[i - 1] >= nums[i]) ok = false;
}
if (i + 1 < n) {
if (nums[i + 1] >= nums[i]) ok = false;
}
if (ok) return i;
}
return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 二分
题目让我们实现一个 $O(\log{n})$ 算法,这是对使用「二分」的强烈暗示。
和往常的题目一样,**我们应当从是否具有「二段性」来考虑是否可以进行「二分」**。
不难发现,**如果** 在确保有解的情况下,我们可以根据当前的分割点 $mid$ 与左右元素的大小关系来指导 $l$ 或者 $r$ 的移动。
假设当前分割点 $mid$ 满足关系 $num[mid] > nums[mid + 1]$ 的话,一个很简单的想法是 $num[mid]$ 可能为峰值,而 $nums[mid + 1]$ 必然不为峰值,于是让 $r = mid$,从左半部分继续找峰值。
估计不少同学靠这个思路 AC 了,只能说做法对了,分析没对。
上述做法正确的前提有两个:
1. 对于任意数组而言,一定存在峰值(一定有解);
2. 二分不会错过峰值。
我们分别证明一下。
**证明 $1$ :对于任意数组而言,一定存在峰值(一定有解)**
根据题意,我们有「数据长度至少为 $1$」、「越过数组两边看做负无穷」和「相邻元素不相等」的起始条件。
我们可以根据数组长度是否为 $1$ 进行分情况讨论:
1. 数组长度为 $1$,由于边界看做负无穷,此时峰值为该唯一元素的下标;
2. 数组长度大于 $1$,从最左边的元素 $nums[0]$ 开始出发考虑:
* 如果 $nums[0] > nums[1]$,那么最左边元素 $nums[0]$ 就是峰值(结合左边界为负无穷);
* 如果 $nums[0] < nums[1]$,由于已经存在明确的 $nums[0]$ 和 $nums[1]$ 大小关系,我们将 $nums[0]$ 看做边界, $nums[1]$ 看做新的最左侧元素,继续往右进行分析:
* 如果在到达数组最右侧前,出现 $nums[i] > nums[i + 1]$,说明存在峰值位置 $i$(当我们考虑到 $nums[i]$,必然满足 $nums[i]$ 大于前一元素的前提条件,当然前一元素可能是原始左边界);
* 到达数组最右侧,还没出现 $nums[i] > nums[i + 1]$,说明数组严格递增。此时结合右边界可以看做负无穷,可判定 $nums[n - 1]$ 为峰值。
**综上,我们证明了无论何种情况,数组必然存在峰值。**
**证明 $2$ :二分不会错过峰值**
其实基于「证明 $1$」,我们很容易就可以推理出「证明 $2$」的正确性。
整理一下由「证明 $1$」得出的推理:**如果当前位置大于其左边界或者右边界,那么在当前位置的右边或左边必然存在峰值。**
**换句话说,对于一个满足 $nums[x] > nums[x - 1]$ 的位置,$x$ 的右边一定存在峰值;或对于一个满足 $nums[x] > nums[x + 1]$ 的位置,$x$ 的左边一定存在峰值。**
因此这里的「二段性」其实是指:**在以 $mid$ 为分割点的数组上,根据 $nums[mid]$ 与 $nums[mid \pm 1]$ 的大小关系,可以确定其中一段满足「必然有解」,另外一段不满足「必然有解」(可能有解,可能无解)。**
> 如果不理解为什么「证明 $2$」的正确性可以由「证明 $1$」推导而出的话,可以重点看看「证明 $1$」的第 $2$ 点的证明。
**至此,我们证明了始终选择大于边界一端进行二分,可以确保选择的区间一定存在峰值,并随着二分过程不断逼近峰值位置。**
另外,为了照顾还在纠结使用什么“模板”的同学,特意写了两个版本。但其实只要搞清楚我们「二分」什么内容,根本不会存在说用哪种方式才能写过的情况。
代码:
```Java
class Solution {
public int findPeakElement(int[] nums) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] > nums[mid + 1]) r = mid;
else l = mid + 1;
}
return r;
}
}
```
```Java
class Solution {
public int findPeakElement(int[] nums) {
int n = nums.length;
if (n == 1) return 0;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] > nums[mid - 1]) l = mid;
else r = mid - 1;
}
return r;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 总结
**通过本题,我们可以对「二分」有进一步的认识。**
**最早在 [33. 搜索旋转排序数组](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485864&idx=1&sn=e5482b2cf55962cd0c5384698d4d0fde&chksm=fd9ca2b7caeb2ba152ef1b900dce805ccfc73cf2a1595fa62eba8a6c5c5212d2d5b3e9f752ba&token=1232059512&lang=zh_CN#rd) 中,我们强调,二分的本质是「二段性」而非「单调性」,而经过本题,我们进一步发现「二段性」还能继续细分,不仅仅只有满足 $01$ 特性(满足/不满足)的「二段性」可以使用二分,满足 $1?$ 特性(一定满足/不一定满足)也可以二分。** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.162` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/165. 比较版本号（中等）.md | 165. 比较版本号 | https://leetcode-cn.com/problems/compare-version-numbers/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-xsod/ | 中等 | [
"模拟"
] | 给你两个版本号 version1 和 version2 ,请你比较它们。
版本号由一个或多个修订号组成,各修订号由一个 '.' 连接。每个修订号由 多位数字 组成,可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号,下标从 0 开始,最左边的修订号下标为 0 ,下一个修订号下标为 1 ,以此类推。例如,2.5.33 和 0.1 都是有效的版本号。
比较版本号时,请按从左到右的顺序依次比较它们的修订号。比较修订号时,只需比较 忽略任何前导零后的整数值 。也就是说,修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号,则该修订号视为 0 。例如,版本 1.0 小于版本 1.1 ,因为它们下标为 0 的修订号相同,而下标为 1 的修订号分别为 0 和 1 ,0 < 1 。
返回规则如下:
* 如果 version1 > version2 返回 1,
* 如果 version1 < version2 返回 -1,
* 除此之外返回 0。
示例 1:
```
输入:version1 = "1.01", version2 = "1.001"
输出:0
解释:忽略前导零,"01" 和 "001" 都表示相同的整数 "1"
```
示例 2:
```
输入:version1 = "1.0", version2 = "1.0.0"
输出:0
解释:version1 没有指定下标为 2 的修订号,即视为 "0"
```
示例 3:
```
输入:version1 = "0.1", version2 = "1.1"
输出:-1
解释:version1 中下标为 0 的修订号是 "0",version2 中下标为 0 的修订号是 "1" 。0 < 1,所以 version1 < version2
```
示例 4:
```
输入:version1 = "1.0.1", version2 = "1"
输出:1
```
示例 5:
```
输入:version1 = "7.5.2.4", version2 = "7.5.3"
输出:-1
```
提示:
* 1 <= version1.length, version2.length <= 500
* version1 和 version2 仅包含数字和 '.'
* version1 和 version2 都是 有效版本号
* version1 和 version2 的所有修订号都可以存储在 32 位整数 中 | ### 模拟
根据题意,对字符串进行分割,诸位比较「修订号」大小即可。
对于缺省的修订号位置,使用 $0$ 进行代指。
代码:
```Java
class Solution {
public int compareVersion(String v1, String v2) {
String[] ss1 = v1.split("\\."), ss2 = v2.split("\\.");
int n = ss1.length, m = ss2.length;
int i = 0, j = 0;
while (i < n || j < m) {
int a = 0, b = 0;
if (i < n) a = Integer.parseInt(ss1[i++]);
if (j < m) b = Integer.parseInt(ss2[j++]);
if (a != b) return a > b ? 1 : -1;
}
return 0;
}
}
```
* 时间复杂度:令 `v1` 长度为 $n$,`v2` 长度为 $m$。整体复杂度为 $O(\max(n, m))$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.165` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/166. 分数到小数（中等）.md | 166. 分数到小数 | https://leetcode-cn.com/problems/fraction-to-recurring-decimal/solution/gong-shui-san-xie-mo-ni-shu-shi-ji-suan-kq8c4/ | 中等 | [
"数学",
"模拟",
"哈希表"
] | 给定两个整数,分别表示分数的分子 `numerator` 和分母 `denominator`,以**字符串形式返回小数**。
如果小数部分为循环小数,则将循环的部分括在括号内。
如果存在多个答案,只需返回 **任意一个**。
对于所有给定的输入,保证答案字符串的长度小于 $10^4$ 。
示例 1:
```
输入:numerator = 1, denominator = 2
输出:"0.5"
```
示例 2:
```
输入:numerator = 2, denominator = 1
输出:"2"
```
示例 3:
```
输入:numerator = 2, denominator = 3
输出:"0.(6)"
```
示例 4:
```
输入:numerator = 4, denominator = 333
输出:"0.(012)"
```
示例 5:
```
输入:numerator = 1, denominator = 5
输出:"0.2"
```
提示:
* $-2^{31}$ <= numerator, denominator <= $2^{31} - 1$
* denominator != 0 | ### 模拟
这是一道模拟 [竖式计算(除法)](https://baike.baidu.com/item/%E7%AB%96%E5%BC%8F%E8%AE%A1%E7%AE%97)的题目。
首先可以明确,两个数相除要么是「有限位小数」,要么是「无限循环小数」,而不可能是「无限不循环小数」。
然后考虑人工计算两数相除是如何进行:
这引导我们可以在模拟竖式计算(除法)过程中,使用「哈希表」记录某个余数最早在什么位置出现过,一旦出现相同余数,则将「出现位置」到「当前结尾」之间的字符串抠出来,即是「循环小数」部分。
> PS. 到这里,从人工模拟除法运算的过程,我们就可以知道「为什么不会出现“无限不循环小数”」,因为始终是对余数进行补零操作,再往下进行运算,而余数个数具有明确的上限(有限集)。所以一直往下计算,最终结果要么是「出现相同余数」,要么是「余数为 $0$,运算结束」。
一些细节:
* 一个显然的条件是,如果本身两数能够整除,直接返回即可;
* 如果两个数有一个为“负数”,则最终答案为“负数”,因此可以起始先判断两数相乘是否小于 $0$,如果是,先往答案头部追加一个负号 `-`;
* 两者范围为 `int`,但计算结果可以会超过 `int` 范围,考虑 $numerator = -2^{31}$ 和 $denominator = -1$ 的情况,其结果为 $2^{31}$,超出 `int` 的范围 $[-2^{31}, 2^{31} - 1]$。因此起始需要先使用 `long` 对两个入参类型转换一下。
代码:
```Java
class Solution {
public String fractionToDecimal(int numerator, int denominator) {
// 转 long 计算,防止溢出
long a = numerator, b = denominator;
// 如果本身能够整除,直接返回计算结果
if (a % b == 0) return String.valueOf(a / b);
StringBuilder sb = new StringBuilder();
// 如果其一为负数,先追加负号
if (a * b < 0) sb.append('-');
a = Math.abs(a); b = Math.abs(b);
// 计算小数点前的部分,并将余数赋值给 a
sb.append(String.valueOf(a / b) + ".");
a %= b;
Map<Long, Integer> map = new HashMap<>();
while (a != 0) {
// 记录当前余数所在答案的位置,并继续模拟除法运算
map.put(a, sb.length());
a *= 10;
sb.append(a / b);
a %= b;
// 如果当前余数之前出现过,则将 [出现位置 到 当前位置] 的部分抠出来(循环小数部分)
if (map.containsKey(a)) {
int u = map.get(a);
return String.format("%s(%s)", sb.substring(0, u), sb.substring(u));
}
}
return sb.toString();
}
}
```
* 时间复杂度:复杂度取决于最终答案的长度,题目规定了最大长度不会超过 $10^4$,整体复杂度为 $O(M)$
* 空间复杂度:复杂度取决于最终答案的长度,题目规定了最大长度不会超过 $10^4$,整体复杂度为 $O(M)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.166` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/161-170/168. Excel表列名称（简单）.md | 168. Excel表列名称 | https://leetcode-cn.com/problems/excel-sheet-column-title/solution/gong-shui-san-xie-cong-1-kai-shi-de-26-j-g2ur/ | 简单 | [
"模拟"
] | 给定一个正整数,返回它在 Excel 表中相对应的列名称。
例如,
```
1 -> A
2 -> B
3 -> C
...
26 -> Z
27 -> AA
28 -> AB
...
```
示例 1:
```
输入: 1
输出: "A"
```
示例 2:
```
输入: 28
输出: "AB"
```
示例 3:
```
输入: 701
输出: "ZY"
``` | ### 模拟
这是一道从 $1$ 开始的的 $26$ 进制转换题。
对于一般性的进制转换题目,只需要不断地对 $columnNumber$ 进行 `%` 运算取得最后一位,然后对 $columnNumber$ 进行 `/` 运算,将已经取得的位数去掉,直到 $columnNumber$ 为 $0$ 即可。
一般性的进制转换题目无须进行额外操作,是因为我们是在「每一位数值范围在 $[0,x)$」的前提下进行「逢 $x$ 进一」。
但本题需要我们将从 $1$ 开始,因此在执行「进制转换」操作前,我们需要先对 $columnNumber$ 执行减一操作,从而实现整体偏移。
Java 代码:
```Java
class Solution {
public String convertToTitle(int columnNumber) {
StringBuilder sb = new StringBuilder();
while (columnNumber > 0) {
columnNumber--;
sb.append((char)(columnNumber % 26 + 'A'));
columnNumber /= 26;
}
sb.reverse();
return sb.toString();
}
}
```
C++ 代码:
```C++
class Solution {
public:
string convertToTitle(int columnNumber) {
string sb;
while (columnNumber > 0) {
columnNumber--;
sb.push_back((char)(columnNumber % 26 + 'A'));
columnNumber /= 26;
}
reverse(sb.begin(), sb.end());
return sb;
}
};
```
Python 代码:
```Python
class Solution:
def convertToTitle(self, columnNumber: int) -> str:
sb = ""
while columnNumber > 0:
columnNumber -= 1
sb += chr((columnNumber % 26) + ord('A'))
columnNumber //= 26
return sb[::-1]
```
* 时间复杂度:$O(\log_{26}{cn})$
* 空间复杂度:不算构造答案所消耗的空间,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.168` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1611-1620/1614. 括号的最大嵌套深度（简单）.md | 1614. 括号的最大嵌套深度 | https://leetcode-cn.com/problems/maximum-nesting-depth-of-the-parentheses/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-pf5d/ | 简单 | [
"模拟"
] | 如果字符串满足以下条件之一,则可以称之为 有效括号字符串(valid parentheses string,可以简写为 VPS):
* 字符串是一个空字符串 `""`,或者是一个不为 `"("` 或 `")"` 的单字符。
* 字符串可以写为 `AB`(`A` 与 `B` 字符串连接),其中 `A` 和 `B` 都是 有效括号字符串 。
* 字符串可以写为 `(A)`,其中 `A` 是一个 有效括号字符串 。
类似地,可以定义任何有效括号字符串 `S` 的 嵌套深度 `depth(S)`:
* `depth("") = 0`
* `depth(C) = 0`,其中 `C` 是单个字符的字符串,且该字符不是 `"("` 或者 `")"`
* `depth(A + B) = max(depth(A), depth(B))`,其中 `A` 和 `B` 都是 有效括号字符串
* `depth("(" + A + ")") = 1 + depth(A)`,其中 `A` 是一个 有效括号字符串
例如:`""`、`"()()"`、`"()(()())"` 都是 有效括号字符串(嵌套深度分别为 0、1、2),而 `")("` 、`"(()"` 都不是 有效括号字符串 。
给你一个 有效括号字符串 `s`,返回该字符串的 `s` 嵌套深度 。
示例 1:
```
输入:s = "(1+(2*3)+((8)/4))+1"
输出:3
解释:数字 8 在嵌套的 3 层括号中。
```
示例 2:
```
输入:s = "(1)+((2))+(((3)))"
输出:3
```
示例 3:
```
输入:s = "1+(2*3)/(2-1)"
输出:1
```
示例 4:
```
输入:s = "1"
输出:0
```
提示:
* $1 <= s.length <= 100$
* `s` 由数字 `0-9` 和字符 `'+'`、`'-'`、`'*'`、`'/'`、`'('`、`')'` 组成
* 题目数据保证括号表达式 `s` 是 有效的括号表达式 | ### 模拟
根据题意,其实就是求最大的连续左括号的数量(跳过普通字符,且与 `)` 抵消后),只需要边遍历边统计即可。
代码:
```Java
class Solution {
public int maxDepth(String s) {
int n = s.length(), ans = 0;
for (int i = 0, cnt = 0; i < n; i++) {
if (s.charAt(i) == '(') cnt++;
else if (s.charAt(i) == ')') cnt--;
ans = Math.max(ans, cnt);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1614` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1611-1620/1619. 删除某些元素后的数组均值（简单）.md | 1619. 删除某些元素后的数组均值 | https://leetcode.cn/problems/mean-of-array-after-removing-some-elements/solution/by-ac_oier-73w7/ | 简单 | [
"模拟",
"排序"
] | 给你一个整数数组 `arr`,请你删除最小 `5%` 的数字和最大 `5%` 的数字后,剩余数字的平均值。
与 标准答案 误差在 $10^{-5}$ 的结果都被视为正确结果。
示例 1:
```
输入:arr = [1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3]
输出:2.00000
解释:删除数组中最大和最小的元素后,所有元素都等于 2,所以平均值为 2 。
```
示例 2:
```
输入:arr = [6,2,7,5,1,2,0,3,10,2,5,0,5,5,0,8,7,6,8,0]
输出:4.00000
```
示例 3:
```
输入:arr = [6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,3,4]
输出:4.77778
```
示例 4:
```
输入:arr = [9,7,8,7,7,8,4,4,6,8,8,7,6,8,8,9,2,6,0,0,1,10,8,6,3,3,5,1,10,9,0,7,10,0,10,4,1,10,6,9,3,6,0,0,2,7,0,6,7,2,9,7,7,3,0,1,6,1,10,3]
输出:5.27778
```
示例 5:
```
输入:arr = [4,8,4,10,0,7,1,3,7,8,8,3,4,1,6,2,1,1,8,0,9,8,0,3,9,10,3,10,1,10,7,3,2,1,4,9,10,7,6,4,0,8,5,1,2,1,6,2,5,0,7,10,9,10,3,7,10,5,8,5,7,6,7,6,10,9,5,10,5,5,7,2,10,7,7,8,2,0,1,1]
输出:5.29167
```
提示:
* $20 <= arr.length <= 1000$
* `arr.length` 是 `20` 的 倍数
* $0 <= arr[i] <= 10^5$ | ### 模拟
根据题意进行模拟即可:先对 `arr` 进行排序,再计算出待统计的左右端点(端点以外的数值为 `5%` 最值),最后计算出相应均值。
Java 代码:
```Java
class Solution {
public double trimMean(int[] arr) {
Arrays.sort(arr);
int n = arr.length, tot = 0;
for (int i = n / 20; i < n - n / 20; i++) tot += arr[i];
return tot * 1.0 / (n * 0.9);
}
}
```
TypeScript 代码:
```TypeScript
function trimMean(arr: number[]): number {
arr.sort((a,b)=>a-b)
let n = arr.length, tot = 0
for (let i = n / 20; i < n - n / 20; i++) tot += arr[i]
return tot / (n * 0.9)
};
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1619` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1611-1620/1620. 网络信号最好的坐标（中等）.md | 1620. 网络信号最好的坐标 | https://leetcode.cn/problems/coordinate-with-maximum-network-quality/solution/by-ac_oier-xtx3/ | 中等 | [
"模拟",
"枚举"
] | 给你一个数组 `towers` 和一个整数 `radius` 。
数组 `towers` 中包含一些网络信号塔,其中 $towers[i] = [x_{i}, y_{i}, q_{i}]$ 表示第 `i` 个网络信号塔的坐标是 $(x_{i}, y_{i})$ 且信号强度参数为 $q_{i}$ 。所有坐标都是在 `X-Y` 坐标系内的 **整数** 坐标。两个坐标之间的距离用 **欧几里得距离** 计算。
整数 `radius` 表示一个塔 能到达 的 最远距离 。如果一个坐标跟塔的距离在 `radius` 以内,那么该塔的信号可以到达该坐标。在这个范围以外信号会很微弱,所以 `radius` 以外的距离该塔是 不能到达的 。
如果第 `i` 个塔能到达 $(x, y)$ ,那么该塔在此处的信号为 `⌊q / (1 + d)⌋` ,其中 `d` 是塔跟此坐标的距离。一个坐标的 信号强度 是所有 能到达 该坐标的塔的信号强度之和。
请你返回数组 $[c_{x}, c_{y}]$ ,表示 信号强度 最大的 整数 坐标点 $(c_{x}, c_{y})$ 。如果有多个坐标网络信号一样大,请你返回字典序最小的 **非负** 坐标。
注意:
* 坐标 `(x1, y1)` 字典序比另一个坐标 `(x2, y2)` 小,需满足以下条件之一:
* 要么 `x1 < x2` ,
* 要么 `x1 == x2` 且 `y1 < y2` 。
* `⌊val⌋` 表示小于等于 `val` 的最大整数(向下取整函数)。
示例 1:
```
输入:towers = [[1,2,5],[2,1,7],[3,1,9]], radius = 2
输出:[2,1]
解释:
坐标 (2, 1) 信号强度之和为 13
- 塔 (2, 1) 强度参数为 7 ,在该点强度为 ⌊7 / (1 + sqrt(0)⌋ = ⌊7⌋ = 7
- 塔 (1, 2) 强度参数为 5 ,在该点强度为 ⌊5 / (1 + sqrt(2)⌋ = ⌊2.07⌋ = 2
- 塔 (3, 1) 强度参数为 9 ,在该点强度为 ⌊9 / (1 + sqrt(1)⌋ = ⌊4.5⌋ = 4
没有别的坐标有更大的信号强度。
```
示例 2:
```
输入:towers = [[23,11,21]], radius = 9
输出:[23,11]
解释:由于仅存在一座信号塔,所以塔的位置信号强度最大。
```
示例 3:
```
输入:towers = [[1,2,13],[2,1,7],[0,1,9]], radius = 2
输出:[1,2]
解释:坐标 (1, 2) 的信号强度最大。
```
提示:
* $1 <= towers.length <= 50$
* $towers[i].length = 3$
* $0 <= x_{i}, y_{i}, q_{i} <= 50$
* $1 <= radius <= 50$ | ### 模拟
观察数据范围:无论是 `towers` 数组大小、坐标 $(x, y)$ 的值域大小,还是最远距离 `k = radius`,取值均不超过 $50$。
因此我们可以直接采用「模拟」的方式进行求解,而不会面临 `TLE` 或 `MLE` 的风险。
具体的,我们建立一个大小为 $110 \times 110$ 的棋盘 `g`,用于记录每个坐标点的信号值,即 $g[i][j] = x$ 代表坐标 $(i, j)$ 的信号值为 $x$。
> 其中 $110$ 的大小是利用了「任意坐标 $(x, y)$ 的取值范围不超过 $50$」,同时「最远距离 $k$ 不超过 $50$」并且「最终答案为非负坐标」而定。
随后,我们可以枚举所有 $towers[i] = (a, b, q)$,并检查以该塔为中心点,大小为 $(k + k)^2$ 的矩阵中的所有点(该塔所能贡献信号的所有坐标均落在矩阵中),枚举过程中使用变量 `val` 记录最大信号值,使用 `x` 和 `y` 记录答案坐标。
Java 代码:
```Java
class Solution {
public int[] bestCoordinate(int[][] towers, int k) {
int[][] g = new int[110][110];
int x = 0, y = 0, val = 0;
for (int[] t : towers) {
int a = t[0], b = t[1], q = t[2];
for (int i = Math.max(0, a - k); i <= a + k; i++) {
for (int j = Math.max(0, b - k); j <= b + k; j++) {
double d = Math.sqrt((a - i) * (a - i) + (b - j) * (b - j));
if (d > k) continue;
g[i][j] += Math.floor(q / (1 + d));
if (g[i][j] > val) {
x = i; y = j; val = g[i][j];
} else if (g[i][j] == val && (i < x || (i == x && j < y))) {
x = i; y = j;
}
}
}
}
return new int[]{x, y};
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> bestCoordinate(vector<vector<int>>& towers, int k) {
const int n = 110;
vector<vector<int>> g(n, vector<int>(n, 0));
int x = 0, y = 0, val = 0;
for (const auto& t : towers) {
int a = t[0], b = t[1], q = t[2];
for (int i = max(0, a - k); i <= a + k; ++i) {
for (int j = max(0, b - k); j <= b + k; ++j) {
double d = sqrt((a - i) * (a - i) + (b - j) * (b - j));
if (d > k) continue;
g[i][j] += floor(q / (1.0 + d));
if (g[i][j] > val) {
x = i; y = j; val = g[i][j];
} else if (g[i][j] == val && (i < x || (i == x && j < y))) {
x = i; y = j;
}
}
}
}
return vector<int>{x, y};
}
};
```
Python 代码:
```Python
class Solution:
def bestCoordinate(self, towers: List[List[int]], k: int) -> List[int]:
g = [[0] * 110 for _ in range(110)]
x, y, val = 0, 0, 0
for (a, b, q) in towers:
for i in range(max(0, a - k), a + k + 1):
for j in range(max(0, b - k), b + k + 1):
d = math.sqrt((a - i) * (a - i) + (b - j) * (b - j))
if d > k:
continue
g[i][j] += int(q / (1 + d))
if g[i][j] > val:
val, x, y = g[i][j], i, j
elif g[i][j] == val and ((i < x or (i == x and j < y))):
x, y = i, j
return [x, y]
```
TypeScript 代码:
```TypeScript
function bestCoordinate(towers: number[][], k: number): number[] {
const g = new Array<Array<number>>(110)
for (let i = 0; i < 110; i++) g[i] = new Array<number>(110).fill(0)
let x = 0, y = 0, val = 0
for (const t of towers) {
const a = t[0], b = t[1], q = t[2]
for (let i = Math.max(0, a - k); i <= a + k; i++) {
for (let j = Math.max(0, b - k); j <= b + k; j++) {
const d = Math.sqrt((a - i) * (a - i) + (b - j) * (b - j))
if (d > k) continue
g[i][j] += Math.floor(q / (1 + d))
if (g[i][j] > val) {
x = i; y = j; val = g[i][j]
} else if (g[i][j] == val && ((i < x) || (i == x && j < y))) {
x = i; y = j
}
}
}
}
return [x, y]
}
```
* 时间复杂度:需要 $O(n)$ 的复杂度枚举所有的塔 $towers[i]$;对于每座塔,我们需要枚举以该塔为中心点,大小为 $(k + k)^2$ 的矩阵中的所有坐标。整体复杂度为 $O(n \times k^2)$
* 空间复杂度:$O(M^2)$,其中 $M = 110$ 为棋盘大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1620` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1621-1630/1622. 奇妙序列（困难）.md | 1622. 奇妙序列 | null | 困难 | [
"线段树"
] | 请你实现三个 API `append`,`addAll` 和 `multAll` 来实现奇妙序列。
请实现 `Fancy` 类 :
* `Fancy()` 初始化一个空序列对象。
* `void append(val)` 将整数 `val` 添加在序列末尾。
* `void addAll(inc)` 将所有序列中的现有数值都增加 `inc` 。
* `void multAll(m)` 将序列中的所有现有数值都乘以整数 `m` 。
* `int getIndex(idx)` 得到下标为 `idx` 处的数值(下标从 $0$ 开始),并将结果对 $10^9 + 7$ 取余。如果下标大于等于序列的长度,请返回 $-1$ 。
示例:
```
输入:
["Fancy", "append", "addAll", "append", "multAll", "getIndex", "addAll", "append", "multAll", "getIndex", "getIndex", "getIndex"]
[[], [2], [3], [7], [2], [0], [3], [10], [2], [0], [1], [2]]
输出:
[null, null, null, null, null, 10, null, null, null, 26, 34, 20]
解释:
Fancy fancy = new Fancy();
fancy.append(2); // 奇妙序列:[2]
fancy.addAll(3); // 奇妙序列:[2+3] -> [5]
fancy.append(7); // 奇妙序列:[5, 7]
fancy.multAll(2); // 奇妙序列:[5*2, 7*2] -> [10, 14]
fancy.getIndex(0); // 返回 10
fancy.addAll(3); // 奇妙序列:[10+3, 14+3] -> [13, 17]
fancy.append(10); // 奇妙序列:[13, 17, 10]
fancy.multAll(2); // 奇妙序列:[13*2, 17*2, 10*2] -> [26, 34, 20]
fancy.getIndex(0); // 返回 26
fancy.getIndex(1); // 返回 34
fancy.getIndex(2); // 返回 20
```
提示:
* $1 <= val, inc, m <= 100$
* $0 <= idx <= 10^5$
* 总共最多会有 $10^5$ 次对 `append`,`addAll`,`multAll` 和 `getIndex` 的调用。 | ### 线段树(多个懒标记)
使用多个懒标记来解决 `add` 和 `mul` 问题。
代码:
```Java
class Fancy {
class Node {
int ls, rs;
long val, add, mul = 1;
}
int N = (int) 1e8 + 10, M = 1000010, loc = 1, cnt = 0, mod = (int)1e9+7;
Node[] tr = new Node[M];
void add(int u, int lc, int rc, int l, int r, int v) {
int len = rc - lc + 1;
if (l <= lc && rc <= r) {
tr[u].val += len * v; tr[u].val %= mod;
tr[u].add += v; tr[u].add %= mod;
return ;
}
pushdown(u, len);
int mid = lc + rc >> 1;
if (l <= mid) add(tr[u].ls, lc, mid, l, r, v);
if (r > mid) add(tr[u].rs, mid + 1, rc, l, r, v);
pushup(u);
}
void mul(int u, int lc, int rc, int l, int r, int v) {
if (l <= lc && rc <= r) {
tr[u].val *= v; tr[u].val %= mod;
tr[u].mul *= v; tr[u].mul %= mod;
tr[u].add *= v; tr[u].add %= mod;
return ;
}
pushdown(u, rc - lc + 1);
int mid = lc + rc >> 1;
if (l <= mid) mul(tr[u].ls, lc, mid, l, r, v);
if (r > mid) mul(tr[u].rs, mid + 1, rc, l, r, v);
pushup(u);
}
long query(int u, int lc, int rc, int l, int r) {
if (l <= lc && rc <= r) return tr[u].val;
pushdown(u, rc - lc + 1);
int mid = lc + rc >> 1;
long ans = 0;
if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);
if (r > mid) ans += query(tr[u].rs, mid + 1, rc, l, r);
return ans;
}
void pushdown(int u, int len) {
if (tr[u] == null) tr[u] = new Node();
if (tr[u].ls == 0) {
tr[u].ls = ++loc;
tr[tr[u].ls] = new Node();
}
if (tr[u].rs == 0) {
tr[u].rs = ++loc;
tr[tr[u].rs] = new Node();
}
long mul = tr[u].mul, add = tr[u].add;
tr[tr[u].ls].val = tr[tr[u].ls].val * mul + (len / 2) * add; tr[tr[u].rs].val = tr[tr[u].rs].val * mul + (len / 2) * add;
tr[tr[u].ls].mul *= mul; tr[tr[u].rs].mul *= mul;
tr[tr[u].ls].add = tr[tr[u].ls].add * mul + add; tr[tr[u].rs].add = tr[tr[u].rs].add * mul + add;
tr[tr[u].ls].val %= mod; tr[tr[u].rs].val %= mod;
tr[tr[u].ls].mul %= mod; tr[tr[u].rs].mul %= mod;
tr[tr[u].ls].add %= mod; tr[tr[u].rs].add %= mod;
tr[u].add = 0; tr[u].mul = 1;
}
void pushup(int u) {
tr[u].val = tr[tr[u].ls].val + tr[tr[u].rs].val;
tr[u].val %= mod;
}
public void append(int val) {
cnt++;
add(1, 1, N, cnt, cnt, val);
}
public void addAll(int inc) {
if (cnt == 0) return ;
add(1, 1, N, 1, cnt, inc);
}
public void multAll(int m) {
if (cnt == 0) return ;
mul(1, 1, N, 1, cnt, m);
}
public int getIndex(int idx) {
return idx + 1 > cnt ? -1 : (int)(query(1, 1, N, idx + 1, idx + 1) % mod);
}
}
```
* 时间复杂度:查询次数为 $m$,值域大小为 $n$,插入和查询复杂度均为 $O(\log{n})$
* 空间复杂度:$O(m \times \log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1622` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1621-1630/1624. 两个相同字符之间的最长子字符串（简单）.md | 1624. 两个相同字符之间的最长子字符串 | https://leetcode.cn/problems/largest-substring-between-two-equal-characters/solution/by-ac_oier-ki3t/ | 简单 | [
"模拟"
] | 给你一个字符串 `s`,请你返回 两个相同字符之间的最长子字符串的长度 ,计算长度时不含这两个字符。如果不存在这样的子字符串,返回 `-1` 。
子字符串 是字符串中的一个连续字符序列。
示例 1:
```
输入:s = "aa"
输出:0
解释:最优的子字符串是两个 'a' 之间的空子字符串。
```
示例 2:
```
输入:s = "abca"
输出:2
解释:最优的子字符串是 "bc" 。
```
示例 3:
```
输入:s = "cbzxy"
输出:-1
解释:s 中不存在出现出现两次的字符,所以返回 -1 。
```
示例 4:
```
输入:s = "cabbac"
输出:4
解释:最优的子字符串是 "abba" ,其他的非最优解包括 "bb" 和 "" 。
```
提示:
* $1 <= s.length <= 300$
* `s` 只含小写英文字母 | ### 模拟
根据题意继续模拟即可:使用数组 `idxs` 记录下每个字符最开始出现的下标即可。
Java 代码:
```Java
class Solution {
public int maxLengthBetweenEqualCharacters(String s) {
int[] idxs = new int[26];
Arrays.fill(idxs, 310);
int n = s.length(), ans = -1;
for (int i = 0; i < n; i++) {
int u = s.charAt(i) - 'a';
idxs[u] = Math.min(idxs[u], i);
ans = Math.max(ans, i - idxs[u] - 1);
}
return ans;
}
}
```
Typescript 代码:
```Typescript
function maxLengthBetweenEqualCharacters(s: string): number {
const idxs = new Array<number>(26).fill(310)
let n = s.length, ans = -1
for (let i = 0; i < n; i++) {
const u = s.charCodeAt(i) - 'a'.charCodeAt(0)
idxs[u] = Math.min(idxs[u], i)
ans = Math.max(ans, i - idxs[u] - 1)
}
return ans
};
```
Python 代码:
```Python
class Solution:
def maxLengthBetweenEqualCharacters(self, s: str) -> int:
idxs = {}
ans = -1
for i, c in enumerate(s):
idxs[c] = idxs[c] if c in idxs else i
ans = max(ans, i - idxs[c] - 1)
return ans
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1624` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1621-1630/1629. 按键持续时间最长的键（简单）.md | 1629. 按键持续时间最长的键 | https://leetcode-cn.com/problems/slowest-key/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-zjwb/ | 简单 | [
"模拟"
] | LeetCode 设计了一款新式键盘,正在测试其可用性。测试人员将会点击一系列键(总计 `n` 个),每次一个。
给你一个长度为 `n` 的字符串 `keysPressed` ,其中 `keysPressed[i]` 表示测试序列中第 i 个被按下的键。`releaseTimes` 是一个升序排列的列表,其中 `releaseTimes[i]` 表示松开第 `i` 个键的时间。字符串和数组的 下标都从 `0` 开始 。第 `0` 个键在时间为 `0` 时被按下,接下来每个键都 恰好 在前一个键松开时被按下。
测试人员想要找出按键 持续时间最长 的键。第 `i` 次按键的持续时间为 `releaseTimes[i] - releaseTimes[i - 1]` ,第 `0` 次按键的持续时间为 `releaseTimes[0]` 。
注意,测试期间,同一个键可以在不同时刻被多次按下,而每次的持续时间都可能不同。
请返回按键 持续时间最长 的键,如果有多个这样的键,则返回 按字母顺序排列最大 的那个键。
示例 1:
```
输入:releaseTimes = [9,29,49,50], keysPressed = "cbcd"
输出:"c"
解释:按键顺序和持续时间如下:
按下 'c' ,持续时间 9(时间 0 按下,时间 9 松开)
按下 'b' ,持续时间 29 - 9 = 20(松开上一个键的时间 9 按下,时间 29 松开)
按下 'c' ,持续时间 49 - 29 = 20(松开上一个键的时间 29 按下,时间 49 松开)
按下 'd' ,持续时间 50 - 49 = 1(松开上一个键的时间 49 按下,时间 50 松开)
按键持续时间最长的键是 'b' 和 'c'(第二次按下时),持续时间都是 20
'c' 按字母顺序排列比 'b' 大,所以答案是 'c'
```
示例 2:
```
输入:releaseTimes = [12,23,36,46,62], keysPressed = "spuda"
输出:"a"
解释:按键顺序和持续时间如下:
按下 's' ,持续时间 12
按下 'p' ,持续时间 23 - 12 = 11
按下 'u' ,持续时间 36 - 23 = 13
按下 'd' ,持续时间 46 - 36 = 10
按下 'a' ,持续时间 62 - 46 = 16
按键持续时间最长的键是 'a' ,持续时间 16
```
提示:
* `releaseTimes.length == n`
* `keysPressed.length == n`
* `2 <= n <= 1000`
* `1 <= releaseTimes[i] <= 10^9`
* `releaseTimes[i] < releaseTimes[i+1]`
* `keysPressed` 仅由小写英文字母组成 | ### 模拟
为了方便,我们用 $rt$ 来代指 $releaseTimes$,用 $kp$ 来代指 $keysPressed$。
根据题意,从先往后处理每个 $kp[i]$,计算每次的持续时间(当前结束时间与上次时间的差值)$rt[i] - rt[i - 1]$,遍历过程中维护最大持续时间和对应的字符下标。
代码:
```Java
class Solution {
public char slowestKey(int[] rt, String kp) {
int n = rt.length, idx = 0, max = rt[0];
for (int i = 1; i < n; i++) {
int cur = rt[i] - rt[i - 1];
if (cur > max) {
idx = i; max = cur;
} else if (cur == max && kp.charAt(i) > kp.charAt(idx)) {
idx = i;
}
}
return kp.charAt(idx);
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1629` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1631-1640/1631. 最小体力消耗路径（中等）.md | 1631. 最小体力消耗路径 | https://leetcode-cn.com/problems/path-with-minimum-effort/solution/fan-zheng-fa-zheng-ming-si-lu-de-he-fa-x-ohby/ | 中等 | [
"最小生成树",
"并查集",
"Kruskal"
] | 你准备参加一场远足活动。
给你一个二维 `rows x columns` 的地图 heights ,其中 `heights[row][col]` 表示格子 `(row, col)` 的高度。
一开始你在最左上角的格子 `(0, 0`) ,且你希望去最右下角的格子 `(rows-1, columns-1)` (注意下标从 0 开始编号)。
你每次可以往 上,下,左,右 四个方向之一移动,你想要找到耗费 体力 最小的一条路径。
一条路径耗费的「体力值」是路径上相邻格子之间「高度差绝对值」的「最大值」决定的。
请你返回从左上角走到右下角的最小 体力消耗值 。
示例 1:
```
输入:heights = [[1,2,2],[3,8,2],[5,3,5]]
输出:2
解释:路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。
这条路径比路径 [1,2,2,2,5] 更优,因为另一条路径差值最大值为 3 。
```
示例 2:
```
输入:heights = [[1,2,3],[3,8,4],[5,3,5]]
输出:1
解释:路径 [1,2,3,4,5] 的相邻格子差值绝对值最大为 1 ,比路径 [1,3,5,3,5] 更优。
```
示例 3:
```
输入:heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
输出:0
解释:上图所示路径不需要消耗任何体力。
```
提示:
* rows == heights.length
* columns == heights[i].length
* 1 <= rows, columns <= 100
* 1 <= heights[i][j] <= $10^6$ | ### 基本分析
对于这道题,可能会有同学想这是不是应该用 DP 呀?
特别是接触过[「路径问题」](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzU4NDE3MTEyMA==&action=getalbum&album_id=1773144264147812354&scene=173&from_msgid=2247485319&from_itemidx=1&count=3#wechat_redirect)但又还没系统学完的同学。
**事实上,当题目允许往任意方向移动时,考察的往往就不是 DP 了,而是图论。**
**从本质上说,DP 问题是一类特殊的图论问题。**
**那为什么有一些 DP 题目简单修改条件后,就只能彻底转化为图论问题来解决了呢?**
**这是因为修改条件后,导致我们 DP 状态展开不再是一个拓扑序列,也就是我们的图不再是一个拓扑图。**
**换句话说,DP 题虽然都属于图论范畴。**
**但对于不是拓扑图的图论问题,我们无法使用 DP 求解。**
**而此类看似 DP,实则图论的问题,通常是最小生成树或者最短路问题。**
---
### Kruskal
**当一道题我们决定往「图论」方向思考时,我们的重点应该放在「如何建图」上。**
因为解决某个特定的图论问题(最短路/最小生成树/二分图匹配),我们都是使用特定的算法。
由于使用到的算法都有固定模板,因此编码难度很低,而「如何建图」的思维难度则很高。
对于本题,我们可以按照如下分析进行建图:
因为在任意格子可以往「任意方向」移动,所以相邻的格子之间存在一条无向边。
题目要我们求的就是**从起点到终点的最短路径中,边权最大的值**。
我们可以先遍历所有的格子,将所有的边加入集合。
存储的格式为数组 $[a, b, w]$ ,代表编号为 $a$ 的点和编号为 $b$ 的点之间的权重为 $w$。
按照题意,$w$ 为两者的高度差的绝对值。
对集合进行排序,按照 $w$ 进行从小到大排序(Kruskal 部分)。
当我们有了所有排好序的候选边集合之后,我们可以对边进行从前往后处理,每次加入一条边之后,使用并查集来查询「起点」和「终点」是否连通(并查集部分)。
**当第一次判断「起点」和「终点」联通时,说明我们「最短路径」的所有边都已经应用到并查集上了,而且由于我们的边是按照「从小到大」进行排序,因此最后一条添加的边就是「最短路径」上权重最大的边。**
代码:
```Java
class Solution {
int N = 10009;
int[] p = new int[N];
int row, col;
void union(int a, int b) {
p[find(a)] = p[find(b)];
}
boolean query(int a, int b) {
return p[find(a)] == p[find(b)];
}
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
public int minimumEffortPath(int[][] heights) {
row = heights.length;
col = heights[0].length;
// 初始化并查集
for (int i = 0; i < row * col; i++) p[i] = i;
// 预处理出所有的边
// edge 存的是 [a, b, w]:代表从 a 到 b 的体力值为 w
// 虽然我们可以往四个方向移动,但是只要对于每个点都添加「向右」和「向下」两条边的话,其实就已经覆盖了所有边了
List<int[]> edges = new ArrayList<>();
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
int idx = getIndex(i, j);
if (i + 1 < row) {
int a = idx, b = getIndex(i + 1, j);
int w = Math.abs(heights[i][j] - heights[i + 1][j]);
edges.add(new int[]{a, b, w});
}
if (j + 1 < col) {
int a = idx, b = getIndex(i, j + 1);
int w = Math.abs(heights[i][j] - heights[i][j + 1]);
edges.add(new int[]{a, b, w});
}
}
}
// 根据权值 w 降序
Collections.sort(edges, (a,b)->a[2]-b[2]);
// 从「小边」开始添加,当某一条边别应用之后,恰好使用得「起点」和「结点」联通
// 那么代表找到了「最短路径」中的「权重最大的边」
int start = getIndex(0, 0), end = getIndex(row - 1, col - 1);
for (int[] edge : edges) {
int a = edge[0], b = edge[1], w = edge[2];
union(a, b);
if (query(start, end)) {
return w;
}
}
return 0;
}
int getIndex(int x, int y) {
return x * col + y;
}
}
```
令行数为 $r$,列数为 $c$,那么节点的数量为 $r * c$,无向边的数量严格为 $r * (c - 1) + c * (r - 1)$,数量级上为 $r * c$。
* 时间复杂度:获取所有的边复杂度为 $O(r * c)$,排序复杂度为 $O((r * c)\log{(r * c)})$,遍历得到最终解复杂度为 $O(r * c)$。整体复杂度为 $O((r * c)\log{(r * c)})$。
* 空间复杂度:使用了并查集数组。复杂度为 $O(r * c)$。
---
### 证明
**我们之所以能够这么做,是因为「跳出循环前所遍历的最后一条边必然是最优路径上的边,而且是 $w$ 最大的边」。**
我们可以用「反证法」来证明这个结论为什么是正确的。
我们先假设「跳出循环前所遍历的最后一条边必然是最优路径上的边,而且是 $w$ 最大的边」不成立:
我们令循环终止前的最后一条边为 `a`
1. *假设 a 不在最优路径内*:如果 $a$ 并不在最优路径内,即最优路径是由 $a$ 边之前的边构成,那么 $a$ 边不会对左上角和右下角节点的连通性产生影响。也就是在遍历到该边之前,左上角和右下角应该是联通的,逻辑上循环会在遍历到该边前终止。与我们循环的决策逻辑冲突。
2. *$a$ 在最优路径内,但不是 $w$ 最大的边*:我们在遍历之前就已经排好序。与排序逻辑冲突。
因此,我们的结论是正确的。`a` 边必然属于「最短路径」并且是权重最大的边。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1631` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1631-1640/1636. 按照频率将数组升序排序（简单）.md | 1636. 按照频率将数组升序排序 | https://leetcode.cn/problems/sort-array-by-increasing-frequency/solution/by-ac_oier-c3xc/ | 简单 | [
"哈希表",
"排序",
"模拟"
] | 给你一个整数数组 `nums`,请你将数组按照每个值的频率 升序 排序。如果有多个值的频率相同,请你按照数值本身将它们 降序 排序。
请你返回排序后的数组。
示例 1:
```
输入:nums = [1,1,2,2,2,3]
输出:[3,1,1,2,2,2]
解释:'3' 频率为 1,'1' 频率为 2,'2' 频率为 3 。
```
示例 2:
```
输入:nums = [2,3,1,3,2]
输出:[1,3,3,2,2]
解释:'2' 和 '3' 频率都为 2 ,所以它们之间按照数值本身降序排序。
```
示例 3:
```
输入:nums = [-1,1,-6,4,5,-6,1,4,1]
输出:[5,-1,4,4,-6,-6,1,1,1]
```
提示:
* $1 <= nums.length <= 100$
* $-100 <= nums[i] <= 100$ | ### 哈希表 + 排序 + 模拟
根据题意,先使用哈希表进行词频统计,再以二元组 $(x, cnt)$ 的形式转存到数组 `list` 中(其中 $x$ 为对应的 $nums$ 中的数值,$cnt$ 为数值 $x$ 在 `nums` 中的出现次数),再根据题目给定对 `list` 进行排序,最后再构造出答案。
Java 代码:
```Java
class Solution {
public int[] frequencySort(int[] nums) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
List<int[]> list = new ArrayList<>();
for (int key : map.keySet()) list.add(new int[]{key, map.get(key)});
Collections.sort(list, (a, b)->{
return a[1] != b[1] ? a[1] - b[1] : b[0] - a[0];
});
int[] ans = new int[n];
int idx = 0;
for (int[] info : list) {
int a = info[0], b = info[1];
while (b-- > 0) ans[idx++] = a;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function frequencySort(nums: number[]): number[] {
const map = new Map<number, number>()
for (const x of nums) {
if (!map.has(x)) map.set(x, 0)
map.set(x, map.get(x) + 1)
}
nums.sort((a,b)=>{
return map.get(a) != map.get(b) ? map.get(a) - map.get(b) : b - a
})
return nums
};
```
* 时间复杂度:使用哈希表进行统计复杂度为 $O(n)$;根据规则进行排序复杂度为 $O(n\log{n})$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1636` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1631-1640/1640. 能否连接形成数组（简单）.md | 1640. 能否连接形成数组 | https://leetcode.cn/problems/check-array-formation-through-concatenation/solution/by-ac_oier-3jqf/ | 简单 | [
"排序",
"二分",
"哈希表",
"模拟"
] | 给你一个整数数组 `arr` ,数组中的每个整数 互不相同 。
另有一个由整数数组构成的数组 `pieces`,其中的整数也互不相同。
请你以任意顺序连接 `pieces` 中的数组以形成 `arr` 。
但是,不允许对每个数组 `pieces[i]` 中的整数重新排序。
如果可以连接 `pieces` 中的数组形成 `arr` ,返回 `true` ;否则,返回 `false` 。
示例 1:
```
输入:arr = [15,88], pieces = [[88],[15]]
输出:true
解释:依次连接 [15] 和 [88]
```
示例 2:
```
输入:arr = [49,18,16], pieces = [[16,18,49]]
输出:false
解释:即便数字相符,也不能重新排列 pieces[0]
```
示例 3:
```
输入:arr = [91,4,64,78], pieces = [[78],[4,64],[91]]
输出:true
解释:依次连接 [91]、[4,64] 和 [78]
```
提示:
* $1 <= pieces.length <= arr.length <= 100$
* `sum(pieces[i].length) = arr.length`
* $1 <= pieces[i].length <= arr.length$
* $1 <= arr[i], pieces[i][j] <= 100$
* `arr` 中的整数 互不相同
* `pieces` 中的整数 互不相同(也就是说,如果将 `pieces` 扁平化成一维数组,数组中的所有整数互不相同) | ### 排序 + 二分
偷懒直接看示例做了,于是漏掉「两数组元素各不相同」且「两数组总元素个数相等」等条件,写了一个「排序 + 二分 + 贪心」的解法。
**但实际上该做法也仅能解决「两数组元素各不相同」的问题,若允许元素重复,并不存在多项式解法。**
回归到元素互不相同的条件,可以退化出「排序 + 二分」解法。
记 `arr` 数组长度为 $n$,`pieces` 数组长度为 $m$。
起始对 `pieces` 进行排序(根据 $pieces[i]$ 的首位元素排升序),从前往后处理每个 `arr[i]` 尝试匹配,先通过二分找到合适的 $pieces[j]$(即满足首位元素与 `arr[i]` 相同的 $pieces[j]$),并进行连续段的匹配,若匹配失败直接返回 `false`。
Java 代码:
```Java
class Solution {
public boolean canFormArray(int[] arr, int[][] pieces) {
int n = arr.length, m = pieces.length;
Arrays.sort(pieces, (a,b)->a[0]-b[0]);
for (int i = 0; i < n; ) {
int l = 0, r = m - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (pieces[mid][0] <= arr[i]) l = mid;
else r = mid - 1;
}
int len = pieces[r].length, idx = 0;
while (idx < len && pieces[r][idx] == arr[i + idx]) idx++;
if (idx == len) i += len;
else return false;
}
return true;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {
int n = arr.size(), m = pieces.size();
sort(pieces.begin(), pieces.end());
for (int i = 0; i < n; ) {
int l = 0, r = m - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (pieces[mid][0] <= arr[i]) l = mid;
else r = mid - 1;
}
int len = pieces[r].size(), idx = 0;
while (idx < len && pieces[r][idx] == arr[i + idx]) idx++;
if (idx == len) i += len;
else return false;
}
return true;
}
};
```
Python 代码:
```Python
class Solution:
def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:
n, m = len(arr), len(pieces)
pieces.sort(key=lambda x: x[0])
i = 0
while i < n:
l, r = 0, m - 1
while l < r:
mid = l + r + 1 >> 1
if pieces[mid][0] <= arr[i]:
l = mid
else:
r = mid - 1
sz, idx = len(pieces[r]), 0
while idx < sz and pieces[r][idx] == arr[i + idx]:
idx += 1
if idx == sz:
i += sz
else:
return False
return True
```
TypeScript 代码:
```TypeScript
function canFormArray(arr: number[], pieces: number[][]): boolean {
const n = arr.length, m = pieces.length
pieces.sort((a,b)=>a[0]-b[0])
for (let i = 0; i < n; ) {
let l = 0, r = m - 1
while (l < r) {
const mid = l + r + 1 >> 1
if (pieces[mid][0] <= arr[i]) l = mid
else r = mid - 1
}
let len = pieces[r].length, idx = 0
while (idx < len && pieces[r][idx] == arr[i + idx]) idx++
if (idx == len) i += len
else return false
}
return true
};
```
* 时间复杂度:排序复杂度为 $O(m\log{m})$;构造的复杂度为 $O(n\log{m})$。整体复杂度为 $O(m\log{m} + n\log{m})$
* 空间复杂度:$O(\log{m})$
---
### 哈希表
利用元素各不相同,使用哈希表进行预处理即可:$hash[x] = idx$ 含义为 $pieces[idx]$ 的首位元素为 $x$。
Java 代码:
```Java
class Solution {
public boolean canFormArray(int[] arr, int[][] pieces) {
int n = arr.length, m = pieces.length;
int[] hash = new int[110];
for (int i = 0; i < m; i++) hash[pieces[i][0]] = i;
for (int i = 0; i < n; ) {
int[] cur = pieces[hash[arr[i]]];
int len = cur.length, idx = 0;
while (idx < len && cur[idx] == arr[i + idx]) idx++;
if (idx == len) i += len;
else return false;
}
return true;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {
int n = arr.size(), m = pieces.size();
vector<int> hash(110);
for (int i = 0; i < m; i++) hash[pieces[i][0]] = i;
for (int i = 0; i < n; ) {
vector<int> cur = pieces[hash[arr[i]]];
int len = cur.size(), idx = 0;
while (idx < len && cur[idx] == arr[i + idx]) idx++;
if (idx == len) i += len;
else return false;
}
return true;
}
};
```
Python 代码:
```Python
class Solution:
def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:
n, m = len(arr), len(pieces)
hash = [0] * 110
for i in range(m):
hash[pieces[i][0]] = i
i = 0
while i < n:
cur = pieces[hash[arr[i]]]
sz, idx = len(cur), 0
while idx < sz and cur[idx] == arr[i + idx]:
idx += 1
if idx == sz:
i += sz
else:
return False
return True
```
TypeScript 代码:
```TypeScript
function canFormArray(arr: number[], pieces: number[][]): boolean {
const n = arr.length, m = pieces.length
const hash = new Array<number>(110).fill(0)
for (let i = 0; i < m; i++) hash[pieces[i][0]] = i
for (let i = 0; i < n; ) {
let cur = pieces[hash[arr[i]]], sz = cur.length, idx = 0
while (idx < sz && cur[idx] == arr[i + idx]) idx++
if (idx == sz) i += sz
else return false
}
return true
};
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(C)$,其中 $C = 110$ 为两数组的值域大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1640` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1641-1650/1646. 获取生成数组中的最大值（简单）.md | 1646. 获取生成数组中的最大值 | https://leetcode-cn.com/problems/get-maximum-in-generated-array/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-sj53/ | 简单 | [
"模拟",
"打表"
] | 给你一个整数 n 。按下述规则生成一个长度为 n + 1 的数组 nums :
* nums[0] = 0
* nums[1] = 1
* 当 2 <= 2 * i <= n 时,nums[2 * i] = nums[i]
* 当 2 <= 2 * i + 1 <= n 时,nums[2 * i + 1] = nums[i] + nums[i + 1]
返回生成数组 nums 中的 最大 值。
示例 1:
```
输入:n = 7
输出:3
解释:根据规则:
nums[0] = 0
nums[1] = 1
nums[(1 * 2) = 2] = nums[1] = 1
nums[(1 * 2) + 1 = 3] = nums[1] + nums[2] = 1 + 1 = 2
nums[(2 * 2) = 4] = nums[2] = 1
nums[(2 * 2) + 1 = 5] = nums[2] + nums[3] = 1 + 2 = 3
nums[(3 * 2) = 6] = nums[3] = 2
nums[(3 * 2) + 1 = 7] = nums[3] + nums[4] = 2 + 1 = 3
因此,nums = [0,1,1,2,1,3,2,3],最大值 3
```
示例 2:
```
输入:n = 2
输出:1
解释:根据规则,nums[0]、nums[1] 和 nums[2] 之中的最大值是 1
```
示例 3:
```
输入:n = 3
输出:2
解释:根据规则,nums[0]、nums[1]、nums[2] 和 nums[3] 之中的最大值是 2
```
提示:
* 0 <= n <= 100 | ### 模拟
按照题意模拟一遍,得到数列 $nums$,再从 $nums$ 中找出最大值即可。
代码:
```Java
class Solution {
public int getMaximumGenerated(int n) {
if (n == 0) return 0;
int[] nums = new int[n + 1];
nums[0] = 0;
nums[1] = 1;
for (int i = 0; i < n; i++) {
if (2 * i <= n) nums[2 * i] = nums[i];
if (2 * i + 1 <= n) nums[2 * i + 1] = nums[i] + nums[i + 1];
}
int ans = 0;
for (int i : nums) ans = Math.max(ans, i);
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 打表
利用数据范围,可以直接使用 `static` 进行打表构造。
代码:
```Java
class Solution {
static int N = 110;
static int[] nums = new int[N];
static {
nums[0] = 0;
nums[1] = 1;
for (int i = 0; i < N; i++) {
if (2 * i < N) nums[2 * i] = nums[i];
if (2 * i + 1 < N) nums[2 * i + 1] = nums[i] + nums[i + 1];
}
for (int i = 0, max = 0; i < N; i++) {
nums[i] = max = Math.max(max, nums[i]);
}
}
public int getMaximumGenerated(int n) {
return nums[n];
}
}
```
* 时间复杂度:将打表逻辑放到本地进行,复杂度为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1651-1660/1652. 拆炸弹（简单）.md | 1652. 拆炸弹 | https://leetcode.cn/problems/defuse-the-bomb/solution/by-ac_oier-osbg/ | 简单 | [
"模拟",
"前缀和"
] | 你有一个炸弹需要拆除,时间紧迫!
你的情报员会给你一个长度为 `n` 的 循环 数组 `code` 以及一个密钥 `k` 。
为了获得正确的密码,你需要替换掉每一个数字。所有数字会 同时 被替换。
* 如果 $k > 0$,将第 `i` 个数字用 接下来 `k` 个数字之和替换。
* 如果 $k < 0$,将第 `i` 个数字用 之前 `k` 个数字之和替换。
* 如果 $k = 0$,将第 `i` 个数字用 `0` 替换。
由于 `code` 是循环的, `code[n-1]` 下一个元素是 `code[0]` ,且 `code[0]` 前一个元素是 `code[n-1]` 。
给你 循环 数组 `code` 和整数密钥 `k` ,请你返回解密后的结果来拆除炸弹!
示例 1:
```
输入:code = [5,7,1,4], k = 3
输出:[12,10,16,13]
解释:每个数字都被接下来 3 个数字之和替换。解密后的密码为 [7+1+4, 1+4+5, 4+5+7, 5+7+1]。注意到数组是循环连接的。
```
示例 2:
```
输入:code = [1,2,3,4], k = 0
输出:[0,0,0,0]
解释:当 k 为 0 时,所有数字都被 0 替换。
```
示例 3:
```
输入:code = [2,4,9,3], k = -2
输出:[12,5,6,13]
解释:解密后的密码为 [3+9, 2+3, 4+2, 9+4] 。注意到数组是循环连接的。如果 k 是负数,那么和为 之前 的数字。
```
提示:
* $n = code.length$
* $1 <= n <= 100$
* $1 <= code[i] <= 100$
* $-(n - 1) <= k <= n - 1$ | ### 前缀和
根据题意 `code` 为循环数组,我们可以建立一个长度为 $2 \times n$ 的前缀和数组(为了方便,我们令前缀和数组下标从 $1$ 开始),利用前缀和数组来构建答案。
对于每一位 $ans[i - 1]$ 而言(其中 $i$ 的取值范围为 $[1, n]$),我们根据 `k` 值的正负情况来决定取自前缀和数组中的哪一段:
* 若有 $k < 0$:需要取位置 $i$ 前的 $-k$ 个数,为防止下越界标,先将位置 $i$ 往后进行 $n$ 个偏移(即位置 $i + n$),随后可知对应区间 $[i + n + k, i + n - 1]$,对应区间和为 $sum[i + n - 1] - sum[i + n + k - 1]$
* 若有 $k > 0$:需要取位置 $i$ 后的 $k$ 个数,对应前缀和数组下标 $[i + 1, i + k]$,对应区间和为 $sum[i + k] - sum[i]$
Java 代码:
```Java
class Solution {
public int[] decrypt(int[] code, int k) {
int n = code.length;
int[] ans = new int[n];
if (k == 0) return ans;
int[] sum = new int[n * 2 + 10];
for (int i = 1; i <= 2 * n; i++) sum[i] += sum[i - 1] + code[(i - 1) % n];
for (int i = 1; i <= n; i++) {
if (k < 0) ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1];
else ans[i - 1] = sum[i + k] - sum[i];
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
vector<int> decrypt(vector<int>& code, int k) {
int n = code.size();
vector<int> ans(n);
if (k == 0) return ans;
vector<long long> sum((n + 1) * 2, 0);
for (int i = 1; i <= 2 * n; ++i) sum[i] = sum[i - 1] + code[(i - 1) % n];
for (int i = 1; i <= n; ++i) {
if (k < 0) ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1];
else ans[i - 1] = sum[i + k] - sum[i];
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def decrypt(self, code: List[int], k: int) -> List[int]:
n = len(code)
ans = [0] * n
if k == 0:
return ans
sum = [0] * (2 * n + 10)
for i in range(1, 2 * n + 1):
sum[i] = sum[i - 1] + code[(i - 1) % n]
for i in range(1, n + 1):
if k < 0:
ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1]
else:
ans[i - 1] = sum[i + k] - sum[i]
return ans
```
TypeScript 代码:
```TypeScript
function decrypt(code: number[], k: number): number[] {
const n = code.length
const ans = new Array<number>(n).fill(0)
if (k == 0) return ans
const sum = new Array<number>(2 * n + 10).fill(0)
for (let i = 1; i <= 2 * n; i++) sum[i] = sum[i - 1] + code[(i - 1) % n]
for (let i = 1; i <= n; i++) {
if (k < 0) ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1]
else ans[i - 1] = sum[i + k] - sum[i]
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1652` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1651-1660/1656. 设计有序流（简单）.md | 1656. 设计有序流 | https://leetcode.cn/problems/design-an-ordered-stream/solution/by-ac_oier-5pe8/ | 简单 | [
"模拟"
] | 有 `n` 个 `(id, value)` 对,其中 `id` 是 `1` 到 `n` 之间的一个整数,`value` 是一个字符串。不存在 `id` 相同的两个 `(id, value)` 对。
设计一个流,以任意顺序获取 `n` 个 `(id, value)` 对,并在多次调用时按 `id` 递增的顺序返回一些值。
实现 `OrderedStream` 类:
* `OrderedStream(int n)` 构造一个能接收 `n` 个值的流,并将当前指针 `ptr` 设为 `1` 。
* `String[] insert(int id, String value)` 向流中存储新的 `(id, value)` 对。存储后:
* 如果流存储有 `id = ptr` 的 `(id, value)` 对,则找出从 `id = ptr` 开始的 最长 `id` 连续递增序列 ,并 按顺序 返回与这些 `id` 关联的值的列表。然后,将 `ptr` 更新为最后那个 `id + 1` 。
* 否则,返回一个空列表。
示例:
```
输入
["OrderedStream", "insert", "insert", "insert", "insert", "insert"]
[[5], [3, "ccccc"], [1, "aaaaa"], [2, "bbbbb"], [5, "eeeee"], [4, "ddddd"]]
输出
[null, [], ["aaaaa"], ["bbbbb", "ccccc"], [], ["ddddd", "eeeee"]]
解释
OrderedStream os= new OrderedStream(5);
os.insert(3, "ccccc"); // 插入 (3, "ccccc"),返回 []
os.insert(1, "aaaaa"); // 插入 (1, "aaaaa"),返回 ["aaaaa"]
os.insert(2, "bbbbb"); // 插入 (2, "bbbbb"),返回 ["bbbbb", "ccccc"]
os.insert(5, "eeeee"); // 插入 (5, "eeeee"),返回 []
os.insert(4, "ddddd"); // 插入 (4, "ddddd"),返回 ["ddddd", "eeeee"]
```
提示:
* $1 <= n <= 1000$
* $1 <= id <= n$
* $value.length = 5$
* `value` 仅由小写字母组成
* 每次调用 `insert` 都会使用一个唯一的 `id`
* 恰好调用 `n` 次 `insert` | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class OrderedStream {
String[] ss = new String[1010];
int idx, n;
public OrderedStream(int _n) {
Arrays.fill(ss, "");
idx = 1; n = _n;
}
public List<String> insert(int key, String value) {
ss[key] = value;
List<String> ans = new ArrayList<>();
while (ss[idx].length() == 5) ans.add(ss[idx++]);
return ans;
}
}
```
TypeScript 代码:
```TypeScript
class OrderedStream {
ss: string[]
idx: number; n: number;
constructor(_n: number) {
this.idx = 1; this.n = _n;
this.ss = new Array<string>(1010).fill("")
}
insert(key: number, value: string): string[] {
this.ss[key] = value
const ans = new Array<string>()
while (this.ss[this.idx].length == 5) ans.push(this.ss[this.idx++])
return ans
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 加餐
**加餐一道近期笔试题 : [近期面试原题(简单计算几何运用)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492965&idx=1&sn=d0f2b13578e8b61891fbd7f9d1693695)🎉 🎉** | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1656` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1651-1660/1657. 确定两个字符串是否接近（中等）.md | 1657. 确定两个字符串是否接近 | https://leetcode.cn/problems/determine-if-two-strings-are-close/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-feae/ | 中等 | [
"模拟"
] | 如果可以使用以下操作从一个字符串得到另一个字符串,则认为两个字符串 接近 :
* 操作 1:交换任意两个 现有 字符。
* 例如,`abcde -> aecdb`
* 操作 2:将一个 现有 字符的每次出现转换为另一个 现有 字符,并对另一个字符执行相同的操作。
* 例如,`aacabb -> bbcbaa`(所有 `a` 转化为 `b` ,而所有的 `b` 转换为 `a`)
你可以根据需要对任意一个字符串多次使用这两种操作。
给你两个字符串,`word1` 和 `word2`。如果 `word1` 和 `word2` 接近 ,就返回 `true`;否则,返回 `false`。
示例 1:
```
输入:word1 = "abc", word2 = "bca"
输出:true
解释:2 次操作从 word1 获得 word2 。
执行操作 1:"abc" -> "acb"
执行操作 1:"acb" -> "bca"
```
示例 2:
```
输入:word1 = "a", word2 = "aa"
输出:false
解释:不管执行多少次操作,都无法从 word1 得到 word2 ,反之亦然。
```
示例 3:
```
输入:word1 = "cabbba", word2 = "abbccc"
输出:true
解释:3 次操作从 word1 获得 word2 。
执行操作 1:"cabbba" -> "caabbb"
执行操作 2:"caabbb" -> "baaccc"
执行操作 2:"baaccc" -> "abbccc"
```
示例 4:
```
输入:word1 = "cabbba", word2 = "aabbss"
输出:false
解释:不管执行多少次操作,都无法从 word1 得到 word2 ,反之亦然。
```
提示:
* $1 <= word1.length, word2.length <= 10^5$
* `word1` 和 `word2` 仅包含小写英文字母 | ### 模拟
两类操作都不会凭空产生或删除字符,而仅仅是对字符进行互换。
由于操作 `1` 和 `2` 都不限次数,因此我们只需检查「字符种类是否相同」和「字符频次是否相等」,即可得出两字符串是否接近的结论。
具体的,由于 `s1` 和 `s2` 都仅包含小写字母,因此可以创建两个大小为 `26` 的数组 `c1` 和 `c2` 分别对两字符串进行词频统计。
随后进行合法性检查:
1. 字符种类是否相同:若存在某个字符仅在 `s1` 或 `s2` 中出现过,两字符串必不接近,返回 `False`
2. 字符频次是否相等:对 `c1` 和 `c2` 进行排序,并逐项检查,若存在 `c1[i] != c2[i]`,说明存在词频为 `c1[i]` 的字符种类数在 `s1` 和 `s2` 间并不相等,返回 `False`
若上述两项检查无误,说明两字符串接近,返回 `True`。
Java 代码:
```Java
class Solution {
public boolean closeStrings(String s1, String s2) {
int[] c1 = new int[26], c2 = new int[26];
for (char c : s1.toCharArray()) c1[c - 'a']++;
for (char c : s2.toCharArray()) c2[c - 'a']++;
for (int i = 0; i < 26; i++) {
if (c1[i] + c2[i] == 0) continue;
if (c1[i] == 0 || c2[i] == 0) return false;
}
Arrays.sort(c1); Arrays.sort(c2);
for (int i = 0; i < 26; i++) {
if (c1[i] != c2[i]) return false;
}
return true;
}
}
```
Python 代码:
```Python
class Solution:
def closeStrings(self, s1: str, s2: str) -> bool:
c1, c2 = [0] * 26, [0] * 26
for c in s1:
c1[ord(c) - ord('a')] += 1
for c in s2:
c2[ord(c) - ord('a')] += 1
for i in range(26):
if c1[i] + c2[i] == 0:
continue
if c1[i] == 0 or c2[i] == 0:
return False
c1.sort()
c2.sort()
for i in range(26):
if c1[i] != c2[i]:
return False
return True
```
C++ 代码:
```C++
class Solution {
public:
bool closeStrings(string s1, string s2) {
vector<int> c1(26, 0), c2(26, 0);
for (char c : s1) c1[c - 'a']++;
for (char c : s2) c2[c - 'a']++;
for (int i = 0; i < 26; i++) {
if (c1[i] + c2[i] == 0) continue;
if (c1[i] == 0 || c2[i] == 0) return false;
}
sort(c1.begin(), c1.end());
sort(c2.begin(), c2.end());
for (int i = 0; i < 26; i++) {
if (c1[i] != c2[i]) return false;
}
return true;
}
};
```
TypeScirpt 代码:
```TypeScript
function closeStrings(s1: string, s2: string): boolean {
const c1: number[] = Array(26).fill(0);
const c2: number[] = Array(26).fill(0);
for (const c of s1) c1[c.charCodeAt(0) - 'a'.charCodeAt(0)]++;
for (const c of s2) c2[c.charCodeAt(0) - 'a'.charCodeAt(0)]++;
for (let i = 0; i < 26; i++) {
if (c1[i] + c2[i] === 0) continue;
if (c1[i] === 0 || c2[i] === 0) return false;
}
c1.sort((a, b) => a - b);
c2.sort((a, b) => a - b);
for (let i = 0; i < 26; i++) {
if (c1[i] !== c2[i]) return false;
}
return true;
};
```
* 时间复杂度:统计词频复杂度为 $O(n + m)$;排序复杂度为 $O(C\log{C})$,其中 $C = 26$ 为字符集大小,进行合法性检查复杂度为 $O(C)$。整体复杂度为 $O(n + m + C\log{C})$
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1657` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1662. 检查两个字符串数组是否相等（简单）.md | 1662. 检查两个字符串数组是否相等 | https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent/solution/by-ac_oier-h0l6/ | 简单 | [
"模拟",
"双指针"
] | 给你两个字符串数组 `word1` 和 `word2`。如果两个数组表示的字符串相同,返回 `true` ;否则,返回 `false` 。
数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。
示例 1:
```
输入:word1 = ["ab", "c"], word2 = ["a", "bc"]
输出:true
解释:
word1 表示的字符串为 "ab" + "c" -> "abc"
word2 表示的字符串为 "a" + "bc" -> "abc"
两个字符串相同,返回 true
```
示例 2:
```
输入:word1 = ["a", "cb"], word2 = ["ab", "c"]
输出:false
```
示例 3:
```
输入:word1 = ["abc", "d", "defg"], word2 = ["abcddefg"]
输出:true
```
提示:
* $1 <= word1.length, word2.length <= 10^3$
* $1 <= word1[i].length, word2[i].length <= 10^3$
* $1 <= sum(word1[i].length), sum(word2[i].length) <= 10^3$
* `word1[i]` 和 `word2[i]` 由小写字母组成 | ### 双指针
将 `word1` 和 `word2` 的长度记为 $n$ 和 $m$。
题目本质是要我们比较两个数组扁平化后的字符串是否相同。
使用变量 `i` 和 `j` 代表当前处理到哪个 $word1[i]$ 和 $word2[j]$,使用变量 `p` 和 `q` 代表当前比较到 $word1[i]$ 和 $word2[j]$ 的哪一位。
最后根据是否能顺利比较完返回相应答案。
Java 代码:
```Java
class Solution {
public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
int n = word1.length, m = word2.length;
int i = 0, j = 0, p = 0, q = 0;
while (i < n && j < m) {
if (word1[i].charAt(p++) != word2[j].charAt(q++)) return false;
if (p == word1[i].length()) {
i++; p = 0;
}
if (q == word2[j].length()) {
j++; q = 0;
}
}
return i == n && j == m;
}
}
```
TypeScript 代码:
```TypeScript
function arrayStringsAreEqual(word1: string[], word2: string[]): boolean {
const n = word1.length, m = word2.length
let i = 0, j = 0, p = 0, q = 0
while (i < n && j < m) {
if (word1[i][p++] != word2[j][q++]) return false
if (p == word1[i].length) {
i++; p = 0
}
if (q == word2[j].length) {
j++; q = 0
}
}
return i == n && j == m
}
```
Python 代码:
```Python
class Solution:
def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:
n, m = len(word1), len(word2)
i, j, p, q = 0, 0, 0, 0
while i < n and j < m:
if word1[i][p] != word2[j][q]:
return False
p, q = p + 1, q + 1
if p == len(word1[i]):
i, p = i + 1, 0
if q == len(word2[j]):
j, q = j + 1, 0
return i == n and j == m
```
* 时间复杂度:$O(\sum_{i = 0}^{n - 1}word1[i].length + \sum_{j = 0}^{m - 1}word2[j].length)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1662` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1668. 最大重复子字符串（简单）.md | 1668. 最大重复子字符串 | https://leetcode.cn/problems/maximum-repeating-substring/solution/by-ac_oier-xjhn/ | 简单 | [
"动态规划",
"序列 DP",
"字符串哈希"
] | 给你一个字符串 `sequence`,如果字符串 `word` 连续重复 `k` 次形成的字符串是 `sequence` 的一个子字符串,那么单词 `word` 的 重复值为 `k` 。
单词 `word` 的 最大重复值 是单词 `word` 在 `sequence` 中最大的重复值。如果 `word` 不是 `sequence` 的子串,那么重复值 `k` 为 `0` 。
给你一个字符串 `sequence` 和 `word` ,请你返回 最大重复值 `k` 。
示例 1:
```
输入:sequence = "ababc", word = "ab"
输出:2
解释:"abab" 是 "ababc" 的子字符串。
```
示例 2:
```
输入:sequence = "ababc", word = "ba"
输出:1
解释:"ba" 是 "ababc" 的子字符串,但 "baba" 不是 "ababc" 的子字符串。
```
示例 3:
```
输入:sequence = "ababc", word = "ac"
输出:0
解释:"ac" 不是 "ababc" 的子字符串。
```
提示:
* $1 <= sequence.length <= 100$
* $1 <= word.length <= 100$
* `sequence` 和 `word` 都只包含小写英文字母。 | ### 序列 DP
为了方便,我们记 `sequence` 为 `ss`,记 `word` 为 `pp`,将两者长度分别记为 `n` 和 `m`。
同时我们调整「字符串」以及「将要用到的动规数组」的下标从 $1$ 开始。
这是一道入门级的「序列 DP」运用题,容易想到 **定义 $f[i]$ 为了考虑以 `ss[i]` 结尾时的最大重复值**。
不失一般性考虑 $f[i]$ 该如何转移:由于 `pp` 的长度已知,每次转移 $f[i]$ 时我们可以从 `ss` 中截取 **以 $ss[i]$ 为结尾,长度为 $m$ 的后缀字符串** `sub` 并与 `pp` 匹配,若两者相等,说明 `sub` 贡献了大小为 $1$ 的重复度,同时该重复度可累加在 $f[i - m]$ 上(好好回想我们的状态定义),即有状态转移方程:$f[i] = f[i - m] + 1$。
最终所有 $f[i]$ 的最大值即为答案。
Java 代码:
```Java
class Solution {
public int maxRepeating(String ss, String pp) {
int n = ss.length(), m = pp.length(), ans = 0;
int[] f = new int[n + 10];
for (int i = 1; i <= n; i++) {
if (i - m < 0) continue;
if (ss.substring(i - m, i).equals(pp)) f[i] = f[i - m] + 1;
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function maxRepeating(ss: string, pp: string): number {
let n = ss.length, m = pp.length, ans = 0
const f = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) {
if (i - m < 0) continue
if (ss.substr(i - m, i) == pp) f[i] = f[i - m] + 1
ans = Math.max(ans, f[i])
}
return ans
}
```
Python 代码:
```Python
class Solution:
def maxRepeating(self, ss: str, pp: str) -> int:
n, m, ans = len(ss), len(pp), 0
f = [0] * (n + 10)
for i in range(1, n + 1):
if i - m < 0:
continue
if ss[i - m:i] == pp:
f[i] = f[i - m] + 1
ans = max(ans, f[i])
return ans
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n)$
---
### 字符串哈希
解法一的转移瓶颈在于:每次需要花费 $O(m)$ 的复杂度来生成子串,并进行字符串比较。
该过程可用「字符串哈希」进行优化:将 `ss` 和 `pp` 进行拼接得到完整字符串,并计算完整字符串的哈希数组和次方数组。随后从前往后检查 `ss`,若「某个以 $ss[i]$ 结尾长度为 `m` 的后缀字符串哈希值」与「 `pp` 字符串的哈希值」相等,说明找到了前驱状态值 $f[i - m]$,可进行转移。
我们通过 $O(n + m)$ 复杂度预处理了字符串哈希,将转移过程中「复杂度为 $O(m)$ 的子串截取与字符串比较」替换成了「复杂度为 $O(1)$ 的数值对比」,整体复杂度从 $O(n \times m)$ 下降到 $O(n + m)$。
> **不了解「字符串哈希」的同学可见前置 🧀 : [字符串哈希入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489813&idx=1&sn=7f3bc18ca390d85b17655f7164d8e660)。里面详解字符串哈希基本原理以及哈希冲突简单处理方式**
Java 代码:
```Java
class Solution {
public int maxRepeating(String ss, String pp) {
int n = ss.length(), m = pp.length(), ans = 0;
int[] f = new int[n + 10];
String s = ss + pp;
int P = 1313131, N = s.length();
long[] h = new long[N + 10], p = new long[N + 10];
p[0] = 1;
for (int i = 1; i <= N; i++) {
h[i] = h[i - 1] * P + s.charAt(i - 1);
p[i] = p[i - 1] * P;
}
long phash = h[N] - h[N - m] * p[m];
for (int i = 1; i <= n; i++) {
if (i - m < 0) continue;
long cur = h[i] - h[i - m] * p[m];
if (cur == phash) f[i] = f[i - m] + 1;
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
Python 代码:
```Python
class Solution:
def maxRepeating(self, ss: str, pp: str) -> int:
n, m, ans = len(ss), len(pp), 0
f = [0] * (n + 10)
s = ss + pp
P, N, MOD = 131, len(s), 987654321
h, p = [0] * (N + 10), [0] * (N + 10)
p[0] = 1
for i in range(1, N + 1):
h[i] = (h[i - 1] * P + ord(s[i - 1])) % MOD
p[i] = (p[i - 1] * P) % MOD
phash = (h[N] - h[N - m] * p[m]) % MOD
for i in range(1, n + 1):
if i - m < 0:
continue
cur = (h[i] - h[i - m] * p[m]) % MOD
if cur == phash:
f[i] = f[i - m] + 1
ans = max(ans, f[i])
return ans
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$
---
### 总结
这里简单说下「线性 DP」和「序列 DP」的区别。
线性 DP 通常强调「状态转移所依赖的前驱状态」是由给定数组所提供的,即拓扑序是由原数组直接给出。更大白话来说就是通常有 $f[i][...]$ 依赖于 $f[i - 1][...]$。
这就限定了线性 DP 的复杂度是简单由「状态数量(或者说是维度数)」所决定。
序列 DP 通常需要结合题意来寻找前驱状态,即需要自身寻找拓扑序关系(例如本题,需要自己结合题意来找到可转移的前驱状态 $f[i - m]$)。
这就限定了序列 DP 的复杂度是由「状态数 + 找前驱」的复杂度所共同决定。也直接导致了序列 DP 有很多玩法,往往能够结合其他知识点出题,来优化找前驱这一操作,通常是利用某些性质,或是利用数据结构进行优化。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1668` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1669. 合并两个链表（中等）.md | 1669. 合并两个链表 | https://leetcode.cn/problems/merge-in-between-linked-lists/solutions/2538688/gong-shui-san-xie-jian-dan-lian-biao-ti-4k20i/ | 中等 | [
"链表"
] | 给你两个链表 `list1` 和 `list2`,它们包含的元素分别为 `n` 个和 `m` 个。
请你将 `list1` 中下标从 `a` 到 `b` 的全部节点都删除,并将 `list2` 接在被删除节点的位置。
下图中蓝色边和节点展示了操作后的结果:
请你返回结果链表的头指针。
示例 1:
```
输入:list1 = [0,1,2,3,4,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]
输出:[0,1,2,1000000,1000001,1000002,5]
解释:我们删除 list1 中下标为 3 和 4 的两个节点,并将 list2 接在该位置。上图中蓝色的边和节点为答案链表。
```
示例 2:
```
输入:list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]
输出:[0,1,1000000,1000001,1000002,1000003,1000004,6]
解释:上图中蓝色的边和节点为答案链表。
```
提示:
* $3 <= list1.length <= 10^4$
* $1 <= a <= b < list1.length - 1$
* $1 <= list2.length <= 10^4$ | ### 模拟
根据题意进行模拟即可。
使用两个变量 `A` 和 `B` 分别指向 `list1` 中两个断联的位置,分别将 `A` 指向 `list2` 的开头,将 `list2` 的 `next` 指针指向 `B`。
Java 代码:
```Java
class Solution {
public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
ListNode ans = list1;
ListNode A = null, B = null;
while (--a > 0 && --b > 0) list1 = list1.next;
A = list1;
while (b-- > 0) list1 = list1.next;
B = list1;
A.next = list2;
while (list2.next != null) list2 = list2.next;
list2.next = B.next;
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function mergeInBetween(list1: ListNode | null, a: number, b: number, list2: ListNode | null): ListNode | null {
const ans = list1
let A = null, B = null
while (--a > 0 && --b > 0) list1 = list1.next
A = list1
while (b-- > 0) list1 = list1.next
B = list1
A.next = list2
while (list2.next != null) list2 = list2.next
list2.next = B.next
return ans
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1699` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1661-1670/1670. 设计前中后队列（中等）.md | 1670. 设计前中后队列 | https://leetcode.cn/problems/design-front-middle-back-queue/solutions/2544779/gong-shui-san-xie-qing-xi-gao-xiao-de-qu-o0eq/ | 中等 | [
"数据结构",
"双端队列",
"队列",
"链表"
] | 请你设计一个队列,支持在前,中,后三个位置的 `push` 和 `pop` 操作。
请你完成 `FrontMiddleBack` 类:
* `FrontMiddleBack()` 初始化队列。
* `void pushFront(int val)` 将 `val` 添加到队列的 最前面 。
* `void pushMiddle(int val)` 将 `val` 添加到队列的 正中间 。
* `void pushBack(int val)` 将 `val` 添加到队里的 最后面 。
* `int popFront()` 将最前面的元素从队列中删除并返回值,如果删除之前队列为空,那么返回 `-1`。
* `int popMiddle()` 将正中间的元素从队列中删除并返回值,如果删除之前队列为空,那么返回 `-1`。
* `int popBack()` 将 最后面 的元素从队列中删除并返回值,如果删除之前队列为空,那么返回 `-1`。
请注意当有 两个 中间位置的时候,选择靠前面的位置进行操作。比方说:
* 将 `6` 添加到 `[1, 2, 3, 4, 5]` 的中间位置,结果数组为 `[1, 2, 6, 3, 4, 5]`。
* 从 `[1, 2, 3, 4, 5, 6]` 的中间位置弹出元素,返回 `3`,数组变为 `[1, 2, 4, 5, 6]`。
示例 1:
```
输入:
["FrontMiddleBackQueue", "pushFront", "pushBack", "pushMiddle", "pushMiddle", "popFront", "popMiddle", "popMiddle", "popBack", "popFront"]
[[], [1], [2], [3], [4], [], [], [], [], []]
输出:
[null, null, null, null, null, 1, 3, 4, 2, -1]
解释:
FrontMiddleBackQueue q = new FrontMiddleBackQueue();
q.pushFront(1); // [1]
q.pushBack(2); // [1, 2]
q.pushMiddle(3); // [1, 3, 2]
q.pushMiddle(4); // [1, 4, 3, 2]
q.popFront(); // 返回 1 -> [4, 3, 2]
q.popMiddle(); // 返回 3 -> [4, 2]
q.popMiddle(); // 返回 4 -> [2]
q.popBack(); // 返回 2 -> []
q.popFront(); // 返回 -1 -> [] (队列为空)
```
提示:
* $1 <= val <= 10^9$
* 最多调用 $1000$ 次 `pushFront`, `pushMiddle`, `pushBack`, `popFront`, `popMiddle` 和 `popBack`。 | ### 双端队列
只要求在头部或尾部高效插入/弹出元素的话,容易联想到双端队列。
还需要考虑往中间插入/弹出元素的话,会想到使用两个双端队列。
将两个双端队列分别称为 `l` 和 `r`,把 `l` 和 `r` 拼接起来就是完整元素列表:
由于双端队列本身支持 $O(1)$ 首尾操作,问题的关键在于如何确保涉及 `Middle` 操作的高效性。
我们可以设计一个 `update` 方法,用于确保两队列的相对平衡:
* 当元素总个数为偶数时,确保两队列元素相等
* 当元素总个数为奇数时,确保 `r` 队列比 `l` 队列元素多一个
如此一来,当我们需要往 `Middle` 插入元素时,始终往 `l` 的尾部插入即可;而当需要读取 `Middle` 位置元素时,根据两队列的元素个数关系决定是从 `l` 的尾部还是从 `r` 的头部取元素。
以下是对上述代码中几个操作的简短实现说明:
* `pushFront`:将元素添加到 `l` 队列的头部,调用 `update` 保持队列平衡
* `pushMiddle`:将元素添加到 `l` 队列的尾部,调用 `update` 保持队列平衡
* `pushBack`:将元素添加到 `r` 队列的尾部,调用 `update` 保持队列平衡
* `popFront`:若 `l` 队列不为空,从 `l` 队列的头部弹出一个元素;否则,从 `r` 队列的头部弹出一个元素(当且仅当元素个数为 $1$ 时,队列 `l` 为空,唯一元素在队列 `r` 中),调用 `update` 保持队列平衡
* `popMiddle`:若 `l` 队列和 `r` 队列的大小相等,则从 `l` 队列的尾部弹出一个元素;否则,从 `r` 队列的头部弹出一个元素。调用 `update` 保持队列平衡
* `popBack`:从 `r` 队列的尾部弹出一个元素,调用 `update` 保持队列平衡
双端队列的实现,可通过「数组 + 首尾坐标指针」来实现。为方便大家理清脉络,先使用语言自带的 `Deque` 实现一版。
Java 代码(`Deque` 版):
```Java
class FrontMiddleBackQueue {
Deque<Integer> l = new ArrayDeque<>(1010), r = new ArrayDeque<>(1010);
public void pushFront(int val) {
l.addFirst(val);
update();
}
public void pushMiddle(int val) {
l.addLast(val);
update();
}
public void pushBack(int val) {
r.addLast(val);
update();
}
public int popFront() {
if (l.size() + r.size() == 0) return -1;
int ans = l.size() != 0 ? l.pollFirst() : r.pollFirst();
update();
return ans;
}
public int popMiddle() {
if (l.size() + r.size() == 0) return -1;
int ans = l.size() == r.size() ? l.pollLast() : r.pollFirst();
update();
return ans;
}
public int popBack() {
if (l.size() + r.size() == 0) return -1;
int ans = r.pollLast();
update();
return ans;
}
void update() {
while (l.size() > r.size()) r.addFirst(l.pollLast());
while (r.size() - l.size() > 1) l.addLast(r.pollFirst());
}
}
```
看过 `Deque` 实现版本,考虑如何使用数组实现。
各类操作的总调用次数最多为 $1000$ 次,我们可创建大小为 $2010$ 的数组,并从下标 $1010$(接近中间位置)开始进行存储,这样无论是从前还是往后存数都不会越界。
使用 `lhe` 和 `lta` 代表队列 `l` 的头部和尾部坐标,使用 `rhe` 和 `rta` 代表队列 `r` 的头部和尾部坐标,所有坐标初始值均为 $1100$。
需要注意的是,`ta`(无论是 `lta` 还是 `rta`)是严格指向尾部,因此如果要往尾部插数的话,需要先对指针自增(移到下一个空闲位置),再赋值;而 `he`(无论是 `lhe` 还是 `rhe`)是指向实际队列头部的前一位置,需要先赋值再前移。当 `he = ta` 代表队列为空。
Java 代码(纯数组版):
```Java
class FrontMiddleBackQueue {
int[] l = new int[2010], r = new int[2010];
int lhe = 1010, lta = 1010, rhe = 1010, rta = 1010;
public void pushFront(int val) {
l[lhe--] = val;
update();
}
public void pushMiddle(int val) {
l[++lta] = val;
update();
}
public void pushBack(int val) {
r[++rta] = val;
update();
}
public int popFront() {
if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
int ans = getSize(lhe, lta) != 0 ? l[++lhe] : r[++rhe];
update();
return ans;
}
public int popMiddle() {
if (getSize(lhe, lta) + getSize(rhe, rta) == 0) return -1;
int ans = getSize(lhe, lta) == getSize(rhe, rta) ? l[lta--] : r[++rhe];
update();
return ans;
}
public int popBack() {
if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
int ans = r[rta--];
update();
return ans;
}
int getSize(int he, int ta) {
return ta - he;
}
void update() {
while (getSize(lhe, lta) > getSize(rhe, rta)) r[rhe--] = l[lta--];
while (getSize(rhe, rta) - getSize(lhe, lta) > 1) l[++lta] = r[++rhe];
}
}
```
C++ 代码:
```C++
class FrontMiddleBackQueue {
public:
int l[2010], r[2010], lhe = 1010, lta = 1010, rhe = 1010, rta = 1010;
void pushFront(int val) {
l[lhe--] = val;
update();
}
void pushMiddle(int val) {
l[++lta] = val;
update();
}
void pushBack(int val) {
r[++rta] = val;
update();
}
int popFront() {
if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
int ans = getSize(lhe, lta) != 0 ? l[++lhe] : r[++rhe];
update();
return ans;
}
int popMiddle() {
if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
int ans = getSize(lhe, lta) == getSize(rhe, rta) ? l[lta--] : r[++rhe];
update();
return ans;
}
int popBack() {
if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;
int ans = r[rta--];
update();
return ans;
}
int getSize(int he, int ta) {
return ta - he;
}
void update() {
while (getSize(lhe, lta) > getSize(rhe, rta)) r[rhe--] = l[lta--];
while (getSize(rhe, rta) - getSize(lhe, lta) > 1) l[++lta] = r[++rhe];
}
};
```
Python 代码:
```Python
class FrontMiddleBackQueue:
def __init__(self):
self.l, self.r = [0] * 2010, [0] * 2010
self.r = [0] * 2010
self.lhe, self.lta, self.rhe, self.rta = 1010, 1010, 1010, 1010
def pushFront(self, val: int) -> None:
self.l[self.lhe] = val
self.lhe -= 1
self.update()
def pushMiddle(self, val: int) -> None:
self.lta += 1
self.l[self.lta] = val
self.update()
def pushBack(self, val: int) -> None:
self.rta += 1
self.r[self.rta] = val
self.update()
def popFront(self) -> int:
if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:
return -1
if self.getSize(self.lhe, self.lta) != 0:
self.lhe += 1
ans = self.l[self.lhe]
else:
self.rhe += 1
ans = self.r[self.rhe]
self.update()
return ans
def popMiddle(self) -> int:
if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:
return -1
if self.getSize(self.lhe, self.lta) == self.getSize(self.rhe, self.rta):
ans = self.l[self.lta]
self.lta -= 1
else:
self.rhe += 1
ans = self.r[self.rhe]
self.update()
return ans
def popBack(self) -> int:
if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:
return -1
ans = self.r[self.rta]
self.rta -= 1
self.update()
return ans
def getSize(self, he: int, ta: int) -> int:
return ta - he
def update(self) -> None:
while self.getSize(self.lhe, self.lta) > self.getSize(self.rhe, self.rta):
self.r[self.rhe] = self.l[self.lta]
self.rhe -= 1
self.lta -= 1
while self.getSize(self.rhe, self.rta) - self.getSize(self.lhe, self.lta) > 1:
self.lta += 1
self.rhe += 1
self.l[self.lta] = self.r[self.rhe]
```
TypeScript 代码:
```TypeScript
class FrontMiddleBackQueue {
private l: number[];
private r: number[];
private lhe: number;
private lta: number;
private rhe: number;
private rta: number;
constructor() {
this.l = Array(2010).fill(0), this.r = Array(2010).fill(0);
this.lhe = 1010, this.lta = 1010, this.rhe = 1010, this.rta = 1010;
}
pushFront(val: number): void {
this.l[this.lhe--] = val;
this.update();
}
pushMiddle(val: number): void {
this.l[++this.lta] = val;
this.update();
}
pushBack(val: number): void {
this.r[++this.rta] = val;
this.update();
}
popFront(): number {
if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;
const ans = this.getSize(this.lhe, this.lta) != 0 ? this.l[++this.lhe] : this.r[++this.rhe];
this.update();
return ans;
}
popMiddle(): number {
if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;
const ans = this.getSize(this.lhe, this.lta) == this.getSize(this.rhe, this.rta) ? this.l[this.lta--] : this.r[++this.rhe];
this.update();
return ans;
}
popBack(): number {
if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;
const ans = this.r[this.rta--];
this.update();
return ans;
}
private getSize(he: number, ta: number): number {
return ta - he;
}
private update(): void {
while (this.getSize(this.lhe, this.lta) > this.getSize(this.rhe, this.rta)) this.r[this.rhe--] = this.l[this.lta--];
while (this.getSize(this.rhe, this.rta) - this.getSize(this.lhe, this.lta) > 1) this.l[++this.lta] = this.r[++this.rhe];
}
}
```
* 时间复杂度:所有操作复杂度均为 $O(1)$
* 空间复杂度:$O(n)$
---
### 进阶
更进一步,使用双向链表并与实现 `update` 类似效果,维护 `Middle` 位置的元素节点,同样可实现 $O(1)$ 各项操作,你能完成吗?
与纯数组版相比,使用链表好处在于可严格按需创建。
```Java
class Node {
Node prev, next;
int val;
Node (int _val) {
val = _val;
}
}
class FrontMiddleBackQueue {
Node he, ta, mid;
int lsz, rsz;
public FrontMiddleBackQueue() {
he = new Node(-1); ta = new Node(-1);
he.next = ta; ta.prev = he;
mid = ta;
lsz = rsz = 0;
}
public void pushFront(int val) {
Node cur = new Node(val);
cur.next = he.next;
cur.prev = he;
he.next.prev = cur;
he.next = cur;
lsz++;
update();
}
public void pushMiddle(int val) {
Node cur = new Node(val);
cur.next = mid;
cur.prev = mid.prev;
mid.prev.next = cur;
mid.prev = cur;
lsz++;
update();
}
public void pushBack(int val) {
Node cur = new Node(val);
cur.next = ta;
cur.prev = ta.prev;
ta.prev.next = cur;
ta.prev = cur;
rsz++;
update();
}
public int popFront() {
if (lsz + rsz == 0) return -1;
int ans = he.next.val;
he.next.next.prev = he;
he.next = he.next.next;
lsz--;
update();
return ans;
}
public int popMiddle() {
if (lsz + rsz == 0) return -1;
Node realMid = null;
if (lsz == rsz) {
realMid = mid.prev;
lsz--;
} else {
realMid = mid;
mid = mid.next;
rsz--;
}
int ans = realMid.val;
realMid.prev.next = realMid.next;
realMid.next.prev = realMid.prev;
realMid = realMid.next;
update();
return ans;
}
public int popBack() {
if (lsz + rsz == 0) return -1;
int ans = ta.prev.val;
ta.prev.prev.next = ta;
ta.prev = ta.prev.prev;
rsz--;
update();
return ans;
}
void update() {
while (lsz > rsz) {
mid = mid.prev;
lsz--; rsz++;
}
while (rsz - lsz > 1) {
mid = mid.next;
lsz++; rsz--;
}
if (lsz + rsz == 1) mid = ta.prev;
if (lsz + rsz == 0) mid = ta;
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1670` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1671-1680/1672. 最富有客户的资产总量（简单）.md | 1672. 最富有客户的资产总量 | https://leetcode-cn.com/problems/richest-customer-wealth/solution/by-ac_oier-ai19/ | 简单 | [
"模拟"
] | 给你一个 $m * n$ 的整数网格 `accounts`,其中 $accounts[i][j]$ 是第 $i$ 位客户在第 $j$ 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
示例 1:
```
输入:accounts = [[1,2,3],[3,2,1]]
输出:6
解释:
第 1 位客户的资产总量 = 1 + 2 + 3 = 6
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
两位客户都是最富有的,资产总量都是 6 ,所以返回 6 。
```
示例 2:
```
输入:accounts = [[1,5],[7,3],[3,5]]
输出:10
解释:
第 1 位客户的资产总量 = 6
第 2 位客户的资产总量 = 10
第 3 位客户的资产总量 = 8
第 2 位客户是最富有的,资产总量是 10
```
示例 3:
```
输入:accounts = [[2,8,7],[7,1,3],[1,9,5]]
输出:17
```
提示:
* $m == accounts.length$
* $n == accounts[i].length$
* $1 <= m, n <= 50$
* $1 <= accounts[i][j] <= 100$ | ### 模拟
根据题意进行模拟即可。
```Java
class Solution {
public int maximumWealth(int[][] accounts) {
int m = accounts.length, n = accounts[0].length, ans = 0;
for (int i = 0; i < m; i++) {
int cur = 0;
for (int j = 0; j < n; j++) cur += accounts[i][j];
ans = Math.max(ans, cur);
}
return ans;
}
}
```
* 时间复杂度:$O(m * n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1672` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1671-1680/1678. 设计 Goal 解析器（简单）.md | 1678. 设计 Goal 解析器 | https://leetcode.cn/problems/goal-parser-interpretation/solution/by-ac_oier-a00y/ | 简单 | [
"模拟"
] | 请你设计一个可以解释字符串 `command` 的 `Goal` 解析器 。
`command` 由 `"G"`、`"()"` 或 `"(al)"` 按某种顺序组成。`Goal` 解析器会将 `"G"` 解释为字符串 `"G"`、`"()"` 解释为字符串 `"o"` ,`"(al)"` 解释为字符串 `"al"` 。
然后,按原顺序将经解释得到的字符串连接成一个字符串。
给你字符串 `command`,返回 `Goal` 解析器 对 `command` 的解释结果。
示例 1:
```
输入:command = "G()(al)"
输出:"Goal"
解释:Goal 解析器解释命令的步骤如下所示:
G -> G
() -> o
(al) -> al
最后连接得到的结果是 "Goal"
```
示例 2:
```
输入:command = "G()()()()(al)"
输出:"Gooooal"
```
示例 3:
```
输入:command = "(al)G(al)()()G"
输出:"alGalooG"
```
提示:
* $1 <= command.length <= 100$
* `command` 由 `"G"`、`"()"` 或 `"(al)"` 按某种顺序组成 | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public String interpret(String s) {
StringBuilder sb = new StringBuilder();
int n = s.length();
for (int i = 0; i < n; ) {
if (s.charAt(i) == 'G') {
sb.append('G'); i++;
} else if (i + 1 < n && s.charAt(i + 1) == ')') {
sb.append('o'); i += 2;
} else {
sb.append("al"); i += 4;
}
}
return sb.toString();
}
}
```
TypeScript 代码:
```TypeScript
function interpret(s: string): string {
const n = s.length
let ans = ''
for (let i = 0; i < n; ) {
if (s[i] == 'G') {
ans += 'G'; i++
} else if (i + 1 < n && s[i + 1] == ')') {
ans += 'o'; i += 2
} else {
ans += 'al'; i += 4
}
}
return ans
}
```
Python 代码:
```Python
class Solution:
def interpret(self, s: str) -> str:
ans = ''
n, i = len(s), 0
while i < n:
if s[i] == 'G':
ans, i = ans + s[i], i + 1
elif i + 1 < n and s[i + 1] == ')':
ans, i = ans + 'o', i + 2
else:
ans, i = ans + 'al', i + 4
return ans
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1678` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1681-1690/1684. 统计一致字符串的数目（简单）.md | 1684. 统计一致字符串的数目 | https://leetcode.cn/problems/count-the-number-of-consistent-strings/solution/by-ac_oier-j2kj/ | 简单 | [
"模拟",
"位运算"
] | 给你一个由不同字符组成的字符串 `allowed` 和一个字符串数组 `words`。如果一个字符串的每一个字符都在 `allowed` 中,就称这个字符串是 一致字符串 。
请你返回 `words` 数组中 一致字符串 的数目。
示例 1:
```
输入:allowed = "ab", words = ["ad","bd","aaab","baa","badab"]
输出:2
解释:字符串 "aaab" 和 "baa" 都是一致字符串,因为它们只包含字符 'a' 和 'b' 。
```
示例 2:
```
输入:allowed = "abc", words = ["a","b","c","ab","ac","bc","abc"]
输出:7
解释:所有字符串都是一致的。
```
示例 3:
```
输入:allowed = "cad", words = ["cc","acd","b","ba","bac","bad","ac","d"]
输出:4
解释:字符串 "cc","acd","ac" 和 "d" 是一致字符串。
```
提示:
* $1 <= words.length <= 10^4$
* $1 <= allowed.length <= 26$
* $1 <= words[i].length <= 10$
* `allowed` 中的字符 互不相同 。
* `words[i]` 和 `allowed` 只包含小写英文字母。 | ### 模拟
根据题意模拟即可:为了快速判断某个字符是否在 `allowed` 出现过,我们可以使用 `Set` 结构、定长数组或是一个 `int` 变量(搭配位运算)来对 `allowed` 中出现的字符进行转存。
随后遍历所有的 $words[i]$,统计符合要求的字符串个数。
Java 代码:
```Java
class Solution {
public int countConsistentStrings(String allowed, String[] words) {
boolean[] hash = new boolean[26];
for (char c : allowed.toCharArray()) hash[c - 'a'] = true;
int ans = 0;
out:for (String s : words) {
for (char c : s.toCharArray()) {
if (!hash[c - 'a']) continue out;
}
ans++;
}
return ans;
}
}
```
Java 代码:
```Java
class Solution {
public int countConsistentStrings(String allowed, String[] words) {
int hash = 0, ans = 0;
for (char c : allowed.toCharArray()) hash |= (1 << (c - 'a'));
out:for (String s : words) {
for (char c : s.toCharArray()) {
if (((hash >> (c - 'a')) & 1) == 0) continue out;
}
ans++;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function countConsistentStrings(allowed: string, words: string[]): number {
const sset = new Set<string>()
for (const c of allowed) sset.add(c)
let ans = 0
out:for (const s of words) {
for (const c of s) {
if (!sset.has(c)) continue out
}
ans++
}
return ans
}
```
TypeScript 代码:
```TypeScript
function countConsistentStrings(allowed: string, words: string[]): number {
let hash = 0, ans = 0
for (const c of allowed) hash |= (1 << (c.charCodeAt(0) - 'a'.charCodeAt(0)))
out:for (const s of words) {
for (const c of s) {
if (((hash >> (c.charCodeAt(0) - 'a'.charCodeAt(0))) & 1) == 0) continue out
}
ans++
}
return ans
}
```
Python3 代码:
```Python3
class Solution:
def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
sset = set([c for c in allowed])
ans = 0
for s in words:
ok = True
for c in s:
if c not in sset:
ok = False
break
ans += 1 if ok else 0
return ans
```
Python3 代码:
```Python3
class Solution:
def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
num, ans = 0, 0
for c in allowed:
num |= (1 << (ord(c) - ord('a')))
for s in words:
ok = True
for c in s:
if not (num >> (ord(c) - ord('a')) & 1):
ok = False
break
ans += 1 if ok else 0
return ans
```
* 时间复杂度:$O(m + \sum_{i = 0}^{n - 1}words[i].length)$,其中 $m$ 为 `allowed` 长度,$n$ 为 `words` 长度
* 空间复杂度:$O(m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1684` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1681-1690/1688. 比赛中的配对次数（简单）.md | 1688. 比赛中的配对次数 | https://leetcode-cn.com/problems/count-of-matches-in-tournament/solution/gong-shui-san-xie-jian-dan-nao-jin-ji-zh-cx7a/ | 简单 | [
"模拟"
] | 给你一个整数 `n` ,表示比赛中的队伍数。比赛遵循一种独特的赛制:
* 如果当前队伍数是 偶数 ,那么每支队伍都会与另一支队伍配对。总共进行 `n / 2` 场比赛,且产生 `n / 2` 支队伍进入下一轮。
* 如果当前队伍数为 奇数 ,那么将会随机轮空并晋级一支队伍,其余的队伍配对。总共进行 `(n - 1) / 2` 场比赛,且产生 `(n - 1) / 2 + 1` 支队伍进入下一轮。
返回在比赛中进行的配对次数,直到决出获胜队伍为止。
示例 1:
```
输入:n = 7
输出:6
解释:比赛详情:
- 第 1 轮:队伍数 = 7 ,配对次数 = 3 ,4 支队伍晋级。
- 第 2 轮:队伍数 = 4 ,配对次数 = 2 ,2 支队伍晋级。
- 第 3 轮:队伍数 = 2 ,配对次数 = 1 ,决出 1 支获胜队伍。
总配对次数 = 3 + 2 + 1 = 6
```
示例 2:
```
输入:n = 14
输出:13
解释:比赛详情:
- 第 1 轮:队伍数 = 14 ,配对次数 = 7 ,7 支队伍晋级。
- 第 2 轮:队伍数 = 7 ,配对次数 = 3 ,4 支队伍晋级。
- 第 3 轮:队伍数 = 4 ,配对次数 = 2 ,2 支队伍晋级。
- 第 4 轮:队伍数 = 2 ,配对次数 = 1 ,决出 1 支获胜队伍。
总配对次数 = 7 + 3 + 2 + 1 = 13
```
提示:
* 1 <= n <= 200 | ### 脑筋急转弯
这个题不能浪费了,吃个鱼啥的吧 🤣
* [全鱼宴 I](https://leetcode-cn.com/problems/largest-number-at-least-twice-of-others/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-8179/)
* [全鱼宴 II](https://leetcode-cn.com/problems/calculate-money-in-leetcode-bank/solution/quan-yu-yan-di-er-can-jian-dan-de-shu-xu-zux4/)
共有 $n$ 支队伍,每场比赛淘汰一支,最终剩下一支冠军队,即有 $n - 1$ 支队伍需要通过 $n - 1$ 场比赛来被淘汰。
**代码(感谢 [@5cm/s 🌸](/u/megurine/) 烟花总提供的所有语言版本 🤣 🤣 ):**
```Java
class Solution {
public int numberOfMatches(int n) {
return n - 1;
}
}
```
-
```C++
class Solution {
public:
int numberOfMatches(int n) {
return n - 1;
}
};
```
-
```Python
class Solution(object):
def numberOfMatches(self, n):
return n - 1
```
-
```Python3
class Solution:
def numberOfMatches(self, n: int) -> int:
return n - 1
```
-
```C
int numberOfMatches(int n){
return n - 1;
}
```
-
```C#
public class Solution {
public int NumberOfMatches(int n) {
return n - 1;
}
}
```
-
```JS
var numberOfMatches = function(n) {
return n - 1
};
```
-
```TS
function numberOfMatches(n: number): number {
return n - 1
};
```
-
```Ruby
def number_of_matches(n)
n - 1
end
```
-
```Swift
class Solution {
func numberOfMatches(_ n: Int) -> Int {
return n - 1
}
}
```
-
```Go
func numberOfMatches(n int) int {
return n - 1
}
```
-
```Scala
object Solution {
def numberOfMatches(n: Int): Int = {
return n - 1
}
}
```
-
```Kotlin
class Solution {
fun numberOfMatches(n: Int): Int {
return n - 1
}
}
```
-
```Rust
impl Solution {
pub fn number_of_matches(n: i32) -> i32 {
n - 1
}
}
```
-
```PHP
class Solution {
function numberOfMatches($n) {
return $n - 1;
}
}
```
-
```Racket
(define/contract (number-of-matches n)
(-> exact-integer? exact-integer?)
(- n 1)
)
```
-
```Erlang
-spec number_of_matches(N :: integer()) -> integer().
number_of_matches(N) ->
N - 1.
```
-
```Elixir
defmodule Solution do
@spec number_of_matches(n :: integer) :: integer
def number_of_matches(n) do
n - 1
end
end
```
* 时间复杂度:$O(1)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1688` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1691. 堆叠长方体的最大高度（困难）.md | 1691. 堆叠长方体的最大高度 | https://acoier.com/2022/12/10/1691.%20%E5%A0%86%E5%8F%A0%E9%95%BF%E6%96%B9%E4%BD%93%E7%9A%84%E6%9C%80%E5%A4%A7%E9%AB%98%E5%BA%A6%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/ | 困难 | [
"排序",
"序列 DP",
"动态规划"
] | 给你 `n` 个长方体 `cuboids`,其中第 `i` 个长方体的长宽高表示为 $cuboids[i] = [width_i, length_i, height_i]$(下标从 `0` 开始)。
请你从 `cuboids` 选出一个「子集」,并将它们堆叠起来。
如果 $width_{i} <= width_{j}$ 且 $length_{i} <= length_{j}$ 且 $height_{i} <= height_{j}$ ,你就可以将长方体 `i` 堆叠在长方体 `j` 上。你可以通过旋转把长方体的长宽高重新排列,以将它放在另一个长方体上。
返回 堆叠长方体 `cuboids` 可以得到的 最大高度 。
示例 1:
```
输入:cuboids = [[50,45,20],[95,37,53],[45,23,12]]
输出:190
解释:
第 1 个长方体放在底部,53x37 的一面朝下,高度为 95 。
第 0 个长方体放在中间,45x20 的一面朝下,高度为 50 。
第 2 个长方体放在上面,23x12 的一面朝下,高度为 45 。
总高度是 95 + 50 + 45 = 190 。
```
示例 2:
```
输入:cuboids = [[38,25,45],[76,35,3]]
输出:76
解释:
无法将任何长方体放在另一个上面。
选择第 1 个长方体然后旋转它,使 35x3 的一面朝下,其高度为 76 。
```
示例 3:
```
输入:cuboids = [[7,11,17],[7,17,11],[11,7,17],[11,17,7],[17,7,11],[17,11,7]]
输出:102
解释:
重新排列长方体后,可以看到所有长方体的尺寸都相同。
你可以把 11x7 的一面朝下,这样它们的高度就是 17 。
堆叠长方体的最大高度为 6 * 17 = 102 。
```
提示:
* $n = cuboids.length$
* $1 <= n <= 100$
* $1 <= width_{i}, length_{i}, height_{i} <= 100$ | ### 排序 + 序列 DP
定义 $f[i]$ 为考虑前 $i$ 个箱子,且必须使用到第 $i$ 个箱子的最大高度。
不难发现,$f[i]$ 至少为当前箱子中的最大边长,而所有 $f[i]$ 的最大值即是答案。
由于题目规定了只有三边都不超过盒子 `j` 的盒子 `i` 才能放置在上面,因此我们可以先对三边总和进行「降序」排序。
这样当我们处理到盒子 `i` 时,所有能够位于盒子 `i` 底部的盒子 `j` 均位于 `i` 左侧,我们可以通过枚举 $j \in [0, i - 1]$ 的盒子,用满足条件的盒子 `j` 来更新 $f[i]$,即有 $f[i] = \max(f[j] + height_i)$。
实现上,当我们在判定某个盒子 `j` 是否能够位于盒子 `i` 的底部时,并不需要枚举两盒子的旋转情况,可以在进行 DP 之前先对所有盒子进行排序预处理(按照升序排序)。
Java 代码:
```Java
class Solution {
public int maxHeight(int[][] cs) {
int n = cs.length;
for (int i = 0; i < n; i++) Arrays.sort(cs[i]);
Arrays.sort(cs, (a, b)->(b[0]+b[1]+b[2])-(a[0]+a[1]+a[2]));
int ans = 0;
int[] f = new int[n + 10];
for (int i = 0; i < n; i++) {
f[i] = cs[i][2];
for (int j = 0; j < i; j++) {
if (cs[j][0] >= cs[i][0] && cs[j][1] >= cs[i][1] && cs[j][2] >= cs[i][2]) {
f[i] = Math.max(f[i], f[j] + cs[i][2]);
}
}
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxHeight(vector<vector<int>>& cs) {
int n = cs.size();
for(int i = 0; i < n; i++) sort(cs[i].begin(), cs[i].end());
sort(cs.begin(), cs.end(), [](vector<int>& a, vector<int>& b){
return a[0] + a[1] + a[2] > b[0] + b[1] + b[2];
});
vector<int> f(n + 10, 0);
int ans = 0;
for(int i = 0; i < n; i++) {
f[i] = cs[i][2];
for(int j = 0; j < i; j++) {
if(cs[j][0] >= cs[i][0] && cs[j][1] >= cs[i][1] && cs[j][2] >= cs[i][2]) {
f[i] = max(f[i], f[j] + cs[i][2]);
}
}
ans = max(ans, f[i]);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maxHeight(self, cs):
n = len(cs)
for i in range(n):
cs[i].sort()
cs.sort(key=lambda x: -(x[0]+x[1]+x[2]))
f, ans = [0] * (n+10), 0
for i in range(n):
f[i] = cs[i][2]
for j in range(i):
if cs[j][0] >= cs[i][0] and cs[j][1] >= cs[i][1] and cs[j][2] >= cs[i][2]:
f[i] = max(f[i], f[j] + cs[i][2])
ans = max(ans, f[i])
return ans
```
TypeScript 代码:
```TypeScript
function maxHeight(cs: number[][]): number {
const n = cs.length;
for (let i = 0; i < n; i++) cs[i].sort((a, b) => a-b);
cs.sort((a, b) => (b[0] + b[1] + b[2]) - (a[0] + a[1] + a[2]));
const f: number[] = new Array(n + 10).fill(0);
let ans = 0;
for (let i = 0; i < n; i++) {
f[i] = cs[i][2];
for (let j = 0; j < i; j++) {
if (cs[j][0] >= cs[i][0] && cs[j][1] >= cs[i][1] && cs[j][2] >= cs[i][2]) {
f[i] = Math.max(f[i], f[j] + cs[i][2]);
}
}
ans = Math.max(ans, f[i]);
}
return ans;
};
```
* 时间复杂度:$O(n^2)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1691` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1694. 重新格式化电话号码（简单）.md | 1694. 重新格式化电话号码 | https://leetcode.cn/problems/reformat-phone-number/solution/by-ac_oier-82xq/ | 简单 | [
"模拟"
] | 给你一个字符串形式的电话号码 `number`。`number` 由数字、空格 `' '`、和破折号 `'-'` 组成。
请你按下述方式重新格式化电话号码。
首先,删除 所有的空格和破折号。
其次,将数组从左到右 每 `3` 个一组 分块,直到 剩下 `4` 个或更少数字。剩下的数字将按下述规定再分块:
* `2` 个数字:单个含 `2` 个数字的块。
* `3` 个数字:单个含 `3` 个数字的块。
* `4` 个数字:两个分别含 `2` 个数字的块。
最后用破折号将这些块连接起来。注意,重新格式化过程中 不应该 生成仅含 `1` 个数字的块,并且 最多 生成两个含 `2` 个数字的块。
返回格式化后的电话号码。
示例 1:
```
输入:number = "1-23-45 6"
输出:"123-456"
解释:数字是 "123456"
步骤 1:共有超过 4 个数字,所以先取 3 个数字分为一组。第 1 个块是 "123" 。
步骤 2:剩下 3 个数字,将它们放入单个含 3 个数字的块。第 2 个块是 "456" 。
连接这些块后得到 "123-456" 。
```
示例 2:
```
输入:number = "123 4-567"
输出:"123-45-67"
解释:数字是 "1234567".
步骤 1:共有超过 4 个数字,所以先取 3 个数字分为一组。第 1 个块是 "123" 。
步骤 2:剩下 4 个数字,所以将它们分成两个含 2 个数字的块。这 2 块分别是 "45" 和 "67" 。
连接这些块后得到 "123-45-67" 。
```
示例 3:
```
输入:number = "123 4-5678"
输出:"123-456-78"
解释:数字是 "12345678" 。
步骤 1:第 1 个块 "123" 。
步骤 2:第 2 个块 "456" 。
步骤 3:剩下 2 个数字,将它们放入单个含 2 个数字的块。第 3 个块是 "78" 。
连接这些块后得到 "123-456-78" 。
```
示例 4:
```
输入:number = "12"
输出:"12"
```
示例 5:
```
输入:number = "--17-5 229 35-39475 "
输出:"175-229-353-94-75"
```
提示:
* $2 <= number.length <= 100$
* `number` 由数字和字符 `'-'` 及 `' '` 组成。
* `number` 中至少含 `2` 个数字。 | ### 模拟
根据题意进行模拟即可。
Java 代码:
```Java
class Solution {
public String reformatNumber(String number) {
String s = number.replace(" ", "").replace("-", "");
int n = s.length();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i += 3) {
if (sb.length() != 0) sb.append("-");
if (i + 5 > n) {
if (i + 3 >= n) sb.append(s.substring(i));
else sb.append(s.substring(i, i + 2)).append("-").append(s.substring(i + 2));
break;
}
sb.append(s.substring(i, i + 3));
}
return sb.toString();
}
}
```
Python 代码:
```Python
class Solution:
def reformatNumber(self, number: str) -> str:
s = number.replace(" ", "").replace("-", "")
n, idx = len(s), 0
ans = ""
while idx < n:
if ans:
ans += "-"
if idx + 5 > n:
ans += s[idx:] if idx + 3 >= n else f"{s[idx:idx+2]}-{s[idx+2:]}"
break
ans += s[idx:idx+3]
idx += 3
return ans
```
TypeScript 代码:
```TypeScript
function reformatNumber(number: string): string {
let s = ""
for (let c of number) {
if (c != " " && c != "-") s += c
}
const n = s.length
let ans = ""
for (let i = 0; i < n; i += 3) {
if (ans.length != 0) ans += "-"
if (i + 5 > n) {
if (i + 3 >= n) ans += s.substring(i)
else ans += s.substring(i, i + 2) + "-" + s.substring(i + 2)
break
}
ans += s.substring(i, i + 3)
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1694` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1697. 检查边长度限制的路径是否存在（困难）.md | 1697. 检查边长度限制的路径是否存在 | https://acoier.com/2022/12/14/1697.%20%E6%A3%80%E6%9F%A5%E8%BE%B9%E9%95%BF%E5%BA%A6%E9%99%90%E5%88%B6%E7%9A%84%E8%B7%AF%E5%BE%84%E6%98%AF%E5%90%A6%E5%AD%98%E5%9C%A8%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/ | 困难 | [
"并查集",
"排序",
"双指针"
] | 给你一个 `n` 个点组成的无向图边集 `edgeList`,其中 $edgeList[i] = [u_i, v_i, dis_i]$ 表示点 $u_i$ 和点 $v_i$ 之间有一条长度为 $dis_i$ 的边。请注意,两个点之间可能有 超过一条边 。
给你一个查询数组 `queries`,其中 $queries[j] = [p_j, q_j, limit_j]$ ,你的任务是对于每个查询 $queries[j]$ ,判断是否存在从 $p_j$ 到 $q_j$ 的路径,且这条路径上的每一条边都 严格小于 $limit_j$ 。
请你返回一个 布尔数组 `answer`,其中 `answer.length == queries.length`,当 $queries[j]$ 的查询结果为 `true` 时, `answer` 第 `j` 个值为 `true` ,否则为 `false` 。
示例 1:
```
输入:n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
输出:[false,true]
解释:上图为给定的输入数据。注意到 0 和 1 之间有两条重边,分别为 2 和 16 。
对于第一个查询,0 和 1 之间没有小于 2 的边,所以我们返回 false 。
对于第二个查询,有一条路径(0 -> 1 -> 2)两条边都小于 5 ,所以这个查询我们返回 true 。
```
示例 2:
```
输入:n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]
输出:[true,false]
解释:上图为给定数据。
```
提示:
* $2 <= n <= 10^5$
* $1 <= edgeList.length, queries.length <= 10^5$
* $edgeList[i].length == 3$
* $queries[j].length == 3$
* $0 <= u_i, v_i, p_j, q_j <= n - 1$
* $u_i != v_i$
* $p_j != q_j$
* $1 <= dis_i, limit_j <= 10^9$
* 两个点之间可能有多条边。 | ### 排序 + 并查集 + 双指针
为了方便,我们将点数记为 `n`,边数记为 `m`,询问数量记为 `k`,将 `edgeList` 简化为 `es`,将 `queries` 简化为 `qs`。
对于点边数量都在 $10^5$,同时询问次数也在 $10^5$ 的问题,不可能对于每个询问执行最短路算法,尤其还需考虑边权限制。
**对于一个询问 $(a, b, limit)$ 而言,等价于问我们使用所有边权小于 `limit` 的边,能否使得 `a` 和 `b` 两点联通。**
关于回答连通性问题,容易想到并查集。同时我们可以通过「调整回答询问的顺序」来降低复杂度(避免重复重置并查集和添加某些边),即转换为离线问题来处理。
> 何为离线问题?预先知道所有询问,能够通过调整回答询问的顺序,来降低算法复杂度。同时不同询问相互独立,不会因为调整询问顺序,对每个询问的结果造成影响。例如莫队算法。
具体的,我们可以对边集 `es` 和所有询问 `qs` 分别按照「边权」以及「限制」排升序。为了排序后,仍能知道当前询问的原编号,我们要将所有的 `qs[i]` 转换为四元组。
随后从前往后处理每个询问 `qs[i] = (a, b, t, idx)`,同时使用变量 `j` 来记录当前处理到的边。在查询 `a` 和 `b` 是否连通前,先将边集 `es` 中所有所有边权小于 `t` 的边应用到并查集上,从而实现每次 `ans[idx] = query(a, b)` 查询到的是原图中所有边权小于限制值 `t` 的子图。
Java 代码:
```Java
class Solution {
static int N = 100010;
static int[] p = new int[N];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void union(int a, int b) {
p[find(a)] = p[find(b)];
}
boolean query(int a, int b) {
return find(a) == find(b);
}
public boolean[] distanceLimitedPathsExist(int n, int[][] es, int[][] _qs) {
for (int i = 0; i < n; i++) p[i] = i;
int m = es.length, k = _qs.length;
int[][] qs = new int[k][4];
for (int i = 0; i < k; i++) qs[i] = new int[]{_qs[i][0], _qs[i][1], _qs[i][2], i};
Arrays.sort(qs, (a,b)->a[2]-b[2]);
Arrays.sort(es, (a,b)->a[2]-b[2]);
boolean[] ans = new boolean[k];
for (int i = 0, j = 0; i < k; i++) {
int a = qs[i][0], b = qs[i][1], t = qs[i][2], idx = qs[i][3];
while (j < m && es[j][2] < t) {
union(es[j][0], es[j][1]);
j++;
}
ans[idx] = query(a, b);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int p[100010];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void unite(int a, int b) {
p[find(a)] = find(b);
}
bool query(int a, int b) {
return find(a) == find(b);
}
vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& es, vector<vector<int>>& qs) {
for (int i = 0; i < n; i++) p[i] = i;
int m = es.size(), k = qs.size();
vector<vector<int>> qss(k, vector<int>(4, 0));
for (int i = 0; i < k; i++) qss[i] = {qs[i][0], qs[i][1], qs[i][2], i};
sort(qss.begin(), qss.end(), [](const vector<int>& a, const vector<int>& b) {
return a[2] < b[2];
});
sort(es.begin(), es.end(), [](const vector<int>& a, const vector<int>& b) {
return a[2] < b[2];
});
vector<bool> ans(k, false);
for (int i = 0, j = 0; i < k; i++) {
int a = qss[i][0], b = qss[i][1], t = qss[i][2], idx = qss[i][3];
while (j < m && es[j][2] < t) {
unite(es[j][0], es[j][1]);
j++;
}
ans[idx] = query(a, b);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def distanceLimitedPathsExist(self, n: int, es: List[List[int]], _qs: List[List[int]]) -> List[bool]:
p = [i for i in range(n)]
def find(x):
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(a, b):
p[find(a)] = p[find(b)]
def query(a, b):
return find(a) == find(b)
m, k = len(es), len(_qs)
qs = [(a, b, c, i) for i, (a, b, c) in enumerate(_qs)]
es.sort(key=lambda x: x[2])
qs.sort(key=lambda x: x[2])
j = 0
ans = [False] * k
for i in range(k):
a, b, t, idx = qs[i]
while j < m and es[j][2] < t:
union(es[j][0], es[j][1])
j += 1
ans[idx] = query(a, b)
return ans
```
TypeScript 代码:
```TypeScript
function distanceLimitedPathsExist(n: number, es: number[][], _qs: number[][]): boolean[] {
const p = new Array<number>(n).fill(0)
for (let i = 0; i < n; i++) p[i] = i;
function find(x: number): number {
if (p[x] != x) p[x] = find(p[x])
return p[x]
}
function union(a: number, b: number): void {
p[find(a)] = p[find(b)]
}
function query(a: number, b: number): boolean {
return find(a) == find(b)
}
const m = es.length, k = _qs.length
const qs = []
for (let i = 0; i < k; i++) qs.push([_qs[i][0], _qs[i][1], _qs[i][2], i])
qs.sort((a, b)=>a[2]-b[2])
es.sort((a, b)=>a[2]-b[2])
const ans = new Array<boolean>(k).fill(false)
for (let i = 0, j = 0; i < k; i++) {
const a = qs[i][0], b = qs[i][1], t = qs[i][2], idx = qs[i][3]
while (j < m && es[j][2] < t) {
union(es[j][0], es[j][1])
j++
}
ans[idx] = query(a, b)
}
return ans
}
```
* 时间复杂度:初始化并查集的复杂度为 $O(n)$;对所有边进行排序复杂度为 $O(m\log{m})$;对所有询问进行排序复杂度为 $O(k\log{k})$;统计答案时使用双指针的方式将所有边运用到并查集上,整体复杂度为 $O(k + m)$。整体复杂度为 $O(n + m\log{m} + k\log{k})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1697` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1691-1700/1700. 无法吃午餐的学生数量（简单）.md | 1700. 无法吃午餐的学生数量 | https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch/solution/by-ac_oier-rvc3/ | 简单 | [
"模拟",
"计数",
"哈希表"
] | 学校的自助午餐提供圆形和方形的三明治,分别用数字 $0$ 和 $1$ 表示。所有学生站在一个队列里,每个学生要么喜欢圆形的要么喜欢方形的。
餐厅里三明治的数量与学生的数量相同。所有三明治都放在一个 栈 里,每一轮:
* 如果队列最前面的学生 喜欢 栈顶的三明治,那么会 拿走它 并离开队列。
* 否则,这名学生会 放弃这个三明治 并回到队列的尾部。
这个过程会一直持续到队列里所有学生都不喜欢栈顶的三明治为止。
给你两个整数数组 `students` 和 `sandwiches`,其中 `sandwiches[i]` 是栈里面第 `i` 个三明治的类型(`i = 0` 是栈的顶部), `students[j]` 是初始队列里第 `j` 名学生对三明治的喜好(`j = 0` 是队列的最开始位置)。请你返回无法吃午餐的学生数量。
示例 1:
```
输入:students = [1,1,0,0], sandwiches = [0,1,0,1]
输出:0
解释:
- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [1,0,0,1]。
- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [0,0,1,1]。
- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [0,1,1],三明治栈为 sandwiches = [1,0,1]。
- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [1,1,0]。
- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [1,0],三明治栈为 sandwiches = [0,1]。
- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [0,1]。
- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [1],三明治栈为 sandwiches = [1]。
- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [],三明治栈为 sandwiches = []。
所以所有学生都有三明治吃。
```
示例 2:
```
输入:students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]
输出:3
```
提示:
* $1 <= students.length, sandwiches.length <= 100$
* $students.length == sandwiches.length$
* `sandwiches[i]` 要么是 $0$ ,要么是 $1$ 。
* `students[i]` 要么是 $0$ ,要么是 $1$ 。 | ### 模拟
根据题意进行模拟即可 : 当学生遇到喜欢的种类会进行匹配,否则会轮到队列尾部,而面包则是一直停在栈顶位置等待匹配。
因此当且仅当栈顶的面包种类没有待匹配的学生种类与之相对应时,整个匹配过程结束。
Java 代码:
```Java
class Solution {
public int countStudents(int[] a, int[] b) {
int[] cnts = new int[2];
for (int x : a) cnts[x]++;
for (int i = 0; i < b.length; i++) {
if (--cnts[b[i]] == -1) return b.length - i;
}
return 0;
}
}
```
TypeScript 代码:
```TypeScript
function countStudents(a: number[], b: number[]): number {
const cnts = new Array<number>(2).fill(0)
for (const x of a) cnts[x]++
for (let i = 0; i < b.length; i++) {
if (--cnts[b[i]] == -1) return b.length - i
}
return 0
}
```
Python 代码:
```Python
class Solution:
def countStudents(self, a: List[int], b: List[int]) -> int:
cnts = Counter(a)
for i, x in enumerate(b):
if cnts[x] == 0:
return len(b) - i
cnts[x] -= 1
return 0
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$,其中 $C = 2$ 为种类数 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1700` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1704. 判断字符串的两半是否相似（简单）.md | 1704. 判断字符串的两半是否相似 | https://leetcode.cn/problems/determine-if-string-halves-are-alike/solution/by-ac_oier-u26p/ | 简单 | [
"模拟"
] | 给你一个偶数长度的字符串 `s` 。将其拆分成长度相同的两半,前一半为 `a` ,后一半为 `b` 。
两个字符串 相似 的前提是它们都含有相同数目的元音`('a','e','i','o','u','A','E','I','O','U')`。注意,`s` 可能同时含有大写和小写字母。
如果 `a` 和 `b` 相似,返回 `true`;否则,返回 `false` 。
示例 1:
```
输入:s = "book"
输出:true
解释:a = "bo" 且 b = "ok" 。a 中有 1 个元音,b 也有 1 个元音。所以,a 和 b 相似。
```
示例 2:
```
输入:s = "textbook"
输出:false
解释:a = "text" 且 b = "book" 。a 中有 1 个元音,b 中有 2 个元音。因此,a 和 b 不相似。
注意,元音 o 在 b 中出现两次,记为 2 个。
```
提示:
* $2 <= s.length <= 1000$
* `s.length` 是偶数
* `s` 由 大写和小写 字母组成 | ### 模拟
根据题意进行模拟即可。
为了快速判断某个字符是否为元音字母,起始先对所有元音字母进行转存。
随后对 `s` 进行遍历,使用单个变量 `cnt` 记录元音字母数量。若当前遍历到的 `c` 所在下标属于前半部分,对 `cnt` 进行自增操作,若属于后半部分,对 `cnt` 进行自减操作。
当处理完整个 `s` 后满足 `cnt = 0` 说明前半部分元音字母和后半部分元音字母数量相同。
Java 代码:
```Java
class Solution {
public boolean halvesAreAlike(String s) {
Set<Character> set = new HashSet<>();
for (char c : "aeiouAEIOU".toCharArray()) set.add(c);
int n = s.length(), cnt = 0;
for (int i = 0; i < n; i++) {
if (!set.contains(s.charAt(i))) continue;
cnt += i < n / 2 ? 1 : -1;
}
return cnt == 0;
}
}
```
TypeScript 代码:
```TypeScript
function halvesAreAlike(s: string): boolean {
let n = s.length, cnt = 0
const set = new Set<String>()
for (const c of "aeiouAEIOU") set.add(c)
for (let i = 0; i < n; i++) {
if (!set.has(s[i])) continue
cnt += i < n / 2 ? 1 : -1
}
return cnt == 0
}
```
Python 代码:
```Python
class Solution:
def halvesAreAlike(self, s: str) -> bool:
cnt = 0
ss = set('aeiouAEIOU')
for idx, c in enumerate(s):
if c not in ss:
continue
cnt += 1 if idx < len(s) / 2 else -1
return cnt == 0
```
* 时间复杂度:$O(C + n)$,其中 $C$ 为元音字母数量
* 空间复杂度:$O(C)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1704` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1705. 吃苹果的最大数目（中等）.md | 1705. 吃苹果的最大数目 | https://leetcode-cn.com/problems/maximum-number-of-eaten-apples/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-hfdy0/ | 中等 | [
"贪心",
"优先队列(堆)"
] | 有一棵特殊的苹果树,一连 `n` 天,每天都可以长出若干个苹果。
在第 `i` 天,树上会长出 `apples[i]` 个苹果,这些苹果将会在 `days[i]` 天后(也就是说,第 `i + days[i]` 天时)腐烂,变得无法食用。
也可能有那么几天,树上不会长出新的苹果,此时用 `apples[i] == 0` 且 `days[i] == 0` 表示。
你打算每天 最多 吃一个苹果来保证营养均衡。注意,你可以在这 n 天之后继续吃苹果。
给你两个长度为 `n` 的整数数组 `days` 和 `apples` ,返回你可以吃掉的苹果的最大数目。
示例 1:
```
输入:apples = [1,2,3,5,2], days = [3,2,1,4,2]
输出:7
解释:你可以吃掉 7 个苹果:
- 第一天,你吃掉第一天长出来的苹果。
- 第二天,你吃掉一个第二天长出来的苹果。
- 第三天,你吃掉一个第二天长出来的苹果。过了这一天,第三天长出来的苹果就已经腐烂了。
- 第四天到第七天,你吃的都是第四天长出来的苹果。
```
示例 2:
```
输入:apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]
输出:5
解释:你可以吃掉 5 个苹果:
- 第一天到第三天,你吃的都是第一天长出来的苹果。
- 第四天和第五天不吃苹果。
- 第六天和第七天,你吃的都是第六天长出来的苹果。
```
提示:
* $apples.length == n$
* $days.length == n$
* $1 <= n <= 2 * 10^4$
* $0 <= apples[i], days[i] <= 2 * 10^4$
* 只有在 `apples[i] = 0` 时,`days[i] = 0` 才成立 | ### 贪心 + 优先队列(堆)
这题是一道经典的结合优先队列(堆)的贪心题,与结合排序的贪心题一样,属于最为常见的贪心题型。
**直觉上,我们会觉得「优先吃掉最快过期的苹果」会是最优,而这个维护苹果过期的过程,可以使用「小根堆」来实现。**
苹果数量很大,但产生苹果的天数最多为 $2 * 10^4$,因此我们以二元组 `(最后食用日期, 当日产生苹果数量)` 的形式存入「小根堆」进行维护。
具体的,我们可以按照如下逻辑进行模拟(令 $n$ 为数组长度,$time$ 为当前时间,$ans$ 为吃到的苹果数量):
* 首先,如果「$time < n$」或者「堆不为空」,说明「还有苹果未被生成」或者「未必吃掉」,继续模拟;
* 在当日模拟中,如果「$time < n$」,说明当天有苹果生成,先将苹果 **以二元组 $(time + days[time] - 1, apples[time])$ 形式加入小根堆中**;
> 其中二元组表示 $(最后食用日期, 当日产生苹果数量)$,同时需要过滤 $apples[time] = 0$ 的情况。
* 然后尝试从堆中取出「最后食用日期」最早「可食用」的苹果 `cur`,如果堆顶元素已过期,则抛弃;
* 如果吃掉 `cur` 一个苹果后,仍有剩余,并且最后时间大于当前时间(尚未过期),将 `cur` 重新入堆;
* 循环上述逻辑,直到所有苹果出堆。
**直观感受往往会骗人,我们使用「归纳法 + 反证法」证明上述猜想的正确性**
假设使用上述吃法得到的苹果序列为 $(a_1, a_2, ... ,a_n)$,而真实最优解对应序列为 $(b_1, b_2, ..., b_m)$。
我们目的是证明 $n = m$,即吃掉苹果数量一致(贪心解是最优解的具体方案之一)。
起始,我们先证明边界成立,即 $b_1$ 可以为 $a_1$。
首先该替换操作必然不会使最优序列变长,否则就违背了最优解是长度最长的合法序列这一前提。
由于贪心解中每次总是取「过期时间最早的」苹果来吃,因此有 $a_1$ 过期时间小于等于 $b_1$ 过期时间,需要证明如果将最优解中的 $b_1$ 替换为 $a_1$,并不会影响整个序列的长度。
重点在与该操作是否会使得最优序列长度变短,这需要分情况讨论:
* $a_1$ 不存在与 $(b_2, b_3, ..., b_m)$ 当中,此时直接用 $a_1$ 替换 $b_1$ 自然不会对后面的序列产生影响,也就是说替换后,最优序列合法性仍有保证,同时长度不变,结果不会变差;
* $a_1$ 为 $(b_2, b_3, ..., b_m)$ 中的某个,假设为 $b_i = a_1$,由于 $b_i/a_1$ 在贪心解中的先出堆(过期时间最早),因此必然也有 $b_i/a_1$ 过期时间早于等于 $b_1$ 的过期时间,此时将 $b_1$ 放到 $b_i$ 的位置仍是合法(过期时间比 $b_i/a_1$ 要晚),即将 $b_1$ 和 $b_i/a_1$ 交换位置,最优序列合法性仍有保证,同时长度不变,结果不会变差。
当贪心解和最优解的首个位置决策相同(吃掉的苹果一样),下一位置决策所面临的条件完全相同,归纳推理所依赖的结构没有发生改变,上述分析同样成立。
也就是说,上述推理可以推广到最优解序列中的任意位置。
**至此,我们证明出了最优解可以调整为我们的贪心序列,同时长度不变,即贪心解为最优解的具体方案之一。**
代码:
```Java
class Solution {
public int eatenApples(int[] apples, int[] days) {
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]);
int n = apples.length, time = 0, ans = 0;
while (time < n || !q.isEmpty()) {
if (time < n && apples[time] > 0) q.add(new int[]{time + days[time] - 1, apples[time]});
while (!q.isEmpty() && q.peek()[0] < time) q.poll();
if (!q.isEmpty()) {
int[] cur = q.poll();
if (--cur[1] > 0 && cur[0] > time) q.add(cur);
ans++;
}
time++;
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为数组长度,最多有 $n$ 组苹果入堆/出堆。复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1705` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1706. 球会落何处（中等）.md | 1706. 球会落何处 | https://leetcode-cn.com/problems/where-will-the-ball-fall/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-jz6f/ | 中等 | [
"模拟"
] | 用一个大小为 `m x n` 的二维网格 $grid$ 表示一个箱子。你有 $n$ 颗球。箱子的顶部和底部都是开着的。
箱子中的每个单元格都有一个对角线挡板,跨过单元格的两个角,可以将球导向左侧或者右侧。
* 将球导向右侧的挡板跨过左上角和右下角,在网格中用 $1$ 表示。
* 将球导向左侧的挡板跨过右上角和左下角,在网格中用 $-1$ 表示。
在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。如果球恰好卡在两块挡板之间的 `"V"` 形图案,或者被一块挡导向到箱子的任意一侧边上,就会卡住。
返回一个大小为 $n$ 的数组 $answer$ ,其中 $answer[i]$ 是球放在顶部的第 $i$ 列后从底部掉出来的那一列对应的下标,如果球卡在盒子里,则返回 $-1$ 。
示例 1:
```
输入:grid = [[1,1,1,-1,-1],[1,1,1,-1,-1],[-1,-1,-1,1,1],[1,1,1,1,-1],[-1,-1,-1,-1,-1]]
输出:[1,-1,-1,-1,-1]
解释:示例如图:
b0 球开始放在第 0 列上,最终从箱子底部第 1 列掉出。
b1 球开始放在第 1 列上,会卡在第 2、3 列和第 1 行之间的 "V" 形里。
b2 球开始放在第 2 列上,会卡在第 2、3 列和第 0 行之间的 "V" 形里。
b3 球开始放在第 3 列上,会卡在第 2、3 列和第 0 行之间的 "V" 形里。
b4 球开始放在第 4 列上,会卡在第 2、3 列和第 1 行之间的 "V" 形里。
```
示例 2:
```
输入:grid = [[-1]]
输出:[-1]
解释:球被卡在箱子左侧边上。
```
示例 3:
```
输入:grid = [[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1],[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1]]
输出:[0,1,2,3,4,-1]
```
提示:
* $m == grid.length$
* $n == grid[i].length$
* $1 <= m, n <= 100$
* $grid[i][j]$ 为 $1$ 或 $-1$ | ### 模拟
数据范围只有 $100$,直接模拟每个球从顶部的某列出发,最终到底底部哪列即可(如果可以到达的话)。
我们使用 `r` 和 `c` 表示小球当前所处的位置,受重力影响,在不被卡住的情况下,`r` 会持续自增,直到到达底部,而 `c` 的变化,则是取决于当前挡板 `grid[r][c]` 的方向,若 `grid[r][c]` 为 $1$,则小球的下一个位置为 $(r + 1, c + 1)$;若 `grid[r][c]` 为 $-1$,则下一位置为 $(r + 1, c - 1)$,即可以统一表示为 $(r + 1, c + grid[r][c])$。当且仅当小球在本次移动过程中没被卡住,才能继续移动。即只有 $c + grid[r][c]$ 没有超过矩阵的左右边界(没有被边界卡住),或者 $grid[r][c]$ 和 $grid[r][c + grid[r][c]]$ 同向(不形成夹角),小球方能继续移动。
代码:
```Java
class Solution {
int m, n;
int[][] g;
public int[] findBall(int[][] grid) {
g = grid;
m = g.length; n = g[0].length;
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = getVal(i);
return ans;
}
int getVal(int x) {
int r = 0, c = x;
while (r < m) {
int ne = c + g[r][c];
if (ne < 0 || ne >= n) return -1;
if (g[r][c] != g[r][ne]) return -1;
r++; c = ne;
}
return c;
}
}
```
* 时间复杂度:$O(m * n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1706` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1707. 与数组中元素的最大异或值（困难）.md | 1707. 与数组中元素的最大异或值 | https://leetcode-cn.com/problems/maximum-xor-with-an-element-from-array/solution/gong-shui-san-xie-jie-zhe-ge-wen-ti-lai-lypqr/ | 困难 | [
"字典树",
"二分"
] | 给你一个由非负整数组成的数组 $nums$ 。另有一个查询数组 $queries$,其中 $queries[i] = [xi, mi]$ 。
第 $i$ 个查询的答案是 $x_i$ 和任何 $nums$ 数组中不超过 $m_i$ 的元素按位异或(XOR)得到的最大值。
换句话说,答案是 `max(nums[j] \{XOR} x_i)` ,其中所有 $j$ 均满足 $nums[j] <= m_i$ 。如果 $nums$ 中的所有元素都大于 $m_i$,最终答案就是 $-1$ 。
返回一个整数数组 $answer$ 作为查询的答案,其中 $answer.length == queries.length$ 且 $answer[i]$ 是第 $i$ 个查询的答案。
示例 1:
```
输入:nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]
输出:[3,3,7]
解释:
1) 0 和 1 是仅有的两个不超过 1 的整数。0 XOR 3 = 3 而 1 XOR 3 = 2 。二者中的更大值是 3 。
2) 1 XOR 2 = 3.
3) 5 XOR 2 = 7.
```
示例 2:
```
输入:nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]
输出:[15,-1,5]
```
提示:
* 1 <= nums.length, queries.length <= $10^5$
* queries[i].length == 2
* 0 <= nums[j], xi, mi <= $10^9$ | ### 基本分析
**在做本题之前,请先确保已经完成 [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/)。**
这种提前给定了所有询问的题目,我们可以运用离线思想(调整询问的回答顺序)进行求解。
对于本题有两种离线方式可以进行求解。
---
### 普通 Trie
第一种方法基本思路是:**不一次性地放入所有数,而是每次将需要参与筛选的数字放入 $Trie$,再进行与 [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/) 类似的贪心查找逻辑。**
具体的,我们可以按照下面的逻辑进行处理:
1. 对 `nums` 进行「从小到大」进行排序,对 `queries` 的第二维进行「从小到大」排序(排序前先将询问原本的下标映射关系存下来)。
2. 按照排序顺序处理所有的 `queries[i]`:
1. 在回答每个询问前,将小于等于 `queries[i][1]` 的数值存入 $Trie$。由于我们已经事先对 `nums` 进行排序,因此这个过程只需要维护一个在 `nums` 上有往右移动的指针即可。
2. 然后利用贪心思路,查询每个 `queries[i][0]` 所能找到的最大值是多少,计算异或和(此过程与 [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/) 一致)。
3. 找到当前询问在原询问序列的下标,将答案存入。
代码:
```Java
class Solution {
static int N = (int)1e5 * 32;
static int[][] trie = new int[N][2];
static int idx = 0;
public Solution() {
for (int i = 0; i <= idx; i++) {
Arrays.fill(trie[i], 0);
}
idx = 0;
}
void add(int x) {
int p = 0;
for (int i = 31; i >= 0; i--) {
int u = (x >> i) & 1;
if (trie[p][u] == 0) trie[p][u] = ++idx;
p = trie[p][u];
}
}
int getVal(int x) {
int ans = 0;
int p = 0;
for (int i = 31; i >= 0; i--) {
int a = (x >> i) & 1, b = 1 - a;
if (trie[p][b] != 0) {
p = trie[p][b];
ans = ans | (b << i);
} else {
p = trie[p][a];
ans = ans | (a << i);
}
}
return ans ^ x;
}
public int[] maximizeXor(int[] nums, int[][] qs) {
int m = nums.length, n = qs.length;
// 使用哈希表将原本的顺序保存下来
Map<int[], Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) map.put(qs[i], i);
// 将 nums 与 queries[x][1] 进行「从小到大」进行排序
Arrays.sort(nums);
Arrays.sort(qs, (a, b)->a[1]-b[1]);
int[] ans = new int[n];
int loc = 0; // 记录 nums 中哪些位置之前的数已经放入 Trie
for (int[] q : qs) {
int x = q[0], limit = q[1];
// 将小于等于 limit 的数存入 Trie
while (loc < m && nums[loc] <= limit) add(nums[loc++]);
if (loc == 0) {
ans[map.get(q)] = -1;
} else {
ans[map.get(q)] = getVal(x);
}
}
return ans;
}
}
```
* 时间复杂度:令 `nums` 的长度为 `m`,`qs` 的长度为 `n`。两者排序的复杂度为 $O(m\log{m})$ 和 $O(n\log{n})$;将所有数插入 $Trie$ 和从 $Trie$ 中查找的复杂度均为 $O(Len)$,$Len$ 为 $32$。
整体复杂度为 $O(m\log{m} + n\log{n} + (m + n) * Len)$ = $O(m * \max(\log{m}, Len) + n * \max(\log{n}, Len))$。
* 空间复杂度:$O(C)$。其中 $C$ 为常数,固定为 $1e5 * 32 * 2$。
---
### 计数 Trie & 二分
另外一个比较「增加难度」的做法是,将整个过程翻转过来:**一次性存入所有的 $Trie$ 中,然后每次将不再参与的数从 $Trie$ 中移除。相比于解法一,这就要求我们为 $Trie$ 增加一个「删除/计数」功能,并且需要实现二分来找到移除元素的上界下标是多少。**
具体的,我们可以按照下面的逻辑进行处理:
1. 对 `nums` 进行「从大到小」进行排序,对 `queries` 的第二维进行「从大到小」排序(排序前先将询问原本的下标映射关系存下来)。
2. 按照排序顺序处理所有的 `queries[i]`:
1. 在回答每个询问前,通过「二分」找到在 `nums` 中第一个满足「小于等于 `queries[i][1]` 的下标在哪」,然后将该下标之前的数从 $Trie$ 中移除。同理,这个过程我们需要使用一个指针来记录上一次删除的下标位置,避免重复删除。
2. 然后利用贪心思路,查询每个 `queries[i][0]` 所能找到的最大值是多少。注意这是要判断当前节点是否有被计数,如果没有则返回 $-1$。
3. 找到当前询问在原询问序列的下标,将答案存入。
代码:
```Java
class Solution {
static int N = (int)1e5 * 32;
static int[][] trie = new int[N][2];
static int[] cnt = new int[N];
static int idx = 0;
public Solution() {
for (int i = 0; i <= idx; i++) {
Arrays.fill(trie[i], 0);
cnt[i] = 0;
}
idx = 0;
}
// 往 Trie 存入(v = 1)/删除(v = -1) 某个数 x
void add(int x, int v) {
int p = 0;
for (int i = 31; i >= 0; i--) {
int u = (x >> i) & 1;
if (trie[p][u] == 0) trie[p][u] = ++idx;
p = trie[p][u];
cnt[p] += v;
}
}
int getVal(int x) {
int ans = 0;
int p = 0;
for (int i = 31; i >= 0; i--) {
int a = (x >> i) & 1, b = 1 - a;
if (cnt[trie[p][b]] != 0) {
p = trie[p][b];
ans = ans | (b << i);
} else if (cnt[trie[p][a]] != 0) {
p = trie[p][a];
ans = ans | (a << i);
} else {
return -1;
}
}
return ans ^ x;
}
public int[] maximizeXor(int[] nums, int[][] qs) {
int n = qs.length;
// 使用哈希表将原本的顺序保存下来
Map<int[], Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) map.put(qs[i], i);
// 对两者排降序
sort(nums);
Arrays.sort(qs, (a, b)->b[1]-a[1]);
// 将所有数存入 Trie
for (int i : nums) add(i, 1);
int[] ans = new int[n];
int left = -1; // 在 nums 中下标「小于等于」left 的值都已经从 Trie 中移除
for (int[] q : qs) {
int x = q[0], limit = q[1];
// 二分查找到待删除元素的右边界,将其右边界之前的所有值从 Trie 中移除。
int right = getRight(nums, limit);
for (int i = left + 1; i < right; i++) add(nums[i], -1);
left = right - 1;
ans[map.get(q)] = getVal(x);
}
return ans;
}
// 二分找到待删除的右边界
int getRight(int[] nums, int limit) {
int l = 0, r = nums.length - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] <= limit) {
r = mid;
} else {
l = mid + 1;
}
}
return nums[r] <= limit ? r : r + 1;
}
// 对 nums 进行降序排序(Java 没有 Api 直接支持对基本类型 int 排倒序,其他语言可忽略)
void sort(int[] nums) {
Arrays.sort(nums);
int l = 0, r = nums.length - 1;
while (l < r) {
int c = nums[r];
nums[r--] = nums[l];
nums[l++] = c;
}
}
}
```
* 时间复杂度:令 `nums` 的长度为 `m`,`qs` 的长度为 `n`,常数 $Len = 32$。两者排序的复杂度为 $O(m\log{m})$ 和 $O(n\log{n})$;将所有数插入 $Trie$ 的复杂度为 $O(m * Len)$;每个查询都需要经过「二分」找边界,复杂度为 $O(n\log{m})$;最坏情况下所有数都会从 $Trie$ 中被标记删除,复杂度为 $O(m * Len)$。
整体复杂度为 $O(m\log{m} + n\log{n} + n\log{m} + mLen)$ = $O(m * \max(\log{m}, Len) + n * \max(\log{m}, \log{n}))$。
* 空间复杂度:$O(C)$。其中 $C$ 为常数,固定为 $1e5 * 32 * 3$。
---
### 说明
这两种方法我都是采取「数组实现」,而且由于数据范围较大,都使用了 `static` 来优化大数组创建,具体的「优化原因」与「类实现 Trie 方式」可以在题解 [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/) 查看,这里不再赘述。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1707` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/1701-1710/1710. 卡车上的最大单元数（简单）.md | 1710. 卡车上的最大单元数 | https://leetcode.cn/problems/maximum-units-on-a-truck/solution/by-ac_oier-5wlo/ | 简单 | [
"贪心",
"排序",
"模拟"
] | 请你将一些箱子装在 一辆卡车 上。给你一个二维数组 `boxTypes`,其中 $boxTypes[i] = [numberOfBoxes_i, numberOfUnitsPerBox_i]$ :
* $numberOfBoxes_i$ 是类型 `i` 的箱子的数量。
* $numberOfUnitsPerBox_i$ 是类型 `i` 每个箱子可以装载的单元数量。
整数 `truckSize` 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 `truckSize`,你就可以选择任意箱子装到卡车上。
返回卡车可以装载 单元 的 最大 总数。
示例 1:
```
输入:boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
输出:8
解释:箱子的情况如下:
- 1 个第一类的箱子,里面含 3 个单元。
- 2 个第二类的箱子,每个里面含 2 个单元。
- 3 个第三类的箱子,每个里面含 1 个单元。
可以选择第一类和第二类的所有箱子,以及第三类的一个箱子。
单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8
```
示例 2:
```
输入:boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
输出:91
```
提示:
* $1 <= boxTypes.length <= 1000$
* $1 <= numberOfBoxes_i, numberOfUnitsPerBox_i <= 1000$
* $1 <= truckSize <= 10^6$ | ### 贪心
为了方便,我们令 `boxTypes` 为 `bs`,令 `truckSize` 为 `k`。
由于每个箱子成本相同(均占用一个箱子位置),因此在 `k` 给定的情况下,我们应当尽可能选择装载单元数量大的箱子。
这引导我们可以将 `bs` 根据「装载单元数量」排倒序,然后从前往后 `pick` 箱子,直到没有空闲位置。
Java 代码:
```Java
class Solution {
public int maximumUnits(int[][] bs, int k) {
int n = bs.length, ans = 0;
Arrays.sort(bs, (a,b)->b[1]-a[1]);
for (int i = 0, cnt = 0; i < n && cnt < k; i++) {
int a = bs[i][0], b = bs[i][1], c = Math.min(a, k - cnt);
cnt += c; ans += c * b;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function maximumUnits(bs: number[][], k: number): number {
let n = bs.length, ans = 0
bs.sort((a,b)=>b[1]-a[1])
for (let i = 0, cnt = 0; i < n && cnt < k; i++) {
const a = bs[i][0], b = bs[i][1], c = Math.min(a, k - cnt)
cnt += c; ans += c * b
}
return ans
}
```
Python 代码:
```Python
class Solution:
def maximumUnits(self, bs: List[List[int]], k: int) -> int:
bs.sort(key=lambda x: -x[1])
n, ans = len(bs), 0
idx, cnt = 0, 0
while idx < n and cnt < k:
a, b, c = bs[idx][0], bs[idx][1], min(bs[idx][0], k - cnt)
cnt, ans = cnt + c, ans + b * c
idx += 1
return ans
```
* 时间复杂度:排序复杂度为 $O(n\log{n})$,同时答案复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.1710` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/171-180/171. Excel表列序号（简单）.md | 171. Excel表列序号 | https://leetcode-cn.com/problems/excel-sheet-column-number/solution/gong-shui-san-xie-tong-yong-jin-zhi-zhua-y5fm/ | 简单 | [
"模拟",
"进制转换"
] | 给你一个字符串 columnTitle ,表示 Excel 表格中的列名称。返回该列名称对应的列序号。
例如,
```
A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...
```
示例 1:
```
输入: columnTitle = "A"
输出: 1
```
示例 2:
```
输入: columnTitle = "AB"
输出: 28
```
示例 3:
```
输入: columnTitle = "ZY"
输出: 701
```
示例 4:
```
输入: columnTitle = "FXSHRXW"
输出: 2147483647
```
提示:
* 1 <= columnTitle.length <= 7
* columnTitle 仅由大写英文组成
* columnTitle 在范围 ["A", "FXSHRXW"] 内 | ### 进制转换
也许你没专门做过「进制转换」类的题目,但相信你确实在 $10$ 进制中使用过如下的「进制转换」手段。
如果题目是 $10$ 进制转换,那么你会很容易想到如下转换过程:**从高位向低位处理,起始让 $ans$ 为 $0$,每次使用当前位数值更新 $ans$,更新规则为 $ans = ans * 10 + val_i$。**
举个🌰,假设存在某个十进制数字,编码为 $ABCD$(字母与数字的映射关系与本题相同),转换过程如下:
> $ans$ = 0
$ans = ans * 10 + 1$ => A
$ans = ans * 10 + 2$ => B
$ans = ans * 10 + 3$ => C
$ans = ans * 10 + 4$ => D
同理,本题只是将 $10$ 进制换成 $26$ 进制。
代码:
```Java
class Solution {
public int titleToNumber(String s) {
char[] cs = s.toCharArray();
int n = cs.length;
int ans = 0;
for (int i = 0; i < n; i++) {
ans = ans * 26 + (cs[i] - 'A' + 1);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:因为 `toCharArray` 会创建与 `s` 等长的数组,因此使用 `charAt` 代替 `toCharArray` 的话为 $O(1)$,否则为 $O(n)$
---
### 拓展
与本题互逆的题目,你可以一同复习一下 ~
* [168. Excel表列名称](https://leetcode-cn.com/problems/excel-sheet-column-title/) : [题解](https://leetcode-cn.com/problems/excel-sheet-column-title/solution/gong-shui-san-xie-cong-1-kai-shi-de-26-j-g2ur/) | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.171` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/171-180/172. 阶乘后的零（中等）.md | 172. 阶乘后的零 | https://leetcode-cn.com/problems/factorial-trailing-zeroes/solution/by-ac_oier-1y6w/ | 中等 | [
"数学"
] | 给定一个整数 $n$ ,返回 $n!$ 结果中尾随零的数量。
提示 `n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1`
示例 1:
```
输入:n = 3
输出:0
解释:3! = 6 ,不含尾随 0
```
示例 2:
```
输入:n = 5
输出:1
解释:5! = 120 ,有一个尾随 0
```
示例 3:
```
输入:n = 0
输出:0
```
提示:
* $0 <= n <= 10^4$
进阶:你可以设计并实现对数时间复杂度的算法来解决此问题吗? | ### 数学
对于任意一个 $n!$ 而言,其尾随零的个数取决于展开式中 $10$ 的个数,而 $10$ 可由质因数 $2 * 5$ 而来,因此 $n!$ 的尾随零个数为展开式中各项分解质因数后 $2$ 的数量和 $5$ 的数量中的较小值。
即问题转换为对 $[1, n]$ 中的各项进行分解质因数,能够分解出来的 $2$ 的个数和 $5$ 的个数分别为多少。
为了更具一般性,我们分析对 $[1, n]$ 中各数进行分解质因数,能够分解出质因数 $p$ 的个数为多少。根据每个数能够分解出 $p$ 的个数进行分情况讨论:
* 能够分解出至少一个 $p$ 的个数为 $p$ 的倍数,在 $[1, n]$ 范围内此类数的个数为 $c_1 = \left \lfloor \frac{n}{p} \right \rfloor$
* 能够分解出至少两个 $p$ 的个数为 $p^2$ 的倍数,在 $[1, n]$ 范围内此类数的个数为 $c_2 = \left \lfloor \frac{n}{p^2} \right \rfloor$
* ...
* 能够分解出至少 $k$ 个 $p$ 的个数为 $p^k$ 的倍数,在 $[1, n]$ 范围内此类数的个数为 $c_k = \left \lfloor \frac{n}{p^k} \right \rfloor$
**我们定义一个合法的 $k$ 需要满足 $p^k \leqslant n$,上述的每一类数均是前一类数的「子集」(一个数如果是 $p^k$ 的倍数,必然是 $p^{k-1}$ 的倍数),因此如果一个数是 $p^k$ 的倍数,其出现在的集合数量为 $k$,与其最终贡献的 $p$ 的数量相等。**
回到本题,$n!$ 中质因数 $2$ 的数量为 :
$$
\sum_{i = 1}^{k_1}\left \lfloor \frac{n}{2^i} \right \rfloor = \left \lfloor \frac{n}{2} \right \rfloor + \left \lfloor \frac{n}{2^2} \right \rfloor + ... + \left \lfloor \frac{n}{2^{k_1}} \right \rfloor
$$
$n!$ 中质因数 $5$ 的数量为 :
$$
\sum_{i = 1}^{k_2}\left \lfloor \frac{n}{5^i} \right \rfloor = \left \lfloor \frac{n}{5} \right \rfloor + \left \lfloor \frac{n}{5^2} \right \rfloor + ... + \left \lfloor \frac{n}{5^{k_2}} \right \rfloor
$$
由 $2 < 5$,可知 $k_2 \leqslant k_1$,同时 $i$ 相同的每一项满足 $\left \lfloor \frac{n}{5^i} \right \rfloor \leqslant \left \lfloor \frac{n}{2^i} \right \rfloor$,可知最终 $\sum_{i = 1}^{k_2}\left \lfloor \frac{n}{5^i} \right \rfloor \leqslant \sum_{i = 1}^{k_1}\left \lfloor \frac{n}{2^i} \right \rfloor$,即质因数 $5$ 的个数必然不会超过质因数 $2$ 的个数。我们只需要统计质因数 $5$ 的个数即可。
代码:
```Java
class Solution {
public int trailingZeroes(int n) {
return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);
}
}
```
```Python
class Solution:
def trailingZeroes(self, n: int) -> int:
return n // 5 + self.trailingZeroes(n // 5) if n else 0
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.172` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/171-180/173. 二叉搜索树迭代器（中等）.md | 173. 二叉搜索树迭代器 | https://leetcode-cn.com/problems/binary-search-tree-iterator/solution/xiang-jie-ru-he-dui-die-dai-ban-de-zhong-4rxj/ | 中等 | [
"树的搜索",
"中序遍历"
] | 实现一个二叉搜索树迭代器类 `BSTIterator`,表示一个按中序遍历二叉搜索树(`BST`)的迭代器:
* `BSTIterator(TreeNode root)` 初始化 `BSTIterator` 类的一个对象。`BST` 的根节点 `root` 会作为构造函数的一部分给出。指针应初始化为一个不存在于 `BST` 中的数字,且该数字小于 `BST` 中的任何元素。
* `boolean hasNext()` 如果向指针右侧遍历存在数字,则返回 `true`;否则返回 `false`。
* `int next()` 将指针向右移动,然后返回指针处的数字。
注意,指针初始化为一个不存在于 `BST` 中的数字,所以对 `next()` 的首次调用将返回 `BST` 中的最小元素。
你可以假设 `next()` 调用总是有效的,也就是说,当调用 `next()` 时,`BST` 的中序遍历中至少存在一个下一个数字。
示例:
```
输入
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
输出
[null, 3, 7, true, 9, true, 15, true, 20, false]
解释
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
bSTIterator.next(); // 返回 3
bSTIterator.next(); // 返回 7
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 9
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 15
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 20
bSTIterator.hasNext(); // 返回 False
```
提示:
* 树中节点的数目在范围 [1, $10^5$] 内
* $0 <= Node.val <= 10^6$
* 最多调用 $10^5$ 次 `hasNext` 和 `next` 操作
进阶:
* 你可以设计一个满足下述条件的解决方案吗?`next()` 和 `hasNext()` 操作均摊时间复杂度为 $O(1)$ ,并使用 $O(h)$ 内存。其中 `h` 是树的高度。 | ### 基本思路
**这道题本质上考的是「将迭代版的中序遍历代码」做等价拆分。**
我们知道,中序遍历的基本逻辑是:处理左子树 -> 处理当前节点 -> 处理右子树。
其中迭代做法是利用「栈」进行处理:
1. 先将当前节点的所有左子树压入栈,压到没有为止
2. 将最后一个压入的节点弹出(栈顶元素),加入答案
3. 将当前弹出的节点作为当前节点,重复步骤一
相应的裸题在这里:[94. 二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
中序遍历的迭代代码:
```java
class Solution {
List<Integer> ans = new ArrayList<>();
Deque<TreeNode> d = new ArrayDeque<>();
public List<Integer> inorderTraversal(TreeNode root) {
while (root != null || !d.isEmpty()) {
// 步骤 1
while (root != null) {
d.addLast(root);
root = root.left;
}
// 步骤 2
root = d.pollLast();
ans.add(root.val);
// 步骤 3
root = root.right;
}
return ans;
}
}
```
总的来说是这么一个迭代过程:步骤 1 -> 步骤 2 -> 步骤 3 -> 步骤 1 ...
***
### 「中序遍历」代码的「等价拆分」
首先因为 `next()` 方法中我们需要输出一个值,执行的的是「步骤 2」的逻辑,同时我们需要在其前后添加「步骤 1」和「步骤 3」。
另外,我们还有一个 `hasNext()` 要处理,显然 `hasNext()` 应该对应我们的栈是否为空。
为此,我们**需要确保每次输出之后「步骤 1」被及时执行。**
综上,我们应该在初始化时,走一遍「步骤 1」,然后在 `next()` 方法中走「步骤 2」、「步骤 3」和「步骤 1」。
代码:
```java []
class BSTIterator {
Deque<TreeNode> d = new ArrayDeque<>();
public BSTIterator(TreeNode root) {
// 步骤 1
dfsLeft(root);
}
public int next() {
// 步骤 2
TreeNode root = d.pollLast();
int ans = root.val;
// 步骤 3
root = root.right;
// 步骤 1
dfsLeft(root);
return ans;
}
void dfsLeft(TreeNode root) {
while (root != null) {
d.addLast(root);
root = root.left;
}
}
public boolean hasNext() {
return !d.isEmpty();
}
}
```
* 时间复杂度:由于每个元素都是严格「进栈」和「出栈」一次,复杂度为均摊 $O(1)$
* 空间复杂度:栈内最多保存与深度一致的节点数量,复杂度为 $O(h)$
***
### 进阶
事实上,我们空间复杂度也能做到 $O(1)$,该如何做呢? | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.173` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |