动态规划的目的主要是为了降低时间复杂度,降低重复计算的部分。
leecode 454
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ,使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化,所有的 A, B, C, D 具有相同的长度 N,且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间,最终结果不会超过 231 - 1 。
例如:
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:
2
解释:
两个元组如下:
1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/4sum-ii
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
class Solution:
def fourSumCount(self, A: List[int], B: List[int], C: List[int], D: List[int]) -> int:
hashmap= {}
for i in range(len(C)):
for j in range(len(D)):
hashmap[C[i]+D[j]]= hashmap.get(C[i]+D[j], 0) +1 #把出现的次数作为字典的值,字典的get用法,假如没有,就返回默认值,这里设置为0
print(hashmap)
res=0
for l in range(len(A)):
for m in range(len(B)):
res+= hashmap.get(-A[l]-B[m], 0)
return res
leecode 18
给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c 和 d ,使得 a + b + c + d 的值与 target 相等?找出所有满足条件且不重复的四元组。
注意:
答案中不可以包含重复的四元组。
示例:
给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0。
满足要求的四元组集合为:
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]
#参考的题解,加以注释
class Solution(object):
def fourSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[List[int]]
"""
nums.sort()
ans=set()
for i in range(len(nums)-3):
for j in range(i+1,len(nums)-2):#固定两个数(固定最左侧的两个数,留出两个位置给右侧)
left=j+1#左指针
right=len(nums)-1#右指针
while(right>left):
temp=nums[i]+nums[j]+nums[left]+nums[right]
if temp==target:
ans.add((nums[i],nums[j],nums[left],nums[right]))
left+=1
right-=1 #左侧加1,右侧减1,会得到一个小的变化量,比单纯的left+=1好
if temp>target:right-=1#太大了,右指针左移
if temp<target:left+=1#反之
#去重
rec=[]
for i in ans:
rec.append(list(i))
return rec
总结:
这类动态规划题,如果用暴力解法,那么复杂度很高。
比如第二题,如果以是否加入该元素来看,其结果是2的n方。所以可以考虑哈希查找,哈希查找是O(1)复杂度,利用哈希查找的条件应当是元素不会重复出现的情况。值得注意的是,python的字典和集合用了hash的方法,所以其查找是O(1)的
哈希查找简单来说就是一种映射关系,地址一般是连续的。简单的理解6对应基地址0x00+6*1 ,7对应基地址0x00+7*1,那么你要查找7的时候,就直接得到其地址了。就是说值的value与地址有种映射关系,即是散列函数。
而假如存储时先使用哈希函数进行计算,这里我随便用个函数:
H[key] = key % 3;
四个数 {2,9,13} 对应的哈希值为:
H[2] = 2 % 3 = 2;
H[9] = 9 % 3 = 0;
H[13] = 13 % 3 = 1;
然后把它们存储到对应的位置.。比如2存储在0x2,9存储在0x0, 13存储在0x1。当要查找 13 时,只要先使用哈希函数计算它的位置0x1,然后去那个位置查看是否存在就好了,本例中只需查找一次,时间复杂度为 O(1)。
附录如下
:
列表(list)
以完全随机的列表考虑平均情况。
列表是以数组(Array)实现的。最大的开销发生在超过当前分配大小的增长,这种情况下所有元素都需要移动;或者是在起始位置附近插入或者删除元素,这种情况下所有在该位置后面的元素都需要移动。如果你需要在一个队列的两端进行增删的操作,应当使用collections.deque(双向队列)
操作 | 平均情况 | 最坏情况 |
---|---|---|
复制 | O(n) | O(n) |
append[注1] | O(1) | O(1) |
插入 | O(n) | O(n) |
取元素 | O(1) | O(1) |
更改元素 | O(1) | O(1) |
删除元素 | O(n) | O(n) |
遍历 | O(n) | O(n) |
取切片 | O(k) | O(k) |
删除切片 | O(n) | O(n) |
更改切片 | O(k+n) | O(k+n) |
extend[注1] | O(k) | O(k) |
排序 | O(n log n) | O(n log n) |
列表乘法 | O(nk) | O(nk) |
x in s | O(n) | |
min(s), max(s) | O(n) | |
计算长度 | O(1) | O(1) |
双向队列(collections.deque)
deque (double-ended queue,双向队列)是以双向链表的形式实现的 (Well, a list of arrays rather than objects, for greater efficiency)。双向队列的两端都是可达的,但从查找队列中间的元素较为缓慢,增删元素就更慢了。
操作 | 平均情况 | 最坏情况 |
---|---|---|
复制 | O(n) | O(n) |
append | O(1) | O(1) |
appendleft | O(1) | O(1) |
pop | O(1) | O(1) |
popleft | O(1) | O(1) |
extend | O(k) | O(k) |
extendleft | O(k) | O(k) |
rotate | O(k) | O(k) |
remove | O(n) | O(n) |
集合(set)
未列出的操作可参考 dict —— 二者的实现非常相似。
操作 | 平均情况 | 最坏情况 |
---|---|---|
x in s | O(1) | O(n) |
并集 s|t | O(len(s)+len(t)) | |
交集 s&t | O(min(len(s), len(t)) | O(len(s) * len(t)) |
差集 s-t | O(len(s)) | |
多交集 s1&s2&..&sn | (n-1)*O(l) where l is max(len(s1),..,len(sn)) | |
s.difference_update(t) | O(len(t)) | |
对称差集 s^t | O(len(s)) | O(len(s) * len(t)) |
s.symmetric_difference_update(t) | O(len(t)) | O(len(t) * len(s)) |
由源码得知,求差集(s-t,或s.difference(t))运算与更新为差集(s.difference_uptate(t))运算的时间复杂度并不相同!前者是将在s中,但不在t中的元素添加到新的集合中,因此时间复杂度为O(len(s));后者是将在t中的元素从s中移除,因此时间复杂度为O(len(t))。因此,使用时请留心,根据两个集合的大小以及是否需要新集合来选择合适的方法。
集合的s-t运算中,并不要求t也一定是集合。只要t是可遍历的对象即可。
字典(dict)
下列字典的平均情况基于以下假设:
1. 对象的散列函数足够撸棒(robust),不会发生冲突。
2. 字典的键是从所有可能的键的集合中随机选择的。
小窍门:只使用字符串作为字典的键。这么做虽然不会影响算法的时间复杂度,但会对常数项产生显著的影响,这决定了你的一段程序能多快跑完。
操作 | 平均情况 | 最坏情况 |
---|---|---|
复制[注2] | O(n) | O(n) |
取元素 | O(1) | O(n) |
更改元素注1 | O(1) | O(n) |
删除元素 | O(1) | O(n) |
遍历[注2] | O(n) | O(n) |