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/991-1000/998. 最大二叉树 II（中等）.md | 998. 最大二叉树 II | https://leetcode.cn/problems/maximum-binary-tree-ii/solution/by-ac_oier-v82s/ | 中等 | [
"迭代",
"模拟"
] | 最大树定义:一棵树,并满足「其中每个节点的值都大于其子树中的任何其他值」。
给你最大树的根节点 `root` 和一个整数 `val` 。
给定的树是利用 `Construct(a)` 例程从列表 `a`(`root = Construct(a)`)递归地构建的:
* 如果 `a` 为空,返回 `null` 。
* 否则,令 `a[i]` 作为 `a` 的最大元素。创建一个值为 `a[i]` 的根节点 `root` 。
* `root` 的左子树将被构建为 `Construct([a[0], a[1], ..., a[i - 1]])` 。
* `root` 的右子树将被构建为 `Construct([a[i + 1], a[i + 2], ..., a[a.length - 1]])` 。
* 返回 `root` 。
请注意,题目没有直接给出 `a` ,只是给出一个根节点 `root = Construct(a)` 。
假设 `b` 是 `a` 的副本,并在末尾附加值 `val`。题目数据保证 `b` 中的值互不相同。
返回 `Construct(b)`。
示例 1:
```
输入:root = [4,1,3,null,null,2], val = 5
输出:[5,4,null,1,3,null,null,2]
解释:a = [1,4,2,3], b = [1,4,2,3,5]
```
示例 2:
```
输入:root = [5,2,4,null,1], val = 3
输出:[5,2,4,null,1,null,3]
解释:a = [2,1,5,4], b = [2,1,5,4,3]
```
示例 3:
```
输入:root = [5,2,3,null,1], val = 4
输出:[5,2,4,null,1,3]
解释:a = [2,1,5,3], b = [2,1,5,3,4]
```
提示:
* 树中节点数目在范围 $[1, 100]$ 内
* $1 <= Node.val <= 100$
* 树中的所有值 互不相同
* $1 <= val <= 100$ | ### 模拟
题意不是很好理解,先稍微解释一下吧。
大概意思是最大树 `root` 是根据特定的规则构造出来的,即给定的 `root` 其实对应一个具体的 `nums`,题目要求是将 `val` 追加到 `nums` 的尾部,然后再对得到的 `nums` 运用相同规则的构造,返回重新构造的最大树头结点。
根据构造规则,若有下标 $i < j$,则 $nums[i]$ 必然在 $nums[j]$ 水平线的左边,而 `val` 又是追加在原有 `nums` 的结尾。因此其最终位置分如下两种情况:
* `val` 为新 `nums` 中的最大值,同时 `val` 又是追加在原有 `nums` 的结尾,此时将原有的 `root` 挂在 `val` 对应节点的左子树即可,新树的根节点为 `val` 对应节点;
* 否则,我们只需要不断在 `root` 的右子树中找目标位置(反证法可以知,`val` 必不可能出现在任一非右位置,否则可推断出在 `val` 右边仍有元素,这与 `val` 位于 `nums` 的结尾位置冲突)。假设目标位置的父节点为 `prev`,目标位置的原节点为 `cur`,根据构造规则可知 `prev.right = node` 且 `node.left = cur`,新树的根节点不变。
Java 代码:
```Java
class Solution {
public TreeNode insertIntoMaxTree(TreeNode root, int val) {
TreeNode node = new TreeNode(val);
TreeNode prev = null, cur = root;
while (cur != null && cur.val > val) {
prev = cur; cur = cur.right;
}
if (prev == null) {
node.left = cur;
return node;
} else {
prev.right = node;
node.left = cur;
return root;
}
}
}
```
C++ 代码:
```C++
class Solution {
public:
TreeNode* insertIntoMaxTree(TreeNode* root, int val) {
TreeNode* node = new TreeNode(val);
TreeNode* prev = nullptr;
TreeNode* cur = root;
while (cur != nullptr && cur->val > val) {
prev = cur; cur = cur->right;
}
if (prev == nullptr) {
node->left = cur;
return node;
} else {
prev->right = node;
node->left = cur;
return root;
}
}
};
```
Python 代码:
```Python
class Solution:
def insertIntoMaxTree(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
node = TreeNode(val)
prev, cur = None, root
while cur is not None and cur.val > val:
prev = cur
cur = cur.right
if prev is None:
node.left = cur
return node
else:
prev.right = node
node.left = cur
return root
```
Typescript 代码:
```Typescript
function insertIntoMaxTree(root: TreeNode | null, val: number): TreeNode | null {
const node = new TreeNode(val)
let prev = null, cur = root
while (cur != null && cur.val > val) {
prev = cur; cur = cur.right
}
if (prev == null) {
node.left = root
return node
} else {
prev.right = node
node.left = cur
return root
}
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.998` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/LCP/LCP 07. 传递信息（简单）.md | LCP 07. 传递信息 | https://leetcode-cn.com/problems/chuan-di-xin-xi/solution/gong-shui-san-xie-tu-lun-sou-suo-yu-dong-cyxo/ | 简单 | [
"图论搜索",
"图论 BFS",
"图论 DFS",
"线性 DP"
] | 小朋友 A 在和 ta 的小伙伴们玩传信息游戏,游戏规则如下:
1. 有 n 名玩家,所有玩家编号分别为 0 ~ n-1,其中小朋友 A 的编号为 0
2. 每个玩家都有固定的若干个可传信息的其他玩家(也可能没有)。传信息的关系是单向的(比如 A 可以向 B 传信息,但 B 不能向 A 传信息)。
3. 每轮信息必须需要传递给另一个人,且信息可重复经过同一个人
给定总玩家数 n,以及按 [玩家编号,对应可传递玩家编号] 关系组成的二维数组 relation。返回信息从小 A (编号 0 ) 经过 k 轮传递到编号为 n-1 的小伙伴处的方案数;若不能到达,返回 0。
示例 1:
```
输入:n = 5, relation = [[0,2],[2,1],[3,4],[2,3],[1,4],[2,0],[0,4]], k = 3
输出:3
解释:信息从小 A 编号 0 处开始,经 3 轮传递,到达编号 4。
共有 3 种方案,分别是 0->2->0->4, 0->2->1->4, 0->2->3->4。
```
示例 2:
```
输入:n = 3, relation = [[0,2],[2,1]], k = 2
输出:0
解释:信息不能从小 A 处经过 2 轮传递到编号 2
```
限制:
* 2 <= n <= 10
* 1 <= k <= 5
* 1 <= relation.length <= 90, 且 relation[i].length == 2
* 0 <= relation[i][0],relation[i][1] < n 且 relation[i][0] != relation[i][1] | ### 基本分析
`n` 和 `k` 的数据范围都很小,并且根据题目对 `relation` 的定义可以知道这是一个边权相等的图。
对于边权相等的图,统计有限步数的到达某个节点的方案数,最常见的方式是使用 `BFS` 或 `DFS`。
---
### BFS
一个朴素的做法是使用 `BFS` 进行求解。
起始时,将起点入队,按照常规的 `BFS` 方式进行拓展,直到拓展完第 $k$ 层。
然后统计队列中编号为 `n-1` 的节点的出现次数。
一些细节:为了方便找到某个点 $i$ 所能到达的节点,我们需要先预处理出所有的边。数据量较少,直接使用 `Map` 套 `Set` 即可。
代码:
```Java
class Solution {
public int numWays(int n, int[][] rs, int k) {
Map<Integer, Set<Integer>> map = new HashMap<>();
for (int[] r : rs) {
int a = r[0], b = r[1];
Set<Integer> s = map.getOrDefault(a, new HashSet<>());
s.add(b);
map.put(a, s);
}
Deque<Integer> d = new ArrayDeque<>();
d.addLast(0);
while (!d.isEmpty() && k-- > 0) {
int size = d.size();
while (size-- > 0) {
int poll = d.pollFirst();
Set<Integer> es = map.get(poll);
if (es == null) continue;
for (int next : es) {
d.addLast(next);
}
}
}
int ans = 0;
while (!d.isEmpty()) {
if (d.pollFirst() == n - 1) ans++;
}
return ans;
}
}
```
* 时间复杂度:最多搜索 $k$ 层,最坏情况下每层的每个节点都能拓展出 $n - 1$ 个节点,复杂度为 $O(n^k)$
* 空间复杂度:最坏情况下,所有节点都相互连通。复杂度为 $O(n^k + n^2)$
---
### DFS
同理,我们可以使用 `DFS` 进行求解。
在 `DFS` 过程中限制深度最多为 $k$,然后检查所达节点为 `n-1` 的次数即可。
代码:
```Java
class Solution {
Map<Integer, Set<Integer>> map = new HashMap<>();
int n, k, ans;
public int numWays(int _n, int[][] rs, int _k) {
n = _n; k = _k;
for (int[] r : rs) {
int a = r[0], b = r[1];
Set<Integer> s = map.getOrDefault(a, new HashSet<>());
s.add(b);
map.put(a, s);
}
dfs(0, 0);
return ans;
}
void dfs(int u, int sum) {
if (sum == k) {
if (u == n - 1) ans++;
return;
}
Set<Integer> es = map.get(u);
if (es == null) return;
for (int next : es) {
dfs(next, sum + 1);
}
}
}
```
* 时间复杂度:最多搜索 $k$ 层,最坏情况下每层的每个节点都能拓展出 $n - 1$ 个节点,复杂度为 $O(n^k)$
* 空间复杂度:最坏情况下,所有节点都相互连通。忽略递归带来的额外空间消耗,复杂度为 $O(n^2)$
---
### 动态规划
假设当前我们已经走了 $i$ 步,所在位置为 $j$,那么剩余的 $k - i$ 步,能否到达位置 $n - 1$,仅取决于「剩余步数 $k - i$」和「边权关系 `relation`」,而与我是如何到达位置 $i$ 无关。
而对于方案数而言,如果已经走了 $i$ 步,所在位置为 $j$,到达位置 $n - 1$ 的方案数仅取决于「剩余步数 $i - k$」、「边权关系 `relation`」和「花费 $i$ 步到达位置 $j$ 的方案数」。
**以上分析,归纳到边界「已经走了 $0$ 步,所在位置为 $0$」同样成立。**
**这是一个「无后效性」的问题,可以使用动态规划进行求解。**
定义 $f[i][j]$ 为当前已经走了 $i$ 步,所在位置为 $j$ 的方案数。
那么 $f[k][n - 1]$ 为最终答案,$f[0][0] = 1$ 为显而易见的初始化条件。
不失一般性的考虑,$f[i][j]$ 该如何转移,$f[i][j]$ 应该为所有能够到达位置 $j$ 的点 $p$ 的 $f[i - 1][p]$ 的总和:
$$
f[i][j] = \sum_{i = 0}^{relation.length - 1}f[i - 1][p], relation[i][0]=p,relation[i][1]=j
$$
代码:
```Java
class Solution {
public int numWays(int n, int[][] rs, int k) {
int[][] f = new int[k + 1][n];
f[0][0] = 1;
for (int i = 1; i <= k; i++) {
for (int[] r : rs) {
int a = r[0], b = r[1];
f[i][b] += f[i - 1][a];
}
}
return f[k][n - 1];
}
}
```
* 时间复杂度:$O(relation.length * k)$
* 空间复杂度:$O(n * k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `LCP 07` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/LCR/LCR 161. 连续天数的最高销售额（简单）.md | LCR 161. 连续天数的最高销售额 | https://leetcode.cn/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/solution/gong-shui-san-xie-tu-jie-cong-on-chang-g-se9p/ | 简单 | [
"前缀和",
"区间求和问题",
"线性 DP",
"分治"
] | 某公司每日销售额记于整数数组 `sales`,请返回所有连续一或多天销售额总和的最大值。
要求实现时间复杂度为 $O(n)$ 的算法。
示例 1:
```
输入:sales = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:[4,-1,2,1] 此连续四天的销售总额最高,为 6。
```
示例 2:
```
输入:sales = [5,4,-1,7,8]
输出:23
解释:[5,4,-1,7,8] 此连续五天的销售总额最高,为 23。
```
提示:
* $1 <= arr.length <= 10^5$
* $-100 <= arr[i] <= 100$ | ### 前缀和 or 线性 DP
当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。
所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。
设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。
有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。
通用公式:`ans = sum[j] - sum[i - 1]`。
由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1$ 开始。在进行快速求和时,再根据原数组下标是否从 $1$ 开始,决定是否进行相应的下标偏移。
学习完一维前缀和后,回到本题。
先用 `nums` 预处理出前缀和数组 `sum`,然后在遍历子数组右端点 `j` 的过程中,通过变量 `m` 动态记录已访问的左端点 `i` 的前缀和最小值。最终,在所有 `sum[j] - m` 的取值中选取最大值作为答案。
代码实现上,我们无需明确计算前缀和数组 `sum`,而是使用变量 `s` 表示当前累计的前缀和(充当右端点),并利用变量 `m` 记录已访问的前缀和的最小值(充当左端点)即可。
**本题除了将其看作为「前缀和裸题用有限变量进行空间优化」以外,还能以「线性 DP」角度进行理解。**
定义 $f[i]$ 为考虑前 $i$ 个元素,且第 $nums[i]$ 必选的情况下,形成子数组的最大和。
不难发现,仅考虑前 $i$ 个元素,且 $nums[i]$ 必然参与的子数组中。要么是 $nums[i]$ 自己一个成为子数组,要么与前面的元素共同组成子数组。
因此,状态转移方程:
$$
f[i] = \max(f[i - 1] + nums[i], nums[i])
$$
由于 $f[i]$ 仅依赖于 $f[i - 1]$ 进行转移,可使用有限变量进行优化,因此写出来的代码也是和上述前缀和角度分析的类似。
Java 代码:
```Java
class Solution {
public int maxSales(int[] nums) {
int s = 0, m = 0, ans = -10010;
for (int x : nums) {
s += x;
ans = Math.max(ans, s - m);
m = Math.min(m, s);
}
return ans;
}
}
```
C++ 代码:
```C++
class Solution {
public:
int maxSales(vector<int>& nums) {
int s = 0, m = 0, ans = -10010;
for (int x : nums) {
s += x;
ans = max(ans, s - m);
m = min(m, s);
}
return ans;
}
};
```
Python 代码:
```Python
class Solution:
def maxSales(self, nums: List[int]) -> int:
s, m, ans = 0, 0, -10010
for x in nums:
s += x
ans = max(ans, s - m)
m = min(m, s)
return ans
```
TypeScript 代码:
```TypeScript
function maxSales(nums: number[]): number {
let s = 0, m = 0, ans = -10010;
for (let x of nums) {
s += x;
ans = Math.max(ans, s - m);
m = Math.min(m, s);
}
return ans;
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 分治
“分治法”的核心思路是将大问题拆分成更小且相似的子问题,通过递归解决这些子问题,最终合并子问题的解来得到原问题的解。
实现分治,关键在于对“递归函数”的设计(入参 & 返回值)。
在涉及数组的分治题中,左右下标 `l` 和 `r` 必然会作为函数入参,因为它能用于表示当前所处理的区间,即小问题的范围。
对于本题,仅将最大子数组和(答案)作为返回值并不足够,因为单纯从小区间的解无法直接推导出大区间的解,我们需要一些额外信息来辅助求解。
具体的,我们可以将返回值设计成四元组,分别代表 `区间和`,`前缀最大值`,`后缀最大值` 和 `最大子数组和`,用 `[sum, lm, rm, max]` 表示。
有了完整的函数签名 `int[] dfs(int[] nums, int l, int r)`,考虑如何实现分治:
1. 根据当前区间 $[l, r]$ 的长度进行分情况讨论:
1. 若 $l = r$,只有一个元素,区间和为 $nums[l]$,而 最大子数组和、前缀最大值 和 后缀最大值 由于允许“空数组”,因此均为 $\max(nums[l], 0)$
2. 否则,将当前问题划分为两个子问题,通常会划分为两个相同大小的子问题,划分为 $[l, mid]$ 和 $[mid + 1, r]$ 两份,递归求解,其中 $mid = \left \lfloor \frac{l + r}2{} \right \rfloor$
随后考虑如何用“子问题”的解合并成“原问题”的解:
1. **合并区间和 (`sum`):** 当前问题的区间和等于左右两个子问题的区间和之和,即 `sum = left[0] + right[0]`。
2. **合并前缀最大值 (`lm`):** 当前问题的前缀最大值可以是左子问题的前缀最大值,或者左子问题的区间和加上右子问题的前缀最大值。即 `lm = max(left[1], left[0] + right[1])`。
3. **合并后缀最大值 (`rm`):** 当前问题的后缀最大值可以是右子问题的后缀最大值,或者右子问题的区间和加上左子问题的后缀最大值。即 `rm = max(right[2], right[0] + left[2])`。
4. **合并最大子数组和 (`max`):** 当前问题的最大子数组和可能出现在左子问题、右子问题,或者跨越左右两个子问题的边界。因此,`max` 可以通过 `max(left[3], right[3], left[2] + right[1])` 来得到。
一些细节:由于我们在计算 `lm`、`rm` 和 `max` 的时候允许数组为空,而答案对子数组的要求是至少包含一个元素。因此对于 `nums` 全为负数的情况,我们会错误得出最大子数组和为 `0` 的答案。针对该情况,需特殊处理,遍历一遍 `nums`,若最大值为负数,直接返回最大值。
Java 代码:
```Java
class Solution {
// 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]
int[] dfs(int[] nums, int l, int r) {
if (l == r) {
int t = Math.max(nums[l], 0);
return new int[]{nums[l], t, t, t};
}
// 划分成两个子区间,分别求解
int mid = l + r >> 1;
int[] left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);
// 组合左右子区间的信息,得到当前区间的信息
int[] ans = new int[4];
ans[0] = left[0] + right[0]; // 当前区间和
ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值
ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值
ans[3] = Math.max(Math.max(left[3], right[3]), left[2] + right[1]); // 最大子数组和
return ans;
}
public int maxSales(int[] nums) {
int m = nums[0];
for (int x : nums) m = Math.max(m, x);
if (m <= 0) return m;
return dfs(nums, 0, nums.length - 1)[3];
}
}
```
C++ 代码:
```C++
class Solution {
public:
// 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]
vector<int> dfs(vector<int>& nums, int l, int r) {
if (l == r) {
int t = max(nums[l], 0);
return {nums[l], t, t, t};
}
// 划分成两个子区间,分别求解
int mid = l + r >> 1;
auto left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);
// 组合左右子区间的信息,得到当前区间的信息
vector<int> ans(4);
ans[0] = left[0] + right[0]; // 当前区间和
ans[1] = max(left[1], left[0] + right[1]); // 当前区间前缀最大值
ans[2] = max(right[2], right[0] + left[2]); // 当前区间后缀最大值
ans[3] = max({left[3], right[3], left[2] + right[1]}); // 最大子数组和
return ans;
}
int maxSales(vector<int>& nums) {
int m = nums[0];
for (int x : nums) m = max(m, x);
if (m <= 0) return m;
return dfs(nums, 0, nums.size() - 1)[3];
}
};
```
Python 代码:
```Python
class Solution:
def maxSales(self, nums: List[int]) -> int:
def dfs(l, r):
if l == r:
t = max(nums[l], 0)
return [nums[l], t, t, t]
# 划分成两个子区间,分别求解
mid = (l + r) // 2
left, right = dfs(l, mid), dfs(mid + 1, r)
# 组合左右子区间的信息,得到当前区间的信息
ans = [0] * 4
ans[0] = left[0] + right[0] # 当前区间和
ans[1] = max(left[1], left[0] + right[1]) # 当前区间前缀最大值
ans[2] = max(right[2], right[0] + left[2]) # 当前区间后缀最大值
ans[3] = max(left[3], right[3], left[2] + right[1]) # 最大子数组和
return ans
m = max(nums)
if m <= 0:
return m
return dfs(0, len(nums) - 1)[3]
```
TypeScript 代码:
```TypeScript
function maxSales(nums: number[]): number {
const dfs = function (l: number, r: number): number[] {
if (l == r) {
const t = Math.max(nums[l], 0);
return [nums[l], t, t, t];
}
// 划分成两个子区间,分别求解
const mid = (l + r) >> 1;
const left = dfs(l, mid), right = dfs(mid + 1, r);
// 组合左右子区间的信息,得到当前区间的信息
const ans = Array(4).fill(0);
ans[0] = left[0] + right[0]; // 当前区间和
ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值
ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值
ans[3] = Math.max(left[3], right[3], left[2] + right[1]); // 最大子数组和
return ans;
}
const m = Math.max(...nums);
if (m <= 0) return m;
return dfs(0, nums.length - 1)[3];
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.LCR 161` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 003. 前 n 个数字二进制中 1 的个数（简单）.md | 剑指 Offer II 003. 前 n 个数字二进制中 1 的个数 | https://leetcode.cn/problems/w3tCBm/solution/by-ac_oier-cnlt/ | 简单 | [
"模拟",
"动态规划"
] | 给定一个非负整数 `n` ,请计算 `0` 到 `n` 之间的每个数字的二进制表示中 $1$ 的个数,并输出一个数组。
示例 1:
```
输入: n = 2
输出: [0,1,1]
解释:
0 --> 0
1 --> 1
2 --> 10
```
示例 2:
```
输入: n = 5
输出: [0,1,1,2,1,2]
解释:
0 --> 0
1 --> 1
2 --> 10
3 --> 11
4 --> 100
5 --> 101
```
说明 :
* $0 <= n <= 10^5$
进阶:
* 给出时间复杂度为 $O(n \times sizeof(integer))$ 的解答非常容易。但你可以在线性时间 $O(n)$ 内用一趟扫描做到吗?
* 要求算法的空间复杂度为 $O(n)$。
* 你能进一步完善解法吗?要求在 `C++` 或任何其他语言中不使用任何内置函数(如 `C++` 中的 `__builtin_popcount` )来执行此操作。 | ### 模拟
这道题要对每个数进行统计,因此不会有比 $O(n)$ 更低的做法。
而很容易想到的朴素做法是对每个数进行「位运算」计数,每个数都是 $32$ 位的,因此是一个 $O(32n)$ 的做法。
代码:
```Java
class Solution {
public int[] countBits(int n) {
int[] ans = new int[n + 1];
for (int i = 0; i <= n; i++) ans[i] = getCnt(i);
return ans;
}
int getCnt(int u) {
int ans = 0;
for (int i = 0; i < 32; i++) ans += (u >> i) & 1;
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$
---
### 动态规划
事实上,这道题是有严格 $O(n)$ 的解法的,要求 $O(n)$ 复杂度又是输出方案的题,通常就是递推的 DP 题。
用已算出的值去凑出要算的值。
那么对于这类问题我们该如何考虑呢?一般是靠经验,如果实在没见过这类题型的话,我们就需要在纸上画一下,分析一下我们**朴素做法的最后一步**是怎么进行的。
不失一般性的,假设当前我要统计的数的 `i`,`i` 对应的二进制表示是 `00000...0010100101`(共 32 位)
如果我们是使用「朴素解法」求解的话,无论是从高位进行统计,还是从低位进行统计,最后一位扫描的都是边缘的数(如果是 1 就计数,不是 1 就不计数)。
* **从低位到高位**,最后一步在扫描**最高位**之前,**统计出 1 的个数应该等同于将 `i` 左移一位,并在最低位补 0,也就是等于 `ans[i << 1]`,这时候就要求我们在计算 `i` 的时候 `i << 1` 已经被算出来(从大到小遍历)**
* **从高位到低位**,最后一步在扫描**最低位**之前,**统计出 1 的个数应该等同于将 `i` 右移一位,并在最高位补 0,也就是等于 `ans[i >> 1]`,这时候就要求我们在计算 `i` 的时候 `i >> 1` 已经被算出来(从小到大遍历)**
通过**对「朴素做法」的最后一步分析**,转移方程就出来了:
* 当**从大到小遍历** :$f(i) = f(i << 1) + ((i >>31 ) \& 1)$
* 当**从小到大遍历** :$f(i) = f(i >> 1) + ( i \& 1 )$
代码:
```Java
class Solution {
// 从小到大遍历
public int[] countBits(int n) {
int[] ans = new int[n + 1];
// ans[i] = 「i >> 1 所包含的 1 的个数」+「i 的最低位是否为 1」
for (int i = 1; i <= n; i++) ans[i] = ans[i >> 1] + (i & 1);
return ans;
}
}
```
-
```Java
class Solution {
// 从大到小遍历
public int[] countBits(int n) {
int[] ans = new int[n + 1];
for (int i = n; i >= 0; i--) {
// 如果计算 i 所需要的 i << 1 超过 n,则不存储在 ans 内,需要额外计算
int u = i << 1 <= n ? ans[i << 1] : getCnt(i << 1);
// ans[i] =「i << 1 所包含的 1 的个数」 + 「i 的最高位是否为 1」
ans[i] = u + ((i >> 31) & 1);
}
return ans;
}
int getCnt(int u) {
int ans = 0;
for (int i = 0; i < 32; i++) ans += (u >> i) & 1;
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$
---
### 位运算说明
* `a >> b & 1` 代表检查 `a` 的第 `b` 位是否为 $1$,有两种可能性 $0$ 或者 $1$
* `a += 1 << b` 代表将 `a` 的第 `b` 位设置为 $1$ (当第 `b` 位为 $0$ 的时候适用)
如不想写对第 `b` 位为 $0$ 的前置判断,`a += 1 << b` 也可以改成 `a |= 1 << b`
在之前的题解我就强调过,以上两个操作在位运算中**使用频率超高,建议每位同学都加深理解**。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 003` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 005. 单词长度的最大乘积（中等）.md | 剑指 Offer II 005. 单词长度的最大乘积 | https://leetcode.cn/problems/aseY1I/solution/by-ac_oier-qk3a/ | 中等 | [
"模拟",
"位运算"
] | 给定一个字符串数组 `words`,请计算当两个字符串 `words[i]` 和 `words[j]` 不包含相同字符时,它们长度的乘积的最大值。假设字符串中只包含英语的小写字母。如果没有不包含相同字符的一对字符串,返回 $0$。
示例 1:
```
输入: words = ["abcw","baz","foo","bar","fxyz","abcdef"]
输出: 16
解释: 这两个单词为 "abcw", "fxyz"。它们不包含相同字符,且长度的乘积最大。
```
示例 2:
```
输入: words = ["a","ab","abc","d","cd","bcd","abcd"]
输出: 4
解释: 这两个单词为 "ab", "cd"。
```
示例 3:
```
输入: words = ["a","aa","aaa","aaaa"]
输出: 0
解释: 不存在这样的两个单词。
```
提示:
* $2 <= words.length <= 1000$
* $1 <= words[i].length <= 1000$
* `words[i]` 仅包含小写字母 | ### 模拟
根据题意进行模拟即可,利用每个 $words[i]$ 只有小写字母,且只需要区分两字符是否有字母重复。
我们可以使用一个 `int` 来代指某个 $word[i]$:低 $26$ 来代指字母 `a-z` 是否出现过。
然后对每个「字符对」所对应的两个 `int` 值执行 `&` 操作(若两字符无重复字符,则结果为 $0$),并得出最终答案。
代码:
```Java []
class Solution {
public int maxProduct(String[] words) {
int n = words.length, idx = 0;
int[] masks = new int[n];
for (String w : words) {
int t = 0;
for (int i = 0; i < w.length(); i++) {
int u = w.charAt(i) - 'a';
t |= (1 << u);
}
masks[idx++] = t;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if ((masks[i] & masks[j]) == 0) ans = Math.max(ans, words[i].length() * words[j].length());
}
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为 $words$ 数组的长度,转换出 $masks$ 的复杂度为 $O(\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\max(\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$
* 空间复杂度:$O(n)$
---
### 优化
不难发现,对于词频相同($mask$ 值相等)的两字符,只需要保留字符长度大的即可,因此我们可以使用「哈希表」代替 $masks$ 数组。
代码:
```Java
class Solution {
public int maxProduct(String[] words) {
Map<Integer, Integer> map = new HashMap<>();
for (String w : words) {
int t = 0, m = w.length();
for (int i = 0; i < m; i++) {
int u = w.charAt(i) - 'a';
t |= (1 << u);
}
if (!map.containsKey(t) || map.get(t) < m) map.put(t, m);
}
int ans = 0;
for (int a : map.keySet()) {
for (int b : map.keySet()) {
if ((a & b) == 0) ans = Math.max(ans, map.get(a) * map.get(b));
}
}
return ans;
}
}
```
* 时间复杂度:令 $n$ 为 $words$ 数组的长度,得到 $map$ 的复杂度为 $O(\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\max(\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 005` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 007. 数组中和为 0 的三个数（中等）.md | 剑指 Offer II 007. 数组中和为 0 的三个数 | https://leetcode.cn/problems/1fGaJU/solution/by-ac_oier-6mfb/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给你一个包含 $n$ 个整数的数组 `nums`,判断 `nums` 中是否存在三个元素 `a`,`b`,`c` ,使得 `a + b + c = 0` ?
请你找出所有和为 $0$ 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
示例 1:
```
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
```
示例 2:
```
输入:nums = []
输出:[]
```
示例 3:
```
输入:nums = [0]
输出:[]
```
提示:
* $0 <= nums.length <= 3000$
* $-10^5 <= nums[i] <= 10^5$ | ### 排序 + 双指针
对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。
1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] == 0` 的所有组合。
2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :
* `sum` > 0:`k` 左移,使 `sum` 变小
* `sum` < 0:`j` 右移,使 `sum` 变大
* `sum` = 0:找到符合要求的答案,存起来
由于题目要求答案不能包含重复的三元组,所以在确定第一个数和第二个数的时候,要跳过数值一样的下标(在三数之和确定的情况下,确保第一个数和第二个数不会重复,即可保证三元组不重复)。
代码:
```Java
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
int j = i + 1, k = n - 1;
while (j < k) {
while (j > i + 1 && j < n && nums[j] == nums[j - 1]) j++;
if (j >= k) break;
int sum = nums[i] + nums[j] + nums[k];
if (sum == 0) {
ans.add(Arrays.asList(nums[i], nums[j], nums[k]));
j++;
} else if (sum > 0) {
k--;
} else if (sum < 0) {
j++;
}
}
}
return ans;
}
}
```
* 时间复杂度:排序的复杂度为 $O(n\log{n})$,对于每个 `i` 而言,最坏的情况 `j` 和 `k` 都要扫描一遍数组的剩余部分,复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 007` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 008. 和大于等于 target 的最短子数组（中等）.md | 剑指 Offer II 008. 和大于等于 target 的最短子数组 | https://leetcode.cn/problems/2VG8Kg/solution/by-ac_oier-vw5r/ | 中等 | [
"前缀和",
"二分"
] | 给定一个含有 `n` 个正整数的数组和一个正整数 `target`。
找出该数组中满足其和 `≥ target` 的长度最小的 连续子数组 $[nums_{l}, nums_{l+1}, ..., nums_{r-1}, nums_{r}]$ ,并返回其长度。如果不存在符合条件的子数组,返回 $0$ 。
示例 1:
```
输入:target = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
```
示例 2:
```
输入:target = 4, nums = [1,4,4]
输出:1
```
示例 3:
```
输入:target = 11, nums = [1,1,1,1,1,1,1,1]
输出:0
```
提示:
* $1 <= target <= 10^9$
* $1 <= nums.length <= 10^5$
* $1 <= nums[i] <= 10^5$ | ### 前缀和 + 二分
利用 $nums[i]$ 的数据范围为 $[1, 10^5]$,可知前缀和数组满足「单调递增」。
我们先预处理出前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于每个 $nums[i]$ 而言,假设其对应的前缀和值为 $s = sum[i + 1]$,我们将 $nums[i]$ 视为子数组的右端点,问题转换为:在前缀和数组下标 $[0, i]$ 范围内找到满足「**值小于等于 $s - t$**」的最大下标,充当子数组左端点的前一个值。
利用前缀和数组的「单调递增」(即具有二段性),该操作可使用「二分」来做。
代码:
```Java
class Solution {
public int minSubArrayLen(int t, int[] nums) {
int n = nums.length, ans = n + 10;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
for (int i = 1; i <= n; i++) {
int s = sum[i], d = s - t;
int l = 0, r = i;
while (l < r) {
int mid = l + r + 1 >> 1;
if (sum[mid] <= d) l = mid;
else r = mid - 1;
}
if (sum[r] <= d) ans = Math.min(ans, i - r);
}
return ans == n + 10 ? 0 : ans;
}
}
```
* 时间复杂度:预处理前缀和数组的复杂度为 $O(n)$,遍历前缀和数组统计答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 008` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 009. 乘积小于 K 的子数组（中等）.md | 剑指 Offer II 009. 乘积小于 K 的子数组 | https://leetcode.cn/problems/ZVAVXX/solution/by-ac_oier-lop5/ | 中等 | [
"滑动窗口",
"双指针"
] | 给你一个整数数组 `nums` 和一个整数 $k$ ,请你返回子数组内所有元素的乘积严格小于 $k$ 的连续子数组的数目。
示例 1:
```
输入:nums = [10,5,2,6], k = 100
输出:8
解释:8 个乘积小于 100 的子数组分别为:[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
```
示例 2:
```
输入:nums = [1,2,3], k = 0
输出:0
```
提示:
* $1 <= nums.length <= 3 \times 10^4$
* $1 <= nums[i] <= 1000$
* $0 <= k <= 10^6$ | ### 滑动窗口
利用 $1 <= nums[i] <= 1000$,我们可以从前往后处理所有的 $nums[i]$,使用一个变量 $cur$ 记录当前窗口的乘积,使用两个变量 $j$ 和 $i$ 分别代表当前窗口的左右端点。
当 $cur >= k$ 时,我们考虑将左端点 $j$ 右移,同时消除原来左端点元素 $nums[j]$ 对 $cur$ 的贡献,直到 $cur >= k$ 不再满足,这样我们就可以得到每个右端点 $nums[i]$ 的最远左端点 $nums[j]$,从而得知以 $nums[i]$ 为结尾的合法子数组个数为 $i - j + 1$。
Java 代码:
```Java
class Solution {
public int numSubarrayProductLessThanK(int[] nums, int k) {
int n = nums.length, ans = 0;
if (k <= 1) return 0;
for (int i = 0, j = 0, cur = 1; i < n; i++) {
cur *= nums[i];
while (cur >= k) cur /= nums[j++];
ans += i - j + 1;
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function numSubarrayProductLessThanK(nums: number[], k: number): number {
let n = nums.length, ans = 0
if (k <= 1) return 0
for (let i = 0, j = 0, cur = 1; i < n; i++) {
cur *= nums[i]
while (cur >= k) cur /= nums[j++]
ans += i - j + 1
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 009` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 010. 和为 k 的子数组（中等）.md | 剑指 Offer II 010. 和为 k 的子数组 | https://leetcode.cn/problems/QTMn0o/solution/by-ac_oier-hr6k/ | 中等 | [
"前缀和",
"哈希表"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,请你统计并返回该数组中和为 `k` 的子数组的个数 。
示例 1:
```
输入:nums = [1,1,1], k = 2
输出:2
```
示例 2:
```
输入:nums = [1,2,3], k = 3
输出:2
```
提示:
* $1 <= nums.length <= 2 \times 10^4$
* $-1000 <= nums[i] <= 1000$
* $-10^7 <= k <= 10^7$ | ### 前缀和 + 哈希表
这是一道经典的前缀和运用题。
统计以每一个 $nums[i]$ 为结尾,和为 $k$ 的子数组数量即是答案。
我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于求解以某一个 $nums[i]$ 为结尾的,和为 $k$ 的子数组数量,本质上是求解在 $[0, i]$ 中,`sum` 数组中有多少个值为 $sum[i + 1] - k$ 的数,这可以在遍历过程中使用「哈希表」进行同步记录。
Java 代码:
```Java
class Solution {
public int subarraySum(int[] nums, int k) {
int n = nums.length, ans = 0;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
Map<Integer, Integer> map = new HashMap<>();
map.put(0, 1);
for (int i = 1; i <= n; i++) {
int t = sum[i], d = t - k;
ans += map.getOrDefault(d, 0);
map.put(t, map.getOrDefault(t, 0) + 1);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function subarraySum(nums: number[], k: number): number {
let n = nums.length, ans = 0
const sum = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1]
const map = new Map<number, number>()
map.set(0, 1)
for (let i = 1; i <= n; i++) {
const t = sum[i], d = t - k
if (map.has(d)) ans += map.get(d)
map.set(t, map.has(t) ? map.get(t) + 1 : 1)
}
return ans
};
```
* 时间复杂度:预处理前缀和的复杂度为 $O(n)$,统计答案的复杂度为 $O(n)$。整体复杂度为 $O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 010` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 011. 0 和 1 个数相同的子数组（中等）.md | 剑指 Offer II 011. 0 和 1 个数相同的子数组 | https://leetcode-cn.com/problems/contiguous-array/solution/gong-shui-san-xie-qian-zhui-he-ha-xi-bia-q400/ | 中等 | [
"前缀和",
"哈希表"
] | 给定一个二进制数组 `nums` , 找到含有相同数量的 $0$ 和 $1$ 的最长连续子数组,并返回该子数组的长度。
示例 1:
```
输入: nums = [0,1]
输出: 2
说明: [0, 1] 是具有相同数量0和1的最长连续子数组。
```
示例 2:
```
输入: nums = [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。
```
提示:
* $1 <= nums.length <= 10^5$
* `nums[i]` 不是 $0$ 就是 $1$ | ### 前缀和 + 哈希表
根据题意,我们可以轻易发现如下性质:如果答案非 $0$,那么子数组长度必然为偶数,且长度至少为 $2$。
具体的,我们在预处理前缀和时,将 $nums[i]$ 为 $0$ 的值当做 $-1$ 处理。
从而将问题转化为:**如何求得最长一段区间和为 $0$ 的子数组。** 同时使用「哈希表」来记录「某个前缀和出现的最小下标」是多少。
Java 代码:
```Java
class Solution {
public int findMaxLength(int[] nums) {
int n = nums.length, ans = 0;
int[] sum = new int[n + 10];
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1);
Map<Integer, Integer> map = new HashMap<>();
map.put(0, 0);
for (int i = 1; i <= n; i++) {
int t = sum[i];
if (map.containsKey(t)) ans = Math.max(ans, i - map.get(t));
if (!map.containsKey(t)) map.put(t, i);
}
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function findMaxLength(nums: number[]): number {
let n = nums.length, ans = 0
const sum = new Array<number>(n + 10).fill(0)
for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1)
const map = new Map<number, number>()
map.set(0, 0)
for (let i = 1; i <= n; i++) {
const t = sum[i]
if (map.has(t)) ans = Math.max(ans, i - map.get(t))
if (!map.has(t)) map.set(t, i)
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 029. 排序的循环链表（中等）.md | 剑指 Offer II 029. 排序的循环链表 | https://leetcode.cn/problems/4ueAj6/solution/by-ac_oier-kqv3/ | 中等 | [
"链表",
"模拟"
] | 给定循环单调非递减列表中的一个点,写一个函数向这个列表中插入一个新元素 `insertVal`,使这个列表仍然是循环升序的。
给定的可以是这个列表中任意一个顶点的指针,并不一定是这个列表中最小元素的指针。
如果有多个满足条件的插入位置,可以选择任意一个位置插入新的值,插入后整个列表仍然保持有序。
如果列表为空(给定的节点是 `null`),需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。
示例 1:
```
输入:head = [3,4,1], insertVal = 2
输出:[3,4,1,2]
```
```
解释:在上图中,有一个包含三个元素的循环有序列表,你获得值为 3 的节点的指针,我们需要向表中插入元素 2 。新插入的节点应该在 1 和 3 之间,插入之后,整个列表如上图所示,最后返回节点 3 。
```
示例 2:
```
输入:head = [], insertVal = 1
输出:[1]
解释:列表为空(给定的节点是 null),创建一个循环有序列表并返回这个节点。
```
示例 3:
```
输入:head = [1], insertVal = 0
输出:[1,0]
```
提示:
* $0 <= Number of Nodes <= 5 \times 10^4$
* $-10^6 <= Node.val <= 10^6$
* $-10^6 <= insertVal <= 10^6$ | ### 链表
这是一道常规的链表模拟题。
为了方便,我们记 `insertVal` 为 `x`,记 `head` 为 `he`。
起始我们先将待插入的节点创建出来,记为 `t`,当 `he` 为空时,直接返回 `t` 即可。
由于我们需要返回原本的头结点,因此我们先使用变量 `ans` 对原始的 `he` 进行转存,随后复用 `he` 来充当游标进行遍历。
我们先对链表进行一次完成遍历,遍历过程中维护节点最值 `max` 和 `min`,由于链表是循环的,我们需要使用 `he.next != ans` 作为我们循环的结束条件,含义为回到链表开头。
此时根据最大值和最小值是否相等(即整段链表值是否一致)来进行分情况讨论:
* 若满足 `max = min`,此时目标节点 `t` 插入在哪个位置都满足条件,我们直接将其与 `ans` 关联即可;
* 若不满足 `max = min`,此时我们先对链表进行一次遍历,找到有序列表的结束点(结束点的定义为:当前节点值为最大值,下一节点值为最小值。即为有序链表分割位置的左端点),在根据「插入值 `x` 是否为新链表的最值」进行分情况讨论:
* 若满足 $x >= max$ 或 $x <= min$ ,说明目标节点 `t` 插入分割位置即可;
* 若不满足上述两条件,需要从分割位置出发,找到目标插入位置,即满足 `he.val <= x && x <= he.next.val` 的位置。
代码:
```Java
class Solution {
public Node insert(Node he, int x) {
Node t = new Node(x);
t.next = t;
if (he == null) return t;
Node ans = he;
int min = he.val, max = he.val;
while (he.next != ans) {
he = he.next;
min = Math.min(min, he.val);
max = Math.max(max, he.val);
}
if (min == max) {
t.next = ans.next;
ans.next = t;
} else {
while (!(he.val == max && he.next.val == min)) he = he.next;
while (!(x <= min || x >= max) && !(he.val <= x && x <= he.next.val)) he = he.next;
t.next = he.next;
he.next = t;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 029` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器（中等）.md | 剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器 | https://leetcode-cn.com/problems/FortPu/solution/by-ac_oier-rls4/ | 中等 | [
"数据结构",
"哈希表"
] | 实现 `RandomizedSet` 类:
* `RandomizedSet()` 初始化 `RandomizedSet` 对象
* `bool insert(int val)` 当元素 `val` 不存在时,向集合中插入该项,并返回 `true`;否则,返回 `false`。
* `bool remove(int val)` 当元素 `val` 存在时,从集合中移除该项,并返回 `true`;否则,返回 `false`。
* `int getRandom()` 随机返回现有集合中的一项(测试用例保证调用此方法时集合中至少存在一个元素)。每个元素应该有 相同的概率 被返回。
你必须实现类的所有函数,并满足每个函数的 平均 时间复杂度为 $O(1)$ 。
示例:
```
输入
["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
[[], [1], [2], [2], [], [1], [2], []]
输出
[null, true, false, true, 2, true, false, 2]
解释
RandomizedSet randomizedSet = new RandomizedSet();
randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomizedSet.remove(2); // 返回 false ,表示集合中不存在 2 。
randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
randomizedSet.remove(1); // 从集合中移除 1 ,返回 true 。集合现在包含 [2] 。
randomizedSet.insert(2); // 2 已在集合中,所以返回 false 。
randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字,getRandom 总是返回 2 。
```
提示:
* $-2^{31} <= val <= 2^{31} - 1$
* 最多调用 `insert`、`remove` 和 `getRandom` 函数 $2 * 10^5$ 次
* 在调用 `getRandom` 方法时,数据结构中 至少存在一个 元素。 | ### 哈希表 + 删除交换
对于 `insert` 和 `remove` 操作容易想到使用「哈希表」来实现 $O(1)$ 复杂度,但对于 `getRandom` 操作,比较理想的情况是能够在一个数组内随机下标进行返回。
将两者结合,我们可以将哈希表设计为:以入参 `val` 为键,数组下标 `loc` 为值。
**为了确保严格 $O(1)$,我们不能「使用拒绝采样」和「在数组非结尾位置添加/删除元素」。**
因此我们需要申请一个足够大的数组 `nums`(利用数据范围为 $2* 10^5$),并使用变量 `idx` 记录当前使用到哪一位(即下标在 $[0, idx]$ 范围内均是存活值)。
对于几类操作逻辑:
* `insert` 操作:使用哈希表判断 `val` 是否存在,存在的话返回 `false`,否则将其添加到 `nums`,更新 `idx`,同时更新哈希表;
* `remove` 操作:使用哈希表判断 `val` 是否存在,不存在的话返回 `false`,否则从哈希表中将 `val` 删除,同时取出其所在 `nums` 的下标 `loc`,然后将 `nums[idx]` 赋值到 `loc` 位置,并更新 `idx`(含义为将原本处于 `loc` 位置的元素删除),同时更新原本位于 `idx` 位置的数在哈希表中的值为 `loc`(若 `loc` 与 `idx` 相等,说明删除的是最后一个元素,这一步可跳过);
* `getRandom` 操作:由于我们人为确保了 $[0, idx]$ 均为存活值,因此直接在 $[0, idx + 1)$ 范围内进行随机即可。
代码:
```Java
class RandomizedSet {
static int[] nums = new int[200010];
Random random = new Random();
Map<Integer, Integer> map = new HashMap<>();
int idx = -1;
public boolean insert(int val) {
if (map.containsKey(val)) return false;
nums[++idx] = val;
map.put(val, idx);
return true;
}
public boolean remove(int val) {
if (!map.containsKey(val)) return false;
int loc = map.remove(val);
if (loc != idx) map.put(nums[idx], loc);
nums[loc] = nums[idx--];
return true;
}
public int getRandom() {
return nums[random.nextInt(idx + 1)];
}
}
```
* 时间复杂度:所有操作均为 $O(1)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 030` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 041. 滑动窗口的平均值（简单）.md | 剑指 Offer II 041. 滑动窗口的平均值 | https://leetcode.cn/problems/qIsx9U/solution/by-ac_oier-g5ha/ | 简单 | [
"模拟",
"队列"
] | 给定一个整数数据流和一个窗口大小,根据该滑动窗口的大小,计算滑动窗口里所有数字的平均值。
实现 `MovingAverage` 类:
* `MovingAverage(int size)` 用窗口大小 `size` 初始化对象。
* `double next(int val)` 成员函数 `next` 每次调用的时候都会往滑动窗口增加一个整数,请计算并返回数据流中最后 `size` 个值的移动平均值,即滑动窗口里所有数字的平均值。
示例:
```
输入:
inputs = ["MovingAverage", "next", "next", "next", "next"]
inputs = [[3], [1], [10], [3], [5]]
输出:
[null, 1.0, 5.5, 4.66667, 6.0]
解释:
MovingAverage movingAverage = new MovingAverage(3);
movingAverage.next(1); // 返回 1.0 = 1 / 1
movingAverage.next(10); // 返回 5.5 = (1 + 10) / 2
movingAverage.next(3); // 返回 4.66667 = (1 + 10 + 3) / 3
movingAverage.next(5); // 返回 6.0 = (10 + 3 + 5) / 3
```
提示:
* $1 <= size <= 1000$
* $-10^5 <= val <= 10^5$
* 最多调用 `next` 方法 $10^4$ 次 | ### 双端队列
根据题意,我们可以使用变量 `n` 将初始化传入的 `size` 进行转存,同时使用「双端队列」来存储 `next` 所追加的值(添加到队列尾部),当双端队列所包含元素超过规定数量 `n` 时,我们从队列头部进行 `pop` 操作,整个维护过程使用变量 `sum` 记录当前包含的元素和。
利用 `next` 操作最多被调用 $10^4$ 次,我们可以使用直接开个 $10^4$ 数组来充当双端队列,使用两指针 `j` 和 `i` 分别指向队列的头部和尾部。
Java 代码:
```Java
class MovingAverage {
int[] arr = new int[10010];
int n, sum, j, i;
public MovingAverage(int size) {
n = size;
}
public double next(int val) {
sum += arr[i++] = val;
if (i - j > n) sum -= arr[j++];
return sum * 1.0 / (i - j);
}
}
```
Typescript 代码:
```Typescript
class MovingAverage {
arr: number[] = new Array<number>(10010).fill(0)
n: number = 0; sum: number = 0; i: number = 0; j: number = 0;
constructor(size: number) {
this.n = size
}
next(val: number): number {
this.sum += this.arr[this.i++] = val
if (this.i - this.j > this.n) this.sum -= this.arr[this.j++]
return this.sum / (this.i - this.j)
}
}
```
* 时间复杂度:$O(m)$,其中 $m$ 为 `next` 操作的调用次数
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 041` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 067. 最大的异或（中等）.md | 剑指 Offer II 067. 最大的异或 | https://leetcode.cn/problems/ms70jA/solution/by-ac_oier-d9kx/ | 中等 | [
"贪心",
"字典树"
] | 给定一个整数数组 `nums`,返回 `nums[i] XOR nums[j]` 的最大运算结果,其中 $0 ≤ i ≤ j < n$ 。
示例 1:
```
输入:nums = [3,10,5,25,2,8]
输出:28
解释:最大运算结果是 5 XOR 25 = 28.
```
示例 2:
```
输入:nums = [0]
输出:0
```
示例 3:
```
输入:nums = [2,4]
输出:6
```
示例 4:
```
输入:nums = [8,10,2]
输出:10
```
示例 5:
```
输入:nums = [14,70,53,83,49,91,36,80,92,51,66,70]
输出:127
```
提示:
* $1 <= nums.length <= 2 \times 10^4$
* $0 <= nums[i] <= 2^{31} - 1$
进阶:你可以在 $O(n)$ 的时间解决这个问题吗? | ### 基本分析
要求得数组 `nums` 中的「最大异或结果」,假定 $nums[i]$ 与 $nums[j]$ 异或可以取得最终结果。
**由于异或计算「每位相互独立」(又称为不进位加法),同时具有「相同值异或结果为 $0$,不同值异或结果为 $1$」的特性。**
因此对于 $nums[j]$ 而言,可以从其二进制表示中的最高位开始往低位找,尽量让每一位的异或结果为 $1$,这样找到的 $nums[i]$ 与 $nums[j]$ 的异或结果才是最大的。
具体的,我们需要先将 `nums` 中下标范围为 $[0, j]$ 的数(二进制表示)加入 $Trie$ 中,然后每次贪心的匹配每一位(优先匹配与之不同的二进制位)。
---
### 证明
由于我们会从前往后扫描 `nums` 数组,因此 $nums[j]$ 必然会被处理到,所以我们只需要证明,在选定 $nums[j]$ 的情况下,我们的算法能够在 $[0, j]$ 范围内找到 $nums[i]$ 即可。
假定我们算法找出来的数值与 $nums[j]$ 的异或结果为 $x$,而真实的最优异或结果为 $y$。
接下来需要证得 $x$ 和 $y$ 相等。
由于找的是「最大异或结果」, 而 $x$ 是一个合法值,因此我们天然有 $x \leq y$。
然后利用反证法证明 $x \geq y$,假设 $x \geq y$ 不成立,即有 $x < y$,那么从两者的二进制表示的高位开始找,必然能找到第一位不同:$y$ 的「不同位」的值为 $1$,而 $x$ 的「不同位」的值为 $0$。
那么对应到选择这一个「不同位」的逻辑:能够选择与 $nums[j]$ 该位不同的值,使得该位的异或结果为 $1$,但是我们的算法选择了与 $nums[j]$ 该位相同的值,使得该位的异或结果为 $0$。
这与我们的算法逻辑冲突,因此必然不存在这样的「不同位」。即 $x < y$ 不成立,反证 $x \geq y$ 成立。
得证 $x$ 与 $y$ 相等。
---
### Trie 数组实现
可以使用数组来实现 $Trie$,但由于 OJ 每跑一个样例都会创建一个新的对象,因此使用数组实现,相当于每跑一个数据都需要 `new` 一个百万级别的数组,会 TLE 。
因此这里使用数组实现必须要做的一个优化是:**使用 `static` 来修饰 $Trie$ 数组,然后在初始化时做相应的清理工作。**
担心有不熟 Java 的同学,在代码里添加了相应注释说明。
代码:
```Java
class Solution {
// static 成员整个类独一份,只有在类首次加载时才会创建,因此只会被 new 一次
static int N = (int)1e6;
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) {
ans |= (b << i);
p = trie[p][b];
} else {
ans |= (a << i);
p = trie[p][a];
}
}
return ans;
}
public int findMaximumXOR(int[] nums) {
int ans = 0;
for (int i : nums) {
add(i);
int j = getVal(i);
ans = Math.max(ans, i ^ j);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1e6)$
---
### Trie 类实现
相比于使用 `static` 来优化,一个更好的做法是使用类来实现 $Trie$,这样可以真正做到「按需分配」内存,缺点是会发生不确定次数的 `new`。
代码:
```Java
class Solution {
class Node {
Node[] ns = new Node[2];
}
Node root = new Node();
void add(int x) {
Node p = root;
for (int i = 31; i >= 0; i--) {
int u = (x >> i) & 1;
if (p.ns[u] == null) p.ns[u] = new Node();
p = p.ns[u];
}
}
int getVal(int x) {
int ans = 0;
Node p = root;
for (int i = 31; i >= 0; i--) {
int a = (x >> i) & 1, b = 1 - a;
if (p.ns[b] != null) {
ans |= (b << i);
p = p.ns[b];
} else {
ans |= (a << i);
p = p.ns[a];
}
}
return ans;
}
public int findMaximumXOR(int[] nums) {
int ans = 0;
for (int i : nums) {
add(i);
int j = getVal(i);
ans = Math.max(ans, i ^ j);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer II 067` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 069. 山峰数组的顶部（简单）.md | 剑指 Offer II 069. 山峰数组的顶部 | https://leetcode-cn.com/problems/B1IidL/solution/gong-shui-san-xie-er-fen-san-fen-ji-zhi-lc8zl/ | 简单 | [
"二分",
"三分"
] | 符合下列属性的数组 `arr` 称为 山峰数组(山脉数组) :
* `arr.length >= 3`
* 存在 `i`(`0 < i < arr.length - 1`)使得:
* `arr[0] < arr[1] < ... arr[i-1] < arr[i]`
* `arr[i] > arr[i+1] > ... > arr[arr.length - 1]`
给定由整数组成的山峰数组 arr ,返回任何满足 `arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1]` 的下标 `i` ,即山峰顶部。
示例 1:
```
输入:arr = [0,1,0]
输出:1
```
示例 2:
```
输入:arr = [1,3,5,4,2]
输出:2
```
示例 3:
```
输入:arr = [0,10,5,2]
输出:1
```
示例 4:
```
输入:arr = [3,4,5,1]
输出:2
```
示例 5:
```
输入:arr = [24,69,100,99,79,78,67,36,26,19]
输出:2
```
提示:
* 3 <= arr.length <= $10^4$
* 0 <= arr[i] <= $10^6$
* 题目数据保证 arr 是一个山脉数组
**进阶:很容易想到时间复杂度 O(n) 的解决方案,你可以设计一个 O(log(n)) 的解决方案吗?** | ### 二分
往常我们使用「二分」进行查值,需要确保序列本身满足「二段性」:当选定一个端点(基准值)后,结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。
但本题求的是峰顶索引值,如果我们选定数组头部或者尾部元素,其实无法根据大小关系“直接”将数组分成两段。
但可以利用题目发现如下性质:**由于 `arr` 数值各不相同,因此峰顶元素左侧必然满足严格单调递增,峰顶元素右侧必然不满足。**
因此 **以峰顶元素为分割点的 `arr` 数组,根据与 前一元素/后一元素 的大小关系,具有二段性:**
* 峰顶元素左侧满足 $arr[i-1] < arr[i]$ 性质,右侧不满足
* 峰顶元素右侧满足 $arr[i] > arr[i+1]$ 性质,左侧不满足
因此我们可以选择任意条件,写出若干「二分」版本。
代码:
```Java
class Solution {
// 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 1, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (arr[mid - 1] < arr[mid]) l = mid;
else r = mid - 1;
}
return r;
}
}
```
```Java
class Solution {
// 根据 arr[i] > arr[i+1] 在 [0,n-2] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素值
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 0, r = n - 2;
while (l < r) {
int mid = l + r >> 1;
if (arr[mid] > arr[mid + 1]) r = mid;
else l = mid + 1;
}
return r;
}
}
```
```Java
class Solution {
// 根据 arr[i-1] > arr[i] 在 [1,n-1] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素的前一个值
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 1, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (arr[mid - 1] > arr[mid]) r = mid;
else l = mid + 1;
}
return r - 1;
}
}
```
```Java
class Solution {
// 根据 arr[i] < arr[i+1] 在 [0,n-2] 范围内找值
// 峰顶元素为符合条件的最靠近中心的元素的下一个值
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 0, r = n - 2;
while (l < r) {
int mid = l + r + 1 >> 1;
if (arr[mid] < arr[mid + 1]) l = mid;
else r = mid - 1;
}
return r + 1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 三分
事实上,我们还可以利用「三分」来解决这个问题。
顾名思义,**「三分」就是使用两个端点将区间分成三份,然后通过每次否决三分之一的区间来逼近目标值。**
具体的,由于峰顶元素为全局最大值,因此我们可以每次将当前区间分为 $[l, m1]$、$[m1, m2]$ 和 $[m2, r]$ 三段,如果满足 $arr[m1] > arr[m2]$,说明峰顶元素不可能存在与 $[m2, r]$ 中,让 $r = m2 - 1$ 即可。另外一个区间分析同理。
代码:
```Java
class Solution {
public int peakIndexInMountainArray(int[] arr) {
int n = arr.length;
int l = 0, r = n - 1;
while (l < r) {
int m1 = l + (r - l) / 3;
int m2 = r - (r - l) / 3;
if (arr[m1] > arr[m2]) r = m2 - 1;
else l = m1 + 1;
}
return r;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 二分 & 三分 & k 分 ?
必须说明一点,「二分」和「三分」在渐进复杂度上都是一样的,都可以通过换底公式转化为可忽略的常数,因此两者的复杂度都是 $O(\log{n})$。
因此选择「二分」还是「三分」取决于要解决的是什么问题:
* 二分通常用来解决单调函数的找 $target$ 问题,但进一步深入我们发现只需要满足「二段性」就能使用「二分」来找分割点;
* 三分则是解决单峰函数极值问题。
**因此一般我们将「通过比较两个端点,每次否决 1/3 区间 来解决单峰最值问题」的做法称为「三分」;而不是简单根据单次循环内将区间分为多少份来判定是否为「三分」。**
随手写了一段反例代码:
```Java
class Solution {
public int peakIndexInMountainArray(int[] arr) {
int left = 0, right = arr.length - 1;
while(left < right) {
int m1 = left + (right - left) / 3;
int m2 = right - (right - left + 2) / 3;
if (arr[m1] > arr[m1 + 1]) {
right = m1;
} else if (arr[m2] < arr[m2 + 1]) {
left = m2 + 1;
} else {
left = m1;
right = m2;
}
}
return left;
}
}
```
这并不是「三分」做法,最多称为「变形二分」。本质还是利用「二段性」来做分割的,只不过同时 check 了两个端点而已。
如果这算「三分」的话,那么我能在一次循环里面划分 $k - 1$ 个端点来实现 $k$ 分?
**显然这是没有意义的,因为按照这种思路写出来的所谓的「四分」、「五分」、「k 分」是需要增加同等数量的分支判断的。这时候单次 `while` 决策就不能算作 $O(1)$ 了,而是需要在 $O(k)$ 的复杂度内决定在哪个分支,就跟上述代码有三个分支进行判断一样。** 因此,这种写法只能算作是「变形二分」。
**综上,只有「二分」和「三分」的概念,不存在所谓的 $k$ 分。** 同时题解中的「三分」部分提供的做法就是标准的「三分」做法。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer II 069` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 091. 粉刷房子（中等）.md | 剑指 Offer II 091. 粉刷房子 | https://leetcode.cn/problems/JEj789/solution/by-ac_oier-6v2v/ | 中等 | [
"状态机 DP",
"动态规划"
] | 假如有一排房子,共 `n` 个,每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种,你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。
当然,因为市场上不同颜色油漆的价格不同,所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 `n x 3` 的正整数矩阵 `costs` 来表示的。
例如,`costs[0][0]` 表示第 $0$ 号房子粉刷成红色的成本花费;`costs[1][2]` 表示第 $1$ 号房子粉刷成绿色的花费,以此类推。
请计算出粉刷完所有房子最少的花费成本。
示例 1:
```
输入: costs = [[17,2,17],[16,16,5],[14,3,19]]
输出: 10
解释: 将 0 号房子粉刷成蓝色,1 号房子粉刷成绿色,2 号房子粉刷成蓝色。
最少花费: 2 + 5 + 3 = 10。
```
示例 2:
```
输入: costs = [[7,6,2]]
输出: 2
```
提示:
* $costs.length == n$
* $costs[i].length == 3$
* $1 <= n <= 100$
* $1 <= costs[i][j] <= 20$ | ### 状态机 DP
为了方便,我们记 `costs` 为 `cs`。
根据题意,当我们从前往后决策每间房子的颜色时,当前房子所能刷的颜色,取决于上一间房子的颜色。
我们可以定义 $f[i][j]$ 为考虑下标不超过 $i$ 的房子,且最后一间房子颜色为 $j$ 时的最小成本。
起始我们有 $f[0][i] = cs[0][i]$,代表只有第一间房子时,对应成本为第一间房子的上色成本。
然后不失一般性考虑,$f[i][j]$ 该如何计算:$f[i][j]$ 为所有 $f[i - 1][prev]$(其中 $prev \neq j$)中的最小值加上 $cs[i][j]$。
本质上这是一道「状态机 DP」问题:某些状态只能由规则限定的状态所转移,通常我们可以从 $f[i][j]$ 能够更新哪些目标状态(后继状态)进行转移,也能够从 $f[i][j]$ 依赖哪些前置状态(前驱状态)来转移。
一些细节:考虑到我们 $f[i][X]$ 的计算只依赖于 $f[i - 1][X]$,因此我们可以使用三个变量来代替我们的动规数组。
Java 代码:
```Java
class Solution {
public int minCost(int[][] cs) {
int n = cs.length;
int a = cs[0][0], b = cs[0][1], c = cs[0][2];
for (int i = 1; i < n; i++) {
int d = Math.min(b, c) + cs[i][0];
int e = Math.min(a, c) + cs[i][1];
int f = Math.min(a, b) + cs[i][2];
a = d; b = e; c = f;
}
return Math.min(a, Math.min(b, c));
}
}
```
Java 代码:
```Java
class Solution {
public int minCost(int[][] cs) {
int n = cs.length;
int a = cs[0][0], b = cs[0][1], c = cs[0][2];
for (int i = 0; i < n - 1; i++) {
int d = Math.min(b, c) + cs[i + 1][0];
int e = Math.min(a, c) + cs[i + 1][1];
int f = Math.min(a, b) + cs[i + 1][2];
a = d; b = e; c = f;
}
return Math.min(a, Math.min(b, c));
}
}
```
* 时间复杂度:$O(n \times C)$,其中 $C = 3$ 为颜色数量
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 091` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 114. 外星文字典（困难）.md | 剑指 Offer II 114. 外星文字典 | https://leetcode.cn/problems/Jf1JuT/solution/by-ac_oier-4xmv/ | 困难 | [
"图论",
"拓扑排序",
"建图",
"图论 BFS"
] | 现有一种使用英语字母的外星文语言,这门语言的字母顺序与英语顺序不同。
给定一个字符串列表 `words` ,作为这门语言的词典,`words` 中的字符串已经 按这门新语言的字母顺序进行了排序 。
请你根据该词典还原出此语言中已知的字母顺序,并 按字母递增顺序 排列。若不存在合法字母顺序,返回 `""` 。若存在多种可能的合法字母顺序,返回其中 任意一种 顺序即可。
字符串 `s` 字典顺序小于 字符串 `t` 有两种情况:
在第一个不同字母处,如果 `s` 中的字母在这门外星语言的字母顺序中位于 `t` 中字母之前,那么 `s` 的字典顺序小于 `t` 。
如果前面 `min(s.length, t.length)` 字母都相同,那么 `s.length < t.length` 时,`s` 的字典顺序也小于 `t` 。
示例 1:
```
输入:words = ["wrt","wrf","er","ett","rftt"]
输出:"wertf"
```
示例 2:
```
输入:words = ["z","x"]
输出:"zx"
```
示例 3:
```
输入:words = ["z","x","z"]
输出:""
解释:不存在合法字母顺序,因此返回 "" 。
```
提示:
* $1 <= words.length <= 100$
* $1 <= words[i].length <= 100$
* `words[i]` 仅由小写英文字母组成 | ### 建图 + 拓扑排序
为了方便,我们称 `words` 为 `ws`,同时将两个字符串 `a` 和 `b` 之间的字典序关系简称为「关系」。
由于数组长度和每个 $ws[i]$ 的最大长度均为 $100$,我们可以实现复杂度为 $O(n^3)$ 的算法。
首先容易想到,我们从前往后处理每个 $ws[i]$,利用 `ws` 数组本身已按字典序排序,然后通过 $ws[i]$ 与 $ws[j]$ 的关系(其中 $j$ 的范围为 $[0, i - 1]$),来构建字符之间的关系。
具体的,当我们明确字符 $c1$ 比 $c2$ 字典序要小,可以建立从 $c1$ 到 $c2$ 的有向边,同时统计增加 $c1$ 的出度,增加 $c2$ 的入度。
当建图完成后,我们从所有入度为 $0$ 的点开始(含义为没有比这些字符字典序更小的字符),跑一遍拓扑排序:在 `BFS` 过程中,不断的删点(出队的点可以看做从图中移除)和更新删除点的出边点的入度,若有新的入度为 $0$ 的点,则将其进行入队操作。
> **不了解拓扑排序的同学可以看前置 🧀 : [图论拓扑排序入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489706&idx=1&sn=771cd807f39d1ca545640c0ef7e5baec)**
若最终出队节点数量与总数量 $cnt$ 相等,说明这是一张拓扑图(无环,字符之间不存在字典序冲突),出队的顺序即是字典序,否则存在冲突,返回空串。
代码:
```Java
class Solution {
int N = 26, M = N * N, idx = 0, cnt = 0;
int[] he = new int[N], e = new int[M], ne = new int[M];
int[] in = new int[N], out = new int[N];
boolean[] vis = new boolean[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
out[a]++; in[b]++;
}
public String alienOrder(String[] ws) {
int n = ws.length;
Arrays.fill(he, -1);
for (int i = 0; i < n; i++) {
for (char c : ws[i].toCharArray()) {
if (!vis[c - 'a'] && ++cnt >= 0) vis[c - 'a'] = true;
}
for (int j = 0; j < i; j++) {
if (!build(ws[j], ws[i])) return "";
}
}
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < 26; i++) {
if (vis[i] && in[i] == 0) d.addLast(i);
}
StringBuilder sb = new StringBuilder();
while (!d.isEmpty()) {
int u = d.pollFirst();
sb.append((char)(u + 'a'));
for (int i = he[u]; i != -1; i = ne[i]) {
int j = e[i];
if (--in[j] == 0) d.addLast(j);
}
}
return sb.length() == cnt ? sb.toString() : "";
}
boolean build(String a, String b) {
int n = a.length(), m = b.length(), len = Math.min(n, m);
for (int i = 0; i < len; i++) {
int c1 = a.charAt(i) - 'a', c2 = b.charAt(i) - 'a';
if (c1 != c2) {
add(c1, c2);
return true;
}
}
return n <= m;
}
}
```
* 时间复杂度:令 $n$ 为数组 `ws` 的长度,统计字符数的复杂度为 $O(\sum_{i}^{n - 1} len(ws[i]))$,建图复杂度为 $O(n^3)$;跑拓扑序构建答案复杂度 $O(n^2)$。整体复杂度为 $O(n^3)$
* 空间复杂度:$O(C^2)$,其中 $C = 26$ 为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 114` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 115. 重建序列（中等）.md | 剑指 Offer II 115. 重建序列 | https://leetcode.cn/problems/ur2n8P/solution/by-ac_oier-oqxs/ | 中等 | [
"图论",
"拓扑排序",
"建图",
"图论 BFS"
] | 给定一个长度为 `n` 的整数数组 `nums` ,其中 `nums` 是范围为 $[1,n]$ 的整数的排列。还提供了一个 `2D` 整数数组 `sequences`,其中 `sequences[i]` 是 `nums` 的子序列。
检查 `nums` 是否是唯一的最短 超序列 。最短 超序列 是 长度最短 的序列,并且所有序列 `sequences[i]` 都是它的子序列。对于给定的数组 `sequences`,可能存在多个有效的 超序列 。
* 例如,对于 `sequences = [[1,2],[1,3]]` ,有两个最短的 超序列,`[1,2,3]` 和 `[1,3,2]` 。
* 而对于 `sequences = [[1,2],[1,3],[1,2,3]]`,唯一可能的最短 超序列 是 `[1,2,3]` 。`[1,2,3,4]` 是可能的超序列,但不是最短的。
如果 `nums` 是序列的唯一最短 超序列 ,则返回 `true` ,否则返回 `false` 。
子序列 是一个可以通过从另一个序列中删除一些元素或不删除任何元素,而不改变其余元素的顺序的序列。
示例 1:
```
输入:nums = [1,2,3], sequences = [[1,2],[1,3]]
输出:false
解释:有两种可能的超序列:[1,2,3]和[1,3,2]。
序列 [1,2] 是[1,2,3]和[1,3,2]的子序列。
序列 [1,3] 是[1,2,3]和[1,3,2]的子序列。
因为 nums 不是唯一最短的超序列,所以返回false。
```
示例 2:
```
输入:nums = [1,2,3], sequences = [[1,2]]
输出:false
解释:最短可能的超序列为 [1,2]。
序列 [1,2] 是它的子序列:[1,2]。
因为 nums 不是最短的超序列,所以返回false。
```
示例 3:
```
输入:nums = [1,2,3], sequences = [[1,2],[1,3],[2,3]]
输出:true
解释:最短可能的超序列为[1,2,3]。
序列 [1,2] 是它的一个子序列:[1,2,3]。
序列 [1,3] 是它的一个子序列:[1,2,3]。
序列 [2,3] 是它的一个子序列:[1,2,3]。
因为 nums 是唯一最短的超序列,所以返回true。
```
提示:
* $n == nums.length$
* $1 <= n <= 104$
* `nums` 是 $[1, n]$ 范围内所有整数的排列
* $1 <= sequences.length <= 10^4$
* $1 <= sequences[i].length <= 104$
* $1 <= sum(sequences[i].length) <= 10^5$
* $1 <= sequences[i][j] <= n$
* `sequences` 的所有数组都是 唯一 的
* `sequences[i]` 是 `nums` 的一个子序列 | ### 拓扑排序 + 构造
为了方便,我们令 `sequences` 为 `ss`。
根据题意,如果我们能够利用所有的 $ss[i]$ 构造出一个唯一的序列,且该序列与 `nums` 相同,则返回 `True`,否则返回 `False`。
将每个 $ss[i]$ 看做对 $ss[i]$ 所包含点的前后关系约束,我们可以将问题转换为拓扑排序问题。
利用所有 $ss[i]$ 构造新图:对于 $ss[i] = [A_1, A_2, ..., A_k]$,我们将其转换为点 $A_1$ -> $A_2$ -> ... -> $A_k$ 的有向图,同时统计每个点的入度情况。
然后在新图上跑一遍拓扑排序,构造对应的拓扑序列,与 `nums` 进行对比。
实现上,由于拓扑排序过程中,出点的顺序即为拓扑序,因此我们并不需要完整保存整个拓扑序,只需使用一个变量 `loc` 来记录当前拓扑序的下标,将出点 $t$ 与 $nums[loc]$ 做比较即可。
在拓扑序过程中若有 $t$ 不等于 $nums[loc]$(构造出来的方案与 `nums` 不同) 或某次拓展过程中发现队列元素不止 $1$ 个(此时可能的原因有 :「起始入度为 $0$ 的点不止一个或存在某些点根本不在 $ss$ 中」或「单次拓展新产生的入度为 $0$ 的点不止一个,即拓扑序不唯一」),则直接返回 `False`,
Java 代码:
```Java
class Solution {
int N = 10010, M = N, idx;
int[] he = new int[N], e = new int[M], ne = new int[M], in = new int[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = he[a];
he[a] = idx++;
in[b]++;
}
public boolean sequenceReconstruction(int[] nums, int[][] ss) {
int n = nums.length;
Arrays.fill(he, -1);
for (int[] s : ss) {
for (int i = 1; i < s.length; i++) add(s[i - 1], s[i]);
}
Deque<Integer> d = new ArrayDeque<>();
for (int i = 1; i <= n; i++) {
if (in[i] == 0) d.addLast(i);
}
int loc = 0;
while (!d.isEmpty()) {
if (d.size() != 1) return false;
int t = d.pollFirst();
if (nums[loc++] != t) return false;
for (int i = he[t]; i != -1; i = ne[i]) {
int j = e[i];
if (--in[j] == 0) d.addLast(j);
}
}
return true;
}
}
```
TypeScript 代码:
```TypeScript
const N = 10010, M = N
const he: number[] = new Array<number>(N).fill(-1), e = new Array<number>(N).fill(0), ne = new Array<number>(N).fill(0), ind = new Array<number>(N).fill(0);
let idx = 0
function add(a: number, b: number): void {
e[idx] = b
ne[idx] = he[a]
he[a] = idx++
ind[b]++
}
function sequenceReconstruction(nums: number[], ss: number[][]): boolean {
he.fill(-1); ind.fill(0)
idx = 0
const n = nums.length
for (const s of ss) {
for (let i = 1; i < s.length; i++) add(s[i - 1], s[i])
}
const stk: number[] = new Array<number>()
let head = 0, tail = 0
for (let i = 1; i <= n; i++) {
if (ind[i] == 0) stk[tail++] = i
}
let loc = 0
while (head < tail) {
if (tail - head > 1) return false
const t = stk[head++]
if (nums[loc++] != t) return false
for (let i = he[t]; i != -1; i = ne[i]) {
const j = e[i]
if (--ind[j] == 0) stk[tail++] = j
}
}
return true
};
```
* 时间复杂度:建图复杂度为 $O(\sum_{i = 0}^{n - 1}ss[i].length)$;跑拓扑排序的复杂度为 $O(n + \sum_{i = 0}^{n - 1}ss[i].length)$。整体复杂度为 $O(n + \sum_{i = 0}^{n - 1}ss[i].length)$
* 空间复杂度: $O(n + \sum_{i = 0}^{n - 1}ss[i].length)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 115` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 04. 二维数组中的查找（中等）.md | 剑指 Offer 04. 二维数组中的查找 | https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/solution/by-ac_oier-7jo0/ | 中等 | [
"二叉树搜索树",
"BST",
"二分"
] | 在一个 $n \times m$ 的二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个高效的函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
示例:
```
现有矩阵 matrix 如下:
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5,返回 true。
给定 target = 20,返回 false。
```
限制:
* $0 <= n <= 1000$
* $0 <= m <= 1000$ | ### 二分
与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 不同,本题没有确保「每行的第一个整数大于前一行的最后一个整数」,因此我们无法采取「两次二分」的做法。
只能退而求之,遍历行/列,然后再对列/行进行二分。
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
if (matrix.length == 0 || matrix[0].length == 0) return false;
int m = matrix.length, n = matrix[0].length;
for (int i = 0; i < m; i++) {
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (matrix[i][mid] <= target) l = mid;
else r = mid - 1;
}
if (matrix[i][r] == target) return true;
}
return false;
}
}
```
-
```Java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
if (matrix.length == 0 || matrix[0].length == 0) return false;
int m = matrix.length, n = matrix[0].length;
for (int i = 0; i < n; i++) {
int l = 0, r = m - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (matrix[mid][i] <= target) l = mid;
else r = mid - 1;
}
if (matrix[r][i] == target) return true;
}
return false;
}
}
```
* 时间复杂度:$O(m\log{n})$ 或 $O(n\log{m})$
* 空间复杂度:$O(1)$
---
### 抽象 BST
该做法则与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 的「解法二」完全一致。
我们可以将二维矩阵抽象成「以右上角为根的 BST」:
那么我们可以从根(右上角)开始搜索,如果当前的节点不等于目标值,可以按照树的搜索顺序进行:
1. 当前节点「大于」目标值,搜索当前节点的「左子树」,也就是当前矩阵位置的「左方格子」,即 $c$--
2. 当前节点「小于」目标值,搜索当前节点的「右子树」,也就是当前矩阵位置的「下方格子」,即 $r$++
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
if (matrix.length == 0 || matrix[0].length == 0) return false;
int m = matrix.length, n = matrix[0].length;
int r = 0, c = n - 1;
while (r < m && c >= 0) {
if (matrix[r][c] < target) r++;
else if (matrix[r][c] > target) c--;
else return true;
}
return false;
}
}
```
* 时间复杂度:$O(m + n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 04` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 06. 从尾到头打印链表（简单）.md | 剑指 Offer 06. 从尾到头打印链表 | https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/by-ac_oier-3qsk/ | 简单 | [
"链表",
"迭代",
"递归",
"双指针"
] | 输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)。
示例 1:
```
输入:head = [1,3,2]
输出:[2,3,1]
```
限制:
* $0 <= 链表长度 <= 10000$ | ### 迭代
使用「迭代」方式求解是极其容易的。
在遍历链表 `head` 时,使用变长数组将节点值进行转存,随后再利用变长数组来「从后往前」构造定长数组并进行返回即可(其中 `TS` 代码无须额外构造定长数组,直接在原有数组基础上使用「双指针」翻转即可)。
Java 代码:
```Java
class Solution {
public int[] reversePrint(ListNode head) {
List<Integer> list = new ArrayList<>();
while (head != null) {
list.add(head.val);
head = head.next;
}
int n = list.size();
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = list.get(n - 1 - i);
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function reversePrint(head: ListNode | null): number[] {
const ans = new Array<number>()
while (head != null) {
ans.push(head.val)
head = head.next
}
const n = ans.length
for (let i = 0, j = n - 1; i < j; i++, j--) {
const c = ans[i]
ans[i] = ans[j]
ans[j] = c
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 递归
使用「递归」求解只需要进行常规的 `DFS` 即可,每次先将当前节点的 `next` 指针进行递归处理,然后再将当前节点值加入数组,即可实现「从后往前」的顺序添加。
Java 代码:
```Java
class Solution {
public int[] reversePrint(ListNode head) {
List<Integer> list = new ArrayList<>();
dfs(head, list);
int n = list.size();
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = list.get(i);
return ans;
}
void dfs(ListNode head, List<Integer> list) {
if (head == null) return ;
dfs(head.next, list);
list.add(head.val);
}
}
```
TypeScript 代码:
```TypeScript
function reversePrint(head: ListNode | null): number[] {
const ans: number[] = new Array<number>()
dfs(head, ans)
return ans
};
function dfs(head: ListNode | null, list: number[]) {
if (head == null) return
dfs(head.next, list)
list.push(head.val)
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 06` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 10- I. 斐波那契数列（简单）.md | 剑指 Offer 10- I. 斐波那契数列 | https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof/solution/gong-shui-san-xie-yi-ti-si-jie-dong-tai-9zip0/ | 简单 | [
"动态规划",
"线性 DP",
"记忆化搜索",
"打表",
"矩阵快速幂"
] | 写一个函数,输入 n ,求斐波那契(Fibonacci)数列的第 n 项(即 F(N))。斐波那契数列的定义如下:
* F(0) = 0, F(1) = 1
* F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始,之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
示例 1:
```
输入:n = 2
输出:1
```
示例 2:
```
输入:n = 5
输出:5
```
提示:
* 0 <= n <= 100 | ### 递推实现动态规划
既然转移方程都给出了,直接根据转移方程从头到尾递递推一遍即可。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int fib(int n) {
if (n <= 1) return n;
int a = 0, b = 1;
for (int i = 2; i <= n; i++) {
int c = a + b;
c %= mod;
a = b;
b = c;
}
return b;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 递归实现动态规划
能以「递推」形式实现动态规划,自然也能以「递归」的形式实现。
为防止重复计算,我们需要加入「记忆化搜索」功能,同时利用某个值 $x$ 在不同的样例之间可能会作为“中间结果”被重复计算,并且计算结果 $fib(x)$ 固定,我们可以使用 `static` 修饰缓存器,以实现计算过的结果在所有测试样例中共享。
代码:
```Java
class Solution {
static int mod = (int)1e9+7;
static int N = 110;
static int[] cache = new int[N];
public int fib(int n) {
if (n <= 1) return n;
if (cache[n] != 0) return cache[n];
cache[n] = fib(n - 1) + fib(n - 2);
cache[n] %= mod;
return cache[n];
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 打表
经过「解法二」,我们进一步发现,可以利用数据范围只有 $100$ 进行打表预处理,然后直接返回。
代码:
```Java
class Solution {
static int mod = (int)1e9+7;
static int N = 110;
static int[] cache = new int[N];
static {
cache[1] = 1;
for (int i = 2; i < N; i++) {
cache[i] = cache[i - 1] + cache[i - 2];
cache[i] %= mod;
}
}
public int fib(int n) {
return cache[n];
}
}
```
* 时间复杂度:将打表逻辑放到本地执行,复杂度为 $O(1)$;否则为 $O(C)$,$C$ 为常量,固定为 $110$
* 空间复杂度:$O(C)$
---
### 矩阵快速幂
**对于数列递推问题,可以使用矩阵快速幂进行加速,最完整的介绍在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488198&idx=1&sn=8272ca6b0ef6530413da4a270abb68bc&chksm=fd9cb9d9caeb30cf6c2defab0f5204adc158969d64418916e306f6bf50ae0c38518d4e4ba146&token=1067450240&lang=zh_CN#rd) 讲过。**
对于本题,某个 $f(n)$ 依赖于 $f(n - 1)$ 和 $f(n - 2)$,将其依赖的状态存成列向量:
$$
\begin{bmatrix}
f(n - 1)\\
f(n - 2)
\end{bmatrix}
$$
目标值 $f(n)$ 所在矩阵为:
$$
\begin{bmatrix}
f(n)\\
f(n - 1)
\end{bmatrix}
$$
根据矩阵乘法,不难发现:
$$
\begin{bmatrix}
f(n)\\
f(n - 1)
\end{bmatrix}
=
\begin{bmatrix}
1& 1\\
1& 0
\end{bmatrix}
*
\begin{bmatrix}
f(n - 1)\\
f(n - 2)
\end{bmatrix}
$$
我们令:
$$
mat =
\begin{bmatrix}
1& 1\\
1& 0
\end{bmatrix}
$$
起始时,我们只有 $
\begin{bmatrix}
f(1)\\
f(0)
\end{bmatrix}
$,根据递推式得:
$$
\begin{bmatrix}
f(n)\\
f(n - 1)
\end{bmatrix}
=
mat * mat * ... * mat *
\begin{bmatrix}
f(1)\\
f(0)
\end{bmatrix}
$$
再根据矩阵乘法具有「结合律」,最终可得:
$$
\begin{bmatrix}
f(n)\\
f(n - 1)
\end{bmatrix}
=
mat^{n - 1}
*
\begin{bmatrix}
f(1)\\
f(0)
\end{bmatrix}
$$
计算 $mat^{n - 1}$ 可以套用「快速幂」进行求解。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
long[][] mul(long[][] a, long[][] b) {
int r = a.length, c = b[0].length, z = b.length;
long[][] ans = new long[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
for (int k = 0; k < z; k++) {
ans[i][j] += a[i][k] * b[k][j];
ans[i][j] %= mod;
}
}
}
return ans;
}
public int fib(int n) {
if (n <= 1) return n;
long[][] mat = new long[][]{
{1, 1},
{1, 0}
};
long[][] ans = new long[][]{
{1},
{0}
};
int x = n - 1;
while (x != 0) {
if ((x & 1) != 0) ans = mul(mat, ans);
mat = mul(mat, mat);
x >>= 1;
}
return (int)(ans[0][0] % mod);
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 10- I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 11. 旋转数组的最小数字（简单）.md | 剑指 Offer 11. 旋转数组的最小数字 | https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/solution/by-ac_oier-p751/ | 简单 | [
"二分"
] | 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。
给你一个可能存在 重复 元素值的数组 `numbers`,它原来是一个升序排列的数组,并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如,数组 `[3,4,5,1,2]` 为 `[1,2,3,4,5]` 的一次旋转,该数组的最小值为 $1$。
注意,数组 `[a[0], a[1], a[2], ..., a[n-1]]` 旋转一次 的结果为数组 `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`。
示例 1:
```
输入:numbers = [3,4,5,1,2]
输出:1
```
示例 2:
```
输入:numbers = [2,2,2,0,1]
输出:0
```
提示:
* $n = numbers.length$
* $1 <= n <= 5000$
* $-5000 <= numbers[i] <= 5000$
* `numbers` 原来是一个升序排序的数组,并进行了 $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)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 15. 二进制中1的个数（简单）.md | 剑指 Offer 15. 二进制中1的个数 | https://leetcode-cn.com/problems/er-jin-zhi-zhong-1de-ge-shu-lcof/solution/gong-shui-san-xie-yi-ti-si-jie-wei-shu-j-g9w6/ | 简单 | [
"位运算",
"分治"
] | 请实现一个函数,输入一个整数(以二进制串形式),输出该数二进制表示中 1 的个数。例如,把 9 表示成二进制是 1001,有 2 位是 1。因此,如果输入 9,则该函数输出 2。
示例 1:
```
输入:00000000000000000000000000001011
输出:3
解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'。
```
示例 2:
```
输入:00000000000000000000000010000000
输出:1
解释:输入的二进制串 00000000000000000000000010000000 中,共有一位为 '1'。
```
示例 3:
```
输入:11111111111111111111111111111101
输出:31
解释:输入的二进制串 11111111111111111111111111111101 中,共有 31 位为 '1'。
```
提示:
* 输入必须是长度为 32 的 二进制串 。 | ### 「位数检查」解法
一个朴素的做法是,对 `int` 的每一位进行检查,并统计 $1$ 的个数。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
for (int i = 0; i < 32; i++) {
ans += ((n >> i) & 1);
}
return ans;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位
* 空间复杂度:$O(1)$
***
### 「右移统计」解法
对于方法一,即使 $n$ 的高位均为是 $0$,我们也会对此进行循环检查。
因此另外一个做法是:通过 `n & 1` 来统计当前 $n$ 的最低位是否为 $1$,同时每次直接对 $n$ 进行右移并高位补 0。
当 $n = 0$ 代表,我们已经将所有的 $1$ 统计完成。
这样的做法,可以确保只会循环到最高位的 $1$。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
while (n != 0) {
ans += (n & 1);
n >>>= 1;
}
return ans;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$
* 空间复杂度:$O(1)$
---
### 「lowbit」解法
对于方法二,如果最高位 $1$ 和 最低位 $1$ 之间全是 $0$,我们仍然会诸次右移,直到处理到最高位的 $1$ 为止。
那么是否有办法,只对位数为 $1$ 的二进制位进行处理呢?
使用 `lowbit` 即可做到,`lowbit` 会在 $O(1)$ 复杂度内返回二进制表示中最低位 $1$ 所表示的数值。
例如 $(0000...111100)_2$ 传入 `lowbit` 返回 $(0000...000100)_2$;$(0000...00011)_2$ 传入 `lowbit` 返回 $(0000...00001)_2$ ...
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
for (int i = n; i != 0; i -= lowbit(i)) ans++;
return ans;
}
int lowbit(int x) {
return x & -x;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$
* 空间复杂度:$O(1)$
---
### 「分组统计」解法
以上三种解法都是 $O(k)$ 的,事实上我们可以通过分组统计的方式,做到比 $O(k)$ 更低的复杂度。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
n = (n & 0x55555555) + ((n >>> 1) & 0x55555555);
n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
n = (n & 0x0f0f0f0f) + ((n >>> 4) & 0x0f0f0f0f);
n = (n & 0x00ff00ff) + ((n >>> 8) & 0x00ff00ff);
n = (n & 0x0000ffff) + ((n >>> 16) & 0x0000ffff);
return n;
}
}
```
* 时间复杂度:$O(\log{k})$,$k$ 为 `int` 的位数,固定为 $32$ 位
* 空间复杂度:$O(1)$
PS. 对于该解法,如果大家学有余力的话,还是建议大家在纸上模拟一下这个过程。如果不想深入,也可以当成模板背过(写法非常固定),但通常如果不是写底层框架,你几乎不会遇到需要一个 $O(\log{k})$ 解法的情况。
而且这个做法的最大作用,不是处理 `int`,而是处理更大位数的情况,在长度只有 $32$ 位的 `int` 的情况下,该做法不一定就比循环要快(该做法会产生多个的中间结果,导致赋值发生多次,而且由于指令之间存在对 $n$ 数值依赖,可能不会被优化为并行指令),这个道理和对于排序元素少的情况下,我们会选择「选择排序」而不是「归并排序」是一样的。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 15` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 20. 表示数值的字符串（中等）.md | 剑指 Offer 20. 表示数值的字符串 | https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/solution/gong-shui-san-xie-chang-gui-zi-fu-chuan-sduvz/ | 中等 | [
"模拟"
] | 请实现一个函数用来判断字符串是否表示数值(包括整数和小数)。
**数值**(按顺序)可以分成以下几个部分:
1. 若干空格
2. 一个 小数 或者 整数
3. (可选)一个 `'e'` 或 `'E'` ,后面跟着一个 整数
4. 若干空格
**小数**(按顺序)可以分成以下几个部分:
1. (可选)一个符号字符(`'+'` 或 `'-'`)
2. 下述格式之一:
1. 至少一位数字,后面跟着一个点 `'.'`
2. 至少一位数字,后面跟着一个点 `'.'` ,后面再跟着至少一位数字
3. 一个点 `'.'` ,后面跟着至少一位数字
**整数**(按顺序)可以分成以下几个部分:
1. (可选)一个符号字符(`'+'` 或 `'-'`)
2. 至少一位数字
部分数值列举如下:
* `["+100", "5e2", "-123", "3.1416", "-1E-16", "0123"]`
部分非数值列举如下:
* `["12e", "1a3.14", "1.2.3", "+-5", "12e+5.4"]`
示例 1:
```
输入:s = "0"
输出:true
```
示例 2:
```
输入:s = "e"
输出:false
```
示例 3:
```
输入:s = "."
输出:false
```
示例 4:
```
输入:s = " .1 "
输出:true
```
提示:
* $1 <= s.length <= 20$
* `s` 仅含英文字母(大写和小写),数字(`0-9`),加号 `'+'`,减号 `'-'` ,空格 `' '` 或者点 `'.'` 。 | ### 模拟
我们对题面中的「数值」、「小数」和「整数」进行重新定义。
* 整数:可以有 `'+'` 或 `'-'`,但不能同时存在;且至少有一个数字
* 小数:可以有 `'+'` 或 `'-'`,但不能同时存在;有 `.`,且 `.` 的两边至少有一个数字
* 数值:前后可以有连续段的空格,其余位置则不能有;可以有 `E/e`,但最多只能有一个,同时 `E/e` 分割的左边可以是「整数」或「小数」,右边则只能是「整数」
根据上面的重新定义,再来设计我们的基本处理流程:
* 将 `s` 两端的连续段空格进行去除,得到不该含有空格的核心串,若核心串为空,则返回 `False`;
* 将所有的小写 `e` 切换为 `E`
* 从前往后,找到第一个 `E` 的所在位置 `idx`,根据是否有 `E` 进行分情况讨论:
* 若没有 `E`(即 `idx = n`),判断整个核心串是否为「整数」或「小数」
* 若有 `E`(即 `idx < n`),判断以 `E` 为分割的左半部分是否为「整数」或「小数」,判断以 `E` 为分割的右半部分是否「整数」
Java 代码:
```Java
class Solution {
public boolean isNumber(String s) {
int n = s.length(), l = 0, r = n - 1;
while (l < n && s.charAt(l) == ' ') l++;
while (r >= 0 && s.charAt(r) == ' ') r--;
if (l > r) return false;
s = s.substring(l, r + 1).replace('e', 'E');
n = s.length();
int idx = 0;
while (idx < n && s.charAt(idx) != 'E') idx++;
if (idx == n) {
return check(s, true);
} else {
return check(s.substring(0, idx), true) && check(s.substring(idx + 1), false);
}
}
boolean check(String s, boolean isDecimal) {
if (s.equals(".") || s.equals("")) return false;
int n = s.length();
for (int i = 0, cnt = 0; i < n; i++) {
char c = s.charAt(i);
if (c == '+' || c == '-') {
if (i != 0 || i == n - 1) return false;
} else if (c == '.') {
if (!isDecimal) return false;
if (cnt != 0) return false;
boolean a = i - 1 >= 0 && Character.isDigit(s.charAt(i - 1));
boolean b = i + 1 < n && Character.isDigit(s.charAt(i + 1));
if (!(a || b)) return false;
cnt++;
} else if (!Character.isDigit(c)) return false;
}
return true;
}
}
```
C++ 代码:
```C++
class Solution {
public:
bool isNumber(string s) {
int n = s.length(), l = 0, r = n - 1;
while (l < n && s[l] == ' ') l++;
while (r >= 0 && s[r] == ' ') r--;
if (l > r) return false;
s = s.substr(l, r - l + 1);
for (char& c : s) {
if (c == 'e') c = 'E';
}
n = s.length();
int idx = 0;
while (idx < n && s[idx] != 'E') idx++;
if (idx == n) {
return check(s, true);
} else {
return check(s.substr(0, idx), true) && check(s.substr(idx + 1), false);
}
}
bool check(string s, bool isDecimal) {
if (s == "." || s == "") return false;
int n = s.length();
for (int i = 0, cnt = 0; i < n; i++) {
char c = s[i];
if (c == '+' || c == '-') {
if (i != 0 || i == n - 1) return false;
} else if (c == '.') {
if (!isDecimal) return false;
if (cnt != 0) return false;
bool a = i - 1 >= 0 && isdigit(s[i - 1]);
bool b = i + 1 < n && isdigit(s[i + 1]);
if (!(a || b)) return false;
cnt++;
} else if (!isdigit(c)) return false;
}
return true;
}
};
```
Python 代码:
```Python
class Solution:
def isNumber(self, s: str) -> bool:
n, l, r = len(s), 0, len(s) - 1
while l < n and s[l] == ' ':
l += 1
while r >= 0 and s[r] == ' ':
r -= 1
if l > r:
return False
s = s[l:r + 1].replace('e', 'E')
n, idx = len(s), 0
while idx < n and s[idx] != 'E':
idx += 1
if idx == n:
return self.check(s, True)
else:
return self.check(s[:idx], True) and self.check(s[idx + 1:], False)
def check(self, s: str, is_decimal: bool) -> bool:
if s == "." or s == "":
return False
n, cnt = len(s), 0
for i in range(n):
c = s[i]
if c == '+' or c == '-':
if i != 0 or i == n - 1:
return False
elif c == '.':
if not is_decimal:
return False
if cnt != 0:
return False
a = i - 1 >= 0 and s[i - 1].isdigit()
b = i + 1 < n and s[i + 1].isdigit()
if not (a or b):
return False
cnt += 1
elif not c.isdigit():
return False
return True
```
TypeScript 代码:
```TypeScript
function isNumber(s: string): boolean {
let n = s.length, l = 0, r = n - 1;
while (l < n && s.charAt(l) === ' ') l++;
while (r >= 0 && s.charAt(r) === ' ') r--;
if (l > r) return false;
s = s.substring(l, r + 1).replace(/e/g, 'E');
n = s.length;
let idx = 0;
while (idx < n && s.charAt(idx) !== 'E') idx++;
if (idx === n) {
return check(s, true);
} else {
return check(s.substring(0, idx), true) && check(s.substring(idx + 1), false);
}
}
function check(s: string, isDecimal: boolean): boolean {
if (s === '.' || s === '') return false;
const n = s.length;
for (let i = 0, cnt = 0; i < n; i++) {
const c = s.charAt(i);
if (c === '+' || c === '-') {
if (i !== 0 || i === n - 1) return false;
} else if (c === '.') {
if (!isDecimal) return false;
if (cnt !== 0) return false;
const a = i - 1 >= 0 && /\d/.test(s.charAt(i - 1));
const b = i + 1 < n && /\d/.test(s.charAt(i + 1));
if (!(a || b)) return false;
cnt++;
} else if (!/\d/.test(c)) return false;
}
return true;
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 20` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 22. 链表中倒数第k个节点（简单）.md | 剑指 Offer 22. 链表中倒数第k个节点 | https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/solution/gong-shui-san-xie-yi-ti-san-jie-zhan-dui-w3rz/ | 简单 | [
"链表",
"栈",
"队列",
"快慢指针"
] | 输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。
例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
示例:
```
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
``` | ### 栈/队列 解法
一个使用额外空间的解法是利用栈(队列),将所有的节点压入占中栈(队列)中,令当前栈(队列)容量为 $cnt$。
然后从栈顶(队列头)弹出 $k$ 个($cnt - k + 1$ 个)元素,最后一个出栈(出队列)的元素即是答案。
代码(栈):
```Java
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
Deque<ListNode> d = new ArrayDeque<>();
while (head != null) {
d.addLast(head);
head = head.next;
}
ListNode ans = null;
while (k-- > 0) ans = d.pollLast();
return ans;
}
}
```
代码(队列):
```Java
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
Deque<ListNode> d = new ArrayDeque<>();
while (head != null) {
d.addLast(head);
head = head.next;
}
k = d.size() - k + 1;
ListNode ans = null;
while (k-- > 0) ans = d.pollFirst();
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 差值法
我们可以先对链表进行一次完整遍历,拿到总长度 $cnt$,最后由 $cnt - k$ 即是倒数第 $k$ 个节点距离 $head$ 节点的距离。
代码:
```Java
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
int cnt = 0;
ListNode tmp = head;
while (tmp != null && ++cnt > 0) tmp = tmp.next;
cnt -= k;
while (cnt-- > 0) head = head.next;
return head;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 快慢指针
事实上,我们还可以使用「快慢指针」进行求解。
起始先让快指针 `fast` 先走 $k$ 步,此时 `fast` 和 `slow` 之间距离为 $k$,之后让 `fast` 和 `slow` 指针一起走(始终维持相对距离为 $k$),当 `fast` 到达链表尾部,`slow` 即停在倒数第 $k$ 个节点处。
代码:
```Java
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
ListNode slow = head, fast = head;
while (k-- > 0) fast = fast.next;
while (fast != null) {
slow = slow.next;
fast = fast.next;
}
return slow;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 22. 链表中倒数第k个节点` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 24. 反转链表（简单）.md | 剑指 Offer 24. 反转链表 | https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/solution/by-ac_oier-nqfc/ | 简单 | [
"链表",
"迭代",
"递归"
] | 定义一个函数,输入一个链表的头节点,反转该链表并输出反转后链表的头节点。
示例:
```
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
```
限制:
* $0 <= 节点个数 <= 5000$ | ### 迭代
迭代做法只需要使用两个指针即可,复用 `head` 变量来代指当前处理到的节点,使用 `prev` 变量代指原链表中 `head` 的上一节点,只需使用循环构造出所有的 `head.next = prev` 关系即可。
Java 代码:
```Java
class Solution {
public ListNode reverseList(ListNode head) {
ListNode prev = null;
while (head != null) {
ListNode temp = head.next;
head.next = prev;
prev = head;
head = temp;
}
return prev;
}
}
```
TypeScript 代码:
```TypeScript
function reverseList(head: ListNode | null): ListNode | null {
let prev = null
while (head != null) {
const temp = head.next
head.next = prev
prev = head
head = temp
}
return prev
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 递归
相对而言,递归方法需要一定的抽象能力:将 `reverseList` 作为我们的递归函数,函数的含义为将以 `head` 为头节点进行翻转,并返回新的头节点。
不失一般性考虑某个递归回合:当传入节点 `head` 为空,或者其 `next` 节点为空(即只有单个节点)时,我们 直接返回 `head` 即可。而对于剩余情况,对于某个节点 `head` 而言,我们可以先递归处理它的剩余部分 `reverseList(head.next)` ,此时我们拿到的返回值既是以 `head.next` 为头结点进行翻转后的新链表头结点,也是以 `head` 为头结点进行翻转后的新链表头结点,将其记为 `ans`。我们只需要关注原有 `head` 部分如何处理,即将原来的 `head -> head.next` 关系进行翻转,则有 `head.next.next = head`,并 `head.next` 指向空即可,最后返回 `ans`。
Java 代码:
```Java
class Solution {
public ListNode reverseList(ListNode head) {
if (head == null || head.next == null) return head;
ListNode ans = reverseList(head.next);
head.next.next = head;
head.next = null;
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function reverseList(head: ListNode | null): ListNode | null {
if (head == null || head.next == null) return head
const ans = reverseList(head.next)
head.next.next = head
head.next = null
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 24` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 25. 合并两个排序的链表（简单）.md | 剑指 Offer 25. 合并两个排序的链表 | https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/solution/by-ac_oier-d6wf/ | 简单 | [
"链表",
"迭代",
"递归"
] | 输入两个递增排序的链表,合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1:
```
输入:1->2->4, 1->3->4
输出:1->1->2->3->4->4
```
限制:
* $0 <= 链表长度 <= 1000$ | ### 迭代 - 二路归并
使用「迭代」方式求解的话,本质与合并两个有序数组并无区别。
创建一个虚拟头结点 `dummy` 来拼接合并后的链表,`cur` 代表当前合并链表的末尾位置,同时复用入参的 `l1` 和 `l2` 来进行构造。
当 `l1` 和 `l2` 均不为空的时候,找到两者中的较小值拼接到 `cur ` 的后面,若 `l1` 和 `l2` 任一为空,则将另外的链表拼接完。
Java 代码:
```Java
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dummy = new ListNode(-1), cur = dummy;
while (l1 != null || l2 != null) {
if (l1 != null && l2 != null) {
if (l1.val < l2.val) {
cur.next = l1;
cur = cur.next; l1 = l1.next;
} else {
cur.next = l2;
cur = cur.next; l2 = l2.next;
}
} else if (l1 != null) {
cur.next = l1;
cur = cur.next; l1 = l1.next;
} else {
cur.next = l2;
cur = cur.next; l2 = l2.next;
}
}
return dummy.next;
}
}
```
TypeScript 代码:
```TypeScript
function mergeTwoLists(l1: ListNode | null, l2: ListNode | null): ListNode | null {
let dummy = new ListNode(-1), cur = dummy
while (l1 != null || l2 != null) {
if (l1 != null && l2 != null) {
if (l1.val < l2.val) {
cur.next = l1
cur = cur.next; l1 = l1.next
} else {
cur.next = l2
cur = cur.next; l2 = l2.next
}
} else if (l1 != null) {
cur.next = l1
cur = cur.next; l1 = l1.next
} else {
cur.next = l2
cur = cur.next; l2 = l2.next
}
}
return dummy.next
};
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(1)$
---
### 递归
另一种实现方式是使用「递归」进行构造。
直接将 `mergeTwoLists` 作为递归函数,该函数的定义为传入两个「有序」链表,并返回合并链表的头结点。
显然当 `l1` 或者 `l2` 任一为空时,返回另一链表即可。
而对于其余一般情况而言,根据 `l1` 和 `l2` 的节点值分情况讨论:
* 若 `l1.val < l2.val`,说明此时 `l1` 必然是当前构造回合中值最小的节点,也就是需要被返回的头结点,而 `l1` 后接的内容应该是 `mergeTwoLists(l1.next, l2)`,含义 `l1` 后接的内容应该是由有序链表 `l1.next` 和 `l2` 合并而来;
* 其余情况 `l1.val >= l2.val`,分析同理,此时有 `l2.next = mergeTwoLists(l2.next, l1)`,同时返回 `l2`。
Java 代码:
```Java
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
else if (l2 == null) return l1;
else if (l1.val < l2.val) {
l1.next = mergeTwoLists(l1.next, l2);
return l1;
} else {
l2.next = mergeTwoLists(l2.next, l1);
return l2;
}
}
}
```
TypeScript 代码:
```TypeScript
function mergeTwoLists(l1: ListNode | null, l2: ListNode | null): ListNode | null {
if (l1 == null) return l2
else if (l2 == null) return l1
else if (l1.val < l2.val) {
l1.next = mergeTwoLists(l1.next, l2)
return l1
} else {
l2.next = mergeTwoLists(l2.next, l1)
return l2
}
};
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 32 - I. 从上到下打印二叉树（中等）.md | 剑指 Offer 32 - I. 从上到下打印二叉树 | https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/solution/by-ac_oier-a9n5/ | 中等 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: `[3,9,20,null,null,15,7]`,
```
3
/ \
9 20
/ \
15 7
```
返回:
```
[3,9,20,15,7]
```
提示:
* `节点总数 <= 1000` | ### 迭代 - BFS
使用「迭代」进行求解是容易的,只需使用常规的 `BFS` 方法进行层序遍历即可。
Java 代码:
```Java
class Solution {
public int[] levelOrder(TreeNode root) {
List<Integer> list = new ArrayList<>();
Deque<TreeNode> d = new ArrayDeque<>();
if (root != null) d.addLast(root);
while (!d.isEmpty()) {
TreeNode t = d.pollFirst();
list.add(t.val);
if (t.left != null) d.addLast(t.left);
if (t.right != null) d.addLast(t.right);
}
int n = list.size();
int[] ans = new int[n];
for (int i = 0; i < n; i++) ans[i] = list.get(i);
return ans;
}
}
```
TypeScript 代码:
```TypeScript
function levelOrder(root: TreeNode | null): number[] {
let he = 0, ta = 0
const ans: number[] = new Array<number>()
const d: TreeNode[] = new Array<TreeNode>()
if (root != null) d[ta++] = root
while (he < ta) {
const t = d[he++]
ans.push(t.val)
if (t.left != null) d[ta++] = t.left
if (t.right != null) d[ta++] = t.right
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 递归 - DFS
使用「递归」来进行「层序遍历」虽然不太符合直观印象,但也是可以的。
此时我们需要借助「哈希表」来存储起来每一层的节点情况。
首先我们按照「中序遍历」的方式进行 `DFS`,同时在 `DFS` 过程中传递节点所在的深度(`root` 节点默认在深度最小的第 $0$ 层),每次处理当前节点时,通过哈希表获取所在层的数组,并将当前节点值追加到数组尾部,同时维护一个最大深度 `max`,在 `DFS` 完成后,再使用深度范围 $[0, max]$ 从哈希表中进行构造答案。
Java 代码:
```Java
class Solution {
Map<Integer, List<Integer>> map = new HashMap<>();
int max = -1, cnt = 0;
public int[] levelOrder(TreeNode root) {
dfs(root, 0);
int[] ans = new int[cnt];
for (int i = 0, idx = 0; i <= max; i++) {
for (int x : map.get(i)) ans[idx++] = x;
}
return ans;
}
void dfs(TreeNode root, int depth) {
if (root == null) return ;
max = Math.max(max, depth);
cnt++;
dfs(root.left, depth + 1);
List<Integer> list = map.getOrDefault(depth, new ArrayList<Integer>());
list.add(root.val);
map.put(depth, list);
dfs(root.right, depth + 1);
}
}
```
TypeScript 代码:
```TypeScript
const map:Map<number, Array<number>> = new Map<number, Array<number>>()
let max = -1, cnt = 0
function levelOrder(root: TreeNode | null): number[] {
map.clear()
max = -1; cnt = 0;
dfs(root, 0)
const ans: Array<number> = new Array<number>()
for (let i = 0; i <= max; i++) {
for (const x of map.get(i)) ans.push(x)
}
return ans
};
function dfs(root: TreeNode | null, depth: number): void {
if (root == null) return
max = Math.max(max, depth)
cnt++
dfs(root.left, depth + 1)
if (!map.has(depth)) map.set(depth, new Array<number>())
map.get(depth).push(root.val)
dfs(root.right, depth + 1)
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 32 - II. 从上到下打印二叉树 II（简单）.md | 剑指 Offer 32 - II. 从上到下打印二叉树 II | https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/solution/by-ac_oier-s9jz/ | 简单 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 从上到下按层打印二叉树,同一层的节点按从左到右的顺序打印,每一层打印到一行。
例如:
给定二叉树: `[3,9,20,null,null,15,7]`,
```
3
/ \
9 20
/ \
15 7
```
返回其层次遍历结果:
```
[
[3],
[9,20],
[15,7]
]
```
提示:
* `节点总数 <= 1000` | ### 迭代 - BFS
这道题是 [(题解)剑指 Offer 32 - I. 从上到下打印二叉树](https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/solution/by-ac_oier-a9n5/) 的练习版本。
只需要在每次 `BFS` 拓展时,将完整的层进行取出,存如独立数组后再加入答案。
Java 代码:
```Java
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
Deque<TreeNode> d = new ArrayDeque<>();
if (root != null) d.addLast(root);
List<List<Integer>> ans = new ArrayList<>();
while (!d.isEmpty()) {
int sz = d.size();
List<Integer> list = new ArrayList<>();
while (sz-- > 0) {
TreeNode t = d.pollFirst();
list.add(t.val);
if (t.left != null) d.addLast(t.left);
if (t.right != null) d.addLast(t.right);
}
ans.add(list);
}
return ans;
}
}
```
Typescript 代码:
```Typescript
function levelOrder(root: TreeNode | null): number[][] {
const ans: number[][] = new Array<Array<number>>()
const stk: TreeNode[] = new Array<TreeNode>()
let he = 0, ta = 0
if (root != null) stk[ta++] = root
while (he < ta) {
const temp = new Array<number>()
let sz = ta - he
while (sz-- > 0) {
const t = stk[he++]
temp.push(t.val)
if (t.left != null) stk[ta++] = t.left
if (t.right != null) stk[ta++] = t.right
}
ans.push(temp)
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 递归 - DFS
同理,可以使用「递归」来进行「层序遍历」。
此时我们需要借助「哈希表」来存储起来每一层的节点情况。
首先我们按照「中序遍历」的方式进行 `DFS`,同时在 `DFS` 过程中传递节点所在的深度(`root` 节点默认在深度最小的第 $0$ 层),每次处理当前节点时,通过哈希表获取所在层的数组,并将当前节点值追加到数组尾部,同时维护一个最大深度 `max`,在 `DFS` 完成后,再使用深度范围 $[0, max]$ 从哈希表中进行构造答案。
Java 代码:
```Java
class Solution {
Map<Integer, List<Integer>> map = new HashMap<>();
int max = -1;
public List<List<Integer>> levelOrder(TreeNode root) {
dfs(root, 0);
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i <= max; i++) ans.add(map.get(i));
return ans;
}
void dfs(TreeNode root, int depth) {
if (root == null) return ;
max = Math.max(max, depth);
dfs(root.left, depth + 1);
List<Integer> list = map.getOrDefault(depth, new ArrayList<>());
list.add(root.val);
map.put(depth, list);
dfs(root.right, depth + 1);
}
}
```
TypeScript 代码:
```TypeScript
const map: Map<number, Array<number>> = new Map<number, Array<number>>()
let max = -1
function levelOrder(root: TreeNode | null): number[][] {
map.clear()
max = -1
dfs(root, 0)
const ans = new Array<Array<number>>()
for (let i = 0; i <= max; i++) ans.push(map.get(i))
return ans
};
function dfs(root: TreeNode | null, depth: number): void {
if (root == null) return
max = Math.max(max, depth)
dfs(root.left, depth + 1)
if (!map.has(depth)) map.set(depth, new Array<number>())
map.get(depth).push(root.val)
dfs(root.right, depth + 1)
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - II` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 32 - III. 从上到下打印二叉树 III（中等）.md | 剑指 Offer 32 - III. 从上到下打印二叉树 III | https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/solution/by-ac_oier-98od/ | 中等 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 请实现一个函数按照之字形顺序打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右到左的顺序打印,第三行再按照从左到右的顺序打印,其他行以此类推。
例如:
给定二叉树: `[3,9,20,null,null,15,7]`,
```
3
/ \
9 20
/ \
15 7
```
返回其层次遍历结果:
```
[
[3],
[20,9],
[15,7]
]
```
提示:
* `节点总数 <= 1000` | ### 迭代 - BFS
这题相比于前两道二叉树打印题目,增加了打印方向的要求。
在 `BFS` 过程中,入队我们可以仍然采用「左子节点优先入队」进行,而在出队构造答案时,我们则要根据当前所在层数来做判别:对于所在层数为偶数(`root` 节点在第 $0$ 层),我们按照「出队添加到尾部」的方式进行;对于所在层数为奇数,我们按照「出队添加到头部」的方式进行。
> 为支持「从尾部追加元素」和「从头部追加元素」操作,`Java` 可使用基于链表的 `LinkedList`,而 `TS` 可创建定长数组后通过下标赋值。
其中判断当前所在层数,无须引用额外变量,直接根据当前 `ans` 的元素大小即可。
Java 代码:
```Java
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ans = new ArrayList<>();
Deque<TreeNode> d = new ArrayDeque<>();
if (root != null) d.addLast(root);
while (!d.isEmpty()) {
LinkedList<Integer> list = new LinkedList<>();
int sz = d.size(), dirs = ans.size() % 2;
while (sz-- > 0) {
TreeNode t = d.pollFirst();
if (dirs == 0) list.addLast(t.val);
else list.addFirst(t.val);
if (t.left != null) d.addLast(t.left);
if (t.right != null) d.addLast(t.right);
}
ans.add(list);
}
return ans;
}
}
```
Typescript 代码:
```Typescript
function levelOrder(root: TreeNode | null): number[][] {
const ans = new Array<Array<number>>()
const stk = new Array<TreeNode>()
let he = 0, ta = 0
if (root != null) stk[ta++] = root
while (he < ta) {
const dirs = ans.length % 2 == 0
let sz = ta - he, idx = dirs ? 0 : sz - 1
const temp = new Array<number>(sz)
while (sz-- > 0) {
const t = stk[he++]
temp[idx] = t.val
idx += dirs ? 1 : -1
if (t.left != null) stk[ta++] = t.left
if (t.right != null) stk[ta++] = t.right
}
ans.push(temp)
}
return ans
};
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 递归 - DFS
递归的实现方式与前两题同理。
不过对于 `TS` 语言来说,由于 `DFS` 过程中无法知道当前层有多少节点,因此只能在使用「哈希表」记录每层「从左往右」的方向,然后在构造答案时,运用「双指针」来将奇数层的节点进行翻转。
Java 代码:
```Java
class Solution {
Map<Integer, LinkedList<Integer>> map = new HashMap<>();
int max = -1;
public List<List<Integer>> levelOrder(TreeNode root) {
dfs(root, 0);
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i <= max; i++) ans.add(map.get(i));
return ans;
}
void dfs(TreeNode root, int depth) {
if (root == null) return ;
max = Math.max(max, depth);
dfs(root.left, depth + 1);
LinkedList<Integer> list = map.getOrDefault(depth, new LinkedList<>());
if (depth % 2 == 0) list.addLast(root.val);
else list.addFirst(root.val);
map.put(depth, list);
dfs(root.right, depth + 1);
}
}
```
TypeScript 代码:
```TypeScript
const map: Map<number, Array<number>> = new Map<number, Array<number>> ()
let max = -1
function levelOrder(root: TreeNode | null): number[][] {
map.clear()
max = -1
dfs(root, 0)
const ans = new Array<Array<number>>()
for (let i = 0; i <= max; i++) {
const temp = map.get(i)
if (i % 2 == 1) {
for (let p = 0, q = temp.length - 1; p < q; p++, q--) {
const c = temp[p]
temp[p] = temp[q]
temp[q] = c
}
}
ans.push(temp)
}
return ans
};
function dfs(root: TreeNode | null, depth: number): void {
if (root == null) return
max = Math.max(max, depth)
dfs(root.left, depth + 1)
if (!map.has(depth)) map.set(depth, new Array<number>())
map.get(depth).push(root.val)
dfs(root.right, depth + 1)
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - III` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 34. 二叉树中和为某一值的路径（中等）.md | 剑指 Offer 34. 二叉树中和为某一值的路径 | https://leetcode.cn/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/solution/by-ac_oier-3ehr/ | 中等 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 给你二叉树的根节点 `root` 和一个整数目标和 `targetSum`,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1:
```
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:[[5,4,11,2],[5,8,4,5]]
```
示例 2:
```
输入:root = [1,2,3], targetSum = 5
输出:[]
```
示例 3:
```
输入:root = [1,2], targetSum = 0
输出:[]
```
提示:
* 树中节点总数在范围 $[0, 5000]$ 内
* $-1000 <= Node.val <= 1000$
* $-1000 <= targetSum <= 1000$ | ### DFS
较为直观的做法是使用 `DFS`,在 `DFS` 过程中记录路径以及路径对应的元素和,当出现元素和为 `target`,且到达了叶子节点,说明找到了一条满足要求的路径,将其加入答案。
使用 `DFS` 的好处是在记录路径的过程中可以使用「回溯」的方式进行记录及回退,而无须时刻进行路径数组的拷贝。
Java 代码:
```Java
class Solution {
List<List<Integer>> ans = new ArrayList<>();
int t;
public List<List<Integer>> pathSum(TreeNode root, int target) {
t = target;
dfs(root, 0, new ArrayList<>());
return ans;
}
void dfs(TreeNode root, int cur, List<Integer> list) {
if (root == null) return ;
list.add(root.val);
if (cur + root.val == t && root.left == null && root.right == null) ans.add(new ArrayList<>(list));
dfs(root.left, cur + root.val, list);
dfs(root.right, cur + root.val, list);
list.remove(list.size() - 1);
}
}
```
TypeScript 代码:
```TypeScript
let ans: number[][]
let t
function pathSum(root: TreeNode | null, target: number): number[][] {
ans = new Array<Array<number>>()
t = target
dfs(root, 0, new Array<number>())
return ans
};
function dfs(root: TreeNode | null, cur: number, list: Array<number>): void {
if (root == null) return
list.push(root.val)
if (cur + root.val == t && root.left == null && root.right == null) ans.push(list.slice())
dfs(root.left, cur + root.val, list)
dfs(root.right, cur + root.val, list)
list.pop()
}
```
* 时间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \times h)$
* 空间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \times h)$
---
### BFS
使用 `BFS` 的话,我们需要封装一个类/结构体 `TNode`,该结构体存储所对应的原始节点 `node`,到达 `node` 所经过的路径 `list`,以及对应的路径和 `tot`。
由于 `BFS` 过程并非按照路径进行(即相邻出队的节点并非在同一路径),因此我们每次创建新的 `TNode` 对象时,需要对路径进行拷贝操作。
Java 代码:
```Java
class Solution {
class Node {
TreeNode node;
List<Integer> list;
int tot;
Node (TreeNode _node, List<Integer> _list, int _tot) {
node = _node; list = new ArrayList<>(_list); tot = _tot;
list.add(node.val); tot += node.val;
}
}
public List<List<Integer>> pathSum(TreeNode root, int target) {
List<List<Integer>> ans = new ArrayList<>();
Deque<Node> d = new ArrayDeque<>();
if (root != null) d.addLast(new Node(root, new ArrayList<>(), 0));
while (!d.isEmpty()) {
Node t = d.pollFirst();
if (t.tot == target && t.node.left == null && t.node.right == null) ans.add(t.list);
if (t.node.left != null) d.addLast(new Node(t.node.left, t.list, t.tot));
if (t.node.right != null) d.addLast(new Node(t.node.right, t.list, t.tot));
}
return ans;
}
}
```
Typescript 代码:
```Typescript
class TNode {
node: TreeNode
tot: number
list: Array<number>
constructor(node: TreeNode, tot: number, list: Array<number>) {
this.node = node; this.tot = tot; this.list = list.slice();
this.list.push(node.val)
this.tot += node.val
}
}
function pathSum(root: TreeNode | null, target: number): number[][] {
const ans = new Array<Array<number>>()
const stk = new Array<TNode>()
let he = 0, ta = 0
if (root != null) stk[ta++] = new TNode(root, 0, new Array<number>())
while (he < ta) {
const t = stk[he++]
if (t.tot == target && t.node.left == null && t.node.right == null) ans.push(t.list)
if (t.node.left != null) stk[ta++] = new TNode(t.node.left, t.tot, t.list)
if (t.node.right != null) stk[ta++] = new TNode(t.node.right, t.tot, t.list)
}
return ans
};
```
* 时间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \times h)$
* 空间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \times h)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 34` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 35. 复杂链表的复制（中等）.md | 剑指 Offer 35. 复杂链表的复制 | https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof/solution/by-ac_oier-6atv/ | 中等 | [
"哈希表",
"链表"
] | 给你一个长度为 `n` 的链表,每个节点包含一个额外增加的随机指针 `random`,该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 `n` 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 `next` 指针和 `random` 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如,如果原链表中有 `X` 和 `Y` 两个节点,其中 `X.random --> Y` 。那么在复制链表中对应的两个节点 `x` 和 `y` ,同样有 `x.random --> y` 。
返回复制链表的头节点。
用一个由 `n` 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 `[val, random_index]` 表示:
* `val`:一个表示 `Node.val` 的整数。
* `random_index`:随机指针指向的节点索引(范围从 $0$ 到 $n-1$);如果不指向任何节点,则为 `null` 。
你的代码 只 接受原链表的头节点 `head` 作为传入参数。
示例 1:
```
输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]
```
示例 2:
```
输入:head = [[1,1],[2,1]]
输出:[[1,1],[2,1]]
```
示例 3:
```
输入:head = [[3,null],[3,0],[3,null]]
输出:[[3,null],[3,0],[3,null]]
```
示例 4:
```
输入:head = []
输出:[]
解释:给定的链表为空(空指针),因此返回 null。
```
提示:
* $0 <= n <= 1000$
* $-10000 <= Node.val <= 10000$ | ### 模拟 + 哈希表
如果不考虑 `random` 指针的话,对一条链表进行拷贝,我们只需要使用两个指针:一个用于遍历原链表,一个用于构造新链表(始终指向新链表的尾部)即可。这一步操作可看做是「创建节点 + 构建 `next` 指针关系」。
现在在此基础上增加一个 `random` 指针,我们可以将 `next` 指针和 `random` 指针关系的构建拆开进行:
1. 先不考虑 `random` 指针,和原本的链表复制一样,创建新新节点,并构造 `next` 指针关系,同时使用「哈希表」记录原节点和新节点的映射关系;
2. 对原链表和新链表进行同时遍历,对于原链表的每个节点上的 `random` 都通过「哈希表」找到对应的新 `random` 节点,并在新链表上构造 `random` 关系。
代码:
```Java
class Solution {
public Node copyRandomList(Node head) {
Node t = head;
Node dummy = new Node(-10010), cur = dummy;
Map<Node, Node> map = new HashMap<>();
while (head != null) {
Node node = new Node(head.val);
map.put(head, node);
cur.next = node;
cur = cur.next; head = head.next;
}
cur = dummy.next; head = t;
while (head != null) {
cur.random = map.get(head.random);
cur = cur.next; head = head.next;
}
return dummy.next;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 模拟(原地算法)
显然时间复杂度上无法优化,考虑如何降低空间(不使用「哈希表」)。
我们使用「哈希表」的目的为了实现原节点和新节点的映射关系,更进一步的是为了快速找到某个节点 `random` 在新链表的位置。
那么我们可以利用原链表的 `next` 做一个临时中转,从而实现映射。
具体的,我们可以按照如下流程进行:
1. 对原链表的每个节点节点进行复制,并追加到原节点的后面;
2. 完成 $1$ 操作之后,链表的奇数位置代表了原链表节点,链表的偶数位置代表了新链表节点,且每个原节点的 `next` 指针执行了对应的新节点。这时候,我们需要构造新链表的 `random` 指针关系,可以利用 `link[i + 1].random = link[i].random.next`,$i$ 为奇数下标,含义为 **新链表节点的 `random` 指针指向旧链表对应节点的 `random` 指针的下一个值**;
3. 对链表进行拆分操作。
代码:
```Java
class Solution {
public Node copyRandomList(Node head) {
if (head == null) return head;
Node t = head;
while (head != null) {
Node node = new Node(head.val);
node.next = head.next;
head.next = node;
head = node.next;
}
head = t;
while (head != null) {
if (head.random != null) head.next.random = head.random.next;
head = head.next.next;
}
head = t;
Node ans = head.next;
while (head != null) {
Node ne = head.next;
if (ne != null) head.next = ne.next;
head = ne;
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 35` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 37. 序列化二叉树（困难）.md | 剑指 Offer 37. 序列化二叉树 | https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof/solution/gong-shui-san-xie-er-cha-shu-de-xu-lie-h-n89a/ | 困难 | [
"二叉树",
"层序遍历"
] | 序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。
示例 1:
```
输入:root = [1,2,3,null,null,4,5]
输出:[1,2,3,null,null,4,5]
```
示例 2:
```
输入:root = []
输出:[]
```
示例 3:
```
输入:root = [1]
输出:[1]
```
示例 4:
```
输入:root = [1,2]
输出:[1,2]
```
提示:
* 树中结点数在范围 $[0, 10^4]$ 内
* -1000 <= Node.val <= 1000 | ### 基本思路
无论使用何种「遍历方式」进行二叉树存储,为了方便,我们都需要对空节点有所表示。
其实题目本身的样例就给我们提供了很好的思路:**使用层序遍历的方式进行存储,对于某个叶子节点的空节点进行存储,同时确保不递归存储空节点对应的子节点。**
---
### 层序遍历
根据节点值的数据范围 `-1000 <= Node.val <= 1000`(我是在 [297. 二叉树的序列化与反序列化](https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/) 看的,你也可以不使用数字,使用某个特殊字符进行表示,只要能在反序列时有所区分即可),我们可以建立占位节点 `emptyNode` 用来代指空节点(`emptyNode.val = INF`)。
序列化:先特判掉空树的情况,之后就是常规的层序遍历逻辑:
1. 起始时,将 `root` 节点入队;
2. 从队列中取出节点,检查节点是否有左/右节点:
* 如果有的话,将值追加序列化字符中(注意使用分隔符),并将节点入队;
* 如果没有,检查当前节点是否为 `emptyNode` 节点,如果不是 `emptyNode` 说明是常规的叶子节点,需要将其对应的空节点进行存储,即将 `emptyNode` 入队;
3. 循环流程 $2$,直到整个队列为空。
反序列:同理,怎么「序列化」就怎么进行「反序列」即可:
1. 起始时,构造出 `root` 并入队;
2. 每次从队列取出元素时,同时从序列化字符中截取两个值(对应左右节点),检查是否为 `INF`,若不为 `INF` 则构建对应节点;
3. 循环流程 $2$,直到整个序列化字符串被处理完(注意跳过最后一位分隔符)。
代码:
```Java
public class Codec {
int INF = -2000;
TreeNode emptyNode = new TreeNode(INF);
public String serialize(TreeNode root) {
if (root == null) return "";
StringBuilder sb = new StringBuilder();
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
while (!d.isEmpty()) {
TreeNode poll = d.pollFirst();
sb.append(poll.val + "_");
if (!poll.equals(emptyNode)) {
d.addLast(poll.left != null ? poll.left : emptyNode);
d.addLast(poll.right != null ? poll.right : emptyNode);
}
}
return sb.toString();
}
public TreeNode deserialize(String data) {
if (data.equals("")) return null;
String[] ss = data.split("_");
int n = ss.length;
TreeNode root = new TreeNode(Integer.parseInt(ss[0]));
Deque<TreeNode> d = new ArrayDeque<>();
d.addLast(root);
for (int i = 1; i < n - 1; i += 2) {
TreeNode poll = d.pollFirst();
int a = Integer.parseInt(ss[i]), b = Integer.parseInt(ss[i + 1]);
if (a != INF) {
poll.left = new TreeNode(a);
d.addLast(poll.left);
}
if (b != INF) {
poll.right = new TreeNode(b);
d.addLast(poll.right);
}
}
return root;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 37` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 38. 字符串的排列（中等）.md | 剑指 Offer 38. 字符串的排列 | https://leetcode-cn.com/problems/zi-fu-chuan-de-pai-lie-lcof/solution/gong-shui-san-xie-tong-yong-shi-xian-qu-4jbkj/ | 中等 | [
"字符串",
"回溯算法"
] | 输入一个字符串,打印出该字符串中字符的所有排列。
你可以以任意顺序返回这个字符串数组,但里面不能有重复元素。
示例:
```
输入:s = "abc"
输出:["abc","acb","bac","bca","cab","cba"]
```
限制:
* 1 <= s 的长度 <= 8 | ### 基本分析
根据题意,我们需要返回所有不重复的排列字符串。
此类问题通常都是使用 `DFS` 来做:**决策当前字符串的某一位填入什么字符。**
设计如下 `DFS` 函数:
```Java
/**
* cs : 原字符串
* u : 当前决策到目标字符串的哪一位
* cur : 当前目标字符串
*/
void dfs(char[] cs, int u, String cur);
```
而对于去重通常有两种方式:
1. 使用 `Set` 实现去重;
2. 先对原字符串进行排序,然后确保相同字符传入同一目标位置的动作只发生一次。
---
### 回溯(Set 去重)
使用 `HashSet` 实现去重十分简单,就是不用考虑去重问题。
直接决策目标字符串哪一位取哪个字符即可,同时使用布尔数组记录哪些字符已使用。
代码:
```Java
class Solution {
int N = 10;
Set<String> set = new HashSet<>();
boolean[] vis = new boolean[N];
public String[] permutation(String s) {
char[] cs = s.toCharArray();
dfs(cs, 0, "");
String[] ans = new String[set.size()];
int idx = 0;
for (String str : set) ans[idx++] = str;
return ans;
}
void dfs(char[] cs, int u, String cur) {
int n = cs.length;
if (u == n) {
set.add(cur);
return;
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
vis[i] = true;
dfs(cs, u + 1, cur + String.valueOf(cs[i]));
vis[i] = false;
}
}
}
}
```
* 时间复杂度:$O(n * n!)$
* 空间复杂度:$O(n)$
---
### 回溯(排序去重)
想要通过预处理实现去重,需要「**先对原字符串进行排序,然后确保相同字符传入同一目标位置的动作只发生一次**」。
具体的,我们可以在「决策目标字符串的第 $u$ 个位置」时,对于 `cs[i-1] = cs[i]` 的情况进行跳过,同时为了确保这个动作不会影响到后面的位置决策,需要利用同一目标位置会进行“回溯”的特性,增加一个 `!vis[i - 1]` 的判断。
这样对于形如 `...xxx...` 的原字符串,使用字符 `x` 决策目标字符串的第 $u$ 个位置的动作只会发生一次,从而确保了一模一样的分支不会在「递归树」中展开多次。
此类去重方式在很多方式出现过,事实上这种去重方式不仅仅能应用于排列问题。
其本质是对递归树中「状态完全相同」的节点进行跳过,从而实现去重。
这里的「状态完全相同」是指:**当前形成部分结果为 $cur$ 相同,同时剩余字符集合也相同**。
代码:
```Java
class Solution {
int N = 10;
List<String> list = new ArrayList<>();
boolean[] vis = new boolean[N];
public String[] permutation(String s) {
char[] cs = s.toCharArray();
Arrays.sort(cs);
dfs(cs, 0, "");
String[] ans = new String[list.size()];
int idx = 0;
for (String str : list) ans[idx++] = str;
return ans;
}
void dfs(char[] cs, int u, String cur) {
int n = cs.length;
if (u == n) {
list.add(cur);
return;
}
for (int i = 0; i < n; i++) {
if (i > 0 && !vis[i - 1] && cs[i] == cs[i - 1]) continue;
if (!vis[i]) {
vis[i] = true;
dfs(cs, u + 1, cur + String.valueOf(cs[i]));
vis[i] = false;
}
}
}
}
```
* 时间复杂度:$O(n * n!)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 38` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 41. 数据流中的中位数（困难）.md | 剑指 Offer 41. 数据流中的中位数 | https://leetcode.cn/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof/solution/by-ac_oier-exn5/ | 困难 | [
"优先队列(堆)"
] | 中位数是有序列表中间的数。如果列表长度是偶数,中位数则是中间两个数的平均值。
例如,
* `[2,3,4]` 的中位数是 $3$
* `[2,3]` 的中位数是 $(2 + 3) / 2 = 2.5$
设计一个支持以下两种操作的数据结构:
* `void addNum(int num)` - 从数据流中添加一个整数到数据结构中。
* `double findMedian()` - 返回目前所有元素的中位数。
示例:
```
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2
```
进阶:
* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?
* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法? | ### 优先队列(堆)
这是一道经典的数据结构运用题。
具体的,**我们可以使用两个优先队列(堆)来维护整个数据流数据,令维护数据流左半边数据的优先队列(堆)为 `l`,维护数据流右半边数据的优先队列(堆)为 `r`**。
显然,**为了可以在 $O(1)$ 的复杂度内取得当前中位数,我们应当令 `l` 为大根堆,`r` 为小根堆,并人为固定 `l` 和 `r` 之前存在如下的大小关系**:
* **当数据流元素数量为偶数:`l` 和 `r` 大小相同,此时动态中位数为两者堆顶元素的平均值;**
* **当数据流元素数量为奇数:`l` 比 `r` 多一,此时动态中位数为 `l` 的堆顶原数。**
为了满足上述说的奇偶性堆大小关系,在进行 `addNum` 时,我们应当分情况处理:
* 插入前两者大小相同,说明插入前数据流元素个数为偶数,插入后变为奇数。我们期望操作完达到「`l` 的数量为 `r` 多一,同时双堆维持有序」,进一步分情况讨论:
* 如果 `r` 为空,说明当前插入的是首个元素,直接添加到 `l` 即可;
* 如果 `r` 不为空,且 `num <= r.peek()`,说明 `num` 的插入位置不会在后半部分(不会在 `r` 中),直接加到 `l` 即可;
* 如果 `r` 不为空,且 `num > r.peek()`,说明 `num` 的插入位置在后半部分,此时将 `r` 的堆顶元素放到 `l` 中,再把 `num` 放到 `r`(相当于从 `r` 中置换一位出来放到 `l` 中)。
* 插入前两者大小不同,说明前数据流元素个数为奇数,插入后变为偶数。我们期望操作完达到「`l` 和 `r` 数量相等,同时双堆维持有序」,进一步分情况讨论(此时 `l` 必然比 `r` 元素多一):
* 如果 `num >= l.peek()`,说明 `num` 的插入位置不会在前半部分(不会在 `l` 中),直接添加到 `r` 即可。
* 如果 `num < l.peek()`,说明 `num` 的插入位置在前半部分,此时将 `l` 的堆顶元素放到 `r` 中,再把 `num` 放入 `l` 中(相等于从 `l` 中替换一位出来当到 `r` 中)。
代码:
```Java
class MedianFinder {
PriorityQueue<Integer> l = new PriorityQueue<>((a,b)->b-a);
PriorityQueue<Integer> r = new PriorityQueue<>((a,b)->a-b);
public void addNum(int num) {
int s1 = l.size(), s2 = r.size();
if (s1 == s2) {
if (r.isEmpty() || num <= r.peek()) {
l.add(num);
} else {
l.add(r.poll());
r.add(num);
}
} else {
if (l.peek() <= num) {
r.add(num);
} else {
r.add(l.poll());
l.add(num);
}
}
}
public double findMedian() {
int s1 = l.size(), s2 = r.size();
if (s1 == s2) {
return (l.peek() + r.peek()) / 2.0;
} else {
return l.peek();
}
}
}
```
* 时间复杂度:`addNum` 函数的复杂度为 $O(\log{n})$;`findMedian` 函数的复杂度为 $O(1)$
* 空间复杂度:$O(n)$
---
### 进阶
* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?
可以使用建立长度为 $101$ 的桶,每个桶分别统计每个数的出现次数,同时记录数据流中总的元素数量,每次查找中位数时,先计算出中位数是第几位,从前往后扫描所有的桶得到答案。
**这种做法相比于对顶堆做法,计算量上没有优势,更多的是空间上的优化。**
**对顶堆解法两个操作中耗时操作复杂度为 $O(\log{n})$,$\log$ 操作常数不会超过 $3$,在极限数据 $10^7$ 情况下计算量仍然低于耗时操作复杂度为 $O(C)$($C$ 固定为 $101$)桶计数解法。**
* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?
和上一问解法类似,对于 $1$% 采用哨兵机制进行解决即可,在常规的最小桶和最大桶两侧分别维护一个有序序列,即建立一个代表负无穷和正无穷的桶。
上述两个进阶问题的代码如下,但注意由于真实样例的数据分布不是进阶所描述的那样(不是绝大多数都在 $[0,100]$ 范围内),所以会 `TLE`。
代码:
```Java
class MedianFinder {
TreeMap<Integer, Integer> head = new TreeMap<>(), tail = new TreeMap<>();
int[] arr = new int[101];
int a, b, c;
public void addNum(int num) {
if (num >= 0 && num <= 100) {
arr[num]++;
b++;
} else if (num < 0) {
head.put(num, head.getOrDefault(num, 0) + 1);
a++;
} else if (num > 100) {
tail.put(num, tail.getOrDefault(num, 0) + 1);
c++;
}
}
public double findMedian() {
int size = a + b + c;
if (size % 2 == 0) return (find(size / 2) + find(size / 2 + 1)) / 2.0;
return find(size / 2 + 1);
}
int find(int n) {
if (n <= a) {
for (int num : head.keySet()) {
n -= head.get(num);
if (n <= 0) return num;
}
} else if (n <= a + b) {
n -= a;
for (int i = 0; i <= 100; i++) {
n -= arr[i];
if (n <= 0) return i;
}
} else {
n -= a + b;
for (int num : tail.keySet()) {
n -= tail.get(num);
if (n <= 0) return num;
}
}
return -1; // never
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 41` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 42. 连续子数组的最大和（简单）.md | 剑指 Offer 42. 连续子数组的最大和 | https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/solution/gong-shui-san-xie-jian-dan-xian-xing-dp-mqk5v/ | 简单 | [
"线性 DP"
] | 输入一个整型数组,数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
要求时间复杂度为$O(n)$。
示例1:
```
输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。
```
提示:
* 1 <= arr.length <= $10^5$
* -100 <= arr[i] <= 100 | ### 动态规划
这是一道简单线性 DP 题。
定义 $f[i]$ 为考虑以 $nums[i]$ 为结尾的子数组的最大值。
不失一般性的考虑 $f[i]$ 如何转移。
显然对于 $nums[i]$ 而言,以它为结尾的子数组分两种情况:
* $num[i]$ 自身作为独立子数组:$f[i] = nums[i]$ ;
* $num[i]$ 与之前的数值组成子数组,由于是子数组,其只能接在 $nums[i - 1]$,即有:$f[i] = f[i - 1] + nums[i]$。
最终 $f[i]$ 为上述两种情况取 $\max$ 即可:
$$
f[i] = \max(nums[i], f[i - 1] + nums[i])
$$
代码:
```Java
class Solution {
public int maxSubArray(int[] nums) {
int n = nums.length;
int[] f = new int[n];
f[0] = nums[0];
int ans = f[0];
for (int i = 1; i < n; i++) {
f[i] = Math.max(nums[i], f[i - 1] + nums[i]);
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 空间优化
观察状态转移方程,我们发现 $f[i]$ 明确值依赖于 $f[i - 1]$。
因此我们可以使用「有限变量」或者「滚动数组」的方式,将空间优化至 $O(1)$。
代码:
```Java
class Solution {
public int maxSubArray(int[] nums) {
int n = nums.length;
int max = nums[0], ans = max;
for (int i = 1; i < n; i++) {
max = Math.max(nums[i], max + nums[i]);
ans = Math.max(ans, max);
}
return ans;
}
}
```
```Java
class Solution {
public int maxSubArray(int[] nums) {
int n = nums.length;
int[] f = new int[2];
f[0] = nums[0];
int ans = f[0];
for (int i = 1; i < n; i++) {
int a = i & 1, b = (i - 1) & 1;
f[a] = Math.max(nums[i], f[b] + nums[i]);
ans = Math.max(ans, f[a]);
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 拓展
一个有意思的拓展是,将 **加法** 替换成 **乘法**。
题目变成 [152. 乘积最大子数组(中等)](https://leetcode-cn.com/problems/maximum-product-subarray/)。
又该如何考虑呢?
一个朴素的想法,仍然是考虑定义 $f[i]$ 代表以 $nums[i]$ 为结尾的最大值,但存在「负负得正」取得最大值的情况,光维护一个前缀最大值显然是不够的,我们可以多引入一维 $g[i]$ 作为前缀最小值。
其余分析与本题同理。
代码:
```Java
class Solution {
public int maxProduct(int[] nums) {
int n = nums.length;
int[] g = new int[n + 1]; // 考虑前 i 个,结果最小值
int[] f = new int[n + 1]; // 考虑前 i 个,结果最大值
g[0] = 1;
f[0] = 1;
int ans = nums[0];
for (int i = 1; i <= n; i++) {
int x = nums[i - 1];
g[i] = Math.min(x, Math.min(g[i - 1] * x, f[i - 1] * x));
f[i] = Math.max(x, Math.max(g[i - 1] * x, f[i - 1] * x));
ans = Math.max(ans, f[i]);
}
return ans;
}
}
```
```Java
class Solution {
public int maxProduct(int[] nums) {
int n = nums.length;
int min = 1, max = 1;
int ans = nums[0];
for (int i = 1; i <= n; i++) {
int x = nums[i - 1];
int nmin = Math.min(x, Math.min(min * x, max * x));
int nmax = Math.max(x, Math.max(min * x, max * x));
min = nmin;
max = nmax;
ans = Math.max(ans, max);
}
return ans;
}
}
``` | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 42` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 44. 数字序列中某一位的数字（中等）.md | 剑指 Offer 44. 数字序列中某一位的数字 | https://leetcode.cn/problems/shu-zi-xu-lie-zhong-mou-yi-wei-de-shu-zi-lcof/solution/by-ac_oier-wgr8/ | 中等 | [
"数学",
"模拟"
] | 数字以 `0123456789101112131415...` 的格式序列化到一个字符序列中。在这个序列中,第 $5$ 位(从下标 $0$ 开始计数)是 $5$,第 $13$ 位是 $1$,第 $19$ 位是 $4$,等等。
请写一个函数,求任意第 $n$ 位对应的数字。
示例 1:
```
输入:n = 3
输出:3
```
示例 2:
```
输入:n = 11
输出:0
```
限制:
* $0 <= n < 2^31$ | ### 模拟
我们知道,对于长度为 $len$ 的数字的范围为 $[10^{len - 1}, 10^{len} - 1]$(共 $9 \times 10^{len - 1}$ 个),总长度为:
$$
L = len \times 9 \times 10^{len - 1}
$$
因此我们可以先对 $n$ 进行不断试减(更新 $n$),确定下来目标数字 $x$ 的长度为多少,假设为 $len$。
然后直接计算出长度 $len$ 的最小值为 $s = 10^{len - 1}$,由于范围内的数长度都是 $len$,因此我们可以直接定位到目标数字 $x$ 为何值。
根据目标值 $x$ 必然满足关系式:
$$
(x - s + 1) \times len \geq n
$$
变形可得:
$$
x \geq \left \lfloor \frac{n}{len} \right \rfloor - 1 + s
$$
对 $n$ 进行最后一次的试减(更新 $n$),若恰好有 $n = 0$,说明答案为 $x$ 的最后一位,可由 `x % 10` 取得;若大于 $0$,说明答案是 $x + 1$ 的第 $n$ 位(十进制表示,从左往右数),可由 `(x + 1) / (int) (Math.pow(10, len - n)) % 10` 取得。
代码:
```Java
class Solution {
public int findNthDigit(int n) {
int len = 1;
while (len * 9 * Math.pow(10, len - 1) < n) {
n -= len * 9 * Math.pow(10, len - 1);
len++;
}
long s = (long) Math.pow(10, len - 1);
long x = n / len - 1 + s;
n -= (x - s + 1) * len;
return n == 0 ? (int) (x % 10) : (int) ((x + 1) / Math.pow(10, len - n) % 10);
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$
---
### 补充
上述讲解可能对于新手并不友好,尤其是对一些上来只做剑指 Offer 的面试向同学,下面使用更为通俗的方式进行讲解。
对于长度 `len` 的所有数,其最小值为 $10^{len - 1}$,最大值为 $10^{len} - 1$,每个数所能贡献的数的个数为 $len$ 个,因此对于长度为 `len` 的所有数,其所能贡献的数的个数为 $(10^{len} - 10^{len - 1}) \times len$。我们专门开一个函数 `getCnt` 来计算长度为 `len` 的数的个数有多少。
然后我们从 `len = 1` 开始,不断对 `n` 进行试减(`len` 递增),直到 `getCnt(len) <= n` 不再满足。
假设此时的递增到的长度为 `len`,可知长度为 `len` 的最小值 $start = 10^{len - 1}$,我们可以通过计算偏移量 $\left \lfloor \frac{n}{len} \right \rfloor$ 并将其累加到 $start$ 中去,同时对 `n` 进行 $\left \lfloor \frac{n}{len} \right \rfloor \times len$ 的消减。
然后根据 `n` 是否为 $0$ 进行分情况讨论:
* 当 `n` 为 $0$,说明答案落在 $start - 1$ 的最后一位,即 `(start - 1) % 10` ;
* 当 `n` 不为 $0$,说明答案为 `start` 数值中从左往右数的第 $n$ 位,可通过解法一的方式取得,也可以将其转字符串再通过下标获取。
代码:
```Java
class Solution {
long getCnt(int len) {
return (long)(Math.pow(10, len) - Math.pow(10, len - 1)) * len;
}
public int findNthDigit(int n) {
int len = 1;
while (getCnt(len) <= n) {
n -= getCnt(len);
len++;
}
long start = (long)Math.pow(10, len - 1);
start += n / len;
n -= n / len * len;
if (n == 0) return (int)(start - 1) % 10;
else return String.valueOf(start).toCharArray()[n - 1] - '0';
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 44` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 52. 两个链表的第一个公共节点（简单）.md | 剑指 Offer 52. 两个链表的第一个公共节点 | https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/solution/gong-shui-san-xie-zhao-liang-tiao-lian-b-ifqw/ | 简单 | [
"链表"
] | 输入两个链表,找出它们的第一个公共节点。
如下面的两个链表:
在节点 c1 开始相交。
示例 1:
```
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Reference of the node with value = 8
输入解释:相交节点的值为 8 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
```
示例 2:
```
输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出:Reference of the node with value = 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。
```
注意:
* 如果两个链表没有交点,返回 null.
* 在返回结果后,两个链表仍须保持原有的结构。
* 可假定整个链表结构中没有循环。
* 程序尽量满足 $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 == 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.add(a);
a = a.next;
}
while (b != null) {
d2.add(b);
b = b.next;
}
ListNode ans = null;
while (!d1.isEmpty() && !d2.isEmpty() && d1.peekLast() == d2.peekLast()) {
ans = d1.pollLast();
d2.pollLast();
}
return ans;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n + m)$
---
### Set 解法
这是一种「从前往后」找的方式。
使用 `Set` 数据结构,先对某一条链表进行遍历,同时记录下来所有的节点。
然后在对第二链条进行遍历时,检查当前节点是否在 `Set` 中出现过,第一个在 `Set` 出现过的节点即是交点。
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
Set<ListNode> set = new HashSet<>();
while (a != null) {
set.add(a);
a = a.next;
}
while (b != null && !set.contains(b)) b = b.next;
return b;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(n)$
---
### 差值法
由于两条链表在相交节点后面的部分完全相同,因此我们可以先对两条链表进行遍历,分别得到两条链表的长度,并计算差值 `d`。
让长度较长的链表先走 `d` 步,然后两条链表同时走,第一个相同的节点即是节点。
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
int c1 = 0, c2 = 0;
ListNode ta = a, tb = b;
while (ta != null && c1++ >= 0) ta = ta.next;
while (tb != null && c2++ >= 0) tb = tb.next;
int d = c1 - c2;
if (d > 0) {
while (d-- > 0) a = a.next;
} else if (d < 0) {
d = -d;
while (d-- > 0) b = b.next;
}
while (a != b) {
a = a.next;
b = b.next;
}
return a;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(1)$
---
### 等值法
这是「差值法」的另外一种实现形式,原理同样利用「两条链表在相交节点后面的部分完全相同」。
我们令第一条链表相交节点之前的长度为 `a`,第二条链表相交节点之前的长度为 `b`,相交节点后的公共长度为 `c`(注意 `c` 可能为 $0$,即不存在相交节点)。
分别对两条链表进行遍历:
* 当第一条链表遍历完,移动到第二条链表的头部进行遍历;
* 当第二条链表遍历完,移动到第一条链表的头部进行遍历。
如果存在交点:**第一条链表首次到达「第一个相交节点」的充要条件是第一条链表走了 $a + c + b$ 步,由于两条链表同时出发,并且步长相等,因此当第一条链表走了 $a + c + b$ 步时,第二条链表同样也是走了 $a + c + b$ 步,即 第二条同样停在「第一个相交节点」的位置。**
如果不存在交点:**两者会在走完 $a + c + b + c$ 之后同时变为 $null$,退出循环。**
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
ListNode ta = a, tb = b;
while (ta != tb) {
ta = ta == null ? b : ta.next;
tb = tb == null ? a : tb.next;
}
return ta;
}
}
```
* 时间复杂度:$O(n + m)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 52` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 53 - I. 在排序数组中查找数字 I（简单）.md | 剑指 Offer 53 - I. 在排序数组中查找数字 I | https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solution/gong-shui-san-xie-liang-chong-er-fen-ton-3epx/ | 简单 | [
"二分"
] | 统计一个数字在排序数组中出现的次数。
示例 1:
```
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
```
示例 2:
```
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
```
限制:
* 0 <= 数组长度 <= 50000 | ### 二分单边 + 线性扫描
一个朴素的想法是,找到目标值 $target$ 「首次」出现或者「最后」出现的下标,然后「往后」或者「往前」进行数量统计。
代码:
```Java
// 找到目标值「最后」出现的分割点,并「往前」进行统计
class Solution {
public int search(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] <= t) l = mid;
else r = mid - 1;
}
int ans = 0;
while (r >= 0 && nums[r] == t && r-- >= 0) ans++;
return ans;
}
}
```
```Java
// 找到目标值「首次」出现的分割点,并「往后」进行统计
class Solution {
public int search(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= t) r = mid;
else l = mid + 1;
}
int ans = 0;
while (l < n && nums[l] == t && l++ >= 0) ans++;
return ans;
}
}
```
* 时间复杂度:二分找到分割点之后,需要往前或者往后进行扫描。复杂度为 $O(n)$
* 空间复杂度:$O(1)$
---
### 二分两边
进一步,我们可以直接经过两次「二分」找到左右边界,计算总长度即是 $target$ 的数量。
代码:
```Java
class Solution {
public int search(int[] nums, int t) {
int n = nums.length;
if (n == 0) return 0;
int a = -1, b = -1;
// 二分出左边界
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] >= t) r = mid;
else l = mid + 1;
}
if (nums[r] != t) return 0;
a = r;
// 二分出右边界
l = 0; r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] <= t) l = mid;
else r = mid - 1;
}
if (nums[r] != t) return 0;
b = r;
return b - a + 1;
}
}
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 53 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 53 - II. 0～n-1中缺失的数字（简单）.md | 剑指 Offer 53 - II. 0~n-1中缺失的数字 | https://leetcode.cn/problems/que-shi-de-shu-zi-lcof/solution/by-ac_oier-gs6q/ | 简单 | [
"二分"
] | 一个长度为 $n-1$ 的递增排序数组中的所有数字都是唯一的,并且每个数字都在范围 $[0, n-1]$ 之内。
在范围 $[0, n-1]$ 内的 $n$ 个数字中有且只有一个数字不在该数组中,请找出这个数字。
示例 1:
```
输入: [0,1,3]
输出: 2
```
示例 2:
```
输入: [0,1,2,3,4,5,6,7,9]
输出: 8
```
限制:
* $1 <= 数组长度 <= 10000$ | ### 二分
强调过无数次,二分的本质是「二段性」。
我们可以考虑对于一个给定数组 `nums` 中,对于缺失元素左右数值而言,有何性质。
假设我们缺失的元素数值为 `x`,那么对于 `x` 左边的元素(若有)必然是完整且连续的,也就是其必然满足 `nums[i] = i`,而其右边的元素(若有)必然由于 `x` 的缺失,导致必然不满足 `nums[i] = i`,因此在以缺失元素为分割点的数轴上,具有二段性,我们可以使用「二分」来找该分割点。
同时由于缺失元素可能是 $[0, n - 1]$ 范围内的最大值,因此我们需要二分结束后再 `check` 一次,若不满足,说明缺失的元素值为 $n - 1$。
Java 代码:
```Java
class Solution {
public int missingNumber(int[] nums) {
int l = 0, r = nums.length - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] == mid) l = mid;
else r = mid - 1;
}
return nums[r] != r ? r : r + 1;
}
}
```
Typescript 代码:
```Typescript
function missingNumber(nums: number[]): number {
let l = 0, r = nums.length - 1
while (l < r) {
const mid = l + r + 1 >> 1
if (nums[mid] == mid) l = mid
else r = mid - 1
}
return nums[r] != r ? r : r + 1
};
```
* 时间复杂度:$O(\log{n})$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 53 - II` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 59 - I. 滑动窗口的最大值（困难）.md | 剑指 Offer 59 - I. 滑动窗口的最大值 | https://leetcode.cn/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/solution/by-ac_oier-sjym/ | 困难 | [
"优先队列(堆)",
"线段树",
"分块",
"单调队列",
"RMQ"
] | 给你一个整数数组 `nums`,有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值 。
示例 1:
```
输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
输出:[3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
```
示例 2:
```
输入:nums = [1], k = 1
输出:[1]
```
提示:
* $1 <= nums.length <= 10^5$
* $-10^4 <= nums[i] <= 10^4$
* $1 <= k <= nums.length$ | ### 优先队列(堆)
根据题意,容易想到优先队列(大根堆),同时为了确保滑动窗口的大小合法性,我们以二元组 $(idx, nums[idx])$ 的形式进行入队。
当下标达到首个滑动窗口的右端点后,每次尝试从优先队列(大根堆)中取出最大值(若堆顶元素的下标小于当前滑动窗口左端点时,则丢弃该元素)。
代码:
```Java
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->b[1]-a[1]);
int n = nums.length, m = n - k + 1, idx = 0;
int[] ans = new int[m];
for (int i = 0; i < n; i++) {
q.add(new int[]{i, nums[i]});
if (i >= k - 1) {
while (q.peek()[0] <= i - k) q.poll();
ans[idx++] = q.peek()[1];
}
}
return ans;
}
}
```
* 时间复杂度:$O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 线段树
容易将问题转换为「区间求和」问题:使用原始的 `nums` 构建线段树等价于在位置 $i$ 插入 $nums[i]$,即单点操作,而查询每个滑动窗口最大值,则对应的区间查询。
由于只涉及单点修改,无须实现懒标记 `pushdown` 操作,再结合 $n$ 的数据范围为 $10^5$,无须进行动态开点。
直接写 `build` 四倍空间的线段树数组实现即可。
代码:
```Java
class Solution {
class Node {
int l, r, val;
Node (int _l, int _r) {
l = _l; r = _r; val = Integer.MIN_VALUE;
}
}
Node[] tr = new Node[100010 * 4];
void build(int u, int l, int r) {
tr[u] = new Node(l, r);
if (l == r) return ;
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
}
void update(int u, int x, int v) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].val = Math.max(tr[u].val, v);
return ;
}
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid) update(u << 1, x, v);
else update(u << 1 | 1, x, v);
pushup(u);
}
int query(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;
int mid = tr[u].l + tr[u].r >> 1, ans = Integer.MIN_VALUE;
if (l <= mid) ans = query(u << 1, l, r);
if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));
return ans;
}
void pushup(int u) {
tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val);
}
public int[] maxSlidingWindow(int[] nums, int k) {
int n = nums.length, m = n - k + 1;
int[] ans = new int[m];
build(1, 1, n);
for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);
for (int i = k; i <= n; i++) ans[i - k] = query(1, i - k + 1, i);
return ans;
}
}
```
* 时间复杂度:建立线段树复杂度为 $O(n\log{n})$;构建答案复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n)$
---
### 分块
另外一个做法是分块,又名「优雅的暴力」,也是莫队算法的基础。
具体的,除了给定的 `nums` 以外,我们构建一个分块数组 `region`,其中 `region[idx] = x` 含义为块编号为 `idx` 的最大值为 `x`,其中一个块对应一个原始区间 $[l, r]$。
如何定义块大小是实现分块算法的关键。
对于本题,本质是求若干个大小为 $k$ 的区间最大值。
我们可以设定块大小为 $\sqrt{k}$,这样所需创建的分块数组大小为 $\frac{n}{\sqrt{k}}$。分块数组的更新操作为 $O(1)$,而查询则为 $\sqrt{k}$。
容易证明查询操作的复杂度:对于每个长度为 $k$ 的 $[l, r]$ 查询操作而言,最多遍历两个(左右端点对应的块)的块内元素,复杂度为 $O(\sqrt{k})$,同时最多遍历 $\sqrt{k}$ 个块,复杂度同为 $O(\sqrt{k})$。
因此最多两步复杂度为 $O(\sqrt{k})$ 的块内操作,最多 $\sqrt{k}$ 步复杂度为 $O(1)$ 的块间操作,整体复杂度为 $O(\sqrt{k})$。
因此使用分块算法总的计算量为 $n\times\sqrt{k} = 10^6$,可以过。
分块算法的几个操作函数:
* `int getIdx(int x)` :计算原始下标对应的块编号;
* `void add(int x, int v)` :计算原始下标 `x` 对应的下标 `idx`,并将 `region[idx]` 和 `v` 取 `max` 来更新 `region[idx]`;
* `int query(int l, int r)` :查询 $[l, r]$ 中的最大值,如果 $l$ 和 $r$ 所在块相同,直接遍历 $[l, r]$ 进行取值;若 $l$ 和 $r$ 不同块,则处理 $l$ 和 $r$ 对应的块内元素后,对块编号在 $(getIdx(l), getIdx(r))$ 之间的块进行遍历。
代码:
```Java
class Solution {
int n, m, len;
int[] nums, region;
int getIdx(int x) {
return x / len;
}
void add(int x, int v) {
region[getIdx(x)] = Math.max(region[getIdx(x)], v);
}
int query(int l, int r) {
int ans = Integer.MIN_VALUE;
if (getIdx(l) == getIdx(r)) {
for (int i = l; i <= r; i++) ans = Math.max(ans, nums[i]);
} else {
int i = l, j = r;
while (getIdx(i) == getIdx(l)) ans = Math.max(ans, nums[i++]);
while (getIdx(j) == getIdx(r)) ans = Math.max(ans, nums[j--]);
for (int k = getIdx(i); k <= getIdx(j); k++) ans = Math.max(ans, region[k]);
}
return ans;
}
public int[] maxSlidingWindow(int[] _nums, int k) {
nums = _nums;
n = nums.length; len = (int) Math.sqrt(k); m = n / len + 10;
region = new int[m];
Arrays.fill(region, Integer.MIN_VALUE);
for (int i = 0; i < n; i++) add(i, nums[i]);
int[] ans = new int[n - k + 1];
for (int i = 0; i < n - k + 1; i++) ans[i] = query(i, i + k - 1);
return ans;
}
}
```
* 时间复杂度:数组大小为 $n$,块大小为 $\sqrt{k}$,分块数组大小为 $\frac{n}{\sqrt{k}}$。预处理分块数组复杂度为 $O(n)$(即 `add` 操作复杂度为 $O(1)$ );构造答案复杂度为 $O(n\times\sqrt{k})$(即 `query` 操作复杂度为 $O(\sqrt{k})$,最多有 $n$ 次查询)
* 空间复杂度:$\frac{n}{\sqrt{k}}$
---
### 单调队列
关于 `RMQ` 的另外一个优秀做法通常是使用「单调队列/单调栈」。
当然,我们也能不依靠经验,而从问题的本身出发,逐步分析出该做法。
假设我们当前处理到某个长度为 $k$ 的窗口,此时窗口往后滑动一格,会导致后一个数(新窗口的右端点)添加进来,同时会导致前一个数(旧窗口的左端点)移出窗口。
随着窗口的不断平移,该过程会一直发生。**若同一时刻存在两个数 $nums[j]$ 和 $nums[i]$($j < i$)所在一个窗口内,下标更大的数会被更晚移出窗口,此时如果有 $nums[j] <= nums[i]$ 的话,可以完全确定 $nums[j]$ 将不会成为后续任何一个窗口的最大值,此时可以将必然不会是答案的 $nums[j]$ 从候选中进行移除**。
不难发现,当我们将所有必然不可能作为答案的元素(即所有满足的小于等于 $nums[i]$ )移除后,候选集合满足「单调递减」特性,即集合首位元素为当前窗口中的最大值(为了满足窗口长度为 $k$ 的要求,在从集合头部取答案时需要先将下标小于的等于的 $i - k$ 的元素移除)。
为方便从尾部添加元素,从头部获取答案,我们可使用「双端队列」存储所有候选元素。
代码:
```Java
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
Deque<Integer> d = new ArrayDeque<>();
int n = nums.length, m = n - k + 1;
int[] ans = new int[m];
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && nums[d.peekLast()] <= nums[i]) d.pollLast();
d.addLast(i);
if (i >= k - 1) {
while (!d.isEmpty() && d.peekFirst() <= i - k) d.pollFirst();
ans[i - k + 1] = nums[d.peekFirst()];
}
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 59 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 01.02. 判定是否互为字符重排（简单）.md | 面试题 01.02. 判定是否互为字符重排 | https://leetcode.cn/problems/check-permutation-lcci/solution/by-ac_oier-qj3j/ | 简单 | [
"模拟"
] | 给定两个字符串 `s1` 和 `s2`,请编写一个程序,确定其中一个字符串的字符重新排列后,能否变成另一个字符串。
示例 1:
```
输入: s1 = "abc", s2 = "bca"
输出: true
```
示例 2:
```
输入: s1 = "abc", s2 = "bad"
输出: false
```
说明:
* $0 <= len(s1) <= 100$
* $0 <= len(s2) <= 100$ | ### 模拟
根据题意,对两字符串进行词频统计,统计过程中使用变量 `tot` 记录词频不同的字符个数。
Java 代码:
```Java
class Solution {
public boolean CheckPermutation(String s1, String s2) {
int n = s1.length(), m = s2.length(), tot = 0;
if (n != m) return false;
int[] cnts = new int[128];
for (int i = 0; i < n; i++) {
if (++cnts[s1.charAt(i)] == 1) tot++;
if (--cnts[s2.charAt(i)] == 0) tot--;
}
return tot == 0;
}
}
```
TypeScript 代码:
```TypeScript
function CheckPermutation(s1: string, s2: string): boolean {
let n = s1.length, m = s2.length, tot = 0
if (n != m) return false
const cnts = new Array<number>(128).fill(0)
for (let i = 0; i < n; i++) {
if (++cnts[s1.charCodeAt(i)] == 1) tot++
if (--cnts[s2.charCodeAt(i)] == 0) tot--
}
return tot == 0
};
```
Python3 代码:
```Python3
class Solution:
def CheckPermutation(self, s1: str, s2: str) -> bool:
return Counter(s1) == Counter(s2)
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(C)$,其中 $C = 128$ 为字符集大小 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.02` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 01.05. 一次编辑（中等）.md | 面试题 01.05. 一次编辑 | https://leetcode.cn/problems/one-away-lcci/solution/by-ac_oier-7ml0/ | 中等 | [
"模拟",
"双指针"
] | 字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。 给定两个字符串,编写一个函数判定它们是否只需要一次(或者零次)编辑。
示例 1:
```
输入:
first = "pale"
second = "ple"
输出: True
```
示例 2:
```
输入:
first = "pales"
second = "pal"
输出: False
``` | ### 双指针模拟
为了方便,我们令 $a = first$、$b = second$,两者长度为 $n$ 和 $m$,并让 $a$ 为两种中的长度较短的那个(若 $b$ 较短,则将两者交换)。
接下来是简单的双指针处理(使用 $cnt$ 记录操作次数):
1. 我们最多使用不超过一次的操作,因此如果 $\left | n - m \right | > 1$,直接返回 `False`;
2. 若两者长度差不超过 $1$,使用 $i$ 和 $j$ 分别指向两字符的最左侧进行诸位检查:
* 若 $a[i] = b[j]$,让 $i$ 和 $j$ 继续后移进行检查;
* 若 $a[i] \neq b[j]$,根据两字符串长度进行分情况讨论:
* 若 $n = m$,说明此时只能通过「替换」操作消除不同,分别让 $i$ 和 $j$ 后移,并对 $cnt$ 进行加一操作;
* 若 $n \neq m$,由于我们人为确保了 $a$ 更短,即此时是 $n < m$,此时只能通过对 $a$ 字符串进行「添加」操作来消除不同,此时让 $j$ 后移,$i$ 不动(含义为在 $a$ 字符串中的 $i$ 位置增加一个 $b[j]$ 字符),并对 $cnt$ 进行加一操作。
最终我们根据 $cnt$ 是否不超过 $1$ 来返回结果。
代码:
```Java
class Solution {
public boolean oneEditAway(String a, String b) {
int n = a.length(), m = b.length();
if (Math.abs(n - m) > 1) return false;
if (n > m) return oneEditAway(b, a);
int i = 0, j = 0, cnt = 0;
while (i < n && j < m && cnt <= 1) {
char c1 = a.charAt(i), c2 = b.charAt(j);
if (c1 == c2) {
i++; j++;
} else {
if (n == m) {
i++; j++; cnt++;
} else {
j++; cnt++;
}
}
}
return cnt <= 1;
}
}
```
* 时间复杂度:令 $n$ 和 $m$ 分别为两字符串长度,复杂度为 $O(\max(n, m))$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.05` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 01.08. 零矩阵（中等）.md | 面试题 01.08. 零矩阵 | https://leetcode.cn/problems/zero-matrix-lcci/solution/by-ac_oier-0lo0/ | 中等 | [
"模拟"
] | 编写一种算法,若 $M \times N$ 矩阵中某个元素为 $0$,则将其所在的行与列清零。
示例 1:
```
输入:
[
[1,1,1],
[1,0,1],
[1,1,1]
]
输出:
[
[1,0,1],
[0,0,0],
[1,0,1]
]
```
示例 2:
```
输入:
[
[0,1,2,0],
[3,4,5,2],
[1,3,1,5]
]
输出:
[
[0,0,0,0],
[0,4,5,0],
[0,3,1,0]
]
``` | ### 模拟
根据题意进行模拟。
Java 代码:
```Java
class Solution {
public void setZeroes(int[][] mat) {
int n = mat.length, m = mat[0].length;
boolean[] rows = new boolean[n], cols = new boolean[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mat[i][j] == 0) rows[i] = cols[j] = true;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (rows[i] || cols[j]) mat[i][j] = 0;
}
}
}
}
```
TypeScript 代码:
```TypeScript
function setZeroes(mat: number[][]): void {
const n = mat.length, m = mat[0].length
const rows = new Array<boolean>(n).fill(false), cols = new Array<boolean>(m).fill(false)
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (mat[i][j] == 0) rows[i] = cols[j] = true
}
}
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (rows[i] || cols[j]) mat[i][j] = 0
}
}
};
```
Python 代码:
```Python
class Solution:
def setZeroes(self, mat: List[List[int]]) -> None:
n, m = len(mat), len(mat[0])
rows, cols = [False] * n, [False] * m
for i in range(n):
for j in range(m):
if mat[i][j] == 0:
rows[i] = cols[j] = True
for i in range(n):
for j in range(m):
mat[i][j] = 0 if rows[i] or cols[j] else mat[i][j]
```
* 时间复杂度:$O(n \times m)$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.08` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 01.09. 字符串轮转（简单）.md | 面试题 01.09. 字符串轮转 | https://leetcode.cn/problems/string-rotation-lcci/solution/by-ac_oier-2wo1/ | 简单 | [
"字符串哈希"
] | 字符串轮转。给定两个字符串 `s1` 和 `s2`,请编写代码检查 `s2` 是否为 `s1` 旋转而成(比如,`waterbottle` 是 `erbottlewat` 旋转后的字符串)。
示例1:
```
输入:s1 = "waterbottle", s2 = "erbottlewat"
输出:True
```
示例2:
```
输入:s1 = "aa", s2 = "aba"
输出:False
```
提示:
* 字符串长度在 $[0, 100000]$ 范围内。
说明:
你能只调用一次检查子串的方法吗? | ### 字符串哈希
若两字符串互为旋转,则「其一字符串」必然为「另一字符串拓展两倍长度后(循环子串)」的子串。
基于此,我们可以使用「字符串哈希」进行求解:先计算 `s2` 的字符串哈希值 `t`,然后构造出 `s1 + s1` 的哈希数组和次方数组,在两数组中检查是否存在长度为 $n$ 的连续子段的哈希值 `cur` 与 `t` 相等。
**不了解字符串哈希的同学可以看前置🧀 : [字符串哈希入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489813&idx=1&sn=7f3bc18ca390d85b17655f7164d8e660)**
> 一些细节:其他语言可能不像 `Java` 那样存在自然取模,可手动取模,对于自带高精度的语言若不取模会导致单次计算复杂度上升,会 `TLE`。
Java 代码:
```Java
class Solution {
static int N = 200010, P = 13131;
static int[] h = new int[N], p = new int[N];
public boolean isFlipedString(String s1, String s2) {
if (s1.length() != s2.length()) return false;
int n = s1.length();
for (int i = 1; i <= n; i++) h[i] = h[i - 1] * P + s2.charAt(i - 1);
int t = h[n]; // s2 hash
s1 = s1 + s1;
p[0] = 1;
for (int i = 1; i <= 2 * n; i++) {
h[i] = h[i - 1] * P + s1.charAt(i - 1);
p[i] = p[i - 1] * P;
}
for (int i = 1; i + n - 1 <= 2 * n; i++) {
int j = i + n - 1, cur = h[j] - h[i - 1] * p[j - i + 1];
if (cur == t) return true;
}
return false;
}
}
```
Python 代码:
```Python
N, P, MOD = 200010, 13131, 987654321
h, p = [0] * N, [1] * N
class Solution:
def isFlipedString(self, s1: str, s2: str) -> bool:
if len(s1) != len(s2):
return False
if s1 == s2:
return True
n = len(s1)
for i in range(1, n + 1):
h[i] = (h[i - 1] * P + ord(s2[i - 1])) % MOD
t = h[n]
s1 = s1 + s1
for i in range(1, 2 * n + 1):
h[i] = (h[i - 1] * P + ord(s1[i - 1])) % MOD
p[i] = (p[i - 1] * P) % MOD
for i in range(1, n + 1):
j = i + n - 1
cur = (h[j] - h[i - 1] * p[j - i + 1]) % MOD
if cur == t:
return True
return False
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.09` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 02.05. 链表求和（中等）.md | 面试题 02.05. 链表求和 | https://leetcode-cn.com/problems/sum-lists-lcci/solution/by-ac_oier-v1zb/ | 中等 | [
"链表",
"模拟"
] | 给定两个用链表表示的整数,每个节点包含一个数位。
这些数位是反向存放的,也就是个位排在链表首部。
编写函数对这两个整数求和,并用链表形式返回结果。
示例:
```
输入:(7 -> 1 -> 6) + (5 -> 9 -> 2),即617 + 295
输出:2 -> 1 -> 9,即912
```
示例:
```
输入:(6 -> 1 -> 7) + (2 -> 9 -> 5),即617 + 295
输出:9 -> 1 -> 2,即912
```
进阶:思考一下,假设这些数位是正向存放的,又该如何解决呢? | ### 链表(反向)
访问链表节点的顺序为「个位、百位、千位 ...」,即与执行「竖式加法」时访问的位数次序一致。
因此我们可以边遍历,边模拟「竖式加法」的过程,使用变量 $t$ 存储进位情况,当 $l1$ 和 $l2$ 没遍历完,或者进位 $t$ 不为 $0$,该计算过程就可以继续,每次使用当前计算结果 `t % 10` 来创建新节点,使用 `t / 10` 来更新进位。
代码:
```Java
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode ans = new ListNode(-1), temp = ans;
int t = 0;
while (l1 != null || l2 != null || t != 0) {
if (l1 != null) {
t += l1.val;
l1 = l1.next;
}
if (l2 != null) {
t += l2.val;
l2 = l2.next;
}
temp.next = new ListNode(t % 10);
temp = temp.next;
t /= 10;
}
return ans.next;
}
}
```
* 时间复杂度:令 $n$ 为链表 `l1` 的长度,$m$ 为链表 `l2` 的长度,复杂度为 $O(\max(n, m))$
* 空间复杂度:$O(1)$
---
### 链表(正向)
如果将链表翻转(先访问到的是数值高位),该如何处理?
由于我们的「竖式加法」是从低位开始,因此我们需要先使用数据结构(栈 / 数组)对链表元素进行存储,再实现「从低位访问」并进行「竖式加法」的模拟过程。
为了验证代码正确性,我们可以先对 `l1` 和 `l2` 进行翻转,再走链表(正向)的处理逻辑。
代码:
```Java
class Solution {
ListNode reverse(ListNode node) {
ListNode prev = null, cur = node;
while (cur != null) {
ListNode temp = cur.next;
cur.next = prev;
prev = cur; cur = temp;
}
return prev;
}
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
l1 = reverse(l1);
l2 = reverse(l2);
Deque<Integer> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();
while (l1 != null) {
d1.addLast(l1.val);
l1 = l1.next;
}
while (l2 != null) {
d2.addLast(l2.val);
l2 = l2.next;
}
ListNode ans = new ListNode(-1), temp = ans;
int t = 0;
while (!d1.isEmpty() || !d2.isEmpty() || t != 0) {
if (!d1.isEmpty()) t += d1.pollLast();
if (!d2.isEmpty()) t += d2.pollLast();
temp.next = new ListNode(t % 10);
temp = temp.next;
t /= 10;
}
return ans.next;
}
}
```
* 时间复杂度:令 $n$ 为链表 `l1` 的长度,$m$ 为链表 `l2` 的长度,复杂度为 $O(\max(n, m))$
* 空间复杂度:$O(n + m)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `面试题 02.05. 链表求和` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 03.01. 三合一（简单）.md | 面试题 03.01. 三合一 | https://leetcode-cn.com/problems/three-in-one-lcci/solution/yi-ti-shuang-jie-er-wei-shu-zu-yi-wei-sh-lih7/ | 简单 | [
"栈"
] | 三合一。描述如何只用一个数组来实现三个栈。
你应该实现push(stackNum, value)、pop(stackNum)、isEmpty(stackNum)、peek(stackNum)方法。stackNum表示栈下标,value表示压入的值。
构造函数会传入一个stackSize参数,代表每个栈的大小。
示例1:
```
输入:
["TripleInOne", "push", "push", "pop", "pop", "pop", "isEmpty"]
[[1], [0, 1], [0, 2], [0], [0], [0], [0]]
输出:
[null, null, null, 1, -1, -1, true]
说明:当栈为空时`pop, peek`返回-1,当栈满时`push`不压入元素。
```
示例2:
```
输入:
["TripleInOne", "push", "push", "push", "pop", "pop", "pop", "peek"]
[[2], [0, 1], [0, 2], [0, 3], [0], [0], [0], [0]]
输出:
[null, null, null, null, 2, 1, -1, -1]
``` | ### 二维数组
题目只要求我们使用「一个数组」来实现栈,并没有限制我们使用数组的维度。
因此一个简单的做法是,建立一个二维数组 $data$ 来做。
二维数组的每一行代表一个栈,同时使用一个 $locations$ 记录每个栈「待插入」的下标。
代码:
```java
class TripleInOne {
int N = 3;
// 3 * n 的数组,每一行代表一个栈
int[][] data;
// 记录每个栈「待插入」位置
int[] locations;
public TripleInOne(int stackSize) {
data = new int[N][stackSize];
locations = new int[N];
}
public void push(int stackNum, int value) {
int[] stk = data[stackNum];
int loc = locations[stackNum];
if (loc < stk.length) {
stk[loc] = value;
locations[stackNum]++;
}
}
public int pop(int stackNum) {
int[] stk = data[stackNum];
int loc = locations[stackNum];
if (loc > 0) {
int val = stk[loc - 1];
locations[stackNum]--;
return val;
} else {
return -1;
}
}
public int peek(int stackNum) {
int[] stk = data[stackNum];
int loc = locations[stackNum];
if (loc > 0) {
return stk[loc - 1];
} else {
return -1;
}
}
public boolean isEmpty(int stackNum) {
return locations[stackNum] == 0;
}
}
```
* 时间复杂度:所有的操作均为 $O(1)$。
* 空间复杂度:$O(k * n)$。k 为我们需要实现的栈的个数,n 为栈的容量。
***
### 一维数组
当然了,我们也能使用一个一维数组来做。
建立一个长度为 $3 * stackSize$ 的数组,并将 3 个栈的「待插入」存储在 $locations$ 数组。
代码:
```java
class TripleInOne {
int N = 3;
int[] data;
int[] locations;
int size;
public TripleInOne(int stackSize) {
size = stackSize;
data = new int[size * N];
locations = new int[N];
for (int i = 0; i < N; i++) {
locations[i] = i * size;
}
}
public void push(int stackNum, int value) {
int idx = locations[stackNum];
if (idx < (stackNum + 1) * size) {
data[idx] = value;
locations[stackNum]++;
}
}
public int pop(int stackNum) {
int idx = locations[stackNum];
if (idx > stackNum * size) {
locations[stackNum]--;
return data[idx - 1];
} else {
return -1;
}
}
public int peek(int stackNum) {
int idx = locations[stackNum];
if (idx > stackNum * size) {
return data[idx - 1];
} else {
return -1;
}
}
public boolean isEmpty(int stackNum) {
return locations[stackNum] == stackNum * size;
}
}
```
* 时间复杂度:所有的操作均为 $O(1)$。
* 空间复杂度:$O(k * n)$。k 为我们需要实现的栈的个数,n 为栈的容量。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `面试题 03.01. 三合一` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 04.06. 后继者（中等）.md | 面试题 04.06. 后继者 | https://leetcode.cn/problems/successor-lcci/solution/by-ac_oier-xib5/ | 中等 | [
"BST",
"递归"
] | 设计一个算法,找出二叉搜索树中指定节点的 “下一个” 节点(也即中序后继)。
如果指定节点没有对应的 “下一个” 节点,则返回 `null`。
示例 1:
```
输入: root = [2,1,3], p = 1
2
/ \
1 3
输出: 2
```
示例 2:
```
输入: root = [5,3,6,2,4,null,null,1], p = 6
5
/ \
3 6
/ \
2 4
/
1
输出: null
``` | ### BST 特性 + 递归
利用 `BST` 的特性,我们可以根据当前节点 `root` 与 `p` 的值大小关系来确定搜索方向:
1. 若有 `root.val <= p.val` : 根据 `BST` 特性可知当前节点 `root` 及其左子树子节点均满足「值小于等于 `p.val`」,因此不可能是 `p` 点的后继,我们直接到 `root` 的右子树搜索 `p` 的后继(递归处理);
2. 若有 `root.val > p.val` : 当第一次搜索到满足此条件的节点时,在以 `root` 为根节点的子树中「位于最左下方」的值为 `p` 的后继,但也有可能 `root` 没有左子树,因此 `p` 的后继要么在 `root` 的左子树中(若有),要么是 `root` 本身,此时我们可以直接到 `root` 的左子树搜索,若搜索结果为空返回 `root`,否则返回搜索结果。
代码:
```Java
class Solution {
public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
if (root == null) return null;
if (root.val <= p.val) return inorderSuccessor(root.right, p);
TreeNode ans = inorderSuccessor(root.left, p);
return ans == null ? root : ans;
}
}
```
* 时间复杂度:复杂度与深度相关,最坏情况下仍会搜索所有节点,复杂度为 $O(n)$
* 空间复杂度:忽略递归带来的额外空间消耗,复杂度为 $O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 04.06` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 10.02. 变位词组（中等）.md | 面试题 10.02. 变位词组 | https://leetcode-cn.com/problems/group-anagrams-lcci/solution/gong-shui-san-xie-tong-ji-bian-wei-ci-de-0iqe/ | 中等 | [
"哈希表",
"排序",
"计数",
"数学",
"打表"
] | 编写一种方法,对字符串数组进行排序,将所有变位词组合在一起。变位词是指字母相同,但排列不同的字符串。
注意:本题相对原题稍作修改
示例:
```
输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
输出:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]
```
说明:
* 所有输入均为小写字母。
* 不考虑答案输出的顺序。 | ### 模拟 + 排序
一个朴素的想法是根据题意进行模拟,对每个字符串进行排序作为 `key`,从而实现相同的「变位词」对应同一个 `key`,使用哈希表进行统计即可。
代码:
```Java
class Solution {
public List<List<String>> groupAnagrams(String[] ss) {
List<List<String>> ans = new ArrayList<>();
Map<String, List<String>> map = new HashMap<>();
for (String s : ss) {
char[] cs = s.toCharArray();
Arrays.sort(cs);
String key = String.valueOf(cs);
List<String> list = map.getOrDefault(key, new ArrayList<>());
list.add(s);
map.put(key, list);
}
for (String key : map.keySet()) ans.add(map.get(key));
return ans;
}
}
```
* 时间复杂度:$O(\sum_{i = 0}^{n - 1}ss[i].length * \log{ss[i].length})$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1}ss[i])$
---
### 模拟 + 计数
方法一无法做到线性,主要是存在对字符串进行排序的环节。
事实上,我们可以利用字符集大小有限作为切入点(只包含小写字母),使用一个大小为 $26$ 的数组进行计数,然后对计数后的数组统计值进行拼接,作为哈希表的 `key`,从而实现线性复杂度。
代码:
```Java
class Solution {
public List<List<String>> groupAnagrams(String[] ss) {
List<List<String>> ans = new ArrayList<>();
Map<String, List<String>> map = new HashMap<>();
for (String s : ss) {
int[] cnts = new int[26];
for (char c : s.toCharArray()) cnts[c - 'a']++;
StringBuilder sb = new StringBuilder();
for (int i : cnts) sb.append(i + "_");
String key = sb.toString();
List<String> list = map.getOrDefault(key, new ArrayList<>());
list.add(s);
map.put(key, list);
}
for (String key : map.keySet()) ans.add(map.get(key));
return ans;
}
}
```
* 时间复杂度:令 $n$ 为数组大小,$C$ 为字符集大小,固定为 $26$。整体复杂度为 $O(\sum_{i = 0}^{n - 1}ss[i].length + n * C)$,
* 空间复杂度:$O(\sum_{i = 0}^{n - 1}ss[i])$
---
### 质数分解唯一性
事实上,我们还能使用「质数分解唯一性」性质,使用质数乘积代指某个「变位词」。
具体的,我们可以先使用 `static` 代码块(确保只会发生一次)打表最小的 $26$ 个质数(任意 $26$ 个都可以,使用小的,乘积溢出风险低一点),这 $26$ 个质数分别对应了 $26$ 个字母。
对于一个「变位词」而言,其对应的质数乘积必然相同。
代码:
```Java
class Solution {
static int[] nums = new int[26];
static {
for (int i = 2, idx = 0; idx != 26; i++) {
boolean ok = true;
for (int j = 2; j <= i / j; j++) {
if (i % j == 0) {
ok = false;
break;
}
}
if (ok) nums[idx++] = i;
}
}
public List<List<String>> groupAnagrams(String[] ss) {
List<List<String>> ans = new ArrayList<>();
Map<Long, List<String>> map = new HashMap<>();
for (String s : ss) {
long cur = 1;
for (char c : s.toCharArray()) {
cur *= nums[c - 'a'];
}
List<String> list = map.getOrDefault(cur, new ArrayList<>());
list.add(s);
map.put(cur, list);
}
for (long key : map.keySet()) ans.add(map.get(key));
return ans;
}
}
```
* 时间复杂度:$O(\sum_{i = 0}^{n - 1}ss[i].length)$
* 空间复杂度:$O(\sum_{i = 0}^{n - 1}ss[i])$
---
### 溢出说明
使用 `long` 仍然存在溢出风险,但使用“长度不受限制”的高精度哈希值实现是不现实的。
哈希值必须是有限值域内,才有意义。
换句话说,如果使用高精度的哈希值的话,我们是无法直接将两个哈希值进行异或判断结果是否为 $0$ 来得出哈希值是否相同的结论,而是需要使用 $O(Len)$ 的复杂度来判定哈希值是否相同。
因此,针对存在的哈希冲突问题,要么是解决冲突;要是使用与「字符串哈希」类似的做法,不处理溢出(相当于模 $2^{64}$),但这样会存在溢出次数不一样的值对应的哈希值相同的问题,只能说是一种期望冲突不发生的做法。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 10.02` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 16.25. LRU 缓存（中等）.md | 面试题 16.25. LRU 缓存 | https://leetcode-cn.com/problems/lru-cache-lcci/solution/gong-shui-san-xie-she-ji-shu-ju-jie-gou-k0iwg/) | 中等 | [
"设计",
"链表",
"哈希表"
] | 运用你所掌握的数据结构,设计和实现一个 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.面试题 16.25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.09. 第 k 个数（中等）.md | 面试题 17.09. 第 k 个数 | https://leetcode.cn/problems/get-kth-magic-number-lcci/solution/by-ac_oier-2czm/ | 中等 | [
"优先队列(堆)",
"多路归并",
"双指针"
] | 有些数的素因子只有 `3`,`5`,`7`,请设计一个算法找出第 `k` 个数。注意,不是必须有这些素因子,而是必须不包含其他的素因子。例如,前几个数按顺序应该是 `1`,`3`,`5`,`7`,`9`,`15`,`21`。
示例 1:
```
输入: k = 5
输出: 9
``` | ### 基本分析
本题的基本思路与 [264. 丑数 II : 从朴素优先队列到多路归并](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490029&idx=1&sn=bba9ddff88d247db310406ee418d5a15) 完全一致。
---
### 优先队列(小根堆)
有了基本的分析思路,一个简单的解法是使用优先队列:
1. 起始先将最小数值 $1$ 放入队列
2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的数值 $3x$、$5x$ 和 $7x$ 进行入队
3. 对步骤 2 循环多次,第 $k$ 次出队的值即是答案
为了防止同一数值多次进队,我们需要使用数据结构 $Set$ 来记录入过队列的数值。
Java 代码:
```Java
class Solution {
public int getKthMagicNumber(int k) {
int[] nums = new int[]{3, 5, 7};
PriorityQueue<Long> q = new PriorityQueue<>();
Set<Long> set = new HashSet<>();
q.add(1L); set.add(1L);
while (!q.isEmpty()) {
long t = q.poll();
if (--k == 0) return (int) t;
for (int x : nums) {
if (!set.contains(x * t)) {
q.add(x * t); set.add(x * t);
}
}
}
return -1;
}
}
```
Python3 代码:
```Python3
class Solution:
def getKthMagicNumber(self, k: int) -> int:
nums = [3, 5, 7]
q, vis = [], set()
q.append(1)
vis.add(1)
while q:
t = heapq.heappop(q)
k -= 1
if k == 0:
return t
for x in nums:
if t * x not in vis:
heapq.heappush(q, t * x)
vis.add(t * x)
return -1
```
* 时间复杂度:$O(k\log{k})$
* 空间复杂度:$O(k)$
---
### 多路归并(多指针)
从解法一中不难发现,我们「往后产生的数值」都是基于「已有数值」而来(使用「已有数值」乘上 $3$、$5$、$7$)。
因此,如果我们最终的数值序列为 $a1,a2,a3,...,an$ 的话,序列中的每一个数都必然能够被以下三个序列(中的至少一个)覆盖:
* 由数值 $\times 3$ 所得的有序序列:$1 \times 3$、$2 \times 3$、$3 \times 3$、$4 \times 3$、$5 \times 3$、$6 \times 3$、$8 \times 3$ ...
* 由数值 $\times 5$ 所得的有序序列:$1 \times 5$、$2 \times 5$、$3 \times 5$、$4 \times 5$、$5 \times 5$、$6 \times 5$、$8 \times 5$ ...
* 由数值 $\times 6$ 所得的有序序列:$1 \times 7$、$2 \times 7$、$3 \times 7$、$4 \times 7$、$5 \times 7$、$6 \times 7$、$8 \times 6$ ...
举个🌰,假设我们需要求得 $[1, 3, 5, 7, 9, 15, 21]$ 数值序列 $arr$ 的最后一位,那么该序列可以看作以下三个有序序列归并而来:
* $1 \times 3, 3 \times 3, 5 \times 3, ... , 15 \times 3, 21 \times 3$ ,将 $3$ 提出,即 $arr \times 3$
* $1 \times 5, 3 \times 5, 5 \times 5, ... , 15 \times 5, 21 \times 5$ ,将 $5$ 提出,即 $arr \times 5$
* $1 \times 7, 3 \times 7, 5 \times 7, ... , 15 \times 7, 21 \times 7$ ,将 $7$ 提出,即 $arr \times 7$
因此我们可以使用三个指针来指向目标序列 $arr$ 的某个下标(下标 $0$ 作为哨兵不使用,起始都为 $1$),使用 $arr[下标] \times 系数$(`3`、`5` 和 `7`) 代表当前使用到三个有序序列中的哪一位,同时使用 $idx$ 表示当前生成到 $arr$ 哪一位数值。
Java 代码:
```Java
class Solution {
public int getKthMagicNumber(int k) {
int[] ans = new int[k + 1];
ans[1] = 1;
for (int i3 = 1, i5 = 1, i7 = 1, idx = 2; idx <= k; idx++) {
int a = ans[i3] * 3, b = ans[i5] * 5, c = ans[i7] * 7;
int min = Math.min(a, Math.min(b, c));
if (min == a) i3++;
if (min == b) i5++;
if (min == c) i7++;
ans[idx] = min;
}
return ans[k];
}
}
```
TypeScript 代码:
```TypeScript
function getKthMagicNumber(k: number): number {
const ans = new Array<number>(k + 1).fill(1)
for (let i3 = 1, i5 = 1, i7 = 1, idx = 2; idx <= k; idx++) {
const a = ans[i3] * 3, b = ans[i5] * 5, c = ans[i7] * 7
const min = Math.min(a, Math.min(b, c))
if (a == min) i3++
if (b == min) i5++
if (c == min) i7++
ans[idx] = min
}
return ans[k]
};
```
Python 代码:
```Python
class Solution:
def getKthMagicNumber(self, k: int) -> int:
ans = [1] * (k + 1)
i3, i5, i7 = 1, 1, 1
for idx in range(2, k + 1):
a, b, c = ans[i3] * 3, ans[i5] * 5, ans[i7] * 7
cur = min([a, b, c])
i3 = i3 + 1 if cur == a else i3
i5 = i5 + 1 if cur == b else i5
i7 = i7 + 1 if cur == c else i7
ans[idx] = cur
return ans[k]
```
* 时间复杂度:$O(k)$
* 空间复杂度:$O(k)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.09` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.10. 主要元素（简单）.md | 面试题 17.10. 主要元素 | https://leetcode-cn.com/problems/find-majority-element-lcci/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-zkht/ | 简单 | [
"哈希表",
"摩尔投票"
] | 数组中占比超过一半的元素称之为主要元素。给你一个 整数 数组,找出其中的主要元素。
若没有,返回 -1 。请设计时间复杂度为 $O(N)$ 、空间复杂度为 $O(1)$ 的解决方案。
示例 1:
```
输入:[1,2,5,9,5,9,5,5,5]
输出:5
```
示例 2:
```
输入:[3,2]
输出:-1
```
示例 3:
```
输入:[2,2,1,1,1,2,2]
输出:2
``` | ### 哈希表
一个朴素的做法是使用哈希表进行计数,如果发现某个元素数量超过总数一半,说明找到了答案。
代码:
```Java
class Solution {
public int majorityElement(int[] nums) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
for (int x : nums) {
map.put(x, map.getOrDefault(x, 0) + 1);
if (map.get(x) > n / 2) return x;
}
return -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(n)$
---
### 摩尔投票
这还是道「摩尔投票」模板题。
**[摩尔投票](https://zh.wikipedia.org/wiki/%E5%A4%9A%E6%95%B0%E6%8A%95%E7%A5%A8%E7%AE%97%E6%B3%95) :在集合中寻找可能存在的多数元素,这一元素在输入的序列重复出现并占到了序列元素的一半以上;在第一遍遍历之后应该再进行一个遍历以统计第一次算法遍历的结果出现次数,确定其是否为众数;如果一个序列中没有占到多数的元素,那么第一次的结果就可能是无效的随机元素。**
**换句话说,每次将两个不同的元素进行「抵消」,如果最后有元素剩余,则「可能」为元素个数大于总数一半的那个。**
具体的,我们定义一个变量 $x$ 来保存那个可能为主要元素的值,$cnt$ 用来记录该值的出现次数。然后在遍历数组 $nums$ 过程中执行如下逻辑:
* 如果 $cnt$ 为 $0$:说明之前出现过的 $x$ 已经被抵消完了,更新一下 $x$ 为当前值,出现次数为 $1$:`x = nums[i], cnt = 1`;
* 如果 $cnt$ 不为 $0$:说明之前统计的 $x$ 还没被抵消完,这是根据 $nums[i]$ 与 $x$ 是否相等进行计算即可:`cnt += nums[i] == x ? 1 : -1`。
当处理完 $nums$ 之后,我们得到了一个「可能」的主要元素。注意只是可能,因为我们在处理过程中只使用了 $x$ 和 $cnt$ 来记录,我们是无法确定最后剩下的 $x$ 是经过多次抵消后剩余的主要元素,还是只是不存在主要元素的数组中的无效随机元素。
因此我们需要再进行一次遍历,检查这个「可能」的主要元素 $x$ 的出现次数是否超过总数一半。
代码:
```Java
class Solution {
public int majorityElement(int[] nums) {
int n = nums.length;
int x = -1, cnt = 0;
for (int i : nums) {
if (cnt == 0) {
x = i;
cnt = 1;
} else {
cnt += x == i ? 1 : -1;
}
}
cnt = 0;
for (int i : nums) if (x == i) cnt++;
return cnt > n / 2 ? x : -1;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.10` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.11. 单词距离（中等）.md | 面试题 17.11. 单词距离 | https://leetcode.cn/problems/find-closest-lcci/solution/by-ac_oier-0hv9/ | 中等 | [
"模拟",
"双指针"
] | 有个内含单词的超大文本文件,给定任意两个不同的单词,找出在这个文件中这两个单词的最短距离(相隔单词数)。如果寻找过程在这个文件中会重复多次,而每次寻找的单词不同,你能对此优化吗?
示例:
```
输入:words = ["I","am","a","student","from","a","university","in","a","city"], word1 = "a", word2 = "student"
输出:1
```
提示:
* $words.length <= 100000$ | ### 模拟
对 `words` 进行遍历,使用两个指针 `p` 和 `q` 分别记录最近的两个关键字的位置,并维护更新最小距离。
代码:
```Java
class Solution {
public int findClosest(String[] ws, String a, String b) {
int n = ws.length, ans = n;
for (int i = 0, p = -1, q = -1; i < n; i++) {
String t = ws[i];
if (t.equals(a)) p = i;
if (t.equals(b)) q = i;
if (p != -1 && q != -1) ans = Math.min(ans, Math.abs(p - q));
}
return ans;
}
}
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.14. 最小K个数（中等）.md | 面试题 17.14. 最小K个数 | https://leetcode-cn.com/problems/smallest-k-lcci/solution/gong-shui-san-xie-yi-ti-si-jie-you-xian-yy5k5/ | 中等 | [
"优先队列(堆)",
"排序"
] | 设计一个算法,找出数组中最小的 $k$ 个数。以任意顺序返回这k个数均可。
示例:
```
输入: arr = [1,3,5,7,2,4,6,8], k = 4
输出: [1,2,3,4]
```
提示:
* $0 <= len(arr) <= 100000$
* $0 <= k <= \min(100000, len(arr))$ | ### 优先队列(小根堆)
一个直观的想法是使用「优先队列(小根堆)」,起始将所有元素放入堆中,然后再从堆中取出 $k$ 个元素并「顺序」构造答案。
代码:
```Java
class Solution {
public int[] smallestK(int[] arr, int k) {
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);
for (int i : arr) q.add(i);
int[] ans = new int[k];
for (int i = 0; i < k; i++) ans[i] = q.poll();
return ans;
}
}
```
* 时间复杂度:建堆复杂度为 $O(n\log{n})$,构造答案复杂度为 $O(k\log{n})$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(n + k)$
---
### 优先队列(大根堆)
在解法一中,我们将所有的原始都放入堆中,堆中元素最多有 $n$ 个,这导致了我们复杂度的上界为 $O(n\log{n})$。
而另外一个比较优秀的做法是,使用「优先队列(大根堆)」。
当处理到原始 $arr[i]$ 时,根据堆内元素个数,以及其与堆顶元素的关系分情况讨论:
* 堆内元素不足 $k$ 个:直接将 $arr[i]$ 放入堆内;
* 堆内元素为 $k$ 个:根据 $arr[i]$ 与堆顶元素的大小关系分情况讨论:
* $arr[i] >= heapTop$:$arr[i]$ 不可能属于第 $k$ 小数(已有 $k$ 个元素在堆中),直接丢弃 $arr[i]$;
* $arr[i] < heapTop$:$arr[i]$ 可能属于第 $k$ 小数,弹出堆顶元素,并放入 $arr[i]$。
当 $arr$ 被处理完,我们再使用堆中元素「逆序」构造答案。
代码:
```Java
class Solution {
public int[] smallestK(int[] arr, int k) {
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);
int[] ans = new int[k];
if (k == 0) return ans;
for (int i : arr) {
if (q.size() == k && q.peek() <= i) continue;
if (q.size() == k) q.poll();
q.add(i);
}
for (int i = k - 1; i >= 0; i--) ans[i] = q.poll();
return ans;
}
}
```
* 时间复杂度:建堆复杂度为 $O(n\log{k})$,构造答案复杂度为 $O(k\log{k})$。整体复杂度为 $O(n\log{k})$
* 空间复杂度:$O(k)$
---
### 全排序
Java 中的 `Arrays.sort` 为综合排序实现。会根据数据规模、元素本身是否大致有序选择不同的排序实现。
因此一个比较省事的实现是先使用 `Arrays.sort` 进行排序,再构造答案。
代码:
```Java
class Solution {
public int[] smallestK(int[] arr, int k) {
Arrays.sort(arr);
int[] ans = new int[k];
for (int i = 0; i < k; i++) ans[i] = arr[i];
return ans;
}
}
```
* 时间复杂度:排序(假定 `Arrays.sort` 使用的是双轴快排实现)的复杂度为 $O(n\log{n})$;构造答案复杂度为 $O(k)$。整体复杂度为 $O(n\log{n})$
* 空间复杂度:$O(\log{n} + k)$
---
### 快排数组划分
注意到题目要求「任意顺序返回这 $k$ 个数即可」,因此我们只需要确保前 $k$ 小的数都出现在下标为 $[0, k)$ 的位置即可。
利用「快速排序」的数组划分即可做到。
我们知道快排每次都会将小于等于基准值的值放到左边,将大于基准值的值放到右边。
因此我们可以通过判断基准点的下标 $idx$ 与 $k$ 的关系来确定过程是否结束:
* $idx < k$:基准点左侧不足 $k$ 个,递归处理右边,让基准点下标右移;
* $idx > k$:基准点左侧超过 $k$ 个,递归处理左边,让基准点下标左移;
* $idx = k$:基准点左侧恰好 $k$ 个,输出基准点左侧元素。
代码:
```Java
class Solution {
int k;
public int[] smallestK(int[] arr, int _k) {
k = _k;
int n = arr.length;
int[] ans = new int[k];
if (k == 0) return ans;
qsort(arr, 0, n - 1);
for (int i = 0; i < k; i++) ans[i] = arr[i];
return ans;
}
void qsort(int[] arr, int l, int r) {
if (l >= r) return ;
int i = l, j = r;
int ridx = new Random().nextInt(r - l + 1) + l;
swap(arr, ridx, l);
int x = arr[l];
while (i < j) {
while (i < j && arr[j] >= x) j--;
while (i < j && arr[i] <= x) i++;
swap(arr, i, j);
}
swap(arr, i, l);
// 集中答疑:因为题解是使用「基准点左侧」来进行描述(不包含基准点的意思),所以这里用的 k(写成 k - 1 也可以滴
if (i > k) qsort(arr, l, i - 1);
if (i < k) qsort(arr, i + 1, r);
}
void swap(int[] arr, int l, int r) {
int tmp = arr[l];
arr[l] = arr[r];
arr[r] = tmp;
}
}
```
* 时间复杂度:由于每次都会随机选择基准值,因此每次递归的数组平均长度为 $n / 2$,那么划分数组操作的次数不会超过 $2 \times n$。整体复杂度为 $O(n)$
* 空间复杂度:$O(\log{n})$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.14` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.19. 消失的两个数字（困难）.md | 面试题 17.19. 消失的两个数字 | https://leetcode.cn/problems/missing-two-lcci/solution/by-ac_oier-pgeh/ | 困难 | [
"数学",
"位运算"
] | 给定一个数组,包含从 `1` 到 `N` 所有的整数,但其中缺了两个数字。你能在 $O(N)$ 时间内只用 $O(1)$ 的空间找到它们吗?
以任意顺序返回这两个数字均可。
示例 1:
```
输入: [1]
输出: [2,3]
```
示例 2:
```
输入: [2,3]
输出: [1,4]
```
提示:
* $nums.length <= 30000$ | ### 数学
根据题意,给定 `nums` 的长度为 $m$ 且缺失了两个数,所有的 $nums[i]$ 加上缺失数字组成连续排列长度为 $n = m + 2$。
根据等差数量求和公式可知,补齐后的排列总和为 $\frac{n \times (1 + n)}{2}$,补全后的理论总和与实际总和之间的差值 $cur = \frac{n \times (1 + n)}{2} - \sum_{i = 0}^{m - 1}nums[i]$ 为缺失数值之和。
根据补全后数值各不相同可知,两者必不可能同时位于 $t = \left \lfloor \frac{cur}{2} \right \rfloor$ 的同一侧(偏大、偏小或数值重复),因此我们可以计算 $[1, t]$ 范围内的理论总和与实际总和之间的差值来确定其一(将问题转换为求解缺失一值),再结合缺失两值之和 $sum$ 算得答案。
Java 代码:
```Java
class Solution {
public int[] missingTwo(int[] nums) {
int n = nums.length + 2, cur = n * (1 + n) / 2;
for (int x : nums) cur -= x;
int sum = cur, t = cur / 2;
cur = t * (1 + t) / 2;
for (int x : nums) {
if (x <= t) cur -= x;
}
return new int[]{cur, sum - cur};
}
}
```
TypeScript 代码:
```TypeScript
function missingTwo(nums: number[]): number[] {
let n = nums.length + 2, cur = Math.floor(n * (1 + n) / 2)
for (let x of nums) cur -= x
let sum = cur, t = Math.floor(cur / 2)
cur = Math.floor(t * (1 + t) / 2)
for (let x of nums) {
if (x <= t) cur -= x
}
return [cur, sum - cur]
};
```
Python 代码:
```Python
class Solution:
def missingTwo(self, nums: List[int]) -> List[int]:
n = len(nums) + 2
cur = n * (1 + n) // 2 - sum(nums)
tot, t = cur, cur // 2
cur = t * (1 + t) // 2 - sum([x for x in nums if x <= t])
return [cur, tot - cur]
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$
---
### 异或
另外一类求解方法是利用「异或」+「lowbit」。
由于我们明确了是在 $[1, n + 2]$ 中缺失了两个数,我们可以先通过异或 $[1, n + 2]$ 以及所有的 $nums[i]$ 来得到缺失两个数值异或和 `t`。
我们知道异或结果二进制表示为 $1$ 代表了两缺失值该位置数值不同(一个该位置 $0$,另一个该位置为 $1$),我们可以根据异或和 `t` 中任意一位为 $1$ 的位置来将两个缺失值划分到两组中。
更加优雅的方式是使用 `lowbit` 操作:`d = t & -t` 可快速得到只保留 `t` 中最低位 `1` 的对应数值。
随后将 $[1, n + 2]$ 中满足 `i & d != 0` 的所有 `i`(含义为对应位置为 $1$ 的数值)与 $nums[i]$ 中满足 `nums[i] & d != 0` 的所有 $nums[i]$(含义为对应位置为 $1$ 的数值) 进行异或,最终能够确定其中一个缺失值,再结合最开始的异或和 `t` 即可确定另外一个缺失值。
Java 代码:
```Java
class Solution {
public int[] missingTwo(int[] nums) {
int n = nums.length + 2, cur = 0;
for (int i = 1; i <= n; i++) cur ^= i;
for (int x : nums) cur ^= x;
int t = cur, d = cur & -cur;
cur = 0;
for (int i = 1; i <= n; i++) {
if ((d & i) != 0) cur ^= i;
}
for (int x : nums) {
if ((d & x) != 0) cur ^= x;
}
return new int[]{cur, t ^ cur};
}
}
```
TypeScript 代码:
```TypeScript
function missingTwo(nums: number[]): number[] {
let n = nums.length + 2, cur = 0
for (let i = 1; i <= n; i++) cur ^= i
for (let x of nums) cur ^= x
const t = cur, d = cur & -cur
cur = 0
for (let i = 1; i <= n; i++) {
if ((d & i) != 0) cur ^= i
}
for (let x of nums) {
if ((d & x) != 0) cur ^= x
}
return [cur, t ^ cur]
};
```
Python 代码:
```Python
class Solution:
def missingTwo(self, nums: List[int]) -> List[int]:
n, cur = len(nums) + 2, 0
for i in range(1, n + 1):
cur ^= i
for x in nums:
cur ^= x
t, d = cur, cur & -cur
cur = 0
for i in range(1, n + 1):
if d & i:
cur ^= i
for x in nums:
if d & x:
cur ^= x
return [cur, t ^ cur]
```
* 时间复杂度:$O(n)$
* 空间复杂度:$O(1)$ | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.19` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.21. 直方图的水量（困难）.md | 面试题 17.21. 直方图的水量 | https://leetcode-cn.com/problems/volume-of-histogram-lcci/solution/gong-shui-san-xie-yi-ti-si-jie-po-su-yu-sqadp/ | 困难 | [
"数学",
"双指针",
"动态规划"
] | 给定一个直方图(也称柱状图),假设有人从上面源源不断地倒水,最后直方图能存多少水量?直方图的宽度为 1。
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的直方图,在这种情况下,可以接 6 个单位的水(蓝色部分表示水)。 感谢 Marcos 贡献此图。
示例:
```
输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6
``` | ### 朴素解法
对于每根柱子而言,我们只需要找出「其左边最高的柱子」和「其右边最高的柱子」。
对左右的最高柱子取一个最小值,再和当前柱子的高度做一个比较,即可得出当前位置可以接下的雨水。
同时,边缘的柱子不可能接到雨水(某一侧没有柱子)。
这样的做法属于「暴力做法」,但题目没有给数据范围,我们无法分析到底能否 AC。
唯唯诺诺交一个,过了 ~ (好题,建议加入蓝桥杯
代码:
```java []
class Solution {
public int trap(int[] height) {
int n = height.length;
int ans = 0;
for (int i = 1; i < n - 1; i++) {
int cur = height[i];
// 获取当前位置的左边最大值
int l = Integer.MIN_VALUE;
for (int j = i - 1; j >= 0; j--) l = Math.max(l, height[j]);
if (l <= cur) continue;
// 获取当前位置的右边边最大值
int r = Integer.MIN_VALUE;
for (int j = i + 1; j < n; j++) r = Math.max(r, height[j]);
if (r <= cur) continue;
// 计算当前位置可接的雨水
ans += Math.min(l, r) - cur;
}
return ans;
}
}
```
* 时间复杂度:需要处理所有非边缘的柱子,复杂度为 $O(n)$;对于每根柱子而言,需要往两边扫描分别找到最大值,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$。
* 空间复杂度:$O(1)$。
***
### 预处理最值
朴素解法的思路有了,我们想想怎么优化。
事实上,任何的优化无非都是「减少重复」。
想想在朴素思路中有哪些环节比较耗时,耗时环节中又有哪些地方是重复的,可以优化的。
首先对每根柱子进行遍历,求解每根柱子可以接下多少雨水,这个 $O(n)$ 操作肯定省不了。
**但在求解某根柱子可以接下多少雨水时,需要对两边进行扫描,求两侧的最大值。每一根柱子都进行这样的扫描操作,导致每个位置都被扫描了 $n$ 次。这个过程显然是可优化的。**
换句话说:**我们希望通过不重复遍历的方式找到任意位置的两侧最大值。**
问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**
一个很直观的方案是:**直接将某个位置的两侧最大值存起来。**
我们可以先从两端分别出发,预处理每个位置的「左右最值」,这样可以将我们「查找左右最值」的复杂度降到 $O(1)$。
整体算法的复杂度也从 $O(n^2)$ 下降到 $O(n)$。
代码:
```java []
class Solution {
public int trap(int[] height) {
int n = height.length;
int ans = 0;
// 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下
if (n == 0) return ans;
// 预处理每个位置左边的最值
int[] lm = new int[n];
lm[0] = height[0];
for (int i = 1; i < n; i++) lm[i] = Math.max(height[i], lm[i - 1]);
// 预处理每个位置右边的最值
int[] rm = new int[n];
rm[n - 1] = height[n - 1];
for (int i = n - 2; i >= 0; i--) rm[i] = Math.max(height[i], rm[i + 1]);
for (int i = 1; i < n - 1; i++) {
ans += Math.min(lm[i], rm[i]) - height[i];
}
return ans;
}
}
```
* 时间复杂度:预处理出两个最大值数组,复杂度为 $O(n)$;计算每根柱子可接的雨水量,复杂度为 $O(n)$。整体复杂度为 $O(n)$。
* 空间复杂度:使用了数组存储两侧最大值。复杂度为 $O(n)$。
***
### 单调栈
前面我们讲到,优化思路将问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**
但仔细一想,其实我们并不需要找两侧最大值,只需要找到两侧最近的比当前位置高的柱子就行了。
针对这一类找最近值的问题,有一个通用解法:**单调栈**。
**单调栈其实就是在栈的基础上,维持一个栈内元素单调。**
在这道题,由于需要找某个位置两侧比其高的柱子(只有两侧有比当前位置高的柱子,当前位置才能接下雨水),我们可以维持栈内元素的单调递减。
**PS. 找某侧最近一个比其大的值,使用单调栈维持栈内元素递减;找某侧最近一个比其小的值,使用单调栈维持栈内元素递增 ...**
当某个位置的元素弹出栈时,例如位置 `a` ,我们自然可以得到 `a` 位置两侧比 `a` 高的柱子:
* 一个是导致 `a` 位置元素弹出的柱子( `a` 右侧比 `a` 高的柱子)
* 一个是 `a` 弹栈后的栈顶元素(`a` 左侧比 `a` 高的柱子)
当有了 `a` 左右两侧比 `a` 高的柱子后,便可计算 `a` 位置可接下的雨水量。
代码:
```java []
class Solution {
public int trap(int[] height) {
int n = height.length;
int ans = 0;
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && height[i] > height[d.peekLast()]) {
int cur = d.pollLast();
// 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过
if (d.isEmpty()) continue;
// 左右位置,并有左右位置得出「宽度」和「高度」
int l = d.peekLast(), r = i;
int w = r - l + 1 - 2;
int h = Math.min(height[l], height[r]) - height[cur];
ans += w * h;
}
d.addLast(i);
}
return ans;
}
}
```
* 时间复杂度:每个元素最多进栈和出栈一次。复杂度为 $O(n)$。
* 空间复杂度:栈最多存储 $n$ 个元素。复杂度为 $O(n)$。
***
### 面积差值
事实上,我们还能利用「面积差值」来进行求解。
我们先统计出「柱子面积」$sum$ 和「以柱子个数为宽、最高柱子高度为高的矩形面积」$full$。
然后分别「从左往右」和「从右往左」计算一次最大高度覆盖面积 $lSum$ 和 $rSum$。
**显然会出现重复面积,并且重复面积只会独立地出现在「山峰」的左边和右边。**
利用此特性,我们可以通过简单的等式关系求解出「雨水面积」:
代码:
```java []
class Solution {
public int trap(int[] height) {
int n = height.length;
int sum = 0, max = 0;
for (int i = 0; i < n; i++) {
int cur = height[i];
sum += cur;
max = Math.max(max, cur);
}
int full = max * n;
int lSum = 0, lMax = 0;
for (int i = 0; i < n; i++) {
lMax = Math.max(lMax, height[i]);
lSum += lMax;
}
int rSum = 0, rMax = 0;
for (int i = n - 1; i >= 0; i--) {
rMax = Math.max(rMax, height[i]);
rSum += rMax;
}
return lSum + rSum - full - sum;
}
}
```
* 时间复杂度:$O(n)$。
* 空间复杂度:$O(1)$。 | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.21` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
Subsets and Splits