algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-10 20:40:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1956 from Lzzzs/master

Browse Source 
贪心算法部分添加视频链接
This commit is contained in:
程序员Carl
2023-03-30 10:56:05 +08:00
committed by GitHub
parent d2bbea431e 33f6bc9a36
commit 13641eaa93
17 changed files with 437 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
problems/0045.跳跃游戏II.md
View File

@ -4,10 +4,9 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
> 相对于[贪心算法：跳跃游戏](https://mp.weixin.qq.com/s/606_N9j8ACKCODoCbV1lSA)难了不少，做好心里准备！
> 相对于[贪心算法：跳跃游戏](https://mp.weixin.qq.com/s/606_N9j8ACKCODoCbV1lSA)难了不少，做好心里准备！ # 45.跳跃游戏 II
# 45.跳跃游戏II
[力扣题目链接](https://leetcode.cn/problems/jump-game-ii/) [力扣题目链接](https://leetcode.cn/problems/jump-game-ii/)
@ -18,13 +17,17 @@
你的目标是使用最少的跳跃次数到达数组的最后一个位置。 你的目标是使用最少的跳跃次数到达数组的最后一个位置。
示例: 示例:
* 输入: [2,3,1,1,4]
* 输出: 2 - 输入: [2,3,1,1,4]
* 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。 - 输出: 2
- 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳  1  步，然后跳  3  步到达数组的最后一个位置。
说明: 说明:
假设你总是可以到达数组的最后一个位置。 假设你总是可以到达数组的最后一个位置。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，最少跳几步还得看覆盖范围 | LeetCode： 45.跳跃游戏 II](https://www.bilibili.com/video/BV1Y24y1r7XZ)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
@ -46,7 +49,6 @@
如图： 如图：
![45.跳跃游戏II](https://code-thinking-1253855093.file.myqcloud.com/pics/20201201232309103.png) ![45.跳跃游戏II](https://code-thinking-1253855093.file.myqcloud.com/pics/20201201232309103.png)
**图中覆盖范围的意义在于，只要红色的区域，最多两步一定可以到！（不用管具体怎么跳，反正一定可以跳到）** **图中覆盖范围的意义在于，只要红色的区域，最多两步一定可以到！（不用管具体怎么跳，反正一定可以跳到）**
@ -57,8 +59,8 @@
这里还是有个特殊情况需要考虑，当移动下标达到了当前覆盖的最远距离下标时 这里还是有个特殊情况需要考虑，当移动下标达到了当前覆盖的最远距离下标时
* 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。 - 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。
* 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。 - 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。
C++代码如下：（详细注释） C++代码如下：（详细注释）
@ -92,14 +94,14 @@ public:
**针对于方法一的特殊情况，可以统一处理**，即：移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不考虑是不是终点的情况。 **针对于方法一的特殊情况，可以统一处理**，即：移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不考虑是不是终点的情况。
想要达到这样的效果，只要让移动下标，最大只能移动到nums.size - 2的地方就可以了。 想要达到这样的效果，只要让移动下标，最大只能移动到 nums.size - 2 的地方就可以了。
因为当移动下标指向nums.size - 2时： 因为当移动下标指向 nums.size - 2 时：
* 如果移动下标等于当前覆盖最大距离下标， 需要再走一步（即ans++），因为最后一步一定是可以到的终点。（题目假设总是可以到达数组的最后一个位置），如图： - 如果移动下标等于当前覆盖最大距离下标， 需要再走一步（即 ans++），因为最后一步一定是可以到的终点。（题目假设总是可以到达数组的最后一个位置），如图：
![45.跳跃游戏II2](https://code-thinking-1253855093.file.myqcloud.com/pics/20201201232445286.png) ![45.跳跃游戏II2](https://code-thinking-1253855093.file.myqcloud.com/pics/20201201232445286.png)
* 如果移动下标不等于当前覆盖最大距离下标，说明当前覆盖最远距离就可以直接达到终点了，不需要再走一步。如图： - 如果移动下标不等于当前覆盖最大距离下标，说明当前覆盖最远距离就可以直接达到终点了，不需要再走一步。如图：
![45.跳跃游戏II1](https://code-thinking-1253855093.file.myqcloud.com/pics/20201201232338693.png) ![45.跳跃游戏II1](https://code-thinking-1253855093.file.myqcloud.com/pics/20201201232338693.png)
@ -127,7 +129,7 @@ public:
可以看出版本二的代码相对于版本一简化了不少！ 可以看出版本二的代码相对于版本一简化了不少！
**其精髓在于控制移动下标i只移动到nums.size() - 2的位置**，所以移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不用考虑别的了。 **其精髓在于控制移动下标 i 只移动到 nums.size() - 2 的位置**，所以移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不用考虑别的了。
## 总结 ## 总结
@ -137,11 +139,10 @@ public:
理解本题的关键在于：**以最小的步数增加最大的覆盖范围，直到覆盖范围覆盖了终点**，这个范围内最小步数一定可以跳到，不用管具体是怎么跳的，不纠结于一步究竟跳一个单位还是两个单位。 理解本题的关键在于：**以最小的步数增加最大的覆盖范围，直到覆盖范围覆盖了终点**，这个范围内最小步数一定可以跳到，不用管具体是怎么跳的，不纠结于一步究竟跳一个单位还是两个单位。
## 其他语言版本 ## 其他语言版本
### Java ### Java
```Java ```Java
// 版本一 // 版本一
class Solution { class Solution {
@ -230,6 +231,7 @@ class Solution:
step += 1 step += 1
return step return step
``` ```
```python ```python
# 动态规划做法 # 动态规划做法
class Solution: class Solution:
@ -244,7 +246,6 @@ class Solution:
``` ```
### Go ### Go
```go ```go
@ -331,21 +332,21 @@ var jump = function(nums) {
```typescript ```typescript
function jump(nums: number[]): number { function jump(nums: number[]): number {
const length: number = nums.length; const length: number = nums.length;
let curFarthestIndex: number = 0, let curFarthestIndex: number = 0,
nextFarthestIndex: number = 0; nextFarthestIndex: number = 0;
let curIndex: number = 0; let curIndex: number = 0;
let stepNum: number = 0; let stepNum: number = 0;
while (curIndex < length - 1) { while (curIndex < length - 1) {
nextFarthestIndex = Math.max(nextFarthestIndex, curIndex + nums[curIndex]); nextFarthestIndex = Math.max(nextFarthestIndex, curIndex + nums[curIndex]);
if (curIndex === curFarthestIndex) { if (curIndex === curFarthestIndex) {
curFarthestIndex = nextFarthestIndex; curFarthestIndex = nextFarthestIndex;
stepNum++; stepNum++;
}
curIndex++;
} }
return stepNum; curIndex++;
}; }
return stepNum;
}
``` ```
### Scala ### Scala
@ -427,7 +428,6 @@ impl Solution {
} }
``` ```
<p align="center"> <p align="center">
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

106
problems/0053.最大子序和.md
View File

@ -4,7 +4,6 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
# 53. 最大子序和 # 53. 最大子序和
[力扣题目链接](https://leetcode.cn/problems/maximum-subarray/) [力扣题目链接](https://leetcode.cn/problems/maximum-subarray/)
@ -12,17 +11,21 @@
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例: 示例:
* 输入: [-2,1,-3,4,-1,2,1,-5,4]
* 输出: 6
* 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
- 输入: [-2,1,-3,4,-1,2,1,-5,4]
- 输出: 6
- 解释:  连续子数组  [4,-1,2,1] 的和最大，为  6。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法的巧妙需要慢慢体会！LeetCode：53. 最大子序和](https://www.bilibili.com/video/BV1aY4y1Z7ya)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 暴力解法 ## 暴力解法
暴力解法的思路，第一层for 就是设置起始位置，第二层for循环遍历数组寻找最大值 暴力解法的思路，第一层 for 就是设置起始位置，第二层 for 循环遍历数组寻找最大值
* 时间复杂度：O(n^2) - 时间复杂度：O(n^2)
* 空间复杂度：O(1) - 空间复杂度：O(1)
```CPP ```CPP
class Solution { class Solution {
@ -42,13 +45,13 @@ public:
}; };
``` ```
以上暴力的解法C++勉强可以过，其他语言就不确定了。 以上暴力的解法 C++勉强可以过，其他语言就不确定了。
## 贪心解法 ## 贪心解法
**贪心贪的是哪里呢？** **贪心贪的是哪里呢？**
如果 -2 1 在一起，计算起点的时候，一定是从1开始计算，因为负数只会拉低总和，这就是贪心贪的地方！ 如果 -2 1 在一起，计算起点的时候，一定是从 1 开始计算，因为负数只会拉低总和，这就是贪心贪的地方！
局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。 局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。
@ -56,29 +59,27 @@ public:
**局部最优的情况下，并记录最大的“连续和”，可以推出全局最优**。 **局部最优的情况下，并记录最大的“连续和”，可以推出全局最优**。
从代码角度上来讲：遍历 nums，从头开始用 count 累积，如果 count 一旦加上 nums[i]变为负数，那么就应该从 nums[i+1]开始从 0 累积 count 了，因为已经变为负数的 count，只会拖累总和。
从代码角度上来讲：遍历nums，从头开始用count累积，如果count一旦加上nums[i]变为负数，那么就应该从nums[i+1]开始从0累积count了，因为已经变为负数的count，只会拖累总和。
**这相当于是暴力解法中的不断调整最大子序和区间的起始位置**。 **这相当于是暴力解法中的不断调整最大子序和区间的起始位置**。
**那有同学问了，区间终止位置不用调整么？ 如何才能得到最大“连续和”呢？** **那有同学问了，区间终止位置不用调整么？ 如何才能得到最大“连续和”呢？**
区间的终止位置，其实就是如果count取到最大值了，及时记录下来了。例如如下代码： 区间的终止位置，其实就是如果 count 取到最大值了，及时记录下来了。例如如下代码：
``` ```
if (count > result) result = count; if (count > result) result = count;
``` ```
**这样相当于是用result记录最大子序和区间和（变相的算是调整了终止位置）**。 **这样相当于是用 result 记录最大子序和区间和（变相的算是调整了终止位置）**。
如动画所示： 如动画所示：
![53.最大子序和](https://code-thinking.cdn.bcebos.com/gifs/53.%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%92%8C.gif) ![53.最大子序和](https://code-thinking.cdn.bcebos.com/gifs/53.%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%92%8C.gif)
红色的起始位置就是贪心每次取count为正数的时候，开始一个区间的统计。 红色的起始位置就是贪心每次取 count 为正数的时候，开始一个区间的统计。
那么不难写出如下C++代码（关键地方已经注释） 那么不难写出如下 C++代码（关键地方已经注释）
```CPP ```CPP
class Solution { class Solution {
@ -98,18 +99,16 @@ public:
}; };
``` ```
* 时间复杂度：O(n) - 时间复杂度：O(n)
* 空间复杂度：O(1) - 空间复杂度：O(1)
当然题目没有说如果数组为空，应该返回什么，所以数组为空的话返回啥都可以了。 当然题目没有说如果数组为空，应该返回什么，所以数组为空的话返回啥都可以了。
## 常见误区 ## 常见误区
误区一： 误区一：
不少同学认为 如果输入用例都是-1，或者 都是负数，这个贪心算法跑出来的结果是0， 这是**又一次证明脑洞模拟不靠谱的经典案例**，建议大家把代码运行一下试一试，就知道了，也会理解 为什么 result 要初始化为最小负数了。 不少同学认为 如果输入用例都是-1，或者 都是负数，这个贪心算法跑出来的结果是 0， 这是**又一次证明脑洞模拟不靠谱的经典案例**，建议大家把代码运行一下试一试，就知道了，也会理解 为什么 result 要初始化为最小负数了。
误区二： 误区二：
@ -117,19 +116,17 @@ public:
在动画演示用，大家可以发现， 4，遇到 -1 的时候，我们依然累加了，为什么呢？ 在动画演示用，大家可以发现， 4，遇到 -1 的时候，我们依然累加了，为什么呢？
因为和为3，只要连续和还是正数就会 对后面的元素 起到增大总和的作用。 所以只要连续和为正数我们就保留。 因为和为 3，只要连续和还是正数就会 对后面的元素 起到增大总和的作用。 所以只要连续和为正数我们就保留。
这里也会有录友疑惑，那 4 + -1 之后 不就变小了吗？ 会不会错过 4 成为最大连续和的可能性？
其实并不会，因为还有一个变量result 一直在更新 最大的连续和，只要有更大的连续和出现，result就更新了，那么result已经把4更新了，后面 连续和变成3，也不会对最后结果有影响。
这里也会有录友疑惑，那 4 + -1 之后 不就变小了吗？ 会不会错过 4 成为最大连续和的可能性？
其实并不会，因为还有一个变量 result 一直在更新 最大的连续和，只要有更大的连续和出现，result 就更新了，那么 result 已经把 4 更新了，后面 连续和变成 3，也不会对最后结果有影响。
## 动态规划 ## 动态规划
当然本题还可以用动态规划来做，当前[「代码随想录」](https://img-blog.csdnimg.cn/20201124161234338.png)主要讲解贪心系列，后续到动态规划系列的时候会详细讲解本题的dp方法。 当然本题还可以用动态规划来做，当前[「代码随想录」](https://img-blog.csdnimg.cn/20201124161234338.png)主要讲解贪心系列，后续到动态规划系列的时候会详细讲解本题的 dp 方法。
那么先给出我的dp代码如下，有时间的录友可以提前做一做： 那么先给出我的 dp 代码如下，有时间的录友可以提前做一做：
```CPP ```CPP
class Solution { class Solution {
@ -148,8 +145,8 @@ public:
}; };
``` ```
* 时间复杂度：O(n) - 时间复杂度：O(n)
* 空间复杂度：O(n) - 空间复杂度：O(n)
## 总结 ## 总结
@ -159,8 +156,8 @@ public:
## 其他语言版本 ## 其他语言版本
### Java ### Java
```java ```java
class Solution { class Solution {
public int maxSubArray(int[] nums) { public int maxSubArray(int[] nums) {
@ -201,6 +198,7 @@ class Solution {
``` ```
### Python ### Python
```python ```python
class Solution: class Solution:
def maxSubArray(self, nums: List[int]) -> int: def maxSubArray(self, nums: List[int]) -> int:
@ -233,6 +231,7 @@ func maxSubArray(nums []int) int {
``` ```
### Rust ### Rust
```rust ```rust
pub fn max_sub_array(nums: Vec<i32>) -> i32 { pub fn max_sub_array(nums: Vec<i32>) -> i32 {
let mut max_sum = i32::MIN; let mut max_sum = i32::MIN;
@ -247,6 +246,7 @@ pub fn max_sub_array(nums: Vec<i32>) -> i32 {
``` ```
### Javascript: ### Javascript:
```Javascript ```Javascript
var maxSubArray = function(nums) { var maxSubArray = function(nums) {
let result = -Infinity let result = -Infinity
@ -264,9 +264,10 @@ var maxSubArray = function(nums) {
}; };
``` ```
### C: ### C:
贪心： 贪心：
```c ```c
int maxSubArray(int* nums, int numsSize){ int maxSubArray(int* nums, int numsSize){
int maxVal = INT_MIN; int maxVal = INT_MIN;
@ -286,6 +287,7 @@ int maxSubArray(int* nums, int numsSize){
``` ```
动态规划： 动态规划：
```c ```c
/** /**
* 解题思路：动态规划： * 解题思路：动态规划：
@ -324,15 +326,15 @@ int maxSubArray(int* nums, int numsSize){
```typescript ```typescript
function maxSubArray(nums: number[]): number { function maxSubArray(nums: number[]): number {
let curSum: number = 0; let curSum: number = 0;
let resMax: number = -Infinity; let resMax: number = -Infinity;
for (let i = 0, length = nums.length; i < length; i++) { for (let i = 0, length = nums.length; i < length; i++) {
curSum += nums[i]; curSum += nums[i];
resMax = Math.max(curSum, resMax); resMax = Math.max(curSum, resMax);
if (curSum < 0) curSum = 0; if (curSum < 0) curSum = 0;
} }
return resMax; return resMax;
}; }
``` ```
**动态规划** **动态规划**
@ -340,17 +342,17 @@ function maxSubArray(nums: number[]): number {
```typescript ```typescript
// 动态规划 // 动态规划
function maxSubArray(nums: number[]): number { function maxSubArray(nums: number[]): number {
const length = nums.length; const length = nums.length;
if (length === 0) return 0; if (length === 0) return 0;
const dp: number[] = []; const dp: number[] = [];
dp[0] = nums[0]; dp[0] = nums[0];
let resMax: number = nums[0]; let resMax: number = nums[0];
for (let i = 1; i < length; i++) { for (let i = 1; i < length; i++) {
dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]); dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
resMax = Math.max(resMax, dp[i]); resMax = Math.max(resMax, dp[i]);
} }
return resMax; return resMax;
}; }
``` ```
### Scala ### Scala

59
problems/0055.跳跃游戏.md
View File

@ -4,7 +4,6 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
# 55. 跳跃游戏 # 55. 跳跃游戏
[力扣题目链接](https://leetcode.cn/problems/jump-game/) [力扣题目链接](https://leetcode.cn/problems/jump-game/)
@ -15,20 +14,25 @@
判断你是否能够到达最后一个位置。 判断你是否能够到达最后一个位置。
示例 1: 示例  1:
* 输入: [2,3,1,1,4]
* 输出: true
* 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2: - 输入: [2,3,1,1,4]
* 输入: [3,2,1,0,4] - 输出: true
* 输出: false - 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
* 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
示例  2:
- 输入: [3,2,1,0,4]
- 输出: false
- 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，怎么跳跃不重要，关键在覆盖范围 | LeetCode：55.跳跃游戏](https://www.bilibili.com/video/BV1VG4y1X7kB)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
刚看到本题一开始可能想：当前位置元素如果是3，我究竟是跳一步呢，还是两步呢，还是三步呢，究竟跳几步才是最优呢？ 刚看到本题一开始可能想：当前位置元素如果是 3，我究竟是跳一步呢，还是两步呢，还是三步呢，究竟跳几步才是最优呢？
其实跳几步无所谓，关键在于可跳的覆盖范围！ 其实跳几步无所谓，关键在于可跳的覆盖范围！
@ -46,14 +50,13 @@
如图： 如图：
![55.跳跃游戏](https://code-thinking-1253855093.file.myqcloud.com/pics/20201124154758229-20230310135019977.png) ![55.跳跃游戏](https://code-thinking-1253855093.file.myqcloud.com/pics/20201124154758229-20230310135019977.png)
i每次移动只能在cover的范围内移动，每移动一个元素，cover得到该元素数值（新的覆盖范围）的补充，让i继续移动下去。 i 每次移动只能在 cover 的范围内移动，每移动一个元素，cover 得到该元素数值（新的覆盖范围）的补充，让 i 继续移动下去。
而cover每次只取 max(该元素数值补充后的范围, cover本身范围)。 而 cover 每次只取 max(该元素数值补充后的范围, cover 本身范围)。
如果cover大于等于了终点下标，直接return true就可以了。 如果 cover 大于等于了终点下标，直接 return true 就可以了。
C++代码如下： C++代码如下：
@ -71,6 +74,7 @@ public:
} }
}; };
``` ```
## 总结 ## 总结
这道题目关键点在于：不用拘泥于每次究竟跳几步，而是看覆盖范围，覆盖范围内一定是可以跳过来的，不用管是怎么跳的。 这道题目关键点在于：不用拘泥于每次究竟跳几步，而是看覆盖范围，覆盖范围内一定是可以跳过来的，不用管是怎么跳的。
@ -83,8 +87,8 @@ public:
## 其他语言版本 ## 其他语言版本
### Java ### Java
```Java ```Java
class Solution { class Solution {
public boolean canJump(int[] nums) { public boolean canJump(int[] nums) {
@ -106,6 +110,7 @@ class Solution {
``` ```
### Python ### Python
```python ```python
class Solution: class Solution:
def canJump(self, nums: List[int]) -> bool: def canJump(self, nums: List[int]) -> bool:
@ -156,8 +161,6 @@ func max(a, b int ) int {
} }
``` ```
### Javascript ### Javascript
```Javascript ```Javascript
@ -196,6 +199,7 @@ impl Solution {
``` ```
### C ### C
```c ```c
#define max(a, b) (((a) > (b)) ? (a) : (b)) #define max(a, b) (((a) > (b)) ? (a) : (b))
@ -217,23 +221,23 @@ bool canJump(int* nums, int numsSize){
} }
``` ```
### TypeScript ### TypeScript
```typescript ```typescript
function canJump(nums: number[]): boolean { function canJump(nums: number[]): boolean {
let farthestIndex: number = 0; let farthestIndex: number = 0;
let cur: number = 0; let cur: number = 0;
while (cur <= farthestIndex) { while (cur <= farthestIndex) {
farthestIndex = Math.max(farthestIndex, cur + nums[cur]); farthestIndex = Math.max(farthestIndex, cur + nums[cur]);
if (farthestIndex >= nums.length - 1) return true; if (farthestIndex >= nums.length - 1) return true;
cur++; cur++;
} }
return false; return false;
}; }
``` ```
### Scala ### Scala
```scala ```scala
object Solution { object Solution {
def canJump(nums: Array[Int]): Boolean = { def canJump(nums: Array[Int]): Boolean = {
@ -250,7 +254,6 @@ object Solution {
} }
``` ```
<p align="center"> <p align="center">
<a href="https://programmercarl.com/other/kstar.html" target="_blank"> <a href="https://programmercarl.com/other/kstar.html" target="_blank">
<img src="../pics/网站星球宣传海报.jpg" width="1000"/> <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

3
problems/0056.合并区间.md
View File

@ -22,6 +22,9 @@
* 解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。 * 解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
* 注意：输入类型已于2019年4月15日更改。 请重置默认代码定义以获取新方法签名。 * 注意：输入类型已于2019年4月15日更改。 请重置默认代码定义以获取新方法签名。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，合并区间有细节！LeetCode：56.合并区间](https://www.bilibili.com/video/BV1wx4y157nD)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路

121
problems/0122.买卖股票的最佳时机II.md
View File

@ -4,43 +4,49 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
# 122.买卖股票的最佳时机 II
# 122.买卖股票的最佳时机II
[力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/) [力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/)
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 给定一个数组，它的第  i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1: 示例 1:
* 输入: [7,1,5,3,6,4]
* 输出: 7 - 输入: [7,1,5,3,6,4]
* 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 - 输出: 7
- 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2: 示例 2:
* 输入: [1,2,3,4,5]
* 输出: 4
* 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3: - 输入: [1,2,3,4,5]
* 输入: [7,6,4,3,1] - 输出: 4
* 输出: 0 - 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
* 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
示例  3:
- 输入: [7,6,4,3,1]
- 输出: 0
- 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
提示： 提示：
* 1 <= prices.length <= 3 * 10 ^ 4
* 0 <= prices[i] <= 10 ^ 4 - 1 <= prices.length <= 3 \* 10 ^ 4
- 0 <= prices[i] <= 10 ^ 4
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法也能解决股票问题！LeetCode：122.买卖股票最佳时机 II](https://www.bilibili.com/video/BV1ev4y1C7na)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
本题首先要清楚两点： 本题首先要清楚两点：
* 只有一只股票！ - 只有一只股票！
* 当前只有买股票或者卖股票的操作 - 当前只有买股票或者卖股票的操作
想获得利润至少要两天为一个交易单元。 想获得利润至少要两天为一个交易单元。
@ -52,17 +58,16 @@
如何分解呢？ 如何分解呢？
假如第0天买入，第3天卖出，那么利润为：prices[3] - prices[0]。 假如第 0 天买入，第 3 天卖出，那么利润为：prices[3] - prices[0]。
相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。 相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。
**此时就是把利润分解为每天为单位的维度，而不是从0天到第3天整体去考虑！** **此时就是把利润分解为每天为单位的维度，而不是从 0 天到第 3 天整体去考虑！**
那么根据prices可以得到每天的利润序列：(prices[i] - prices[i - 1]).....(prices[1] - prices[0])。 那么根据 prices 可以得到每天的利润序列：(prices[i] - prices[i - 1]).....(prices[1] - prices[0])。
如图： 如图：
![122.买卖股票的最佳时机II](https://code-thinking-1253855093.file.myqcloud.com/pics/2020112917480858-20230310134659477.png) ![122.买卖股票的最佳时机II](https://code-thinking-1253855093.file.myqcloud.com/pics/2020112917480858-20230310134659477.png)
一些同学陷入：第一天怎么就没有利润呢，第一天到底算不算的困惑中。 一些同学陷入：第一天怎么就没有利润呢，第一天到底算不算的困惑中。
@ -77,7 +82,7 @@
局部最优可以推出全局最优，找不出反例，试一试贪心！ 局部最优可以推出全局最优，找不出反例，试一试贪心！
对应C++代码如下： 对应 C++代码如下：
```CPP ```CPP
class Solution { class Solution {
@ -92,12 +97,12 @@ public:
}; };
``` ```
* 时间复杂度：O(n) - 时间复杂度：O(n)
* 空间复杂度：O(1) - 空间复杂度：O(1)
### 动态规划 ### 动态规划
动态规划将在下一个系列详细讲解，本题解先给出我的C++代码（带详细注释），感兴趣的同学可以自己先学习一下。 动态规划将在下一个系列详细讲解，本题解先给出我的 C++代码（带详细注释），感兴趣的同学可以自己先学习一下。
```CPP ```CPP
class Solution { class Solution {
@ -119,8 +124,8 @@ public:
}; };
``` ```
* 时间复杂度：$O(n)$ - 时间复杂度：$O(n)$
* 空间复杂度：$O(n)$ - 空间复杂度：$O(n)$
## 总结 ## 总结
@ -137,6 +142,7 @@ public:
### Java: ### Java:
贪心: 贪心:
```java ```java
// 贪心思路 // 贪心思路
class Solution { class Solution {
@ -151,6 +157,7 @@ class Solution {
``` ```
动态规划: 动态规划:
```java ```java
class Solution { // 动态规划 class Solution { // 动态规划
public int maxProfit(int[] prices) { public int maxProfit(int[] prices) {
@ -173,7 +180,9 @@ class Solution { // 动态规划
``` ```
### Python: ### Python:
贪心: 贪心:
```python ```python
class Solution: class Solution:
def maxProfit(self, prices: List[int]) -> int: def maxProfit(self, prices: List[int]) -> int:
@ -184,6 +193,7 @@ class Solution:
``` ```
动态规划: 动态规划:
```python ```python
class Solution: class Solution:
def maxProfit(self, prices: List[int]) -> int: def maxProfit(self, prices: List[int]) -> int:
@ -200,6 +210,7 @@ class Solution:
### Go: ### Go:
贪心算法 贪心算法
```go ```go
func maxProfit(prices []int) int { func maxProfit(prices []int) int {
var sum int var sum int
@ -212,7 +223,9 @@ func maxProfit(prices []int) int {
return sum return sum
} }
``` ```
动态规划 动态规划
```go ```go
func maxProfit(prices []int) int { func maxProfit(prices []int) int {
dp := make([][]int, len(prices)) dp := make([][]int, len(prices))
@ -239,6 +252,7 @@ func max(a, b int) int {
### Javascript: ### Javascript:
贪心 贪心
```Javascript ```Javascript
var maxProfit = function(prices) { var maxProfit = function(prices) {
let result = 0 let result = 0
@ -250,26 +264,27 @@ var maxProfit = function(prices) {
``` ```
动态规划 动态规划
```javascript ```javascript
const maxProfit = (prices) => { const maxProfit = (prices) => {
let dp = Array.from(Array(prices.length), () => Array(2).fill(0)); let dp = Array.from(Array(prices.length), () => Array(2).fill(0));
// dp[i][0] 表示第i天持有股票所得现金。 // dp[i][0] 表示第i天持有股票所得现金。
// dp[i][1] 表示第i天不持有股票所得最多现金 // dp[i][1] 表示第i天不持有股票所得最多现金
dp[0][0] = 0 - prices[0]; dp[0][0] = 0 - prices[0];
dp[0][1] = 0; dp[0][1] = 0;
for(let i = 1; i < prices.length; i++) { for (let i = 1; i < prices.length; i++) {
// 如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来 // 如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来
// 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0] // 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
// 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i] // 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] - prices[i]); dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
// 在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来 // 在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
// 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1] // 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
// 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0] // 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0]
dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] + prices[i]); dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
} }
return dp[prices.length -1][1]; return dp[prices.length - 1][1];
}; };
``` ```
@ -278,12 +293,12 @@ const maxProfit = (prices) => {
贪心 贪心
```typescript ```typescript
function maxProfit(prices: number[]): number { function maxProfit(prices: number[]): number {
let resProfit: number = 0; let resProfit: number = 0;
for (let i = 1, length = prices.length; i < length; i++) { for (let i = 1, length = prices.length; i < length; i++) {
resProfit += Math.max(prices[i] - prices[i - 1], 0); resProfit += Math.max(prices[i] - prices[i - 1], 0);
} }
return resProfit; return resProfit;
}; }
``` ```
动态规划 动态规划
@ -304,6 +319,7 @@ function maxProfit(prices: number[]): number {
### Rust ### Rust
贪心： 贪心：
```Rust ```Rust
impl Solution { impl Solution {
fn max(a: i32, b: i32) -> i32 { fn max(a: i32, b: i32) -> i32 {
@ -320,6 +336,7 @@ impl Solution {
``` ```
动态规划： 动态规划：
```Rust ```Rust
impl Solution { impl Solution {
fn max(a: i32, b: i32) -> i32 { fn max(a: i32, b: i32) -> i32 {
@ -339,7 +356,9 @@ impl Solution {
``` ```
### C: ### C:
贪心： 贪心：
```c ```c
int maxProfit(int* prices, int pricesSize){ int maxProfit(int* prices, int pricesSize){
int result = 0; int result = 0;
@ -355,6 +374,7 @@ int maxProfit(int* prices, int pricesSize){
``` ```
动态规划： 动态规划：
```c ```c
#define max(a, b) (((a) > (b)) ? (a) : (b)) #define max(a, b) (((a) > (b)) ? (a) : (b))
@ -379,6 +399,7 @@ int maxProfit(int* prices, int pricesSize){
### Scala ### Scala
贪心: 贪心:
```scala ```scala
object Solution { object Solution {
def maxProfit(prices: Array[Int]): Int = { def maxProfit(prices: Array[Int]): Int = {

4
problems/0134.加油站.md
View File

@ -45,6 +45,10 @@
* 解释: * 解释:
你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油。开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油。开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油。你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。因此，无论怎样，你都不可能绕环路行驶一周。 你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油。开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油。开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油。你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。因此，无论怎样，你都不可能绕环路行驶一周。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，得这么加油才能跑完全程！LeetCode ：134.加油站](https://www.bilibili.com/video/BV1jA411r7WX)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 暴力方法 ## 暴力方法

4
problems/0135.分发糖果.md
View File

@ -28,6 +28,10 @@
* 输出: 4 * 输出: 4
* 解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。第三个孩子只得到 1 颗糖果，这已满足上述两个条件。 * 解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。第三个孩子只得到 1 颗糖果，这已满足上述两个条件。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，两者兼顾很容易顾此失彼！LeetCode：135.分发糖果](https://www.bilibili.com/video/BV1ev4y1r7wN)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路

161
problems/0376.摆动序列.md
View File

@ -4,7 +4,6 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
> 本周讲解了[贪心理论基础](https://programmercarl.com/贪心算法理论基础.html)，以及第一道贪心的题目：[贪心算法：分发饼干](https://programmercarl.com/0455.分发饼干.html)，可能会给大家一种贪心算法比较简单的错觉，好了，接下来几天的题目难度要上来了，哈哈。 > 本周讲解了[贪心理论基础](https://programmercarl.com/贪心算法理论基础.html)，以及第一道贪心的题目：[贪心算法：分发饼干](https://programmercarl.com/0455.分发饼干.html)，可能会给大家一种贪心算法比较简单的错觉，好了，接下来几天的题目难度要上来了，哈哈。
# 376. 摆动序列 # 376. 摆动序列
@ -13,25 +12,32 @@
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。 例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3)  是正负交替出现的。相反, [1,4,7,2,5]  和  [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。 给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
示例 1: 示例 1:
* 输入: [1,7,4,9,2,5]
* 输出: 6 - 输入: [1,7,4,9,2,5]
* 解释: 整个序列均为摆动序列。 - 输出: 6
- 解释: 整个序列均为摆动序列。
示例 2: 示例 2:
* 输入: [1,17,5,10,13,15,10,5,16,8]
* 输出: 7 - 输入: [1,17,5,10,13,15,10,5,16,8]
* 解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。 - 输出: 7
- 解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。
示例 3: 示例 3:
* 输入: [1,2,3,4,5,6,7,8,9]
* 输出: 2
## 思路1（贪心解法） - 输入: [1,2,3,4,5,6,7,8,9]
- 输出: 2
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，寻找摆动有细节！| LeetCode：376.摆动序列](https://www.bilibili.com/video/BV17M411b7NS)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 1（贪心解法）
本题要求通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。 本题要求通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
@ -55,7 +61,7 @@
**这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点** **这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点**
在计算是否有峰值的时候，大家知道遍历的下标i ，计算prediff（nums[i] - nums[i-1]） 和 curdiff（nums[i+1] - nums[i]），如果`prediff < 0 && curdiff > 0` 或者 `prediff > 0 && curdiff < 0` 此时就有波动就需要统计。 在计算是否有峰值的时候，大家知道遍历的下标 i ，计算 prediff（nums[i] - nums[i-1]） 和 curdiff（nums[i+1] - nums[i]），如果`prediff < 0 && curdiff > 0` 或者 `prediff > 0 && curdiff < 0` 此时就有波动就需要统计。
这是我们思考本题的一个大题思路，但本题要考虑三种情况： 这是我们思考本题的一个大题思路，但本题要考虑三种情况：
@ -69,43 +75,41 @@
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230106170449.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230106170449.png)
它的摇摆序列长度是多少呢？ **其实是长度是3**，也就是我们在删除的时候 要不删除左面的三个2，要不就删除右边的三个2。 它的摇摆序列长度是多少呢？ **其实是长度是 3**，也就是我们在删除的时候 要不删除左面的三个 2，要不就删除右边的三个 2。
如图，可以统一规则，删除左边的三个2： 如图，可以统一规则，删除左边的三个 2：
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230106172613.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230106172613.png)
在图中，当i指向第一个2的时候，`prediff > 0 && curdiff = 0` ，当 i 指向最后一个2的时候 `prediff = 0 && curdiff < 0`。 在图中，当 i 指向第一个 2 的时候，`prediff > 0 && curdiff = 0` ，当 i 指向最后一个 2 的时候 `prediff = 0 && curdiff < 0`。
如果我们采用，删左面三个2的规则，那么 当 `prediff = 0 && curdiff < 0` 也要记录一个峰值，因为他是把之前相同的元素都删掉留下的峰值。 如果我们采用，删左面三个 2 的规则，那么 当 `prediff = 0 && curdiff < 0` 也要记录一个峰值，因为他是把之前相同的元素都删掉留下的峰值。
所以我们记录峰值的条件应该是： `(preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)`，为什么这里允许 prediff == 0 ，就是为了 上面我说的这种情况。 所以我们记录峰值的条件应该是： `(preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)`，为什么这里允许 prediff == 0 ，就是为了 上面我说的这种情况。
### 情况二：数组首尾两端 ### 情况二：数组首尾两端
所以本题统计峰值的时候，数组最左面和最右面如果统计呢？ 所以本题统计峰值的时候，数组最左面和最右面如果统计呢？
题目中说了，如果只有两个不同的元素，那摆动序列也是2。 题目中说了，如果只有两个不同的元素，那摆动序列也是 2。
例如序列[2,5]，如果靠统计差值来计算峰值个数就需要考虑数组最左面和最右面的特殊情况。 例如序列[2,5]，如果靠统计差值来计算峰值个数就需要考虑数组最左面和最右面的特殊情况。
因为我们在计算 prediff（nums[i] - nums[i-1]） 和 curdiff（nums[i+1] - nums[i]）的时候，至少需要三个数字才能计算，而数组只有两个数字。 因为我们在计算 prediff（nums[i] - nums[i-1]） 和 curdiff（nums[i+1] - nums[i]）的时候，至少需要三个数字才能计算，而数组只有两个数字。
这里我们可以写死，就是 如果只有两个元素，且元素不同，那么结果为2。 这里我们可以写死，就是 如果只有两个元素，且元素不同，那么结果为 2。
不写死的话，如果和我们的判断规则结合在一起呢？ 不写死的话，如果和我们的判断规则结合在一起呢？
可以假设，数组最前面还有一个数字，那这个数字应该是什么呢？ 可以假设，数组最前面还有一个数字，那这个数字应该是什么呢？
之前我们在 讨论 情况一：相同数字连续 的时候， prediff = 0 ，curdiff < 0 或者 >0 也记为波谷。 之前我们在 讨论 情况一：相同数字连续 的时候， prediff = 0 ，curdiff < 0 或者 >0 也记为波谷。
那么为了规则统一，针对序列[2,5]，可以假设为[2,2,5]，这样它就有坡度了即preDiff = 0，如图： 那么为了规则统一，针对序列[2,5]，可以假设为[2,2,5]，这样它就有坡度了即 preDiff = 0，如图：
![376.摆动序列1](https://code-thinking-1253855093.file.myqcloud.com/pics/20201124174357612.png) ![376.摆动序列1](https://code-thinking-1253855093.file.myqcloud.com/pics/20201124174357612.png)
针对以上情形，result初始为1（默认最右面有一个峰值），此时curDiff > 0 && preDiff <= 0，那么result++（计算了左面的峰值），最后得到的result就是2（峰值个数为2即摆动序列长度为2） 针对以上情形，result 初始为 1（默认最右面有一个峰值），此时 curDiff > 0 && preDiff <= 0，那么 result++（计算了左面的峰值），最后得到的 result 就是 2（峰值个数为 2 即摆动序列长度为 2）
经过以上分析后，我们可以写出如下代码： 经过以上分析后，我们可以写出如下代码：
@ -130,8 +134,9 @@ public:
} }
}; };
``` ```
* 时间复杂度：O(n)
* 空间复杂度：O(1) - 时间复杂度：O(n)
- 空间复杂度：O(1)
此时大家是不是发现 以上代码提交也不能通过本题？ 此时大家是不是发现 以上代码提交也不能通过本题？
@ -143,13 +148,13 @@ public:
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230108171505.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230108171505.png)
图中，我们可以看出，版本一的代码在三个地方记录峰值，但其实结果因为是2，因为 单调中的平坡 不能算峰值（即摆动）。 图中，我们可以看出，版本一的代码在三个地方记录峰值，但其实结果因为是 2，因为 单调中的平坡 不能算峰值（即摆动）。
之所以版本一会出问题，是因为我们实时更新了 prediff。 之所以版本一会出问题，是因为我们实时更新了 prediff。
那么我们应该什么时候更新prediff呢？ 那么我们应该什么时候更新 prediff 呢？
我们只需要在 这个坡度 摆动变化的时候，更新prediff就行，这样prediff在 单调区间有平坡的时候 就不会发生变化，造成我们的误判。 我们只需要在 这个坡度 摆动变化的时候，更新 prediff 就行，这样 prediff 在 单调区间有平坡的时候 就不会发生变化，造成我们的误判。
所以本题的最终代码为： 所以本题的最终代码为：
@ -182,19 +187,19 @@ public:
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230108174452.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230108174452.png)
## 思路2（动态规划） ## 思路 2（动态规划）
考虑用动态规划的思想来解决这个问题。 考虑用动态规划的思想来解决这个问题。
很容易可以发现，对于我们当前考虑的这个数，要么是作为山峰（即nums[i] > nums[i-1]），要么是作为山谷（即nums[i] < nums[i - 1]）。 很容易可以发现，对于我们当前考虑的这个数，要么是作为山峰（即 nums[i] > nums[i-1]），要么是作为山谷（即 nums[i] < nums[i - 1]）。
* 设dp状态`dp[i][0]`，表示考虑前i个数，第i个数作为山峰的摆动子序列的最长长度 - 设 dp 状态`dp[i][0]`，表示考虑前 i 个数，第 i 个数作为山峰的摆动子序列的最长长度
* 设dp状态`dp[i][1]`，表示考虑前i个数，第i个数作为山谷的摆动子序列的最长长度 - 设 dp 状态`dp[i][1]`，表示考虑前 i 个数，第 i 个数作为山谷的摆动子序列的最长长度
则转移方程为： 则转移方程为：
* `dp[i][0] = max(dp[i][0], dp[j][1] + 1)`，其中`0 < j < i`且`nums[j] < nums[i]`，表示将nums[i]接到前面某个山谷后面，作为山峰。 - `dp[i][0] = max(dp[i][0], dp[j][1] + 1)`，其中`0 < j < i`且`nums[j] < nums[i]`，表示将 nums[i]接到前面某个山谷后面，作为山峰。
* `dp[i][1] = max(dp[i][1], dp[j][0] + 1)`，其中`0 < j < i`且`nums[j] > nums[i]`，表示将nums[i]接到前面某个山峰后面，作为山谷。 - `dp[i][1] = max(dp[i][1], dp[j][0] + 1)`，其中`0 < j < i`且`nums[j] > nums[i]`，表示将 nums[i]接到前面某个山峰后面，作为山谷。
初始状态： 初始状态：
@ -223,28 +228,25 @@ public:
}; };
``` ```
* 时间复杂度：O(n^2) - 时间复杂度：O(n^2)
* 空间复杂度：O(n) - 空间复杂度：O(n)
**进阶** **进阶**
可以用两棵线段树来维护区间的最大值 可以用两棵线段树来维护区间的最大值
* 每次更新`dp[i][0]`，则在`tree1`的`nums[i]`位置值更新为`dp[i][0]` - 每次更新`dp[i][0]`，则在`tree1`的`nums[i]`位置值更新为`dp[i][0]`
* 每次更新`dp[i][1]`，则在`tree2`的`nums[i]`位置值更新为`dp[i][1]` - 每次更新`dp[i][1]`，则在`tree2`的`nums[i]`位置值更新为`dp[i][1]`
* 则dp转移方程中就没有必要j从0遍历到i-1，可以直接在线段树中查询指定区间的值即可。 - 则 dp 转移方程中就没有必要 j 从 0 遍历到 i-1，可以直接在线段树中查询指定区间的值即可。
时间复杂度：O(nlog n) 时间复杂度：O(nlog n)
空间复杂度：O(n) 空间复杂度：O(n)
## 其他语言版本 ## 其他语言版本
### Java ### Java
```Java ```Java
class Solution { class Solution {
public int wiggleMaxLength(int[] nums) { public int wiggleMaxLength(int[] nums) {
@ -270,6 +272,7 @@ class Solution {
} }
} }
``` ```
```java ```java
// DP // DP
class Solution { class Solution {
@ -360,6 +363,7 @@ class Solution:
### Go ### Go
**贪心** **贪心**
```go ```go
func wiggleMaxLength(nums []int) int { func wiggleMaxLength(nums []int) int {
n := len(nums) n := len(nums)
@ -383,6 +387,7 @@ func wiggleMaxLength(nums []int) int {
``` ```
**动态规划** **动态规划**
```go ```go
func wiggleMaxLength(nums []int) int { func wiggleMaxLength(nums []int) int {
n := len(nums) n := len(nums)
@ -420,7 +425,9 @@ func max(a, b int) int {
``` ```
### Javascript ### Javascript
**贪心** **贪心**
```Javascript ```Javascript
var wiggleMaxLength = function(nums) { var wiggleMaxLength = function(nums) {
if(nums.length <= 1) return nums.length if(nums.length <= 1) return nums.length
@ -437,7 +444,9 @@ var wiggleMaxLength = function(nums) {
return result return result
}; };
``` ```
**动态规划** **动态规划**
```Javascript ```Javascript
var wiggleMaxLength = function(nums) { var wiggleMaxLength = function(nums) {
if (nums.length === 1) return 1; if (nums.length === 1) return 1;
@ -458,7 +467,9 @@ var wiggleMaxLength = function(nums) {
``` ```
### Rust ### Rust
**贪心** **贪心**
```Rust ```Rust
impl Solution { impl Solution {
pub fn wiggle_max_length(nums: Vec<i32>) -> i32 { pub fn wiggle_max_length(nums: Vec<i32>) -> i32 {
@ -504,6 +515,7 @@ impl Solution {
``` ```
### C ### C
**贪心** **贪心**
```c ```c
@ -568,54 +580,49 @@ int wiggleMaxLength(int* nums, int numsSize){
} }
``` ```
### TypeScript ### TypeScript
**贪心** **贪心**
```typescript ```typescript
function wiggleMaxLength(nums: number[]): number { function wiggleMaxLength(nums: number[]): number {
let length: number = nums.length; let length: number = nums.length;
if (length <= 1) return length; if (length <= 1) return length;
let preDiff: number = 0; let preDiff: number = 0;
let curDiff: number = 0; let curDiff: number = 0;
let count: number = 1; let count: number = 1;
for (let i = 1; i < length; i++) { for (let i = 1; i < length; i++) {
curDiff = nums[i] - nums[i - 1]; curDiff = nums[i] - nums[i - 1];
if ( if ((preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)) {
(preDiff <= 0 && curDiff > 0) || preDiff = curDiff;
(preDiff >= 0 && curDiff < 0) count++;
) {
preDiff = curDiff;
count++;
}
} }
return count; }
}; return count;
}
``` ```
**动态规划** **动态规划**
```typescript ```typescript
function wiggleMaxLength(nums: number[]): number { function wiggleMaxLength(nums: number[]): number {
const length: number = nums.length; const length: number = nums.length;
if (length <= 1) return length; if (length <= 1) return length;
const dp: number[][] = new Array(length).fill(0).map(_ => []); const dp: number[][] = new Array(length).fill(0).map((_) => []);
dp[0][0] = 1; // 第一个数作为波峰 dp[0][0] = 1; // 第一个数作为波峰
dp[0][1] = 1; // 第一个数作为波谷 dp[0][1] = 1; // 第一个数作为波谷
for (let i = 1; i < length; i++) { for (let i = 1; i < length; i++) {
dp[i][0] = 1; dp[i][0] = 1;
dp[i][1] = 1; dp[i][1] = 1;
for (let j = 0; j < i; j++) { for (let j = 0; j < i; j++) {
if (nums[j] < nums[i]) dp[i][0] = Math.max(dp[i][0], dp[j][1] + 1); if (nums[j] < nums[i]) dp[i][0] = Math.max(dp[i][0], dp[j][1] + 1);
}
for (let j = 0; j < i; j++) {
if (nums[j] > nums[i]) dp[i][1] = Math.max(dp[i][1], dp[j][0] + 1);
}
} }
return Math.max(dp[length - 1][0], dp[length - 1][1]); for (let j = 0; j < i; j++) {
}; if (nums[j] > nums[i]) dp[i][1] = Math.max(dp[i][1], dp[j][0] + 1);
}
}
return Math.max(dp[length - 1][0], dp[length - 1][1]);
}
``` ```
### Scala ### Scala

4
problems/0406.根据身高重建队列.md
View File

@ -37,6 +37,10 @@
题目数据确保队列可以被重建 题目数据确保队列可以被重建
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，不要两边一起贪，会顾此失彼 | LeetCode：406.根据身高重建队列](https://www.bilibili.com/video/BV1EA411675Y)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
本题有两个维度，h和k，看到这种题目一定要想如何确定一个维度，然后再按照另一个维度重新排列。 本题有两个维度，h和k，看到这种题目一定要想如何确定一个维度，然后再按照另一个维度重新排列。

4
problems/0435.无重叠区间.md
View File

@ -30,6 +30,10 @@
* 输出: 0 * 输出: 0
* 解释: 你不需要移除任何区间，因为它们已经是无重叠的了。 * 解释: 你不需要移除任何区间，因为它们已经是无重叠的了。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，依然是判断重叠区间 | LeetCode：435.无重叠区间](https://www.bilibili.com/video/BV1A14y1c7E1)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
**相信很多同学看到这道题目都冥冥之中感觉要排序，但是究竟是按照右边界排序，还是按照左边界排序呢？** **相信很多同学看到这道题目都冥冥之中感觉要排序，但是究竟是按照右边界排序，还是按照左边界排序呢？**

4
problems/0452.用最少数量的箭引爆气球.md
View File

@ -42,6 +42,10 @@
* points[i].length == 2 * points[i].length == 2
* -2^31 <= xstart < xend <= 2^31 - 1 * -2^31 <= xstart < xend <= 2^31 - 1
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，判断重叠区间问题 | LeetCode：452.用最少数量的箭引爆气球](https://www.bilibili.com/video/BV1SA41167xe)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
如何使用最少的弓箭呢？ 如何使用最少的弓箭呢？

137
problems/0455.分发饼干.md
View File

@ -4,31 +4,35 @@
</a> </a>
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p> <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
# 455.分发饼干 # 455.分发饼干
[力扣题目链接](https://leetcode.cn/problems/assign-cookies/) [力扣题目链接](https://leetcode.cn/problems/assign-cookies/)
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。 对每个孩子 i，都有一个胃口值  g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
示例 1: 示例  1:
* 输入: g = [1,2,3], s = [1,1]
* 输出: 1
解释:你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。所以你应该输出1。
示例 2: - 输入: g = [1,2,3], s = [1,1]
* 输入: g = [1,2], s = [1,2,3] - 输出: 1
* 输出: 2 解释:你有三个孩子和两块小饼干，3 个孩子的胃口值分别是：1,2,3。虽然你有两块小饼干，由于他们的尺寸都是 1，你只能让胃口值是 1 的孩子满足。所以你应该输出 1。
* 解释:你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。你拥有的饼干数量和尺寸都足以让所有孩子满足。所以你应该输出2.
示例  2:
- 输入: g = [1,2], s = [1,2,3]
- 输出: 2
- 解释:你有两个孩子和三块小饼干，2 个孩子的胃口值分别是 1,2。你拥有的饼干数量和尺寸都足以让所有孩子满足。所以你应该输出 2.
提示： 提示：
* 1 <= g.length <= 3 * 10^4
* 0 <= s.length <= 3 * 10^4
* 1 <= g[i], s[j] <= 2^31 - 1
- 1 <= g.length <= 3 \* 10^4
- 0 <= s.length <= 3 \* 10^4
- 1 <= g[i], s[j] <= 2^31 - 1
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，你想先喂哪个小孩？| LeetCode：455.分发饼干](https://www.bilibili.com/video/BV1MM411b7cq)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
@ -46,9 +50,7 @@
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230203105634.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230203105634.png)
这个例子可以看出饼干 9 只有喂给胃口为 7 的小孩，这样才是整体最优解，并想不出反例，那么就可以撸代码了。
这个例子可以看出饼干9只有喂给胃口为7的小孩，这样才是整体最优解，并想不出反例，那么就可以撸代码了。
C++代码整体如下： C++代码整体如下：
@ -74,10 +76,9 @@ public:
}; };
``` ```
从代码中可以看出我用了一个index来控制饼干数组的遍历，遍历饼干并没有再起一个for循环，而是采用自减的方式，这也是常用的技巧。 从代码中可以看出我用了一个 index 来控制饼干数组的遍历，遍历饼干并没有再起一个 for 循环，而是采用自减的方式，这也是常用的技巧。
有的同学看到要遍历两个数组，就想到用两个for循环，那样逻辑其实就复杂了。
有的同学看到要遍历两个数组，就想到用两个 for 循环，那样逻辑其实就复杂了。
### 注意事项 ### 注意事项
@ -85,16 +86,15 @@ public:
其实是不可以的。 其实是不可以的。
外面的for 是里的下标i 是固定移动的，而if里面的下标 index 是符合条件才移动的。 外面的 for 是里的下标 i 是固定移动的，而 if 里面的下标 index 是符合条件才移动的。
如果 for 控制的是饼干， if 控制胃口，就是出现如下情况 ： 如果 for 控制的是饼干， if 控制胃口，就是出现如下情况 ：
![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230112102848.png) ![](https://code-thinking-1253855093.file.myqcloud.com/pics/20230112102848.png)
if 里的 index 指向 胃口 10， for里的i指向饼干9，因为 饼干9 满足不了 胃口10，所以 i 持续向前移动，而index 走不到` s[index] >= g[i]` 的逻辑，所以index不会移动，那么当i 持续向前移动，最后所有的饼干都匹配不上。 if 里的 index 指向 胃口 10， for 里的 i 指向饼干 9，因为 饼干 9 满足不了 胃口 10，所以 i 持续向前移动，而 index 走不到` s[index] >= g[i]` 的逻辑，所以 index 不会移动，那么当 i 持续向前移动，最后所有的饼干都匹配不上。
所以 一定要for 控制 胃口，里面的if控制饼干。
所以 一定要 for 控制 胃口，里面的 if 控制饼干。
### 其他思路 ### 其他思路
@ -131,8 +131,8 @@ public:
## 其他语言版本 ## 其他语言版本
### Java ### Java
```java ```java
class Solution { class Solution {
// 思路1：优先考虑饼干，小饼干先喂饱小胃口 // 思路1：优先考虑饼干，小饼干先喂饱小胃口
@ -151,6 +151,7 @@ class Solution {
} }
} }
``` ```
```java ```java
class Solution { class Solution {
// 思路2：优先考虑胃口，先喂饱大胃口 // 思路2：优先考虑胃口，先喂饱大胃口
@ -172,6 +173,7 @@ class Solution {
``` ```
### Python ### Python
```python ```python
class Solution: class Solution:
# 思路1：优先考虑小胃口 # 思路1：优先考虑小胃口
@ -184,6 +186,7 @@ class Solution:
res += 1 res += 1
return res return res
``` ```
```python ```python
class Solution: class Solution:
# 思路2：优先考虑大胃口 # 思路2：优先考虑大胃口
@ -199,6 +202,7 @@ class Solution:
``` ```
### Go ### Go
```golang ```golang
//排序后，局部最优 //排序后，局部最优
func findContentChildren(g []int, s []int) int { func findContentChildren(g []int, s []int) int {
@ -218,6 +222,7 @@ func findContentChildren(g []int, s []int) int {
``` ```
### Rust ### Rust
```rust ```rust
pub fn find_content_children(mut children: Vec<i32>, mut cookie: Vec<i32>) -> i32 { pub fn find_content_children(mut children: Vec<i32>, mut cookie: Vec<i32>) -> i32 {
children.sort(); children.sort();
@ -236,21 +241,21 @@ pub fn find_content_children(mut children: Vec<i32>, mut cookie: Vec<i32>) -> i3
``` ```
### Javascript ### Javascript
```js
var findContentChildren = function(g, s) {
g = g.sort((a, b) => a - b)
s = s.sort((a, b) => a - b)
let result = 0
let index = s.length - 1
for(let i = g.length - 1; i >= 0; i--) {
if(index >= 0 && s[index] >= g[i]) {
result++
index--
}
}
return result
};
```js
var findContentChildren = function (g, s) {
g = g.sort((a, b) => a - b);
s = s.sort((a, b) => a - b);
let result = 0;
let index = s.length - 1;
for (let i = g.length - 1; i >= 0; i--) {
if (index >= 0 && s[index] >= g[i]) {
result++;
index--;
}
}
return result;
};
``` ```
### TypeScript ### TypeScript
@ -258,41 +263,41 @@ var findContentChildren = function(g, s) {
```typescript ```typescript
// 大饼干尽量喂胃口大的 // 大饼干尽量喂胃口大的
function findContentChildren(g: number[], s: number[]): number { function findContentChildren(g: number[], s: number[]): number {
g.sort((a, b) => a - b); g.sort((a, b) => a - b);
s.sort((a, b) => a - b); s.sort((a, b) => a - b);
const childLength: number = g.length, const childLength: number = g.length,
cookieLength: number = s.length; cookieLength: number = s.length;
let curChild: number = childLength - 1, let curChild: number = childLength - 1,
curCookie: number = cookieLength - 1; curCookie: number = cookieLength - 1;
let resCount: number = 0; let resCount: number = 0;
while (curChild >= 0 && curCookie >= 0) { while (curChild >= 0 && curCookie >= 0) {
if (g[curChild] <= s[curCookie]) { if (g[curChild] <= s[curCookie]) {
curCookie--; curCookie--;
resCount++; resCount++;
}
curChild--;
} }
return resCount; curChild--;
}; }
return resCount;
}
``` ```
```typescript ```typescript
// 小饼干先喂饱小胃口的 // 小饼干先喂饱小胃口的
function findContentChildren(g: number[], s: number[]): number { function findContentChildren(g: number[], s: number[]): number {
g.sort((a, b) => a - b); g.sort((a, b) => a - b);
s.sort((a, b) => a - b); s.sort((a, b) => a - b);
const childLength: number = g.length, const childLength: number = g.length,
cookieLength: number = s.length; cookieLength: number = s.length;
let curChild: number = 0, let curChild: number = 0,
curCookie: number = 0; curCookie: number = 0;
while (curChild < childLength && curCookie < cookieLength) { while (curChild < childLength && curCookie < cookieLength) {
if (g[curChild] <= s[curCookie]) { if (g[curChild] <= s[curCookie]) {
curChild++; curChild++;
}
curCookie++;
} }
return curChild; curCookie++;
}; }
return curChild;
}
``` ```
### C ### C

4
problems/0738.单调递增的数字.md
View File

@ -26,6 +26,10 @@
说明: N 是在 [0, 10^9] 范围内的一个整数。 说明: N 是在 [0, 10^9] 范围内的一个整数。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，思路不难想，但代码不好写！LeetCode:738.单调自增的数字](https://www.bilibili.com/video/BV1Kv4y1x7tP)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 暴力解法 ## 暴力解法

4
problems/0763.划分字母区间.md
View File

@ -24,6 +24,10 @@
* S的长度在[1, 500]之间。 * S的长度在[1, 500]之间。
* S只包含小写字母 'a' 到 'z' 。 * S只包含小写字母 'a' 到 'z' 。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，寻找最远的出现位置！ LeetCode：763.划分字母区间](https://www.bilibili.com/video/BV18G4y1K7d5)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
一想到分割字符串就想到了回溯，但本题其实不用回溯去暴力搜索。 一想到分割字符串就想到了回溯，但本题其实不用回溯去暴力搜索。

4
problems/0860.柠檬水找零.md
View File

@ -50,6 +50,10 @@
* 0 <= bills.length <= 10000 * 0 <= bills.length <= 10000
* bills[i] 不是 5 就是 10 或是 20  * bills[i] 不是 5 就是 10 或是 20 
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，看上去复杂，其实逻辑都是固定的！LeetCode：860.柠檬水找零](https://www.bilibili.com/video/BV12x4y1j7DD)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
这是前几天的leetcode每日一题，感觉不错，给大家讲一下。 这是前几天的leetcode每日一题，感觉不错，给大家讲一下。

4
problems/0968.监控二叉树.md
View File

@ -38,6 +38,10 @@
* 给定树的节点数的范围是 [1, 1000]。 * 给定树的节点数的范围是 [1, 1000]。
* 每个节点的值都是 0。 * 每个节点的值都是 0。
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，二叉树与贪心的结合，有点难...... LeetCode:968.监督二叉树](https://www.bilibili.com/video/BV1SA411U75i)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路

4
problems/1005.K次取反后最大化的数组和.md
View File

@ -34,6 +34,10 @@
* 1 <= K <= 10000 * 1 <= K <= 10000
* -100 <= A[i] <= 100 * -100 <= A[i] <= 100
# 视频讲解
**《代码随想录》算法视频公开课：[贪心算法，这不就是常识？还能叫贪心？LeetCode：1005.K次取反后最大化的数组和](https://www.bilibili.com/video/BV138411G7LY)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
## 思路 ## 思路
本题思路其实比较好想了，如何可以让数组和最大呢？ 本题思路其实比较好想了，如何可以让数组和最大呢？