黄金比例编程python_Leetcode 常用算法 Python 模板

小 trick

overlap条件：start1 < end2 and end1 > start2

在DFS中我们说关键点是递归以及回溯，在BFS中，关键点则是状态的选取和标记

树算法

Binary Indexed Tree BIT 树状数组

class BIT:

def __init__(self, n):

self.n = n + 1

self.sums = [0] * self.n

def update(self, i, delta):

while i < self.n:

self.sums[i] += delta

i += i & (-i) # = i & (~i + 1) 用于追踪最低位的1

def prefixSum(self, i):

res = 0

while i > 0:

res += self.sums[i]

i -= i & (-i)

return res

def rangeSum(self, s, e):

return self.prefixSum(e) - self.prefixSum(s - 1)

Binary Search Tree

class Node(object):

def __init__(self, data):

self.left = None

self.right = None

self.data = data

def insert(self, data):

if self.data:

if data < self.data:

if self.left is None:

self.left = Node(data)

else:

self.left.insert(data)

elif data > self.data:

if self.right is None:

self.right = Node(data)

else:

self.right.insert(data)

else:

self.data = data

def search(self, data, parent=None):

if data < self.data:

if self.left is None:

return None, None

return self.left.search(data, self)

elif data > self.data:

if self.right is None:

return None, None

return self.right.search(data, self)

else:

return self, parent

Trie

import collections

class TrieNode():

def __init__(self):

self.children = collections.defaultdict(TrieNode)

self.isEnd = False

class Trie():

def __init__(self):

self.root = TrieNode()

def insert(self, word):

node = self.root

for w in word:

node = node.children[w]

node.isEnd = True

def search(self, word):

node = self.root

for w in word:

# dict.get() 找不到的话返回None

node = node.children.get(w)

if not node:

return False

return node.isEnd

线段树

class SegmentTree(object):

def __init__(self, nums, s=None, e=None): # build

self.lo, self.hi = s, e

self.left, self.right = None, None

self.mid = (self.lo+self.hi)/2

self.val = 0

if self.hi < self.lo:

return

elif self.hi == self.lo:

self.val = nums[self.lo]

else: # self.lo < self.hi

self.left = SegmentTree(nums, self.lo, self.mid)

self.right = SegmentTree(nums, self.mid+1, self.hi)

self.val = self.left.val + self.right.val

def update(self, i, val): # modify

if i == self.lo == self.hi:

self.val = val

else:

if i <= self.mid:

self.left.update(i, val)

else:

self.right.update(i, val)

self.val = self.left.val + self.right.val

def sumRange(self, i, j): # query

if i == self.lo and j == self.hi: # equal

return self.val

elif self.lo > j or self.hi < i: # not intersect

return 0

else: # intersect

if i > self.mid: # all at the right sub tree

return self.right.sumRange(i, j)

elif j <= self.mid: # all at the left sub tree

return self.left.sumRange(i, j)

else: # some at the right & some at the left

return self.left.sumRange(i, self.mid) + self.right.sumRange(self.mid+1, j)

def get(self, i):

if self.lo == self.hi == i:

return self.val

elif self.lo > i or self.hi < i:

return 0

else:

if i > self.mid: # right

return self.right.get(i)

else: # left

return self.left.get(i)

排序算法

快速选择

quick select

def partition(nums, lo, hi):

i, x = lo, nums[hi]

for j in range(lo, hi):

if nums[j] <= x:

nums[i], nums[j] = nums[j], nums[i]

i += 1

nums[i], nums[hi] = nums[hi], nums[i]

return i

def quick_select(nums, lo, hi, k):

while lo < hi:

mid = partition(nums, lo, hi)

if mid == k:

return nums[k]

elif mid < k:

lo = mid+1

else:

hi = mid-1

nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]

for i in range(len(nums)):

print(quick_select(nums, 0, len(nums)-1, i))

selection sort

def selection_sort(nums):

for i in range(len(nums), 0, -1):

tmp = 0

for j in range(i):

if not compare(nums[j], nums[tmp]):

tmp = j

nums[tmp], nums[i-1] = nums[i-1], nums[tmp]

