Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit f1dfdd6

Browse files
committed
更新题解列表
1 parent 9ec1a5b commit f1dfdd6

File tree

4 files changed

+168
-34
lines changed

4 files changed

+168
-34
lines changed

‎Solutions/0778. 水位上升的泳池中游泳.md‎

Lines changed: 47 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -5,27 +5,62 @@
55

66
## 题目大意
77

8-
给定一个 `n * n` 大小的二维数组 `grid`,每一个方格的值 `grid[i][j]` 表示为位置 `(i, j)` 的高度。
8+
**描述**:给定一个 $n \times n$ 大小的二维数组 $grid$,每一个方格的值 $grid[i][j]$ 表示为位置 $(i, j)$ 的高度。
99

10-
现在要从左上角 `(0, 0)` 位置出发,经过方格的一些点,到达右下角 `(n - 1, n - 1)` 位置上。其中所经过路径的花费为这条路径上所有位置的最大高度。
10+
现在要从左上角 $(0, 0)$ 位置出发,经过方格的一些点,到达右下角 $(n - 1, n - 1)$ 位置上。其中所经过路径的花费为这条路径上所有位置的最大高度。
1111

12-
现在要求:计算从 `(0, 0)` 位置到 `(n - 1, n - 1)` 的最优路径的花费。
12+
**要求**:计算从 $(0, 0)$ 位置到 $(n - 1, n - 1)$ 的最优路径的花费。
1313

