递归 Recursion
通过函数体来进行的循环，一种编程技巧。倒着思考，看到问题的尽头。思路简单但效率低（建立函数的副本，消耗大量时间和内存）。递归是分治和动态规划的基础，而贪心是动态规划中的一种特殊情况（局部最优也是全局最优）。
终止条件（最简子问题的答案） + 自身调用（解决子问题），不要试图去搞清楚函数内部如何实现的，就先认为它可以实现这个功能。
比如，遍历一颗树
def traverse(root):
if root is None:
return
for child in root.children:
traverse(child)
计算n阶乘，递归实现。
def Factorial(n):
if n <= 1: # 终止条件
return 1
return n*Factorial(n-1)
层层深入再回溯：
递归的代码模板：
def recursion(level, param1, param2, ...):
# recursion terminator
if level > MAX_LEVEL:
print_result
return
# process logic in current level
process_data(level, data, ...)
# drill down
recursion(level + 1, p1, ...)
# reverse the current level status if needed
reverse_state(level)
有些情况下递归处理问题是高效的，比如归并排序。但有些情况下，非常低效。比如斐波那契数列，显然递推是简单快速的，但如果非要递归但话也可以，低效。
Fibonacci数列，函数调用自身，注意递归的停止条件。分为调用和回溯两个阶段。
但是过程中存在大量重复计算，递归效率并不高。（因为存在重复的子问题，可以用判重或记录结果）
# 递归
class Solution:
def fib(self, N: int) -> int:
if N <= 1:
return N
return self.fib(N-1) + self.fib(N-2)
# 迭代
class Solution:
def fib(self, N: int) -> int:
if N <= 1:
return N
tmp1 = 0
tmp2 = 1
for i in range(2, N+1):
res = tmp1 + tmp2
tmp1 = tmp2
tmp2 = res
return res
任意长度的字符串反向，递归实现
# 需要额外存储空间
def reverseStr(string):
if string == None or len(string) == 0:
return None
if len(string) == 1:
return string
return reverseStr(string[1:])+string[0]
#leetcode，O(1)额外空间，原地修改。双指针
class Solution:
def reverseString(self, s: List[str]) -> None:
"""
Do not return anything, modify s in-place instead.
"""
if s == None or len(s) <= 1:
return None
i, j = 0, len(s)-1
while i<j:
s[i], s[j] = s[j], s[i]
i += 1
j -= 1
return
# 超时的递归解法
class Solution:
def reverseString(self, s: List[str]) -> None:
"""
Do not return anything, modify s in-place instead.
"""
if s == None or len(s) <= 1:
return None
cur = s.pop(0)
self.reverseString(s)
s.append(cur)
汉诺塔问题：
def move(n, a, b, c):
"""n个盘子从a借助b移动到c上"""
if n==1:
print(a+'->'+c)
else:
move(n-1, a, c, b)
move(1, a, b, c)
move(n-1, b, a, c)
回溯 backtrack
回溯算法可以抽象理解为一个N叉树的遍历，比如斐波那契数列可以理解成一个二叉树，而零钱兑换的例子就是一个N叉树。
# 二叉树遍历
def traverse(root):
if root is None:
return
# 前序代码在这
traverse(root.left)
# 中序代码在这
traverse(root.right)
# 后序代码在这
# N叉树遍历
def traverse(root):
if root is None:
return
for child in root.childen:
# 前序代码在这
traverse(child)
# 后序代码在这
回溯的代码模板：
def backtrack(choiceList, track, answer):
"""choiceList, 当前可以进行的选择列表
track, 决策路径，即已经作出的一系列选择
answer, 储存符合条件的决策路径
"""
if track is OK:
answer.add(track)
else:
for choice in choiceList:
# choose: 选择一个choice 加入track
backtrack(choices, track, answer)
# unchoose: 从track中撤销上面的选择
全排列问题：给定一个没有重复数字的序列，返回其所有可能的全排列。
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
if not nums:
return[[]]
ans = []
def backtrack(nums, track):
nonlocal ans
if not nums:
ans.append(track)
else:
for i in range(len(nums)):
# track加入当前选的nums[i], 下一层nums[i]也不能选了
backtrack(nums[:i]+nums[i+1:], track+[nums[i]])
# track自然的回退了，因为没有真的append上去
backtrack(nums, [])
return ans
子集：给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。解集不能包含重复的子集。
class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
ans = []
def backtrack(nums, track):
nonlocal ans
ans.append(track) # 每次都记录track
for i in range(len(nums)):
backtrack(nums[i+1:], track+[nums[i]])
backtrack(nums, [])
return ans
八皇后问题：
如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n×n，而皇后个数也变成n。当且仅当 n = 1 或 n ≥ 4 时问题有解。
当在棋盘上放置了几个皇后且不会相互攻击。但是选择的方案不是最优的，因为无法放置下一个皇后。此时该怎么做？回溯：回退一步，来改变最后放置皇后的位置并且接着往下放置。如果还是不行，再回溯。
一行只可能有一个皇后且一列也只可能有一个皇后。这意味着没有必要再棋盘上考虑所有的方格。按行往下找皇后，对于每个皇后的位置只需要按列循环即可。对于所有的主对角线有：行号 - 列号 = 常数，对于所有的次对角线有 行号 + 列号 = 常数。
class Solution:
def solveNQueens(self, n: int) -> List[List[str]]:
def could_place(row, col):
# row这一行是没有放置过的行，要检查col这一列、(row,col)所占两条对角线有没有被放置过，如果都没有，(row,col)可以放皇后
return not (cols[col]+hill_diagonals[row-col]+
dale_diagonals[row+col])
def place_queen(row, col):
queens.add((row, col)) # 放皇后，记录位置，标记列和两对角线
cols[col] = 1
hill_diagonals[row-col] = 1
dale_diagonals[row+col] = 1
def remove_queen(row, col):
queens.remove((row, col)) # 移除皇后，清空列和两对角线的标记
cols[col] = 0
hill_diagonals[row-col] = 0
dale_diagonals[row+col] = 0
def add_solution():
# 如果找到一个解，按要求记录下来
solution = []
for _, col in sorted(queens):
solution.append('.'*col + 'Q' + '.'*(n-col-1))
output.append(solution)
def backtrack(row):
# 从第一行row=0开始放置皇后，放到n-1行
for col in range(n): # 对于确定的row，遍历所有列col
if could_place(row, col):
place_queen(row, col) # 如果(row, col)可以放皇后，就放
if row == n-1: # 如果已经放了最后一个，说明找到一个解
add_solution()
else: # 没有放到最后一个的话
backtrack(row+1) # 去找row行之后所有可能的放置解法
remove_queen(row, col) # 不管是哪种情况都要回溯，移除当前皇后，进入(row, col+1)的情况
cols = [0] * n
hill_diagonals = [0] * (2 * n -1)
dale_diagonals = [0] * (2 * n -1)
queens = set()
output = []
backtrack(0)
return output
分治 Divde & Conquer
将问题分成几个小模块，逐一解决。典型的递归结构。分治可以高效率解决的，是没有中间结果（没有所谓的重复计算）的问题。 （适合的解决方法：动态规划、子问题记忆）
给定一个字符串，将小写字母变为大写。循环或者递归都可以。分治的做法：
子问题互不相关，可以并行计算。
典型的分治思想，归并排序。将数组分解最小之后，把n个记录看成是n个有序的子序列，每个子序列长度为1。然后两两归并，得到ceil(n/2)个长度为2或者1的有序子序列，再两两归并...，如此重复直到得到长度为n的有序序列为止。
用递归实现的话就很简洁，直接左右两边递归的归并排序，再merge左右两边就行了。
def merge_sort(alist):
if len(alist) <= 1:
return alist
# 二分分解
num = len(alist)//2
left = merge_sort(alist[:num])
right = merge_sort(alist[num:])
# 合并
return merge(left,right)
剩下的细节无非就是写一下如何合并两个有序数组，双指针同时向后扫，小的就放进结果指针后移，大的就指针不动。
def merge(left, right):
'''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
#left与right的下标指针
l, r = 0, 0
result = []
while l<len(left) and r<len(right):
if left[l] < right[r]:
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
if l < len(left):
result += left[l:]
elif r < len(right):
result += right[r:]
return result
完事了。用迭代写的话要利用mod的技巧来操作索引，还是比较繁琐的。代码放到排序https://www.cnblogs.com/chaojunwang-ml/p/11296423.html 中了。
分治的代码模板：
def divide_conquer(problem, param1, param2, ...):
# recursion terminator
if problem is None:
print_result
return
# prepare data
data = prepare_data(problem)
subproblems = split_problem(problem, data)
# conquer subproblems
subresult1 = divide_conquer(subproblems[0], p1, ...)
subresult2 = divide_conquer(subproblems[1], p1, ...)
...
# process and generate the final result
result = process_result(subresult1, subresult2, ...)
二分搜索，思路很简单，但细节很蛋疼。
# 最普通的情况，规定有序数组不重复
class Solution:
def search(self, nums: List[int], target: int) -> int:
if nums == None or len(nums) == 0:
return -1
low = 0
high = len(nums) - 1
while low <= high: # 双端闭区间[low, high]查找
mid = (low + high) // 2
if nums[mid] == target:
return mid
elif nums[mid] > target:
high = mid - 1
elif nums[mid] < target:
low = mid + 1
return -1
# 寻找左侧边界的二分搜索。初始化 right = nums.length，决定了「搜索区间」是 [left, right)，所以决定了 while (left < right)，同时也决定了 left = mid + 1 和 right = mid
# 因为需找到 target 的最左侧索引，所以当 nums[mid] == target 时不要立即返回，而要收紧右侧边界以锁定左侧边界。
def search(nums, target):
if nums == None or len(nums) == 0:
return -1
low = 0
high = len(nums)
while low < high: # [low, high) 上搜索
mid = (low + high) // 2
if nums[mid] == target:
high = mid # 找到target之后不要立即返回，缩小搜索区间上界，在[low, mid)中继续搜索，锁定左侧边界low
elif nums[mid] > target:
high = mid
elif nums[mid] < target:
low = mid + 1
if low == len(nums): # target 比所有数都大
return -1
return low if nums[low] == target else -1 # 如果找到，low应该指向左侧边界
# 寻找右侧边界的二分搜索
def search(nums, target):
if nums == None or len(nums) == 0:
return -1
low = 0
high = len(nums)
while low < high: # [low, high) 上搜索
mid = (low + high) // 2
if nums[mid] == target:
low = mid + 1 # 找到target之后不要立即返回，缩小搜索区间下界，在[mid+1, high)中继续搜索，锁定右侧边界high-1
elif nums[mid] > target:
high = mid
elif nums[mid] < target:
low = mid + 1
if low == len(nums): # target 比所有数都大
return -1
return low-1 if nums[low-1] == target else -1 # 若找到，最后low == high，右侧边界在 high-1
# 递归实现二分搜索，和迭代是一样的，因为没有重叠子问题
class Solution:
def search(self, nums: List[int], target: int) -> int:
if nums == None or len(nums) == 0:
return -1
return self.recursiveSearch(nums, 0, len(nums)-1, target)
def recursiveSearch(self, nums, low, high, target):
if low > high: # 双端闭区间搜索
return -1
mid = (low+high)//2
if nums[mid] == target:
return mid
elif nums[mid] > target:
return self.recursiveSearch(nums, low, mid-1, target)
elif nums[mid] < target:
return self.recursiveSearch(nums, mid+1, high, target)
return -1
贪心 Greedy
对问题求解的时候，总是做出在当前看来最优的选择。但处处做贪心，总体未必是最优的。
适用贪心的场景：问题能够分解成子问题来解决，子问题的最优解能够递推到最终问题的最优解。这种子问题最优解称为最优子结构。
贪心和动态规划的区别在于，它对每个子问题的解决方案都做出选择，不能回退。而动态规划会保存以前的运算结果，并根据以前的结果对当前进行选择，有回退功能。贪心可以看作是动态规划的一个特例。
手里有面额20、10、5、1元的四种纸币，问要凑够36元最少需要多少张。
每次先选最大面额的，不能选了再选次大的；...
经典贪心，Interval Scheduling（区间调度问题），算出给定的一组[start, end]区间中最多有几个互不相交的区间。例如 intvs = [[1, 3], [2, 4], [3, 6]]，最多有两个区间互不相交。边界相同不算相交。
1. 从区间集合中选出 end 最小的区间x；2.把所有和这个区间相交的区间从 intvs 中删除；3. 重复1.2. 直到intvs 为空。
可以先排个序，这样如果一个区间不和 x 相交的话，start必须要大于等于x_end
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
if not intervals:
return 0
n = len(intervals)
intervals.sort(key=lambda x: x[1]) # 先按 end 排序
count = 1 # 至少一个区间不相交
x_end = intervals[0][1]
for i in range(1, n):
if intervals[i][0] >= x_end: # 如果一个区间的start大于等于x_end，那么区间必然不相交x，计数并且更新x即可
count += 1
x_end = intervals[i][1]
return n-count
用最少的箭头射爆气球
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以y坐标并不重要，因此只要知道开始和结束的x坐标就足够了。开始坐标总是小于结束坐标。平面内最多存在104个气球。
一支弓箭可以沿着x轴从不同点完全垂直地射出。在坐标x处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。
这题和区间调度问题一摸一样，如果最多有n个不重叠区间，就至少需要n个箭头射爆气球。