return nums

quick sort, in-place

def quick_sort(nums, l, r):

if l >= r:

return

pos = partition(nums, l, r)

quick_sort(nums, l, pos-1)

quick_sort(nums, pos+1, r)

def partition(nums, lo, hi):

i, x = lo, nums[hi]

for j in range(lo, hi):

if nums[j] <= x:

nums[i], nums[j] = nums[j], nums[i]

i += 1

nums[i], nums[hi] = nums[hi], nums[i]

return i

arr = [4, 2, 1, 23, 2, 4, 2, 3]

quick_sort(arr, 0, len(arr)-1)

print(arr)

bubble sort

def bubble_sort(nums):

for i in reversed(range(len(nums))):

for j in range(i-1):

if not compare(nums[j], nums[j+1]):

nums[j], nums[j+1] = nums[j+1], nums[j]

return nums

insertion sort

def insertion_sort(nums):

for i in range(len(nums)):

pos, cur = i, nums[i]

while pos > 0 and not compare(nums[pos-1], cur):

nums[pos] = nums[pos-1] # move one-step forward

pos -= 1

nums[pos] = cur

return nums

merge sort

def merge_sort(nums):

nums = mergeSort(nums, 0, len(nums)-1)

return str(int("".join(map(str, nums))))

def mergeSort(nums, l, r):

if l > r:

return

if l == r:

return [nums[l]]

mid = (r+l)//2

left = mergeSort(nums, l, mid)

right = mergeSort(nums, mid+1, r)

return merge(left, right)

def merge(l1, l2):

res, i, j = [], 0, 0

while i < len(l1) and j < len(l2):

if not compare(l1[i], l2[j]):

res.append(l2[j])

j += 1

else:

res.append(l1[i])

i += 1

res.extend(l1[i:] or l2[j:]) # 喵

return res

图论算法

拓扑排序

两个defaultdict 一个graph，一个in_degree

from collections import defaultdict

def findOrder(numCourses, prerequisites):

graph = defaultdict(list)

in_degree = defaultdict(int)

for dest, src in prerequisites:

graph[src].append(dest)

in_degree[dest] += 1

zero_degree = [k for k, v in in_degree.items() if v == 0]

res = []

while zero_degree:

node = zero_degree.pop(0)

res.append(node)

for child in graph[node]:

in_degree[child] -= 1

if in_degree[child] == 0:

zero_degree.append(child) # 同时也说这个元素该删除了

return res

普利姆(Prime)算法

每个节点选cost最小的边

from collections import defaultdict

import heapq

def prim(vertexs, edges):

adjacent_vertex = defaultdict(list)

for v1, v2, length in edges:

adjacent_vertex[v1].append((length, v1, v2))

adjacent_vertex[v2].append((length, v2, v1))

"""经过上述操作，将edges列表中各项归类成以某点为dictionary的key，其value则是其相邻的点以及边长。如下：defaultdict(, {'A': [(7, 'A', 'B'), (5, 'A', 'D')],'C': [(8, 'C', 'B'), (5, 'C', 'E')],'B': [(7, 'B', 'A'), (8, 'B', 'C'), (9, 'B', 'D'), (7, 'B', 'E')],'E': [(7, 'E', 'B'), (5, 'E', 'C'), (15, 'E', 'D'), (8, 'E', 'F'), (9, 'E', 'G')],'D': [(5, 'D', 'A'), (9, 'D', 'B'), (15, 'D', 'E'), (6, 'D', 'F')],'G': [(9, 'G', 'E'), (11, 'G', 'F')],'F': [(6, 'F', 'D'), (8, 'F', 'E'), (11, 'F', 'G')]})"""

res = [] # 存储最小生成树结果

# vertexs是顶点列表，vertexs = list("ABCDEFG") == = > vertexs = ['A', 'B', 'C', 'D', 'E', 'F', 'G']

visited = set(vertexs[0])

# 得到adjacent_vertexs_edges中顶点是'A'(nodes[0]='A')的相邻点list，即adjacent_vertexs['A']=[(7,'A','B'),(5,'A','D')]

