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 26b5388

Browse files
authored
Merge branch 'youngyangyang04:master' into master
2 parents 5b4249d + f83bbd4 commit 26b5388

File tree

56 files changed

+2156
-685
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

56 files changed

+2156
-685
lines changed

‎README.md‎

Lines changed: 18 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -387,10 +387,26 @@
387387
4. [单调栈:42.接雨水](./problems/0042.接雨水.md)
388388
5. [单调栈:84.柱状图中最大的矩形](./problems/0084.柱状图中最大的矩形.md)
389389

390-
(持续更新中....)
391390

392391
## 图论
393392

393+
通知:开始更新图论内容,图论部分还没有其他语言版本,欢迎录友们提交PR,成为contributor
394+
395+
### 深搜广搜
396+
397+
* [图论:深度优先搜索理论基础](./problems/图论深搜理论基础.md)
398+
* [图论:797.所有可能的路径](./problems/0797.所有可能的路径.md)
399+
* [图论:广度优先搜索理论基础](./problems/图论广索理论基础.md)
400+
* [图论:200.岛屿数量.深搜版](./problems/0200.岛屿数量.深搜版.md)
401+
* [图论:200.岛屿数量.广搜版](./problems/0200.岛屿数量.广搜版.md)
402+
* [图论:695.岛屿的最大面积](./problems/0695.岛屿的最大面积.md)
403+
* [图论:1020.飞地的数量](./problems/1020.飞地的数量.md)
404+
* [图论:130.被围绕的区域](./problems/0130.被围绕的区域.md)
405+
* [图论:417.太平洋大西洋水流问题](./problems/0417.太平洋大西洋水流问题.md)
406+
407+
(持续更新中....)
408+
409+
394410
## 十大排序
395411

396412
## 数论
@@ -492,7 +508,7 @@
492508

493509
大家好,我是程序员Carl,哈工大师兄,《代码随想录》作者,先后在腾讯和百度从事后端技术研发,CSDN博客专家。对算法和C++后端技术有一定的见解,利用工作之余重新刷leetcode。
494510

495-
加入「代码随想录」刷题小分队(微信群),可以扫下方二维码加我微信。
511+
加入「代码随想录」刷题小分队(微信群),可以扫下方二维码,加代码随想录客服微信。
496512

497513
如果是已工作,备注:姓名-城市-岗位-组队刷题。如果学生,备注:姓名-学校-年级-组队刷题。**备注没有自我介绍不通过哦**
498514

‎problems/0019.删除链表的倒数第N个节点.md‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -412,6 +412,28 @@ struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
412412

413413
```
414414
415+
C#:
416+
```csharp
417+
public class Solution {
418+
public ListNode RemoveNthFromEnd(ListNode head, int n) {
419+
ListNode dummpHead = new ListNode(0);
420+
dummpHead.next = head;
421+
var fastNode = dummpHead;
422+
var slowNode = dummpHead;
423+
while(n-- != 0 && fastNode != null)
424+
{
425+
fastNode = fastNode.next;
426+
}
427+
while(fastNode.next != null)
428+
{
429+
fastNode = fastNode.next;
430+
slowNode = slowNode.next;
431+
}
432+
slowNode.next = slowNode.next.next;
433+
return dummpHead.next;
434+
}
435+
}
436+
```
415437
<p align="center">
416438
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
417439
<img src="../pics/网站星球宣传海报.jpg" width="1000"/>

‎problems/0045.跳跃游戏II.md‎

Lines changed: 58 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -205,66 +205,81 @@ class Solution {
205205
```
206206

207207
### Python
208-
208+
贪心(版本一)
209209
```python
210210
class Solution:
211-
def jump(self, nums: List[int]) -> int:
212-
if len(nums) == 1: return 0
213-
ans = 0
214-
curDistance = 0
215-
nextDistance = 0
211+
def jump(self, nums):
212+
if len(nums) == 1:
213+
return 0
214+
215+
cur_distance = 0 # 当前覆盖最远距离下标
216+
ans = 0 # 记录走的最大步数
217+
next_distance = 0 # 下一步覆盖最远距离下标
218+
216219
for i in range(len(nums)):
217-
nextDistance = max(i + nums[i], nextDistance)
218-
if i == curDistance:
219-
if curDistance != len(nums) - 1:
220-
ans += 1
221-
curDistance = nextDistance
222-
if nextDistance >= len(nums) - 1: break
220+
next_distance = max(nums[i] + i, next_distance) # 更新下一步覆盖最远距离下标
221+
if i == cur_distance: # 遇到当前覆盖最远距离下标
222+
ans += 1 # 需要走下一步
223+
cur_distance = next_distance # 更新当前覆盖最远距离下标(相当于加油了)
224+
if next_distance >= len(nums) - 1: # 当前覆盖最远距离达到数组末尾,不用再做ans++操作,直接结束
225+
break
226+
223227
return ans
228+
224229
```
230+
贪心(版本二)
225231

