feat: 贪婪专题

Author: lucifer

README.md

@@ -159,15 +159,15 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 
 - [数据结构](./thinkings/basic-data-structure.md)
 - [基础算法](./thinkings/basic-algorithm.md)
-- [二叉树的遍历](./thinkings/binary-tree-traversal.md) 🖊
-- [动态规划](./thinkings/dynamic-programming.md) 🖊
+- [二叉树的遍历](./thinkings/binary-tree-traversal.md) 
+- [动态规划](./thinkings/dynamic-programming.md) 
 - [哈夫曼编码和游程编码](./thinkings/run-length-encode-and-huffman-encode.md)
 - [布隆过滤器](./thinkings/bloom-filter.md)
 - [字符串问题](./thinkings/string-problems.md)
-- [前缀树专题](./thinkings/trie.md) 🖊
+- [前缀树专题](./thinkings/trie.md) 
 - [《日程安排》专题](https://lucifer.ren/blog/2020/02/03/leetcode-%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%E7%B3%BB%E5%88%97/)
 - [《构造二叉树》专题](https://lucifer.ren/blog/2020/02/08/%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91%E4%B8%93%E9%A2%98/)
-- [《贪婪策略》专题](./thinkings/greedy.md)
+- [《贪婪策略》专题](./thinkings/greedy.md)🖊
 - [《深度优先遍历》专题](./thinkings/DFS.md)
 - [滑动窗口（思路 + 模板）](./thinkings/slide-window.md)
 - [位运算](./thinkings/bit.md)

SUMMARY.md

@@ -173,6 +173,7 @@
     * [0900. RLE 迭代器](problems/900.rle-iterator.md)
     * [0912. 排序数组](problems/912.sort-an-array.md)
     * [0935. 骑士拨号器](problems/935.knight-dialer.md)
+    * [0978. 最长湍流子数组](problems/978.longest-turbulent-subarray.md)
     * [1011. 在 D 天内送达包裹的能力](problems/1011.capacity-to-ship-packages-within-d-days.md)
     * [1014. 最佳观光组合](problems/1014.best-sightseeing-pair.md)
     * [1015. 可被 K 整除的最小整数](problems/1015.smallest-integer-divisible-by-k.md)

collections/medium.md

@@ -97,6 +97,7 @@
 - [0900. RLE 迭代器](../problems/900.rle-iterator.md)
 - [0912. 排序数组](../problems/912.sort-an-array.md)
 - [0935. 骑士拨号器](../problems/935.knight-dialer.md)
+- [0978. 最长湍流子数组](../problems/978.longest-turbulent-subarray.md) 🆕
 - [1011. 在 D 天内送达包裹的能力](../problems/1011.capacity-to-ship-packages-within-d-days.md)
 - [1014. 最佳观光组合](../problems/1014.best-sightseeing-pair.md)
 - [1015. 可被 K 整除的最小整数](../problems/1015.smallest-integer-divisible-by-k.md)

introduction.md

@@ -22,7 +22,6 @@
 
 ![](https://cdn.jsdelivr.net/gh/azl397985856/cdn/2020-10-17/1602928846461-image.png)
 
-
 ![](https://cdn.jsdelivr.net/gh/azl397985856/cdn/2020-10-17/1602928862442-image.png)
 
 我写这本电子书花费了大量的时间和精力，除了内容上的创作，还要做一些电子书的排版，以让大家获得更好的阅读体验。光数学公式的展示，我就研究了多个插件的要源码，并魔改了一下才使得导出的电子书支持 latex。 不过有些动图，在做成电子书的时候自然就变没了，如果需要看动图的， 可以去我的公众号《力扣加加》或者我的 leetcode 题解仓库看。
@@ -43,7 +42,6 @@
 
 - [在线版](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/)
 
-
 html, pdf，mobi 和 epub 格式，关注我的公众号《力扣加加》回复`电子书`即可。
 
 ## 介绍
@@ -87,7 +85,7 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 ## 食用指南
 
 - 我对大部分题目的复杂度都进行了分析，除了个别分析起来复杂的题目，大家一定要对一道题的复杂度了如指掌才可以。
-> 有些题目我是故意不写的， 比如所有的回溯题目我都没写， 不过它们全部都是指数的复杂度
+  > 有些题目我是故意不写的， 比如所有的回溯题目我都没写， 不过它们全部都是指数的复杂度
 - 我对题目难度进行了分类的保留，因此你可以根据自己的情况刷。我推荐大家从简单开始，逐步加大难度，直到困难。
 - 这里有一张互联网公司面试中经常考察的问题类型总结的思维导图，我们可以结合图片中的信息分析一下。
 
@@ -188,7 +186,7 @@ anki - 文件 - 导入 - 下拉格式选择“打包的 anki 集合”，然后
 
 ## 关于我
 
-擅长前端工程化，前端性能优化，前端标准化等，做过。net， 搞过 Java，现在是一名前端工程师，我的个人博客：https://lucifer.ren/blog/
+擅长前端工程化，前端性能优化，前端标准化等，做过 .net， 搞过 Java，现在是一名前端工程师，我的个人博客：https://lucifer.ren/blog/
 
 我经常会在开源社区进行一些输出和分享，比较受欢迎的有 [宇宙最强的前端面试指南](https://github.com/azl397985856/fe-interview)
 和 [我的第一本小书](https://github.com/azl397985856/automate-everything)。目前本人正在写一本关于《leetcode 题解》的实体书，感兴趣的可以通过邮箱或者微信联系我，我会在出版的第一时间通知你，并给出首发优惠价。有需要可以直接群里联系我，或者发送到我的个人邮箱 [azl397985856@gmail.com]。 新书详情戳这里：[《或许是一本可以彻底改变你刷 LeetCode 效率的题解书》](https://lucifer.ren/blog/2020/04/07/leetcode-book.intro/)

problems/935.knight-dialer.md

@@ -1,16 +1,17 @@
-
 ## 题目地址 (935. 骑士拨号器）
+
 https://leetcode-cn.com/problems/knight-dialer/
 
 ## 题目描述
+
 ```
 国际象棋中的骑士可以按下图所示进行移动：
 
 ```
 
 ![](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlu303ibcj305305p744.jpg)
 
-```          
+```         
 
 这一次，我们将 “骑士” 放在电话拨号盘的任意数字键（如上图所示）上，接下来，骑士将会跳 N-1 步。每一步必须是从一个数字键跳到另一个数字键。
 
@@ -47,12 +48,12 @@ https://leetcode-cn.com/problems/knight-dialer/
 - DFS
 - 记忆化搜索
 
-## 深度优先遍历（DFS）
-
 ## 公司
 
 - 暂无
 
+## 深度优先遍历（DFS）
+
 ### 思路
 
 这道题要求解一个数字。并且每一个格子能够跳的状态是确定的。 因此我们的思路就是“状态机”（动态规划），暴力遍历（BFS or DFS），这里我们使用 DFS。（注意这几种思路并无本质不同）
@@ -94,6 +95,7 @@ class Solution:
 ```
 
 **复杂度分析**
+
 - 时间复杂度：$O(N)$
 - 空间复杂度：$O(N)$
 
@@ -116,6 +118,7 @@ class Solution:
 ```
 
 **复杂度分析**
+
 - 时间复杂度：$O(N)$
 - 空间复杂度：$O(1)$
 

problems/978.longest-turbulent-subarray.md

@@ -0,0 +1,95 @@
+## 题目地址 (978. 最长湍流子数组）
+
+https://leetcode-cn.com/problems/longest-turbulent-subarray/
+
+## 题目描述
+
+```
+当 A 的子数组 A[i], A[i+1], ..., A[j] 满足下列条件时，我们称其为湍流子数组：
+
+若 i <= k < j，当 k 为奇数时， A[k] > A[k+1]，且当 k 为偶数时，A[k] < A[k+1]；
+或 若 i <= k < j，当 k 为偶数时，A[k] > A[k+1] ，且当 k 为奇数时， A[k] < A[k+1]。
+也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。
+
+返回 A 的最大湍流子数组的长度。
+
+ 
+
+示例 1：
+
+输入：[9,4,2,10,7,8,8,1,9]
+输出：5
+解释：(A[1] > A[2] < A[3] > A[4] < A[5])
+示例 2：
+
+输入：[4,8,12,16]
+输出：2
+示例 3：
+
+输入：[100]
+输出：1
+ 
+
+提示：
+
+1 <= A.length <= 40000
+0 <= A[i] <= 10^9
+```
+
+## 前置知识
+
+- [滑动窗口](../thinkings/slide-window.md)
+
+## 公司
+
+- 暂无
+
+## 思路
+
+我们先尝试从题目给的例子打开思路。
+
+对于 A 为 [9,4,2,10,7,8,8,1,9] 来说，我用这样的一个数组 arr 来表示 [-, -, +, -, +, 0, -, +]。其含义是 arr[i] 表示 A[i] - A[i - 1]的符号，其中：**+ 表示正号，- 表示 负号，0 表示 A[i] 和 A[i - 1]相同的情况**，那么显然 arr 的长度始终为 A 的长度 - 1。
+
+那么不难得出，题目给出的剩下两个例子的 arr 为：[+, +, +] 和 []。
+
+通过观察不难发现， 实际题目要求的就是**正负相间的最大长度**。如上的三个例子分别为：
+
+> 我用粗体表示答案部分
+
+- [-, **-, +, -, +**, 0, -, +]，答案是 4 + 1
+- [**+**, +, +]，答案是 1 + 1
+- []，答案是 0 + 1
+
+于是使用滑动窗口求解就不难想到了，实际上题目求的是**连续xxxx**，你应该有滑动窗口的想法才对，对不对另说，想到是最起码的。
+
+由于 0 是始终不可以出现在答案中的，因此这算是一个临界条件，大家需要注意特殊判断一下，具体参考代码部分。
+
+## 代码
+
+代码中使用了一个小技巧，就是 a ^ b >= 0 说明其符号相同，这样比相乘判断符号的好处是可以**避免大数溢出**。
+
+```python
+class Solution:
+    def maxTurbulenceSize(self, A: List[int]) -> int:
+        ans = 1
+        i = 0
+        for j in range(2, len(A)):
+            if (A[j] == A[j - 1]):
+                i = j
+            elif (A[j] - A[j - 1]) ^ (A[j - 1] - A[j - 2]) >= 0:
+                i = j - 1
+            ans = max(ans, j - i + 1)
+        return ans
+
+```
+
+**复杂度分析**
+
+- 时间复杂度：$O(N)$
+- 空间复杂度：$O(1)$
+
+更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
+
+关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。
+
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlu0yircgj30p00dwt9t.jpg)

selected/atMostK.md

@@ -575,6 +575,8 @@ class Solution:
 
 ![](https://tva1.sinaimg.cn/large/007S8ZIlly1gj8k997nmbj30q9074dhm.jpg)
 
+> 1094. 拼车 是这道题的换皮题， 思路一模一样。
+
 ### 代码（Python）
 
 ```py

thinkings/greedy.md

@@ -127,23 +127,21 @@ class Solution:
 
 ![](https://tva1.sinaimg.cn/large/007S8ZIlly1ghluind4orj30yg0i00um.jpg)
 
-如图：
+上一题的思路是维护一个 furthest，end 变量，不断贪心更新。 这一道题也是如此，不同的点是本题的数据是一个二维数组。 不过如果你彻底理解了上面的题，我想这道题也难不倒你。
 
-- 1 不可以，因此存在断层
-- 2 可以
-- 3 不行，因为不到 T
+我们来看下这道题究竟和上面的题有多像。
 
-我们当前的 clip 开始结束时间分别为 s，e。 上一段 clip 的结束时间是 t1，上上一段 clip 结束时间是 t2。
+以题目给的数据为例：
 
-那么这种情况下 t1 实际上是不需要的，因为 t2 完全可以覆盖它：
+clips = [[0,1],[6,8],[0,2],[5,6],[0,4],[0,3],[6,7],[1,3],[4,7],[1,4],[2,5],[2,6],[3,4],[4,5],[5,7],[6,9]], T = 9
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1ghluinuuz2j30o604s3yo.jpg)
+我们对原数组按开始时间排序，并先看前面的一部分：
 
-那什么样 t1 才是需要的呢？如图：
+[[0,1], [0,2], [0,3], [0,4], [1,3], [1,4], [2,5], [2,6] ...]
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1ghluis28zej30mc05saa7.jpg)
+> 注意并不需要真正地排序，而是类似桶排序的思路，使用额外的空间，具体参考代码区
 
-用代码来说的话就是`s > t2 and t2 <= t1`
+这是不是就相当于上面跳跃游戏中的：[4,0,2]。 至此我们成功将这道题转换为了上面已经做出来的题。 只不过有一点不同，那就是上面的题保证可以跳到最后，而这道题是可能拼不出来的，因此这个临界值需要注意，具体参考后面的代码区。
 
 #### 代码
 
@@ -155,27 +153,32 @@ Python3 Code:
 
 class Solution:
     def videoStitching(self, clips: List[List[int]], T: int) -> int:
-        #  t1 表示选取的上一个clip的结束时间
-        #  t2 表示选取的上上一个clip的结束时间
-        t2, t1, cnt = -1, 0, 0
-        clips.sort(key=lambda a: a[0])
+        furthest = [0] * (T)
+
         for s, e in clips:
-            # s > t1 已经确定不可以了， t1 >= T 已经可以了
-            if s > t1 or t1 >= T:
-                break
-            if s > t2 and t2 <= t1:
-                cnt += 1
-                t2 = t1
-            t1 = max(t1,e)
-        return cnt if t1 >= T else - 1
+            for i in range(s, e + 1):
+                # 无需考虑，这也是我可以建立一个大小为 T 的 furthest 的数组的原因
+                if i >= T:break
+                furthest[i] = max(furthest[i], e)
+        # 经过上面的预处理，本题和上面的题差距以及很小了
+        # 这里的 last 相当于上题的 furthest
+        end = last = ans = 0
+        for i in range(T):
+            last = max(last, furthest[i])
+            # 比上面题目多的一个临界值
+            if last == i: return - 1
+            if end == i:
+                ans += 1
+                end = last
+        return ans
 
 ```
 
 **复杂度分析**
 
-- 时间复杂度：由于使用了排序（假设是基于比较的排序），因此时间复杂度为 $O(NlogN)$。
+- 时间复杂度：$O(\sum_{i=1}^{n}ranges[i] + T)$，其中 ranges[i] 为 clips[i] 的区间长度。
 
-- 空间复杂度：$O(1)$。
+- 空间复杂度：$O(T)$。
 
 ### 1326. 灌溉花园的最少水龙头数目
 
@@ -229,13 +232,17 @@ ranges.length == n + 1
 
 #### 思路
 
-贪心策略，我们尽量找到能够覆盖最远（右边）位置的水龙头，并记录它最右覆盖的土地。
+和上面的题思路还是一样的。我们仍然采用贪心策略，继续沿用上面的思路，尽量找到能够覆盖最远（右边）位置的水龙头，并记录它最右覆盖的土地。
+
+这里我就不多解释了，我们来看下具体的算法，大家自己体会一下有多像。
+
+算法：
 
-- 我们使用 furthest[i] 来记录经过每一个水龙头 i 能够覆盖的最右侧土地。
-- 一共有 n+1 个水龙头，我们遍历 n + 1 次。
-- 对于每次我们计算水龙头的左右边界，[i - ranges[i], i + ranges[i]]
-- 我们更新左右边界范围内的水龙头的 furthest
-- 最后从土地 0 开始，一直到土地 n ，记录水龙头数目
+- 使用 furthest[i] 来记录经过每一个水龙头 i 能够覆盖的最右侧土地。一共有 n+1 个水龙头，我们遍历 n + 1 次。
+- 每次都计算并更新水龙头的左右边界 [i - ranges[i], i + ranges[i]] 范围内的水龙头的 furthest
+- 最后从土地 0 开始，一直遍历到土地 n ，记录水龙头数目，类似跳跃游戏。
+
+是不是和上面的题几乎一模一样？
 
 #### 代码
 
@@ -247,23 +254,43 @@ Python3 Code:
 
 class Solution:
     def minTaps(self, n: int, ranges: List[int]) -> int:
-        furthest, cnt, cur = [0] * n, 0, 0
-
+        furthest, ans, cur = [0] * n, 0, 0
+        # 预处理
         for i in range(n + 1):
-            l = max(0, i - ranges[i])
-            r = min(n, i + ranges[i])
-            for j in range(l, r):
-                furthest[j] = max(furthest[j], r)
-        while cur < n:
-            if furthest[cur] == 0: return -1
-            cur = furthest[cur]
-            cnt += 1
-        return cnt
+            for j in range(max(0, i - ranges[i]), min(n, i + ranges[i])):
+                furthest[j] = max(furthest[j], min(n, i + ranges[i]))
+        # 老套路了
+        end = last = 0
+        for i in range(n):
+            if furthest[i] == 0: return -1
+            last = max(last, furthest[i])
+            if i == end:
+                end = last
+                ans += 1
+        return ans
 
 ```
 
 **复杂度分析**
 
-- 时间复杂度：时间复杂度取决 l 和 r，也就是说取决于 ranges 数组的值，假设 ranges 的平均大小为 Size 的话，那么时间复杂度为 $O(N * Size)$。
+- 时间复杂度：$O(\sum_{i=1}^{n}R[i] + n)$，其中 R[i] 为 ranges[i] 的区间长度。
+
+- 空间复杂度：$O(n)$。
+
+## 总结
+
+极值问题我们可以考虑使用动态规划和贪心，而覆盖类的问题使用动态规划和贪心都是可以的，只不过使用贪心的代码和复杂度通常都会更简单。但是相应地，贪心的难点在于如何证明局部最优解就可以得到全局最优解。通过这几道题的学习，希望你能够明白覆盖类问题的套路，其底层都是一样的。明白了这些， 你回头再去看覆盖类的题目，或许会发现新的世界。
+
+我整理的 1000 多页的电子书已经开发下载了，大家可以去我的公众号《力扣加加》后台回复电子书获取。 
+
+![](https://cdn.jsdelivr.net/gh/azl397985856/cdn/2020-10-17/1602928846461-image.png)
+
+
+![](https://cdn.jsdelivr.net/gh/azl397985856/cdn/2020-10-17/1602928862442-image.png)
+
+
+大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
+
+大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。
 
-- 空间复杂度：我们使用了 furthest 数组， 因此空间复杂度为 $O(N)$。
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1gfcuzagjalj30p00dwabs.jpg)

thinkings/slide-window.md

@@ -90,6 +90,7 @@ class Solution:
 - [【904. 水果成篮】（Python3）](https://leetcode-cn.com/problems/fruit-into-baskets/solution/904-shui-guo-cheng-lan-python3-by-fe-lucifer/)
 - [【930. 和相同的二元子数组】（Java，Python）](https://leetcode-cn.com/problems/binary-subarrays-with-sum/solution/930-he-xiang-tong-de-er-yuan-zi-shu-zu-javapython-/)
 - [【992. K 个不同整数的子数组】滑动窗口（Python）](https://leetcode-cn.com/problems/subarrays-with-k-different-integers/solution/992-k-ge-bu-tong-zheng-shu-de-zi-shu-zu-hua-dong-c/)
+- [978. 最长湍流子数组](../problems/978.longest-turbulent-subarray.md)
 - [【1004. 最大连续 1 的个数 III】滑动窗口（Python3）](https://leetcode-cn.com/problems/max-consecutive-ones-iii/solution/1004-zui-da-lian-xu-1de-ge-shu-iii-hua-dong-chuang/)
 - [【1234. 替换子串得到平衡字符串】[Java/C++/Python] Sliding Window](https://leetcode.com/problems/replace-the-substring-for-balanced-string/discuss/408978/javacpython-sliding-window/367697)
 - [【1248. 统计「优美子数组」】滑动窗口（Python）](https://leetcode-cn.com/problems/count-number-of-nice-subarrays/solution/1248-tong-ji-you-mei-zi-shu-zu-hua-dong-chuang-kou/)