adjacent_vertexs_edges = adjacent_vertex[vertexs[0]]

# 将usable_edges加入到堆中，并能够实现用heappop从其中动态取出最小值。关于heapq模块功能，参考python官方文档

heapq.heapify(adjacent_vertexs_edges)

while adjacent_vertexs_edges:

# 得到某个定点(做为adjacent_vertexs_edges的键)与相邻点距离(相邻点和边长/距离做为该键的值)最小值

w, v1, v2 = heapq.heappop(adjacent_vertexs_edges)

if v2 not in visited:

# 在used中有第一选定的点'A'，上面得到了距离A点最近的点'D',举例是5。将'd'追加到used中

visited.add(v2)

# 将v1,v2,w，第一次循环就是('A','D',5) append into res

res.append((v1, v2, w))

# 再找与d相邻的点，如果没有在heap中，则应用heappush压入堆内，以加入排序行列

for next_vertex in adjacent_vertex[v2]:

if next_vertex[2] not in visited:

heapq.heappush(adjacent_vertexs_edges, next_vertex)

return res

# test

vertexs = list("ABCDEFG")

edges = [("A", "B", 7), ("A", "D", 5),

("B", "C", 8), ("B", "D", 9),

("B", "E", 7), ("C", "E", 5),

("D", "E", 15), ("D", "F", 6),

("E", "F", 8), ("E", "G", 9),

("F", "G", 11)]

print("edges:", edges)

print("prim:", prim(vertexs, edges))

Dijkstra[单源最短路径算法]Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径

以起始点为中心向外层层扩展，直到扩展到终点为止

要求图中不存在负权边

import sys

def dijkstra(graph):

n = len(graph)

dist = [sys.maxsize] * n

dist[0] = 0 # 自己和自己距离为0

visited = set()

def minDistance():

# 找到还没确定的里面距离最小的

min_ans, min_index = min((dis, i)

for i, dis in enumerate(dist) if i not in visited)

return min_index

for _ in range(n):

min_index = minDistance()

# 已经确定了

visited.add(min_index)

for v in range(n):

if v not in visited and graph[min_index][v] > 0:

# graph[min_index][v] > 0 表示存在这个路径

new_dist = dist[min_index] + graph[min_index][v]

if dist[v] > new_dist: # 表示值得被更新

dist[v] = new_dist

print(dist)

# Driver program

graph = [[0, 4, 0, 0, 0, 0, 0, 8, 0],

[4, 0, 8, 0, 0, 0, 0, 11, 0],

[0, 8, 0, 7, 0, 4, 0, 0, 2],

[0, 0, 7, 0, 9, 14, 0, 0, 0],

[0, 0, 0, 9, 0, 10, 0, 0, 0],

[0, 0, 4, 14, 10, 0, 2, 0, 0],

[0, 0, 0, 0, 0, 2, 0, 1, 6],

[8, 11, 0, 0, 0, 0, 1, 0, 7],

[0, 0, 2, 0, 0, 0, 6, 7, 0]]

dijkstra(graph)

Floyd[任意两点间的最短路径]

a.从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。

b.对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是更新它。

Inf = 65535 # 代表无穷大

arr = [[0, 10, Inf, Inf, Inf, 11, Inf, Inf, Inf], # 邻接矩阵

[10, 0, 18, Inf, Inf, Inf, 16, Inf, 12],

[Inf, 18, 0, 22, Inf, Inf, Inf, Inf, 8],

[Inf, Inf, 22, 0, 20, Inf, Inf, 16, 21],

[Inf, Inf, Inf, 20, 0, 26, Inf, 7, Inf],

[11, Inf, Inf, Inf, 26, 0, 17, Inf, Inf],

[Inf, 16, Inf, 24, Inf, 17, 0, 19, Inf],

[Inf, Inf, Inf, 16, 7, Inf, 19, 0, Inf],

[Inf, 12, 8, 21, Inf, Inf, Inf, Inf, 0]]

n = len(arr) # 邻接矩阵大小

path = [[-1]*n for _ in range(n)]

for k in range(n): # k在第一层