14-
最优路径指的路径上最大高度最小的那条路径。
14+
**说明**:
15+
16+
- **最优路径**:路径上最大高度最小的那条路径。
17+
- $n == grid.length$。
18+
- $n == grid[i].length$。
19+
- 1ドル \le n \le 50$。
20+
- 0ドル \le grid[i][j] < n2$。
21+
- $grid[i][j]$ 中每个值均无重复。
22+
23+
**示例**:
24+
25+
- 示例 1:
26+
27+
![](https://assets.leetcode.com/uploads/2021/06/29/swim1-grid.jpg)
28+
29+
```python
30+
输入: grid = [[0,2],[1,3]]
31+
输出: 3
32+
解释:
33+
时间为 0 时,你位于坐标方格的位置为 (0, 0)。
34+
此时你不能游向任意方向,因为四个相邻方向平台的高度都大于当前时间为 0 时的水位。
35+
等时间到达 3 时,你才可以游向平台 (1, 1). 因为此时的水位是 3,坐标方格中的平台没有比水位 3 更高的,所以你可以游向坐标方格中的任意位置。
36+
```
37+
38+
- 示例 2:
39+
40+
![](https://assets.leetcode.com/uploads/2021/06/29/swim2-grid-1.jpg)
41+
42+
```python
43+
输入: grid = [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
44+
输出: 16
45+
解释: 最终的路线用加粗进行了标记。
46+
我们必须等到时间为 16,此时才能保证平台 (0, 0) 和 (4, 4) 是连通的。
47+
```
1548

1649
## 解题思路
1750

51+
### 思路 1:并查集
52+
1853
将整个网络抽象为一个无向图,每个点与相邻的点(上下左右)之间都存在一条无向边,边的权重为两个点之间的最大高度。
1954

20-
我们要找到左上角到右下角的最优路径,可以遍历所有的点,将所有的边存储到数组中,每条边的存储格式为 `[x, y, h]`,意思是编号 `x` 的点和编号为 `y` 的点之间的权重为 `h`。
55+
我们要找到左上角到右下角的最优路径,可以遍历所有的点,将所有的边存储到数组中,每条边的存储格式为 $[x, y, h]$,意思是编号 $x$ 的点和编号为 $y$ 的点之间的权重为 $h$。
2156

2257
然后按照权重从小到大的顺序,对所有边进行排序。
2358

24-
再按照权重大小遍历所有边,将其依次加入并查集中。并且每次都需要判断 `(0, 0)` 点和 `(n - 1, n - 1)` 点是否连通。
59+
再按照权重大小遍历所有边,将其依次加入并查集中。并且每次都需要判断 $(0, 0)$ 点和 $(n - 1, n - 1)$ 点是否连通。
2560

2661
如果连通,则该边的权重即为答案。
2762

28-
##代码
63+
### 思路 1:代码
2964

3065
```python
3166
class UnionFind:
@@ -83,3 +118,8 @@ class Solution:
83118
return 0
84119
```
85120

121+
### 思路 1:复杂度分析
122+
123+
- **时间复杂度**:$O(m \times n \times \alpha(m \times n)),ドル其中 $\alpha$ 是反 Ackerman 函数。
124+
- **空间复杂度**:$O(m \times n)$。
125+

‎Solutions/0803. 打砖块.md‎

Lines changed: 72 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -5,41 +5,94 @@
55

66
## 题目大意
77

8-
给定一个 `m * n` 大小的二元网格,其中 `1` 表示砖块,`0` 表示空白。砖块稳定(不会掉落)的前提是:
8+
**描述**:给定一个 $m \times n$ 大小的二元网格,其中 1ドル$ 表示砖块,0ドル$ 表示空白。砖块稳定(不会掉落)的前提是:
99

1010
- 一块砖直接连接到网格的顶部。
1111
- 或者至少有一块相邻(4 个方向之一)砖块稳定不会掉落时。
1212

13-
再给定一个数组 `hits`,这是需要依次消除砖块的位置。每当消除 `hits[i] = (row_i, col_i)` 位置上的砖块时,对应位置的砖块(若存在)会消失,然后其他的砖块可能因为这一消除操作而掉落。一旦砖块掉落,它会立即从网格中消失(即,它不会落在其他稳定的砖块上)。
13+
再给定一个数组 $hits$,这是需要依次消除砖块的位置。每当消除 $hits[i] = (row_i, col_i)$ 位置上的砖块时,对应位置的砖块(若存在)会消失,然后其他的砖块可能因为这一消除操作而掉落。一旦砖块掉落,它会立即从网格中消失(即,它不会落在其他稳定的砖块上)。
1414

15-
要求:返回一个数组 `result`,其中 `result[i]` 表示第 `i` 次消除操作对应掉落的砖块数目。
15+
**要求**:返回一个数组 $result$,其中 $result[i]$ 表示第 $i$ 次消除操作对应掉落的砖块数目。
1616

17-
注意:消除可能指向是没有砖块的空白位置,如果发生这种情况,则没有砖块掉落。
17+
**说明**:
18+
19+
- 消除可能指向是没有砖块的空白位置,如果发生这种情况,则没有砖块掉落。
20+
- $m == grid.length$。
21+
- $n == grid[i].length$。
22+
- 1ドル \le m, n \le 200$。
23+
- $grid[i][j]$ 为 0ドル$ 或 1ドル$。
24+
- 1ドル \le hits.length \le 4 \times 10^4$。
25+
- $hits[i].length == 2$。
26+
- 0ドル \le xi \le m - 1$。
27+
- 0ドル \le yi \le n - 1$。
28+
- 所有 $(xi, yi)$ 互不相同。
29+
30+
**示例**:
31+
32+
- 示例 1:
33+
34+
```python
35+
输入:grid = [[1,0,0,0],[1,1,1,0]], hits = [[1,0]]
36+
输出:[2]
37+
解释:网格开始为:
38+
[[1,0,0,0],
39+
[1,1,1,0]]
40+
消除 (1,0) 处加粗的砖块,得到网格:
41+
[[1,0,0,0]
42+
[0,1,1,0]]
43+
两个加粗的砖不再稳定,因为它们不再与顶部相连,也不再与另一个稳定的砖相邻,因此它们将掉落。得到网格:
44+
[[1,0,0,0],
45+
[0,0,0,0]]
46+
因此,结果为 [2]。
47+
```
48+
49+
- 示例 2:
50+
51+
```python
52+
输入:grid = [[1,0,0,0],[1,1,0,0]], hits = [[1,1],[1,0]]
53+
输出:[0,0]
54+
解释:网格开始为:
55+
[[1,0,0,0],
56+
[1,1,0,0]]
57+
消除 (1,1) 处加粗的砖块,得到网格:
58+
[[1,0,0,0],
59+
[1,0,0,0]]
60+
剩下的砖都很稳定,所以不会掉落。网格保持不变:
61+
[[1,0,0,0],
62+
[1,0,0,0]]
63+
接下来消除 (1,0) 处加粗的砖块,得到网格:
64+
[[1,0,0,0],
65+
[0,0,0,0]]
66+
剩下的砖块仍然是稳定的,所以不会有砖块掉落。
67+
因此,结果为 [0,0]。
68+
```
1869

1970
## 解题思路
2071

72+
### 思路 1:并查集
73+
2174
一个很直观的想法:
2275

2376
- 将所有砖块放入一个集合中。
24-
- 根据 `hits` 数组的顺序,每敲掉一块砖。则将这块砖与相邻(4 个方向)的砖块断开集合。
77+
- 根据 $hits$ 数组的顺序,每敲掉一块砖。则将这块砖与相邻(4 个方向)的砖块断开集合。
2578
- 然后判断哪些砖块会掉落,从集合中删除会掉落的砖块,并统计掉落砖块的数量。
26-
- `掉落砖块的数目 = 击碎砖块之前与屋顶相连的砖块数目 - 击碎砖块之后与屋顶相连的砖块数目 - 1`。
79+
- **掉落砖块的数目 = 击碎砖块之前与屋顶相连的砖块数目 - 击碎砖块之后与屋顶相连的砖块数目 - 1**。
2780

2881
涉及集合问题,很容易想到用并查集来做。但是并查集主要用于合并查找集合,不适合断开集合。我们可以反向思考问题:
2982

30-
- 先将 `hits` 中的所有位置上的砖块敲掉。
83+
- 先将 $hits$ 中的所有位置上的砖块敲掉。
3184
- 将剩下的砖块建立并查集。
32-
- 逆序填回被敲掉的砖块,并与相邻(4 个方向)的砖块合并。这样问题就变为了 `补上砖块会新增多少个砖块粘到屋顶`。
85+
- 逆序填回被敲掉的砖块,并与相邻(4 个方向)的砖块合并。这样问题就变为了 **补上砖块会新增多少个砖块粘到屋顶**。
3386

3487
整个算法步骤具体如下:
3588

36-
- 先将二维数组 `grid` 复制一份到二维数组 `copy_gird` 上。这是因为遍历 `hits` 元素时需要判断原网格是空白还是被打碎的砖块。
37-
- 在 `copy_grid` 中将 `hits` 中打碎的砖块赋值为 `0`。
38-
- 建立并查集,将房顶上的砖块合并到一个集合中。
39-
- 逆序遍历 `hits`,将 `hits` 中的砖块补到 `copy_grid` 中,并计算每一步中有多少个砖块粘到屋顶上(与屋顶砖块在一个集合中),并存入答案数组对应位置。
40-
- 最后输出答案数组。
89+
1. 先将二维数组 $grid$ 复制一份到二维数组 $copy\underline{}gird$ 上。这是因为遍历 $hits$ 元素时需要判断原网格是空白还是被打碎的砖块。
90+
2. 在 $copy\underline{}grid$ 中将 $hits$ 中打碎的砖块赋值为 0ドル$。
91+
3. 建立并查集,将房顶上的砖块合并到一个集合中。
92+
4. 逆序遍历 $hits$,将 $hits$ 中的砖块补到 $copy\underline{}grid$ 中,并计算每一步中有多少个砖块粘到屋顶上(与屋顶砖块在一个集合中),并存入答案数组对应位置。
93+
5. 最后输出答案数组。
4194

42-
##代码
95+
### 思路 1:代码
4396

4497
```python
4598
class UnionFind:
@@ -119,3 +172,8 @@ class Solution:
119172
return res
120173
```
121174

175+
### 思路 1:复杂度分析
176+
177+
- **时间复杂度**:$O(m \times n \times \alpha(m \times n)),ドル其中 $\alpha$ 是反 Ackerman 函数。
178+
- **空间复杂度**:$O(m \times n)$。
179+

‎Solutions/0947. 移除最多的同行或同列石头.md‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@
55

66
## 题目大意
77

8-
**描述**:二维平面中有 `n` 块石头,每块石头都在整数坐标点上,且每个坐标点上最多只能有一块石头。如果一块石头的同行或者同列上有其他石头存在,那么就可以移除这块石头。
8+
**描述**:二维平面中有 $n$ 块石头,每块石头都在整数坐标点上,且每个坐标点上最多只能有一块石头。如果一块石头的同行或者同列上有其他石头存在,那么就可以移除这块石头。
99

10-
给你一个长度为 `n` 的数组 `stones` ,其中 `stones[i] = [xi, yi]` 表示第 `i` 块石头的位置。
10+
给你一个长度为 $n$ 的数组 $stones$ ,其中 $stones[i] = [xi, yi]$ 表示第 $i$ 块石头的位置。
1111

1212
**要求**:返回可以移除的石子的最大数量。
1313

@@ -51,9 +51,9 @@
5151

5252
题目「求最多可以移走的石头数目」也可以换一种思路:「求最少留下的石头数目」。
5353

54-
- 如果两个石头 `A`、`B` 处于同一行或者同一列,我们就可以删除石头 `A` 或 `B`,最少留下 `1` 个石头。
55-
- 如果三个石头 `A`、`B`、`C`,其中 `A`、`B` 处于同一行,`B`、`C` 处于同一列,则我们可以先删除石头 `A`,再删除石头 `C`,最少留下 `1` 个石头。
56-
- 如果有 `n` 个石头,其中每个石头都有一个同行或者同列的石头,则我们可以将 `n - 1` 个石头都删除,最少留下 `1` 个石头。
54+
- 如果两个石头 $A$、$B$ 处于同一行或者同一列,我们就可以删除石头 $A$ 或 $B$,最少留下 1ドル$ 个石头。
55+
- 如果三个石头 $A$、$B$、$C$,其中 $A$、$B$ 处于同一行,$B$、$C$ 处于同一列,则我们可以先删除石头 $A$,再删除石头 $C$,最少留下 1ドル$ 个石头。
56+
- 如果有 $n$ 个石头,其中每个石头都有一个同行或者同列的石头,则我们可以将 $n - 1$ 个石头都删除,最少留下 1ドル$ 个石头。
5757

5858
通过上面的分析,我们可以利用并查集,将同行、同列的石头都加入到一个集合中。这样「最少可以留下的石头」就是并查集中集合的个数。
5959

@@ -116,5 +116,5 @@ class Solution:
116116

117117
### 思路 1:复杂度分析
118118

119-
- **时间复杂度**:$O(n \times \alpha(n))$。其中 $n$ 是石子个数。$\alpha$ 是反 `Ackerman` 函数。
119+
- **时间复杂度**:$O(n \times \alpha(n))$。其中 $n$ 是石子个数。$\alpha$ 是反 Ackerman 函数。
120120
- **空间复杂度**:$O(n)$。

‎Solutions/1631. 最小体力消耗路径.md‎

Lines changed: 43 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -5,27 +5,58 @@
55

66
## 题目大意
77

8-
给定一个 `rows * cols` 大小的二维数组 `heights`,其中 `heights[i][j]` 表示为位置 `(i, j)` 的高度。
8+
**描述**:给定一个 $rows \times cols$ 大小的二维数组 $heights$,其中 $heights[i][j]$ 表示为位置 $(i, j)$ 的高度。
99

10-
现在要从左上角 `(0, 0)` 位置出发,经过方格的一些点,到达右下角 `(n - 1, n - 1)` 位置上。其中所经过路径的花费为「这条路径上所有相邻位置的最大高度差绝对值」。
10+
现在要从左上角 $(0, 0)$ 位置出发,经过方格的一些点,到达右下角 $(n - 1, n - 1)$ 位置上。其中所经过路径的花费为「这条路径上所有相邻位置的最大高度差绝对值」。
1111

12-
现在要求:计算从 `(0, 0)` 位置到 `(n - 1, n - 1)` 的最优路径的花费。
12+
**要求**:计算从 $(0, 0)$ 位置到 $(n - 1, n - 1)$ 的最优路径的花费。
1313

14-
最优路径指的路径上「所有相邻位置最大高度差绝对值」最小的那条路径。
14+
**说明**:
15+
16+
- **最优路径**:路径上「所有相邻位置最大高度差绝对值」最小的那条路径。
17+
- $rows == heights.length$。
18+
- $columns == heights[i].length$。
19+
- 1ドル \le rows, columns \le 100$。
20+
- 1ドル \le heights[i][j] \le 10^6$。
21+
22+
**示例**:
23+
24+
- 示例 1:
25+
26+
![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/25/ex1.png)
27+
28+
```python
29+
输入:heights = [[1,2,2],[3,8,2],[5,3,5]]
30+
输出:2
31+
解释:路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。
32+
这条路径比路径 [1,2,2,2,5] 更优,因为另一条路径差值最大值为 3。
33+
```
34+
35+
- 示例 2:
36+
37+
![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/25/ex2.png)
38+
39+
```python
40+
输入:heights = [[1,2,3],[3,8,4],[5,3,5]]
41+
输出:1
42+
解释:路径 [1,2,3,4,5] 的相邻格子差值绝对值最大为 1 ,比路径 [1,3,5,3,5] 更优。
43+
```
1544

1645
## 解题思路
1746

47+
### 思路 1:并查集
48+
1849
将整个网络抽象为一个无向图,每个点与相邻的点(上下左右)之间都存在一条无向边,边的权重为两个点之间的高度差绝对值。
1950

20-
我们要找到左上角到右下角的最优路径,可以遍历所有的点,将所有的边存储到数组中,每条边的存储格式为 `[x, y, h]`,意思是编号 `x` 的点和编号为 `y` 的点之间的权重为 `h`。
51+
我们要找到左上角到右下角的最优路径,可以遍历所有的点,将所有的边存储到数组中,每条边的存储格式为 $[x, y, h]$,意思是编号 $x$ 的点和编号为 $y$ 的点之间的权重为 $h$。
2152

2253
然后按照权重从小到大的顺序,对所有边进行排序。
2354

24-
再按照权重大小遍历所有边,将其依次加入并查集中。并且每次都需要判断 `(0, 0)` 点和 `(n - 1, n - 1)` 点是否连通。
55+
再按照权重大小遍历所有边,将其依次加入并查集中。并且每次都需要判断 $(0, 0)$ 点和 $(n - 1, n - 1)$ 点是否连通。
2556

2657
如果连通,则该边的权重即为答案。
2758

28-
##代码
59+
### 思路 1:代码
2960

3061
```python
3162
class UnionFind:
@@ -83,3 +114,8 @@ class Solution:
83114
return 0
84115
```
85116

117+
### 思路 1:复杂度分析
118+
119+
- **时间复杂度**:$O(m \times n \times \alpha(m \times n)),ドル其中 $\alpha$ 是反 Ackerman 函数。
120+
- **空间复杂度**:$O(m \times n)$。
121+

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /