问题描述：【Two Pointers】75. Sort Colors
解题思路：
颜色排序。给一个 012 数组，0、1、2 分别代表红色、白色和蓝色，将数组升序排序。要求只能遍历数组一次，并使用常量级的空间。
这道题的 Follow up 说可以使用计数排序，但是计数排序需要遍历两遍数组。那么怎么遍历一次使得数组有序呢？
因为这个数组只有 0、1、2 三个元素，因此可以使用双指针做法：
- 设一个指针 red 指向开头，blue 指向末尾，从左到右遍历数组位置 i；
- 如果遇到 0（红色），就交换最左边去，red 向后移动一次；如果遇到 2 （蓝色），就交换到最右边去，blue 向前移动一次；这样 1 就会被保留在最中间；
- 注意：当 2 （蓝色）交换完毕后，数组在 i 处要停留一次，因为还需要继续检查被 2 交换回来的数字（比如 2 和 2 交换，如果不停留，交换回来的 2 就永远不能交换到后面了）；但是当遇到 0（红色）就不需要停留（因为交换回来的是 0），直接向后就可以。
- 当 i 和 blue 相遇，说明所有的 0 和 1 都在 i 之前排好了，在 blue 之后都是 2，这时候结束遍历，得到的就是排序好的数组。
以 nums = [2,1,0,1,0,2] 为例：
- red 指向开头 nums[0] = 2，blue 指向末尾 nums[5] = 2，从左到右遍历；
- i = 0，碰到 2，nums[0] 和 nums[5] 交换，得到 [2,1,0,1,0,2]，blue 向前指向 nums[4] = 0，这时数组要在 i = 0 处停留一下（不然交换回来的 2 就永远交换不到后面了）；
- i = 0，碰到 2，nums[0] 和 nums[4] 交换，得到 [0,1,0,1,2,2]，blue 向前指向 nums[3] = 1，数组还在 i = 0 处停留；
- i = 0，碰到 0，nums[0] 和 nums[0] 交换，得到 [0,1,0,1,2,2]，red 向后指向 nums[1] = 1，数组向后滑动到 i = 1 处；
- i = 1，碰到 1，什么都不操作，数组向后滑动到 i = 2 处；
- i = 2，碰到 0，nums[1] 和 nums[2] 交换，得到 [0,0,1,1,2,2]，red 向后指向 nums[2] = 1，数组向后滑动到 i = 3 处；
- i 和 blue 相遇，结束，数组排序完毕。
这样，我们使用双指针，只遍历了一次数组，同时使用了常量级别的空间复杂度，就完成了排序，满足题意。
Python3 实现：
class Solution:
def sortColors(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
red, blue = 0, len(nums) - 1
i = 0
while i <= blue:
if nums[i] == 0: # 交换到前面
nums[i], nums[red] = nums[red], nums[i]
red += 1
elif nums[i] == 2: # 交换到后面
nums[i], nums[blue] = nums[blue], nums[i]
blue -= 1
i -= 1 # 2交换到后面，数组在i处停留
i += 1
问题描述：【Divide and Conquer、Binary Search】153. Find Minimum in Rotated Sorted Array
解题思路：
这道题是给一个按照升序排列的旋转数组，找到旋转有序数组的最小值。
很明显，要用 O(logN) 的算法去求解。因为旋转有序数组的特殊性，故能想到用分治和二分查找两种算法求解。
方法1（分治）：
1、比如 [3,4,5,1,2]、[4,5,1,2,3]，我们发现：对于中间的数字 nums[mid]，它左右两边不满足 nums[mid-1] < nums[mid] < nums[mid+1]，那么说明最小值肯定是在这相邻三个数之间，直接返回三个数中的最小值即可；
2、再比如 [5,1,2,3,4]、[1,2,3,4,5]、[2,3,4,5,1]，中间的数字满足 nums[mid-1] < nums[mid] < nums[mid+1]，那么最小值就在 nums[:mid] 或 nums[mid+1:] 之中，可以采取分治的算法在这两部分中找最小值；
3、递归函数还有一个出口，就是如果 len(nums) <= 2，直接返回 nums 中的最小值即可，防止进行 nums[mid-1] < nums[mid] < nums[mid+1] 比较时数组越界。
Python3 实现：
class Solution:
def findMin(self, nums: List[int]) -> int:
if len(nums) <= 2: # 最小值出口2
return min(nums)
mid = (len(nums) - 1) // 2 # 计算中间的坐标
if nums[mid-1] < nums[mid] < nums[mid+1]:
return min(self.findMin(nums[:mid]), self.findMin(nums[mid+1:])) # 分治求解
else:
return min(nums[mid-1], nums[mid], nums[mid+1]) # 最小值出口1
方法1（二分查找）：
二分查找的思想是每次中间的数字和最后一个数字比较。如果 nums[mid] < nums[high]，说明最小值在 nums[:mid+1] 中，更新 high 为 mid；如果 nums[mid] > nums[high]，说明最小值在 nums[mid+1:] 中，更新 low 为 mid + 1；最后 nums[low] 就是最小值。**
举例，nums = [5,6,1,2,3,4]，low = 0，high = 5，mid = 2
- nums[mid] < nums[high]，则 high = mid = 2，mid = 1；
- nums[mid] > nums[high]，则 low = mid + 1 = 2；
- 不满足 low < high，退出，nums[low] = 1 就是最小值。
Python3 实现：
class Solution:
def findMin(self, nums: List[int]) -> int:
low, high = 0, len(nums) - 1
while low < high:
mid = low + (high - low) // 2
if nums[mid] < nums[high]: # [5,6,1,2,3,4] -> high = mid
high = mid
elif nums[mid] > nums[high]:
low = mid + 1
return nums[low]
问题描述：【Math】795. Number of Subarrays with Bounded Maximum
解题思路：
这道题是给一个数组，求最大值大于等于 L 且小于等于 R 的连续子数组个数。
首先看了一下数据范围，采取 O(n^2) 的暴力求解方法肯定超时，排序又不行，因此只能使用 O(n) 的解法。又思考了 DP 发现貌似也不可行，因此就只能从数学上找找规律了。
以 A = [73,55,36,5,55,14,9,7,72,52]，L = 32，R = 69 为例：
1、因为是连续子数组，所以可以根据 A[i] > R 进行分段。以上述为例，可以分为 3 段，即 [73]、[55,36,5,55,14,9,7]、[72,52]；
2、以中间一段为例，共有 21 个符合题意的子数组。那么这个 21 是怎么计算得到的呢？首先，总共有 (1+7) * 7 // 2 = 28 个子数组，然后我们排除连续的 A[i] < L 的子数组个数，即 [5] 和 [14,9,7]，共有 1 + (1+3) * 3 // 2 = 7 个子数组，因此就得到了该段子数组的个数为 21；
3、每一段都进行这样的操作，就可以得到最终结果 ans = 0 + 21 + 1 = 22。
代码实现细节：
- 使用两个变量 cntLessR 和 cntLessL 分别记录小于等于 R 的连续子数组长度和小于 L 的连续子数组长度，对结果 ans 进行累加 cntLessR，同时累减 cntLessL；
- 如果 A[i] >= L，说明小于 L 的子数组不连续，则置 cntLessL 为 0； 如果 A[i] > R，说明小于等于 R 的子数组不连续，则置 cntLessR 为 0；
这种做法的时间复杂度为 O(N)，空间复杂度为 O(1)。
Python3 实现：
class Solution:
def numSubarrayBoundedMax(self, A: List[int], L: int, R: int) -> int:
ans = 0
cntLessR = 0 # 记录小于R的连续子数组长度
cntLessL = 0 # 记录小于L的连续子数组长度
for i in range(len(A)):
if A[i] <= R: # 小于R的连续子数组个数累加
cntLessR += 1
ans += cntLessR
if A[i] < L: # 小于L的连续子数组个数累减
cntLessL += 1
ans -= cntLessL
if A[i] >= L: # 不连续，将cntLessL置0
cntLessL = 0
if A[i] > R: # 不连续，将cntLessR置0
cntLessR = 0
return ans
问题描述：【Sort】945. Minimum Increment to Make Array Unique
解题思路：
这道题是给一个数组，每次移动可以把一个数字增加 1，最后使得数组元素都不同，求最小移动次数。
首先看了数据范围，O(n^2) 的暴力解法肯定会超时，先 pass。可以先对数组升序排序，然后使用一个变量保存当前不重复的数字已经增加到哪里了。所以，当下一个数字到来的时候，它应该增加到这个数字的位置，可以直接求出它需要移动的次数。
举个例子，A = [1,1,1,2,5,5]（已经排序），用 pre 记录不重复数字增加到了哪里，pre 初始化为 A[0]，即 pre = 1，用 ans 累加结果
- A[1] <= pre，说明 A[1] 要向后移动，则将 pre += 1 = 2，表示 A[1] 移动到 2 的位置，ans += pre - A[1] = 1；
- A[2] <= pre，说明 A[2] 要向后移动，则将 pre += 1 = 3，表示 A[2] 移动到 3 的位置，ans += pre - A[2] = 3；
- A[3] <= pre，说明 A[3] 要向后移动，则将 pre += 1 = 4，表示 A[3] 移动到 4 的位置，ans += pre - A[3] = 5；
- A[4] > pre，说明 A[4] 不需要向后移动，保持在自己的位置就好，但是要把 pre 更新到 pre = A[4] = 5，表示下一次从 5 开始移动；因为没有移动，ans 不变；
- A[5] <= pre，说明 A[5] 要向后移动，则将 pre += 1 = 6，表示 A[5] 移动到 6的位置，ans += pre - A[5] = 6；
- 结束，最少移动次数为 ans = 6。
Python3 实现：
class Solution:
def minIncrementForUnique(self, A: List[int]) -> int:
N = len(A)
if N == 0:
return 0
A.sort() # 升序排序
ans = 0
pre = A[0] # 记录当前不重复的数字已经增加到哪里了
for i in range(1, N):
if A[i] <= pre:
pre += 1
ans += pre - A[i]
else:
pre = A[i]
return ans
问题描述：【DP】1109. Corporate Flight Bookings
解题思路：
这道题是给一个航班行程，每一项 (i, j, k) 表示在 [i, j] 之间预定 k 个座位。求每一时刻预定的座位数。
这道题和 Leetcode 【Greedy、DP、DP2】1094. Car Pooling 拼车问题以及 Leetcode 253：Meeting Rooms II（超详细的解法！！！） 几乎一模一样。刚开始使用 Leetcode 194 中的方法 2，结果超时，但是使用方法 3 不会超时。
Leetcode 1094 方法 3 的做法是对于每个区间，左加右减人数；而这道题也类似，不过根据题意，只有超过右端点才减，因为我们的统计要包括右端点。最后，循环 n 次，对于 dp[i] 进行累加即可得到各个时刻座位数。
时间复杂度和空间复杂度均为 O(N)。注意：dp 大小为 N + 2 而不是 N + 1，因为我们到 dp[i+1] 还要执行相减操作。
举个例子： bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5
- 对于 (1, 2, 10)，dp[1] += 10 = 10，dp[2+1] -= 10 = -10 （因为我们要统计右端点，所以要到 dp[3] 才执行相减操作）；
- 对于 (2, 3, 20)，dp[2] += 20 = 20，dp[3+1] -= 20 = -20；
- 对于 (2, 5, 25)，dp[2] += 25 = 45，dp[5+1] -= 45 = -45；
- 循环 n 次，累加，ans[1] = dp[1] = 10，ans[2] = dp[1] + dp[2] = 55，ans[3] = dp[1] + dp[2] + dp[3] = 45，ans[4] = dp[1] + dp[2] + dp[3] + dp[4] = 25，ans[5] = dp[1] + dp[2] + dp[3] + dp[4] + dp[5] = 25。
- 最终答案为 ans = [10, 55, 45, 25, 25]。
Python3 实现：
class Solution:
def corpFlightBookings(self, bookings: List[List[int]], n: int) -> List[int]:
dp = [0] * 20002
for (i, j, k) in bookings:
dp[i] += k
dp[j+1] -= k # 右端点要包括在内，所以到j+1时再减
cnt = 0
ans = []
for i in range(1, n + 1):
cnt += dp[i]
ans.append(cnt)
return ans