for i in range(n):

for j in range(n):

if(arr[i][j] > arr[i][k]+arr[k][j]): # 两个顶点直接较小的间接路径替换较大的直接路径

arr[i][j] = arr[i][k]+arr[k][j]

path[i][j] = k # 记录新路径的前驱

for x in arr:

print(x)

print()

for x in path:

print(x)

字符串算法

KMP

class Solution(object):

def strStr(self, haystack, needle):

""":type haystack: str:type needle: str:rtype: int"""

if not needle: return 0

# build next

next = [0]*len(needle)

l, r = 0, 1

while r < len(needle):

if needle[l] == needle[r]:

next[r] = l+1

l, r = l+1, r+1

elif l: l = next[l-1]

else: r += 1

# find idx

l, r = 0, 0

while r < len(haystack):

if needle[l] == haystack[r]:

if l == len(needle)-1:

return r-l

l, r = l+1, r+1

elif l: l = next[l-1]

else: r += 1

return -1

Rabin-Karp Hash

class RabinKarpHash:

def __init__(self, base, mod=int(1e9+7)):

self.base = base

self.mod = mod

def hash(self, arr):

h = 0

for val in arr:

h = ((h * self.base) + val) % self.mod

return h

def roll(self, origin_hash, drop_val, new_val, max_base):

h = origin_hash - (drop_val * max_base % self.mod)

h = ((h*self.base)+new_val+self.mod)%self.mod

return h

def get_max_base(self, length):

ret = 1

for i in range(length-1):

ret = (ret*self.base) % self.mod

return ret

Manacher’s Algorithm

def findLongestPalindromicString(text):

length = len(text)

if length == 0:

return

N = 2*length+1 # Position count

L = [0] * N

L[0] = 0

L[1] = 1

C = 1 # centerPosition

R = 2 # centerRightPosition

i = 0 # currentRightPosition

iMirror = 0 # currentLeftPosition

maxLPSLength = 0

maxLPSCenterPosition = 0

diff = -1

for i in range(2, N):

# get currentLeftPosition iMirror for currentRightPosition i

iMirror = 2*C-i

L[i] = 0 # 初始化范围

diff = R - i # 当前位置离上一个边界的距离

# If currentRightPosition i is within centerRightPosition R

if diff > 0: # 利用对称性获取L[i]的最小值

L[i] = min(L[iMirror], diff)

# 计算当前palindrome长度

while (True):

# 边界条件

con1 = (i + L[i]) < N and (i - L[i]) > 0

if (not con1):

break

# 奇数位置需要比较char

# 偶数位置直接加一

con2 = (i + L[i]) % 2 == 1

left_radius = int((i + L[i] + 1) / 2)

right_radius = int((i - L[i] - 1) / 2)

con31 = 0 <= left_radius and left_radius < length

con32 = 0 <= right_radius and right_radius < length

con3 = con31 and con32 and (text[left_radius] == text[right_radius])

if(con2 or con3):

L[i] += 1

else:

break

if L[i] > maxLPSLength: # Track maxLPSLength

maxLPSLength = L[i]

maxLPSCenterPosition = i

# 触及上一个边界的话选择center

if i + L[i] > R:

C = i

# 更新边界为当前的边界

R = i + L[i]

# Uncomment it to print LPS Length array

# printf("%d ", L[i]);

start = int((maxLPSCenterPosition - maxLPSLength) / 2)

end = int(start + maxLPSLength)

print(text[start:end])

# Driver program

text1 = "babcbabcbaccba"

findLongestPalindromicString(text1)

链表相关

优雅地遍历链表

while head:

head = head.next

standard linked list reversing

class Solution:

def reverseList(self, head):

cur, prev = head, None

while cur:

cur.next, cur, prev = prev, cur.next, cur # standard reversing

return prev

merge sort list

class Solution(object):

def merge(self, h1, h2):

dummy = tail = ListNode(None)

while h1 and h2:

if h1.val < h2.val:

tail.next, tail, h1 = h1, h1, h1.next

else:

tail.next, tail, h2 = h2, h2, h2.next

tail.next = h1 or h2

