Python算法题笔记

这是本人在学Python和算法题时做的笔记，包含一些Python的典型写法，有用的轮子调用，希望对大家有帮助。
分为三个部分，Python笔记，算法，经典题目，其中Python笔记又包含基本用法，基本的轮子，数据结构。
算法包括Dijkstra，拓扑排序，二分法，回溯。（具体看目录好了）
文中的题目一般来自力扣，数字为题号。
其实本文最初的作用是在力扣周赛时为了节省时间积累的Pythonic写法和各种数据结构的api，算法的模板，以及经典的题目。
推荐在力扣做周赛的同学关注灵茶山艾府的题解，有各种Python的神奇操作和巧妙的解题思路。
以及入门某算法/数据结构时学习yukiyama的教程，如二分查找从入门到入睡。
其中某些解法中有“mine”的标记，是本人能想到的最朴素解法，只是一种补充(不必要的之后再删除)。

Python笔记

基本用法

单词拼写

enumerate
sorted(lis,key=lambda x:f(x),reverse=True)
lis.extend
float('inf')
sys.setrecursionlimit(100000)
from bisect import bisect_left
from itertools import product,accumulate,permutations,combinations
from collections import defaultdict,Counter
from string import ascii_lowercase,ascii_uppercase
from typing import List
@cache # @lru_cache(None)

输入列表(空格隔开元素)

list(map(int,input().split()))

输出列表(空格隔开元素),解包

>>> a=[1,2,3]
>>> print(a)
[1, 2, 3]
>>> print(*a)
1 2 3

翻转序列

lis[::-1]

二进制、十六进制

bin(9) # '0b1001'
hex(31) # '0x1f'
int('11',2) # 3
int('11',16) # 17
int('11',7) # 8

ord(ch) & 15 相当于 ord(ch) - ord('0')，也就是 int(ch)
ord('0') #48

位运算

x += x & -x # 最低的 1 变成 0
x &= x - 1  # 最低的 1 变成 0
x |= x + 1  # 最低的 0 变成 17.bit_length() #SyntaxError: invalid syntax
7 .bit_length() #3
(7).bit_length() #3bin(n).count("1") #位1的个数

解析数学表达式

eval('2+3*4+5*(6+7)') # 79

Python枚举(enumerate)：

for counter, value in enumerate(some_list):print(counter, value)

Python数组按关键词递减排序

arr=['qw','ert','y']
arr=sorted(arr,key=lambda x:len(x),reverse=True)

cnt={'Alice':5,'userTwo':2,'Bob':5}
max(cnt, key = lambda k:(cnt[k], k))
#'Bob' #6084.最多单词数的发件人

Python中函数定义中自变量类型为列表

from typing import List
class Solution:def myFun(self, nums: List[int], target: int) -> int:pass

Python上取整

#ceil(x)函数是向上取整，即取大于等于x的最接近整数。
UP(A/B) = int((A+B-1)/B)
((a-1)//b + 1)

列表追加列表

nums.extend([0, int(2e9) + 1])

all,any

>>> all([1,0,2])
False
>>> any([1,0,2])
True
>>> all([])
True
>>> any([])
False

循环使用for … else 语句

lst = [3, 6, 3, 6, 9, 10, 20]
tag = Truecount = 0
for item in lst:if item % 2 == 0:count += 1if count > 3:break
else:tag = Falseprint(tag)

zip, dict

>>> list(zip([1,2,3],[4,5,6,7]))
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(*zip([1,2,3],[4,5,6,7])))
[(1, 2, 3), (4, 5, 6)]
>>> d=dict(zip([1,2,3],[4,5,6,7]))
>>> d
{1: 4, 2: 5, 3: 6}
>>> d.keys()
dict_keys([1, 2, 3])
>>> d.values()
dict_values([4, 5, 6])
>>> d.items()
dict_items([(1, 4), (2, 5), (3, 6)])

无穷大

float('inf')

字母

{chr(i):i-ord("a") for i in range(ord("a"),ord("z")+1)}
# {'a':0,'b':1,'c':2,'d':3,'e':4,'f':5,'g':6,'h':7,'i':8,'j':9,'k':10,'l':11,'m':12,'n':13,'o':14,'p':15,'q':16,'r':17,'s':18,'t':19,'u':20,'v':21,'w':22,'x':23,'y':24,'z':25}

缓存

@lru_cache #有限制
@lru_cache(None)
@cache #dfs.cache_clear()

python递归深度调整

import sys
sys.setrecursionlimit(100000)

如果您经常需要更改递归限制（例如在解决编程难题时），您可以像这样定义一个简单的上下文管理器：

import sysclass recursionlimit:def __init__(self, limit):self.limit = limitdef __enter__(self):self.old_limit = sys.getrecursionlimit()sys.setrecursionlimit(self.limit)def __exit__(self, type, value, tb):sys.setrecursionlimit(self.old_limit)

然后要调用具有自定义限制的函数，您可以执行以下操作：

with recursionlimit(1500):print(fib(1000, 0))

从with语句主体退出时，递归限制将恢复为默认值。

轮子

factorial阶乘

import math
math.factorial(5) # 120

bisect二分

import bisect
arr = [1, 2, 3, 5]
#ind= [0, 1, 2, 3, 4, 5]
ar2 = [1, 2, 3, 4, 4, 5]
print(bisect.bisect_left(arr, 4))   # 3
print(bisect.bisect_right(arr, 4))  # 3
# print(bisect.bisect(arr, 4))      # 3
print(bisect.bisect_left(ar2, 4))   # 3
print(bisect.bisect_right(ar2, 4))  # 5
# print(bisect.bisect(ar2, 4))      # 5

itertools,product笛卡尔积,排列组合