226232
```python
227-
# 贪心版本二
228233
class Solution:
229-
def jump(self, nums: List[int]) -> int:
230-
if len(nums) == 1:
231-
return 0
232-
curDistance, nextDistance = 0, 0
233-
step = 0
234-
for i in range(len(nums)-1):
235-
nextDistance = max(nextDistance, nums[i]+i)
236-
if i == curDistance:
237-
curDistance = nextDistance
238-
step += 1
239-
return step
234+
def jump(self, nums):
235+
cur_distance = 0 # 当前覆盖的最远距离下标
236+
ans = 0 # 记录走的最大步数
237+
next_distance = 0 # 下一步覆盖的最远距离下标
238+
239+
for i in range(len(nums) - 1): # 注意这里是小于len(nums) - 1,这是关键所在
240+
next_distance = max(nums[i] + i, next_distance) # 更新下一步覆盖的最远距离下标
241+
if i == cur_distance: # 遇到当前覆盖的最远距离下标
242+
cur_distance = next_distance # 更新当前覆盖的最远距离下标
243+
ans += 1
244+
245+
return ans
246+
240247
```
248+
贪心(版本三) 类似‘55-跳跃游戏’写法
249+
241250
```python
242-
# 贪心版本三 - 类似‘55-跳跃游戏’写法
243251
class Solution:
244252
def jump(self, nums) -> int:
245-
if len(nums)==1: return 0
246-
i = 0
247-
count = 0
248-
cover = 0
249-
while i<=cover:
250-
for i in range(i,cover+1):
251-
cover = max(nums[i]+i,cover)
252-
if cover>=len(nums)-1: return count+1
253-
count+=1
253+
if len(nums)==1: # 如果数组只有一个元素,不需要跳跃,步数为0
254+
return 0
254255

255-
```
256+
i = 0 # 当前位置
257+
count = 0 # 步数计数器
258+
cover = 0 # 当前能够覆盖的最远距离
259+
260+
while i <= cover: # 当前位置小于等于当前能够覆盖的最远距离时循环
261+
for i in range(i, cover+1): # 遍历从当前位置到当前能够覆盖的最远距离之间的所有位置
262+
cover = max(nums[i]+i, cover) # 更新当前能够覆盖的最远距离
263+
if cover >= len(nums)-1: # 如果当前能够覆盖的最远距离达到或超过数组的最后一个位置,直接返回步数+1
264+
return count+1
265+
count += 1 # 每一轮遍历结束后,步数+1
256266

267+
268+
```
269+
动态规划
257270
```python
258-
# 动态规划做法
259271
class Solution:
260272
def jump(self, nums: List[int]) -> int:
261-
result = [10**4+1]*len(nums)
262-
result[0]=0
263-
for i in range(len(nums)):
264-
for j in range(nums[i]+1):
265-
if i+j<len(nums): result[i+j]=min(result[i+j],result[i]+1)
266-
#print(result) #打印数组
267-
return result[-1]
273+
result = [10**4+1] * len(nums) # 初始化结果数组,初始值为一个较大的数
274+
result[0] = 0 # 起始位置的步数为0
275+
276+
for i in range(len(nums)): # 遍历数组
277+
for j in range(nums[i] + 1): # 在当前位置能够跳跃的范围内遍历
278+
if i + j < len(nums): # 确保下一跳的位置不超过数组范围
279+
result[i + j] = min(result[i + j], result[i] + 1) # 更新到达下一跳位置的最小步数
280+
281+
return result[-1] # 返回到达最后一个位置的最小步数
282+
268283

269284
```
270285

‎problems/0053.最大子序和.md‎

Lines changed: 19 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -198,21 +198,35 @@ class Solution {
198198
```
199199

200200
### Python
201+
暴力法
202+
```python
203+
class Solution:
204+
def maxSubArray(self, nums):
205+
result = float('-inf') # 初始化结果为负无穷大
206+
count = 0
207+
for i in range(len(nums)): # 设置起始位置
208+
count = 0
209+
for j in range(i, len(nums)): # 从起始位置i开始遍历寻找最大值
210+
count += nums[j]
211+
result = max(count, result) # 更新最大值
212+
return result
201213

214+
```
202215
```python
203216
class Solution:
204-
def maxSubArray(self, nums: List[int]) -> int:
205-
result = -float('inf')
217+
def maxSubArray(self, nums):
218+
result = float('-inf')# 初始化结果为负无穷大
206219
count = 0
207220
for i in range(len(nums)):
208221
count += nums[i]
209-
if count > result:
222+
if count > result:# 取区间累计的最大值(相当于不断确定最大子序终止位置)
210223
result = count
211-
if count <= 0:
224+
if count <= 0:# 相当于重置最大子序起始位置,因为遇到负数一定是拉低总和
212225
count = 0
213226
return result
214-
```
215227

