子串

560.和为K的子数组【没理解】

什么是前缀和：前缀和指一个数组的某下标之前的所有数组元素的和（包含其自身）
通常，会在前缀和首位放一个0。比如数组[1,2,3。其前缀和是[0,1,3,6]
前缀和通常可以帮助我们快速计算某个区间内的和。比如我们要算i,ji,ji,j之间的和，那么就是nums[i]+nums[i+1]+⋯+nums[j]nums[i]

• nums[i+1] + \cdots +nums[j]nums[i]+nums[i+1]+⋯+nums[j]。他可以看作是nums[0]+nums[1]+⋯+nums[i]+nums[i+1]+⋯+nums[j]nums[0]
• nums[1] + \cdots + nums[i] + nums[i+1] + \cdots +nums[j]nums[0]+nums[1]+⋯+nums[i]+nums[i+1]+⋯+nums[j]减去nums[0]+nums[1]+⋯+nums[i−1]nums[0]
• nums[1] + \cdots + nums[i-1]nums[0]+nums[1]+⋯+nums[i−1]。这个式子也是preSum[j]−preSum[i−1]preSum[j]

• preSum[i-1]preSum[j]−preSum[i−1]。

class Solution:def subarraySum(self, nums: List[int], k: int) -> int:# 要求的连续子数组count = 0n = len(nums)preSum = [0]# 求前缀和数组，第i位置代表nums前面i个相加，共有len(nums)+1长tmp = 0for i in range(n):tmp += nums[i]preSum.append(tmp)# 求和为k的连续子数组，求i到j之间的和for i in range(1, n+1):for j in range(i, n+1):if preSum[j] - preSum[i-1] == k:  # preSum[j] - preSum[i-1]代表着在nums数组中，前j个数之和减去前i-1个数之和count += 1return count

class Solution:def subarraySum(self, nums: List[int], k: int) -> int:# 要求的连续子数组count = 0n = len(nums)preSums = collections.defaultdict(int)   #其键是前缀和，值是该前缀和出现的次数。preSums[0] = 1presum = 0for i in range(n):presum += nums[i]    # if preSums[presum - k] != 0:count += preSums[presum - k]   # 利用defaultdict的特性，当presum-k不存在时，返回的是0。这样避免了判断preSums[presum] += 1  # 给前缀和为presum的个数加1return count

【暴力解法】
class Solution:def subarraySum(self, nums: List[int], k: int) -> int:# 要求的连续子数组count = 0n = len(nums)for i in range(n):sum = 0for j in range(i, n):sum += nums[j]if sum == k:count += 1 return count

239.滑动窗口最大值【大顶堆】

代码随机录写过这道题：使用大顶堆

from collections import dequeclass MyQueue: #单调队列（从大到小def __init__(self):self.queue = deque() #这里需要使用deque实现单调队列，直接使用list会超时#每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。#同时pop之前判断队列当前是否为空。def pop(self, value):if self.queue and value == self.queue[0]:self.queue.popleft()#list.pop()时间复杂度为O(n),这里需要使用collections.deque()#如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。#这样就保持了队列里的数值是单调从大到小的了。def push(self, value):while self.queue and value > self.queue[-1]:self.queue.pop()self.queue.append(value)#查询当前队列里的最大值 直接返回队列前端也就是front就可以了。def front(self):return self.queue[0]class Solution:def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:que = MyQueue()result = []for i in range(k): #先将前k的元素放进队列que.push(nums[i])result.append(que.front()) #result 记录前k的元素的最大值for i in range(k, len(nums)):que.pop(nums[i - k]) #滑动窗口移除最前面元素que.push(nums[i]) #滑动窗口前加入最后面的元素result.append(que.front()) #记录对应的最大值return result

76.最小覆盖子串【双指针|滑动窗口】

1. 用need字典维护，当前还需要的字符以及个数，need[i]为负数，代表无需求，need[i]代表需要
2. 滑动串口，先让right动起来，左指针指向队首，如果能cover字符T；就开始收缩窗口，让left滑动，直至不能coverT
3. 在窗口滑动过程中，维护的need也要变，加入字符，就–，减去字符就+
   如果尝试访问一个在 defaultdict 中不存在的键，它会自动创建一个新键，并将其值设置为默认值（在这个例子中是 0）。但是{}不支持自动创建键

    def minWindow(self, s: str, t: str) -> str:need=collections.defaultdict(int)for c in t:need[c]+=1needCnt=len(t)left=0res=(0,float('inf'))for index,c in enumerate(s):if need[c]>0:  #如果需要字母cneedCnt-=1need[c]-=1if needCnt==0:       #步骤一：滑动窗口包含了所有T元素while True:      #步骤二：增加left，排除多余元素c=s[left] if need[c]==0:breakneed[c]+=1left+=1if index-left<res[1]-res[0]:   #记录结果，当前窗口左指针left，右指针indexres=(left,index)need[s[left]]+=1  #步骤三：left增加一个位置，寻找新的满足条件滑动窗口needCnt+=1left+=1return '' if res[1]>len(s) else s[res[0]:res[1]+1]    #如果res始终没被更新过，代表无满足条件的结果

普通数组

53.最大子数组和【动态规划】

因为dp[i]只与dp[i-1]和nums[i]有关，因此直接在nums原地修改，空间复杂度O(1)

class Solution:def maxSubArray(self, nums: List[int]) -> int:for i in range(1,len(nums)):nums[i] = max(nums[i-1]+nums[i],nums[i])return max(nums)

56.合并区间

1. 先对左节点排序
2. 判断当前合并区间和候选区间，是否重叠

class Solution:def merge(self, intervals: List[List[int]]) -> List[List[int]]:ans = []intervals.sort()  # 按照所有区间的左端点进行排序for interval in intervals:if not ans or ans[-1][1] < interval[0]:   #当ans为空，或者 当前区间的右节点 在 候选区间的左边【无重叠】ans.append(interval)else: #当前并区间和候选区间  有重叠ans[-1][1] = max(interval[1],ans[-1][1])   #取最大右区间return ans

189.轮转数组

直接用nums会报错？？
修改nums[:]不会影响到nums,nums[;]是一个新列表，是nums的副本，她两指向不同内存地址

class Solution:def rotate(self, nums: List[int], k: int) -> None:"""Do not return anything, modify nums in-place instead."""k = k % len(nums)nums[:] = nums[len(nums)-k:] + nums[:len(nums)-k]return nums

238.除自身以外数组的乘积

1. 先初始化ans，ans[0]=1；辅助变量temp=1
2. 计算下三角，计算上三角乘积temp，并乘以上三角
   索引容易搞错，可以看个图，根据图写索引

class Solution:def productExceptSelf(self, nums: List[int]) -> List[int]:ans = [1] * len(nums)temp = 1for i in range(1,len(nums)):ans[i] = ans[i-1] * nums[i-1]  #下三角for j in range(len(nums)-2,-1,-1):temp *= nums[j+1]   #上三角ans[j] *= temp   #下三角 * 上三角return ans

41.缺失的第一个正数【困难】

最后的结果一定是在 [1,n+1] 内
修改 nums，使对应的下标 [0,n] 里 nums[i] 第一个不是 i+1 的，i+1 就是答案
也就是，让 nums 里的数字，在 [1,n] 内的，都去他们对应的 [0,n-1] 位置上去的

class Solution:def firstMissingPositive(self, nums: List[int]) -> int:n = len(nums)for i in range(n):while 1 <= nums[i] <= n and nums[nums[i] - 1] != nums[i]:# 这是错误的# nums[i], nums[nums[i] - 1] = nums[nums[i] - 1], nums[i]#先计算右边的值，也就是nums[i]和nums[nums[i] - 1]的值，然后将他们赋值给一个临时元祖；
#然后按顺序赋值给左边，也就是说会先修改nums[i]的值，这样一来，nums[i] - 1就不是原来想要修改的下标了。nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]for i in range(n):if nums[i] != i + 1:return i + 1return n + 1

矩阵

73.矩阵置0

两遍扫matrix,第一遍用集合记录哪些行,哪些列有0;第二遍置0

class Solution:def setZeroes(self, matrix: List[List[int]]) -> None:"""Do not return anything, modify matrix in-place instead."""row = len(matrix)col = len(matrix[0])row_zero = set()col_zero = set()for i in range(row):for j in range(col):if matrix[i][j] == 0:row_zero.add(i)col_zero.add(j)for i in range(row):for j in range(col):if i in row_zero or j in col_zero:matrix[i][j] = 0

54.螺旋矩阵

48.旋转图像

240.搜索二维矩阵||