import itertools
for a in itertools.product([0,1],repeat=12)
# a=(0, 0, 0)等
list(itertools.permutations('abc',2))  # 缺少数时默认为长度
# [('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]
list(itertools.combinations('1234',2)) # 缺少数时报错
# [('1', '2'), ('1', '3'), ('1', '4'), ('2', '3'), ('2', '4'), ('3', '4')]
# groupby(iterable,key=None) 可以把相邻元素按照 key 函数分组，并返回相应的 key 和 groupby，如果key函数为 None，则只有相同的元素才能放在一组。
for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):print(key,list(group))
# A ['A', 'a', 'a']
# B ['B', 'B', 'b']
# C ['c', 'C']
# A ['A', 'A', 'a']

defaultdict 字典提供默认值

>>> from collections import defaultdict
>>> d=defaultdict(int)
>>> d      # defaultdict(<class 'int'>, {})
>>> d['q']   # 0
>>> d      # defaultdict(<class 'int'>, {'q': 0})
>>> int()  # 0
>>> list() # []
>>> set()  # set()
>>> tuple()    # ()
>>> str()  # ''
>>> (lambda:0)() # 0
>>> d2=defaultdict(lambda:0)
>>> d2['q'] # 0

dict方法：__missing__

class myDict(dict):def __missing__(self, key):self[key] = key-1return key+1
>>> d=myDict()
>>> d[1] # 2
>>> d    # {1: 0}
>>> d[1] # 0

Counter 计数

>>> from collections import Counter
>>> c=Counter([1,2,1,3,2,4])
>>> c # Counter({1: 2, 2: 2, 3: 1, 4: 1})
>>> c[5] # 0
>>> c.items()
dict_items([(1, 2), (2, 2), (3, 1), (4, 1)])
>>> list(c.items())
[(1, 2), (2, 2), (3, 1), (4, 1)]

2190.数组中紧跟 key 之后出现最频繁的数字

by shikata-akiko-fans 我爱志方小姐

class Solution:def mostFrequent(self, nums: List[int], key: int) -> int:n = len(nums)counter = Counter()for i in range(0, n - 1):if nums[i] == key:counter[nums[i + 1]] += 1return counter.most_common(1)[0][0]

Python中的Counter.most_common()方法_AI算法工程师YC的博客-CSDN博客_most_common() https://blog.csdn.net/qq_36134437/article/details/103245281sum(c.values())  # 所有计数的总数
c.clear()  # 重置Counter对象，注意不是删除
list(c)  # 将c中的键转为列表
set(c)  # 将c中的键转为set
dict(c)  # 将c中的键值对转为字典
c.items()  # 转为(elem, cnt)格式的列表
Counter(dict(list_of_pairs))  # 从(elem, cnt)格式的列表转换为Counter类对象
c.most_common()[:-n:-1]  # 取出计数最少的n-1个元素
c += Counter()  # 移除0和负值top_three = word_counts.most_common(3)
print(top_three)
# Outputs [('eyes', 8), ('the', 5), ('look', 4)]

accumulate 累积

创建一个迭代器，返回累积汇总值或其他双目运算函数的累积结果值（通过可选的 func 参数指定）。

>>> import itertools
>>> itertools.accumulate([1,2,3,4,5])
<itertools.accumulate object at 0x0000013A2B175C80>
>>> list(itertools.accumulate([1,2,3,4,5]))
[1, 3, 6, 10, 15]
>>> list(itertools.accumulate([1,2,3,4,5],initial=100))
[100, 101, 103, 106, 110, 115]
>>> list(itertools.accumulate([1,2,3,4,5],lambda x,y:x*y))
[1, 2, 6, 24, 120]
>>> list(itertools.accumulate([3, 4, 6, 2, 1, 9, 0, 7, 5, 8], max))
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

字符串string

>>> s='aBcDe,qwERtY'
>>> s.upper()
'ABCDE,QWERTY'
>>> s.lower()
'abcde,qwerty'
>>> s.swapcase()
'AbCdE,QWerTy'
>>> s.title() #所有单词的首字母大写，其他全部小写
'Abcde,Qwerty'
>>> s.capitalize() #首字母大写，其他小写
'Abcde,qwerty'
>>> s="qwertyqwerty"
>>> s.find("qwe")
0
>>> s.rfind("qwe")
6
>>>
>>> s.find("asd")
-1
>>> s.index("asd")
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> import string
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

子集

def get_sub_set(nums):sub_sets = [[]]for x in nums:sub_sets.extend([item + [x] for item in sub_sets])return sub_sets
def powlist(s):r=[[]]for e in s:r+=[x+[e] for x in r]return r

排列

下一个排列

class Solution:def nextPermutation(self, nums: List[int]) -> None:n=len(nums)i=n-2while i>=0 and nums[i]>=nums[i+1]:i-=1if i>=0:left,right=i+1,n-1while left<right:m=(left+right+1)//2if nums[m]<=nums[i]:right=m-1else:left=mnums[i],nums[right]=nums[right],nums[i]i,j=i+1,n-1while i<j:nums[i],nums[j]=nums[j],nums[i]i+=1j-=1return

全排列

class Solution:#调包def permute(self, nums: List[int]) -> List[List[int]]:return list(itertools.permutations(nums))
class Solution:#官方，无重复def permute(self, nums):""":type nums: List[int]:rtype: List[List[int]]"""def backtrack(first = 0):# 所有数都填完了if first == n:  res.append(nums[:])for i in range(first, n):# 动态维护数组nums[first], nums[i] = nums[i], nums[first]# 继续递归填下一个数backtrack(first + 1)# 撤销操作nums[first], nums[i] = nums[i], nums[first]n = len(nums)res = []backtrack()return res
class Solution:#考虑重复情况def permuteUnique(self, nums: List[int]) -> List[List[int]]:ans=[]p=[]vis=[0]*len(nums)n=len(nums)nums.sort()def generate(first=0):if first==n:ans.append(p[:])for i in range(n):if vis[i] or i>0 and nums[i]==nums[i-1] and vis[i-1]==0:continuep.append(nums[i])vis[i]=1generate(first+1)vis[i]=0p.pop()generate()return ans