return dummy.next

def sortList(self, head):

if not head or not head.next:

return head

pre, slow, fast = None, head, head

while fast and fast.next:

pre, slow, fast = slow, slow.next, fast.next.next

pre.next = None

return self.merge(self.sortList(head), self.sortList(slow))

二分

标准二分(bisect)

永远是lo = mid+1， hi = mid，返回lo,lo=0, hi=n

# 等价于 bisect

# 保证 选的数>k 严格大于

def bisect_right(a, x, lo=0, hi=None):

lo, hi = 0, n

while lo < hi:

mid = (lo+hi)//2

if x < a[mid]:

hi = mid # disgard equals part

else:

lo = mid+1

return lo

# bisect_left is more useful at hand, since it returns the exact index of the element being looked up if it is present in the list

# 保证 选的数>=k 大于等于

def bisect_left(a, x, lo=0, hi=None):

lo, hi = 0, n

while lo < hi:

mid = (lo+hi)//2

if a[mid] < x:

lo = mid+1 # disgard equals part

else:

hi = mid

return lo

>>> import bisect

>>> bisect.bisect_left([1,2,3], 2)

1

>>> bisect.bisect_right([1,2,3], 2)

2

范围都是[0-n]

import bisect

print(bisect.bisect_left([1, 2, 3], -1)) # 0

print(bisect.bisect_left([1, 2, 3], 0)) # 0

print(bisect.bisect_left([1, 2, 3], 1)) # 0

print(bisect.bisect_left([1, 2, 3], 2)) # 1

print(bisect.bisect_left([1, 2, 3], 3)) # 2

print(bisect.bisect_left([1, 2, 3], 4)) # 3

print(bisect.bisect([1, 2, 3], -1)) # 0

print(bisect.bisect([1, 2, 3], 0)) # 0

print(bisect.bisect([1, 2, 3], 1)) # 1

print(bisect.bisect([1, 2, 3], 2)) # 2

print(bisect.bisect([1, 2, 3], 3)) # 3

print(bisect.bisect([1, 2, 3], 4)) # 3

二分最优问题

都是 (lo+hi)//2， helper(mid) >= K， hi = mid-1， lo = mid+1

# 最大

# 找到最大的mid使得helper(mid)>=K

lo, hi = 1, sum(sweetness)

while lo <= hi:

# 找到最大的mid使得count>=K

mid = (lo+hi)//2

if helper(mid) >= K: # mid还可以再大一点

lo = mid+1

else:

hi = mid-1

return hi # 返回的是hi

# 最小

# 找到最小的mid使得helper(mid)>=K

lo, hi = 1, sum(sweetness)

while lo <= hi:

# 找到最大的mid使得count>=K

mid = (lo+hi)//2

if helper(mid) >= K: # mid还可以再大一点

hi = mid-1

else:

lo = mid+1

return lo # 返回的是lo

搜索算法

并查集 Union-Find Set (General)

class UF:

def __init__(self, n):

self.parent = list(range(n+1))

def find(self, i):

if self.parent[i] != i: # 用i来判断

self.parent[i] = self.find(self.parent[i]) # 路径压缩

return self.parent[i]

def union(self, x, y):

self.parent[self.find(x)] = self.find(y)

回溯法通用模板

def combine(self, n, k):

ans = []

def helper(cur, start):

if len(cur) == k:

ans.append(cur[:])

return

else:

for i in range(start+1, n+1):

cur.append(i)

helper(cur, i)

cur.pop()

helper([], 0)

return ans

A星算法核心公式

F = G + H

F - 方块的总移动代价 G - 开始点到当前方块的移动代价 H - 当前方块到结束点的预估移动代价[heuristic]

import heapq

def heuristic(a, b):

