int max

int_min = 2**31-1
int_max = -2**31
print(-inf)

初始化数组

#初始化二维数组
[[0] * n for _ in range(n)]

#使用数组模拟栈
stack.append(1)

遍历二维数组的骚操作

#数组旋转k次
for i, j in enumerate(nums):
    path[(i + k) % n] = nums[i]


#分别遍历二维数组的行和列
for row in grid
for col in zip(*grid)

sum1 = sum(iter(x) for row in grid)

#遍历三角形的数组
for i in range(1, n):
    for j in range(0, i+1):

#遍历二维数组时候通常需要检查边界条件
for i in range(1, n):
    for j in range(1, m):
        if i > 0:
        if j > 0;

字符串相关

l = s.split(" ")
st = [word.swapcase() for word in l]

#在python中ord函数用来获取一个字符表示的整数
n = ord('c') - ord('a') 

#表示会以ascii码的形式输出
for a in map(ord, str):

#字符串反转:
a = [::-1]
b = "".join(reversed(a))

#判断字符串是小写还是大写
str.islower()
str.isupper()

#zip, 同时遍历两个字符串
for i, j in zip(str1, str2)

#统计每一个字符出现的次数
counter(str1)

hash表

hash = {}
#判断是否位于hash表中
1 in hash

#不同于C++中的写法
if value in hash:
    hash[value] += 1

set集合相关操作

#set:
a = set()
b = set()

#集合求交集
l = len(set1 & set2)

单调栈

#通常在一个区间中反转一下
for i in range(1, n):
    while stk and check(stk[-1], value):
        stk.pop()

双指针算法题目

for i in range(0, n):
    j = 0
    while j < i and check(i, j):
        j += 1

## 判断一个字符串是不是回文串
res = ""
for i, j enumerate(str):
    #这种情况是判断当前的字符串是不是奇数
    left, right = i-1, i+1
    while left >= 0 and right <= len(s) and s[left] == s[right]:
        left += 1
        right -= 1

    if len(res) < (right-left-1):
        res = s[left+1:right]

    left, right = i, i+1
    #判断是不是偶数
    while left >= 0 and right <= len(s) and s[left] == s[right]:
        left += 1
        right -= 1

    if len(res) < (right-left-1):
        res = s[left+1:right]

dfs题目

def dfs(i):
    if i == n:
        ans.append(path)
        return
    for i in range(start, end):
        path.append(i)

实现tire树

son = [None] * 26
is_end = False

#查找
p = root
for i in word:
    u = ord(i) - ord('a')
    if not son[u]:
        #创建一个node
        p.son[u] = Node()
    p = p.son[u]
p.is_end = True

并查集

#初始化并查集
p = [i for i in range(1, n + 1)]

def find(x):
    if p[x] != x:
        p[x] = find(p[x])
    return p[x]

#合并并查集
p[find(a)] = find(b)

数学

#位运算计算当前的二进制值中的1
res = 0
while x:
    x -= (x & -x)
    res += 1

#不断的遍历一个数
while x != 0:
    #不断的取出个位
   print(x % 10)
    x //= 10

#遍历二进制数
while x != 0:
    print(x % 2)
    x //= 2

#调换数字的位置
while x != 0:
    sum += sum * 10 + x % 10
    x //= 10

动态规划问题

#常见dp的公式
#01背包问题, 但是需要从结尾开始遍历
#dp的核心就是状态的转移, 我们需要保证每一步的状态转移都是正确的
dp[i] = max(dp[j], dp[j-v[i]]+w[i])

#完全背包
dp[i] = max(dp[j], dp[j-v[i]] + w[i])


#最长上升子序列问题
#我们遍历一个集合使用两种循环
#第一重循环主要是遍历这个集合
#第二重循环主要是用来遍历从(0, i)这个区间的集合
for i in range(0, n):
    f[i] = 1
    for j in range(0, i):
        if nums[i] > nums[j]:
            f[i] = max(f[i], f[j] + 1)

#交错字符串的问题:
#贪心+动态规划问题
#代表问题是跳跃游戏
for i in range(0, n):
    if last + nums[last] < i:
        last += 1
    f[i] = f[last + 1]