代码随想录day7 哈希（2）

454. 四数相加 II - 力扣（LeetCode）

求多少个四元组满足和为0：用两次两层for循环 & 一个哈希表。先用两层for循环将n1和n2之和的频次记录在字典map12中，时间O(n^2)，空间O(n^2)；接着，两层for循环遍历n3和n4，每当com = -(n3+n4)在map12中时，就将对应的频次加到cnt上，时间O(n^2)，空间O(1)。

时间O(n^2)，空间O(n^2)。

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        cnt = 0
        map12 = {}
        n = len(nums1)
        for i in range(n):
            for j in range(n):
                cur_sum = nums1[i] + nums2[j]
                map12[cur_sum] = map12.get(cur_sum, 0) + 1
        
        for i in range(n):
            for j in range(n):
                com = - (nums3[i] + nums4[j])
                if com in map12:
                    cnt += map12[com]

        return cnt

383. 赎金信 - 力扣（LeetCode）

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        dic = {}
        for ch in magazine:
            dic[ch] = dic.get(ch, 0) + 1
        for ch in ransomNote:
            if ch not in dic:
                return False
            dic[ch] -= 1
        for val in list(dic.values()):
            if val < 0:
                return False
        
        return True

15. 三数之和 - 力扣（LeetCode）

要在一个数组nums中找到三个位置不同、和为0的元素，返回值的三元组[v1, v2, v3]。要求返回所有互不重复的三元组。

* 难点在于三元组之间不能重复。

暴力遍历，若不考虑去重，使用三层for循环，时间O(n^3)，空间O(1)。

解法一：哈希表（记录两数和）+ 集合（去重）【通过308/313测试样例，超出时间限制】

首先两层循环遍历nums，获得两数和(int)：两数下标的列表(list[list[int]])的哈希表(dict)。时间O(n^2)，空间O(n^2)。易错：list.append()方法返回None，如果这里写

hashmap[two_sum] = hashmap.get(two_sum, []).append([i, j])

就会出错，因为会将None赋给hashmap[two_sum]。所以需要使用try except KeyError，或者if two_sum in hashmap来处理初始情况。

接着遍历一次nums，当-n3在hashmap中，检查n3下标是否与n1、n2重复，若不重复，那么这三个值的三元组符合要求。接下来考虑对结果去重。对n1~3的列表排序，转为元组放入集合res。应注意，list.sort()对列表原地排序，返回None；sorted(list)则返回排序后的列表：

res_tuple = tuple(sorted([n1, n2, n3])) # right
res_tuple = tuple([n1, n2, n3].sort()) # wrong, tuple(None).

res_list = [n1, n2, n3]
res_list.sort()
res_tuple = tuple(res_list) #right


res.add(res_tuple)

之所以要转成tuple再加入set，是因为set不允许可变的类型作为它的元素。set的元素可以是int、float、string、tuple（tuple中的元素也需要是不可变的，不能是dict、list等），不可以是list、dict、set。返回时遍历set中的tuple，用list()方法将其转为list，再在外层套一个list。

class Solution:
    def threeSum(self, nums):
        n = len(nums)
        hashmap = dict()
        res = set()

        for i in range(0, n - 1):
            for j in range(i + 1, n):
                two_sum = nums[i] + nums[j]
                if two_sum in hashmap:
                    hashmap[two_sum].append([i, j])
                else:
                    hashmap[two_sum] = [[i, j]]
        
        for k in range(n):
            tar = -nums[k]
            if tar in hashmap:
                for l in hashmap[tar]:
                    if k not in l:
                        tri = tuple(sorted([nums[l[0]], nums[l[1]], nums[k]]))
                        res.add(tri)
        
        return list(list(l) for l in res)

除了将一条答案转为tuple，也可以转为string，如下（都需要先对列表排序 