return (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2

def astar(array, start, destination):

n, m = len(array), len(array[0])

dirs = [(0, 1), (0, -1), (1, 0), (-1, 0),

(1, 1), (1, -1), (-1, 1), (-1, -1)]

visited = set()

came_from = {}

gscore = {start: 0}

fscore = {start: heuristic(start, destination)}

queue = []

heapq.heappush(queue, (fscore[start], start))

while queue:

score, cur_pos = heapq.heappop(queue)

if cur_pos == destination:

data = []

while cur_pos in came_from:

data.append(cur_pos)

cur_pos = came_from[cur_pos]

return data

visited.add(cur_pos)

for i, j in dirs:

x, y = cur_pos[0] + i, cur_pos[1] + j

neibor = (x, y)

g = gscore[cur_pos]

h = heuristic(cur_pos, neibor)

f = g+h

if (not(0 <= x < n and 0 <= y < m) # 不能越界

or array[x][y] == 1 # 墙不能走

or(neibor in visited and f >= gscore.get(neibor, 0))): # 还不如从0直接过来

continue

if g < gscore.get(neibor, 0) or neibor not in [i[1]for i in queue]:

came_from[neibor] = cur_pos

gscore[neibor] = g

fscore[neibor] = g + \

heuristic(neibor, destination)

heapq.heappush(queue, (fscore[neibor], neibor))

return False

nmap = [

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1],

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1],

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1],

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

print(astar(nmap, (0, 0), (10, 13)))

def heuristic(a, b):

(x1, y1) = a

(x2, y2) = b

return abs(x1 - x2) + abs(y1 - y2)

def a_star_search(graph, start, goal):

frontier = PriorityQueue()

frontier.put(start, 0)

came_from = {}

cost_so_far = {}

came_from[start] = None

cost_so_far[start] = 0

while not frontier.empty():

current = frontier.get()

if current == goal:

break

for next in graph.neighbors(current):

new_cost = cost_so_far[current] + graph.cost(current, next)

if next not in cost_so_far or new_cost < cost_so_far[next]:

cost_so_far[next] = new_cost

priority = new_cost + heuristic(goal, next)

frontier.put(next, priority)

came_from[next] = current

return came_from, cost_so_far

数学方法

素数筛法

# 1不是素数，最小的质数是2

# Prime table

maxInteger = 1000000

prime = [True]*maxInteger

prime[0] = False

prime[1] = False

for i in range(2, (int)(math.sqrt(maxInteger)+1)):

if prime[i]:

for j in range(i*i, maxInteger, i):

prime[j] = False

求因数

# Given a list A, return all prime factors of elements in A

def getAllFactors(A):

factors = []

for x in A:

facs = []

# 筛法优化

k, d = 0, primes[k]

while d * :

if x % d == 0:

while x % d == 0:

x //= d

facs.append(d)

k += 1

d = primes[k]

# 特判，x>1说明有残余的质数，not facs说明x本身是质数

if x > 1 or not facs:

facs.append(x)

factors.append(facs)

黄金比例求斐波那契

class Solution:

def fib(self, N):

golden_ratio = (1 + 5 ** 0.5) / 2

return int((golden_ratio ** N + 1) / 5 ** 0.5)

$$ \phi=\frac{1+\sqrt{5}}{2} \approx 1.61803 $$

快速幂

def fastExpMod(a, b):

res = 1

while b:

if (b & 1):

# ei = 1, then mul

res *= a

b >>= 1

# b, b^2, b^4, b^8, ... , b^(2^n)

a *= a

return res

牛顿法

class Solution:

def mySqrt(self, x):

r = x + 1 # avoid dividing 0

while r*r > x:

r = int((r+x/r)/2) # newton's method

return r

GCD

def gcd(a, b):

while b:

a, b = b, a % b

return a

求多个数的GCD

def arr_gcd(self, A):

gcd = A[0]

for a in A:

while a:

gcd, a = a, gcd % a

return gcd

graycode

def grayCode(n):

res = [0]

i = 0

while i < n: # 从2的0次方开始，

next_base = 1 << i

res_inv = [x + next_base for x in reversed(res)]

res.extend(res_inv)

i += 1

return res

# 长度为4的所有graycode

# 用于遍历所有情况

# 0000

# 0001

# 0011

# 0010

# 0110

# 0111

# 0101

# 0100

# 1100

# 1101

# 1111

# 1110

# 1010

# 1011

# 1001

# 1000

专用方法