228+
229+
```
216230
### Go
217231

218232
```go

‎problems/0053.最大子序和(动态规划).md‎

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,14 @@
1111
给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
1212

1313
示例:
14-
输入: [-2,1,-3,4,-1,2,1,-5,4]
15-
输出: 6
16-
解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。
14+
* 输入: [-2,1,-3,4,-1,2,1,-5,4]
15+
* 输出: 6
16+
* 解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。
17+
18+
## 算法公开课
19+
20+
**《代码随想录》算法视频公开课:[看起来复杂,其实是简单动态规划 | LeetCode:53.最大子序和](https://www.bilibili.com/video/BV19V4y1F7b5),相信结合视频再看本篇题解,更有助于大家对本题的理解**。
21+
1722

1823
## 思路
1924

‎problems/0056.合并区间.md‎

Lines changed: 14 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -140,18 +140,24 @@ class Solution {
140140
### Python
141141
```python
142142
class Solution:
143-
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
144-
if len(intervals) == 0: return intervals
145-
intervals.sort(key=lambda x: x[0])
143+
def merge(self, intervals):
146144
result = []
147-
result.append(intervals[0])
145+
if len(intervals) == 0:
146+
return result # 区间集合为空直接返回
147+
148+
intervals.sort(key=lambda x: x[0]) # 按照区间的左边界进行排序
149+
150+
result.append(intervals[0]) # 第一个区间可以直接放入结果集中
151+
148152
for i in range(1, len(intervals)):
149-
last =result[-1]
150-
if last[1] >= intervals[i][0]:
151-
result[-1]= [last[0], max(last[1], intervals[i][1])]
153+
ifresult[-1][1] >= intervals[i][0]: # 发现重叠区间
154+
# 合并区间,只需要更新结果集最后一个区间的右边界,因为根据排序,左边界已经是最小的
155+
result[-1][1] =max(result[-1][1], intervals[i][1])
152156
else:
153-
result.append(intervals[i])
157+
result.append(intervals[i]) # 区间不重叠
158+
154159
return result
160+
155161
```
156162

157163
### Go

‎problems/0062.不同路径.md‎

Lines changed: 56 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -287,17 +287,70 @@ public:
287287
```
288288

289289
### Python
290+
递归
291+
```python
292+
class Solution:
293+
def uniquePaths(self, m: int, n: int) -> int:
294+
if m == 1 or n == 1:
295+
return 1
296+
return self.uniquePaths(m - 1, n) + self.uniquePaths(m, n - 1)
290297

298+
```
299+
动态规划(版本一)
291300
```python
292-
class Solution:# 动态规划
301+
class Solution:
293302
def uniquePaths(self, m: int, n: int) -> int:
294-
dp = [[1 for i in range(n)] for j in range(m)]
303+
# 创建一个二维列表用于存储唯一路径数
304+
dp = [[0] * n for _ in range(m)]
305+
306+
# 设置第一行和第一列的基本情况
307+
for i in range(m):
308+
dp[i][0] = 1
309+
for j in range(n):
310+
dp[0][j] = 1
311+
312+
# 计算每个单元格的唯一路径数
295313
for i in range(1, m):
296314
for j in range(1, n):
297-
dp[i][j] = dp[i][j - 1] + dp[i - 1][j]
315+
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
316+
317+
# 返回右下角单元格的唯一路径数
298318
return dp[m - 1][n - 1]
319+
320+
```
321+
动态规划(版本二)
322+
```python
323+
class Solution:
324+
def uniquePaths(self, m: int, n: int) -> int:
325+
# 创建一个一维列表用于存储每列的唯一路径数
326+
dp = [1] * n
327+
328+
# 计算每个单元格的唯一路径数
329+
for j in range(1, m):
330+
for i in range(1, n):
331+
dp[i] += dp[i - 1]
332+
333+
# 返回右下角单元格的唯一路径数
334+
return dp[n - 1]
299335
```
336+
数论
337+
```python
338+
class Solution:
339+
def uniquePaths(self, m: int, n: int) -> int:
340+
numerator = 1 # 分子
341+
denominator = m - 1 # 分母
342+
count = m - 1 # 计数器,表示剩余需要计算的乘积项个数
343+
t = m + n - 2 # 初始乘积项
344+
while count > 0:
345+
numerator *= t # 计算乘积项的分子部分
346+
t -= 1 # 递减乘积项
347+
while denominator != 0 and numerator % denominator == 0:
348+
numerator //= denominator # 约简分子
349+
denominator -= 1 # 递减分母
350+
count -= 1 # 计数器减1,继续下一项的计算
351+
return numerator # 返回最终的唯一路径数
300352

353+
```
301354
### Go
302355

303356
```Go

0 commit comments

Comments
(0)

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