算法40讲

找女朋友问题
· 如果能够后悔 o(n)
· 如果不能后悔

priority queue 一个任务的密度=重要程度/完成时间（始终完成最紧迫的工作）
kelly formula 凯利公式
game theory 博弈论

五个代码的模板（手写）
1、递归的终止条件

# 递归
def recurison(level, param1, param2):
    
    # recursion terminator
    if level > max_level:
        print_result
        return 
    
    # process logic in current level
    process_data(lecel,data...)
    
    # drill down 可能是一行也可能是两行
    self.recursion(level+1, p1, ...)
    
    # reverse the current level status
    recerse.state(level)

BFS

def BFS(graph, start, end):

    queue = []
    queue.append([start])
    visited.add(start)
    
    while queue:
        node = queue.pop() # 当前节点弹出
        visited.add(node)
        
        process(node)
        nodes = generate_related_nodes(note)
        queue.push(nodes)
        
    # other processinf work

二分法

left, right = 0, len(array) - 1
while left <= right:
    mid = left + (right - left)/2
    if array[mid] == target:
        # find the target!
        break or return result
    elif array[mid] < target:
        left = mid + 1
    else:
        right = mid - 1

动态规划

# 状态定义
dp = new int [m + 1][n + 1]

# 初始状态
dp[0][0] = x;
dp[0][1] = y;

# DP状态的推导
for i = 0; i <= n; i ++{
    for j = 0; j <= m; ++j{
        ...
        dp[i][j] = min{dp[i-1][j], dp[i][j-1], etc.}
    }
}
return dp[m][n] # 最优解

反转链表

前面的赋值的前半部分不会影响后半部分的值

def reverselist(self, head):
    cur, prev = head, None
    while cur:
        cur.next, prev, cur = prev, cur, cur.next
    return prev

两两链表交换相邻元素

def swappairs(self, head):
    result = ListNode(0)
    pre, pre.next = result, head
    while pre.next and pre.next.next:
        a = pre.next
        b = a.next
        pre.next, b.next, a.next = b, a, b.next
        pre = a
    return result.next

持续练习 + 精深练习
1、除了做熟悉和会做的题目之外，去刻意练习自己不熟悉的算法和数据结构
2、做过的题目后续要返回再复习

面试答题四件套
1、搞清楚题目到底要干嘛（询问题目细节，边界条件，可能的极端错误情况）
2、可能的解决方法（所有可能的解法都和面试官沟通一遍）
时间复杂度，空间复杂度
最优解
3、写代码
4、测试用例

斐波拉契数列