#通过308/313，超出时间限制
class Solution:
    def threeSum(self, nums):
        n = len(nums)
        hashmap = dict()
        res = []
        visit = set()
        for i in range(0, n - 1):
            for j in range(i + 1, n):
                two_sum = nums[i] + nums[j]
                if two_sum in hashmap:
                    hashmap[two_sum].append([i, j])
                else:
                    hashmap[two_sum] = [[i, j]]
                
        
        for k in range(n):
            tar = -nums[k]
            if tar in hashmap:
                for l in hashmap[tar]:
                    if k not in l:
                        tri = sorted([nums[l[0]], nums[l[1]], nums[k]])
                        triString = "".join(str(v) for v in tri)
                        if triString not in visit:
                            visit.add(triString)
                            res.append(tri)
        
        return res

然而该方法不能跑完所有样例，可能是因为在遍历n3的for循环中存在对hashmap[tar]的遍历，极端情况下，比如nums所有元素相同，则两数和hashmap只有一个键值对，值是长度为n!/2的列表。

解法二：对数组排序 + 一层for循环套双指针遍历（寻找答案三元组），通过条件限制去重。时间：O(n^2)，空间：答案res的空间。

1）三元组的第一个数nums[i]：遍历排序后的数组，若当前数与前一个数重复，continue。

2）三元组的后两个数：将左右指针置于剩下的数组nums[i+1:]的两端，比较当前和与目标和，向中间移动左/右指针。一旦达到目标和，将答案添加到res列表，之后向中间移动两指针，扫过所有重复出现的数，然后再各自向中间移动一位，考虑下一个可能的组合。

#双指针法
class Solution:
    def threeSum(self, nums):
        nums.sort()
        n = len(nums)
        res = []

        for i in range(n - 2):
            if i > 0 and nums[i] == nums[i-1]:
                continue
            
            left = i + 1
            right = n - 1
            while left < right:
                cur_sum = nums[i] + nums[left] + nums[right]

                if cur_sum == 0:
                    res.append([nums[i], nums[left], nums[right]])
                    while left < right and nums[left+1] == nums[left]:
                        left += 1
                    while left < right and nums[right-1] == nums[right]:
                        right -= 1
                    left += 1
                    right -= 1

                elif cur_sum > 0:
                    right -= 1

                else:
                    left += 1

        return res

18. 四数之和 - 力扣（LeetCode）

三数和的拓展。解法一双指针：两层for循环（前两数）套双指针（后两数）。时间：暴力O(n^4) => 双指针O(n^3)。

易错：第二次for循环，j从i+1开始遍历。

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        n = len(nums)
        nums.sort()
        res = []

        for i in range(n-3):
            if i > 0 and nums[i-1] == nums[i]:
                continue

            for j in range(i+1, n-2):
                if j > i+1 and nums[j-1] == nums[j]:
                    continue
                
                tar = target - (nums[i] + nums[j])
                left = j + 1
                right = n - 1
                while left < right:
                    if tar == nums[left] + nums[right]:
                        res.append([nums[i], nums[j], nums[left], nums[right]])
                        while left < right and nums[left+1] == nums[left]:
                            left += 1
                        while left < right and nums[right-1] == nums[right]:
                            right -= 1

                        left += 1
                        right -= 1

                    elif tar > nums[left] + nums[right]:
                        left += 1

                    else:
                        right -= 1
            
        return res

此题没有极端测试用例，可以用字典+集合解：

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        n = len(nums)
        freq = {}
        res = set()

        for i in range(n):
            freq[nums[i]] = freq.get(nums[i], 0) + 1
        
        for i in range(0, n - 3):
            for j in range(i + 1, n - 2):
                for k in range(j + 1, n - 1):
                    tar = target - nums[i] - nums[j] - nums[k]
                    cnt = (nums[i] == tar) + (nums[j] == tar) + (nums[k] == tar)
                    if tar in freq and cnt < freq[tar]:
                        res.add(tuple(sorted([nums[i], nums[j], nums[k], tar])))
        
        return list(list(item) for item in res)