数据结构

堆

api

代码，来自 heapq — 堆队列算法 — Python 3.10.3 文档 https://docs.python.org/zh-cn/3/library/heapq.html

heapq.heappush(heap, item)
将 item 的值加入 heap 中，保持堆的不变性。heapq.heappop(heap)
弹出并返回 heap 的最小的元素，保持堆的不变性。如果堆为空，抛出 IndexError 。使用 heap[0] ，可以只访问最小的元素而不弹出它。heapq.heappushpop(heap, item)
将 item 放入堆中，然后弹出并返回 heap 的最小元素。该组合操作比先调用 heappush() 再调用 heappop() 运行起来更有效率。heapq.heapify(x)
将list x 转换成堆，原地，线性时间内。heapq.heapreplace(heap, item)
弹出并返回 heap 中最小的一项，同时推入新的 item。 堆的大小不变。 如果堆为空则引发 IndexError。
这个单步骤操作比 heappop() 加 heappush() 更高效，并且在使用固定大小的堆时更为适宜。 pop/push 组合总是会从堆中返回一个元素并将其替换为 item。
返回的值可能会比添加的 item 更大。 如果不希望如此，可考虑改用 heappushpop()。 它的 push/pop 组合会返回两个值中较小的一个，将较大的值留在堆中。

最大堆

class MaxHeap:def __init__(self,x=[]):self.data=[-i for i in x]heapq.heapify(self.data)def push(self,item):heapq.heappush(self.data,-item)def top(self):return -self.data[0]def pop(self):return -heapq.heappop(self.data)def pushpop(self,item):return -heapq.heappushpop(self.data,-item)def replace(self,item):return -heapq.heapreplace(self.data,-item)def __repr__(self):return '['+",".join(map(lambda x:str(-x),self.data))+']'q=[1,2,3,4,5]
q2=MaxHeap(q)
print(q2) #[5,4,3,1,2]
print(q2.pushpop(3.5)) #5
print(q2) #[4,3.5,3,1,2]

Java重写比较器

作者：Sparkk
链接：https://leetcode-cn.com/problems/minimum-operations-to-halve-array-sum/solution/by-sparkk-ipqq/

