2023-12-05 哈希表二

哈希表二

454. 四数相加 II

思路：四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不需要考虑有重复四个元素相加为0的情况！

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        # 使用哈希表来做 ！不要考虑去重
        # 第一步统计前两个组的
        dict_nums = {}
        # 有几种可能满足为0的
        count = 0
        for nums_1 in nums1:
            for nums_2 in nums2:
                if nums_1 + nums_2 in dict_nums:
                    dict_nums[nums_1 + nums_2] += 1
                else:
                    dict_nums[nums_1 + nums_2] = 1
        for nums_3 in nums3:
            for nums_4 in nums4:
                if 0 - (nums_3 + nums_4) in dict_nums:
                    sum1 = dict_nums[0 - (nums_3 + nums_4)]
                    # 这里为什么要剩余sum捏？因为前面出现了n个a+b 为sum结果，后面就可能sum+x =0 就会有n中结果
                    count += sum1 * 1
                    # dict_nums(0 - (nums_3 + nums_4)) = 0
                else:
                    continue
        return count

383. 赎金信

思路：使用哈希表来做，先把manazine的字母添加map中并记录出现的次数，然后把ransomNote的字母是否存在map中，存在value – 不存在直接会返回，最后遍历map 全部为0 代表为True，否则为False

或者还有一种方式：使用列表来维护list = [0] * 26!思路以上，不过是改为数组存储而已！

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        dict_m = {}
        for str_m in magazine:
            if str_m in dict_m:
                dict_m[str_m] += 1
            else:
                dict_m[str_m] = 1
        for str_r in ransomNote:
            if str_r in dict_m:
                dict_m[str_r] -= 1
            else:
                return False
        for key in dict_m:
            if dict_m[key] < 0:
                return False
        return True

15. 三数之和

思路：结合双指针来做解题会更快！必须确保列表是有序的，对于指针的移动还可以优化一下！

class Solution:
    def threeSum1(self, nums: List[int]) -> List[List[int]]:
        # 使用结合来做双指针!去重一个有很意思 以及判断一下前面的num大于0 就不必往下走了
        nums.sort()
        # 是为了去重相同的列表
        result = set()
        for i in range(len(nums)):  # 这里可以优化一下
        # 这里还可以加一些判断跳过一写数据
            left = i + 1
            right = len(nums) - 1 
            while left < right:
                temp = nums[i] + nums[left] + nums[right]
                if temp > 0:
                    right -= 1
                elif temp < 0:
                    left += 1
                else:
                    temp_res = (nums[i], nums[left], nums[right])
                    #  这里也还可以优化！当是相同的数组我们向前或先后++ 或 --
                    result.add(temp_res)
                    right -= 1
        res = []
        for value in result:
            res.append(list(value))
        return res
    # 这个方法不用考虑去重了
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        # 使用双指针一定是有序的 保证能正确移动指针嘛
        nums.sort()  
        result = []
        for i in range(len(nums)-2):
            if nums[i] > 0:
                return result
            # 这个条件很关键，保证每次的相加的开头的数不相等，去重条件
            if i >0 and nums[i] == nums[i - 1]:
                continue
            left, right = i + 1, len(nums)-1
            while left < right:
                temp = nums[i] + nums[left] + nums[right]
                if temp > 0:
                    right -= 1
                elif temp < 0:
                    left += 1
                else:
                    result.append([nums[i], 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
        return result

18. 四数之和

思路：和三数之和思想一下，多嵌套一个循坏就可以了！一些小的条件仔细考虑一下就可！

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        # 可以考虑使用使用双指针
        nums.sort()
        result = []
        for i in range(len(nums) - 3):
            # if nums[i] > target:
            #     return result
            # 上个条件不能加的原因是，如果target是负数，那么返回的结果就是错误了！
            # 不过可以改成这样 if nums[i] > target and nums[i] >= 0:  break            
            if i >0 and nums[i] == nums[i-1]:
                continue
            for j in range(i+1,len(nums)-2):
                if j > i + 1 and nums[j] == nums[j-1]:
                    continue
                left, right = j + 1, len(nums) - 1 
                while left < right:
                    temp = nums[i] + nums[j] + nums[left] + nums[right]
                    if temp > target:
                        right -= 1
                    elif temp < target:
                        left += 1
                    else:
                        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
        return result