代码随想录 day6:第三章 哈希表part02

454.四数相加II

• 使用map
  思路：
• 首先定义一个unordered_map，key放a和b两数之和，value放a和b两数之和出现的次数。
• 遍历大A和大B数组，两个数组元素和，以及显示的，在地图中。
• 定义int变量count，用来统计a+b+c+d = 0的出现的次数。
• 再遍历大C和大D数组，找到如果0-(c+d)在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
• 最后返回统计值count就可以了

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        from collections import defaultdict
        table=defaultdict(int)
        count=0
        for num1 in nums1:
            for num2 in nums2:
                table[num1+num2]+=1
        for num3 in nums3:
            for num4 in nums4:
                count+=table[-num3-num4]
        return count

383. 赎金信

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        from collections import defaultdict
        table=defaultdict(int)
        for i in magazine:
            table[i]+=1
        for i in ransomNote:
            table[i]-=1
        for i in table:
            if table[i]<0:
                return False
        else:
            return True

15. 三数之和

思路：

• 不可以包含重复的三元组，应该如何进行去重。
• 这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意，而且使用哈希法在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)，也是可以在leetcode上通过，但是程序的执行时间依然比较长 。
• 本题使用双指针法，这道题目使用双指针法要比哈希法高效一些。
• 首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
• 在数组中找到 abc 使得a + b +c =0，这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。
• 如何移动left 和right：
  • nums[i] + nums[left] + nums[right] > 0 ，right下标就应该向左移动。
  • nums[i] + nums[left] + nums[right] < 0，left 就向右移动。
• 去重操作：
  • a的去重：a 如果重复，应该直接跳过去。应当判断nums[i] 与 nums[i-1] 是否相同。
  • b和c的去重：去重没有意义，可以不用写。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        result=[]
        nums.sort()# 从小到大进行排序

        for i in range(len(nums)):
            if nums[i]>0:
                return result
        
            #对于a的去重
            if i >0 and nums[i]==nums[i-1]:
                continue
            
            left=i+1
            right=len(nums)-1

            while left<right:
                sum_=nums[i]+nums[left]+nums[right]
                if sum_<0:
                    left+=1
                elif sum_>0:
                    right-=1
                else:
                    result.append([nums[i], nums[left], nums[right]])

                    #可能有多种情况，b和c继续往后遍历
                    # c的去重
                    while right>left and nums[right]==nums[right-1]:
                        #因为right是从左往右遍历，避免左边的元素和右边的元素一致，应该是判断nums[right]==nums[right+1]
                        right-=1
                    # b的去重
                    while right>left and nums[left]==nums[left+1]:
                        left+=1
                    right-=1
                    left+=1
        return result       

18. 四数之和

• 使用双指针法。
• 三数之和的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。
• 四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n2，四数之和的时间复杂度是O(n3).
• 一样的道理，五数之和、六数之和等等都采用这种解法。
• 对于15.三数之和双指针法就是将原本暴力O(n3)的解法，降为O(n2)的解法，四数之和的双指针解法就是将原本暴力O(n4)的解法，降为O(n^3)的解法。

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        n = len(nums)
        result = []
        for i in range(n):
            if nums[i] > target and nums[i] > 0 and target > 0:# 剪枝（可省）
                break
            if i > 0 and nums[i] == nums[i-1]:# 去重
                continue
            for j in range(i+1, n):
                if nums[i] + nums[j] > target and target > 0: #剪枝（可省）
                    break
                if j > i+1 and nums[j] == nums[j-1]: # 去重
                    continue
                left, right = j+1, n-1
                while left < right:
                    s = nums[i] + nums[j] + nums[left] + nums[right]
                    if s == target:
                        result.append([nums[i], nums[j], nums[left], nums[right]])
                        while left < right and nums[left] == nums[left+1]:
                            left += 1
                        while left < right and nums[right] == nums[right-1]:
                            right -= 1
                        left += 1
                        right -= 1
                    elif s < target:
                        left += 1
                    else:
                        right -= 1
        return result

总结

• 哈希表都是用来快速判断一个元素是否出现集合里。
• 对于哈希表，要知道哈希函数和哈希碰撞在哈希表中的作用。
• 哈希函数是把传入的key映射到符号表的索引上。
• 哈希碰撞处理有多个key映射到相同索引上时的情景，处理碰撞的普遍方式是拉链法和线性探测法。
• 接下来是常见的三种哈希结构：
  • 数组
  • set（集合）
  • map（映射）
• 使用数组和set来做哈希法的局限。数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
  
• map的空间消耗要比数组大一些，因为map要维护红黑树或者符号表，而且还要做哈希函数的运算。所以数组更加简单直接有效。