class Solution {public int halveArray(int[] nums) {long sum = 0;double res = 0;double target = 0;int count = 0;PriorityQueue<Double> que = new PriorityQueue<>((o1,o2) -> Double.compare(o2, o1));for (int i = 0; i < nums.length; i++) {sum += nums[i];que.add(nums[i] * 1.0);}target = sum * 1.0 / 2;// 比较已减少的数量 与 和的一半while (res < target) {double temp = que.poll();res += temp / 2;que.add(temp / 2);count++;}return count;}
}

应用：

找第k大元素

多次取数组中最小元素，2208.将数组和减半的最少操作次数

链表

技巧：1.合并链表：添加哑节点

2.找链表的倒数第K个元素：用双指针

改变比较方式（优先队列中遇到），防止报错

class Solution:def mergeKLists(self, lists: List[ListNode]) -> ListNode:passdef __lt__(self, other):return self.val < other.valListNode.__lt__ = __lt__

并查集

323.无向图中连通分量的数目

class Solution:def countComponents(self, n: int, edges: List[List[int]]) -> int:def find(x):if fa[x]!=x:fa[x]=find(fa[x])return fa[x]def merge(i,j):x=find(i)y=find(j)if x!=y:if rank[x]<=rank[y]:fa[x]=yelse:fa[y]=xif rank[x]==rank[y]:rank[y]+=1self.count-=1def ask(x,y):return find(x)==find(y)self.count=nrank=[0]*nfa=list(range(n))for a,b in edges:merge(a,b)return self.count

树状数组

307区域和检索 - 数组可修改

'''BIT：Binary Indexed Tree 树状数组'''
class BIT:def __init__(self, n):self.tree = [0] * (n+1)     # 比原数组多1个元素def lowbit(self, x):return x & (-x)def add(self, i, delta):        # 单点更新：执行+deltai += 1                      # 原数组下标转换到树状数组下标while i<len(self.tree):self.tree[i] += deltai += self.lowbit(i)def preSum(self, i):            # 前缀和i += 1                      # 原数组下标转换到树状数组下标summ = 0while i>0:summ += self.tree[i]i -= self.lowbit(i)return summdef rangeSum(self, a, b):       # 区间[a,b]的原数组和return self.preSum(b) - self.preSum(a-1)class NumArray:def __init__(self, nums: List[int]):self.nums=numsself.tree = BIT(len(nums))for i,v in enumerate(nums):self.tree.add(i,v)def update(self, index: int, val: int) -> None:self.tree.add(index,val-self.nums[index])self.nums[index]=valdef sumRange(self, left: int, right: int) -> int:return self.tree.rangeSum(left,right)# Your NumArray object will be instantiated and called as such:
# obj = NumArray(nums)
# obj.update(index,val)
# param_2 = obj.sumRange(left,right)

线段树

题目链接：307. 区域和检索 - 数组可修改 - 力扣（LeetCode）
https://leetcode.cn/problems/range-sum-query-mutable/
参考教程：线段树从入门到急停 - 力扣（LeetCode）
https://leetcode.cn/circle/discuss/H4aMOn/
基本线段树1 (无懒标记，无区间修改方法，实时维护 nums[i])
支持：单点修改 / 单点查询 / 区间查询

class SegmentTree:def __init__(self, nums):self.nums=numsself.n=len(self.nums)self.tree = [0] * (4*self.n)self.build(0,self.n-1,1)def pushUp(self,i): #更新tree[i]self.tree[i]=self.tree[i*2]+self.tree[i*2+1]def build(self,s,t,i): #构建线段树(tree数组)if s==t:self.tree[i]=self.nums[s]returnc=(s+t)//2self.build(s,c,i*2)self.build(c+1,t,i*2+1)self.pushUp(i)def update(self,i,x): #单点修改，驱动，nums[i]=xself.add(i,x-self.nums[i],0,self.n-1,1)self.nums[i]=xdef add(self,idx,x,s,t,i): #单点修改，nums[idx]+=xif s==t:self.tree[i]+=xreturnc=(s+t)//2if idx<=c:self.add(idx,x,s,c,i*2)else:self.add(idx,x,c+1,t,i*2+1)self.pushUp(i)def query(self,i): #单点查询，查询nums[i]return self.nums[i]def querySum(self,l,r): #区间查询，驱动，查询nums[l...r]return self.sum(l,r,0,self.n-1,1)def sum(self,l,r,s,t,i): #区间查询，查询nums[l...r]if l<=s and t<=r:return self.tree[i]c=(s+t)//2summ=0if l<=c:summ+=self.sum(l,r,s,c,i*2)if r>c:summ+=self.sum(l,r,c+1,t,i*2+1)return summclass NumArray:def __init__(self, nums: List[int]):self.seg=SegmentTree(nums)def update(self, index: int, val: int) -> None:self.seg.update(index,val)def sumRange(self, left: int, right: int) -> int:return self.seg.querySum(left,right)

二叉树-前序遍历

递归

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/solution/er-cha-shu-de-qian-xu-bian-li-by-leetcode-solution/

class Solution:def preorderTraversal(self, root: TreeNode) -> List[int]:def preorder(root: TreeNode):if not root:returnres.append(root.val)preorder(root.left)preorder(root.right)res = list()preorder(root)return res

迭代

参考LeetCode-Solution

class Solution:def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:ans=[]if not root:return ans #这行不必须stack=[]node=rootwhile stack or node:while node:ans.append(node.val)stack.append(node)node=node.leftnode=stack.pop()node=node.rightreturn ans

二叉树-中序遍历

递归

import sys
sys.setrecursionlimit(100000)
class Solution:def inorderTraversal(self , root: TreeNode) -> List[int]:ans=[]def preOrder(x):if not x:returnpreOrder(x.left)ans.append(x.val)preOrder(x.right)preOrder(root)return ans

迭代

class Solution:def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:ans=[]stack=[]node=rootwhile stack or node:while node:stack.append(node)node=node.leftnode=stack.pop()ans.append(node.val)node=node.rightreturn ans

颜色标记法

颜色标记法-一种通用且简明的树遍历方法
henry

核心思想如下：

1使用颜色标记节点的状态，新节点为白色，已访问的节点为灰色。
2如果遇到的节点为白色，则将其标记为灰色，然后将其右子节点、自身、左子节点依次入栈。
3如果遇到的节点为灰色，则将节点的值输出。

作者：hzhu212
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/yan-se-biao-ji-fa-yi-chong-tong-yong-qie-jian-ming/

zjl233评论

本题需要中序遍历。

栈是一种 先进后出的结构，出栈顺序为左，中，右
那么入栈顺序必须调整为倒序，也就是右，中，左

同理，如果是前序遍历，入栈顺序为 右，左，中；后序遍历，入栈顺序中，右，左。

class Solution:def inorderTraversal(self, root: TreeNode) -> List[int]:WHITE, GRAY = 0, 1res = []stack = [(WHITE, root)]while stack:color, node = stack.pop()if node is None: continueif color == WHITE:stack.append((WHITE, node.right))stack.append((GRAY, node))stack.append((WHITE, node.left))else:res.append(node.val)return res

二叉树-后序遍历

递归

class Solution:def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:def postorder(x):if not x:returnpostorder(x.left)postorder(x.right)ans.append(x.val)ans=[]postorder(root)return ans

迭代

参考LeetCode-Solution

class Solution:def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:ans=[]if not root:return ansstack=[]prev=Nonenode=rootwhile node or stack:while node:stack.append(node)node=node.leftnode=stack.pop()if not node.right or node.right==prev:ans.append(node.val)prev=nodenode=Noneelse:stack.append(node)node=node.rightreturn ans

前序的翻转

作者：carlsun-2
链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/bang-ni-dui-er-cha-shu-bu-zai-mi-mang-che-di-chi-t/

class Solution {public:vector<int> postorderTraversal(TreeNode* root) {stack<TreeNode*> st;vector<int> result;if (root == NULL) return result;st.push(root);while (!st.empty()) {TreeNode* node = st.top();st.pop();result.push_back(node->val);if (node->left) st.push(node->left); // 相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）if (node->right) st.push(node->right); // 空节点不入栈}reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了return result;}
};

二叉树-层序遍历

Mine-下标增加

class Solution:def levelOrder(self, root: TreeNode) -> List[List[int]]:if not root:return []ans=[]i=0q=[]q.append(root)lastn=curn=1while i<len(q):anscur=[]while i<lastn:node=q[i]anscur.append(node.val)if node.left:q.append(node.left)curn+=1if node.right:q.append(node.right)curn+=1i+=1lastn=curnans.append(anscur)return ans

官方-dfs,cpp

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/er-cha-shu-de-ceng-xu-bian-li-by-leetcode-solution/

class Solution {public:vector<vector<int>> levelOrder(TreeNode* root) {vector <vector <int>> ret;if (!root) {return ret;}queue <TreeNode*> q;q.push(root);while (!q.empty()) {int currentLevelSize = q.size();ret.push_back(vector <int> ());for (int i = 1; i <= currentLevelSize; ++i) {auto node = q.front(); q.pop();ret.back().push_back(node->val);if (node->left) q.push(node->left);if (node->right) q.push(node->right);}}return ret;}
};

第二快,Python,列表模拟队列

class Solution:def levelOrder(self, root: TreeNode) -> List[List[int]]:if not root:return []queue = [root]ans=[]while queue:path = []for _ in range(len(queue)):node = queue.pop(0)path.append(node.val)if node.left:queue.append(node.left)if node.right:queue.append(node.right)ans.append(path) #原为ans.append(path[:])return ans

双端队列

by霍格沃茨优秀毕业生，评论来自文章“BFS 的使用场景总结：层序遍历、最短路径问题”

from collections import deque
class Solution:def levelOrder(self, root: TreeNode) -> List[List[int]]:if not root:return []res = []d = deque()d.append(root)while d:length = len(d)level = []for i in range(length):node = d.popleft()level.append(node.val)if node.left:d.append(node.left)if node.right:d.append(node.right)res.append(level)return res

二叉树-最大深度

mine

class Solution:def maxDepth(self, root: Optional[TreeNode]) -> int:if not root:return 0return max(self.maxDepth(root.left),self.maxDepth(root.right))+1
class Solution:def maxDepth(self, root: Optional[TreeNode]) -> int:def maxd(r,d):if not r:ans[0]=max(ans[0],d)returnmaxd(r.left,d+1)maxd(r.right,d+1)ans=[0]maxd(root,0)return ans[0]
class Solution:def maxDepth(self, root: Optional[TreeNode]) -> int:if not root:return 0q=[root]ans=0while q:path=[]for _ in range(len(q)):node=q.pop(0)if node.left:q.append(node.left)if node.right:q.append(node.right)ans+=1return ans

other

典型的深度优先搜索和广度优先搜索

class Solution:def maxDepth(self, root: Optional[TreeNode]) -> int:# def recur(root): # DFS#     if not root:#         return 0#     left = recur(root.left)#     right = recur(root.right)#     return max(left, right)+1# return recur(root)# BFSif not root:return 0deque = collections.deque([root])Len = 0while deque:for _ in range(len(deque)):tmp = deque.popleft()if tmp.left:deque.append(tmp.left)if tmp.right:deque.append(tmp.right)Len += 1return Len

二叉树-对称

