leecode 动态规划

动态规划的目的主要是为了降低时间复杂度，降低重复计算的部分。

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用法，假如没有，就返回默认值，这里设置为０
        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   #左侧加１，右侧减１，会得到一个小的变化量，比单纯的left+=1好
                    if temp>target:right-=1#太大了，右指针左移
                    if temp<target:left+=1#反之
        #去重
        rec=[]
        for i in ans:
            rec.append(list(i))
        return rec

总结：
这类动态规划题，如果用暴力解法，那么复杂度很高。

比如第二题，如果以是否加入该元素来看，其结果是２的ｎ方。所以可以考虑哈希查找，哈希查找是Ｏ(1)复杂度，利用哈希查找的条件应当是元素不会重复出现的情况。值得注意的是，python的字典和集合用了hash的方法，所以其查找是O(1)的

哈希查找简单来说就是一种映射关系，地址一般是连续的。简单的理解６对应基地址0x00+6*1 ，７对应基地址０x00+7*1，那么你要查找７的时候，就直接得到其地址了。就是说值的value与地址有种映射关系，即是散列函数。

 

而假如存储时先使用哈希函数进行计算，这里我随便用个函数：
 H[key] = key % 3;
四个数 {2,9,13} 对应的哈希值为：

 H[2] = 2 % 3 = 2;
 H[9] = 9 % 3 = 0;
 H[13] = 13 % 3 = 1;

然后把它们存储到对应的位置.。比如２存储在０x2，9存储在０x0, 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)