单调栈

def foo(nums):

st = []

res = [0]*len(nums)

for i, x in enumerate(nums):

while st and nums[st[-1]] < x:

idx = st.pop()

res[idx] = i-idx

st.append(i)

return res

slide window

一个for 一个 while 不容易出错

class Window:

def __init__(self):

self.count = collections.Counter()

self.reserve = 0

def add(self, x):

if self.count[x] == 0: # 从效果上来判断

self.reserve += 1

self.count[x] += 1

def remove(self, x):

self.count[x] -= 1

if self.count[x] == 0: #

self.reserve -= 1

class Solution(object):

def lengthOfLongestSubstringKDistinct(self, A, K):

if not A or not len(A) or not K:

return 0

win = Window()

ans = l = 0

# 一个for 一个 while 不容易出错

for r, x in enumerate(A):

win.add(x)

while win.reserve > K:

win.remove(A[l])

l += 1

ans = max(r-l+1, ans)

return ans

二维数组前缀和

n, m = len(grid), len(grid[0])

pre_sum = [[0]*(m+1) for _ in range(n+1)]

for i in range(n):

for j in range(m):

pre_sum[i][j] = pre_sum[i][j-1] + \

pre_sum[i-1][j] - pre_sum[i-1][j-1] + grid[i][j]

def get_sum(x0, y0, x1, y1):

return pre_sum[x1][y1] - pre_sum[x0-1][y1] - pre_sum[x1][y0-1] + pre_sum[x0-1][y0-1]

def helper(size):

cur_max_sum = max(get_sum(x, y, x+size-1, y+size-1)

for x in range(n-size+1) for y in range(m-size+1))

return cur_max_sum

RMQ/ST[Sparse Table]算法

import math

class ST:

def __init__(self, arr):

self.arr = arr

self.n = n = len(arr)

self.m = m = int(math.log(n, 2))

self.maxsum = maxsum = [[0]*(m+1) for _ in range(n)]

self.minsum = minsum = [[0]*(m+1) for _ in range(n)]

for i, x in enumerate(arr):

maxsum[i][0] = minsum[i][0] = x

for j in range(m):

for i in range(n):

k = i + (1 << j)

if(k < n):

maxsum[i][j+1] = max(

maxsum[i][j], maxsum[k][j])

minsum[i][j+1] = min(

minsum[i][j], minsum[k][j])

def get_max(self, a, b):

k = int(math.log(b-a+1, 2))

# 一头一尾

return max(self.maxsum[a][k], self.maxsum[b-(1 << k)+1][k])

def get_min(self, a, b):

k = int(math.log(b-a+1, 2))

return min(self.minsum[a][k], self.minsum[b-(1 << k)+1][k])

arr = [3, 4, 5, 7, 8, 9, 0, 3, 4, 5]

st = ST(arr)

print(st.get_max(0, 9)) # 9

print(st.get_max(6, 9)) # 5

print(st.get_min(0, 9)) # 0

print(st.get_min(0, 4)) # 3

LZ77

def compress(message):

win_size = 10 # 窗口长度

pointer = 0 # 指针，初始指向第一个位置

compressed_message = []

while pointer < len(message):

matched_length = 0 # 匹配到的长度

# 窗口的corner case

window = message[max(pointer - win_size, 0):pointer]

# 能找到的最大长度

while window.find(message[pointer:pointer + matched_length + 1]) != -1:

matched_length += 1

e = pointer + matched_length

# window.find(message[start:end]) 相对窗口的offset

# max(start - win_size, 0) 整个窗口的offset

# first：在整个字符串中的offset

first_appear = window.find(message[pointer:e]) + \

max(pointer - win_size, 0)

item = (pointer - first_appear, matched_length, message[e])

compressed_message.append(item)

pointer += matched_length + 1

return compressed_message

print(compress("abcdbbccaaabaeaaabaee"))

优雅地先序遍历

def preorder(self, root):

if (not root):

return ["null"]

return [str(root.val)]+self.preorder(root.left)+self.preorder(root.right)

def serialize(self, root):

return ",".join(self.preorder(root))