         1/ \/   \/     \/       \2         2/ \       / \3   4     4   3/ \ / \   / \ / \
8  7 6  5 5  6 7  8

递归-mine

class Solution:def isSymmetric(self, root: Optional[TreeNode]) -> bool:def isSym2(a,b):if not a:if not b:return Trueelse:return Falseelse:if not b:return Falseif a.val!=b.val:return Falsereturn isSym2(a.left,b.right) and isSym2(a.right,b.left)if not root:return Truereturn isSym2(root.left,root.right)

迭代-每次提取两个结点

递归程序改写成迭代程序的常用方法

「方法一」中我们用递归的方法实现了对称性的判断，那么如何用迭代的方法实现呢？首先我们引入一个队列，这是把递归程序改写成迭代程序的常用方法。初始化时我们把根节点入队两次。每次提取两个结点并比较它们的值（队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像），然后将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/symmetric-tree/solution/dui-cheng-er-cha-shu-by-leetcode-solution/

class Solution: #从官方cpp翻译def isSymmetric(self, root: Optional[TreeNode]) -> bool:if not root:return Truedef isSym2(a,b):q=[]q.append(a)q.append(b)while q:u=q.pop(0)v=q.pop(0)if not u and not v:continueif (not u or not v) or u.val!=v.val:return Falseq.append(u.left)q.append(v.right)q.append(u.right)q.append(v.left)return Truereturn isSym2(root.left,root.right)

算法

最短路dijkstra

官方:=743.网络延迟时间

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/network-delay-time/solution/wang-luo-yan-chi-shi-jian-by-leetcode-so-6phc/

class Solution:def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:g = [[] for _ in range(n)]for x, y, time in times:g[x - 1].append((y - 1, time))dist = [float('inf')] * ndist[k - 1] = 0q = [(0, k - 1)]while q:time, x = heapq.heappop(q)if dist[x] < time:continuefor y, time in g[x]:if (d := dist[x] + time) < dist[y]:dist[y] = dheapq.heappush(q, (d, y))ans = max(dist)return ans if ans < float('inf') else -1

最小堆+visited+dijkstra算法

作者：QRhqcDD90G
链接：https://leetcode-cn.com/problems/network-delay-time/solution/cpython3java-1po-su-dijkstrasuan-fa-2zui-ks36/

class Solution:def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:#------------------------最小堆+visited+dijkstra算法 -------------------------#INF = 10 ** 9adjvex = defaultdict(list)for x, y, cost in times:x -= 1y -= 1adjvex[x].append((y, cost))start = k - 1  #起点dist = [INF for _ in range(n)]visited = [False for _ in range(n)]dist[start] = 0minHeap = []heapq.heappush(minHeap, (0, start))while minHeap:d, x = heapq.heappop(minHeap)if visited[x] == True:continuevisited[x] = Truefor y, cost in adjvex[x]:if dist[x] + cost < dist[y]:dist[y] = dist[x] + costheapq.heappush(minHeap, (dist[y], y))#----- 最后一个结点收到的时间。是求maxres = max(dist)return res if res != INF else -1

三条最短路by灵茶山艾府

题目：2203.得到要求路径的最小带权子图

枚举三条最短路的交汇点_灵茶山艾府

作者：endlesscheng
链接：https://leetcode-cn.com/problems/minimum-weighted-subgraph-with-the-required-paths/solution/by-endlesscheng-2mxm/

class Solution:def minimumWeight(self, n: int, edges: List[List[int]], src1: int, src2: int, dest: int) -> int:def dijkstra(g: List[List[tuple]], start: int) -> List[int]:dis = [inf] * ndis[start] = 0pq = [(0, start)]while pq:d, x = heappop(pq)if d > dis[x]:continuefor y, wt in g[x]:new_d = dis[x] + wtif new_d < dis[y]:dis[y] = new_dheappush(pq, (new_d, y))return disg = [[] for _ in range(n)]rg = [[] for _ in range(n)]for x, y, wt in edges:g[x].append((y, wt))rg[y].append((x, wt))d1 = dijkstra(g, src1)d2 = dijkstra(g, src2)d3 = dijkstra(rg, dest)ans = min(sum(d) for d in zip(d1, d2, d3))return ans if ans < inf else -1

拓扑排序

课程表 II - 课程表 II - 力扣（LeetCode） https://leetcode.cn/problems/course-schedule-ii/solution/ke-cheng-biao-ii-by-leetcode-solution/

210官方,BFS,用了collections

用了collections的defaultdict和deque

class Solution:def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:# 存储有向图edges = collections.defaultdict(list)# 存储每个节点的入度indeg = [0] * numCourses# 存储答案result = list()for info in prerequisites:edges[info[1]].append(info[0])indeg[info[0]] += 1# 将所有入度为 0 的节点放入队列中q = collections.deque([u for u in range(numCourses) if indeg[u] == 0])while q:# 从队首取出一个节点u = q.popleft()# 放入答案中result.append(u)for v in edges[u]:indeg[v] -= 1# 如果相邻节点 v 的入度为 0，就可以选 v 对应的课程了if indeg[v] == 0:q.append(v)if len(result) != numCourses:result = list()return result

mine,BFS,没用collections

class Solution:def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:n=numCoursesdeg=[0]*n #入度nex=[[] for _ in range(n)] #之后的课程,nex[i]依赖ifor a,b in prerequisites: # b指向adeg[a]+=1nex[b].append(a)q=[]for i,v in enumerate(deg):if v==0:q.append(i)ans=[]while q:u=q.pop(0)ans.append(u)for v in nex[u]:deg[v]-=1if deg[v]==0:q.append(v)if len(ans)==n:return ansreturn []

207官方,只判断是否有环

class Solution:def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:edges = collections.defaultdict(list)indeg = [0] * numCoursesfor info in prerequisites:edges[info[1]].append(info[0])indeg[info[0]] += 1q = collections.deque([u for u in range(numCourses) if indeg[u] == 0])visited = 0while q:visited += 1u = q.popleft()for v in edges[u]:indeg[v] -= 1if indeg[v] == 0:q.append(v)return visited == numCourses

6163.给定条件下构造矩阵by灵茶山艾府

作者：endlesscheng
链接：https://leetcode.cn/problems/build-a-matrix-with-conditions/solution/by-endlesscheng-gpev/

class Solution:def buildMatrix(self, k: int, rowConditions: List[List[int]], colConditions: List[List[int]]) -> List[List[int]]:def topo_sort(edges: List[List[int]]) -> List[int]:g = [[] for _ in range(k)]in_deg = [0] * kfor x, y in edges:g[x - 1].append(y - 1)  # 顶点编号从 0 开始，方便计算in_deg[y - 1] += 1order = []q = deque(i for i, d in enumerate(in_deg) if d == 0)while q:x = q.popleft()order.append(x)for y in g[x]:in_deg[y] -= 1if in_deg[y] == 0:q.append(y)return order if len(order) == k else Noneif (row := topo_sort(rowConditions)) is None or (col := topo_sort(colConditions)) is None:return []pos = {x: i for i, x in enumerate(col)}ans = [[0] * k for _ in range(k)]for i, x in enumerate(row):ans[i][pos[x]] = x + 1return ans

二分法

我的思路（纯属记录，可忽略看其他教程，如有错麻烦指出）
先看等于时，划入那一边
再看该边应该是大于还是小于
最后（循环外）处理边界（始终不发生某条件，可能下标要更改1）
看是否包含解，来设置mid加减1

m偏向哪一边的两个情形

m=(zo+yo)//2
yo=m
zo=m+1m=(zo+yo+1)//2
yo=m-1
zo=m

一规律

二分查找通用规律(固定模板解决寻找>=, >, <, <=)

/**
* 范围查询规律
* 初始化:
*   int left = 0;
*   int right = nums.length - 1;
* 循环条件
*   left <= right
* 右边取值
*   right = mid - 1
* 左边取值
*   left = mid + 1
* 查询条件
*   >= target值, 则 nums[mid] >= target时, 都减right = mid - 1
*   >  target值, 则 nums[mid] >  target时, 都减right = mid - 1
*   <= target值, 则 nums[mid] <= target时, 都加left = mid + 1
*   <  target值, 则 nums[mid] <  target时, 都加left = mid + 1
* 结果
*   求大于(含等于), 返回left
*   求小于(含等于), 返回right
* 核心思想: 要找某个值, 则查找时遇到该值时, 当前指针(例如right指针)要错过它, 让另外一个指针(left指针)跨过他(体现在left <= right中的=号), 则找到了
*/
作者：chendragon
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/er-fen-cha-zhao-tong-yong-gui-lu-gu-ding-g93u/

回溯

39组合总和

class Solution:def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:candidates.sort()ans=[]def dfs(pre,ind,ta):print(pre,ind,ta)if ind==len(candidates) or candidates[ind]>ta:returnif candidates[ind]==ta:ans.append(pre+[ta])returndfs(pre+[candidates[ind]],ind,ta-candidates[ind])dfs(pre,ind+1,ta)dfs([],0,target)return ans

40组合总和2

class Solution:def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:n=len(candidates)candidates.sort()ans=[]def dfs(pre,ind,ta,last):if ind==n or candidates[ind]>ta:returnif candidates[ind]==ta:ans.append(pre+[ta])returnif candidates[ind]!=last:dfs(pre+[candidates[ind]],ind+1,ta-candidates[ind],-1)dfs(pre,ind+1,ta,candidates[ind])dfs([],0,target,-1)return ans

其他

技巧

1.通常先排序，如2126. 摧毁小行星，除了少数对元素顺序有要求的（如2210. 统计数组中峰和谷的数量）

2.有时先去重会少很多麻烦，如上文提到的2210题；集合去重

易错

• 2+1&2结果是2，因为&的优先级低于+，2|3&1结果是3

出现题目：2172数组的最大与和 - 力扣（LeetCode）

https://leetcode-cn.com/problems/maximum-and-sum-of-array/

• 数组中出现负数，与非负处理有所不同

• Python中nums[-k]不会报错，但是k为0时导致结果不对

dp[k][i]=max((dp[k][i-1] if i>=1 else 0),(dp[k-1][i-le] if i-le>=0 else 0)+pre[i]-(pre[i-le] if i-le>=0 else 0))

• 当数组的第零个元素被忽略时，数组长度n加一，所有的地方n都要改为n+1。

