Skip to content

Commit edd547b

Browse files
author
lucifer
committed
feat: $1658
1 parent 9aaa7d4 commit edd547b

File tree

7 files changed

+387
-6
lines changed

7 files changed

+387
-6
lines changed

‎91/binary-search.md‎

Lines changed: 97 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -372,6 +372,103 @@ function binarySearchRight(nums, target) {
372372

373373
```
374374

375+
### 寻找最左插入位置
376+
377+
上面我们讲了`寻找最左满足条件的值`。如果找不到，就返回 -1。那如果我想让你找不到不是返回 -1，而是应该插入的位置，使得插入之后列表仍然有序呢？
378+
379+
比如一个数组 nums: [1,3,4]，target 是 2。我们应该将其插入（注意不是真的插入）的位置是索引 1 的位置，即 [1,**2**,3,4]。因此`寻找最左插入位置`应该返回 1，而`寻找最左满足条件` 应该返回-1。
380+
381+
另外如果有多个满足条件的值，我们返回最左侧的。 比如一个数组 nums: [1,2,2,2,3,4]，target 是 2，我们应该插入的位置是 1。
382+
383+
不管是寻找最左插入位置还是后面的寻找最右插入位置，我们的更新指针代码都是一样的。即：
384+
385+
```
386+
l = mid + 1
387+
# or
388+
r = mid
389+
```
390+
391+
当然也有别的方式（比如 mid 不是向下取整，而是向上取整）， 但是这样可以最小化记忆成本。
392+
393+
#### 思维框架
394+
395+
- 首先定义搜索区间为 [left, right]，注意是左右都闭合，之后会用到这个点。
396+
397+
> 你可以定义别的搜索区间形式，不过后面的代码也相应要调整，感兴趣的可以试试别的搜索区间。
398+
399+
- 由于我们定义的搜索区间为 [left, right]，因此当 left <= right 的时候，搜索区间都不为空。 但由于上面提到了更新条件有一个`r = mid`，因此如果结束条件是 left <= right 则会死循环。因此结束条件是 left < right。
400+
401+
> 有的人有疑问，这样设置结束条件会不会漏过正确的解，其实不会。举个例子容易明白一点。 比如对于区间 [4,4]，其包含了一个元素 4，搜索区间不为空。如果我们的答案恰好是 4，会被错过么？不会，因为我们直接返回了 4。
402+
403+
- 循环体内，我们不断计算 mid ，并将 nums[mid] 与 目标值比对。
404+
- 如果 nums[mid] 大于等于目标值， r 也可能是目标解，r - 1 可能会错过解，因此我们使用 r = mid。
405+
- 如果 nums[mid] 小于目标值， mid 以及 mid 左侧都不可能是解，因此我们使用 l = mid + 1。
406+
- 最后直接返回 l 或者 r 即可。（并且不需要像`最左满足条件的值`那样判断了）
407+
408+
#### 代码模板
409+
410+
##### Python
411+
412+
```py
413+
def bisect_left(nums, x):
414+
# 内置 api
415+
bisect.bisect_left(nums, x)
416+
# 手写
417+
l, r = 0, len(nums) - 1
418+
while l < r:
419+
mid = (l + r) // 2
420+
if nums[mid] < x:
421+
l = mid + 1
422+
else:
423+
r = mid
424+
# 由于 l 和 r 相等，因此返回谁都无所谓。
425+
return l
426+
```
427+
428+
其他语言暂时空缺，欢迎 [PR](https://github.com/azl397985856/leetcode-cheat/issues/4)
429+
430+
### 寻找最右插入位置
431+
432+
#### 思维框架
433+
434+
和`寻找最左插入位置`类似。不同的地方在于：如果有多个满足条件的值，我们返回最右侧的。 比如一个数组 nums: [1,2,2,2,3,4]，target 是 2，我们应该插入的位置是 4。
435+
436+
- 首先定义搜索区间为 [left, right]，注意是左右都闭合，之后会用到这个点。
437+
438+
> 你可以定义别的搜索区间形式，不过后面的代码也相应要调整，感兴趣的可以试试别的搜索区间。
439+
440+
- 由于我们定义的搜索区间为 [left, right]，因此当 left <= right 的时候，搜索区间都不为空。 但由于上面提到了更新条件有一个`r = mid`，因此如果结束条件是 left <= right 则会死循环。因此结束条件是 left < right。
441+
442+
> 有的人有疑问，这样设置结束条件会不会漏过正确的解，其实不会。举个例子容易明白一点。 比如对于区间 [4,4]，其包含了一个元素 4，搜索区间不为空。如果我们的答案恰好是 4，会被错过么？不会，因为我们直接返回了 4。
443+
444+
- 循环体内，我们不断计算 mid ，并将 nums[mid] 与 目标值比对。
445+
- 如果 nums[mid] 小于等于目标值， mid 以及 mid 左侧都不可能是解，因此我们使用 l = mid + 1。
446+
- 如果 nums[mid] 大于目标值， r 也可能是目标解，r - 1 可能会错过解，因此我们使用 r = mid。
447+
- 最后直接返回 l 或者 r 即可。（并且不需要像`最左满足条件的值`那样判断了）
448+
449+
#### 代码模板
450+
451+
##### Python
452+
453+
```py
454+
455+
def bisect_right(nums, x):
456+
# 内置 api
457+
bisect.bisect_right(nums, x)
458+
# 手写
459+
l, r = 0, len(nums) - 1
460+
while l < r:
461+
mid = (l + r) // 2
462+
if nums[mid] > x:
463+
r = mid
464+
else:
465+
l = mid + 1
466+
# 由于 l 和 r 相等，因此返回谁都无所谓。
467+
return l
468+
```
469+
470+
其他语言暂时空缺，欢迎 [PR](https://github.com/azl397985856/leetcode-cheat/issues/4)
471+
375472
### 局部有序（先降后升或先升后降）
376473

377474
LeetCode 有原题 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) 和 [81. 搜索旋转排序数组 II](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/)， 我们直接拿过来讲解好了。

‎SUMMARY.md‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@
4444
* [一文看懂《最大子序列和问题》](./selected/LSS.md)
4545

4646

47-
* [第四章 - 高频考题（简单 73 题）](collections/easy.md)
47+
* [第四章 - 高频考题](collections/easy.md)
4848
* [面试题 17.12. BiNode](problems/binode-lcci.md)
4949
* [0001. 两数之和](problems/1.two-sum.md)
5050
* [0020. 有效的括号](problems/20.valid-parentheses.md)
@@ -87,7 +87,7 @@
8787
* [1332. 删除回文子序列](problems/1332.remove-palindromic-subsequences.md)
8888

8989

90-
* [第五章 - 高频考题（中等 118 题）](collections/medium.md)
90+
* [第五章 - 高频考题](collections/medium.md)
9191
* [0002. 两数相加](problems/2.add-two-numbers.md)
9292
* [0003. 无重复字符的最长子串](problems/3.longest-substring-without-repeating-characters.md)
9393
* [0005. 最长回文子串](problems/5.longest-palindromic-substring.md)
@@ -206,9 +206,10 @@
206206
* [1381. 设计一个支持增量操作的栈](../problems/1381.design-a-stack-with-increment-operation.md) 91
207207
* [1558. 得到目标数组的最少函数调用次数](../problems/1558.minimum-numbers-of-function-calls-to-make-target-array.md)
208208
* [1631. 最小体力消耗路径](problems/1631.path-with-minimum-effort.md)
209+
* [1658. 将 x 减到 0 的最小操作数](problems/1658.minimum-operations-to-reduce-x-to-zero.md)
209210

210211

211-
* [第六章 - 高频考题（困难 32 题）](collections/hard.md)
212+
* [第六章 - 高频考题](collections/hard.md)
212213
* [0004. 寻找两个正序数组的中位数](problems/4.median-of-two-sorted-arrays.md)
213214
* [0023. 合并K个升序链表](problems/23.merge-k-sorted-lists.md)
214215
* [0025. K 个一组翻转链表](problems/25.reverse-nodes-in-k-groups.md)

‎collections/medium.md‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -126,3 +126,4 @@
126126
- [1381. 设计一个支持增量操作的栈](../problems/1381.design-a-stack-with-increment-operation.md) 91
127127
- [1558. 得到目标数组的最少函数调用次数](../problems/1558.minimum-numbers-of-function-calls-to-make-target-array.md) 🆕
128128
- [1631.path-with-minimum-effort](../problems/1631.path-with-minimum-effort.md) 🆕
129+
- [1658. 将 x 减到 0 的最小操作数](../problems/1658.minimum-operations-to-reduce-x-to-zero.md) 🆕

‎problems/1658.minimum-operations-to-reduce-x-to-zero.md‎

Lines changed: 163 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,163 @@
1+
# 题目地址（1658. 将 x 减到 0 的最小操作数）
2+
3+
https://leetcode-cn.com/problems/minimum-operations-to-reduce-x-to-zero
4+
5+
## 题目描述
6+
7+
```
8+
给你一个整数数组 nums 和一个整数 x 。每一次操作时，你应当移除数组 nums 最左边或最右边的元素，然后从 x 中减去该元素的值。请注意，需要 修改 数组以供接下来的操作使用。
9+
10+
如果可以将 x 恰好 减到 0 ，返回 最小操作数 ；否则，返回 -1 。
11+
12+
 
13+
14+
示例 1：
15+
16+
输入：nums = [1,1,4,2,3], x = 5
17+
输出：2
18+
解释：最佳解决方案是移除后两个元素，将 x 减到 0 。
19+
示例 2：
20+
21+
输入：nums = [5,6,7,8,9], x = 4
22+
输出：-1
23+
示例 3：
24+
25+
输入：nums = [3,2,20,1,1,3], x = 10
26+
输出：5
27+
解释：最佳解决方案是移除后三个元素和前两个元素（总共 5 次操作），将 x 减到 0 。
28+
 
29+
30+
提示：
31+
32+
1 <= nums.length <= 10^5
33+
1 <= nums[i] <= 104
34+
1 <= x <= 109
35+
36+
```
37+
38+
## 前置知识
39+
40+
- 堆
41+
- [滑动窗口](../thinkings/slide-window.md)
42+
43+
## 公司
44+
45+
- 暂无
46+
47+
## 堆
48+
49+
### 思路
50+
51+
这里可以使用堆来解决。具体来说是我自己总结的**多路归并**题型。
52+
53+
> 关于这个算法套路，请期待后续的堆专题。
54+
55+
### 代码
56+
57+
代码支持：Python3
58+
59+
Python3 Code:
60+
61+
```py
62+
class Solution:
63+
def minOperations(self, nums: List[int], x: int) -> int:
64+
# 看数据范围，这种方法铁定超时（指数复杂度）
65+
h = [(0, 0, len(nums) - 1, x)]
66+
while h:
67+
moves,l,r,remain = heapq.heappop(h)
68+
if remain == 0: return moves
69+
if l + 1 < len(nums): heapq.heappush(h, (moves + 1, l + 1,r, remain-nums[l]))
70+
if r > 0: heapq.heappush(h, (moves + 1, l,r-1, remain-nums[r]))
71+
return -1
72+
73+
```
74+
75+
**复杂度分析**
76+
77+
- 时间复杂度：$O(2^moves)$，其中 moves 为题目答案。最坏情况 moves 和 N 同阶，也就是 $2^N$。
78+
- 空间复杂度：$O(1)$。
79+
80+
由于题目数组长度最大可以达到 10^5， 这提示我们此方法必然超时。
81+
82+
我们必须考虑时间复杂度更加优秀的方式。
83+
84+
## 动态规划（记忆化递归）
85+
86+
### 思路
87+
88+
由上面的解法， 我们不难想到使用动态规划来解决。
89+
90+
枚举所有的 l,r,x 组合，并找到最小的，其中 l 表示 左指针， r 表示右指针，x 表示剩余的数字。这里为了书写简单我使用了记忆化递归。
91+
92+
### 代码
93+
94+
代码支持：Python3
95+
96+
Python3 Code:
97+
98+
> Python 的 @lru_cache 是缓存计算结果的数据结构， None 表示不限制容量。
99+
100+
```py
101+
class Solution:
102+
def minOperations(self, nums: List[int], x: int) -> int:
103+
n = len(nums)
104+
105+
@lru_cache(None)
106+
def dp(l, r, x):
107+
if x == 0:
108+
return 0
109+
if x < 0 or r < 0 or l > len(nums) - 1:
110+
return n + 1
111+
return 1 + min(dp(l + 1, r, x - nums[l]), dp(l, r - 1, x - nums[r]))
112+
113+
ans = dp(0, len(nums) - 1, x)
114+
return -1 if ans > n else ans
115+
```
116+
117+
**复杂度分析**
118+
119+
- 时间复杂度：$O(N^2 * h)$，其中 N 为数组长度, h 为 x 的减少速度，最坏的情况可以达到三次方的复杂度。
120+
- 空间复杂度：$O(N)$，其中 N 为数组长度，这里的空间指的是递归栈的开销。
121+
122+
这种复杂度仍然无法通过 10^5 规模，需要继续优化算法。
123+
124+
## 滑动窗口
125+
126+
### 思路
127+
128+
实际上，我们也可以逆向思考。即：我们剩下的数组一定是原数组的中间部分。
129+
130+
那是不是就是说，我们只要知道数据中子序和等于 sum(nums) - x 的长度。用 nums 的长度减去它就好了？
131+
132+
由于我们的目标是`最小操作数`，因此我们只要求**和为定值的最长子序列**，这是一个典型的[滑动窗口问题](../thinkings/slide-window.md)。
133+
134+
### 代码
135+
136+
代码支持：Python3
137+
138+
Python3 Code:
139+
140+
```py
141+
class Solution:
142+
def minOperations(self, nums: List[int], x: int) -> int:
143+
# 逆向求解，滑动窗口
144+
i = 0
145+
target = sum(nums) - x
146+
win = 0
147+
ans = len(nums)
148+
if target == 0: return ans
149+
for j in range(len(nums)):
150+
win += nums[j]
151+
while i < j and win > target:
152+
win -= nums[i]
153+
i += 1
154+
if win == target:
155+
ans = min(ans, len(nums) - (j - i + 1))
156+
return -1 if ans == len(nums) else ans
157+
158+
```
159+
160+
**复杂度分析**
161+
162+
- 时间复杂度：$O(N)$，其中 N 为数组长度。
163+
- 空间复杂度：$O(1)$。

‎selected/LIS.md‎

Lines changed: 24 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -292,9 +292,32 @@ class Solution:
292292
- 时间复杂度：$$O(N ^ 2)$$
293293
- 空间复杂度：$$O(N)$$
294294

295+
## 优化
296+
297+
大家想看效率高的，其实也不难。 LIS 也可以用 **贪心 + 二分** 达到不错的效率。代码如下：
298+
299+
![](https://tva1.sinaimg.cn/large/0081Kckwly1gl6ajh887vj31zc0gmae6.jpg)
300+
301+
代码文字版如下：
302+
303+
```py
304+
class Solution:
305+
def lengthOfLIS(self, A: List[int]) -> int:
306+
d = []
307+
for a in A:
308+
i = bisect.bisect_left(d, a)
309+
if i < len(d):
310+
d[i] = a
311+
elif not d or d[-1] < a:
312+
d.append(a)
313+
return len(d)
314+
```
315+
295316
## More
296317

297-
其他的我就不一一说了。比如 [673. 最长递增子序列的个数](https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/) （滴滴面试题）。 不就是求出最长序列，之后再循环比对一次就可以得出答案了么？
318+
其他的我就不一一说了。
319+
320+
比如 [673. 最长递增子序列的个数](https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/) （滴滴面试题）。 不就是求出最长序列，之后再循环比对一次就可以得出答案了么？
298321

299322
[491. 递增子序列](https://leetcode-cn.com/problems/increasing-subsequences/) 由于需要找到所有的递增子序列，因此动态规划就不行了，妥妥回溯就行了，套一个模板就出来了。回溯的模板可以看我之前写的[回溯专题](https://github.com/azl397985856/leetcode/blob/master/problems/90.subsets-ii.md "回溯专题")。
300323

0 commit comments

Comments
 (0)