        inf=float('inf')edges=[[inf]*(n+1) for i in range(n+1)]while True:for i in range(n+1):

• Python的q.pop(0)少了0

日期，一年的第多少天

year=int(input("请输入年份："))
month=int(input("请输入月份："))
day=int(input("请输入日期："))
sum=0
months=(31,28,31,30,31,30,31,31,30,31,30,31)
for i in range(month-1):sum+=months[i]
sum+=day
leap=0
if (year%400==0) or (year%4==0 and year%100!=0):leap=1
if leap==1 and month>2:sum+=1
print("It is the {} day".format(sum))

经典题目

300.最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：
输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：
输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：
输入：nums = [7,7,7,7,7,7,7]
输出：1

官方，贪心 + 二分查找

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-by-leetcode-soluti/

class Solution:def lengthOfLIS(self, nums: List[int]) -> int:d = []for n in nums:if not d or n > d[-1]:d.append(n)else:l, r = 0, len(d) - 1loc = rwhile l <= r:mid = (l + r) // 2if d[mid] >= n:loc = midr = mid - 1else:l = mid + 1d[loc] = nreturn len(d)

含有等于情形，动态规划 + 二分查找

作者：jyd
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-dong-tai-gui-hua-2/

# Dynamic programming + Dichotomy.
class Solution:def lengthOfLIS(self, nums: [int]) -> int:tails, res = [0] * len(nums), 0for num in nums:i, j = 0, reswhile i < j:m = (i + j) // 2if tails[m] < num: i = m + 1# 如果要求非严格递增，将此行 '<' 改为 '<=' 即可。else: j = mtails[i] = numif j == res: res += 1return res

最长公共子串

0.dp_mine

class Solution:def findLength(self, nums1: List[int], nums2: List[int]) -> int:n=len(nums1)m=len(nums2)maxl=0dp=[[0]*(m+1) for i in range(n+1)]for i in range(1,n+1):for j in range(1,m+1):if nums1[i-1]==nums2[j-1]:dp[i][j]=1+dp[i-1][j-1]else:dp[i][j]=0if dp[i][j]>maxl:# i1,j1=i,jmaxl=dp[i][j]# print(nums1[i1-maxl:i1])return maxl

1.dp官方

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray/solution/zui-chang-zhong-fu-zi-shu-zu-by-leetcode-solution/

class Solution:def findLength(self, A: List[int], B: List[int]) -> int:n, m = len(A), len(B)dp = [[0] * (m + 1) for _ in range(n + 1)]ans = 0for i in range(n - 1, -1, -1):for j in range(m - 1, -1, -1):dp[i][j] = dp[i + 1][j + 1] + 1 if A[i] == B[j] else 0ans = max(ans, dp[i][j])return ans

2.哈希+二分

class Solution:#https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray/solution/zui-chang-zhong-fu-zi-shu-zu-by-leetcode-solution/def findLength(self, A: List[int], B: List[int]) -> int:base, mod = 113, 10**9 + 9def check(length: int) -> bool:hashA = 0for i in range(length):hashA = (hashA * base + A[i]) % modbucketA = {hashA}mult = pow(base, length - 1, mod)for i in range(length, len(A)):hashA = ((hashA - A[i - length] * mult) * base + A[i]) % modbucketA.add(hashA)hashB = 0for i in range(length):hashB = (hashB * base + B[i]) % modif hashB in bucketA:return Truefor i in range(length, len(B)):hashB = ((hashB - B[i - length] * mult) * base + B[i]) % modif hashB in bucketA:return Truereturn Falseleft, right = 0, min(len(A), len(B))ans = 0while left <= right:mid = (left + right) // 2if check(mid):ans = midleft = mid + 1else:right = mid - 1return ans

最长公共子序列

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-common-subsequence/solution/zui-chang-gong-gong-zi-xu-lie-by-leetcod-y7u0/

class Solution:def longestCommonSubsequence(self, text1: str, text2: str) -> int:m, n = len(text1), len(text2)dp = [[0] * (n + 1) for _ in range(m + 1)]for i in range(1, m + 1):for j in range(1, n + 1):if text1[i - 1] == text2[j - 1]:dp[i][j] = dp[i - 1][j - 1] + 1else:dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])return dp[m][n]

不同的子序列

作者：powcai
链接：https://leetcode-cn.com/problems/distinct-subsequences/solution/dong-tai-gui-hua-by-powcai-5/

class Solution:def numDistinct(self, s: str, t: str) -> int:n1=len(s)n2=len(t)dp=[[0]*(n1+1) for _ in range(n2+1)]for j in range(n1+1):dp[0][j]=1for i in range(1,n2+1):for j in range(1,n1+1):if t[i-1]==s[j-1]:dp[i][j]=dp[i-1][j-1]+dp[i][j-1]else:dp[i][j]=dp[i][j-1]return dp[-1][-1]

数组中的逆序对,剑指 Offer 51

方法一：归并排序

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/solution/shu-zu-zhong-de-ni-xu-dui-by-leetcode-solution/

class Solution:def mergeSort(self, nums, tmp, l, r):if l >= r:return 0mid = (l + r) // 2inv_count = self.mergeSort(nums, tmp, l, mid) + self.mergeSort(nums, tmp, mid + 1, r)i, j, pos = l, mid + 1, lwhile i <= mid and j <= r:if nums[i] <= nums[j]:tmp[pos] = nums[i]i += 1inv_count += (j - (mid + 1))else:tmp[pos] = nums[j]j += 1pos += 1for k in range(i, mid + 1):tmp[pos] = nums[k]inv_count += (j - (mid + 1))pos += 1for k in range(j, r + 1):tmp[pos] = nums[k]pos += 1nums[l:r+1] = tmp[l:r+1]return inv_countdef reversePairs(self, nums: List[int]) -> int:n = len(nums)tmp = [0] * nreturn self.mergeSort(nums, tmp, 0, n - 1)

方法二：离散化树状数组

class BIT:def __init__(self, n):self.n = nself.tree = [0] * (n + 1)@staticmethoddef lowbit(x):return x & (-x)def query(self, x):ret = 0while x > 0:ret += self.tree[x]x -= BIT.lowbit(x)return retdef update(self, x):while x <= self.n:self.tree[x] += 1x += BIT.lowbit(x)class Solution:def reversePairs(self, nums: List[int]) -> int:n = len(nums)# 离散化tmp = sorted(nums)for i in range(n):nums[i] = bisect.bisect_left(tmp, nums[i]) + 1# 树状数组统计逆序对bit = BIT(n)ans = 0for i in range(n - 1, -1, -1):ans += bit.query(nums[i] - 1)bit.update(nums[i])return ans

Python有序集合 + 二分查找实现

by我爱志方小姐
发布于 2022-09-19
求逆序对问题：

315. 计算右侧小于当前元素的个数

493. 翻转对

剑指 Offer 51. 数组中的逆序对

上面三个求 逆序对问题 都可以用下面两种方法做，代码也几乎一毛一样~

Python算法题笔记相关推荐

1. Python 算法题之 俄罗斯套娃信封

   Python 算法题之 俄罗斯套娃信封 文章目录 Python 算法题之 俄罗斯套娃信封 给出题目

2. 装饰器python的通俗理解_2道极好的Python算法题 | 带你透彻理解装饰器的妙用

   今天我分享两道非常好的算法题,大家耐心看完两道算法题之后,注意精华在最后,我相信大家对装饰器的理解又会更上一层楼. 1.斐波那契数列 1).这个序列非常有名,我非常喜欢这个序列(有同学问我为啥,偷偷告 ...

3. python算法题排序_python-数据结构与算法- 面试常考排序算法题-快排-冒泡-堆排-二分-选择等...

   算法可视化网站推荐---->visualgo 0.面试题中的排序算法 一些排序算法可能在工作中用的会比较少,但是面试却是不得不面对的问题.算法有助于提高我们对数据结构的理解以及提高自己的逻辑能力 ...

4. .net 遍历数组找重复值写入一个新数组_第二轮 Python 刷题笔记一：数组

   经过四十多天缓慢的刷题,现在进度大概是刷了八十多道 LeetCode 题,最近也在吸取过来人的经验,仍然需要对刷题计划进行调整. 首先明确一下目标,我是有些 Python 基础,想通过刷题掌握更多算法 ...

5. python算法题_python基本算法题（一）

   1.3位水仙花数计算 "3位水仙花数"是指一个三位整数,其各位数字的3次方和等于该数本身. 例如: ABC是一个"3位水仙花数",则:A的3次方+B的3次方+C ...

6. leetcode题目及答案python_leetcode Python算法题(20)-----多题

   题一:题1 看到这道题的时候我就想把它转换成数字来做,感觉是否有些投机取巧? class Solution: def addBinary(self, a, b): x = int(a, 2) y =  ...

7. 计算机二级python刷题笔记(1)

   题目一 随机选择一个手机品牌输出 # 请在...处使用一行或多行代码替换 # 请在______处使用一行代码替换 # # 注意:请不要修改其他已给出代码import ______ brandlist ...

8. 计算机二级python编程题笔记(基础题）（自用）

   1.以123 为随机种子,随机生成10个介于1(含)到999(含)之间的随机数,每个随机数后跟随一个逗号进行分隔,屏幕输出这10个随机数. 涉及知识:random随机生成 import random ...

9. python刷题笔记怎么改_python面试题刷题笔记1 - 10

   函数参数传递:对象分为多变的对象和不变的对象.在python中,字符串.元组数字是不变的对象.列表,dict类型.设置等改变的对象.当引用传递给一个函数,函数的一个副本参考自动复制.这个函数的引用无关 ...

最新文章

1. 利用OpenSSH实现基于秘钥的认证
2. Java如何转换protobuf-net中的bcl.DateTime对象
3. 算法---------数组-----------两数相加
4. 数据结构（算法）-线性表2（单链表）
5. shell 输入输出重定向
6. maven版本高于idea
7. Kerberos认证代码分析Can't get Kerberos realm
8. view detail data in gateway error log
9. 关系式调用c语言脚本_认识LoadRunner脚本语言
10. 拓扑排序 详解 + 并查集 详解 + 最小生成树详解
11. 原型设计模式及深拷贝
12. js计算字典的个数_JS数据结构与算法_集合字典
13. 不想打造物联网的制造型企业不是一家合格的百年老店
14. tsv文件导oracle窜列,TSV(tsv文档怎么转换excel)
15. A MULTI-TASK FRAMEWORK WITH FEATURE PASSING MODULE FOR SKIN LESION CLASSIFICATION AND SEGMENTATION
16. SIFT算法应用：全景图像拼接
17. Excel操作：使用Excel制作甘特图
18. Mathematica基础
19. Mac字体路径，解决matplotlib中文显示问题，超级好用～
20. Petalinux和SDK安装

热门文章

1. OC和Clover黑苹果USB定制和注入
2. 星起航跨境—亚马逊发展现状及未来趋势分析
3. Redis核心技术与实战-学习笔记（二十九）：Redis并发控制
4. 老司机的奇怪noip模拟T1-guanyu
5. 【读文献笔记】图神经网络加速结构综述
6. Maven项目在new module后，pom文件显示为Ignored pom.xml
7. Harray Potter and the Sorcerer's Stone
8. 信奥中的数学：排列组合
9. 【数据结构与算法】摔鸡蛋
10. 数据传输完整性_基于IBIS模型的FPGA信号完整性仿真验证方法